1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2017 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
31 #include "coretypes.h"
33 #include "c-family/c-target.h"
36 #include "stringpool.h"
38 #include "stor-layout.h"
42 #include "tree-iterator.h"
46 #include "c-family/c-objc.h"
47 #include "c-family/c-pragma.h"
48 #include "c-family/c-ubsan.h"
56 /* Possible cases of bad specifiers type used by bad_specifiers. */
58 BSP_VAR
, /* variable */
59 BSP_PARM
, /* parameter */
64 static const char *redeclaration_error_message (tree
, tree
);
66 static int decl_jump_unsafe (tree
);
67 static void require_complete_types_for_parms (tree
);
68 static void push_local_name (tree
);
69 static tree
grok_reference_init (tree
, tree
, tree
, int);
70 static tree
grokvardecl (tree
, tree
, tree
, const cp_decl_specifier_seq
*,
71 int, int, int, bool, int, tree
);
72 static int check_static_variable_definition (tree
, tree
);
73 static void record_unknown_type (tree
, const char *);
74 static tree
builtin_function_1 (tree
, tree
, bool);
75 static int member_function_or_else (tree
, tree
, enum overload_flags
);
76 static void check_for_uninitialized_const_var (tree
);
77 static tree
local_variable_p_walkfn (tree
*, int *, void *);
78 static const char *tag_name (enum tag_types
);
79 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
80 static void maybe_deduce_size_from_array_init (tree
, tree
);
81 static void layout_var_decl (tree
);
82 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
83 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
84 static void save_function_data (tree
);
85 static void copy_type_enum (tree
, tree
);
86 static void check_function_type (tree
, tree
);
87 static void finish_constructor_body (void);
88 static void begin_destructor_body (void);
89 static void finish_destructor_body (void);
90 static void record_key_method_defined (tree
);
91 static tree
create_array_type_for_decl (tree
, tree
, tree
);
92 static tree
get_atexit_node (void);
93 static tree
get_dso_handle_node (void);
94 static tree
start_cleanup_fn (void);
95 static void end_cleanup_fn (void);
96 static tree
cp_make_fname_decl (location_t
, tree
, int);
97 static void initialize_predefined_identifiers (void);
98 static tree check_special_function_return_type
99 (special_function_kind
, tree
, tree
, int, const location_t
*);
100 static tree
push_cp_library_fn (enum tree_code
, tree
, int);
101 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
102 static void store_parm_decls (tree
);
103 static void initialize_local_var (tree
, tree
);
104 static void expand_static_init (tree
, tree
);
106 /* The following symbols are subsumed in the cp_global_trees array, and
107 listed here individually for documentation purposes.
110 tree wchar_decl_node;
112 tree vtable_entry_type;
113 tree delta_type_node;
114 tree __t_desc_type_node;
116 tree class_type_node;
117 tree unknown_type_node;
119 Array type `vtable_entry_type[]'
122 tree vtbl_ptr_type_node;
129 A FUNCTION_DECL which can call `abort'. Not necessarily the
130 one that the user will declare, but sufficient to be called
131 by routines that want to abort the program.
136 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
137 tree tinfo_var_id; */
139 tree cp_global_trees
[CPTI_MAX
];
141 #define local_names cp_function_chain->x_local_names
143 /* A list of objects which have constructors or destructors
144 which reside in the global scope. The decl is stored in
145 the TREE_VALUE slot and the initializer is stored
146 in the TREE_PURPOSE slot. */
147 tree static_aggregates
;
149 /* Like static_aggregates, but for thread_local variables. */
154 /* A node for the integer constant 2. */
156 tree integer_two_node
;
158 /* vector of static decls. */
159 vec
<tree
, va_gc
> *static_decls
;
161 /* vector of keyed classes. */
162 vec
<tree
, va_gc
> *keyed_classes
;
164 /* Used only for jumps to as-yet undefined labels, since jumps to
165 defined labels can have their validity checked immediately. */
167 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
168 struct named_label_use_entry
*next
;
169 /* The binding level to which this entry is *currently* attached.
170 This is initially the binding level in which the goto appeared,
171 but is modified as scopes are closed. */
172 cp_binding_level
*binding_level
;
173 /* The head of the names list that was current when the goto appeared,
174 or the inner scope popped. These are the decls that will *not* be
175 skipped when jumping to the label. */
177 /* The location of the goto, for error reporting. */
178 location_t o_goto_locus
;
179 /* True if an OpenMP structured block scope has been closed since
180 the goto appeared. This means that the branch from the label will
181 illegally exit an OpenMP scope. */
185 /* A list of all LABEL_DECLs in the function that have names. Here so
186 we can clear out their names' definitions at the end of the
187 function, and so we can check the validity of jumps to these labels. */
189 struct GTY((for_user
)) named_label_entry
{
191 tree name
; /* Name of decl. */
193 tree label_decl
; /* LABEL_DECL, unless deleted local label. */
195 named_label_entry
*outer
; /* Outer shadowed chain. */
197 /* The binding level to which the label is *currently* attached.
198 This is initially set to the binding level in which the label
199 is defined, but is modified as scopes are closed. */
200 cp_binding_level
*binding_level
;
202 /* The head of the names list that was current when the label was
203 defined, or the inner scope popped. These are the decls that will
204 be skipped when jumping to the label. */
207 /* A vector of all decls from all binding levels that would be
208 crossed by a backward branch to the label. */
209 vec
<tree
, va_gc
> *bad_decls
;
211 /* A list of uses of the label, before the label is defined. */
212 named_label_use_entry
*uses
;
214 /* The following bits are set after the label is defined, and are
215 updated as scopes are popped. They indicate that a jump to the
216 label will illegally enter a scope of the given flavor. */
220 bool in_transaction_scope
;
221 bool in_constexpr_if
;
224 #define named_labels cp_function_chain->x_named_labels
226 /* The number of function bodies which we are currently processing.
227 (Zero if we are at namespace scope, one inside the body of a
228 function, two inside the body of a function in a local class, etc.) */
231 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
232 bool flag_noexcept_type
;
234 /* States indicating how grokdeclarator() should handle declspecs marked
235 with __attribute__((deprecated)). An object declared as
236 __attribute__((deprecated)) suppresses warnings of uses of other
238 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
241 /* A list of VAR_DECLs whose type was incomplete at the time the
242 variable was declared. */
244 struct GTY(()) incomplete_var
{
246 tree incomplete_type
;
250 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
252 /* Returns the kind of template specialization we are currently
253 processing, given that it's declaration contained N_CLASS_SCOPES
254 explicit scope qualifications. */
257 current_tmpl_spec_kind (int n_class_scopes
)
259 int n_template_parm_scopes
= 0;
260 int seen_specialization_p
= 0;
261 int innermost_specialization_p
= 0;
264 /* Scan through the template parameter scopes. */
265 for (b
= current_binding_level
;
266 b
->kind
== sk_template_parms
;
269 /* If we see a specialization scope inside a parameter scope,
270 then something is wrong. That corresponds to a declaration
273 template <class T> template <> ...
275 which is always invalid since [temp.expl.spec] forbids the
276 specialization of a class member template if the enclosing
277 class templates are not explicitly specialized as well. */
278 if (b
->explicit_spec_p
)
280 if (n_template_parm_scopes
== 0)
281 innermost_specialization_p
= 1;
283 seen_specialization_p
= 1;
285 else if (seen_specialization_p
== 1)
286 return tsk_invalid_member_spec
;
288 ++n_template_parm_scopes
;
291 /* Handle explicit instantiations. */
292 if (processing_explicit_instantiation
)
294 if (n_template_parm_scopes
!= 0)
295 /* We've seen a template parameter list during an explicit
296 instantiation. For example:
298 template <class T> template void f(int);
300 This is erroneous. */
301 return tsk_invalid_expl_inst
;
303 return tsk_expl_inst
;
306 if (n_template_parm_scopes
< n_class_scopes
)
307 /* We've not seen enough template headers to match all the
308 specialized classes present. For example:
310 template <class T> void R<T>::S<T>::f(int);
312 This is invalid; there needs to be one set of template
313 parameters for each class. */
314 return tsk_insufficient_parms
;
315 else if (n_template_parm_scopes
== n_class_scopes
)
316 /* We're processing a non-template declaration (even though it may
317 be a member of a template class.) For example:
319 template <class T> void S<T>::f(int);
321 The `class T' matches the `S<T>', leaving no template headers
322 corresponding to the `f'. */
324 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
325 /* We've got too many template headers. For example:
327 template <> template <class T> void f (T);
329 There need to be more enclosing classes. */
330 return tsk_excessive_parms
;
332 /* This must be a template. It's of the form:
334 template <class T> template <class U> void S<T>::f(U);
336 This is a specialization if the innermost level was a
337 specialization; otherwise it's just a definition of the
339 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
342 /* Exit the current scope. */
350 /* When a label goes out of scope, check to see if that label was used
351 in a valid manner, and issue any appropriate warnings or errors. */
354 check_label_used (tree label
)
356 if (!processing_template_decl
)
358 if (DECL_INITIAL (label
) == NULL_TREE
)
362 error ("label %q+D used but not defined", label
);
363 location
= input_location
;
364 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
365 /* Avoid crashing later. */
366 define_label (location
, DECL_NAME (label
));
369 warn_for_unused_label (label
);
373 /* Helper function to sort named label entries in a vector by DECL_UID. */
376 sort_labels (const void *a
, const void *b
)
378 tree label1
= *(tree
const *) a
;
379 tree label2
= *(tree
const *) b
;
381 /* DECL_UIDs can never be equal. */
382 return DECL_UID (label1
) > DECL_UID (label2
) ? -1 : +1;
385 /* At the end of a function, all labels declared within the function
386 go out of scope. BLOCK is the top-level block for the
390 pop_labels (tree block
)
395 /* We need to add the labels to the block chain, so debug
396 information is emitted. But, we want the order to be stable so
397 need to sort them first. Otherwise the debug output could be
398 randomly ordered. I guess it's mostly stable, unless the hash
399 table implementation changes. */
400 auto_vec
<tree
, 32> labels (named_labels
->elements ());
401 hash_table
<named_label_hash
>::iterator
end (named_labels
->end ());
402 for (hash_table
<named_label_hash
>::iterator iter
403 (named_labels
->begin ()); iter
!= end
; ++iter
)
405 named_label_entry
*ent
= *iter
;
407 gcc_checking_assert (!ent
->outer
);
409 labels
.quick_push (ent
->label_decl
);
413 labels
.qsort (sort_labels
);
415 while (labels
.length ())
417 tree label
= labels
.pop ();
419 DECL_CHAIN (label
) = BLOCK_VARS (block
);
420 BLOCK_VARS (block
) = label
;
422 check_label_used (label
);
426 /* At the end of a block with local labels, restore the outer definition. */
429 pop_local_label (tree id
, tree label
)
431 check_label_used (label
);
432 named_label_entry
**slot
= named_labels
->find_slot_with_hash
433 (id
, IDENTIFIER_HASH_VALUE (id
), NO_INSERT
);
434 named_label_entry
*ent
= *slot
;
440 ent
= ggc_cleared_alloc
<named_label_entry
> ();
446 /* The following two routines are used to interface to Objective-C++.
447 The binding level is purposely treated as an opaque type. */
450 objc_get_current_scope (void)
452 return current_binding_level
;
455 /* The following routine is used by the NeXT-style SJLJ exceptions;
456 variables get marked 'volatile' so as to not be clobbered by
457 _setjmp()/_longjmp() calls. All variables in the current scope,
458 as well as parent scopes up to (but not including) ENCLOSING_BLK
459 shall be thusly marked. */
462 objc_mark_locals_volatile (void *enclosing_blk
)
464 cp_binding_level
*scope
;
466 for (scope
= current_binding_level
;
467 scope
&& scope
!= enclosing_blk
;
468 scope
= scope
->level_chain
)
472 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
473 objc_volatilize_decl (decl
);
475 /* Do not climb up past the current function. */
476 if (scope
->kind
== sk_function_parms
)
481 /* True if B is the level for the condition of a constexpr if. */
484 level_for_constexpr_if (cp_binding_level
*b
)
486 return (b
->kind
== sk_cond
&& b
->this_entity
487 && TREE_CODE (b
->this_entity
) == IF_STMT
488 && IF_STMT_CONSTEXPR_P (b
->this_entity
));
491 /* Update data for defined and undefined labels when leaving a scope. */
494 poplevel_named_label_1 (named_label_entry
**slot
, cp_binding_level
*bl
)
496 named_label_entry
*ent
= *slot
;
497 cp_binding_level
*obl
= bl
->level_chain
;
499 if (ent
->binding_level
== bl
)
503 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
504 TREE_LISTs representing OVERLOADs, so be careful. */
505 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
507 : TREE_CHAIN (decl
)))
508 if (decl_jump_unsafe (decl
))
509 vec_safe_push (ent
->bad_decls
, decl
);
511 ent
->binding_level
= obl
;
512 ent
->names_in_scope
= obl
->names
;
516 ent
->in_try_scope
= true;
519 ent
->in_catch_scope
= true;
522 ent
->in_omp_scope
= true;
525 ent
->in_transaction_scope
= true;
528 if (level_for_constexpr_if (bl
->level_chain
))
529 ent
->in_constexpr_if
= true;
537 struct named_label_use_entry
*use
;
539 for (use
= ent
->uses
; use
; use
= use
->next
)
540 if (use
->binding_level
== bl
)
542 use
->binding_level
= obl
;
543 use
->names_in_scope
= obl
->names
;
544 if (bl
->kind
== sk_omp
)
545 use
->in_omp_scope
= true;
552 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
553 when errors were reported, except for -Werror-unused-but-set-*. */
554 static int unused_but_set_errorcount
;
556 /* Exit a binding level.
557 Pop the level off, and restore the state of the identifier-decl mappings
558 that were in effect when this level was entered.
560 If KEEP == 1, this level had explicit declarations, so
561 and create a "block" (a BLOCK node) for the level
562 to record its declarations and subblocks for symbol table output.
564 If FUNCTIONBODY is nonzero, this level is the body of a function,
565 so create a block as if KEEP were set and also clear out all
568 If REVERSE is nonzero, reverse the order of decls before putting
569 them into the BLOCK. */
572 poplevel (int keep
, int reverse
, int functionbody
)
575 /* The chain of decls was accumulated in reverse order.
576 Put it into forward order, just for cleanliness. */
581 int leaving_for_scope
;
585 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
590 gcc_assert (current_binding_level
->kind
!= sk_class
591 && current_binding_level
->kind
!= sk_namespace
);
593 if (current_binding_level
->kind
== sk_cleanup
)
595 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
597 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
599 /* We used to use KEEP == 2 to indicate that the new block should go
600 at the beginning of the list of blocks at this binding level,
601 rather than the end. This hack is no longer used. */
602 gcc_assert (keep
== 0 || keep
== 1);
604 if (current_binding_level
->keep
)
607 /* Any uses of undefined labels, and any defined labels, now operate
608 under constraints of next binding contour. */
609 if (cfun
&& !functionbody
&& named_labels
)
610 named_labels
->traverse
<cp_binding_level
*, poplevel_named_label_1
>
611 (current_binding_level
);
613 /* Get the decls in the order they were written.
614 Usually current_binding_level->names is in reverse order.
615 But parameter decls were previously put in forward order. */
617 decls
= current_binding_level
->names
;
620 decls
= nreverse (decls
);
621 current_binding_level
->names
= decls
;
624 /* If there were any declarations or structure tags in that level,
625 or if this level is a function body,
626 create a BLOCK to record them for the life of this function. */
628 /* Avoid function body block if possible. */
629 if (functionbody
&& subblocks
&& BLOCK_CHAIN (subblocks
) == NULL_TREE
)
631 else if (keep
== 1 || functionbody
)
632 block
= make_node (BLOCK
);
633 if (block
!= NULL_TREE
)
635 BLOCK_VARS (block
) = decls
;
636 BLOCK_SUBBLOCKS (block
) = subblocks
;
639 /* In each subblock, record that this is its superior. */
641 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
642 BLOCK_SUPERCONTEXT (link
) = block
;
644 /* We still support the old for-scope rules, whereby the variables
645 in a init statement were in scope after the for-statement ended.
646 We only use the new rules if flag_new_for_scope is nonzero. */
648 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
650 /* Before we remove the declarations first check for unused variables. */
651 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
652 && current_binding_level
->kind
!= sk_template_parms
653 && !processing_template_decl
)
654 for (tree d
= get_local_decls (); d
; d
= TREE_CHAIN (d
))
656 /* There are cases where D itself is a TREE_LIST. See in
657 push_local_binding where the list of decls returned by
658 getdecls is built. */
659 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
661 tree type
= TREE_TYPE (decl
);
663 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
664 && ! DECL_IN_SYSTEM_HEADER (decl
)
665 /* For structured bindings, consider only real variables, not
667 && (DECL_DECOMPOSITION_P (decl
) ? !DECL_DECOMP_BASE (decl
)
668 : (DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
)))
669 && type
!= error_mark_node
670 && (!CLASS_TYPE_P (type
)
671 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
672 || lookup_attribute ("warn_unused",
673 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
675 if (! TREE_USED (decl
))
677 if (!DECL_NAME (decl
) && DECL_DECOMPOSITION_P (decl
))
678 warning_at (DECL_SOURCE_LOCATION (decl
),
679 OPT_Wunused_variable
,
680 "unused structured binding declaration");
682 warning_at (DECL_SOURCE_LOCATION (decl
),
683 OPT_Wunused_variable
, "unused variable %qD", decl
);
685 else if (DECL_CONTEXT (decl
) == current_function_decl
686 // For -Wunused-but-set-variable leave references alone.
687 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
688 && errorcount
== unused_but_set_errorcount
)
690 if (!DECL_NAME (decl
) && DECL_DECOMPOSITION_P (decl
))
691 warning_at (DECL_SOURCE_LOCATION (decl
),
692 OPT_Wunused_but_set_variable
, "structured "
693 "binding declaration set but not used");
695 warning_at (DECL_SOURCE_LOCATION (decl
),
696 OPT_Wunused_but_set_variable
,
697 "variable %qD set but not used", decl
);
698 unused_but_set_errorcount
= errorcount
;
703 /* Remove declarations for all the DECLs in this level. */
704 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
706 decl
= TREE_CODE (link
) == TREE_LIST
? TREE_VALUE (link
) : link
;
707 tree name
= OVL_NAME (decl
);
709 if (leaving_for_scope
&& VAR_P (decl
)
710 /* It's hard to make this ARM compatibility hack play nicely with
711 lambdas, and it really isn't necessary in C++11 mode. */
712 && cxx_dialect
< cxx11
715 cxx_binding
*ob
= outer_binding (name
,
716 IDENTIFIER_BINDING (name
),
718 tree ns_binding
= NULL_TREE
;
720 ns_binding
= get_namespace_binding (current_namespace
, name
);
722 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
723 /* We have something like:
728 and we are leaving the `for' scope. There's no reason to
729 keep the binding of the inner `i' in this case. */
731 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
732 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
733 /* Here, we have something like:
741 We must pop the for-scope binding so we know what's a
742 type and what isn't. */
746 /* Mark this VAR_DECL as dead so that we can tell we left it
747 there only for backward compatibility. */
748 DECL_DEAD_FOR_LOCAL (link
) = 1;
750 /* Keep track of what should have happened when we
751 popped the binding. */
754 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
755 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
758 /* Add it to the list of dead variables in the next
759 outermost binding to that we can remove these when we
760 leave that binding. */
762 current_binding_level
->level_chain
->dead_vars_from_for
,
765 /* Although we don't pop the cxx_binding, we do clear
766 its SCOPE since the scope is going away now. */
767 IDENTIFIER_BINDING (name
)->scope
768 = current_binding_level
->level_chain
;
770 /* Don't remove the binding. */
774 /* Remove the binding. */
775 if (TREE_CODE (decl
) == LABEL_DECL
)
776 pop_local_label (name
, decl
);
778 pop_local_binding (name
, decl
);
781 /* Remove declarations for any `for' variables from inner scopes
782 that we kept around. */
783 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
785 pop_local_binding (DECL_NAME (decl
), decl
);
787 /* Restore the IDENTIFIER_TYPE_VALUEs. */
788 for (link
= current_binding_level
->type_shadowed
;
789 link
; link
= TREE_CHAIN (link
))
790 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
792 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
793 list if a `using' declaration put them there. The debugging
794 back ends won't understand OVERLOAD, so we remove them here.
795 Because the BLOCK_VARS are (temporarily) shared with
796 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
797 popped all the bindings. Also remove undeduced 'auto' decls,
798 which LTO doesn't understand, and can't have been used by anything. */
803 for (d
= &BLOCK_VARS (block
); *d
; )
805 if (TREE_CODE (*d
) == TREE_LIST
806 || (!processing_template_decl
807 && undeduced_auto_decl (*d
)))
808 *d
= TREE_CHAIN (*d
);
810 d
= &DECL_CHAIN (*d
);
814 /* If the level being exited is the top level of a function,
815 check over all the labels. */
820 /* Since this is the top level block of a function, the vars are
821 the function's parameters. Don't leave them in the BLOCK
822 because they are found in the FUNCTION_DECL instead. */
823 BLOCK_VARS (block
) = 0;
827 pop_labels (subblocks
);
830 kind
= current_binding_level
->kind
;
831 if (kind
== sk_cleanup
)
835 /* If this is a temporary binding created for a cleanup, then we'll
836 have pushed a statement list level. Pop that, create a new
837 BIND_EXPR for the block, and insert it into the stream. */
838 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
839 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
846 /* The current function is being defined, so its DECL_INITIAL
847 should be error_mark_node. */
848 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
849 DECL_INITIAL (current_function_decl
) = block
? block
: subblocks
;
852 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
854 if (BLOCK_SUBBLOCKS (subblocks
))
855 BLOCK_OUTER_CURLY_BRACE_P (BLOCK_SUBBLOCKS (subblocks
)) = 1;
858 BLOCK_OUTER_CURLY_BRACE_P (subblocks
) = 1;
862 current_binding_level
->blocks
863 = block_chainon (current_binding_level
->blocks
, block
);
865 /* If we did not make a block for the level just exited,
866 any blocks made for inner levels
867 (since they cannot be recorded as subblocks in that level)
868 must be carried forward so they will later become subblocks
869 of something else. */
871 current_binding_level
->blocks
872 = block_chainon (current_binding_level
->blocks
, subblocks
);
874 /* Each and every BLOCK node created here in `poplevel' is important
875 (e.g. for proper debugging information) so if we created one
876 earlier, mark it as "used". */
878 TREE_USED (block
) = 1;
880 /* All temporary bindings created for cleanups are popped silently. */
881 if (kind
== sk_cleanup
)
884 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
888 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
889 /* Diagnose odr-used extern inline variables without definitions
890 in the current TU. */
893 wrapup_namespace_globals ()
895 if (vec
<tree
, va_gc
> *statics
= static_decls
)
899 FOR_EACH_VEC_ELT (*statics
, i
, decl
)
901 if (warn_unused_function
902 && TREE_CODE (decl
) == FUNCTION_DECL
903 && DECL_INITIAL (decl
) == 0
904 && DECL_EXTERNAL (decl
)
905 && !TREE_PUBLIC (decl
)
906 && !DECL_ARTIFICIAL (decl
)
907 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl
)
908 && !TREE_NO_WARNING (decl
))
909 warning_at (DECL_SOURCE_LOCATION (decl
),
910 OPT_Wunused_function
,
911 "%qF declared %<static%> but never defined", decl
);
914 && DECL_EXTERNAL (decl
)
915 && DECL_INLINE_VAR_P (decl
)
916 && DECL_ODR_USED (decl
))
917 error_at (DECL_SOURCE_LOCATION (decl
),
918 "odr-used inline variable %qD is not defined", decl
);
921 /* Clear out the list, so we don't rescan next time. */
924 /* Write out any globals that need to be output. */
925 return wrapup_global_declarations (statics
->address (),
931 /* In C++, you don't have to write `struct S' to refer to `S'; you
932 can just use `S'. We accomplish this by creating a TYPE_DECL as
933 if the user had written `typedef struct S S'. Create and return
934 the TYPE_DECL for TYPE. */
937 create_implicit_typedef (tree name
, tree type
)
941 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
942 DECL_ARTIFICIAL (decl
) = 1;
943 /* There are other implicit type declarations, like the one *within*
944 a class that allows you to write `S::S'. We must distinguish
946 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
947 TYPE_NAME (type
) = decl
;
948 TYPE_STUB_DECL (type
) = decl
;
953 /* Remember a local name for name-mangling purposes. */
956 push_local_name (tree decl
)
961 timevar_start (TV_NAME_LOOKUP
);
963 name
= DECL_NAME (decl
);
965 nelts
= vec_safe_length (local_names
);
966 for (i
= 0; i
< nelts
; i
++)
968 t
= (*local_names
)[i
];
969 if (DECL_NAME (t
) == name
)
971 retrofit_lang_decl (decl
);
972 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
973 if (DECL_DISCRIMINATOR_SET_P (t
))
974 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
976 DECL_DISCRIMINATOR (decl
) = 1;
978 (*local_names
)[i
] = decl
;
979 timevar_stop (TV_NAME_LOOKUP
);
984 vec_safe_push (local_names
, decl
);
985 timevar_stop (TV_NAME_LOOKUP
);
988 /* Subroutine of duplicate_decls: return truthvalue of whether
989 or not types of these decls match.
991 For C++, we must compare the parameter list so that `int' can match
992 `int&' in a parameter position, but `int&' is not confused with
996 decls_match (tree newdecl
, tree olddecl
)
1000 if (newdecl
== olddecl
)
1003 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
1004 /* If the two DECLs are not even the same kind of thing, we're not
1005 interested in their types. */
1008 gcc_assert (DECL_P (newdecl
));
1010 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1012 tree f1
= TREE_TYPE (newdecl
);
1013 tree f2
= TREE_TYPE (olddecl
);
1014 tree p1
= TYPE_ARG_TYPES (f1
);
1015 tree p2
= TYPE_ARG_TYPES (f2
);
1018 /* Specializations of different templates are different functions
1019 even if they have the same type. */
1020 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
1021 ? DECL_TI_TEMPLATE (newdecl
)
1023 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
1024 ? DECL_TI_TEMPLATE (olddecl
)
1029 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1030 && ! (DECL_EXTERN_C_P (newdecl
)
1031 && DECL_EXTERN_C_P (olddecl
)))
1034 /* A new declaration doesn't match a built-in one unless it
1035 is also extern "C". */
1036 if (DECL_IS_BUILTIN (olddecl
)
1037 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
1040 if (TREE_CODE (f1
) != TREE_CODE (f2
))
1043 /* A declaration with deduced return type should use its pre-deduction
1044 type for declaration matching. */
1045 r2
= fndecl_declared_return_type (olddecl
);
1047 if (same_type_p (TREE_TYPE (f1
), r2
))
1049 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1050 && (DECL_BUILT_IN (olddecl
)
1051 #ifndef NO_IMPLICIT_EXTERN_C
1052 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1053 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1057 types_match
= self_promoting_args_p (p1
);
1058 if (p1
== void_list_node
)
1059 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1061 #ifndef NO_IMPLICIT_EXTERN_C
1062 else if (!prototype_p (f1
)
1063 && (DECL_EXTERN_C_P (olddecl
)
1064 && DECL_IN_SYSTEM_HEADER (olddecl
)
1065 && !DECL_CLASS_SCOPE_P (olddecl
))
1066 && (DECL_EXTERN_C_P (newdecl
)
1067 && DECL_IN_SYSTEM_HEADER (newdecl
)
1068 && !DECL_CLASS_SCOPE_P (newdecl
)))
1070 types_match
= self_promoting_args_p (p2
);
1071 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1077 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
1078 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1079 || comp_type_attributes (TREE_TYPE (newdecl
),
1080 TREE_TYPE (olddecl
)) != 0);
1085 /* The decls dont match if they correspond to two different versions
1086 of the same function. Disallow extern "C" functions to be
1087 versions for now. */
1089 && !DECL_EXTERN_C_P (newdecl
)
1090 && !DECL_EXTERN_C_P (olddecl
)
1091 && maybe_version_functions (newdecl
, olddecl
))
1094 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1096 tree oldres
= DECL_TEMPLATE_RESULT (olddecl
);
1097 tree newres
= DECL_TEMPLATE_RESULT (newdecl
);
1099 if (TREE_CODE (newres
) != TREE_CODE (oldres
))
1102 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1103 DECL_TEMPLATE_PARMS (olddecl
)))
1106 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1107 types_match
= (same_type_p (TREE_TYPE (oldres
), TREE_TYPE (newres
))
1108 && equivalently_constrained (olddecl
, newdecl
));
1110 // We don't need to check equivalently_constrained for variable and
1111 // function templates because we check it on the results.
1112 types_match
= decls_match (oldres
, newres
);
1116 /* Need to check scope for variable declaration (VAR_DECL).
1117 For typedef (TYPE_DECL), scope is ignored. */
1119 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1121 Two declarations for an object with C language linkage
1122 with the same name (ignoring the namespace that qualify
1123 it) that appear in different namespace scopes refer to
1125 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1128 if (TREE_TYPE (newdecl
) == error_mark_node
)
1129 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1130 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1131 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1132 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1135 types_match
= comptypes (TREE_TYPE (newdecl
),
1136 TREE_TYPE (olddecl
),
1137 COMPARE_REDECLARATION
);
1140 // Normal functions can be constrained, as can variable partial
1142 if (types_match
&& VAR_OR_FUNCTION_DECL_P (newdecl
))
1143 types_match
= equivalently_constrained (newdecl
, olddecl
);
1148 /* NEWDECL and OLDDECL have identical signatures. If they are
1149 different versions adjust them and return true. */
1152 maybe_version_functions (tree newdecl
, tree olddecl
)
1154 if (!targetm
.target_option
.function_versions (newdecl
, olddecl
))
1157 bool record
= false;
1159 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1162 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1163 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1164 mangle_decl (olddecl
);
1167 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1170 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1171 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1172 mangle_decl (newdecl
);
1175 /* Only record if at least one was not already versions. */
1177 cgraph_node::record_function_versions (olddecl
, newdecl
);
1182 /* If NEWDECL is `static' and an `extern' was seen previously,
1183 warn about it. OLDDECL is the previous declaration.
1185 Note that this does not apply to the C++ case of declaring
1186 a variable `extern const' and then later `const'.
1188 Don't complain about built-in functions, since they are beyond
1189 the user's control. */
1192 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1194 if (TREE_CODE (newdecl
) == TYPE_DECL
1195 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1196 || TREE_CODE (newdecl
) == CONST_DECL
1197 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1200 /* Don't get confused by static member functions; that's a different
1202 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1203 && DECL_STATIC_FUNCTION_P (newdecl
))
1206 /* If the old declaration was `static', or the new one isn't, then
1207 everything is OK. */
1208 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1211 /* It's OK to declare a builtin function as `static'. */
1212 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1213 && DECL_ARTIFICIAL (olddecl
))
1216 if (permerror (DECL_SOURCE_LOCATION (newdecl
),
1217 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1218 inform (DECL_SOURCE_LOCATION (olddecl
),
1219 "previous declaration of %qD", olddecl
);
1222 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1223 function templates. If their exception specifications do not
1224 match, issue a diagnostic. */
1227 check_redeclaration_exception_specification (tree new_decl
,
1230 tree new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1231 tree old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1233 /* Two default specs are equivalent, don't force evaluation. */
1234 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions
)
1235 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions
))
1238 maybe_instantiate_noexcept (new_decl
);
1239 maybe_instantiate_noexcept (old_decl
);
1240 new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1241 old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1245 If any declaration of a function has an exception-specification,
1246 all declarations, including the definition and an explicit
1247 specialization, of that function shall have an
1248 exception-specification with the same set of type-ids. */
1249 if (! DECL_IS_BUILTIN (old_decl
)
1250 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1252 const char *const msg
1253 = G_("declaration of %qF has a different exception specifier");
1254 bool complained
= true;
1255 location_t new_loc
= DECL_SOURCE_LOCATION (new_decl
);
1256 if (DECL_IN_SYSTEM_HEADER (old_decl
))
1257 complained
= pedwarn (new_loc
, OPT_Wsystem_headers
, msg
, new_decl
);
1258 else if (!flag_exceptions
)
1259 /* We used to silently permit mismatched eh specs with
1260 -fno-exceptions, so make them a pedwarn now. */
1261 complained
= pedwarn (new_loc
, OPT_Wpedantic
, msg
, new_decl
);
1263 error_at (new_loc
, msg
, new_decl
);
1265 inform (DECL_SOURCE_LOCATION (old_decl
),
1266 "from previous declaration %qF", old_decl
);
1270 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1271 Otherwise issue diagnostics. */
1274 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1276 old_decl
= STRIP_TEMPLATE (old_decl
);
1277 new_decl
= STRIP_TEMPLATE (new_decl
);
1278 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1279 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1281 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1282 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1284 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1286 if (DECL_BUILT_IN (old_decl
))
1288 /* Hide a built-in declaration. */
1289 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1290 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1293 /* 7.1.5 [dcl.constexpr]
1294 Note: An explicit specialization can differ from the template
1295 declaration with respect to the constexpr specifier. */
1296 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1297 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1300 error_at (DECL_SOURCE_LOCATION (new_decl
),
1301 "redeclaration %qD differs in %<constexpr%> "
1302 "from previous declaration", new_decl
);
1303 inform (DECL_SOURCE_LOCATION (old_decl
),
1304 "previous declaration %qD", old_decl
);
1310 // If OLDDECL and NEWDECL are concept declarations with the same type
1311 // (i.e., and template parameters), but different requirements,
1312 // emit diagnostics and return true. Otherwise, return false.
1314 check_concept_refinement (tree olddecl
, tree newdecl
)
1316 if (!DECL_DECLARED_CONCEPT_P (olddecl
) || !DECL_DECLARED_CONCEPT_P (newdecl
))
1319 tree d1
= DECL_TEMPLATE_RESULT (olddecl
);
1320 tree d2
= DECL_TEMPLATE_RESULT (newdecl
);
1321 if (TREE_CODE (d1
) != TREE_CODE (d2
))
1324 tree t1
= TREE_TYPE (d1
);
1325 tree t2
= TREE_TYPE (d2
);
1326 if (TREE_CODE (d1
) == FUNCTION_DECL
)
1328 if (compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
))
1329 && comp_template_parms (DECL_TEMPLATE_PARMS (olddecl
),
1330 DECL_TEMPLATE_PARMS (newdecl
))
1331 && !equivalently_constrained (olddecl
, newdecl
))
1333 error ("cannot specialize concept %q#D", olddecl
);
1340 /* DECL is a redeclaration of a function or function template. If
1341 it does have default arguments issue a diagnostic. Note: this
1342 function is used to enforce the requirements in C++11 8.3.6 about
1343 no default arguments in redeclarations. */
1346 check_redeclaration_no_default_args (tree decl
)
1348 gcc_assert (DECL_DECLARES_FUNCTION_P (decl
));
1350 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
1351 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1352 if (TREE_PURPOSE (t
))
1354 permerror (DECL_SOURCE_LOCATION (decl
),
1355 "redeclaration of %q#D may not have default "
1361 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1362 && lookup_attribute ("gnu_inline", \
1363 DECL_ATTRIBUTES (fn)))
1365 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1366 If the redeclaration is invalid, a diagnostic is issued, and the
1367 error_mark_node is returned. Otherwise, OLDDECL is returned.
1369 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1372 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1375 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1377 unsigned olddecl_uid
= DECL_UID (olddecl
);
1378 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1379 int new_defines_function
= 0;
1380 tree new_template_info
;
1382 if (newdecl
== olddecl
)
1385 types_match
= decls_match (newdecl
, olddecl
);
1387 /* If either the type of the new decl or the type of the old decl is an
1388 error_mark_node, then that implies that we have already issued an
1389 error (earlier) for some bogus type specification, and in that case,
1390 it is rather pointless to harass the user with yet more error message
1391 about the same declaration, so just pretend the types match here. */
1392 if (TREE_TYPE (newdecl
) == error_mark_node
1393 || TREE_TYPE (olddecl
) == error_mark_node
)
1394 return error_mark_node
;
1396 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1397 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1399 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1400 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1401 && check_raw_literal_operator (olddecl
))
1402 error ("literal operator template %q+D conflicts with"
1403 " raw literal operator %qD", newdecl
, olddecl
);
1404 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1405 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1406 && check_raw_literal_operator (newdecl
))
1407 error ("raw literal operator %q+D conflicts with"
1408 " literal operator template %qD", newdecl
, olddecl
);
1411 if (DECL_P (olddecl
)
1412 && TREE_CODE (newdecl
) == FUNCTION_DECL
1413 && TREE_CODE (olddecl
) == FUNCTION_DECL
1414 && diagnose_mismatched_attributes (olddecl
, newdecl
))
1416 if (DECL_INITIAL (olddecl
))
1417 inform (DECL_SOURCE_LOCATION (olddecl
),
1418 "previous definition of %qD was here", olddecl
);
1420 inform (DECL_SOURCE_LOCATION (olddecl
),
1421 "previous declaration of %qD was here", olddecl
);
1424 /* Check for redeclaration and other discrepancies. */
1425 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1426 && DECL_ARTIFICIAL (olddecl
))
1428 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1429 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1431 /* Avoid warnings redeclaring built-ins which have not been
1432 explicitly declared. */
1433 if (DECL_ANTICIPATED (olddecl
))
1435 if (TREE_PUBLIC (newdecl
)
1436 && CP_DECL_CONTEXT (newdecl
) == global_namespace
)
1437 warning_at (DECL_SOURCE_LOCATION (newdecl
),
1438 OPT_Wbuiltin_declaration_mismatch
,
1439 "built-in function %qD declared as non-function",
1444 /* If you declare a built-in or predefined function name as static,
1445 the old definition is overridden, but optionally warn this was a
1446 bad choice of name. */
1447 if (! TREE_PUBLIC (newdecl
))
1449 warning (OPT_Wshadow
,
1450 DECL_BUILT_IN (olddecl
)
1451 ? G_("shadowing built-in function %q#D")
1452 : G_("shadowing library function %q#D"), olddecl
);
1453 /* Discard the old built-in function. */
1456 /* If the built-in is not ansi, then programs can override
1457 it even globally without an error. */
1458 else if (! DECL_BUILT_IN (olddecl
))
1459 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1460 "library function %q#D redeclared as non-function %q#D",
1463 error ("declaration of %q+#D conflicts with built-in "
1464 "declaration %q#D", newdecl
, olddecl
);
1467 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1469 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1470 error_at (DECL_SOURCE_LOCATION (newdecl
),
1471 "redeclaration of %<pragma omp declare reduction%>");
1472 inform (DECL_SOURCE_LOCATION (olddecl
),
1473 "previous %<pragma omp declare reduction%> declaration");
1474 return error_mark_node
;
1476 else if (!types_match
)
1478 /* Avoid warnings redeclaring built-ins which have not been
1479 explicitly declared. */
1480 if (DECL_ANTICIPATED (olddecl
))
1484 /* A new declaration doesn't match a built-in one unless it
1485 is also extern "C". */
1486 gcc_assert (DECL_IS_BUILTIN (olddecl
));
1487 gcc_assert (DECL_EXTERN_C_P (olddecl
));
1488 if (!DECL_EXTERN_C_P (newdecl
))
1491 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1492 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1494 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1498 /* FILE, tm types are not known at the time
1499 we create the builtins. */
1500 for (unsigned i
= 0;
1501 i
< sizeof (builtin_structptr_types
)
1502 / sizeof (builtin_structptr_type
);
1504 if (TREE_VALUE (t2
) == builtin_structptr_types
[i
].node
)
1506 tree t
= TREE_VALUE (t1
);
1509 && TYPE_IDENTIFIER (TREE_TYPE (t
))
1510 == get_identifier (builtin_structptr_types
[i
].str
)
1511 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1513 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1515 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1516 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1517 types_match
= decls_match (newdecl
, olddecl
);
1519 return duplicate_decls (newdecl
, olddecl
,
1521 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1526 if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1531 warning_at (DECL_SOURCE_LOCATION (newdecl
),
1532 OPT_Wbuiltin_declaration_mismatch
,
1533 "declaration of %q#D conflicts with built-in "
1534 "declaration %q#D", newdecl
, olddecl
);
1536 else if ((DECL_EXTERN_C_P (newdecl
)
1537 && DECL_EXTERN_C_P (olddecl
))
1538 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1539 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1541 /* A near match; override the builtin. */
1543 if (TREE_PUBLIC (newdecl
))
1544 warning_at (DECL_SOURCE_LOCATION (newdecl
),
1545 OPT_Wbuiltin_declaration_mismatch
,
1546 "new declaration %q#D ambiguates built-in "
1547 "declaration %q#D", newdecl
, olddecl
);
1549 warning (OPT_Wshadow
,
1550 DECL_BUILT_IN (olddecl
)
1551 ? G_("shadowing built-in function %q#D")
1552 : G_("shadowing library function %q#D"), olddecl
);
1555 /* Discard the old built-in function. */
1558 /* Replace the old RTL to avoid problems with inlining. */
1559 COPY_DECL_RTL (newdecl
, olddecl
);
1561 /* Even if the types match, prefer the new declarations type for
1562 built-ins which have not been explicitly declared, for
1563 exception lists, etc... */
1564 else if (DECL_IS_BUILTIN (olddecl
))
1566 tree type
= TREE_TYPE (newdecl
);
1567 tree attribs
= (*targetm
.merge_type_attributes
)
1568 (TREE_TYPE (olddecl
), type
);
1570 type
= cp_build_type_attribute_variant (type
, attribs
);
1571 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1574 /* If a function is explicitly declared "throw ()", propagate that to
1575 the corresponding builtin. */
1576 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1577 && DECL_ANTICIPATED (olddecl
)
1578 && TREE_NOTHROW (newdecl
)
1579 && !TREE_NOTHROW (olddecl
))
1581 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1582 tree tmpdecl
= builtin_decl_explicit (fncode
);
1583 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1584 TREE_NOTHROW (tmpdecl
) = 1;
1587 /* Whether or not the builtin can throw exceptions has no
1588 bearing on this declarator. */
1589 TREE_NOTHROW (olddecl
) = 0;
1591 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1593 /* If a builtin function is redeclared as `static', merge
1594 the declarations, but make the original one static. */
1595 DECL_THIS_STATIC (olddecl
) = 1;
1596 TREE_PUBLIC (olddecl
) = 0;
1598 /* Make the old declaration consistent with the new one so
1599 that all remnants of the builtin-ness of this function
1600 will be banished. */
1601 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1602 COPY_DECL_RTL (newdecl
, olddecl
);
1605 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1607 /* C++ Standard, 3.3, clause 4:
1608 "[Note: a namespace name or a class template name must be unique
1609 in its declarative region (7.3.2, clause 14). ]" */
1610 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1611 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1612 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1613 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1614 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1615 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1617 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1618 && TREE_CODE (newdecl
) != TYPE_DECL
)
1619 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1620 && TREE_CODE (olddecl
) != TYPE_DECL
))
1622 /* We do nothing special here, because C++ does such nasty
1623 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1624 get shadowed, and know that if we need to find a TYPE_DECL
1625 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1626 slot of the identifier. */
1630 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1631 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1632 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1633 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1637 error ("%q#D redeclared as different kind of symbol", newdecl
);
1638 if (TREE_CODE (olddecl
) == TREE_LIST
)
1639 olddecl
= TREE_VALUE (olddecl
);
1640 inform (DECL_SOURCE_LOCATION (olddecl
),
1641 "previous declaration %q#D", olddecl
);
1643 return error_mark_node
;
1645 else if (!types_match
)
1647 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1648 /* These are certainly not duplicate declarations; they're
1649 from different scopes. */
1652 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1654 /* The name of a class template may not be declared to refer to
1655 any other template, class, function, object, namespace, value,
1656 or type in the same scope. */
1657 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1658 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1660 error ("conflicting declaration of template %q+#D", newdecl
);
1661 inform (DECL_SOURCE_LOCATION (olddecl
),
1662 "previous declaration %q#D", olddecl
);
1663 return error_mark_node
;
1665 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1666 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1667 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1668 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1669 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1670 DECL_TEMPLATE_PARMS (olddecl
))
1671 /* Template functions can be disambiguated by
1673 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1674 TREE_TYPE (TREE_TYPE (olddecl
)))
1675 // Template functions can also be disambiguated by
1677 && equivalently_constrained (olddecl
, newdecl
))
1679 error ("ambiguating new declaration %q+#D", newdecl
);
1680 inform (DECL_SOURCE_LOCATION (olddecl
),
1681 "old declaration %q#D", olddecl
);
1683 else if (check_concept_refinement (olddecl
, newdecl
))
1684 return error_mark_node
;
1687 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1689 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1691 error ("conflicting declaration of C function %q+#D",
1693 inform (DECL_SOURCE_LOCATION (olddecl
),
1694 "previous declaration %q#D", olddecl
);
1697 /* For function versions, params and types match, but they
1698 are not ambiguous. */
1699 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1700 && !DECL_FUNCTION_VERSIONED (olddecl
))
1701 // The functions have the same parameter types.
1702 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1703 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)))
1704 // And the same constraints.
1705 && equivalently_constrained (newdecl
, olddecl
))
1707 error ("ambiguating new declaration of %q+#D", newdecl
);
1708 inform (DECL_SOURCE_LOCATION (olddecl
),
1709 "old declaration %q#D", olddecl
);
1710 return error_mark_node
;
1717 error ("conflicting declaration %q+#D", newdecl
);
1718 inform (DECL_SOURCE_LOCATION (olddecl
),
1719 "previous declaration as %q#D", olddecl
);
1720 return error_mark_node
;
1723 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1724 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1725 && (!DECL_TEMPLATE_INFO (newdecl
)
1726 || (DECL_TI_TEMPLATE (newdecl
)
1727 != DECL_TI_TEMPLATE (olddecl
))))
1728 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1729 && (!DECL_TEMPLATE_INFO (olddecl
)
1730 || (DECL_TI_TEMPLATE (olddecl
)
1731 != DECL_TI_TEMPLATE (newdecl
))))))
1732 /* It's OK to have a template specialization and a non-template
1733 with the same type, or to have specializations of two
1734 different templates with the same type. Note that if one is a
1735 specialization, and the other is an instantiation of the same
1736 template, that we do not exit at this point. That situation
1737 can occur if we instantiate a template class, and then
1738 specialize one of its methods. This situation is valid, but
1739 the declarations must be merged in the usual way. */
1741 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1742 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1743 && !DECL_USE_TEMPLATE (newdecl
))
1744 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1745 && !DECL_USE_TEMPLATE (olddecl
))))
1746 /* One of the declarations is a template instantiation, and the
1747 other is not a template at all. That's OK. */
1749 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1751 /* In [namespace.alias] we have:
1753 In a declarative region, a namespace-alias-definition can be
1754 used to redefine a namespace-alias declared in that declarative
1755 region to refer only to the namespace to which it already
1758 Therefore, if we encounter a second alias directive for the same
1759 alias, we can just ignore the second directive. */
1760 if (DECL_NAMESPACE_ALIAS (newdecl
)
1761 && (DECL_NAMESPACE_ALIAS (newdecl
)
1762 == DECL_NAMESPACE_ALIAS (olddecl
)))
1765 /* Leave it to update_binding to merge or report error. */
1770 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1773 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1774 if (DECL_NAME (olddecl
) != NULL_TREE
)
1775 inform (DECL_SOURCE_LOCATION (olddecl
),
1776 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1777 ? G_("%q#D previously defined here")
1778 : G_("%q#D previously declared here"), olddecl
);
1779 return error_mark_node
;
1781 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1782 && DECL_INITIAL (olddecl
) != NULL_TREE
1783 && !prototype_p (TREE_TYPE (olddecl
))
1784 && prototype_p (TREE_TYPE (newdecl
)))
1786 /* Prototype decl follows defn w/o prototype. */
1787 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1788 "prototype specified for %q#D", newdecl
))
1789 inform (DECL_SOURCE_LOCATION (olddecl
),
1790 "previous non-prototype definition here");
1792 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1793 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1796 If two declarations of the same function or object
1797 specify different linkage-specifications ..., the program
1798 is ill-formed.... Except for functions with C++ linkage,
1799 a function declaration without a linkage specification
1800 shall not precede the first linkage specification for
1801 that function. A function can be declared without a
1802 linkage specification after an explicit linkage
1803 specification has been seen; the linkage explicitly
1804 specified in the earlier declaration is not affected by
1805 such a function declaration.
1807 DR 563 raises the question why the restrictions on
1808 functions should not also apply to objects. Older
1809 versions of G++ silently ignore the linkage-specification
1817 which is clearly wrong. Therefore, we now treat objects
1819 if (current_lang_depth () == 0)
1821 /* There is no explicit linkage-specification, so we use
1822 the linkage from the previous declaration. */
1823 retrofit_lang_decl (newdecl
);
1824 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1828 error ("conflicting declaration of %q+#D with %qL linkage",
1829 newdecl
, DECL_LANGUAGE (newdecl
));
1830 inform (DECL_SOURCE_LOCATION (olddecl
),
1831 "previous declaration with %qL linkage",
1832 DECL_LANGUAGE (olddecl
));
1836 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1838 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1840 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1841 if (DECL_FUNCTION_MEMBER_P (olddecl
)
1842 && (/* grokfndecl passes member function templates too
1843 as FUNCTION_DECLs. */
1844 DECL_TEMPLATE_INFO (olddecl
)
1846 Default arguments for a member function of a class
1847 template shall be specified on the initial declaration
1848 of the member function within the class template. */
1849 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl
))))
1850 check_redeclaration_no_default_args (newdecl
);
1853 tree t1
= FUNCTION_FIRST_USER_PARMTYPE (olddecl
);
1854 tree t2
= FUNCTION_FIRST_USER_PARMTYPE (newdecl
);
1857 for (; t1
&& t1
!= void_list_node
;
1858 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1859 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1861 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1864 if (permerror (input_location
,
1865 "default argument given for parameter "
1866 "%d of %q#D", i
, newdecl
))
1867 inform (DECL_SOURCE_LOCATION (olddecl
),
1868 "previous specification in %q#D here",
1873 error ("default argument given for parameter %d "
1874 "of %q#D", i
, newdecl
);
1875 inform (DECL_SOURCE_LOCATION (olddecl
),
1876 "previous specification in %q#D here",
1884 /* Do not merge an implicit typedef with an explicit one. In:
1888 typedef class A A __attribute__ ((foo));
1890 the attribute should apply only to the typedef. */
1891 if (TREE_CODE (olddecl
) == TYPE_DECL
1892 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1893 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1896 /* If new decl is `static' and an `extern' was seen previously,
1898 warn_extern_redeclared_static (newdecl
, olddecl
);
1900 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1901 return error_mark_node
;
1903 /* We have committed to returning 1 at this point. */
1904 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1906 /* Now that functions must hold information normally held
1907 by field decls, there is extra work to do so that
1908 declaration information does not get destroyed during
1910 if (DECL_VINDEX (olddecl
))
1911 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1912 if (DECL_CONTEXT (olddecl
))
1913 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1914 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1915 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1916 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1917 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1918 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1919 DECL_FINAL_P (newdecl
) |= DECL_FINAL_P (olddecl
);
1920 DECL_OVERRIDE_P (newdecl
) |= DECL_OVERRIDE_P (olddecl
);
1921 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1922 if (DECL_OVERLOADED_OPERATOR_P (olddecl
))
1923 DECL_OVERLOADED_OPERATOR_CODE_RAW (newdecl
)
1924 = DECL_OVERLOADED_OPERATOR_CODE_RAW (olddecl
);
1925 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1927 /* Optionally warn about more than one declaration for the same
1928 name, but don't warn about a function declaration followed by a
1930 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1931 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1932 /* Don't warn about extern decl followed by definition. */
1933 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1934 /* Don't warn about friends, let add_friend take care of it. */
1935 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1936 /* Don't warn about declaration followed by specialization. */
1937 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1938 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1940 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1941 OPT_Wredundant_decls
,
1942 "redundant redeclaration of %qD in same scope",
1944 inform (DECL_SOURCE_LOCATION (olddecl
),
1945 "previous declaration of %qD", olddecl
);
1948 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1949 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1951 if (DECL_DELETED_FN (newdecl
))
1953 error ("deleted definition of %q+D", newdecl
);
1954 inform (DECL_SOURCE_LOCATION (olddecl
),
1955 "previous declaration of %qD", olddecl
);
1957 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1961 /* Deal with C++: must preserve virtual function table size. */
1962 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1964 tree newtype
= TREE_TYPE (newdecl
);
1965 tree oldtype
= TREE_TYPE (olddecl
);
1967 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1968 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1969 CLASSTYPE_FRIEND_CLASSES (newtype
)
1970 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1972 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1975 /* Copy all the DECL_... slots specified in the new decl
1976 except for any that we copy here from the old type. */
1977 DECL_ATTRIBUTES (newdecl
)
1978 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1980 if (DECL_DECLARES_FUNCTION_P (olddecl
) && DECL_DECLARES_FUNCTION_P (newdecl
))
1982 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1983 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
1984 && DECL_HIDDEN_FRIEND_P (olddecl
)
1985 && newdecl_is_friend
);
1988 DECL_ANTICIPATED (olddecl
) = 0;
1989 DECL_HIDDEN_FRIEND_P (olddecl
) = 0;
1993 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1997 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1998 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1999 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
2000 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
2001 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
2002 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
2004 DECL_ATTRIBUTES (old_result
)
2005 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
2007 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
2009 /* Per C++11 8.3.6/4, default arguments cannot be added in later
2010 declarations of a function template. */
2011 if (DECL_SOURCE_LOCATION (newdecl
)
2012 != DECL_SOURCE_LOCATION (olddecl
))
2013 check_redeclaration_no_default_args (newdecl
);
2015 check_default_args (newdecl
);
2017 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
2018 && DECL_INITIAL (new_result
))
2020 if (DECL_INITIAL (old_result
))
2021 DECL_UNINLINABLE (old_result
) = 1;
2023 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
2024 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
2025 DECL_NOT_REALLY_EXTERN (old_result
)
2026 = DECL_NOT_REALLY_EXTERN (new_result
);
2027 DECL_INTERFACE_KNOWN (old_result
)
2028 = DECL_INTERFACE_KNOWN (new_result
);
2029 DECL_DECLARED_INLINE_P (old_result
)
2030 = DECL_DECLARED_INLINE_P (new_result
);
2031 DECL_DISREGARD_INLINE_LIMITS (old_result
)
2032 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
2037 DECL_DECLARED_INLINE_P (old_result
)
2038 |= DECL_DECLARED_INLINE_P (new_result
);
2039 DECL_DISREGARD_INLINE_LIMITS (old_result
)
2040 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
2041 check_redeclaration_exception_specification (newdecl
, olddecl
);
2045 /* If the new declaration is a definition, update the file and
2046 line information on the declaration, and also make
2047 the old declaration the same definition. */
2048 if (DECL_INITIAL (new_result
) != NULL_TREE
)
2050 DECL_SOURCE_LOCATION (olddecl
)
2051 = DECL_SOURCE_LOCATION (old_result
)
2052 = DECL_SOURCE_LOCATION (newdecl
);
2053 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
2054 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
2057 DECL_ARGUMENTS (old_result
)
2058 = DECL_ARGUMENTS (new_result
);
2059 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
2060 parm
= DECL_CHAIN (parm
))
2061 DECL_CONTEXT (parm
) = old_result
;
2070 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2071 check_redeclaration_exception_specification (newdecl
, olddecl
);
2073 /* Automatically handles default parameters. */
2074 tree oldtype
= TREE_TYPE (olddecl
);
2077 /* For typedefs use the old type, as the new type's DECL_NAME points
2078 at newdecl, which will be ggc_freed. */
2079 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2081 /* But NEWTYPE might have an attribute, honor that. */
2082 tree tem
= TREE_TYPE (newdecl
);
2085 if (TYPE_USER_ALIGN (tem
))
2087 if (TYPE_ALIGN (tem
) > TYPE_ALIGN (newtype
))
2088 SET_TYPE_ALIGN (newtype
, TYPE_ALIGN (tem
));
2089 TYPE_USER_ALIGN (newtype
) = true;
2092 /* And remove the new type from the variants list. */
2093 if (TYPE_NAME (TREE_TYPE (newdecl
)) == newdecl
)
2095 tree remove
= TREE_TYPE (newdecl
);
2096 for (tree t
= TYPE_MAIN_VARIANT (remove
); ;
2097 t
= TYPE_NEXT_VARIANT (t
))
2098 if (TYPE_NEXT_VARIANT (t
) == remove
)
2100 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (remove
);
2106 /* Merge the data types specified in the two decls. */
2107 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
2109 if (VAR_P (newdecl
))
2111 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
2112 /* For already initialized vars, TREE_READONLY could have been
2113 cleared in cp_finish_decl, because the var needs runtime
2114 initialization or destruction. Make sure not to set
2115 TREE_READONLY on it again. */
2116 if (DECL_INITIALIZED_P (olddecl
)
2117 && !DECL_EXTERNAL (olddecl
)
2118 && !TREE_READONLY (olddecl
))
2119 TREE_READONLY (newdecl
) = 0;
2120 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
2121 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
2122 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
2123 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
2124 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
2125 if (DECL_CLASS_SCOPE_P (olddecl
))
2126 DECL_DECLARED_CONSTEXPR_P (newdecl
)
2127 |= DECL_DECLARED_CONSTEXPR_P (olddecl
);
2129 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2130 if (DECL_LANG_SPECIFIC (olddecl
)
2131 && CP_DECL_THREADPRIVATE_P (olddecl
))
2133 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2134 retrofit_lang_decl (newdecl
);
2135 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
2139 /* An explicit specialization of a function template or of a member
2140 function of a class template can be declared transaction_safe
2141 independently of whether the corresponding template entity is declared
2142 transaction_safe. */
2143 if (flag_tm
&& TREE_CODE (newdecl
) == FUNCTION_DECL
2144 && DECL_TEMPLATE_INSTANTIATION (olddecl
)
2145 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2146 && tx_safe_fn_type_p (newtype
)
2147 && !tx_safe_fn_type_p (TREE_TYPE (newdecl
)))
2148 newtype
= tx_unsafe_fn_variant (newtype
);
2150 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
2152 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2153 check_default_args (newdecl
);
2155 /* Lay the type out, unless already done. */
2156 if (! same_type_p (newtype
, oldtype
)
2157 && TREE_TYPE (newdecl
) != error_mark_node
2158 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2159 layout_type (TREE_TYPE (newdecl
));
2161 if ((VAR_P (newdecl
)
2162 || TREE_CODE (newdecl
) == PARM_DECL
2163 || TREE_CODE (newdecl
) == RESULT_DECL
2164 || TREE_CODE (newdecl
) == FIELD_DECL
2165 || TREE_CODE (newdecl
) == TYPE_DECL
)
2166 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2167 layout_decl (newdecl
, 0);
2169 /* Merge the type qualifiers. */
2170 if (TREE_READONLY (newdecl
))
2171 TREE_READONLY (olddecl
) = 1;
2172 if (TREE_THIS_VOLATILE (newdecl
))
2173 TREE_THIS_VOLATILE (olddecl
) = 1;
2174 if (TREE_NOTHROW (newdecl
))
2175 TREE_NOTHROW (olddecl
) = 1;
2177 /* Merge deprecatedness. */
2178 if (TREE_DEPRECATED (newdecl
))
2179 TREE_DEPRECATED (olddecl
) = 1;
2181 /* Preserve function specific target and optimization options */
2182 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2184 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2185 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2186 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2187 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2189 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2190 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2191 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2192 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2195 /* Merge the initialization information. */
2196 if (DECL_INITIAL (newdecl
) == NULL_TREE
2197 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2199 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2200 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2201 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2203 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2204 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2208 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2210 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2211 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2212 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2213 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2214 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
2215 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2216 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2217 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2218 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2219 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2220 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2221 /* Keep the old RTL. */
2222 COPY_DECL_RTL (olddecl
, newdecl
);
2224 else if (VAR_P (newdecl
)
2225 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2227 /* Keep the old RTL. We cannot keep the old RTL if the old
2228 declaration was for an incomplete object and the new
2229 declaration is not since many attributes of the RTL will
2231 COPY_DECL_RTL (olddecl
, newdecl
);
2234 /* If cannot merge, then use the new type and qualifiers,
2235 and don't preserve the old rtl. */
2238 /* Clean out any memory we had of the old declaration. */
2239 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2241 TREE_VALUE (oldstatic
) = error_mark_node
;
2243 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2244 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2245 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2246 TREE_NOTHROW (olddecl
) = TREE_NOTHROW (newdecl
);
2247 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2250 /* Merge the storage class information. */
2251 merge_weak (newdecl
, olddecl
);
2253 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2254 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2255 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2256 if (! DECL_EXTERNAL (olddecl
))
2257 DECL_EXTERNAL (newdecl
) = 0;
2258 if (! DECL_COMDAT (olddecl
))
2259 DECL_COMDAT (newdecl
) = 0;
2261 new_template_info
= NULL_TREE
;
2262 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2264 bool new_redefines_gnu_inline
= false;
2266 if (new_defines_function
2267 && ((DECL_INTERFACE_KNOWN (olddecl
)
2268 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2269 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2270 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2271 == FUNCTION_DECL
))))
2275 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2276 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2278 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2281 if (!new_redefines_gnu_inline
)
2283 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2284 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2285 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2287 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2288 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2289 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2291 /* If the OLDDECL is an instantiation and/or specialization,
2292 then the NEWDECL must be too. But, it may not yet be marked
2293 as such if the caller has created NEWDECL, but has not yet
2294 figured out that it is a redeclaration. */
2295 if (!DECL_USE_TEMPLATE (newdecl
))
2296 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2298 /* Don't really know how much of the language-specific
2299 values we should copy from old to new. */
2300 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2301 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2302 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2303 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2305 if (LANG_DECL_HAS_MIN (newdecl
))
2307 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2308 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2309 if (DECL_TEMPLATE_INFO (newdecl
))
2311 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2312 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2313 && DECL_TEMPLATE_SPECIALIZATION (newdecl
))
2314 /* Remember the presence of explicit specialization args. */
2315 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl
))
2316 = TINFO_USED_TEMPLATE_ID (new_template_info
);
2318 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2320 /* Only functions have these fields. */
2321 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2323 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2324 DECL_BEFRIENDING_CLASSES (newdecl
)
2325 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2326 DECL_BEFRIENDING_CLASSES (olddecl
));
2327 /* DECL_THUNKS is only valid for virtual functions,
2328 otherwise it is a DECL_FRIEND_CONTEXT. */
2329 if (DECL_VIRTUAL_P (newdecl
))
2330 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2332 /* Only variables have this field. */
2333 else if (VAR_P (newdecl
)
2334 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2335 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2338 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2342 /* Merge parameter attributes. */
2343 tree oldarg
, newarg
;
2344 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2345 newarg
= DECL_ARGUMENTS(newdecl
);
2347 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2348 DECL_ATTRIBUTES (newarg
)
2349 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2350 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2353 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2354 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2356 /* If newdecl is not a specialization, then it is not a
2357 template-related function at all. And that means that we
2358 should have exited above, returning 0. */
2359 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2361 if (DECL_ODR_USED (olddecl
))
2362 /* From [temp.expl.spec]:
2364 If a template, a member template or the member of a class
2365 template is explicitly specialized then that
2366 specialization shall be declared before the first use of
2367 that specialization that would cause an implicit
2368 instantiation to take place, in every translation unit in
2369 which such a use occurs. */
2370 error ("explicit specialization of %qD after first use",
2373 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2374 DECL_COMDAT (newdecl
) = (TREE_PUBLIC (newdecl
)
2375 && DECL_DECLARED_INLINE_P (newdecl
));
2377 /* Don't propagate visibility from the template to the
2378 specialization here. We'll do that in determine_visibility if
2380 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2382 /* [temp.expl.spec/14] We don't inline explicit specialization
2383 just because the primary template says so. */
2385 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2386 the always_inline attribute. */
2387 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2388 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2390 if (DECL_DECLARED_INLINE_P (newdecl
))
2391 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2393 DECL_ATTRIBUTES (newdecl
)
2394 = remove_attribute ("always_inline",
2395 DECL_ATTRIBUTES (newdecl
));
2398 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2400 /* Never inline re-defined extern inline functions.
2401 FIXME: this could be better handled by keeping both
2402 function as separate declarations. */
2403 DECL_UNINLINABLE (newdecl
) = 1;
2407 if (DECL_PENDING_INLINE_P (olddecl
))
2409 DECL_PENDING_INLINE_P (newdecl
) = 1;
2410 DECL_PENDING_INLINE_INFO (newdecl
)
2411 = DECL_PENDING_INLINE_INFO (olddecl
);
2413 else if (DECL_PENDING_INLINE_P (newdecl
))
2415 else if (DECL_SAVED_FUNCTION_DATA (newdecl
) == NULL
)
2416 DECL_SAVED_FUNCTION_DATA (newdecl
)
2417 = DECL_SAVED_FUNCTION_DATA (olddecl
);
2419 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2421 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2422 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2424 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2425 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2426 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2427 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2430 /* Preserve abstractness on cloned [cd]tors. */
2431 DECL_ABSTRACT_P (newdecl
) = DECL_ABSTRACT_P (olddecl
);
2433 /* Update newdecl's parms to point at olddecl. */
2434 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2435 parm
= DECL_CHAIN (parm
))
2436 DECL_CONTEXT (parm
) = olddecl
;
2440 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2441 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2442 COPY_DECL_RTL (newdecl
, olddecl
);
2444 if (! types_match
|| new_defines_function
)
2446 /* These need to be copied so that the names are available.
2447 Note that if the types do match, we'll preserve inline
2448 info and other bits, but if not, we won't. */
2449 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2450 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2452 /* If redeclaring a builtin function, it stays built in
2453 if newdecl is a gnu_inline definition, or if newdecl is just
2455 if (DECL_BUILT_IN (olddecl
)
2456 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2458 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2459 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2460 /* If we're keeping the built-in definition, keep the rtl,
2461 regardless of declaration matches. */
2462 COPY_DECL_RTL (olddecl
, newdecl
);
2463 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2465 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2468 /* If a compatible prototype of these builtin functions
2469 is seen, assume the runtime implements it with the
2470 expected semantics. */
2471 case BUILT_IN_STPCPY
:
2472 if (builtin_decl_explicit_p (fncode
))
2473 set_builtin_decl_implicit_p (fncode
, true);
2476 if (builtin_decl_explicit_p (fncode
))
2477 set_builtin_decl_declared_p (fncode
, true);
2482 copy_attributes_to_builtin (newdecl
);
2484 if (new_defines_function
)
2485 /* If defining a function declared with other language
2486 linkage, use the previously declared language linkage. */
2487 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2488 else if (types_match
)
2490 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2491 /* Don't clear out the arguments if we're just redeclaring a
2493 if (DECL_ARGUMENTS (olddecl
))
2494 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2497 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2498 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2500 /* Now preserve various other info from the definition. */
2501 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2502 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2503 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2504 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2506 /* Warn about conflicting visibility specifications. */
2507 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2508 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2509 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2511 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wattributes
,
2512 "%qD: visibility attribute ignored because it "
2513 "conflicts with previous declaration", newdecl
))
2514 inform (DECL_SOURCE_LOCATION (olddecl
),
2515 "previous declaration of %qD", olddecl
);
2517 /* Choose the declaration which specified visibility. */
2518 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2520 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2521 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2523 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2524 so keep this behavior. */
2525 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2527 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2528 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2530 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2531 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2533 SET_DECL_ALIGN (newdecl
, DECL_ALIGN (olddecl
));
2534 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2536 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2537 if (DECL_WARN_IF_NOT_ALIGN (olddecl
)
2538 > DECL_WARN_IF_NOT_ALIGN (newdecl
))
2539 SET_DECL_WARN_IF_NOT_ALIGN (newdecl
,
2540 DECL_WARN_IF_NOT_ALIGN (olddecl
));
2541 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2542 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2544 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2545 with that from NEWDECL below. */
2546 if (DECL_LANG_SPECIFIC (olddecl
))
2548 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2549 != DECL_LANG_SPECIFIC (newdecl
));
2550 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2553 /* Merge the USED information. */
2554 if (TREE_USED (olddecl
))
2555 TREE_USED (newdecl
) = 1;
2556 else if (TREE_USED (newdecl
))
2557 TREE_USED (olddecl
) = 1;
2558 if (VAR_P (newdecl
))
2560 if (DECL_READ_P (olddecl
))
2561 DECL_READ_P (newdecl
) = 1;
2562 else if (DECL_READ_P (newdecl
))
2563 DECL_READ_P (olddecl
) = 1;
2565 if (DECL_PRESERVE_P (olddecl
))
2566 DECL_PRESERVE_P (newdecl
) = 1;
2567 else if (DECL_PRESERVE_P (newdecl
))
2568 DECL_PRESERVE_P (olddecl
) = 1;
2570 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2571 to olddecl and deleted. */
2572 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2573 && DECL_FUNCTION_VERSIONED (olddecl
))
2575 /* Set the flag for newdecl so that it gets copied to olddecl. */
2576 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2577 /* newdecl will be purged after copying to olddecl and is no longer
2579 cgraph_node::delete_function_version_by_decl (newdecl
);
2582 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2585 struct symtab_node
*snode
= symtab_node::get (olddecl
);
2587 function_size
= sizeof (struct tree_decl_common
);
2589 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2590 (char *) newdecl
+ sizeof (struct tree_common
),
2591 function_size
- sizeof (struct tree_common
));
2593 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2594 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2595 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2597 /* Preserve symtab node mapping. */
2598 olddecl
->decl_with_vis
.symtab_node
= snode
;
2600 if (new_template_info
)
2601 /* If newdecl is a template instantiation, it is possible that
2602 the following sequence of events has occurred:
2604 o A friend function was declared in a class template. The
2605 class template was instantiated.
2607 o The instantiation of the friend declaration was
2608 recorded on the instantiation list, and is newdecl.
2610 o Later, however, instantiate_class_template called pushdecl
2611 on the newdecl to perform name injection. But, pushdecl in
2612 turn called duplicate_decls when it discovered that another
2613 declaration of a global function with the same name already
2616 o Here, in duplicate_decls, we decided to clobber newdecl.
2618 If we're going to do that, we'd better make sure that
2619 olddecl, and not newdecl, is on the list of
2620 instantiations so that if we try to do the instantiation
2621 again we won't get the clobbered declaration. */
2622 reregister_specialization (newdecl
,
2628 size_t size
= tree_code_size (TREE_CODE (newdecl
));
2630 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2631 (char *) newdecl
+ sizeof (struct tree_common
),
2632 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2633 switch (TREE_CODE (newdecl
))
2643 struct symtab_node
*snode
= NULL
;
2646 && (TREE_STATIC (olddecl
) || TREE_PUBLIC (olddecl
)
2647 || DECL_EXTERNAL (olddecl
)))
2648 snode
= symtab_node::get (olddecl
);
2649 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2650 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2651 size
- sizeof (struct tree_decl_common
)
2652 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2653 if (VAR_P (newdecl
))
2654 olddecl
->decl_with_vis
.symtab_node
= snode
;
2658 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2659 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2660 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2661 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2666 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2668 if (DECL_EXTERNAL (olddecl
)
2669 || TREE_PUBLIC (olddecl
)
2670 || TREE_STATIC (olddecl
))
2672 /* Merge the section attribute.
2673 We want to issue an error if the sections conflict but that must be
2674 done later in decl_attributes since we are called before attributes
2676 if (DECL_SECTION_NAME (newdecl
) != NULL
)
2677 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2679 if (DECL_ONE_ONLY (newdecl
))
2681 struct symtab_node
*oldsym
, *newsym
;
2682 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2683 oldsym
= cgraph_node::get_create (olddecl
);
2685 oldsym
= varpool_node::get_create (olddecl
);
2686 newsym
= symtab_node::get (newdecl
);
2687 oldsym
->set_comdat_group (newsym
->get_comdat_group ());
2692 && CP_DECL_THREAD_LOCAL_P (newdecl
))
2694 CP_DECL_THREAD_LOCAL_P (olddecl
) = true;
2695 if (!processing_template_decl
)
2696 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2700 DECL_UID (olddecl
) = olddecl_uid
;
2702 DECL_FRIEND_P (olddecl
) = 1;
2705 DECL_ANTICIPATED (olddecl
) = 1;
2706 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2709 /* NEWDECL contains the merged attribute lists.
2710 Update OLDDECL to be the same. */
2711 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2713 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2714 so that encode_section_info has a chance to look at the new decl
2715 flags and attributes. */
2716 if (DECL_RTL_SET_P (olddecl
)
2717 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2719 && TREE_STATIC (olddecl
))))
2720 make_decl_rtl (olddecl
);
2722 /* The NEWDECL will no longer be needed. Because every out-of-class
2723 declaration of a member results in a call to duplicate_decls,
2724 freeing these nodes represents in a significant savings.
2726 Before releasing the node, be sore to remove function from symbol
2727 table that might have been inserted there to record comdat group.
2728 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2729 structure is shared in between newdecl and oldecl. */
2730 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2731 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2732 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2734 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2739 /* Remove the associated constraints for newdecl, if any, before
2740 reclaiming memory. */
2742 remove_constraints (newdecl
);
2749 /* Return zero if the declaration NEWDECL is valid
2750 when the declaration OLDDECL (assumed to be for the same name)
2751 has already been seen.
2752 Otherwise return an error message format string with a %s
2753 where the identifier should go. */
2756 redeclaration_error_message (tree newdecl
, tree olddecl
)
2758 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2760 /* Because C++ can put things into name space for free,
2761 constructs like "typedef struct foo { ... } foo"
2762 would look like an erroneous redeclaration. */
2763 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2766 return G_("redefinition of %q#D");
2768 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2770 /* If this is a pure function, its olddecl will actually be
2771 the original initialization to `0' (which we force to call
2772 abort()). Don't complain about redefinition in this case. */
2773 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2774 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2777 /* If both functions come from different namespaces, this is not
2778 a redeclaration - this is a conflict with a used function. */
2779 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2780 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2781 && ! decls_match (olddecl
, newdecl
))
2782 return G_("%qD conflicts with used function");
2784 /* We'll complain about linkage mismatches in
2785 warn_extern_redeclared_static. */
2787 /* Defining the same name twice is no good. */
2788 if (decl_defined_p (olddecl
)
2789 && decl_defined_p (newdecl
))
2791 if (DECL_NAME (olddecl
) == NULL_TREE
)
2792 return G_("%q#D not declared in class");
2793 else if (!GNU_INLINE_P (olddecl
)
2794 || GNU_INLINE_P (newdecl
))
2795 return G_("redefinition of %q#D");
2798 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2800 bool olda
= GNU_INLINE_P (olddecl
);
2801 bool newa
= GNU_INLINE_P (newdecl
);
2806 return G_("%q+D redeclared inline with "
2807 "%<gnu_inline%> attribute");
2809 return G_("%q+D redeclared inline without "
2810 "%<gnu_inline%> attribute");
2814 check_abi_tag_redeclaration
2815 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2816 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2820 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2824 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2826 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2827 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2828 return G_("redefinition of %q#D");
2832 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2833 || (DECL_TEMPLATE_RESULT (newdecl
)
2834 == DECL_TEMPLATE_RESULT (olddecl
)))
2837 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2838 if (DECL_TEMPLATE_INFO (nt
))
2839 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2840 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2841 if (DECL_TEMPLATE_INFO (ot
))
2842 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2843 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2844 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2845 return G_("redefinition of %q#D");
2847 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2849 bool olda
= GNU_INLINE_P (ot
);
2850 bool newa
= GNU_INLINE_P (nt
);
2855 return G_("%q+D redeclared inline with "
2856 "%<gnu_inline%> attribute");
2858 return G_("%q+D redeclared inline without "
2859 "%<gnu_inline%> attribute");
2863 /* Core issue #226 (C++0x):
2865 If a friend function template declaration specifies a
2866 default template-argument, that declaration shall be a
2867 definition and shall be the only declaration of the
2868 function template in the translation unit. */
2869 if ((cxx_dialect
!= cxx98
)
2870 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2871 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2872 /*is_primary=*/true,
2873 /*is_partial=*/false,
2874 /*is_friend_decl=*/2))
2875 return G_("redeclaration of friend %q#D "
2876 "may not have default template arguments");
2880 else if (VAR_P (newdecl
)
2881 && CP_DECL_THREAD_LOCAL_P (newdecl
) != CP_DECL_THREAD_LOCAL_P (olddecl
)
2882 && (! DECL_LANG_SPECIFIC (olddecl
)
2883 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2884 || CP_DECL_THREAD_LOCAL_P (newdecl
)))
2886 /* Only variables can be thread-local, and all declarations must
2887 agree on this property. */
2888 if (CP_DECL_THREAD_LOCAL_P (newdecl
))
2889 return G_("thread-local declaration of %q#D follows "
2890 "non-thread-local declaration");
2892 return G_("non-thread-local declaration of %q#D follows "
2893 "thread-local declaration");
2895 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2897 /* The objects have been declared at namespace scope. If either
2898 is a member of an anonymous union, then this is an invalid
2899 redeclaration. For example:
2905 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2906 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2907 return G_("redeclaration of %q#D");
2908 /* If at least one declaration is a reference, there is no
2909 conflict. For example:
2915 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2918 /* Static data member declared outside a class definition
2919 if the variable is defined within the class with constexpr
2920 specifier is declaration rather than definition (and
2922 if (cxx_dialect
>= cxx17
2923 && DECL_CLASS_SCOPE_P (olddecl
)
2924 && DECL_DECLARED_CONSTEXPR_P (olddecl
)
2925 && !DECL_INITIAL (newdecl
))
2927 DECL_EXTERNAL (newdecl
) = 1;
2928 /* For now, only warn with explicit -Wdeprecated. */
2929 if (global_options_set
.x_warn_deprecated
2930 && warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wdeprecated
,
2931 "redundant redeclaration of %<constexpr%> static "
2932 "data member %qD", newdecl
))
2933 inform (DECL_SOURCE_LOCATION (olddecl
),
2934 "previous declaration of %qD", olddecl
);
2938 /* Reject two definitions. */
2939 return G_("redefinition of %q#D");
2943 /* Objects declared with block scope: */
2944 /* Reject two definitions, and reject a definition
2945 together with an external reference. */
2946 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2947 return G_("redeclaration of %q#D");
2953 /* Hash and equality functions for the named_label table. */
2956 named_label_hash::hash (const value_type entry
)
2958 return IDENTIFIER_HASH_VALUE (entry
->name
);
2962 named_label_hash::equal (const value_type entry
, compare_type name
)
2964 return name
== entry
->name
;
2967 /* Look for a label named ID in the current function. If one cannot
2968 be found, create one. Return the named_label_entry, or NULL on
2971 static named_label_entry
*
2972 lookup_label_1 (tree id
, bool making_local_p
)
2974 /* You can't use labels at global scope. */
2975 if (current_function_decl
== NULL_TREE
)
2977 error ("label %qE referenced outside of any function", id
);
2982 named_labels
= hash_table
<named_label_hash
>::create_ggc (13);
2984 hashval_t hash
= IDENTIFIER_HASH_VALUE (id
);
2985 named_label_entry
**slot
2986 = named_labels
->find_slot_with_hash (id
, hash
, INSERT
);
2987 named_label_entry
*old
= *slot
;
2989 if (old
&& old
->label_decl
)
2991 if (!making_local_p
)
2994 if (old
->binding_level
== current_binding_level
)
2996 error ("local label %qE conflicts with existing label", id
);
2997 inform (DECL_SOURCE_LOCATION (old
->label_decl
), "previous label");
3002 /* We are making a new decl, create or reuse the named_label_entry */
3003 named_label_entry
*ent
= NULL
;
3004 if (old
&& !old
->label_decl
)
3008 ent
= ggc_cleared_alloc
<named_label_entry
> ();
3014 /* Now create the LABEL_DECL. */
3015 tree decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
3017 DECL_CONTEXT (decl
) = current_function_decl
;
3018 SET_DECL_MODE (decl
, VOIDmode
);
3021 C_DECLARED_LABEL_FLAG (decl
) = true;
3022 DECL_CHAIN (decl
) = current_binding_level
->names
;
3023 current_binding_level
->names
= decl
;
3026 ent
->label_decl
= decl
;
3031 /* Wrapper for lookup_label_1. */
3034 lookup_label (tree id
)
3036 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3037 named_label_entry
*ent
= lookup_label_1 (id
, false);
3038 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3039 return ent
? ent
->label_decl
: NULL_TREE
;
3043 declare_local_label (tree id
)
3045 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3046 named_label_entry
*ent
= lookup_label_1 (id
, true);
3047 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3048 return ent
? ent
->label_decl
: NULL_TREE
;
3051 /* Returns nonzero if it is ill-formed to jump past the declaration of
3052 DECL. Returns 2 if it's also a real problem. */
3055 decl_jump_unsafe (tree decl
)
3057 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3058 with automatic storage duration is not in scope to a point where it is
3059 in scope is ill-formed unless the variable has scalar type, class type
3060 with a trivial default constructor and a trivial destructor, a
3061 cv-qualified version of one of these types, or an array of one of the
3062 preceding types and is declared without an initializer (8.5). */
3063 tree type
= TREE_TYPE (decl
);
3065 if (!VAR_P (decl
) || TREE_STATIC (decl
)
3066 || type
== error_mark_node
)
3069 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
3070 || variably_modified_type_p (type
, NULL_TREE
))
3073 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3079 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3083 identify_goto (tree decl
, location_t loc
, const location_t
*locus
,
3084 diagnostic_t diag_kind
)
3087 = emit_diagnostic (diag_kind
, loc
, 0,
3088 decl
? N_("jump to label %qD")
3089 : N_("jump to case label"), decl
);
3090 if (complained
&& locus
)
3091 inform (*locus
, " from here");
3095 /* Check that a single previously seen jump to a newly defined label
3096 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3097 the jump context; NAMES are the names in scope in LEVEL at the jump
3098 context; LOCUS is the source position of the jump or 0. Returns
3099 true if all is well. */
3102 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
3103 bool exited_omp
, const location_t
*locus
)
3105 cp_binding_level
*b
;
3106 bool complained
= false;
3108 bool saw_eh
= false, saw_omp
= false, saw_tm
= false, saw_cxif
= false;
3112 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3114 inform (input_location
, " exits OpenMP structured block");
3119 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3121 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
3123 for (new_decls
= b
->names
; new_decls
!= old_decls
;
3124 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
3125 : TREE_CHAIN (new_decls
)))
3127 int problem
= decl_jump_unsafe (new_decls
);
3133 complained
= identify_goto (decl
, input_location
, locus
,
3140 inform (DECL_SOURCE_LOCATION (new_decls
),
3141 " crosses initialization of %q#D", new_decls
);
3143 inform (DECL_SOURCE_LOCATION (new_decls
),
3144 " enters scope of %q#D, which has "
3145 "non-trivial destructor", new_decls
);
3152 const char *inf
= NULL
;
3153 location_t loc
= input_location
;
3158 inf
= N_("enters try block");
3164 inf
= N_("enters catch block");
3170 inf
= N_("enters OpenMP structured block");
3174 case sk_transaction
:
3176 inf
= N_("enters synchronized or atomic statement");
3181 if (!saw_cxif
&& level_for_constexpr_if (b
->level_chain
))
3183 inf
= N_("enters constexpr if statement");
3184 loc
= EXPR_LOCATION (b
->level_chain
->this_entity
);
3196 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3199 inform (loc
, " %s", inf
);
3207 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
3209 check_previous_goto_1 (decl
, use
->binding_level
,
3210 use
->names_in_scope
, use
->in_omp_scope
,
3211 &use
->o_goto_locus
);
3215 check_switch_goto (cp_binding_level
* level
)
3217 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
3220 /* Check that a new jump to a label DECL is OK. Called by
3221 finish_goto_stmt. */
3224 check_goto (tree decl
)
3226 /* We can't know where a computed goto is jumping.
3227 So we assume that it's OK. */
3228 if (TREE_CODE (decl
) != LABEL_DECL
)
3231 /* We didn't record any information about this label when we created it,
3232 and there's not much point since it's trivial to analyze as a return. */
3233 if (decl
== cdtor_label
)
3236 hashval_t hash
= IDENTIFIER_HASH_VALUE (DECL_NAME (decl
));
3237 named_label_entry
**slot
3238 = named_labels
->find_slot_with_hash (DECL_NAME (decl
), hash
, NO_INSERT
);
3239 named_label_entry
*ent
= *slot
;
3241 /* If the label hasn't been defined yet, defer checking. */
3242 if (! DECL_INITIAL (decl
))
3244 /* Don't bother creating another use if the last goto had the
3245 same data, and will therefore create the same set of errors. */
3247 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
3250 named_label_use_entry
*new_use
3251 = ggc_alloc
<named_label_use_entry
> ();
3252 new_use
->binding_level
= current_binding_level
;
3253 new_use
->names_in_scope
= current_binding_level
->names
;
3254 new_use
->o_goto_locus
= input_location
;
3255 new_use
->in_omp_scope
= false;
3257 new_use
->next
= ent
->uses
;
3258 ent
->uses
= new_use
;
3262 bool saw_catch
= false, complained
= false;
3267 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_transaction_scope
3268 || ent
->in_constexpr_if
3269 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
3271 diagnostic_t diag_kind
= DK_PERMERROR
;
3272 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_constexpr_if
3273 || ent
->in_transaction_scope
|| ent
->in_omp_scope
)
3274 diag_kind
= DK_ERROR
;
3275 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3276 &input_location
, diag_kind
);
3277 identified
= 1 + (diag_kind
== DK_ERROR
);
3280 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
3282 int u
= decl_jump_unsafe (bad
);
3284 if (u
> 1 && DECL_ARTIFICIAL (bad
))
3286 /* Can't skip init of __exception_info. */
3287 if (identified
== 1)
3289 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3290 &input_location
, DK_ERROR
);
3294 inform (DECL_SOURCE_LOCATION (bad
), " enters catch block");
3297 else if (complained
)
3300 inform (DECL_SOURCE_LOCATION (bad
),
3301 " skips initialization of %q#D", bad
);
3303 inform (DECL_SOURCE_LOCATION (bad
),
3304 " enters scope of %q#D which has "
3305 "non-trivial destructor", bad
);
3311 if (ent
->in_try_scope
)
3312 inform (input_location
, " enters try block");
3313 else if (ent
->in_catch_scope
&& !saw_catch
)
3314 inform (input_location
, " enters catch block");
3315 else if (ent
->in_transaction_scope
)
3316 inform (input_location
, " enters synchronized or atomic statement");
3317 else if (ent
->in_constexpr_if
)
3318 inform (input_location
, " enters constexpr if statement");
3321 if (ent
->in_omp_scope
)
3324 inform (input_location
, " enters OpenMP structured block");
3326 else if (flag_openmp
)
3327 for (cp_binding_level
*b
= current_binding_level
; b
; b
= b
->level_chain
)
3329 if (b
== ent
->binding_level
)
3331 if (b
->kind
== sk_omp
)
3335 complained
= identify_goto (decl
,
3336 DECL_SOURCE_LOCATION (decl
),
3337 &input_location
, DK_ERROR
);
3341 inform (input_location
, " exits OpenMP structured block");
3347 /* Check that a return is ok wrt OpenMP structured blocks.
3348 Called by finish_return_stmt. Returns true if all is well. */
3351 check_omp_return (void)
3353 for (cp_binding_level
*b
= current_binding_level
; b
; b
= b
->level_chain
)
3354 if (b
->kind
== sk_omp
)
3356 error ("invalid exit from OpenMP structured block");
3359 else if (b
->kind
== sk_function_parms
)
3364 /* Define a label, specifying the location in the source file.
3365 Return the LABEL_DECL node for the label. */
3368 define_label_1 (location_t location
, tree name
)
3370 /* After labels, make any new cleanups in the function go into their
3371 own new (temporary) binding contour. */
3372 for (cp_binding_level
*p
= current_binding_level
;
3373 p
->kind
!= sk_function_parms
;
3375 p
->more_cleanups_ok
= 0;
3377 named_label_entry
*ent
= lookup_label_1 (name
, false);
3378 tree decl
= ent
->label_decl
;
3380 if (DECL_INITIAL (decl
) != NULL_TREE
)
3382 error ("duplicate label %qD", decl
);
3383 return error_mark_node
;
3387 /* Mark label as having been defined. */
3388 DECL_INITIAL (decl
) = error_mark_node
;
3389 /* Say where in the source. */
3390 DECL_SOURCE_LOCATION (decl
) = location
;
3392 ent
->binding_level
= current_binding_level
;
3393 ent
->names_in_scope
= current_binding_level
->names
;
3395 for (named_label_use_entry
*use
= ent
->uses
; use
; use
= use
->next
)
3396 check_previous_goto (decl
, use
);
3403 /* Wrapper for define_label_1. */
3406 define_label (location_t location
, tree name
)
3408 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3409 tree ret
= define_label_1 (location
, name
);
3410 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3417 cp_binding_level
*level
;
3418 struct cp_switch
*next
;
3419 /* The SWITCH_STMT being built. */
3421 /* A splay-tree mapping the low element of a case range to the high
3422 element, or NULL_TREE if there is no high element. Used to
3423 determine whether or not a new case label duplicates an old case
3424 label. We need a tree, rather than simply a hash table, because
3425 of the GNU case range extension. */
3427 /* Remember whether there was a case value that is outside the
3428 range of the original type of the controlling expression. */
3429 bool outside_range_p
;
3432 /* A stack of the currently active switch statements. The innermost
3433 switch statement is on the top of the stack. There is no need to
3434 mark the stack for garbage collection because it is only active
3435 during the processing of the body of a function, and we never
3436 collect at that point. */
3438 static struct cp_switch
*switch_stack
;
3440 /* Called right after a switch-statement condition is parsed.
3441 SWITCH_STMT is the switch statement being parsed. */
3444 push_switch (tree switch_stmt
)
3446 struct cp_switch
*p
= XNEW (struct cp_switch
);
3447 p
->level
= current_binding_level
;
3448 p
->next
= switch_stack
;
3449 p
->switch_stmt
= switch_stmt
;
3450 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3451 p
->outside_range_p
= false;
3458 struct cp_switch
*cs
= switch_stack
;
3459 location_t switch_location
;
3461 /* Emit warnings as needed. */
3462 switch_location
= EXPR_LOC_OR_LOC (cs
->switch_stmt
, input_location
);
3463 const bool bool_cond_p
3464 = (SWITCH_STMT_TYPE (cs
->switch_stmt
)
3465 && TREE_CODE (SWITCH_STMT_TYPE (cs
->switch_stmt
)) == BOOLEAN_TYPE
);
3466 if (!processing_template_decl
)
3467 c_do_switch_warnings (cs
->cases
, switch_location
,
3468 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3469 SWITCH_STMT_COND (cs
->switch_stmt
),
3470 bool_cond_p
, cs
->outside_range_p
);
3472 splay_tree_delete (cs
->cases
);
3473 switch_stack
= switch_stack
->next
;
3477 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3478 condition. Note that if TYPE and VALUE are already integral we don't
3479 really do the conversion because the language-independent
3480 warning/optimization code will work better that way. */
3483 case_conversion (tree type
, tree value
)
3485 if (value
== NULL_TREE
)
3488 if (cxx_dialect
>= cxx11
3489 && (SCOPED_ENUM_P (type
)
3490 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3492 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3493 type
= type_promotes_to (type
);
3494 value
= (perform_implicit_conversion_flags
3495 (type
, value
, tf_warning_or_error
,
3496 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3498 return cxx_constant_value (value
);
3501 /* Note that we've seen a definition of a case label, and complain if this
3502 is a bad place for one. */
3505 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3508 cp_binding_level
*p
;
3511 if (processing_template_decl
)
3515 /* For templates, just add the case label; we'll do semantic
3516 analysis at instantiation-time. */
3517 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3518 return add_stmt (build_case_label (low_value
, high_value
, label
));
3521 /* Find the condition on which this switch statement depends. */
3522 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3523 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3524 cond
= TREE_VALUE (cond
);
3526 if (!check_switch_goto (switch_stack
->level
))
3527 return error_mark_node
;
3529 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3531 low_value
= case_conversion (type
, low_value
);
3532 high_value
= case_conversion (type
, high_value
);
3534 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3535 low_value
, high_value
,
3536 &switch_stack
->outside_range_p
);
3538 /* After labels, make any new cleanups in the function go into their
3539 own new (temporary) binding contour. */
3540 for (p
= current_binding_level
;
3541 p
->kind
!= sk_function_parms
;
3543 p
->more_cleanups_ok
= 0;
3548 struct typename_info
{
3556 struct typename_hasher
: ggc_ptr_hash
<tree_node
>
3558 typedef typename_info
*compare_type
;
3560 /* Hash a TYPENAME_TYPE. */
3567 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3568 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3573 /* Compare two TYPENAME_TYPEs. */
3576 equal (tree t1
, const typename_info
*t2
)
3578 return (TYPE_IDENTIFIER (t1
) == t2
->name
3579 && TYPE_CONTEXT (t1
) == t2
->scope
3580 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3581 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3582 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3586 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3587 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3589 Returns the new TYPENAME_TYPE. */
3591 static GTY (()) hash_table
<typename_hasher
> *typename_htab
;
3594 build_typename_type (tree context
, tree name
, tree fullname
,
3595 enum tag_types tag_type
)
3603 if (typename_htab
== NULL
)
3604 typename_htab
= hash_table
<typename_hasher
>::create_ggc (61);
3606 ti
.scope
= FROB_CONTEXT (context
);
3608 ti
.template_id
= fullname
;
3609 ti
.enum_p
= tag_type
== enum_type
;
3610 ti
.class_p
= (tag_type
== class_type
3611 || tag_type
== record_type
3612 || tag_type
== union_type
);
3613 hash
= (htab_hash_pointer (ti
.scope
)
3614 ^ htab_hash_pointer (ti
.name
));
3616 /* See if we already have this type. */
3617 e
= typename_htab
->find_slot_with_hash (&ti
, hash
, INSERT
);
3622 /* Build the TYPENAME_TYPE. */
3623 t
= cxx_make_type (TYPENAME_TYPE
);
3624 TYPE_CONTEXT (t
) = ti
.scope
;
3625 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3626 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3627 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3629 /* Build the corresponding TYPE_DECL. */
3630 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3631 TYPE_NAME (TREE_TYPE (d
)) = d
;
3632 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3633 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3634 DECL_ARTIFICIAL (d
) = 1;
3636 /* Store it in the hash table. */
3639 /* TYPENAME_TYPEs must always be compared structurally, because
3640 they may or may not resolve down to another type depending on
3641 the currently open classes. */
3642 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3648 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3649 provided to name the type. Returns an appropriate type, unless an
3650 error occurs, in which case error_mark_node is returned. If we
3651 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3652 return that, rather than the _TYPE it corresponds to, in other
3653 cases we look through the type decl. If TF_ERROR is set, complain
3654 about errors, otherwise be quiet. */
3657 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3658 tsubst_flags_t complain
)
3664 if (name
== error_mark_node
3665 || context
== NULL_TREE
3666 || context
== error_mark_node
)
3667 return error_mark_node
;
3671 if (!(TYPE_LANG_SPECIFIC (name
)
3672 && (CLASSTYPE_IS_TEMPLATE (name
)
3673 || CLASSTYPE_USE_TEMPLATE (name
))))
3674 name
= TYPE_IDENTIFIER (name
);
3676 /* Create a TEMPLATE_ID_EXPR for the type. */
3677 name
= build_nt (TEMPLATE_ID_EXPR
,
3678 CLASSTYPE_TI_TEMPLATE (name
),
3679 CLASSTYPE_TI_ARGS (name
));
3681 else if (TREE_CODE (name
) == TYPE_DECL
)
3682 name
= DECL_NAME (name
);
3686 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3688 name
= TREE_OPERAND (name
, 0);
3689 if (DECL_TYPE_TEMPLATE_P (name
))
3690 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3691 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
3693 if (complain
& tf_error
)
3694 error ("%qD is not a type", name
);
3695 return error_mark_node
;
3698 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3700 if (complain
& tf_error
)
3701 error ("%qD used without template parameters", name
);
3702 return error_mark_node
;
3704 gcc_assert (identifier_p (name
));
3705 gcc_assert (TYPE_P (context
));
3707 if (!MAYBE_CLASS_TYPE_P (context
))
3709 if (complain
& tf_error
)
3710 error ("%q#T is not a class", context
);
3711 return error_mark_node
;
3714 /* When the CONTEXT is a dependent type, NAME could refer to a
3715 dependent base class of CONTEXT. But look inside it anyway
3716 if CONTEXT is a currently open scope, in case it refers to a
3717 member of the current instantiation or a non-dependent base;
3718 lookup will stop when we hit a dependent base. */
3719 if (!dependent_scope_p (context
))
3720 /* We should only set WANT_TYPE when we're a nested typename type.
3721 Then we can give better diagnostics if we find a non-type. */
3722 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3726 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3727 return build_typename_type (context
, name
, fullname
, tag_type
);
3729 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3733 if (complain
& tf_error
)
3735 if (!COMPLETE_TYPE_P (context
))
3736 cxx_incomplete_type_error (NULL_TREE
, context
);
3738 error (want_template
? G_("no class template named %q#T in %q#T")
3739 : G_("no type named %q#T in %q#T"), name
, context
);
3741 return error_mark_node
;
3744 /* Pull out the template from an injected-class-name (or multiple). */
3746 t
= maybe_get_template_decl_from_type_decl (t
);
3748 if (TREE_CODE (t
) == TREE_LIST
)
3750 if (complain
& tf_error
)
3752 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3753 print_candidates (t
);
3755 return error_mark_node
;
3758 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3760 if (complain
& tf_error
)
3761 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3763 return error_mark_node
;
3765 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3767 if (complain
& tf_error
)
3768 error ("%<typename %T::%D%> names %q#T, which is not a type",
3770 return error_mark_node
;
3773 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3774 return error_mark_node
;
3776 /* If we are currently parsing a template and if T is a typedef accessed
3777 through CONTEXT then we need to remember and check access of T at
3778 template instantiation time. */
3779 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3782 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3784 /*entering_scope=*/0,
3785 complain
| tf_user
);
3787 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3790 maybe_record_typedef_use (t
);
3795 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3796 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3797 in which case error_mark_node is returned.
3799 If PARM_LIST is non-NULL, also make sure that the template parameter
3800 list of TEMPLATE_DECL matches.
3802 If COMPLAIN zero, don't complain about any errors that occur. */
3805 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3806 tsubst_flags_t complain
)
3812 name
= TYPE_IDENTIFIER (name
);
3813 else if (DECL_P (name
))
3814 name
= DECL_NAME (name
);
3815 gcc_assert (identifier_p (name
));
3817 if (!dependent_type_p (context
)
3818 || currently_open_class (context
))
3820 tree tmpl
= NULL_TREE
;
3822 if (MAYBE_CLASS_TYPE_P (context
))
3823 tmpl
= lookup_field (context
, name
, 0, false);
3825 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3826 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3828 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3830 if (complain
& tf_error
)
3831 error ("no class template named %q#T in %q#T", name
, context
);
3832 return error_mark_node
;
3836 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3838 if (complain
& tf_error
)
3840 error ("template parameters do not match template %qD", tmpl
);
3841 inform (DECL_SOURCE_LOCATION (tmpl
),
3842 "%qD declared here", tmpl
);
3844 return error_mark_node
;
3847 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3849 return error_mark_node
;
3854 /* Build the UNBOUND_CLASS_TEMPLATE. */
3855 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3856 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3857 TREE_TYPE (t
) = NULL_TREE
;
3858 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3860 /* Build the corresponding TEMPLATE_DECL. */
3861 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3862 TYPE_NAME (TREE_TYPE (d
)) = d
;
3863 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3864 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3865 DECL_ARTIFICIAL (d
) = 1;
3866 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3873 /* Push the declarations of builtin types into the global namespace.
3874 RID_INDEX is the index of the builtin type in the array
3875 RID_POINTERS. NAME is the name used when looking up the builtin
3876 type. TYPE is the _TYPE node for the builtin type.
3878 The calls to set_global_binding below should be
3879 eliminated. Built-in types should not be looked up name; their
3880 names are keywords that the parser can recognize. However, there
3881 is code in c-common.c that uses identifier_global_value to look up
3882 built-in types by name. */
3885 record_builtin_type (enum rid rid_index
,
3889 tree decl
= NULL_TREE
;
3893 tree tname
= get_identifier (name
);
3894 tree tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3895 DECL_ARTIFICIAL (tdecl
) = 1;
3896 set_global_binding (tdecl
);
3900 if ((int) rid_index
< (int) RID_MAX
)
3901 if (tree rname
= ridpointers
[(int) rid_index
])
3902 if (!decl
|| DECL_NAME (decl
) != rname
)
3904 tree rdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3905 DECL_ARTIFICIAL (rdecl
) = 1;
3906 set_global_binding (rdecl
);
3913 if (!TYPE_NAME (type
))
3914 TYPE_NAME (type
) = decl
;
3915 debug_hooks
->type_decl (decl
, 0);
3919 /* Push a type into the namespace so that the back ends ignore it. */
3922 record_unknown_type (tree type
, const char* name
)
3924 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3925 TYPE_DECL
, get_identifier (name
), type
));
3926 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3927 DECL_IGNORED_P (decl
) = 1;
3928 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3929 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3930 SET_TYPE_ALIGN (type
, 1);
3931 TYPE_USER_ALIGN (type
) = 0;
3932 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3935 /* Create all the predefined identifiers. */
3938 initialize_predefined_identifiers (void)
3940 struct predefined_identifier
3942 const char *name
; /* Name. */
3943 tree
*node
; /* Node to store it in. */
3944 cp_identifier_kind kind
; /* Kind of identifier. */
3947 /* A table of identifiers to create at startup. */
3948 static const predefined_identifier predefined_identifiers
[] = {
3949 {"C++", &lang_name_cplusplus
, cik_normal
},
3950 {"C", &lang_name_c
, cik_normal
},
3951 /* Some of these names have a trailing space so that it is
3952 impossible for them to conflict with names written by users. */
3953 {"__ct ", &ctor_identifier
, cik_ctor
},
3954 {"__ct_base ", &base_ctor_identifier
, cik_ctor
},
3955 {"__ct_comp ", &complete_ctor_identifier
, cik_ctor
},
3956 {"__dt ", &dtor_identifier
, cik_dtor
},
3957 {"__dt_base ", &base_dtor_identifier
, cik_dtor
},
3958 {"__dt_comp ", &complete_dtor_identifier
, cik_dtor
},
3959 {"__dt_del ", &deleting_dtor_identifier
, cik_dtor
},
3960 {"__conv_op ", &conv_op_identifier
, cik_conv_op
},
3961 {"__in_chrg", &in_charge_identifier
, cik_normal
},
3962 {"this", &this_identifier
, cik_normal
},
3963 {"__delta", &delta_identifier
, cik_normal
},
3964 {"__pfn", &pfn_identifier
, cik_normal
},
3965 {"_vptr", &vptr_identifier
, cik_normal
},
3966 {"__vtt_parm", &vtt_parm_identifier
, cik_normal
},
3967 {"::", &global_identifier
, cik_normal
},
3968 {"std", &std_identifier
, cik_normal
},
3969 /* The demangler expects anonymous namespaces to be called
3970 something starting with '_GLOBAL__N_'. It no longer needs
3971 to be unique to the TU. */
3972 {"_GLOBAL__N_1", &anon_identifier
, cik_normal
},
3973 {"auto", &auto_identifier
, cik_normal
},
3974 {"decltype(auto)", &decltype_auto_identifier
, cik_normal
},
3975 {"initializer_list", &init_list_identifier
, cik_normal
},
3976 {NULL
, NULL
, cik_normal
}
3979 for (const predefined_identifier
*pid
= predefined_identifiers
;
3982 *pid
->node
= get_identifier (pid
->name
);
3983 /* Some of these identifiers already have a special kind. */
3984 if (pid
->kind
!= cik_normal
)
3985 set_identifier_kind (*pid
->node
, pid
->kind
);
3989 /* Create the predefined scalar types of C,
3990 and some nodes representing standard constants (0, 1, (void *)0).
3991 Initialize the global binding level.
3992 Make definitions for built-in primitive functions. */
3995 cxx_init_decl_processing (void)
3998 tree void_ftype_ptr
;
4000 /* Create all the identifiers we need. */
4001 initialize_predefined_identifiers ();
4003 /* Create the global variables. */
4004 push_to_top_level ();
4006 current_function_decl
= NULL_TREE
;
4007 current_binding_level
= NULL
;
4008 /* Enter the global namespace. */
4009 gcc_assert (global_namespace
== NULL_TREE
);
4010 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_identifier
,
4012 TREE_PUBLIC (global_namespace
) = 1;
4013 DECL_CONTEXT (global_namespace
)
4014 = build_translation_unit_decl (get_identifier (main_input_filename
));
4015 debug_hooks
->register_main_translation_unit
4016 (DECL_CONTEXT (global_namespace
));
4017 begin_scope (sk_namespace
, global_namespace
);
4018 current_namespace
= global_namespace
;
4020 if (flag_visibility_ms_compat
)
4021 default_visibility
= VISIBILITY_HIDDEN
;
4024 current_lang_name
= lang_name_c
;
4026 /* Create the `std' namespace. */
4027 push_namespace (std_identifier
);
4028 std_node
= current_namespace
;
4031 flag_noexcept_type
= (cxx_dialect
>= cxx17
);
4033 c_common_nodes_and_builtins ();
4035 integer_two_node
= build_int_cst (NULL_TREE
, 2);
4037 /* Guess at the initial static decls size. */
4038 vec_alloc (static_decls
, 500);
4040 /* ... and keyed classes. */
4041 vec_alloc (keyed_classes
, 100);
4043 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
4044 truthvalue_type_node
= boolean_type_node
;
4045 truthvalue_false_node
= boolean_false_node
;
4046 truthvalue_true_node
= boolean_true_node
;
4048 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
4049 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
4050 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
4051 noexcept_deferred_spec
= build_tree_list (make_node (DEFERRED_NOEXCEPT
),
4055 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
4058 delta_type_node
= ptrdiff_type_node
;
4059 vtable_index_type
= ptrdiff_type_node
;
4061 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
4062 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
4063 void_ftype_ptr
= build_function_type_list (void_type_node
,
4064 ptr_type_node
, NULL_TREE
);
4066 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
4068 /* Create the conversion operator marker. This operator's DECL_NAME
4069 is in the identifier table, so we can use identifier equality to
4071 conv_op_marker
= build_lang_decl (FUNCTION_DECL
, conv_op_identifier
,
4074 /* C++ extensions */
4076 unknown_type_node
= make_node (LANG_TYPE
);
4077 record_unknown_type (unknown_type_node
, "unknown type");
4079 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4080 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
4082 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4084 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
4085 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
4087 init_list_type_node
= make_node (LANG_TYPE
);
4088 record_unknown_type (init_list_type_node
, "init list");
4091 /* Make sure we get a unique function type, so we can give
4092 its pointer type a name. (This wins for gdb.) */
4093 tree vfunc_type
= make_node (FUNCTION_TYPE
);
4094 TREE_TYPE (vfunc_type
) = integer_type_node
;
4095 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
4096 layout_type (vfunc_type
);
4098 vtable_entry_type
= build_pointer_type (vfunc_type
);
4100 record_builtin_type (RID_MAX
, "__vtbl_ptr_type", vtable_entry_type
);
4103 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
4104 layout_type (vtbl_type_node
);
4105 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
4106 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
4107 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
4108 layout_type (vtbl_ptr_type_node
);
4109 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
4111 push_namespace (get_identifier ("__cxxabiv1"));
4112 abi_node
= current_namespace
;
4115 global_type_node
= make_node (LANG_TYPE
);
4116 record_unknown_type (global_type_node
, "global type");
4118 any_targ_node
= make_node (LANG_TYPE
);
4119 record_unknown_type (any_targ_node
, "any type");
4122 current_lang_name
= lang_name_cplusplus
;
4124 if (aligned_new_threshold
> 1
4125 && !pow2p_hwi (aligned_new_threshold
))
4127 error ("-faligned-new=%d is not a power of two", aligned_new_threshold
);
4128 aligned_new_threshold
= 1;
4130 if (aligned_new_threshold
== -1)
4131 aligned_new_threshold
= (cxx_dialect
>= cxx17
) ? 1 : 0;
4132 if (aligned_new_threshold
== 1)
4133 aligned_new_threshold
= malloc_alignment () / BITS_PER_UNIT
;
4136 tree newattrs
, extvisattr
;
4137 tree newtype
, deltype
;
4138 tree ptr_ftype_sizetype
;
4142 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
4143 if (cxx_dialect
== cxx98
)
4146 tree bad_alloc_type_node
;
4147 tree bad_alloc_decl
;
4149 push_namespace (std_identifier
);
4150 bad_alloc_id
= get_identifier ("bad_alloc");
4151 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
4152 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
4154 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
4155 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
4159 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
4162 new_eh_spec
= noexcept_false_spec
;
4164 /* Ensure attribs.c is initialized. */
4167 /* Ensure constraint.cc is initialized. */
4168 init_constraint_processing ();
4170 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
4172 newattrs
= tree_cons (get_identifier ("alloc_size"),
4173 build_tree_list (NULL_TREE
, integer_one_node
),
4175 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
4176 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4177 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
4178 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4179 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4180 DECL_IS_MALLOC (opnew
) = 1;
4181 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4182 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4183 DECL_IS_MALLOC (opnew
) = 1;
4184 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4185 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4186 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4187 if (flag_sized_deallocation
)
4189 /* Also push the sized deallocation variants:
4190 void operator delete(void*, std::size_t) throw();
4191 void operator delete[](void*, std::size_t) throw(); */
4192 tree void_ftype_ptr_size
4193 = build_function_type_list (void_type_node
, ptr_type_node
,
4194 size_type_node
, NULL_TREE
);
4195 deltype
= cp_build_type_attribute_variant (void_ftype_ptr_size
,
4197 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4198 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4199 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4202 if (aligned_new_threshold
)
4204 push_namespace (std_identifier
);
4205 tree align_id
= get_identifier ("align_val_t");
4206 align_type_node
= start_enum (align_id
, NULL_TREE
, size_type_node
,
4207 NULL_TREE
, /*scoped*/true, NULL
);
4210 /* operator new (size_t, align_val_t); */
4211 newtype
= build_function_type_list (ptr_type_node
, size_type_node
,
4212 align_type_node
, NULL_TREE
);
4213 newtype
= cp_build_type_attribute_variant (newtype
, newattrs
);
4214 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4215 opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4216 DECL_IS_MALLOC (opnew
) = 1;
4217 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4218 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4219 DECL_IS_MALLOC (opnew
) = 1;
4220 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4222 /* operator delete (void *, align_val_t); */
4223 deltype
= build_function_type_list (void_type_node
, ptr_type_node
,
4224 align_type_node
, NULL_TREE
);
4225 deltype
= cp_build_type_attribute_variant (deltype
, extvisattr
);
4226 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4227 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4228 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4230 if (flag_sized_deallocation
)
4232 /* operator delete (void *, size_t, align_val_t); */
4233 deltype
= build_function_type_list (void_type_node
, ptr_type_node
,
4234 size_type_node
, align_type_node
,
4236 deltype
= cp_build_type_attribute_variant (deltype
, extvisattr
);
4237 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4238 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4239 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4243 nullptr_type_node
= make_node (NULLPTR_TYPE
);
4244 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
4245 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
4246 TYPE_UNSIGNED (nullptr_type_node
) = 1;
4247 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
4248 if (abi_version_at_least (9))
4249 SET_TYPE_ALIGN (nullptr_type_node
, GET_MODE_ALIGNMENT (ptr_mode
));
4250 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
4251 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
4252 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
4256 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
4257 ECF_NORETURN
| ECF_NOTHROW
| ECF_COLD
);
4259 /* Perform other language dependent initializations. */
4260 init_class_processing ();
4261 init_rtti_processing ();
4262 init_template_processing ();
4264 if (flag_exceptions
)
4265 init_exception_processing ();
4267 if (! supports_one_only ())
4270 make_fname_decl
= cp_make_fname_decl
;
4271 start_fname_decls ();
4273 /* Show we use EH for cleanups. */
4274 if (flag_exceptions
)
4275 using_eh_for_cleanups ();
4278 /* Generate an initializer for a function naming variable from
4279 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4280 filled in with the type of the init. */
4283 cp_fname_init (const char* name
, tree
*type_p
)
4285 tree domain
= NULL_TREE
;
4287 tree init
= NULL_TREE
;
4292 length
= strlen (name
);
4293 domain
= build_index_type (size_int (length
));
4294 init
= build_string (length
+ 1, name
);
4297 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
4298 type
= build_cplus_array_type (type
, domain
);
4303 TREE_TYPE (init
) = type
;
4305 init
= error_mark_node
;
4310 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4311 the decl, LOC is the location to give the decl, NAME is the
4312 initialization string and TYPE_DEP indicates whether NAME depended
4313 on the type of the function. We make use of that to detect
4314 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4315 at the point of first use, so we mustn't push the decl now. */
4318 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4320 const char *const name
= (type_dep
&& processing_template_decl
4321 ? NULL
: fname_as_string (type_dep
));
4323 tree init
= cp_fname_init (name
, &type
);
4324 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4327 free (CONST_CAST (char *, name
));
4329 TREE_STATIC (decl
) = 1;
4330 TREE_READONLY (decl
) = 1;
4331 DECL_ARTIFICIAL (decl
) = 1;
4333 TREE_USED (decl
) = 1;
4335 if (current_function_decl
)
4337 DECL_CONTEXT (decl
) = current_function_decl
;
4338 decl
= pushdecl_outermost_localscope (decl
);
4339 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
4340 LOOKUP_ONLYCONVERTING
);
4344 DECL_THIS_STATIC (decl
) = true;
4345 pushdecl_top_level_and_finish (decl
, init
);
4352 builtin_function_1 (tree decl
, tree context
, bool is_global
)
4354 tree id
= DECL_NAME (decl
);
4355 const char *name
= IDENTIFIER_POINTER (id
);
4357 retrofit_lang_decl (decl
);
4359 DECL_ARTIFICIAL (decl
) = 1;
4360 SET_DECL_LANGUAGE (decl
, lang_c
);
4361 /* Runtime library routines are, by definition, available in an
4362 external shared object. */
4363 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4364 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4366 DECL_CONTEXT (decl
) = context
;
4368 /* A function in the user's namespace should have an explicit
4369 declaration before it is used. Mark the built-in function as
4370 anticipated but not actually declared. */
4371 if (name
[0] != '_' || name
[1] != '_')
4372 DECL_ANTICIPATED (decl
) = 1;
4373 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4375 size_t len
= strlen (name
);
4377 /* Treat __*_chk fortification functions as anticipated as well,
4378 unless they are __builtin_*. */
4379 if (len
> strlen ("___chk")
4380 && memcmp (name
+ len
- strlen ("_chk"),
4381 "_chk", strlen ("_chk") + 1) == 0)
4382 DECL_ANTICIPATED (decl
) = 1;
4386 pushdecl_top_level (decl
);
4394 cxx_builtin_function (tree decl
)
4396 tree id
= DECL_NAME (decl
);
4397 const char *name
= IDENTIFIER_POINTER (id
);
4398 /* All builtins that don't begin with an '_' should additionally
4399 go in the 'std' namespace. */
4402 tree decl2
= copy_node(decl
);
4403 push_namespace (std_identifier
);
4404 builtin_function_1 (decl2
, std_node
, false);
4408 return builtin_function_1 (decl
, NULL_TREE
, false);
4411 /* Like cxx_builtin_function, but guarantee the function is added to the global
4412 scope. This is to allow function specific options to add new machine
4413 dependent builtins when the target ISA changes via attribute((target(...)))
4414 which saves space on program startup if the program does not use non-generic
4418 cxx_builtin_function_ext_scope (tree decl
)
4421 tree id
= DECL_NAME (decl
);
4422 const char *name
= IDENTIFIER_POINTER (id
);
4423 /* All builtins that don't begin with an '_' should additionally
4424 go in the 'std' namespace. */
4427 tree decl2
= copy_node(decl
);
4428 push_namespace (std_identifier
);
4429 builtin_function_1 (decl2
, std_node
, true);
4433 return builtin_function_1 (decl
, NULL_TREE
, true);
4436 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4437 function. Not called directly. */
4440 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4443 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4444 DECL_EXTERNAL (fn
) = 1;
4445 TREE_PUBLIC (fn
) = 1;
4446 DECL_ARTIFICIAL (fn
) = 1;
4447 DECL_OVERLOADED_OPERATOR_CODE_RAW (fn
)
4448 = OVL_OP_INFO (false, operator_code
)->ovl_op_code
;
4449 SET_DECL_LANGUAGE (fn
, lang_c
);
4450 /* Runtime library routines are, by definition, available in an
4451 external shared object. */
4452 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4453 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4454 set_call_expr_flags (fn
, ecf_flags
);
4458 /* Returns the _DECL for a library function with C++ linkage. */
4461 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4464 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4465 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4466 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4470 /* Like build_library_fn, but takes a C string instead of an
4474 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4476 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4479 /* Like build_cp_library_fn, but takes a C string instead of an
4483 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4485 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4489 /* Like build_library_fn, but also pushes the function so that we will
4490 be able to find it via get_global_binding. Also, the function
4491 may throw exceptions listed in RAISES. */
4494 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4499 type
= build_exception_variant (type
, raises
);
4501 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4502 pushdecl_top_level (fn
);
4506 /* Like build_cp_library_fn, but also pushes the function so that it
4507 will be found by normal lookup. */
4510 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4513 tree fn
= build_cp_library_fn (ovl_op_identifier (false, operator_code
),
4514 operator_code
, type
, ecf_flags
);
4517 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4521 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4525 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4527 tree type
= build_function_type (void_type_node
, parmtypes
);
4528 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4531 /* Like push_library_fn, but also note that this function throws
4532 and does not return. Used for __throw_foo and the like. */
4535 push_throw_library_fn (tree name
, tree type
)
4537 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
| ECF_COLD
);
4541 /* When we call finish_struct for an anonymous union, we create
4542 default copy constructors and such. But, an anonymous union
4543 shouldn't have such things; this function undoes the damage to the
4544 anonymous union type T.
4546 (The reason that we create the synthesized methods is that we don't
4547 distinguish `union { int i; }' from `typedef union { int i; } U'.
4548 The first is an anonymous union; the second is just an ordinary
4552 fixup_anonymous_aggr (tree t
)
4554 /* Wipe out memory of synthesized methods. */
4555 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4556 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4557 TYPE_HAS_COPY_CTOR (t
) = 0;
4558 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4559 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4560 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4562 /* Splice the implicitly generated functions out of TYPE_FIELDS. */
4563 for (tree probe
, *prev_p
= &TYPE_FIELDS (t
); (probe
= *prev_p
);)
4564 if (TREE_CODE (probe
) == FUNCTION_DECL
&& DECL_ARTIFICIAL (probe
))
4565 *prev_p
= DECL_CHAIN (probe
);
4567 prev_p
= &DECL_CHAIN (probe
);
4569 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4570 assignment operators (because they cannot have these methods themselves).
4571 For anonymous unions this is already checked because they are not allowed
4572 in any union, otherwise we have to check it. */
4573 if (TREE_CODE (t
) != UNION_TYPE
)
4577 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4578 if (TREE_CODE (field
) == FIELD_DECL
)
4580 type
= TREE_TYPE (field
);
4581 if (CLASS_TYPE_P (type
))
4583 if (TYPE_NEEDS_CONSTRUCTING (type
))
4584 error ("member %q+#D with constructor not allowed "
4585 "in anonymous aggregate", field
);
4586 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4587 error ("member %q+#D with destructor not allowed "
4588 "in anonymous aggregate", field
);
4589 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4590 error ("member %q+#D with copy assignment operator "
4591 "not allowed in anonymous aggregate", field
);
4597 /* Warn for an attribute located at LOCATION that appertains to the
4598 class type CLASS_TYPE that has not been properly placed after its
4599 class-key, in it class-specifier. */
4602 warn_misplaced_attr_for_class_type (source_location location
,
4605 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4607 if (warning_at (location
, OPT_Wattributes
,
4608 "attribute ignored in declaration "
4609 "of %q#T", class_type
))
4611 "attribute for %q#T must follow the %qs keyword",
4612 class_type
, class_key_or_enum_as_string (class_type
));
4615 /* Make sure that a declaration with no declarator is well-formed, i.e.
4616 just declares a tagged type or anonymous union.
4618 Returns the type declared; or NULL_TREE if none. */
4621 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4622 bool explicit_type_instantiation_p
)
4624 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4625 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4626 /* If a class, struct, or enum type is declared by the DECLSPECS
4627 (i.e, if a class-specifier, enum-specifier, or non-typename
4628 elaborated-type-specifier appears in the DECLSPECS),
4629 DECLARED_TYPE is set to the corresponding type. */
4630 tree declared_type
= NULL_TREE
;
4631 bool error_p
= false;
4633 if (declspecs
->multiple_types_p
)
4634 error ("multiple types in one declaration");
4635 else if (declspecs
->redefined_builtin_type
)
4637 if (!in_system_header_at (input_location
))
4638 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4639 "redeclaration of C++ built-in type %qT",
4640 declspecs
->redefined_builtin_type
);
4645 && TYPE_P (declspecs
->type
)
4646 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4647 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4648 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4649 declared_type
= declspecs
->type
;
4650 else if (declspecs
->type
== error_mark_node
)
4652 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4653 permerror (input_location
, "declaration does not declare anything");
4654 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4656 error_at (declspecs
->locations
[ds_type_spec
],
4657 "%<auto%> can only be specified for variables "
4658 "or function declarations");
4659 return error_mark_node
;
4661 /* Check for an anonymous union. */
4662 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4663 && TYPE_UNNAMED_P (declared_type
))
4665 /* 7/3 In a simple-declaration, the optional init-declarator-list
4666 can be omitted only when declaring a class (clause 9) or
4667 enumeration (7.2), that is, when the decl-specifier-seq contains
4668 either a class-specifier, an elaborated-type-specifier with
4669 a class-key (9.1), or an enum-specifier. In these cases and
4670 whenever a class-specifier or enum-specifier is present in the
4671 decl-specifier-seq, the identifiers in these specifiers are among
4672 the names being declared by the declaration (as class-name,
4673 enum-names, or enumerators, depending on the syntax). In such
4674 cases, and except for the declaration of an unnamed bit-field (9.6),
4675 the decl-specifier-seq shall introduce one or more names into the
4676 program, or shall redeclare a name introduced by a previous
4677 declaration. [Example:
4678 enum { }; // ill-formed
4679 typedef class { }; // ill-formed
4683 error ("missing type-name in typedef-declaration");
4686 /* Anonymous unions are objects, so they can have specifiers. */;
4687 SET_ANON_AGGR_TYPE_P (declared_type
);
4689 if (TREE_CODE (declared_type
) != UNION_TYPE
4690 && !in_system_header_at (input_location
))
4691 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4696 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
4697 error_at (declspecs
->locations
[ds_inline
],
4698 "%<inline%> can only be specified for functions");
4699 else if (decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4700 error_at (declspecs
->locations
[ds_virtual
],
4701 "%<virtual%> can only be specified for functions");
4703 && (!current_class_type
4704 || current_scope () != current_class_type
))
4705 error_at (declspecs
->locations
[ds_friend
],
4706 "%<friend%> can only be specified inside a class");
4707 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4708 error_at (declspecs
->locations
[ds_explicit
],
4709 "%<explicit%> can only be specified for constructors");
4710 else if (declspecs
->storage_class
)
4711 error_at (declspecs
->locations
[ds_storage_class
],
4712 "a storage class can only be specified for objects "
4714 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
4715 error_at (declspecs
->locations
[ds_const
],
4716 "%<const%> can only be specified for objects and "
4718 else if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
4719 error_at (declspecs
->locations
[ds_volatile
],
4720 "%<volatile%> can only be specified for objects and "
4722 else if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
4723 error_at (declspecs
->locations
[ds_restrict
],
4724 "%<__restrict%> can only be specified for objects and "
4726 else if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4727 error_at (declspecs
->locations
[ds_thread
],
4728 "%<__thread%> can only be specified for objects "
4730 else if (saw_typedef
)
4731 warning_at (declspecs
->locations
[ds_typedef
], 0,
4732 "%<typedef%> was ignored in this declaration");
4733 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4734 error_at (declspecs
->locations
[ds_constexpr
],
4735 "%<constexpr%> cannot be used for type declarations");
4738 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4741 if (!CLASS_TYPE_P (declared_type
)
4742 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4743 /* For a non-template class, use the name location. */
4744 loc
= location_of (declared_type
);
4746 /* For a template class (an explicit instantiation), use the
4747 current location. */
4748 loc
= input_location
;
4750 if (explicit_type_instantiation_p
)
4751 /* [dcl.attr.grammar]/4:
4753 No attribute-specifier-seq shall appertain to an explicit
4756 if (warning_at (loc
, OPT_Wattributes
,
4757 "attribute ignored in explicit instantiation %q#T",
4760 "no attribute can be applied to "
4761 "an explicit instantiation");
4764 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4767 return declared_type
;
4770 /* Called when a declaration is seen that contains no names to declare.
4771 If its type is a reference to a structure, union or enum inherited
4772 from a containing scope, shadow that tag name for the current scope
4773 with a forward reference.
4774 If its type defines a new named structure or union
4775 or defines an enum, it is valid but we need not do anything here.
4776 Otherwise, it is an error.
4778 C++: may have to grok the declspecs to learn about static,
4779 complain for anonymous unions.
4781 Returns the TYPE declared -- or NULL_TREE if none. */
4784 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4786 tree t
= check_tag_decl (declspecs
,
4787 /*explicit_type_instantiation_p=*/false);
4792 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4795 /* This is where the variables in an anonymous union are
4796 declared. An anonymous union declaration looks like:
4798 because there is no declarator after the union, the parser
4799 sends that declaration here. */
4800 if (ANON_AGGR_TYPE_P (t
))
4802 fixup_anonymous_aggr (t
);
4804 if (TYPE_FIELDS (t
))
4806 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4807 declspecs
, NORMAL
, 0, NULL
);
4808 finish_anon_union (decl
);
4815 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4818 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4819 const cp_declarator
*declarator
,
4820 bool is_template_arg
)
4824 enum decl_context context
4825 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4826 attrs
= type_specifiers
->attributes
;
4827 type_specifiers
->attributes
= NULL_TREE
;
4828 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4829 if (attrs
&& type
!= error_mark_node
)
4831 if (CLASS_TYPE_P (type
))
4832 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4833 "outside of definition", type
);
4834 else if (MAYBE_CLASS_TYPE_P (type
))
4835 /* A template type parameter or other dependent type. */
4836 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4837 "type %qT without an associated declaration", type
);
4839 cplus_decl_attributes (&type
, attrs
, 0);
4844 /* Process a DECLARATOR for a function-scope variable declaration,
4845 namespace-scope variable declaration, or function declaration.
4846 (Function definitions go through start_function; class member
4847 declarations appearing in the body of the class go through
4848 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4849 If an error occurs, the error_mark_node is returned instead.
4851 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4852 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4853 for an explicitly defaulted function, or SD_DELETED for an explicitly
4854 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4855 implicitly initialized via a default constructor. ATTRIBUTES and
4856 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4858 The scope represented by the context of the returned DECL is pushed
4859 (if it is not the global namespace) and is assigned to
4860 *PUSHED_SCOPE_P. The caller is then responsible for calling
4861 pop_scope on *PUSHED_SCOPE_P if it is set. */
4864 start_decl (const cp_declarator
*declarator
,
4865 cp_decl_specifier_seq
*declspecs
,
4868 tree prefix_attributes
,
4869 tree
*pushed_scope_p
)
4877 *pushed_scope_p
= NULL_TREE
;
4879 /* An object declared as __attribute__((deprecated)) suppresses
4880 warnings of uses of other deprecated items. */
4881 if (lookup_attribute ("deprecated", attributes
))
4882 deprecated_state
= DEPRECATED_SUPPRESS
;
4884 attributes
= chainon (attributes
, prefix_attributes
);
4886 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4889 deprecated_state
= DEPRECATED_NORMAL
;
4891 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4892 || decl
== error_mark_node
)
4893 return error_mark_node
;
4895 context
= CP_DECL_CONTEXT (decl
);
4896 if (context
!= global_namespace
)
4897 *pushed_scope_p
= push_scope (context
);
4899 /* Is it valid for this decl to have an initializer at all?
4900 If not, set INITIALIZED to zero, which will indirectly
4901 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4903 && TREE_CODE (decl
) == TYPE_DECL
)
4905 error ("typedef %qD is initialized (use decltype instead)", decl
);
4906 return error_mark_node
;
4911 if (! toplevel_bindings_p ()
4912 && DECL_EXTERNAL (decl
))
4913 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4915 DECL_EXTERNAL (decl
) = 0;
4916 if (toplevel_bindings_p ())
4917 TREE_STATIC (decl
) = 1;
4919 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4921 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4922 record_key_method_defined (decl
);
4924 /* If this is a typedef that names the class for linkage purposes
4925 (7.1.3p8), apply any attributes directly to the type. */
4926 if (TREE_CODE (decl
) == TYPE_DECL
4927 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4928 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4929 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4933 /* Set attributes here so if duplicate decl, will have proper attributes. */
4934 cplus_decl_attributes (&decl
, attributes
, flags
);
4936 /* Dllimported symbols cannot be defined. Static data members (which
4937 can be initialized in-class and dllimported) go through grokfield,
4938 not here, so we don't need to exclude those decls when checking for
4940 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4942 error ("definition of %q#D is marked %<dllimport%>", decl
);
4943 DECL_DLLIMPORT_P (decl
) = 0;
4946 /* If #pragma weak was used, mark the decl weak now. */
4947 if (!processing_template_decl
)
4948 maybe_apply_pragma_weak (decl
);
4950 if (TREE_CODE (decl
) == FUNCTION_DECL
4951 && DECL_DECLARED_INLINE_P (decl
)
4952 && DECL_UNINLINABLE (decl
)
4953 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4954 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4955 "inline function %qD given attribute noinline", decl
);
4957 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4959 bool this_tmpl
= (processing_template_decl
4960 > template_class_depth (context
));
4963 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4964 if (field
== NULL_TREE
4965 || !(VAR_P (field
) || variable_template_p (field
)))
4966 error ("%q+#D is not a static data member of %q#T", decl
, context
);
4967 else if (variable_template_p (field
) && !this_tmpl
)
4969 if (DECL_LANG_SPECIFIC (decl
)
4970 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4971 /* OK, specialization was already checked. */;
4974 error_at (DECL_SOURCE_LOCATION (decl
),
4975 "non-member-template declaration of %qD", decl
);
4976 inform (DECL_SOURCE_LOCATION (field
), "does not match "
4977 "member template declaration here");
4978 return error_mark_node
;
4983 if (variable_template_p (field
))
4984 field
= DECL_TEMPLATE_RESULT (field
);
4986 if (DECL_CONTEXT (field
) != context
)
4988 if (!same_type_p (DECL_CONTEXT (field
), context
))
4989 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4990 "to be defined as %<%T::%D%>",
4991 DECL_CONTEXT (field
), DECL_NAME (decl
),
4992 context
, DECL_NAME (decl
));
4993 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4995 /* Static data member are tricky; an in-class initialization
4996 still doesn't provide a definition, so the in-class
4997 declaration will have DECL_EXTERNAL set, but will have an
4998 initialization. Thus, duplicate_decls won't warn
4999 about this situation, and so we check here. */
5000 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
5001 error ("duplicate initialization of %qD", decl
);
5002 field
= duplicate_decls (decl
, field
,
5003 /*newdecl_is_friend=*/false);
5004 if (field
== error_mark_node
)
5005 return error_mark_node
;
5012 tree field
= check_classfn (context
, decl
,
5014 ? current_template_parms
5016 if (field
&& field
!= error_mark_node
5017 && duplicate_decls (decl
, field
,
5018 /*newdecl_is_friend=*/false))
5022 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5023 DECL_IN_AGGR_P (decl
) = 0;
5024 /* Do not mark DECL as an explicit specialization if it was not
5025 already marked as an instantiation; a declaration should
5026 never be marked as a specialization unless we know what
5027 template is being specialized. */
5028 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
5030 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
5031 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5032 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
5033 && DECL_DECLARED_INLINE_P (decl
));
5035 DECL_COMDAT (decl
) = false;
5037 /* [temp.expl.spec] An explicit specialization of a static data
5038 member of a template is a definition if the declaration
5039 includes an initializer; otherwise, it is a declaration.
5041 We check for processing_specialization so this only applies
5042 to the new specialization syntax. */
5043 if (!initialized
&& processing_specialization
)
5044 DECL_EXTERNAL (decl
) = 1;
5047 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
5048 /* Aliases are definitions. */
5050 permerror (input_location
, "declaration of %q#D outside of class is not definition",
5054 was_public
= TREE_PUBLIC (decl
);
5056 /* Enter this declaration into the symbol table. Don't push the plain
5057 VAR_DECL for a variable template. */
5058 if (!template_parm_scope_p ()
5060 decl
= maybe_push_decl (decl
);
5062 if (processing_template_decl
)
5063 decl
= push_template_decl (decl
);
5064 if (decl
== error_mark_node
)
5065 return error_mark_node
;
5068 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
5069 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
5071 /* This is a const variable with implicit 'static'. Set
5072 DECL_THIS_STATIC so we can tell it from variables that are
5073 !TREE_PUBLIC because of the anonymous namespace. */
5074 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
5075 DECL_THIS_STATIC (decl
) = 1;
5078 if (current_function_decl
&& VAR_P (decl
)
5079 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
5082 if (CP_DECL_THREAD_LOCAL_P (decl
))
5083 error ("%qD declared %<thread_local%> in %<constexpr%> function",
5085 else if (TREE_STATIC (decl
))
5086 error ("%qD declared %<static%> in %<constexpr%> function", decl
);
5090 cp_function_chain
->invalid_constexpr
= true;
5093 if (!processing_template_decl
&& VAR_P (decl
))
5094 start_decl_1 (decl
, initialized
);
5099 /* Process the declaration of a variable DECL. INITIALIZED is true
5100 iff DECL is explicitly initialized. (INITIALIZED is false if the
5101 variable is initialized via an implicitly-called constructor.)
5102 This function must be called for ordinary variables (including, for
5103 example, implicit instantiations of templates), but must not be
5104 called for template declarations. */
5107 start_decl_1 (tree decl
, bool initialized
)
5111 bool aggregate_definition_p
;
5113 gcc_assert (!processing_template_decl
);
5115 if (error_operand_p (decl
))
5118 gcc_assert (VAR_P (decl
));
5120 type
= TREE_TYPE (decl
);
5121 complete_p
= COMPLETE_TYPE_P (type
);
5122 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
5124 /* If an explicit initializer is present, or if this is a definition
5125 of an aggregate, then we need a complete type at this point.
5126 (Scalars are always complete types, so there is nothing to
5127 check.) This code just sets COMPLETE_P; errors (if necessary)
5128 are issued below. */
5129 if ((initialized
|| aggregate_definition_p
)
5131 && COMPLETE_TYPE_P (complete_type (type
)))
5134 /* We will not yet have set TREE_READONLY on DECL if the type
5135 was "const", but incomplete, before this point. But, now, we
5136 have a complete type, so we can try again. */
5137 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
5141 /* Is it valid for this decl to have an initializer at all? */
5143 /* Don't allow initializations for incomplete types except for
5144 arrays which might be completed by the initialization. */
5146 ; /* A complete type is ok. */
5147 else if (type_uses_auto (type
))
5148 ; /* An auto type is ok. */
5149 else if (TREE_CODE (type
) != ARRAY_TYPE
)
5151 error ("variable %q#D has initializer but incomplete type", decl
);
5152 type
= TREE_TYPE (decl
) = error_mark_node
;
5154 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
5156 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
5157 error ("elements of array %q#D have incomplete type", decl
);
5158 /* else we already gave an error in start_decl. */
5161 else if (aggregate_definition_p
&& !complete_p
)
5163 if (type_uses_auto (type
))
5164 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (type
));
5167 error ("aggregate %q#D has incomplete type and cannot be defined",
5169 /* Change the type so that assemble_variable will give
5170 DECL an rtl we can live with: (mem (const_int 0)). */
5171 type
= TREE_TYPE (decl
) = error_mark_node
;
5175 /* Create a new scope to hold this declaration if necessary.
5176 Whether or not a new scope is necessary cannot be determined
5177 until after the type has been completed; if the type is a
5178 specialization of a class template it is not until after
5179 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5180 will be set correctly. */
5181 maybe_push_cleanup_level (type
);
5184 /* Handle initialization of references. DECL, TYPE, and INIT have the
5185 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5186 but will be set to a new CLEANUP_STMT if a temporary is created
5187 that must be destroyed subsequently.
5189 Returns an initializer expression to use to initialize DECL, or
5190 NULL if the initialization can be performed statically.
5192 Quotes on semantics can be found in ARM 8.4.3. */
5195 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
5197 if (init
== NULL_TREE
)
5199 if ((DECL_LANG_SPECIFIC (decl
) == 0
5200 || DECL_IN_AGGR_P (decl
) == 0)
5201 && ! DECL_THIS_EXTERN (decl
))
5202 error ("%qD declared as reference but not initialized", decl
);
5206 if (TREE_CODE (init
) == TREE_LIST
)
5207 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5208 tf_warning_or_error
);
5210 tree ttype
= TREE_TYPE (type
);
5211 if (TREE_CODE (ttype
) != ARRAY_TYPE
5212 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
5213 /* Note: default conversion is only called in very special cases. */
5214 init
= decay_conversion (init
, tf_warning_or_error
);
5216 /* check_initializer handles this for non-reference variables, but for
5217 references we need to do it here or the initializer will get the
5218 incomplete array type and confuse later calls to
5219 cp_complete_array_type. */
5220 if (TREE_CODE (ttype
) == ARRAY_TYPE
5221 && TYPE_DOMAIN (ttype
) == NULL_TREE
5222 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
5223 || TREE_CODE (init
) == STRING_CST
))
5225 cp_complete_array_type (&ttype
, init
, false);
5226 if (ttype
!= TREE_TYPE (type
))
5227 type
= cp_build_reference_type (ttype
, TYPE_REF_IS_RVALUE (type
));
5230 /* Convert INIT to the reference type TYPE. This may involve the
5231 creation of a temporary, whose lifetime must be the same as that
5232 of the reference. If so, a DECL_EXPR for the temporary will be
5233 added just after the DECL_EXPR for DECL. That's why we don't set
5234 DECL_INITIAL for local references (instead assigning to them
5235 explicitly); we need to allow the temporary to be initialized
5237 return initialize_reference (type
, init
, flags
,
5238 tf_warning_or_error
);
5241 /* Designated initializers in arrays are not supported in GNU C++.
5242 The parser cannot detect this error since it does not know whether
5243 a given brace-enclosed initializer is for a class type or for an
5244 array. This function checks that CE does not use a designated
5245 initializer. If it does, an error is issued. Returns true if CE
5246 is valid, i.e., does not have a designated initializer. */
5249 check_array_designated_initializer (constructor_elt
*ce
,
5250 unsigned HOST_WIDE_INT index
)
5252 /* Designated initializers for array elements are not supported. */
5255 /* The parser only allows identifiers as designated
5257 if (ce
->index
== error_mark_node
)
5259 error ("name used in a GNU-style designated "
5260 "initializer for an array");
5263 else if (identifier_p (ce
->index
))
5265 error ("name %qD used in a GNU-style designated "
5266 "initializer for an array", ce
->index
);
5270 tree ce_index
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
5273 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index
))
5274 && (TREE_CODE (ce_index
= maybe_constant_value (ce_index
))
5277 /* A C99 designator is OK if it matches the current index. */
5278 if (wi::to_wide (ce_index
) == index
)
5281 sorry ("non-trivial designated initializers not supported");
5284 error ("C99 designator %qE is not an integral constant-expression",
5293 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5294 array until we finish parsing the initializer. If that's the
5295 situation we're in, update DECL accordingly. */
5298 maybe_deduce_size_from_array_init (tree decl
, tree init
)
5300 tree type
= TREE_TYPE (decl
);
5302 if (TREE_CODE (type
) == ARRAY_TYPE
5303 && TYPE_DOMAIN (type
) == NULL_TREE
5304 && TREE_CODE (decl
) != TYPE_DECL
)
5306 /* do_default is really a C-ism to deal with tentative definitions.
5307 But let's leave it here to ease the eventual merge. */
5308 int do_default
= !DECL_EXTERNAL (decl
);
5309 tree initializer
= init
? init
: DECL_INITIAL (decl
);
5312 /* Check that there are no designated initializers in INIT, as
5313 those are not supported in GNU C++, and as the middle-end
5314 will crash if presented with a non-numeric designated
5316 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
5318 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
5319 constructor_elt
*ce
;
5321 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
5322 if (!check_array_designated_initializer (ce
, i
))
5328 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
5332 error_at (EXPR_LOC_OR_LOC (initializer
,
5333 DECL_SOURCE_LOCATION (decl
)),
5334 "initializer fails to determine size of %qD", decl
);
5336 else if (failure
== 2)
5340 error_at (DECL_SOURCE_LOCATION (decl
),
5341 "array size missing in %qD", decl
);
5343 /* If a `static' var's size isn't known, make it extern as
5344 well as static, so it does not get allocated. If it's not
5345 `static', then don't mark it extern; finish_incomplete_decl
5346 will give it a default size and it will get allocated. */
5347 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
5348 DECL_EXTERNAL (decl
) = 1;
5350 else if (failure
== 3)
5352 error_at (DECL_SOURCE_LOCATION (decl
),
5353 "zero-size array %qD", decl
);
5357 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
5359 relayout_decl (decl
);
5363 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5364 any appropriate error messages regarding the layout. */
5367 layout_var_decl (tree decl
)
5371 type
= TREE_TYPE (decl
);
5372 if (type
== error_mark_node
)
5375 /* If we haven't already laid out this declaration, do so now.
5376 Note that we must not call complete type for an external object
5377 because it's type might involve templates that we are not
5378 supposed to instantiate yet. (And it's perfectly valid to say
5379 `extern X x' for some incomplete type `X'.) */
5380 if (!DECL_EXTERNAL (decl
))
5381 complete_type (type
);
5382 if (!DECL_SIZE (decl
)
5383 && TREE_TYPE (decl
) != error_mark_node
5384 && complete_or_array_type_p (type
))
5385 layout_decl (decl
, 0);
5387 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
5389 /* An automatic variable with an incomplete type: that is an error.
5390 Don't talk about array types here, since we took care of that
5391 message in grokdeclarator. */
5392 error_at (DECL_SOURCE_LOCATION (decl
),
5393 "storage size of %qD isn%'t known", decl
);
5394 TREE_TYPE (decl
) = error_mark_node
;
5397 /* Keep this code around in case we later want to control debug info
5398 based on whether a type is "used". (jason 1999-11-11) */
5400 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
5401 /* Let debugger know it should output info for this type. */
5402 note_debug_info_needed (ttype
);
5404 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
5405 note_debug_info_needed (DECL_CONTEXT (decl
));
5408 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
5409 && DECL_SIZE (decl
) != NULL_TREE
5410 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
5412 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
5413 constant_expression_warning (DECL_SIZE (decl
));
5416 error_at (DECL_SOURCE_LOCATION (decl
),
5417 "storage size of %qD isn%'t constant", decl
);
5418 TREE_TYPE (decl
) = error_mark_node
;
5423 /* If a local static variable is declared in an inline function, or if
5424 we have a weak definition, we must endeavor to create only one
5425 instance of the variable at link-time. */
5428 maybe_commonize_var (tree decl
)
5430 /* Static data in a function with comdat linkage also has comdat
5432 if ((TREE_STATIC (decl
)
5433 /* Don't mess with __FUNCTION__. */
5434 && ! DECL_ARTIFICIAL (decl
)
5435 && DECL_FUNCTION_SCOPE_P (decl
)
5436 && vague_linkage_p (DECL_CONTEXT (decl
)))
5437 || (TREE_PUBLIC (decl
) && DECL_INLINE_VAR_P (decl
)))
5441 /* With weak symbols, we simply make the variable COMDAT;
5442 that will cause copies in multiple translations units to
5444 comdat_linkage (decl
);
5448 if (DECL_INITIAL (decl
) == NULL_TREE
5449 || DECL_INITIAL (decl
) == error_mark_node
)
5451 /* Without weak symbols, we can use COMMON to merge
5452 uninitialized variables. */
5453 TREE_PUBLIC (decl
) = 1;
5454 DECL_COMMON (decl
) = 1;
5458 /* While for initialized variables, we must use internal
5459 linkage -- which means that multiple copies will not
5461 TREE_PUBLIC (decl
) = 0;
5462 DECL_COMMON (decl
) = 0;
5464 if (DECL_INLINE_VAR_P (decl
))
5465 msg
= G_("sorry: semantics of inline variable "
5466 "%q#D are wrong (you%'ll wind up with "
5467 "multiple copies)");
5469 msg
= G_("sorry: semantics of inline function "
5470 "static data %q#D are wrong (you%'ll wind "
5471 "up with multiple copies)");
5472 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5474 inform (DECL_SOURCE_LOCATION (decl
),
5475 "you can work around this by removing the initializer");
5481 /* Issue an error message if DECL is an uninitialized const variable. */
5484 check_for_uninitialized_const_var (tree decl
)
5486 tree type
= strip_array_types (TREE_TYPE (decl
));
5488 /* ``Unless explicitly declared extern, a const object does not have
5489 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5492 && TREE_CODE (type
) != REFERENCE_TYPE
5493 && (CP_TYPE_CONST_P (type
) || var_in_constexpr_fn (decl
))
5494 && !DECL_INITIAL (decl
))
5496 tree field
= default_init_uninitialized_part (type
);
5500 if (CP_TYPE_CONST_P (type
))
5501 permerror (DECL_SOURCE_LOCATION (decl
),
5502 "uninitialized const %qD", decl
);
5505 if (!is_instantiation_of_constexpr (current_function_decl
))
5506 error_at (DECL_SOURCE_LOCATION (decl
),
5507 "uninitialized variable %qD in %<constexpr%> function",
5509 cp_function_chain
->invalid_constexpr
= true;
5512 if (CLASS_TYPE_P (type
))
5514 tree defaulted_ctor
;
5516 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5517 "%q#T has no user-provided default constructor", type
);
5518 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5520 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5521 "constructor is not user-provided because it is "
5522 "explicitly defaulted in the class body");
5523 inform (DECL_SOURCE_LOCATION (field
),
5524 "and the implicitly-defined constructor does not "
5525 "initialize %q#D", field
);
5530 /* Structure holding the current initializer being processed by reshape_init.
5531 CUR is a pointer to the current element being processed, END is a pointer
5532 after the last element present in the initializer. */
5535 constructor_elt
*cur
;
5536 constructor_elt
*end
;
5539 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5541 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5542 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5543 initialized. If there are no more such fields, the return value
5547 next_initializable_field (tree field
)
5550 && (TREE_CODE (field
) != FIELD_DECL
5551 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5552 || (DECL_ARTIFICIAL (field
)
5553 && !(cxx_dialect
>= cxx17
&& DECL_FIELD_IS_BASE (field
)))))
5554 field
= DECL_CHAIN (field
);
5559 /* Return true for [dcl.init.list] direct-list-initialization from
5560 single element of enumeration with a fixed underlying type. */
5563 is_direct_enum_init (tree type
, tree init
)
5565 if (cxx_dialect
>= cxx17
5566 && TREE_CODE (type
) == ENUMERAL_TYPE
5567 && ENUM_FIXED_UNDERLYING_TYPE_P (type
)
5568 && TREE_CODE (init
) == CONSTRUCTOR
5569 && CONSTRUCTOR_IS_DIRECT_INIT (init
)
5570 && CONSTRUCTOR_NELTS (init
) == 1)
5575 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5576 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5577 INTEGER_CST representing the size of the array minus one (the maximum index),
5578 or NULL_TREE if the array was declared without specifying the size. D is
5579 the iterator within the constructor. */
5582 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5583 tsubst_flags_t complain
)
5586 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5587 unsigned HOST_WIDE_INT max_index_cst
= 0;
5588 unsigned HOST_WIDE_INT index
;
5590 /* The initializer for an array is always a CONSTRUCTOR. */
5591 new_init
= build_constructor (init_list_type_node
, NULL
);
5595 /* Minus 1 is used for zero sized arrays. */
5596 if (integer_all_onesp (max_index
))
5599 if (tree_fits_uhwi_p (max_index
))
5600 max_index_cst
= tree_to_uhwi (max_index
);
5601 /* sizetype is sign extended, not zero extended. */
5603 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5606 /* Loop until there are no more initializers. */
5608 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5612 constructor_elt
*old_cur
= d
->cur
;
5614 check_array_designated_initializer (d
->cur
, index
);
5615 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5617 if (elt_init
== error_mark_node
)
5618 return error_mark_node
;
5619 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5620 size_int (index
), elt_init
);
5621 if (!TREE_CONSTANT (elt_init
))
5622 TREE_CONSTANT (new_init
) = false;
5624 /* This can happen with an invalid initializer (c++/54501). */
5625 if (d
->cur
== old_cur
&& !sized_array_p
)
5632 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5633 Parameters are the same of reshape_init_r. */
5636 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5638 tree max_index
= NULL_TREE
;
5640 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5642 if (TYPE_DOMAIN (type
))
5643 max_index
= array_type_nelts (type
);
5645 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5648 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5649 Parameters are the same of reshape_init_r. */
5652 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5654 tree max_index
= NULL_TREE
;
5656 gcc_assert (VECTOR_TYPE_P (type
));
5658 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5660 tree value
= d
->cur
->value
;
5661 if (!same_type_p (TREE_TYPE (value
), type
))
5663 if (complain
& tf_error
)
5664 error ("invalid type %qT as initializer for a vector of type %qT",
5665 TREE_TYPE (d
->cur
->value
), type
);
5666 value
= error_mark_node
;
5672 /* For a vector, we initialize it as an array of the appropriate size. */
5673 if (VECTOR_TYPE_P (type
))
5674 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5676 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5679 /* Subroutine of reshape_init_r, processes the initializers for classes
5680 or union. Parameters are the same of reshape_init_r. */
5683 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5684 tsubst_flags_t complain
)
5689 gcc_assert (CLASS_TYPE_P (type
));
5691 /* The initializer for a class is always a CONSTRUCTOR. */
5692 new_init
= build_constructor (init_list_type_node
, NULL
);
5693 field
= next_initializable_field (TYPE_FIELDS (type
));
5699 An initializer for an aggregate member that is an
5700 empty class shall have the form of an empty
5701 initializer-list {}. */
5702 if (!first_initializer_p
)
5704 if (complain
& tf_error
)
5705 error ("initializer for %qT must be brace-enclosed", type
);
5706 return error_mark_node
;
5711 /* Loop through the initializable fields, gathering initializers. */
5712 while (d
->cur
!= d
->end
)
5715 constructor_elt
*old_cur
= d
->cur
;
5717 /* Handle designated initializers, as an extension. */
5720 if (d
->cur
->index
== error_mark_node
)
5721 return error_mark_node
;
5723 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5724 /* We already reshaped this. */
5725 gcc_assert (d
->cur
->index
== field
);
5726 else if (TREE_CODE (d
->cur
->index
) == IDENTIFIER_NODE
)
5727 field
= get_class_binding (type
, d
->cur
->index
, false);
5730 if (complain
& tf_error
)
5731 error ("%<[%E] =%> used in a GNU-style designated initializer"
5732 " for class %qT", d
->cur
->index
, type
);
5733 return error_mark_node
;
5736 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5738 if (complain
& tf_error
)
5739 error ("%qT has no non-static data member named %qD", type
,
5741 return error_mark_node
;
5745 /* If we processed all the member of the class, we are done. */
5749 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5750 /*first_initializer_p=*/false, complain
);
5751 if (field_init
== error_mark_node
)
5752 return error_mark_node
;
5754 if (d
->cur
== old_cur
&& d
->cur
->index
)
5756 /* This can happen with an invalid initializer for a flexible
5757 array member (c++/54441). */
5758 if (complain
& tf_error
)
5759 error ("invalid initializer for %q#D", field
);
5760 return error_mark_node
;
5763 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5767 When a union is initialized with a brace-enclosed
5768 initializer, the braces shall only contain an
5769 initializer for the first member of the union. */
5770 if (TREE_CODE (type
) == UNION_TYPE
)
5773 field
= next_initializable_field (DECL_CHAIN (field
));
5779 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5780 designators are not valid; either complain or return true to indicate
5781 that reshape_init_r should return error_mark_node. */
5784 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5788 if (complain
& tf_error
)
5789 error ("C99 designator %qE outside aggregate initializer",
5797 /* Subroutine of reshape_init, which processes a single initializer (part of
5798 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5799 iterator within the CONSTRUCTOR which points to the initializer to process.
5800 FIRST_INITIALIZER_P is true if this is the first initializer of the
5801 outermost CONSTRUCTOR node. */
5804 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5805 tsubst_flags_t complain
)
5807 tree init
= d
->cur
->value
;
5809 if (error_operand_p (init
))
5810 return error_mark_node
;
5812 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5813 && has_designator_problem (d
, complain
))
5814 return error_mark_node
;
5816 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5818 /* A complex type can be initialized from one or two initializers,
5819 but braces are not elided. */
5821 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5823 if (CONSTRUCTOR_NELTS (init
) > 2)
5825 if (complain
& tf_error
)
5826 error ("too many initializers for %qT", type
);
5828 return error_mark_node
;
5831 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5833 vec
<constructor_elt
, va_gc
> *v
= 0;
5834 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5835 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5836 if (has_designator_problem (d
, complain
))
5837 return error_mark_node
;
5839 init
= build_constructor (init_list_type_node
, v
);
5844 /* A non-aggregate type is always initialized with a single
5846 if (!CP_AGGREGATE_TYPE_P (type
))
5848 /* It is invalid to initialize a non-aggregate type with a
5849 brace-enclosed initializer before C++0x.
5850 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5851 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5852 a CONSTRUCTOR (with a record type). */
5853 if (TREE_CODE (init
) == CONSTRUCTOR
5854 /* Don't complain about a capture-init. */
5855 && !CONSTRUCTOR_IS_DIRECT_INIT (init
)
5856 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5858 if (SCALAR_TYPE_P (type
))
5860 if (cxx_dialect
< cxx11
5861 /* Isn't value-initialization. */
5862 || CONSTRUCTOR_NELTS (init
) > 0)
5864 if (complain
& tf_error
)
5865 error ("braces around scalar initializer for type %qT",
5867 init
= error_mark_node
;
5871 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5878 /* "If T is a class type and the initializer list has a single element of
5879 type cv U, where U is T or a class derived from T, the object is
5880 initialized from that element." Even if T is an aggregate. */
5881 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5882 && first_initializer_p
5883 && d
->end
- d
->cur
== 1
5884 && reference_related_p (type
, TREE_TYPE (init
)))
5892 All implicit type conversions (clause _conv_) are considered when
5893 initializing the aggregate member with an initializer from an
5894 initializer-list. If the initializer can initialize a member,
5895 the member is initialized. Otherwise, if the member is itself a
5896 non-empty subaggregate, brace elision is assumed and the
5897 initializer is considered for the initialization of the first
5898 member of the subaggregate. */
5899 if (TREE_CODE (init
) != CONSTRUCTOR
5900 /* But don't try this for the first initializer, since that would be
5901 looking through the outermost braces; A a2 = { a1 }; is not a
5902 valid aggregate initialization. */
5903 && !first_initializer_p
5904 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5905 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5912 /* [dcl.init.string]
5914 A char array (whether plain char, signed char, or unsigned char)
5915 can be initialized by a string-literal (optionally enclosed in
5916 braces); a wchar_t array can be initialized by a wide
5917 string-literal (optionally enclosed in braces). */
5918 if (TREE_CODE (type
) == ARRAY_TYPE
5919 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5921 tree str_init
= init
;
5923 /* Strip one level of braces if and only if they enclose a single
5924 element (as allowed by [dcl.init.string]). */
5925 if (!first_initializer_p
5926 && TREE_CODE (str_init
) == CONSTRUCTOR
5927 && CONSTRUCTOR_NELTS (str_init
) == 1)
5929 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5932 /* If it's a string literal, then it's the initializer for the array
5933 as a whole. Otherwise, continue with normal initialization for
5934 array types (one value per array element). */
5935 if (TREE_CODE (str_init
) == STRING_CST
)
5937 if (has_designator_problem (d
, complain
))
5938 return error_mark_node
;
5944 /* The following cases are about aggregates. If we are not within a full
5945 initializer already, and there is not a CONSTRUCTOR, it means that there
5946 is a missing set of braces (that is, we are processing the case for
5947 which reshape_init exists). */
5948 if (!first_initializer_p
)
5950 if (TREE_CODE (init
) == CONSTRUCTOR
)
5952 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5953 /* There is no need to reshape pointer-to-member function
5954 initializers, as they are always constructed correctly
5955 by the front end. */
5957 else if (COMPOUND_LITERAL_P (init
))
5958 /* For a nested compound literal, there is no need to reshape since
5959 brace elision is not allowed. Even if we decided to allow it,
5960 we should add a call to reshape_init in finish_compound_literal,
5961 before calling digest_init, so changing this code would still
5962 not be necessary. */
5963 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5967 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5968 return reshape_init (type
, init
, complain
);
5972 if (complain
& tf_warning
)
5973 warning (OPT_Wmissing_braces
,
5974 "missing braces around initializer for %qT",
5978 /* Dispatch to specialized routines. */
5979 if (CLASS_TYPE_P (type
))
5980 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5981 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5982 return reshape_init_array (type
, d
, complain
);
5983 else if (VECTOR_TYPE_P (type
))
5984 return reshape_init_vector (type
, d
, complain
);
5989 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5990 brace-enclosed aggregate initializer.
5992 INIT is the CONSTRUCTOR containing the list of initializers describing
5993 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5994 It may not presently match the shape of the TYPE; for example:
5996 struct S { int a; int b; };
5997 struct S a[] = { 1, 2, 3, 4 };
5999 Here INIT will hold a vector of four elements, rather than a
6000 vector of two elements, each itself a vector of two elements. This
6001 routine transforms INIT from the former form into the latter. The
6002 revised CONSTRUCTOR node is returned. */
6005 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
6007 vec
<constructor_elt
, va_gc
> *v
;
6011 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
6013 v
= CONSTRUCTOR_ELTS (init
);
6015 /* An empty constructor does not need reshaping, and it is always a valid
6017 if (vec_safe_is_empty (v
))
6020 /* Handle [dcl.init.list] direct-list-initialization from
6021 single element of enumeration with a fixed underlying type. */
6022 if (is_direct_enum_init (type
, init
))
6024 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
6025 type
= cv_unqualified (type
);
6026 if (check_narrowing (ENUM_UNDERLYING_TYPE (type
), elt
, complain
))
6028 warning_sentinel
w (warn_useless_cast
);
6029 return cp_build_c_cast (type
, elt
, tf_warning_or_error
);
6032 return error_mark_node
;
6035 /* Recurse on this CONSTRUCTOR. */
6037 d
.end
= d
.cur
+ v
->length ();
6039 new_init
= reshape_init_r (type
, &d
, true, complain
);
6040 if (new_init
== error_mark_node
)
6041 return error_mark_node
;
6043 /* Make sure all the element of the constructor were used. Otherwise,
6044 issue an error about exceeding initializers. */
6047 if (complain
& tf_error
)
6048 error ("too many initializers for %qT", type
);
6049 return error_mark_node
;
6052 if (CONSTRUCTOR_IS_DIRECT_INIT (init
)
6053 && BRACE_ENCLOSED_INITIALIZER_P (new_init
))
6054 CONSTRUCTOR_IS_DIRECT_INIT (new_init
) = true;
6059 /* Verify array initializer. Returns true if errors have been reported. */
6062 check_array_initializer (tree decl
, tree type
, tree init
)
6064 tree element_type
= TREE_TYPE (type
);
6066 /* The array type itself need not be complete, because the
6067 initializer may tell us how many elements are in the array.
6068 But, the elements of the array must be complete. */
6069 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
6072 error_at (DECL_SOURCE_LOCATION (decl
),
6073 "elements of array %q#D have incomplete type", decl
);
6075 error ("elements of array %q#T have incomplete type", type
);
6078 /* A compound literal can't have variable size. */
6080 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
6081 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
6083 error ("variable-sized compound literal");
6089 /* Subroutine of check_initializer; args are passed down from that function.
6090 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
6093 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
6096 gcc_assert (stmts_are_full_exprs_p ());
6097 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
6100 /* Verify INIT (the initializer for DECL), and record the
6101 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
6102 grok_reference_init.
6104 If the return value is non-NULL, it is an expression that must be
6105 evaluated dynamically to initialize DECL. */
6108 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
6110 tree type
= TREE_TYPE (decl
);
6111 tree init_code
= NULL
;
6114 /* Things that are going to be initialized need to have complete
6116 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
6118 if (DECL_HAS_VALUE_EXPR_P (decl
))
6120 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
6121 it doesn't have storage to be initialized. */
6122 gcc_assert (init
== NULL_TREE
);
6126 if (type
== error_mark_node
)
6127 /* We will have already complained. */
6130 if (TREE_CODE (type
) == ARRAY_TYPE
)
6132 if (check_array_initializer (decl
, type
, init
))
6135 else if (!COMPLETE_TYPE_P (type
))
6137 error_at (DECL_SOURCE_LOCATION (decl
),
6138 "%q#D has incomplete type", decl
);
6139 TREE_TYPE (decl
) = error_mark_node
;
6143 /* There is no way to make a variable-sized class type in GNU C++. */
6144 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
6146 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
6148 int init_len
= CONSTRUCTOR_NELTS (init
);
6149 if (SCALAR_TYPE_P (type
))
6153 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6154 init
= build_zero_init (type
, NULL_TREE
, false);
6156 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
6158 error_at (EXPR_LOC_OR_LOC (init
, DECL_SOURCE_LOCATION (decl
)),
6159 "scalar object %qD requires one element in "
6160 "initializer", decl
);
6161 TREE_TYPE (decl
) = error_mark_node
;
6167 if (TREE_CODE (decl
) == CONST_DECL
)
6169 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
6171 DECL_INITIAL (decl
) = init
;
6173 gcc_assert (init
!= NULL_TREE
);
6176 else if (!init
&& DECL_REALLY_EXTERN (decl
))
6178 else if (init
|| type_build_ctor_call (type
)
6179 || TREE_CODE (type
) == REFERENCE_TYPE
)
6181 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6183 init
= grok_reference_init (decl
, type
, init
, flags
);
6184 flags
|= LOOKUP_ALREADY_DIGESTED
;
6187 check_for_uninitialized_const_var (decl
);
6188 /* Do not reshape constructors of vectors (they don't need to be
6190 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
6192 if (is_std_init_list (type
))
6194 init
= perform_implicit_conversion (type
, init
,
6195 tf_warning_or_error
);
6196 flags
|= LOOKUP_ALREADY_DIGESTED
;
6198 else if (TYPE_NON_AGGREGATE_CLASS (type
))
6200 /* Don't reshape if the class has constructors. */
6201 if (cxx_dialect
== cxx98
)
6202 error_at (EXPR_LOC_OR_LOC (init
, DECL_SOURCE_LOCATION (decl
)),
6203 "in C++98 %qD must be initialized by "
6204 "constructor, not by %<{...}%>",
6207 else if (VECTOR_TYPE_P (type
) && TYPE_VECTOR_OPAQUE (type
))
6209 error ("opaque vector types cannot be initialized");
6210 init
= error_mark_node
;
6214 init
= reshape_init (type
, init
, tf_warning_or_error
);
6215 flags
|= LOOKUP_NO_NARROWING
;
6218 else if (TREE_CODE (init
) == TREE_LIST
6219 && TREE_TYPE (init
) != unknown_type_node
6220 && !MAYBE_CLASS_TYPE_P (type
))
6222 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6224 /* We get here with code like `int a (2);' */
6225 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6226 tf_warning_or_error
);
6229 /* If DECL has an array type without a specific bound, deduce the
6230 array size from the initializer. */
6231 maybe_deduce_size_from_array_init (decl
, init
);
6232 type
= TREE_TYPE (decl
);
6233 if (type
== error_mark_node
)
6236 if (((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
6237 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
6238 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
6239 && CP_AGGREGATE_TYPE_P (type
)
6240 && (CLASS_TYPE_P (type
)
6241 || !TYPE_NEEDS_CONSTRUCTING (type
)
6242 || type_has_extended_temps (type
))))
6243 || (DECL_DECOMPOSITION_P (decl
) && TREE_CODE (type
) == ARRAY_TYPE
))
6245 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
6247 /* A constructor call is a non-trivial initializer even if
6248 it isn't explicitly written. */
6249 if (TREE_SIDE_EFFECTS (init_code
))
6250 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
6252 /* If this is a constexpr initializer, expand_default_init will
6253 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6254 case, pull the initializer back out and pass it down into
6255 store_init_value. */
6256 while (TREE_CODE (init_code
) == EXPR_STMT
6257 || TREE_CODE (init_code
) == CONVERT_EXPR
)
6258 init_code
= TREE_OPERAND (init_code
, 0);
6259 if (TREE_CODE (init_code
) == INIT_EXPR
)
6261 init
= TREE_OPERAND (init_code
, 1);
6262 init_code
= NULL_TREE
;
6263 /* Don't call digest_init; it's unnecessary and will complain
6264 about aggregate initialization of non-aggregate classes. */
6265 flags
|= LOOKUP_ALREADY_DIGESTED
;
6267 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
6269 /* Declared constexpr, but no suitable initializer; massage
6270 init appropriately so we can pass it into store_init_value
6272 if (CLASS_TYPE_P (type
)
6273 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
6275 init
= build_functional_cast (type
, init
, tf_none
);
6276 if (TREE_CODE (init
) == TARGET_EXPR
)
6277 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
6279 init_code
= NULL_TREE
;
6285 if (init
&& TREE_CODE (init
) != TREE_VEC
)
6287 /* In aggregate initialization of a variable, each element
6288 initialization is a full-expression because there is no
6289 enclosing expression. */
6290 gcc_assert (stmts_are_full_exprs_p ());
6292 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
6294 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
6295 && DECL_INITIAL (decl
)
6296 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
6297 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
6298 warning_at (EXPR_LOC_OR_LOC (DECL_INITIAL (decl
),
6299 DECL_SOURCE_LOCATION (decl
)),
6300 0, "array %qD initialized by parenthesized "
6301 "string literal %qE",
6302 decl
, DECL_INITIAL (decl
));
6308 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
6309 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
6310 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
6311 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
6314 check_for_uninitialized_const_var (decl
);
6317 if (init
&& init
!= error_mark_node
)
6318 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
6322 /* We might have set these in cp_finish_decl. */
6323 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
6324 TREE_CONSTANT (decl
) = false;
6328 && (DECL_IN_AGGR_P (decl
) && !DECL_VAR_DECLARED_INLINE_P (decl
)))
6330 static int explained
= 0;
6332 if (cxx_dialect
< cxx11
)
6333 error ("initializer invalid for static member with constructor");
6334 else if (cxx_dialect
< cxx17
)
6335 error ("non-constant in-class initialization invalid for static "
6336 "member %qD", decl
);
6338 error ("non-constant in-class initialization invalid for non-inline "
6339 "static member %qD", decl
);
6342 inform (input_location
,
6343 "(an out of class initialization is required)");
6352 /* If DECL is not a local variable, give it RTL. */
6355 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6357 int toplev
= toplevel_bindings_p ();
6360 /* Set the DECL_ASSEMBLER_NAME for the object. */
6363 /* The `register' keyword, when used together with an
6364 asm-specification, indicates that the variable should be
6365 placed in a particular register. */
6366 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6368 set_user_assembler_name (decl
, asmspec
);
6369 DECL_HARD_REGISTER (decl
) = 1;
6373 if (TREE_CODE (decl
) == FUNCTION_DECL
6374 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
6375 set_builtin_user_assembler_name (decl
, asmspec
);
6376 set_user_assembler_name (decl
, asmspec
);
6380 /* Handle non-variables up front. */
6383 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6387 /* If we see a class member here, it should be a static data
6389 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6391 gcc_assert (TREE_STATIC (decl
));
6392 /* An in-class declaration of a static data member should be
6393 external; it is only a declaration, and not a definition. */
6394 if (init
== NULL_TREE
)
6395 gcc_assert (DECL_EXTERNAL (decl
)
6396 || !TREE_PUBLIC (decl
)
6397 || DECL_INLINE_VAR_P (decl
));
6400 /* We don't create any RTL for local variables. */
6401 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6404 /* We defer emission of local statics until the corresponding
6405 DECL_EXPR is expanded. But with constexpr its function might never
6406 be expanded, so go ahead and tell cgraph about the variable now. */
6407 defer_p
= ((DECL_FUNCTION_SCOPE_P (decl
)
6408 && !var_in_maybe_constexpr_fn (decl
))
6409 || DECL_VIRTUAL_P (decl
));
6411 /* Defer template instantiations. */
6412 if (DECL_LANG_SPECIFIC (decl
)
6413 && DECL_IMPLICIT_INSTANTIATION (decl
))
6416 /* If we're not deferring, go ahead and assemble the variable. */
6418 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6421 /* walk_tree helper for wrap_temporary_cleanups, below. */
6424 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6426 /* Stop at types or full-expression boundaries. */
6427 if (TYPE_P (*stmt_p
)
6428 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6434 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6436 tree guard
= (tree
)data
;
6437 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6439 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6440 /* Tell honor_protect_cleanup_actions to handle this as a separate
6442 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6444 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6450 /* We're initializing a local variable which has a cleanup GUARD. If there
6451 are any temporaries used in the initializer INIT of this variable, we
6452 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6453 variable will be cleaned up properly if one of them throws.
6455 Unfortunately, there's no way to express this properly in terms of
6456 nesting, as the regions for the temporaries overlap the region for the
6457 variable itself; if there are two temporaries, the variable needs to be
6458 the first thing destroyed if either of them throws. However, we only
6459 want to run the variable's cleanup if it actually got constructed. So
6460 we need to guard the temporary cleanups with the variable's cleanup if
6461 they are run on the normal path, but not if they are run on the
6462 exceptional path. We implement this by telling
6463 honor_protect_cleanup_actions to strip the variable cleanup from the
6464 exceptional path. */
6467 wrap_temporary_cleanups (tree init
, tree guard
)
6469 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6472 /* Generate code to initialize DECL (a local variable). */
6475 initialize_local_var (tree decl
, tree init
)
6477 tree type
= TREE_TYPE (decl
);
6481 gcc_assert (VAR_P (decl
)
6482 || TREE_CODE (decl
) == RESULT_DECL
);
6483 gcc_assert (!TREE_STATIC (decl
));
6485 if (DECL_SIZE (decl
) == NULL_TREE
)
6487 /* If we used it already as memory, it must stay in memory. */
6488 DECL_INITIAL (decl
) = NULL_TREE
;
6489 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6493 if (type
== error_mark_node
)
6496 /* Compute and store the initial value. */
6497 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6498 if (TREE_USED (type
))
6499 DECL_READ_P (decl
) = 1;
6501 /* Generate a cleanup, if necessary. */
6502 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6504 /* Perform the initialization. */
6507 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6508 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6509 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6511 /* Stick simple initializers in DECL_INITIAL so that
6512 -Wno-init-self works (c++/34772). */
6513 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6514 DECL_INITIAL (decl
) = rinit
;
6516 if (warn_init_self
&& TREE_CODE (type
) == REFERENCE_TYPE
)
6520 warning_at (DECL_SOURCE_LOCATION (decl
),
6522 "reference %qD is initialized with itself", decl
);
6527 int saved_stmts_are_full_exprs_p
;
6529 /* If we're only initializing a single object, guard the
6530 destructors of any temporaries used in its initializer with
6531 its destructor. This isn't right for arrays because each
6532 element initialization is a full-expression. */
6533 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6534 wrap_temporary_cleanups (init
, cleanup
);
6536 gcc_assert (building_stmt_list_p ());
6537 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6538 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6539 finish_expr_stmt (init
);
6540 current_stmt_tree ()->stmts_are_full_exprs_p
=
6541 saved_stmts_are_full_exprs_p
;
6545 /* Set this to 0 so we can tell whether an aggregate which was
6546 initialized was ever used. Don't do this if it has a
6547 destructor, so we don't complain about the 'resource
6548 allocation is initialization' idiom. Now set
6549 attribute((unused)) on types so decls of that type will be
6550 marked used. (see TREE_USED, above.) */
6551 if (TYPE_NEEDS_CONSTRUCTING (type
)
6553 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6554 && DECL_NAME (decl
))
6555 TREE_USED (decl
) = 0;
6556 else if (already_used
)
6557 TREE_USED (decl
) = 1;
6560 finish_decl_cleanup (decl
, cleanup
);
6563 /* DECL is a VAR_DECL for a compiler-generated variable with static
6564 storage duration (like a virtual table) whose initializer is a
6565 compile-time constant. Initialize the variable and provide it to the
6569 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6572 gcc_assert (DECL_ARTIFICIAL (decl
));
6573 init
= build_constructor (TREE_TYPE (decl
), v
);
6574 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6575 DECL_INITIAL (decl
) = init
;
6576 DECL_INITIALIZED_P (decl
) = 1;
6577 determine_visibility (decl
);
6578 layout_var_decl (decl
);
6579 maybe_commonize_var (decl
);
6580 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6583 /* INIT is the initializer for a variable, as represented by the
6584 parser. Returns true iff INIT is type-dependent. */
6587 type_dependent_init_p (tree init
)
6589 if (TREE_CODE (init
) == TREE_LIST
)
6590 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6591 return any_type_dependent_elements_p (init
);
6592 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6593 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6595 if (dependent_type_p (TREE_TYPE (init
)))
6598 vec
<constructor_elt
, va_gc
> *elts
;
6602 elts
= CONSTRUCTOR_ELTS (init
);
6603 nelts
= vec_safe_length (elts
);
6604 for (i
= 0; i
< nelts
; ++i
)
6605 if (type_dependent_init_p ((*elts
)[i
].value
))
6609 /* It must be a simple expression, e.g., int i = 3; */
6610 return type_dependent_expression_p (init
);
6615 /* INIT is the initializer for a variable, as represented by the
6616 parser. Returns true iff INIT is value-dependent. */
6619 value_dependent_init_p (tree init
)
6621 if (TREE_CODE (init
) == TREE_LIST
)
6622 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6623 return any_value_dependent_elements_p (init
);
6624 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6625 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6627 vec
<constructor_elt
, va_gc
> *elts
;
6631 elts
= CONSTRUCTOR_ELTS (init
);
6632 nelts
= vec_safe_length (elts
);
6633 for (i
= 0; i
< nelts
; ++i
)
6634 if (value_dependent_init_p ((*elts
)[i
].value
))
6638 /* It must be a simple expression, e.g., int i = 3; */
6639 return value_dependent_expression_p (init
);
6644 // Returns true if a DECL is VAR_DECL with the concept specifier.
6646 is_concept_var (tree decl
)
6648 return (VAR_P (decl
)
6649 // Not all variables have DECL_LANG_SPECIFIC.
6650 && DECL_LANG_SPECIFIC (decl
)
6651 && DECL_DECLARED_CONCEPT_P (decl
));
6654 /* A helper function to be called via walk_tree. If any label exists
6655 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
6658 notice_forced_label_r (tree
*tp
, int *walk_subtrees
, void *)
6662 if (TREE_CODE (*tp
) == LABEL_DECL
)
6663 cfun
->has_forced_label_in_static
= 1;
6667 /* Finish processing of a declaration;
6668 install its line number and initial value.
6669 If the length of an array type is not known before,
6670 it must be determined now, from the initial value, or it is an error.
6672 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6673 true, then INIT is an integral constant expression.
6675 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6676 if the (init) syntax was used. */
6679 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6680 tree asmspec_tree
, int flags
)
6683 vec
<tree
, va_gc
> *cleanups
= NULL
;
6684 const char *asmspec
= NULL
;
6685 int was_readonly
= 0;
6686 bool var_definition_p
= false;
6689 if (decl
== error_mark_node
)
6694 error ("assignment (not initialization) in declaration");
6698 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6699 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6700 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6702 type
= TREE_TYPE (decl
);
6703 if (type
== error_mark_node
)
6706 /* Warn about register storage specifiers except when in GNU global
6707 or local register variable extension. */
6708 if (VAR_P (decl
) && DECL_REGISTER (decl
) && asmspec_tree
== NULL_TREE
)
6710 if (cxx_dialect
>= cxx17
)
6711 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
6712 "ISO C++17 does not allow %<register%> storage "
6715 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
6716 "%<register%> storage class specifier used");
6719 /* If a name was specified, get the string. */
6720 if (at_namespace_scope_p ())
6721 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6722 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6723 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6725 if (current_class_type
6726 && CP_DECL_CONTEXT (decl
) == current_class_type
6727 && TYPE_BEING_DEFINED (current_class_type
)
6728 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6729 && (DECL_INITIAL (decl
) || init
))
6730 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6732 if (TREE_CODE (decl
) != FUNCTION_DECL
6733 && (auto_node
= type_uses_auto (type
)))
6736 if (init
== NULL_TREE
)
6738 if (DECL_LANG_SPECIFIC (decl
)
6739 && DECL_TEMPLATE_INSTANTIATION (decl
)
6740 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6742 /* init is null because we're deferring instantiating the
6743 initializer until we need it. Well, we need it now. */
6744 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6748 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (auto_node
));
6753 if (TREE_CODE (d_init
) == TREE_LIST
6754 && !CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
6755 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6756 tf_warning_or_error
);
6757 d_init
= resolve_nondeduced_context (d_init
, tf_warning_or_error
);
6759 enum auto_deduction_context adc
= adc_variable_type
;
6760 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
6761 adc
= adc_decomp_type
;
6762 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
, auto_node
,
6763 tf_warning_or_error
, adc
,
6765 if (type
== error_mark_node
)
6767 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6769 error ("initializer for %<decltype(auto) %D%> has function type "
6770 "(did you forget the %<()%> ?)", decl
);
6771 TREE_TYPE (decl
) = error_mark_node
;
6774 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6777 if (!ensure_literal_type_for_constexpr_object (decl
))
6778 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6781 && DECL_CLASS_SCOPE_P (decl
)
6782 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6783 check_static_variable_definition (decl
, type
);
6785 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6788 if (init
== ridpointers
[(int)RID_DELETE
])
6790 /* FIXME check this is 1st decl. */
6791 DECL_DELETED_FN (decl
) = 1;
6792 DECL_DECLARED_INLINE_P (decl
) = 1;
6793 DECL_INITIAL (decl
) = error_mark_node
;
6794 FOR_EACH_CLONE (clone
, decl
)
6796 DECL_DELETED_FN (clone
) = 1;
6797 DECL_DECLARED_INLINE_P (clone
) = 1;
6798 DECL_INITIAL (clone
) = error_mark_node
;
6802 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6804 if (defaultable_fn_check (decl
))
6805 DECL_DEFAULTED_FN (decl
) = 1;
6807 DECL_INITIAL (decl
) = NULL_TREE
;
6811 if (init
&& VAR_P (decl
))
6813 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6814 /* If DECL is a reference, then we want to know whether init is a
6815 reference constant; init_const_expr_p as passed tells us whether
6816 it's an rvalue constant. */
6817 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6818 init_const_expr_p
= potential_constant_expression (init
);
6819 if (init_const_expr_p
)
6821 /* Set these flags now for templates. We'll update the flags in
6822 store_init_value for instantiations. */
6823 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6824 if (decl_maybe_constant_var_p (decl
)
6825 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
6826 && TREE_CODE (type
) != REFERENCE_TYPE
)
6827 TREE_CONSTANT (decl
) = 1;
6831 if (processing_template_decl
)
6833 bool type_dependent_p
;
6835 /* Add this declaration to the statement-tree. */
6836 if (at_function_scope_p ())
6837 add_decl_expr (decl
);
6839 type_dependent_p
= dependent_type_p (type
);
6841 if (check_for_bare_parameter_packs (init
))
6844 DECL_INITIAL (decl
) = NULL_TREE
;
6847 init
= do_dependent_capture (init
);
6849 /* Generally, initializers in templates are expanded when the
6850 template is instantiated. But, if DECL is a variable constant
6851 then it can be used in future constant expressions, so its value
6852 must be available. */
6854 if (!VAR_P (decl
) || type_dependent_p
)
6855 /* We can't do anything if the decl has dependent type. */;
6857 && init_const_expr_p
6858 && TREE_CODE (type
) != REFERENCE_TYPE
6859 && decl_maybe_constant_var_p (decl
)
6860 && !type_dependent_init_p (init
)
6861 && !value_dependent_init_p (init
))
6863 /* This variable seems to be a non-dependent constant, so process
6864 its initializer. If check_initializer returns non-null the
6865 initialization wasn't constant after all. */
6867 cleanups
= make_tree_vector ();
6868 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6869 if (init_code
== NULL_TREE
)
6871 release_tree_vector (cleanups
);
6873 else if (!init
&& is_concept_var (decl
))
6874 error ("variable concept has no initializer");
6875 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6877 /* Deduce array size even if the initializer is dependent. */
6878 maybe_deduce_size_from_array_init (decl
, init
);
6879 /* And complain about multiple initializers. */
6880 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6881 && !MAYBE_CLASS_TYPE_P (type
))
6882 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6883 tf_warning_or_error
);
6887 DECL_INITIAL (decl
) = init
;
6891 /* Just store non-static data member initializers for later. */
6892 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6893 DECL_INITIAL (decl
) = init
;
6895 /* Take care of TYPE_DECLs up front. */
6896 if (TREE_CODE (decl
) == TYPE_DECL
)
6898 if (type
!= error_mark_node
6899 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6901 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6902 warning (0, "shadowing previous type declaration of %q#D", decl
);
6903 set_identifier_type_value (DECL_NAME (decl
), decl
);
6906 /* If we have installed this as the canonical typedef for this
6907 type, and that type has not been defined yet, delay emitting
6908 the debug information for it, as we will emit it later. */
6909 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6910 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6911 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6913 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6918 /* A reference will be modified here, as it is initialized. */
6919 if (! DECL_EXTERNAL (decl
)
6920 && TREE_READONLY (decl
)
6921 && TREE_CODE (type
) == REFERENCE_TYPE
)
6924 TREE_READONLY (decl
) = 0;
6929 /* If this is a local variable that will need a mangled name,
6930 register it now. We must do this before processing the
6931 initializer for the variable, since the initialization might
6932 require a guard variable, and since the mangled name of the
6933 guard variable will depend on the mangled name of this
6935 if (DECL_FUNCTION_SCOPE_P (decl
)
6936 && TREE_STATIC (decl
)
6937 && !DECL_ARTIFICIAL (decl
))
6939 push_local_name (decl
);
6940 /* Normally has_forced_label_in_static is set during GIMPLE
6941 lowering, but [cd]tors are never actually compiled directly.
6942 We need to set this early so we can deal with the label
6943 address extension. */
6944 if ((DECL_CONSTRUCTOR_P (current_function_decl
)
6945 || DECL_DESTRUCTOR_P (current_function_decl
))
6948 walk_tree (&init
, notice_forced_label_r
, NULL
, NULL
);
6949 add_local_decl (cfun
, decl
);
6951 /* And make sure it's in the symbol table for
6952 c_parse_final_cleanups to find. */
6953 varpool_node::get_create (decl
);
6956 /* Convert the initializer to the type of DECL, if we have not
6957 already initialized DECL. */
6958 if (!DECL_INITIALIZED_P (decl
)
6959 /* If !DECL_EXTERNAL then DECL is being defined. In the
6960 case of a static data member initialized inside the
6961 class-specifier, there can be an initializer even if DECL
6962 is *not* defined. */
6963 && (!DECL_EXTERNAL (decl
) || init
))
6965 cleanups
= make_tree_vector ();
6966 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6972 The memory occupied by any object of static storage
6973 duration is zero-initialized at program startup before
6974 any other initialization takes place.
6976 We cannot create an appropriate initializer until after
6977 the type of DECL is finalized. If DECL_INITIAL is set,
6978 then the DECL is statically initialized, and any
6979 necessary zero-initialization has already been performed. */
6980 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6981 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6982 /*nelts=*/NULL_TREE
,
6983 /*static_storage_p=*/true);
6984 /* Remember that the initialization for this variable has
6986 DECL_INITIALIZED_P (decl
) = 1;
6987 /* This declaration is the definition of this variable,
6988 unless we are initializing a static data member within
6989 the class specifier. */
6990 if (!DECL_EXTERNAL (decl
))
6991 var_definition_p
= true;
6993 /* If the variable has an array type, lay out the type, even if
6994 there is no initializer. It is valid to index through the
6995 array, and we must get TYPE_ALIGN set correctly on the array
6997 else if (TREE_CODE (type
) == ARRAY_TYPE
)
7000 if (TREE_STATIC (decl
)
7001 && !at_function_scope_p ()
7002 && current_function_decl
== NULL
)
7003 /* So decl is a global variable or a static member of a
7004 non local class. Record the types it uses
7005 so that we can decide later to emit debug info for them. */
7006 record_types_used_by_current_var_decl (decl
);
7009 /* Add this declaration to the statement-tree. This needs to happen
7010 after the call to check_initializer so that the DECL_EXPR for a
7011 reference temp is added before the DECL_EXPR for the reference itself. */
7012 if (DECL_FUNCTION_SCOPE_P (decl
))
7014 /* If we're building a variable sized type, and we might be
7015 reachable other than via the top of the current binding
7016 level, then create a new BIND_EXPR so that we deallocate
7017 the object at the right time. */
7020 && !TREE_CONSTANT (DECL_SIZE (decl
))
7021 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
7024 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
7025 TREE_SIDE_EFFECTS (bind
) = 1;
7027 BIND_EXPR_BODY (bind
) = push_stmt_list ();
7029 add_decl_expr (decl
);
7032 /* Let the middle end know about variables and functions -- but not
7033 static data members in uninstantiated class templates. */
7034 if (VAR_OR_FUNCTION_DECL_P (decl
))
7038 layout_var_decl (decl
);
7039 maybe_commonize_var (decl
);
7042 /* This needs to happen after the linkage is set. */
7043 determine_visibility (decl
);
7045 if (var_definition_p
&& TREE_STATIC (decl
))
7047 /* If a TREE_READONLY variable needs initialization
7048 at runtime, it is no longer readonly and we need to
7049 avoid MEM_READONLY_P being set on RTL created for it. */
7052 if (TREE_READONLY (decl
))
7053 TREE_READONLY (decl
) = 0;
7056 else if (was_readonly
)
7057 TREE_READONLY (decl
) = 1;
7059 /* Likewise if it needs destruction. */
7060 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
7061 TREE_READONLY (decl
) = 0;
7064 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
7066 /* Check for abstractness of the type. Notice that there is no
7067 need to strip array types here since the check for those types
7068 is already done within create_array_type_for_decl. */
7069 abstract_virtuals_error (decl
, type
);
7071 if (TREE_TYPE (decl
) == error_mark_node
)
7072 /* No initialization required. */
7074 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
7078 if (init
== ridpointers
[(int)RID_DEFAULT
])
7080 /* An out-of-class default definition is defined at
7081 the point where it is explicitly defaulted. */
7082 if (DECL_DELETED_FN (decl
))
7083 maybe_explain_implicit_delete (decl
);
7084 else if (DECL_INITIAL (decl
) == error_mark_node
)
7085 synthesize_method (decl
);
7088 error ("function %q#D is initialized like a variable", decl
);
7090 /* else no initialization required. */
7092 else if (DECL_EXTERNAL (decl
)
7093 && ! (DECL_LANG_SPECIFIC (decl
)
7094 && DECL_NOT_REALLY_EXTERN (decl
)))
7097 DECL_INITIAL (decl
) = init
;
7099 /* A variable definition. */
7100 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
7101 /* Initialize the local variable. */
7102 initialize_local_var (decl
, init
);
7104 /* If a variable is defined, and then a subsequent
7105 definition with external linkage is encountered, we will
7106 get here twice for the same variable. We want to avoid
7107 calling expand_static_init more than once. For variables
7108 that are not static data members, we can call
7109 expand_static_init only when we actually process the
7110 initializer. It is not legal to redeclare a static data
7111 member, so this issue does not arise in that case. */
7112 else if (var_definition_p
&& TREE_STATIC (decl
))
7113 expand_static_init (decl
, init
);
7116 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
7117 reference, insert it in the statement-tree now. */
7121 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
7122 push_cleanup (decl
, t
, false);
7123 release_tree_vector (cleanups
);
7127 TREE_READONLY (decl
) = 1;
7129 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
7132 /* For class TYPE return itself or some its bases that contain
7133 any direct non-static data members. Return error_mark_node if an
7134 error has been diagnosed. */
7137 find_decomp_class_base (location_t loc
, tree type
, tree ret
)
7139 bool member_seen
= false;
7140 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
7141 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
7145 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
7147 if (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
)
7148 error_at (loc
, "cannot decompose class type %qT because it has an "
7149 "anonymous struct member", type
);
7151 error_at (loc
, "cannot decompose class type %qT because it has an "
7152 "anonymous union member", type
);
7153 inform (DECL_SOURCE_LOCATION (field
), "declared here");
7154 return error_mark_node
;
7156 else if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
7158 error_at (loc
, "cannot decompose non-public member %qD of %qT",
7160 inform (DECL_SOURCE_LOCATION (field
),
7161 TREE_PRIVATE (field
)
7162 ? G_("declared private here")
7163 : G_("declared protected here"));
7164 return error_mark_node
;
7169 tree base_binfo
, binfo
;
7170 tree orig_ret
= ret
;
7174 for (binfo
= TYPE_BINFO (type
), i
= 0;
7175 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
7177 tree t
= find_decomp_class_base (loc
, TREE_TYPE (base_binfo
), ret
);
7178 if (t
== error_mark_node
)
7179 return error_mark_node
;
7184 error_at (loc
, "cannot decompose class type %qT: both it and "
7185 "its base class %qT have non-static data members",
7187 return error_mark_node
;
7189 else if (orig_ret
!= NULL_TREE
)
7192 /* OK, found the same base along another path. We'll complain
7193 in convert_to_base if it's ambiguous. */;
7194 else if (ret
!= NULL_TREE
)
7196 error_at (loc
, "cannot decompose class type %qT: its base "
7197 "classes %qT and %qT have non-static data "
7198 "members", type
, ret
, t
);
7199 return error_mark_node
;
7208 /* Return std::tuple_size<TYPE>::value. */
7211 get_tuple_size (tree type
)
7213 tree args
= make_tree_vec (1);
7214 TREE_VEC_ELT (args
, 0) = type
;
7215 tree inst
= lookup_template_class (get_identifier ("tuple_size"), args
,
7216 /*in_decl*/NULL_TREE
,
7217 /*context*/std_node
,
7218 /*entering_scope*/false, tf_none
);
7219 inst
= complete_type (inst
);
7220 if (inst
== error_mark_node
|| !COMPLETE_TYPE_P (inst
))
7222 tree val
= lookup_qualified_name (inst
, get_identifier ("value"),
7223 /*type*/false, /*complain*/false);
7224 if (TREE_CODE (val
) == VAR_DECL
|| TREE_CODE (val
) == CONST_DECL
)
7225 val
= maybe_constant_value (val
);
7226 if (TREE_CODE (val
) == INTEGER_CST
)
7229 return error_mark_node
;
7232 /* Return std::tuple_element<I,TYPE>::type. */
7235 get_tuple_element_type (tree type
, unsigned i
)
7237 tree args
= make_tree_vec (2);
7238 TREE_VEC_ELT (args
, 0) = build_int_cst (integer_type_node
, i
);
7239 TREE_VEC_ELT (args
, 1) = type
;
7240 tree inst
= lookup_template_class (get_identifier ("tuple_element"), args
,
7241 /*in_decl*/NULL_TREE
,
7242 /*context*/std_node
,
7243 /*entering_scope*/false,
7244 tf_warning_or_error
);
7245 return make_typename_type (inst
, get_identifier ("type"),
7246 none_type
, tf_warning_or_error
);
7249 /* Return e.get<i>() or get<i>(e). */
7252 get_tuple_decomp_init (tree decl
, unsigned i
)
7254 tree get_id
= get_identifier ("get");
7255 tree targs
= make_tree_vec (1);
7256 TREE_VEC_ELT (targs
, 0) = build_int_cst (integer_type_node
, i
);
7258 tree etype
= TREE_TYPE (decl
);
7259 tree e
= convert_from_reference (decl
);
7261 /* [The id-expression] e is an lvalue if the type of the entity e is an
7262 lvalue reference and an xvalue otherwise. */
7263 if (TREE_CODE (etype
) != REFERENCE_TYPE
7264 || TYPE_REF_IS_RVALUE (etype
))
7267 tree fns
= lookup_qualified_name (TREE_TYPE (e
), get_id
,
7268 /*type*/false, /*complain*/false);
7269 if (fns
!= error_mark_node
)
7271 fns
= lookup_template_function (fns
, targs
);
7272 return build_new_method_call (e
, fns
, /*args*/NULL
,
7273 /*path*/NULL_TREE
, LOOKUP_NORMAL
,
7274 /*fn_p*/NULL
, tf_warning_or_error
);
7278 vec
<tree
,va_gc
> *args
= make_tree_vector_single (e
);
7279 fns
= lookup_template_function (get_id
, targs
);
7280 fns
= perform_koenig_lookup (fns
, args
, tf_warning_or_error
);
7281 return finish_call_expr (fns
, &args
, /*novirt*/false,
7282 /*koenig*/true, tf_warning_or_error
);
7286 /* It's impossible to recover the decltype of a tuple decomposition variable
7287 based on the actual type of the variable, so store it in a hash table. */
7288 static GTY(()) hash_map
<tree
,tree
> *decomp_type_table
;
7290 store_decomp_type (tree v
, tree t
)
7292 if (!decomp_type_table
)
7293 decomp_type_table
= hash_map
<tree
,tree
>::create_ggc (13);
7294 decomp_type_table
->put (v
, t
);
7298 lookup_decomp_type (tree v
)
7300 return *decomp_type_table
->get (v
);
7303 /* Finish a decomposition declaration. DECL is the underlying declaration
7304 "e", FIRST is the head of a chain of decls for the individual identifiers
7305 chained through DECL_CHAIN in reverse order and COUNT is the number of
7309 cp_finish_decomp (tree decl
, tree first
, unsigned int count
)
7311 if (error_operand_p (decl
))
7316 TREE_TYPE (first
) = error_mark_node
;
7317 if (DECL_HAS_VALUE_EXPR_P (first
))
7319 SET_DECL_VALUE_EXPR (first
, NULL_TREE
);
7320 DECL_HAS_VALUE_EXPR_P (first
) = 0;
7322 first
= DECL_CHAIN (first
);
7324 if (DECL_P (decl
) && DECL_NAMESPACE_SCOPE_P (decl
))
7325 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier ("<decomp>"));
7329 location_t loc
= DECL_SOURCE_LOCATION (decl
);
7330 if (type_dependent_expression_p (decl
)
7331 /* This happens for range for when not in templates.
7332 Still add the DECL_VALUE_EXPRs for later processing. */
7333 || (!processing_template_decl
7334 && type_uses_auto (TREE_TYPE (decl
))))
7336 for (unsigned int i
= 0; i
< count
; i
++)
7338 if (!DECL_HAS_VALUE_EXPR_P (first
))
7340 tree v
= build_nt (ARRAY_REF
, decl
,
7341 size_int (count
- i
- 1),
7342 NULL_TREE
, NULL_TREE
);
7343 SET_DECL_VALUE_EXPR (first
, v
);
7344 DECL_HAS_VALUE_EXPR_P (first
) = 1;
7346 if (processing_template_decl
)
7347 fit_decomposition_lang_decl (first
, decl
);
7348 first
= DECL_CHAIN (first
);
7353 auto_vec
<tree
, 16> v
;
7354 v
.safe_grow (count
);
7356 for (unsigned int i
= 0; i
< count
; i
++, d
= DECL_CHAIN (d
))
7358 v
[count
- i
- 1] = d
;
7359 fit_decomposition_lang_decl (d
, decl
);
7362 tree type
= TREE_TYPE (decl
);
7365 if (TREE_CODE (type
) == REFERENCE_TYPE
)
7367 dexp
= convert_from_reference (dexp
);
7368 type
= TREE_TYPE (type
);
7371 tree eltype
= NULL_TREE
;
7372 unsigned HOST_WIDE_INT eltscnt
= 0;
7373 if (TREE_CODE (type
) == ARRAY_TYPE
)
7376 nelts
= array_type_nelts_top (type
);
7377 if (nelts
== error_mark_node
)
7379 if (!tree_fits_uhwi_p (nelts
))
7381 error_at (loc
, "cannot decompose variable length array %qT", type
);
7384 eltscnt
= tree_to_uhwi (nelts
);
7385 if (count
!= eltscnt
)
7388 if (count
> eltscnt
)
7389 error_at (loc
, "%u names provided while %qT decomposes into "
7390 "%wu elements", count
, type
, eltscnt
);
7392 error_at (loc
, "only %u names provided while %qT decomposes into "
7393 "%wu elements", count
, type
, eltscnt
);
7396 eltype
= TREE_TYPE (type
);
7397 for (unsigned int i
= 0; i
< count
; i
++)
7399 TREE_TYPE (v
[i
]) = eltype
;
7400 layout_decl (v
[i
], 0);
7401 if (processing_template_decl
)
7403 tree t
= unshare_expr (dexp
);
7404 t
= build4_loc (DECL_SOURCE_LOCATION (v
[i
]), ARRAY_REF
,
7405 eltype
, t
, size_int (i
), NULL_TREE
,
7407 SET_DECL_VALUE_EXPR (v
[i
], t
);
7408 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7411 /* 2 GNU extensions. */
7412 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
7415 if (count
!= eltscnt
)
7417 eltype
= cp_build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
7418 for (unsigned int i
= 0; i
< count
; i
++)
7420 TREE_TYPE (v
[i
]) = eltype
;
7421 layout_decl (v
[i
], 0);
7422 if (processing_template_decl
)
7424 tree t
= unshare_expr (dexp
);
7425 t
= build1_loc (DECL_SOURCE_LOCATION (v
[i
]),
7426 i
? IMAGPART_EXPR
: REALPART_EXPR
, eltype
,
7428 SET_DECL_VALUE_EXPR (v
[i
], t
);
7429 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7432 else if (TREE_CODE (type
) == VECTOR_TYPE
)
7434 eltscnt
= TYPE_VECTOR_SUBPARTS (type
);
7435 if (count
!= eltscnt
)
7437 eltype
= cp_build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
7438 for (unsigned int i
= 0; i
< count
; i
++)
7440 TREE_TYPE (v
[i
]) = eltype
;
7441 layout_decl (v
[i
], 0);
7442 if (processing_template_decl
)
7444 tree t
= unshare_expr (dexp
);
7445 convert_vector_to_array_for_subscript (DECL_SOURCE_LOCATION (v
[i
]),
7447 t
= build4_loc (DECL_SOURCE_LOCATION (v
[i
]), ARRAY_REF
,
7448 eltype
, t
, size_int (i
), NULL_TREE
,
7450 SET_DECL_VALUE_EXPR (v
[i
], t
);
7451 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7454 else if (tree tsize
= get_tuple_size (type
))
7456 if (tsize
== error_mark_node
)
7458 error_at (loc
, "%<std::tuple_size<%T>::value%> is not an integral "
7459 "constant expression", type
);
7462 eltscnt
= tree_to_uhwi (tsize
);
7463 if (count
!= eltscnt
)
7465 int save_read
= DECL_READ_P (decl
);
7466 for (unsigned i
= 0; i
< count
; ++i
)
7468 location_t sloc
= input_location
;
7469 location_t dloc
= DECL_SOURCE_LOCATION (v
[i
]);
7471 input_location
= dloc
;
7472 tree init
= get_tuple_decomp_init (decl
, i
);
7473 tree eltype
= (init
== error_mark_node
? error_mark_node
7474 : get_tuple_element_type (type
, i
));
7475 input_location
= sloc
;
7477 if (init
== error_mark_node
|| eltype
== error_mark_node
)
7479 inform (dloc
, "in initialization of structured binding "
7480 "variable %qD", v
[i
]);
7483 /* Save the decltype away before reference collapse. */
7484 store_decomp_type (v
[i
], eltype
);
7485 eltype
= cp_build_reference_type (eltype
, !lvalue_p (init
));
7486 TREE_TYPE (v
[i
]) = eltype
;
7487 layout_decl (v
[i
], 0);
7488 if (DECL_HAS_VALUE_EXPR_P (v
[i
]))
7490 /* In this case the names are variables, not just proxies. */
7491 SET_DECL_VALUE_EXPR (v
[i
], NULL_TREE
);
7492 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 0;
7494 if (!processing_template_decl
)
7495 cp_finish_decl (v
[i
], init
, /*constexpr*/false,
7496 /*asm*/NULL_TREE
, LOOKUP_NORMAL
);
7498 /* Ignore reads from the underlying decl performed during initialization
7499 of the individual variables. If those will be read, we'll mark
7500 the underlying decl as read at that point. */
7501 DECL_READ_P (decl
) = save_read
;
7503 else if (TREE_CODE (type
) == UNION_TYPE
)
7505 error_at (loc
, "cannot decompose union type %qT", type
);
7508 else if (!CLASS_TYPE_P (type
))
7510 error_at (loc
, "cannot decompose non-array non-class type %qT", type
);
7513 else if (LAMBDA_TYPE_P (type
))
7515 error_at (loc
, "cannot decompose lambda closure type %qT", type
);
7520 tree btype
= find_decomp_class_base (loc
, type
, NULL_TREE
);
7521 if (btype
== error_mark_node
)
7523 else if (btype
== NULL_TREE
)
7525 error_at (loc
, "cannot decompose class type %qT without non-static "
7526 "data members", type
);
7529 for (tree field
= TYPE_FIELDS (btype
); field
; field
= TREE_CHAIN (field
))
7530 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
7534 if (count
!= eltscnt
)
7539 t
= convert_to_base (t
, btype
, /*check_access*/true,
7540 /*nonnull*/false, tf_warning_or_error
);
7544 for (tree field
= TYPE_FIELDS (btype
); field
; field
= TREE_CHAIN (field
))
7545 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
7549 tree tt
= finish_non_static_data_member (field
, unshare_expr (t
),
7551 if (REFERENCE_REF_P (tt
))
7552 tt
= TREE_OPERAND (tt
, 0);
7553 TREE_TYPE (v
[i
]) = TREE_TYPE (tt
);
7554 layout_decl (v
[i
], 0);
7555 if (!processing_template_decl
)
7557 SET_DECL_VALUE_EXPR (v
[i
], tt
);
7558 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7563 if (processing_template_decl
)
7565 for (unsigned int i
= 0; i
< count
; i
++)
7566 if (!DECL_HAS_VALUE_EXPR_P (v
[i
]))
7568 tree a
= build_nt (ARRAY_REF
, decl
, size_int (i
),
7569 NULL_TREE
, NULL_TREE
);
7570 SET_DECL_VALUE_EXPR (v
[i
], a
);
7571 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7574 else if (DECL_NAMESPACE_SCOPE_P (decl
))
7575 SET_DECL_ASSEMBLER_NAME (decl
, mangle_decomp (decl
, v
));
7578 /* Returns a declaration for a VAR_DECL as if:
7580 extern "C" TYPE NAME;
7582 had been seen. Used to create compiler-generated global
7586 declare_global_var (tree name
, tree type
)
7590 push_to_top_level ();
7591 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7592 TREE_PUBLIC (decl
) = 1;
7593 DECL_EXTERNAL (decl
) = 1;
7594 DECL_ARTIFICIAL (decl
) = 1;
7595 DECL_CONTEXT (decl
) = FROB_CONTEXT (global_namespace
);
7596 /* If the user has explicitly declared this variable (perhaps
7597 because the code we are compiling is part of a low-level runtime
7598 library), then it is possible that our declaration will be merged
7599 with theirs by pushdecl. */
7600 decl
= pushdecl (decl
);
7601 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
7602 pop_from_top_level ();
7607 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
7608 if "__cxa_atexit" is not being used) corresponding to the function
7609 to be called when the program exits. */
7612 get_atexit_fn_ptr_type (void)
7616 if (!atexit_fn_ptr_type_node
)
7619 if (flag_use_cxa_atexit
7620 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7621 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
7622 arg_type
= ptr_type_node
;
7624 /* The parameter to "atexit" is "void (*)(void)". */
7625 arg_type
= NULL_TREE
;
7627 fn_type
= build_function_type_list (void_type_node
,
7628 arg_type
, NULL_TREE
);
7629 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
7632 return atexit_fn_ptr_type_node
;
7635 /* Returns a pointer to the `atexit' function. Note that if
7636 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
7637 `__cxa_atexit' function specified in the IA64 C++ ABI. */
7640 get_atexit_node (void)
7646 bool use_aeabi_atexit
;
7651 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7653 /* The declaration for `__cxa_atexit' is:
7655 int __cxa_atexit (void (*)(void *), void *, void *)
7657 We build up the argument types and then the function type
7659 tree argtype0
, argtype1
, argtype2
;
7661 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
7662 /* First, build the pointer-to-function type for the first
7664 fn_ptr_type
= get_atexit_fn_ptr_type ();
7665 /* Then, build the rest of the argument types. */
7666 argtype2
= ptr_type_node
;
7667 if (use_aeabi_atexit
)
7669 argtype1
= fn_ptr_type
;
7670 argtype0
= ptr_type_node
;
7674 argtype1
= ptr_type_node
;
7675 argtype0
= fn_ptr_type
;
7677 /* And the final __cxa_atexit type. */
7678 fn_type
= build_function_type_list (integer_type_node
,
7679 argtype0
, argtype1
, argtype2
,
7681 if (use_aeabi_atexit
)
7682 name
= "__aeabi_atexit";
7684 name
= "__cxa_atexit";
7688 /* The declaration for `atexit' is:
7690 int atexit (void (*)());
7692 We build up the argument types and then the function type
7694 fn_ptr_type
= get_atexit_fn_ptr_type ();
7695 /* Build the final atexit type. */
7696 fn_type
= build_function_type_list (integer_type_node
,
7697 fn_ptr_type
, NULL_TREE
);
7701 /* Now, build the function declaration. */
7702 push_lang_context (lang_name_c
);
7703 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
7704 mark_used (atexit_fndecl
);
7705 pop_lang_context ();
7706 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7711 /* Like get_atexit_node, but for thread-local cleanups. */
7714 get_thread_atexit_node (void)
7716 /* The declaration for `__cxa_thread_atexit' is:
7718 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
7719 tree fn_type
= build_function_type_list (integer_type_node
,
7720 get_atexit_fn_ptr_type (),
7721 ptr_type_node
, ptr_type_node
,
7724 /* Now, build the function declaration. */
7725 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
7726 ECF_LEAF
| ECF_NOTHROW
);
7727 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7730 /* Returns the __dso_handle VAR_DECL. */
7733 get_dso_handle_node (void)
7735 if (dso_handle_node
)
7736 return dso_handle_node
;
7738 /* Declare the variable. */
7739 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
7742 #ifdef HAVE_GAS_HIDDEN
7743 if (dso_handle_node
!= error_mark_node
)
7745 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
7746 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
7750 return dso_handle_node
;
7753 /* Begin a new function with internal linkage whose job will be simply
7754 to destroy some particular variable. */
7756 static GTY(()) int start_cleanup_cnt
;
7759 start_cleanup_fn (void)
7764 bool use_cxa_atexit
= flag_use_cxa_atexit
7765 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
7767 push_to_top_level ();
7769 /* No need to mangle this. */
7770 push_lang_context (lang_name_c
);
7772 /* Build the name of the function. */
7773 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
7774 /* Build the function declaration. */
7775 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
7776 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
7777 /* It's a function with internal linkage, generated by the
7779 TREE_PUBLIC (fndecl
) = 0;
7780 DECL_ARTIFICIAL (fndecl
) = 1;
7781 /* Make the function `inline' so that it is only emitted if it is
7782 actually needed. It is unlikely that it will be inlined, since
7783 it is only called via a function pointer, but we avoid unnecessary
7784 emissions this way. */
7785 DECL_DECLARED_INLINE_P (fndecl
) = 1;
7786 DECL_INTERFACE_KNOWN (fndecl
) = 1;
7787 /* Build the parameter. */
7790 tree parmdecl
= cp_build_parm_decl (fndecl
, NULL_TREE
, ptr_type_node
);
7791 TREE_USED (parmdecl
) = 1;
7792 DECL_READ_P (parmdecl
) = 1;
7793 DECL_ARGUMENTS (fndecl
) = parmdecl
;
7797 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
7799 pop_lang_context ();
7801 return current_function_decl
;
7804 /* Finish the cleanup function begun by start_cleanup_fn. */
7807 end_cleanup_fn (void)
7809 expand_or_defer_fn (finish_function (/*inline_p=*/false));
7811 pop_from_top_level ();
7814 /* Generate code to handle the destruction of DECL, an object with
7815 static storage duration. */
7818 register_dtor_fn (tree decl
)
7825 bool ob_parm
, dso_parm
, use_dtor
;
7826 tree arg0
, arg1
, arg2
;
7829 type
= TREE_TYPE (decl
);
7830 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
7833 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7834 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7835 destructor to "__cxa_atexit"; we don't have to build a temporary
7836 function to do the cleanup. */
7837 dso_parm
= (flag_use_cxa_atexit
7838 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
7839 ob_parm
= (CP_DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
7840 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
7843 cleanup
= get_class_binding (type
, complete_dtor_identifier
);
7845 /* Make sure it is accessible. */
7846 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
7847 tf_warning_or_error
);
7851 /* Call build_cleanup before we enter the anonymous function so
7852 that any access checks will be done relative to the current
7853 scope, rather than the scope of the anonymous function. */
7854 build_cleanup (decl
);
7856 /* Now start the function. */
7857 cleanup
= start_cleanup_fn ();
7859 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7860 to the original function, rather than the anonymous one. That
7861 will make the back end think that nested functions are in use,
7862 which causes confusion. */
7863 push_deferring_access_checks (dk_no_check
);
7864 fcall
= build_cleanup (decl
);
7865 pop_deferring_access_checks ();
7867 /* Create the body of the anonymous function. */
7868 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
7869 finish_expr_stmt (fcall
);
7870 finish_compound_stmt (compound_stmt
);
7874 /* Call atexit with the cleanup function. */
7875 mark_used (cleanup
);
7876 cleanup
= build_address (cleanup
);
7878 if (CP_DECL_THREAD_LOCAL_P (decl
))
7879 atex_node
= get_thread_atexit_node ();
7881 atex_node
= get_atexit_node ();
7885 /* We must convert CLEANUP to the type that "__cxa_atexit"
7887 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
7888 /* "__cxa_atexit" will pass the address of DECL to the
7889 cleanup function. */
7891 addr
= build_address (decl
);
7892 /* The declared type of the parameter to "__cxa_atexit" is
7893 "void *". For plain "T*", we could just let the
7894 machinery in cp_build_function_call convert it -- but if the
7895 type is "cv-qualified T *", then we need to convert it
7896 before passing it in, to avoid spurious errors. */
7897 addr
= build_nop (ptr_type_node
, addr
);
7900 /* Since the cleanup functions we build ignore the address
7901 they're given, there's no reason to pass the actual address
7902 in, and, in general, it's cheaper to pass NULL than any
7904 addr
= null_pointer_node
;
7907 arg2
= cp_build_addr_expr (get_dso_handle_node (),
7908 tf_warning_or_error
);
7910 /* Just pass NULL to the dso handle parm if we don't actually
7911 have a DSO handle on this target. */
7912 arg2
= null_pointer_node
;
7918 if (!CP_DECL_THREAD_LOCAL_P (decl
)
7919 && targetm
.cxx
.use_aeabi_atexit ())
7935 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
7936 arg0
, arg1
, arg2
, NULL_TREE
);
7939 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7940 is its initializer. Generate code to handle the construction
7941 and destruction of DECL. */
7944 expand_static_init (tree decl
, tree init
)
7946 gcc_assert (VAR_P (decl
));
7947 gcc_assert (TREE_STATIC (decl
));
7949 /* Some variables require no dynamic initialization. */
7950 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
7952 /* Make sure the destructor is callable. */
7953 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
7958 if (CP_DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
7959 && !DECL_FUNCTION_SCOPE_P (decl
))
7962 error ("non-local variable %qD declared %<__thread%> "
7963 "needs dynamic initialization", decl
);
7965 error ("non-local variable %qD declared %<__thread%> "
7966 "has a non-trivial destructor", decl
);
7967 static bool informed
;
7970 inform (DECL_SOURCE_LOCATION (decl
),
7971 "C++11 %<thread_local%> allows dynamic initialization "
7978 if (DECL_FUNCTION_SCOPE_P (decl
))
7980 /* Emit code to perform this initialization but once. */
7981 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
7982 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
7983 tree guard
, guard_addr
;
7985 /* We don't need thread-safety code for thread-local vars. */
7986 bool thread_guard
= (flag_threadsafe_statics
7987 && !CP_DECL_THREAD_LOCAL_P (decl
));
7989 /* Emit code to perform this initialization but once. This code
7992 static <type> guard;
7993 if (!__atomic_load (guard.first_byte)) {
7994 if (__cxa_guard_acquire (&guard)) {
7997 // Do initialization.
7998 flag = true; __cxa_guard_release (&guard);
7999 // Register variable for destruction at end of program.
8001 if (!flag) __cxa_guard_abort (&guard);
8006 Note that the `flag' variable is only set to 1 *after* the
8007 initialization is complete. This ensures that an exception,
8008 thrown during the construction, will cause the variable to
8009 reinitialized when we pass through this code again, as per:
8013 If the initialization exits by throwing an exception, the
8014 initialization is not complete, so it will be tried again
8015 the next time control enters the declaration.
8017 This process should be thread-safe, too; multiple threads
8018 should not be able to initialize the variable more than
8021 /* Create the guard variable. */
8022 guard
= get_guard (decl
);
8024 /* Begin the conditional initialization. */
8025 if_stmt
= begin_if_stmt ();
8027 finish_if_stmt_cond (get_guard_cond (guard
, thread_guard
), if_stmt
);
8028 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
8032 tree vfntype
= NULL_TREE
;
8033 tree acquire_name
, release_name
, abort_name
;
8034 tree acquire_fn
, release_fn
, abort_fn
;
8035 guard_addr
= build_address (guard
);
8037 acquire_name
= get_identifier ("__cxa_guard_acquire");
8038 release_name
= get_identifier ("__cxa_guard_release");
8039 abort_name
= get_identifier ("__cxa_guard_abort");
8040 acquire_fn
= get_global_binding (acquire_name
);
8041 release_fn
= get_global_binding (release_name
);
8042 abort_fn
= get_global_binding (abort_name
);
8044 acquire_fn
= push_library_fn
8045 (acquire_name
, build_function_type_list (integer_type_node
,
8046 TREE_TYPE (guard_addr
),
8048 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
8049 if (!release_fn
|| !abort_fn
)
8050 vfntype
= build_function_type_list (void_type_node
,
8051 TREE_TYPE (guard_addr
),
8054 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
8055 ECF_NOTHROW
| ECF_LEAF
);
8057 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
8058 ECF_NOTHROW
| ECF_LEAF
);
8060 inner_if_stmt
= begin_if_stmt ();
8061 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
8064 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
8065 begin
= get_target_expr (boolean_false_node
);
8066 flag
= TARGET_EXPR_SLOT (begin
);
8068 TARGET_EXPR_CLEANUP (begin
)
8069 = build3 (COND_EXPR
, void_type_node
, flag
,
8071 build_call_n (abort_fn
, 1, guard_addr
));
8072 CLEANUP_EH_ONLY (begin
) = 1;
8074 /* Do the initialization itself. */
8075 init
= add_stmt_to_compound (begin
, init
);
8076 init
= add_stmt_to_compound
8077 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
8078 init
= add_stmt_to_compound
8079 (init
, build_call_n (release_fn
, 1, guard_addr
));
8082 init
= add_stmt_to_compound (init
, set_guard (guard
));
8084 /* Use atexit to register a function for destroying this static
8086 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
8088 finish_expr_stmt (init
);
8092 finish_compound_stmt (inner_then_clause
);
8093 finish_then_clause (inner_if_stmt
);
8094 finish_if_stmt (inner_if_stmt
);
8097 finish_compound_stmt (then_clause
);
8098 finish_then_clause (if_stmt
);
8099 finish_if_stmt (if_stmt
);
8101 else if (CP_DECL_THREAD_LOCAL_P (decl
))
8102 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
8104 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
8108 /* Make TYPE a complete type based on INITIAL_VALUE.
8109 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8110 2 if there was no information (in which case assume 0 if DO_DEFAULT),
8111 3 if the initializer list is empty (in pedantic mode). */
8114 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
8117 tree type
, elt_type
;
8119 /* Don't get confused by a CONSTRUCTOR for some other type. */
8120 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
8121 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
)
8122 && TREE_CODE (TREE_TYPE (initial_value
)) != ARRAY_TYPE
)
8127 unsigned HOST_WIDE_INT i
;
8130 /* An array of character type can be initialized from a
8131 brace-enclosed string constant.
8133 FIXME: this code is duplicated from reshape_init. Probably
8134 we should just call reshape_init here? */
8135 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
8136 && TREE_CODE (initial_value
) == CONSTRUCTOR
8137 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
8139 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
8140 tree value
= (*v
)[0].value
;
8142 if (TREE_CODE (value
) == STRING_CST
8143 && v
->length () == 1)
8144 initial_value
= value
;
8147 /* If any of the elements are parameter packs, we can't actually
8148 complete this type now because the array size is dependent. */
8149 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8151 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
8154 if (PACK_EXPANSION_P (value
))
8160 failure
= complete_array_type (ptype
, initial_value
, do_default
);
8162 /* We can create the array before the element type is complete, which
8163 means that we didn't have these two bits set in the original type
8164 either. In completing the type, we are expected to propagate these
8165 bits. See also complete_type which does the same thing for arrays
8168 if (TYPE_DOMAIN (type
))
8170 elt_type
= TREE_TYPE (type
);
8171 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
8172 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
8173 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
8179 /* As above, but either give an error or reject zero-size arrays, depending
8183 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
8184 bool do_default
, tsubst_flags_t complain
)
8187 bool sfinae
= !(complain
& tf_error
);
8188 /* In SFINAE context we can't be lenient about zero-size arrays. */
8191 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
8197 /* Not an error. */;
8198 else if (failure
== 1)
8199 error ("initializer fails to determine size of %qT", *ptype
);
8200 else if (failure
== 2)
8203 error ("array size missing in %qT", *ptype
);
8205 else if (failure
== 3)
8206 error ("zero-size array %qT", *ptype
);
8207 *ptype
= error_mark_node
;
8212 /* Return zero if something is declared to be a member of type
8213 CTYPE when in the context of CUR_TYPE. STRING is the error
8214 message to print in that case. Otherwise, quietly return 1. */
8217 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
8219 if (ctype
&& ctype
!= cur_type
)
8221 if (flags
== DTOR_FLAG
)
8222 error ("destructor for alien class %qT cannot be a member", ctype
);
8224 error ("constructor for alien class %qT cannot be a member", ctype
);
8230 /* Subroutine of `grokdeclarator'. */
8232 /* Generate errors possibly applicable for a given set of specifiers.
8233 This is for ARM $7.1.2. */
8236 bad_specifiers (tree object
,
8237 enum bad_spec_place type
,
8248 error ("%qD declared as a %<virtual%> variable", object
);
8250 error ("%<const%> and %<volatile%> function specifiers on "
8251 "%qD invalid in variable declaration", object
);
8255 error ("%qD declared as a %<virtual%> parameter", object
);
8257 error ("%qD declared as an %<inline%> parameter", object
);
8259 error ("%<const%> and %<volatile%> function specifiers on "
8260 "%qD invalid in parameter declaration", object
);
8264 error ("%qD declared as a %<virtual%> type", object
);
8266 error ("%qD declared as an %<inline%> type", object
);
8268 error ("%<const%> and %<volatile%> function specifiers on "
8269 "%qD invalid in type declaration", object
);
8273 error ("%qD declared as a %<virtual%> field", object
);
8275 error ("%qD declared as an %<inline%> field", object
);
8277 error ("%<const%> and %<volatile%> function specifiers on "
8278 "%qD invalid in field declaration", object
);
8284 error ("%q+D declared as a friend", object
);
8286 && !flag_noexcept_type
8287 && (TREE_CODE (object
) == TYPE_DECL
8288 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
8289 && !TYPE_REFFN_P (TREE_TYPE (object
))
8290 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
8291 error ("%q+D declared with an exception specification", object
);
8294 /* DECL is a member function or static data member and is presently
8295 being defined. Check that the definition is taking place in a
8299 check_class_member_definition_namespace (tree decl
)
8301 /* These checks only apply to member functions and static data
8303 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
8304 /* We check for problems with specializations in pt.c in
8305 check_specialization_namespace, where we can issue better
8307 if (processing_specialization
)
8309 /* We check this in check_explicit_instantiation_namespace. */
8310 if (processing_explicit_instantiation
)
8314 A member function definition that appears outside of the
8315 class definition shall appear in a namespace scope enclosing
8316 the class definition.
8320 The definition for a static data member shall appear in a
8321 namespace scope enclosing the member's class definition. */
8322 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
8323 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
8324 decl
, DECL_CONTEXT (decl
));
8327 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
8328 METHOD_TYPE for a non-static member function; QUALS are the
8329 cv-qualifiers that apply to the function. */
8332 build_this_parm (tree fn
, tree type
, cp_cv_quals quals
)
8337 cp_cv_quals this_quals
;
8339 if (CLASS_TYPE_P (type
))
8342 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
8343 this_type
= build_pointer_type (this_type
);
8346 this_type
= type_of_this_parm (type
);
8347 /* The `this' parameter is implicitly `const'; it cannot be
8349 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
8350 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
8351 parm
= build_artificial_parm (fn
, this_identifier
, qual_type
);
8352 cp_apply_type_quals_to_decl (this_quals
, parm
);
8356 /* DECL is a static member function. Complain if it was declared
8357 with function-cv-quals. */
8360 check_static_quals (tree decl
, cp_cv_quals quals
)
8362 if (quals
!= TYPE_UNQUALIFIED
)
8363 error ("static member function %q#D declared with type qualifiers",
8367 // Check that FN takes no arguments and returns bool.
8369 check_concept_fn (tree fn
)
8371 // A constraint is nullary.
8372 if (DECL_ARGUMENTS (fn
))
8373 error ("concept %q#D declared with function parameters", fn
);
8375 // The declared return type of the concept shall be bool, and
8376 // it shall not be deduced from it definition.
8377 tree type
= TREE_TYPE (TREE_TYPE (fn
));
8379 error ("concept %q#D declared with a deduced return type", fn
);
8380 else if (type
!= boolean_type_node
)
8381 error ("concept %q#D with non-%<bool%> return type %qT", fn
, type
);
8384 /* Helper function. Replace the temporary this parameter injected
8385 during cp_finish_omp_declare_simd with the real this parameter. */
8388 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
8390 tree this_parm
= (tree
) data
;
8391 if (TREE_CODE (*tp
) == PARM_DECL
8392 && DECL_NAME (*tp
) == this_identifier
8393 && *tp
!= this_parm
)
8395 else if (TYPE_P (*tp
))
8400 /* CTYPE is class type, or null if non-class.
8401 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8403 DECLARATOR is the function's name.
8404 PARMS is a chain of PARM_DECLs for the function.
8405 VIRTUALP is truthvalue of whether the function is virtual or not.
8406 FLAGS are to be passed through to `grokclassfn'.
8407 QUALS are qualifiers indicating whether the function is `const'
8409 RAISES is a list of exceptions that this function can raise.
8410 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8411 not look, and -1 if we should not call `grokclassfn' at all.
8413 SFK is the kind of special function (if any) for the new function.
8415 Returns `NULL_TREE' if something goes wrong, after issuing
8416 applicable error messages. */
8419 grokfndecl (tree ctype
,
8423 tree orig_declarator
,
8426 enum overload_flags flags
,
8428 cp_ref_qualifier rqual
,
8435 special_function_kind sfk
,
8440 location_t location
)
8443 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8446 // Was the concept specifier present?
8447 bool concept_p
= inlinep
& 4;
8449 // Concept declarations must have a corresponding definition.
8450 if (concept_p
&& !funcdef_flag
)
8452 error ("concept %qD has no definition", declarator
);
8457 type
= build_ref_qualified_type (type
, rqual
);
8459 type
= build_exception_variant (type
, raises
);
8461 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8463 /* Set the constraints on the declaration. */
8466 tree tmpl_reqs
= NULL_TREE
;
8467 if (processing_template_decl
> template_class_depth (ctype
))
8468 tmpl_reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
8470 /* Adjust the required expression into a constraint. */
8472 decl_reqs
= normalize_expression (decl_reqs
);
8474 tree ci
= build_constraints (tmpl_reqs
, decl_reqs
);
8475 set_constraints (decl
, ci
);
8478 /* If we have an explicit location, use it, otherwise use whatever
8479 build_lang_decl used (probably input_location). */
8480 if (location
!= UNKNOWN_LOCATION
)
8481 DECL_SOURCE_LOCATION (decl
) = location
;
8483 if (TREE_CODE (type
) == METHOD_TYPE
)
8485 tree parm
= build_this_parm (decl
, type
, quals
);
8486 DECL_CHAIN (parm
) = parms
;
8489 /* Allocate space to hold the vptr bit if needed. */
8490 SET_DECL_ALIGN (decl
, MINIMUM_METHOD_BOUNDARY
);
8493 DECL_ARGUMENTS (decl
) = parms
;
8494 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
8495 DECL_CONTEXT (t
) = decl
;
8497 /* Propagate volatile out from type to decl. */
8498 if (TYPE_VOLATILE (type
))
8499 TREE_THIS_VOLATILE (decl
) = 1;
8501 /* Setup decl according to sfk. */
8504 case sfk_constructor
:
8505 case sfk_copy_constructor
:
8506 case sfk_move_constructor
:
8507 DECL_CXX_CONSTRUCTOR_P (decl
) = 1;
8508 DECL_NAME (decl
) = ctor_identifier
;
8510 case sfk_destructor
:
8511 DECL_CXX_DESTRUCTOR_P (decl
) = 1;
8512 DECL_NAME (decl
) = dtor_identifier
;
8518 if (friendp
&& TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8521 error ("defining explicit specialization %qD in friend declaration",
8525 tree fns
= TREE_OPERAND (orig_declarator
, 0);
8526 tree args
= TREE_OPERAND (orig_declarator
, 1);
8528 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8530 /* Something like `template <class T> friend void f<T>()'. */
8531 error ("invalid use of template-id %qD in declaration "
8532 "of primary template",
8538 /* A friend declaration of the form friend void f<>(). Record
8539 the information in the TEMPLATE_ID_EXPR. */
8540 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8542 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
8543 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
8545 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8546 if (TREE_PURPOSE (t
)
8547 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8549 error ("default arguments are not allowed in declaration "
8550 "of friend template specialization %qD",
8557 error ("%<inline%> is not allowed in declaration of friend "
8558 "template specialization %qD",
8565 /* If this decl has namespace scope, set that up. */
8567 set_decl_namespace (decl
, in_namespace
, friendp
);
8569 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
8571 /* `main' and builtins have implicit 'C' linkage. */
8572 if (ctype
== NULL_TREE
8573 && DECL_FILE_SCOPE_P (decl
)
8574 && current_lang_name
== lang_name_cplusplus
8575 && (MAIN_NAME_P (declarator
)
8576 || (IDENTIFIER_LENGTH (declarator
) > 10
8577 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8578 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8579 && strncmp (IDENTIFIER_POINTER (declarator
)+2,
8580 "builtin_", 8) == 0)
8581 || (targetcm
.cxx_implicit_extern_c
8582 && (targetcm
.cxx_implicit_extern_c
8583 (IDENTIFIER_POINTER (declarator
))))))
8584 SET_DECL_LANGUAGE (decl
, lang_c
);
8586 /* Should probably propagate const out from type to decl I bet (mrs). */
8589 DECL_STATIC_FUNCTION_P (decl
) = 1;
8590 DECL_CONTEXT (decl
) = ctype
;
8594 DECL_DELETED_FN (decl
) = 1;
8598 DECL_CONTEXT (decl
) = ctype
;
8600 check_class_member_definition_namespace (decl
);
8603 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8605 if (PROCESSING_REAL_TEMPLATE_DECL_P())
8606 error ("cannot declare %<::main%> to be a template");
8608 error ("cannot declare %<::main%> to be inline");
8610 error ("cannot declare %<::main%> to be constexpr");
8612 error ("cannot declare %<::main%> to be static");
8617 /* Members of anonymous types and local classes have no linkage; make
8618 them internal. If a typedef is made later, this will be changed. */
8619 if (ctype
&& (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype
))
8620 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
8623 if (publicp
&& cxx_dialect
== cxx98
)
8625 /* [basic.link]: A name with no linkage (notably, the name of a class
8626 or enumeration declared in a local scope) shall not be used to
8627 declare an entity with linkage.
8629 DR 757 relaxes this restriction for C++0x. */
8630 no_linkage_error (decl
);
8633 TREE_PUBLIC (decl
) = publicp
;
8636 DECL_INTERFACE_KNOWN (decl
) = 1;
8637 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8640 /* If the declaration was declared inline, mark it as such. */
8643 DECL_DECLARED_INLINE_P (decl
) = 1;
8645 DECL_COMDAT (decl
) = 1;
8648 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
8650 // If the concept declaration specifier was found, check
8651 // that the declaration satisfies the necessary requirements.
8654 DECL_DECLARED_CONCEPT_P (decl
) = true;
8655 check_concept_fn (decl
);
8658 DECL_EXTERNAL (decl
) = 1;
8659 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8662 TREE_TYPE (decl
) = apply_memfn_quals (TREE_TYPE (decl
),
8669 ? G_("static member function %qD cannot have cv-qualifier")
8670 : G_("non-member function %qD cannot have cv-qualifier"),
8672 quals
= TYPE_UNQUALIFIED
;
8678 ? G_("static member function %qD cannot have ref-qualifier")
8679 : G_("non-member function %qD cannot have ref-qualifier"),
8681 rqual
= REF_QUAL_NONE
;
8685 if (deduction_guide_p (decl
))
8687 if (!DECL_NAMESPACE_SCOPE_P (decl
))
8689 error_at (location
, "deduction guide %qD must be declared at "
8690 "namespace scope", decl
);
8695 "deduction guide %qD must not have a function body", decl
);
8697 else if (IDENTIFIER_ANY_OP_P (DECL_NAME (decl
))
8698 && !grok_op_properties (decl
, /*complain=*/true))
8700 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
8702 bool long_long_unsigned_p
;
8704 const char *suffix
= NULL
;
8705 /* [over.literal]/6: Literal operators shall not have C linkage. */
8706 if (DECL_LANGUAGE (decl
) == lang_c
)
8708 error ("literal operator with C linkage");
8709 maybe_show_extern_c_location ();
8713 if (DECL_NAMESPACE_SCOPE_P (decl
))
8715 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
8718 error ("%qD has invalid argument list", decl
);
8722 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
8723 if (long_long_unsigned_p
)
8725 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
8726 warning (0, "integer suffix %qs"
8727 " shadowed by implementation", suffix
);
8729 else if (long_double_p
)
8731 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
8732 warning (0, "floating point suffix %qs"
8733 " shadowed by implementation", suffix
);
8738 error ("%qD must be a non-member function", decl
);
8744 /* Make the init_value nonzero so pushdecl knows this is not
8745 tentative. error_mark_node is replaced later with the BLOCK. */
8746 DECL_INITIAL (decl
) = error_mark_node
;
8748 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
8749 TREE_NOTHROW (decl
) = 1;
8751 if (flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
8753 /* Adjust "omp declare simd" attributes. */
8754 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
8758 for (attr
= ods
; attr
;
8759 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
8761 if (TREE_CODE (type
) == METHOD_TYPE
)
8762 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
8763 DECL_ARGUMENTS (decl
), NULL
);
8764 if (TREE_VALUE (attr
) != NULL_TREE
)
8766 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
8767 cl
= c_omp_declare_simd_clauses_to_numbers
8768 (DECL_ARGUMENTS (decl
), cl
);
8770 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
8772 TREE_VALUE (attr
) = NULL_TREE
;
8778 /* Caller will do the rest of this. */
8782 if (ctype
!= NULL_TREE
)
8783 grokclassfn (ctype
, decl
, flags
);
8786 if (cxx_dialect
>= cxx11
8787 && DECL_DESTRUCTOR_P (decl
)
8788 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
8789 && !processing_template_decl
)
8790 deduce_noexcept_on_destructor (decl
);
8792 decl
= check_explicit_specialization (orig_declarator
, decl
,
8795 4 * (friendp
!= 0) +
8797 if (decl
== error_mark_node
)
8800 if (DECL_STATIC_FUNCTION_P (decl
))
8801 check_static_quals (decl
, quals
);
8805 cplus_decl_attributes (&decl
, *attrlist
, 0);
8806 *attrlist
= NULL_TREE
;
8809 /* Check main's type after attributes have been applied. */
8810 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8812 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
8815 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
8817 error ("%<::main%> must return %<int%>");
8818 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
8819 TREE_TYPE (decl
) = newtype
;
8822 check_main_parameter_types (decl
);
8825 if (ctype
!= NULL_TREE
&& check
)
8827 tree old_decl
= check_classfn (ctype
, decl
,
8828 (processing_template_decl
8829 > template_class_depth (ctype
))
8830 ? current_template_parms
8833 if (old_decl
== error_mark_node
)
8841 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
8842 /* Because grokfndecl is always supposed to return a
8843 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8844 here. We depend on our callers to figure out that its
8845 really a template that's being returned. */
8846 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
8848 if (DECL_STATIC_FUNCTION_P (old_decl
)
8849 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8851 /* Remove the `this' parm added by grokclassfn. */
8852 revert_static_member_fn (decl
);
8853 check_static_quals (decl
, quals
);
8855 if (DECL_ARTIFICIAL (old_decl
))
8857 error ("definition of implicitly-declared %qD", old_decl
);
8860 else if (DECL_DEFAULTED_FN (old_decl
))
8862 error ("definition of explicitly-defaulted %q+D", decl
);
8863 inform (DECL_SOURCE_LOCATION (old_decl
),
8864 "%q#D explicitly defaulted here", old_decl
);
8868 /* Since we've smashed OLD_DECL to its
8869 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8870 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8871 decl
= DECL_TEMPLATE_RESULT (decl
);
8873 /* Attempt to merge the declarations. This can fail, in
8874 the case of some invalid specialization declarations. */
8875 pushed_scope
= push_scope (ctype
);
8876 ok
= duplicate_decls (decl
, old_decl
, friendp
);
8878 pop_scope (pushed_scope
);
8881 error ("no %q#D member function declared in class %qT",
8885 if (ok
== error_mark_node
)
8891 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
8894 if (ctype
== NULL_TREE
|| check
)
8898 DECL_VIRTUAL_P (decl
) = 1;
8903 /* decl is a FUNCTION_DECL.
8904 specifiers are the parsed virt-specifiers.
8906 Set flags to reflect the virt-specifiers.
8911 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
8913 if (decl
== NULL_TREE
)
8915 if (specifiers
& VIRT_SPEC_OVERRIDE
)
8916 DECL_OVERRIDE_P (decl
) = 1;
8917 if (specifiers
& VIRT_SPEC_FINAL
)
8918 DECL_FINAL_P (decl
) = 1;
8922 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8923 the linkage that DECL will receive in the object file. */
8926 set_linkage_for_static_data_member (tree decl
)
8928 /* A static data member always has static storage duration and
8929 external linkage. Note that static data members are forbidden in
8930 local classes -- the only situation in which a class has
8931 non-external linkage. */
8932 TREE_PUBLIC (decl
) = 1;
8933 TREE_STATIC (decl
) = 1;
8934 /* For non-template classes, static data members are always put
8935 out in exactly those files where they are defined, just as
8936 with ordinary namespace-scope variables. */
8937 if (!processing_template_decl
)
8938 DECL_INTERFACE_KNOWN (decl
) = 1;
8941 /* Create a VAR_DECL named NAME with the indicated TYPE.
8943 If SCOPE is non-NULL, it is the class type or namespace containing
8944 the variable. If SCOPE is NULL, the variable should is created in
8945 the innermost enclosing scope. */
8948 grokvardecl (tree type
,
8950 tree orig_declarator
,
8951 const cp_decl_specifier_seq
*declspecs
,
8960 tree explicit_scope
;
8962 gcc_assert (!name
|| identifier_p (name
));
8964 bool constp
= (type_quals
& TYPE_QUAL_CONST
) != 0;
8965 bool volatilep
= (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
8967 /* Compute the scope in which to place the variable, but remember
8968 whether or not that scope was explicitly specified by the user. */
8969 explicit_scope
= scope
;
8972 /* An explicit "extern" specifier indicates a namespace-scope
8974 if (declspecs
->storage_class
== sc_extern
)
8975 scope
= current_decl_namespace ();
8976 else if (!at_function_scope_p ())
8977 scope
= current_scope ();
8981 && (/* If the variable is a namespace-scope variable declared in a
8982 template, we need DECL_LANG_SPECIFIC. */
8983 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
8984 /* Similarly for namespace-scope variables with language linkage
8986 || (TREE_CODE (scope
) == NAMESPACE_DECL
8987 && current_lang_name
!= lang_name_cplusplus
)
8988 /* Similarly for static data members. */
8990 /* Similarly for explicit specializations. */
8992 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
8993 decl
= build_lang_decl (VAR_DECL
, name
, type
);
8995 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
8997 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
8998 set_decl_namespace (decl
, explicit_scope
, 0);
9000 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
9002 if (declspecs
->storage_class
== sc_extern
)
9004 DECL_THIS_EXTERN (decl
) = 1;
9005 DECL_EXTERNAL (decl
) = !initialized
;
9008 if (DECL_CLASS_SCOPE_P (decl
))
9010 set_linkage_for_static_data_member (decl
);
9011 /* This function is only called with out-of-class definitions. */
9012 DECL_EXTERNAL (decl
) = 0;
9013 check_class_member_definition_namespace (decl
);
9015 /* At top level, either `static' or no s.c. makes a definition
9016 (perhaps tentative), and absence of `static' makes it public. */
9017 else if (toplevel_bindings_p ())
9019 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
9020 && (DECL_THIS_EXTERN (decl
)
9024 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
9026 /* Not at top level, only `static' makes a static definition. */
9029 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
9030 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
9033 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
9035 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
9037 CP_DECL_THREAD_LOCAL_P (decl
) = true;
9038 if (!processing_template_decl
)
9039 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
9041 if (declspecs
->gnu_thread_keyword_p
)
9042 SET_DECL_GNU_TLS_P (decl
);
9045 /* If the type of the decl has no linkage, make sure that we'll
9046 notice that in mark_used. */
9047 if (cxx_dialect
> cxx98
9048 && decl_linkage (decl
) != lk_none
9049 && DECL_LANG_SPECIFIC (decl
) == NULL
9050 && !DECL_EXTERN_C_P (decl
)
9051 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
9052 retrofit_lang_decl (decl
);
9054 if (TREE_PUBLIC (decl
))
9056 /* [basic.link]: A name with no linkage (notably, the name of a class
9057 or enumeration declared in a local scope) shall not be used to
9058 declare an entity with linkage.
9060 DR 757 relaxes this restriction for C++0x. */
9061 if (cxx_dialect
< cxx11
)
9062 no_linkage_error (decl
);
9065 DECL_INTERFACE_KNOWN (decl
) = 1;
9067 if (DECL_NAME (decl
)
9068 && MAIN_NAME_P (DECL_NAME (decl
))
9069 && scope
== global_namespace
)
9070 error ("cannot declare %<::main%> to be a global variable");
9072 /* Check that the variable can be safely declared as a concept.
9073 Note that this also forbids explicit specializations. */
9076 if (!processing_template_decl
)
9078 error ("a non-template variable cannot be %<concept%>");
9082 DECL_DECLARED_CONCEPT_P (decl
) = true;
9083 if (!same_type_ignoring_top_level_qualifiers_p (type
, boolean_type_node
))
9084 error_at (declspecs
->locations
[ds_type_spec
],
9085 "concept must have type %<bool%>");
9087 else if (flag_concepts
9088 && processing_template_decl
> template_class_depth (scope
))
9090 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
9091 tree ci
= build_constraints (reqs
, NULL_TREE
);
9092 set_constraints (decl
, ci
);
9095 // Handle explicit specializations and instantiations of variable templates.
9096 if (orig_declarator
)
9097 decl
= check_explicit_specialization (orig_declarator
, decl
,
9098 template_count
, conceptp
* 8);
9100 return decl
!= error_mark_node
? decl
: NULL_TREE
;
9103 /* Create and return a canonical pointer to member function type, for
9104 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9107 build_ptrmemfunc_type (tree type
)
9112 if (type
== error_mark_node
)
9115 /* Make sure that we always have the unqualified pointer-to-member
9117 if (cp_cv_quals quals
= cp_type_quals (type
))
9119 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
9120 return cp_build_qualified_type (unqual
, quals
);
9123 /* If a canonical type already exists for this type, use it. We use
9124 this method instead of type_hash_canon, because it only does a
9125 simple equality check on the list of field members. */
9127 t
= TYPE_PTRMEMFUNC_TYPE (type
);
9131 t
= make_node (RECORD_TYPE
);
9133 /* Let the front end know this is a pointer to member function. */
9134 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
9136 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
9139 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
9141 DECL_CHAIN (field
) = fields
;
9144 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
9146 /* Zap out the name so that the back end will give us the debugging
9147 information for this anonymous RECORD_TYPE. */
9148 TYPE_NAME (t
) = NULL_TREE
;
9150 /* Cache this pointer-to-member type so that we can find it again
9152 TYPE_PTRMEMFUNC_TYPE (type
) = t
;
9154 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
9155 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9156 else if (TYPE_CANONICAL (type
) != type
)
9157 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
9162 /* Create and return a pointer to data member type. */
9165 build_ptrmem_type (tree class_type
, tree member_type
)
9167 if (TREE_CODE (member_type
) == METHOD_TYPE
)
9169 cp_cv_quals quals
= type_memfn_quals (member_type
);
9170 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
9171 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
9172 return build_ptrmemfunc_type (build_pointer_type (member_type
));
9176 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
9177 return build_offset_type (class_type
, member_type
);
9181 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9182 Check to see that the definition is valid. Issue appropriate error
9183 messages. Return 1 if the definition is particularly bad, or 0
9187 check_static_variable_definition (tree decl
, tree type
)
9189 /* Avoid redundant diagnostics on out-of-class definitions. */
9190 if (!current_class_type
|| !TYPE_BEING_DEFINED (current_class_type
))
9192 /* Can't check yet if we don't know the type. */
9193 if (dependent_type_p (type
))
9195 /* If DECL is declared constexpr, we'll do the appropriate checks
9196 in check_initializer. Similarly for inline static data members. */
9198 && (DECL_DECLARED_CONSTEXPR_P (decl
)
9199 || DECL_VAR_DECLARED_INLINE_P (decl
)))
9201 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
9203 if (!COMPLETE_TYPE_P (type
))
9204 error_at (DECL_SOURCE_LOCATION (decl
),
9205 "in-class initialization of static data member %q#D of "
9206 "incomplete type", decl
);
9207 else if (literal_type_p (type
))
9208 permerror (DECL_SOURCE_LOCATION (decl
),
9209 "%<constexpr%> needed for in-class initialization of "
9210 "static data member %q#D of non-integral type", decl
);
9212 error_at (DECL_SOURCE_LOCATION (decl
),
9213 "in-class initialization of static data member %q#D of "
9214 "non-literal type", decl
);
9218 /* Motion 10 at San Diego: If a static const integral data member is
9219 initialized with an integral constant expression, the initializer
9220 may appear either in the declaration (within the class), or in
9221 the definition, but not both. If it appears in the class, the
9222 member is a member constant. The file-scope definition is always
9224 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
9226 error_at (DECL_SOURCE_LOCATION (decl
),
9227 "invalid in-class initialization of static data member "
9228 "of non-integral type %qT",
9232 else if (!CP_TYPE_CONST_P (type
))
9233 error_at (DECL_SOURCE_LOCATION (decl
),
9234 "ISO C++ forbids in-class initialization of non-const "
9235 "static member %qD",
9237 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
9238 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
9239 "ISO C++ forbids initialization of member constant "
9240 "%qD of non-integral type %qT", decl
, type
);
9245 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
9246 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
9247 expressions out into temporary variables so that walk_tree doesn't
9248 step into them (c++/15764). */
9251 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
9253 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
9254 tree expr
= *expr_p
;
9255 if (TREE_CODE (expr
) == SAVE_EXPR
)
9257 tree op
= TREE_OPERAND (expr
, 0);
9258 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
9259 if (TREE_SIDE_EFFECTS (op
))
9260 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
9263 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
9268 /* Entry point for the above. */
9271 stabilize_vla_size (tree size
)
9273 hash_set
<tree
> pset
;
9274 /* Break out any function calls into temporary variables. */
9275 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
9278 /* Reduce a SIZEOF_EXPR to its value. */
9281 fold_sizeof_expr (tree t
)
9284 if (SIZEOF_EXPR_TYPE_P (t
))
9285 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
9286 SIZEOF_EXPR
, false);
9287 else if (TYPE_P (TREE_OPERAND (t
, 0)))
9288 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
9291 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
9293 if (r
== error_mark_node
)
9298 /* Given the SIZE (i.e., number of elements) in an array, compute
9299 an appropriate index type for the array. If non-NULL, NAME is
9300 the name of the entity being declared. */
9303 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
9308 if (error_operand_p (size
))
9309 return error_mark_node
;
9311 if (!type_dependent_expression_p (size
))
9313 tree type
= TREE_TYPE (size
);
9315 size
= mark_rvalue_use (size
);
9317 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
9318 && TREE_SIDE_EFFECTS (size
))
9319 /* In C++98, we mark a non-constant array bound with a magic
9320 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
9323 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
9325 if (CLASS_TYPE_P (type
)
9326 && CLASSTYPE_LITERAL_P (type
))
9328 size
= build_expr_type_conversion (WANT_INT
, size
, true);
9331 if (!(complain
& tf_error
))
9332 return error_mark_node
;
9334 error ("size of array %qD has non-integral type %qT",
9337 error ("size of array has non-integral type %qT", type
);
9338 size
= integer_one_node
;
9340 if (size
== error_mark_node
)
9341 return error_mark_node
;
9342 type
= TREE_TYPE (size
);
9345 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
9346 size
= maybe_constant_value (size
);
9348 if (!TREE_CONSTANT (size
))
9352 if (error_operand_p (size
))
9353 return error_mark_node
;
9355 /* The array bound must be an integer type. */
9356 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
9358 if (!(complain
& tf_error
))
9359 return error_mark_node
;
9361 error ("size of array %qD has non-integral type %qT", name
, type
);
9363 error ("size of array has non-integral type %qT", type
);
9364 size
= integer_one_node
;
9365 type
= TREE_TYPE (size
);
9369 /* A type is dependent if it is...an array type constructed from any
9370 dependent type or whose size is specified by a constant expression
9371 that is value-dependent. */
9372 /* We can only call value_dependent_expression_p on integral constant
9373 expressions; treat non-constant expressions as dependent, too. */
9374 if (processing_template_decl
9375 && (type_dependent_expression_p (size
)
9376 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
9378 /* We cannot do any checking for a SIZE that isn't known to be
9379 constant. Just build the index type and mark that it requires
9380 structural equality checks. */
9381 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
9382 size
, size_one_node
));
9383 TYPE_DEPENDENT_P (itype
) = 1;
9384 TYPE_DEPENDENT_P_VALID (itype
) = 1;
9385 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
9389 if (TREE_CODE (size
) != INTEGER_CST
)
9391 tree folded
= cp_fully_fold (size
);
9392 if (TREE_CODE (folded
) == INTEGER_CST
)
9393 pedwarn (location_of (size
), OPT_Wpedantic
,
9394 "size of array is not an integral constant-expression");
9395 /* Use the folded result for VLAs, too; it will have resolved
9400 /* Normally, the array-bound will be a constant. */
9401 if (TREE_CODE (size
) == INTEGER_CST
)
9403 /* Check to see if the array bound overflowed. Make that an
9404 error, no matter how generous we're being. */
9405 constant_expression_error (size
);
9407 /* An array must have a positive number of elements. */
9408 if (tree_int_cst_lt (size
, integer_zero_node
))
9410 if (!(complain
& tf_error
))
9411 return error_mark_node
;
9413 error ("size of array %qD is negative", name
);
9415 error ("size of array is negative");
9416 size
= integer_one_node
;
9418 /* As an extension we allow zero-sized arrays. */
9419 else if (integer_zerop (size
))
9421 if (!(complain
& tf_error
))
9422 /* We must fail if performing argument deduction (as
9423 indicated by the state of complain), so that
9424 another substitution can be found. */
9425 return error_mark_node
;
9426 else if (in_system_header_at (input_location
))
9427 /* Allow them in system headers because glibc uses them. */;
9429 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
9431 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
9434 else if (TREE_CONSTANT (size
)
9435 /* We don't allow VLAs at non-function scopes, or during
9436 tentative template substitution. */
9437 || !at_function_scope_p ()
9438 || !(complain
& tf_error
))
9440 if (!(complain
& tf_error
))
9441 return error_mark_node
;
9442 /* `(int) &fn' is not a valid array bound. */
9444 error ("size of array %qD is not an integral constant-expression",
9447 error ("size of array is not an integral constant-expression");
9448 size
= integer_one_node
;
9450 else if (pedantic
&& warn_vla
!= 0)
9453 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
9455 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
9457 else if (warn_vla
> 0)
9461 "variable length array %qD is used", name
);
9464 "variable length array is used");
9467 if (processing_template_decl
&& !TREE_CONSTANT (size
))
9468 /* A variable sized array. */
9469 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
9472 /* Compute the index of the largest element in the array. It is
9473 one less than the number of elements in the array. We save
9474 and restore PROCESSING_TEMPLATE_DECL so that computations in
9475 cp_build_binary_op will be appropriately folded. */
9477 processing_template_decl_sentinel s
;
9478 itype
= cp_build_binary_op (input_location
,
9480 cp_convert (ssizetype
, size
, complain
),
9481 cp_convert (ssizetype
, integer_one_node
,
9484 itype
= maybe_constant_value (itype
);
9487 if (!TREE_CONSTANT (itype
))
9489 /* A variable sized array. */
9490 itype
= variable_size (itype
);
9492 stabilize_vla_size (itype
);
9494 if (sanitize_flags_p (SANITIZE_VLA
)
9495 && current_function_decl
!= NULL_TREE
)
9497 /* We have to add 1 -- in the ubsan routine we generate
9498 LE_EXPR rather than LT_EXPR. */
9499 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
9500 build_one_cst (TREE_TYPE (itype
)));
9501 t
= ubsan_instrument_vla (input_location
, t
);
9502 finish_expr_stmt (t
);
9505 /* Make sure that there was no overflow when creating to a signed
9506 index type. (For example, on a 32-bit machine, an array with
9507 size 2^32 - 1 is too big.) */
9508 else if (TREE_CODE (itype
) == INTEGER_CST
9509 && TREE_OVERFLOW (itype
))
9511 if (!(complain
& tf_error
))
9512 return error_mark_node
;
9513 error ("overflow in array dimension");
9514 TREE_OVERFLOW (itype
) = 0;
9518 /* Create and return the appropriate index type. */
9519 itype
= build_index_type (itype
);
9521 /* If the index type were dependent, we would have returned early, so
9522 remember that it isn't. */
9523 TYPE_DEPENDENT_P (itype
) = 0;
9524 TYPE_DEPENDENT_P_VALID (itype
) = 1;
9528 /* Returns the scope (if any) in which the entity declared by
9529 DECLARATOR will be located. If the entity was declared with an
9530 unqualified name, NULL_TREE is returned. */
9533 get_scope_of_declarator (const cp_declarator
*declarator
)
9535 while (declarator
&& declarator
->kind
!= cdk_id
)
9536 declarator
= declarator
->declarator
;
9538 /* If the declarator-id is a SCOPE_REF, the scope in which the
9539 declaration occurs is the first operand. */
9541 && declarator
->u
.id
.qualifying_scope
)
9542 return declarator
->u
.id
.qualifying_scope
;
9544 /* Otherwise, the declarator is not a qualified name; the entity will
9545 be declared in the current scope. */
9549 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9550 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9554 create_array_type_for_decl (tree name
, tree type
, tree size
)
9556 tree itype
= NULL_TREE
;
9558 /* If things have already gone awry, bail now. */
9559 if (type
== error_mark_node
|| size
== error_mark_node
)
9560 return error_mark_node
;
9562 /* 8.3.4/1: If the type of the identifier of D contains the auto
9563 type-specifier, the program is ill-formed. */
9564 if (type_uses_auto (type
))
9566 error ("%qD declared as array of %qT", name
, type
);
9567 return error_mark_node
;
9570 /* If there are some types which cannot be array elements,
9571 issue an error-message and return. */
9572 switch (TREE_CODE (type
))
9576 error ("declaration of %qD as array of void", name
);
9578 error ("creating array of void");
9579 return error_mark_node
;
9583 error ("declaration of %qD as array of functions", name
);
9585 error ("creating array of functions");
9586 return error_mark_node
;
9588 case REFERENCE_TYPE
:
9590 error ("declaration of %qD as array of references", name
);
9592 error ("creating array of references");
9593 return error_mark_node
;
9597 error ("declaration of %qD as array of function members", name
);
9599 error ("creating array of function members");
9600 return error_mark_node
;
9608 The constant expressions that specify the bounds of the arrays
9609 can be omitted only for the first member of the sequence. */
9610 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9613 error ("declaration of %qD as multidimensional array must "
9614 "have bounds for all dimensions except the first",
9617 error ("multidimensional array must have bounds for all "
9618 "dimensions except the first");
9620 return error_mark_node
;
9623 /* Figure out the index type for the array. */
9625 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
9628 T is called the array element type; this type shall not be [...] an
9629 abstract class type. */
9630 abstract_virtuals_error (name
, type
);
9632 return build_cplus_array_type (type
, itype
);
9635 /* Returns the smallest location != UNKNOWN_LOCATION among the
9636 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
9637 and LOCATIONS[ds_restrict]. */
9640 smallest_type_quals_location (int type_quals
, const location_t
* locations
)
9642 location_t loc
= UNKNOWN_LOCATION
;
9644 if (type_quals
& TYPE_QUAL_CONST
)
9645 loc
= locations
[ds_const
];
9647 if ((type_quals
& TYPE_QUAL_VOLATILE
)
9648 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_volatile
] < loc
))
9649 loc
= locations
[ds_volatile
];
9651 if ((type_quals
& TYPE_QUAL_RESTRICT
)
9652 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_restrict
] < loc
))
9653 loc
= locations
[ds_restrict
];
9658 /* Check that it's OK to declare a function with the indicated TYPE
9659 and TYPE_QUALS. SFK indicates the kind of special function (if any)
9660 that this function is. OPTYPE is the type given in a conversion
9661 operator declaration, or the class type for a constructor/destructor.
9662 Returns the actual return type of the function; that may be different
9663 than TYPE if an error occurs, or for certain special functions. */
9666 check_special_function_return_type (special_function_kind sfk
,
9670 const location_t
* locations
)
9674 case sfk_constructor
:
9676 error ("return type specification for constructor invalid");
9677 else if (type_quals
!= TYPE_UNQUALIFIED
)
9678 error_at (smallest_type_quals_location (type_quals
, locations
),
9679 "qualifiers are not allowed on constructor declaration");
9681 if (targetm
.cxx
.cdtor_returns_this ())
9682 type
= build_pointer_type (optype
);
9684 type
= void_type_node
;
9687 case sfk_destructor
:
9689 error ("return type specification for destructor invalid");
9690 else if (type_quals
!= TYPE_UNQUALIFIED
)
9691 error_at (smallest_type_quals_location (type_quals
, locations
),
9692 "qualifiers are not allowed on destructor declaration");
9694 /* We can't use the proper return type here because we run into
9695 problems with ambiguous bases and covariant returns. */
9696 if (targetm
.cxx
.cdtor_returns_this ())
9697 type
= build_pointer_type (void_type_node
);
9699 type
= void_type_node
;
9702 case sfk_conversion
:
9704 error ("return type specified for %<operator %T%>", optype
);
9705 else if (type_quals
!= TYPE_UNQUALIFIED
)
9706 error_at (smallest_type_quals_location (type_quals
, locations
),
9707 "qualifiers are not allowed on declaration of "
9708 "%<operator %T%>", optype
);
9713 case sfk_deduction_guide
:
9715 error ("return type specified for deduction guide");
9716 else if (type_quals
!= TYPE_UNQUALIFIED
)
9717 error_at (smallest_type_quals_location (type_quals
, locations
),
9718 "qualifiers are not allowed on declaration of "
9720 type
= make_template_placeholder (CLASSTYPE_TI_TEMPLATE (optype
));
9721 for (int i
= 0; i
< ds_last
; ++i
)
9722 if (i
!= ds_explicit
&& locations
[i
])
9723 error_at (locations
[i
],
9724 "decl-specifier in declaration of deduction guide");
9734 /* A variable or data member (whose unqualified name is IDENTIFIER)
9735 has been declared with the indicated TYPE. If the TYPE is not
9736 acceptable, issue an error message and return a type to use for
9737 error-recovery purposes. */
9740 check_var_type (tree identifier
, tree type
)
9742 if (VOID_TYPE_P (type
))
9745 error ("unnamed variable or field declared void");
9746 else if (identifier_p (identifier
))
9748 gcc_assert (!IDENTIFIER_ANY_OP_P (identifier
));
9749 error ("variable or field %qE declared void", identifier
);
9752 error ("variable or field declared void");
9753 type
= error_mark_node
;
9759 /* Handle declaring DECL as an inline variable. */
9762 mark_inline_variable (tree decl
)
9764 bool inlinep
= true;
9765 if (! toplevel_bindings_p ())
9767 error ("%<inline%> specifier invalid for variable "
9768 "%qD declared at block scope", decl
);
9771 else if (cxx_dialect
< cxx17
)
9772 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
9773 "inline variables are only available "
9774 "with -std=c++17 or -std=gnu++17");
9777 retrofit_lang_decl (decl
);
9778 SET_DECL_VAR_DECLARED_INLINE_P (decl
);
9783 /* Assign a typedef-given name to a class or enumeration type declared
9784 as anonymous at first. This was split out of grokdeclarator
9785 because it is also used in libcc1. */
9788 name_unnamed_type (tree type
, tree decl
)
9790 gcc_assert (TYPE_UNNAMED_P (type
));
9792 /* Replace the anonymous name with the real name everywhere. */
9793 for (tree t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
9795 if (anon_aggrname_p (TYPE_IDENTIFIER (t
)))
9796 /* We do not rename the debug info representing the
9797 unnamed tagged type because the standard says in
9798 [dcl.typedef] that the naming applies only for
9799 linkage purposes. */
9800 /*debug_hooks->set_name (t, decl);*/
9801 TYPE_NAME (t
) = decl
;
9804 if (TYPE_LANG_SPECIFIC (type
))
9805 TYPE_WAS_UNNAMED (type
) = 1;
9807 /* If this is a typedef within a template class, the nested
9808 type is a (non-primary) template. The name for the
9809 template needs updating as well. */
9810 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
9811 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
9812 = TYPE_IDENTIFIER (type
);
9814 /* Adjust linkage now that we aren't unnamed anymore. */
9815 reset_type_linkage (type
);
9817 /* FIXME remangle member functions; member functions of a
9818 type with external linkage have external linkage. */
9820 /* Check that our job is done, and that it would fail if we
9821 attempted to do it again. */
9822 gcc_assert (!TYPE_UNNAMED_P (type
));
9825 /* Given declspecs and a declarator (abstract or otherwise), determine
9826 the name and type of the object declared and construct a DECL node
9829 DECLSPECS points to the representation of declaration-specifier
9830 sequence that precedes declarator.
9832 DECL_CONTEXT says which syntactic context this declaration is in:
9833 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9834 FUNCDEF for a function definition. Like NORMAL but a few different
9835 error messages in each case. Return value may be zero meaning
9836 this definition is too screwy to try to parse.
9837 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9838 handle member functions (which have FIELD context).
9839 Return value may be zero meaning this definition is too screwy to
9841 PARM for a parameter declaration (either within a function prototype
9842 or before a function body). Make a PARM_DECL, or return void_type_node.
9843 TPARM for a template parameter declaration.
9844 CATCHPARM for a parameter declaration before a catch clause.
9845 TYPENAME if for a typename (in a cast or sizeof).
9846 Don't make a DECL node; just return the ..._TYPE node.
9847 FIELD for a struct or union field; make a FIELD_DECL.
9848 BITFIELD for a field with specified width.
9850 INITIALIZED is as for start_decl.
9852 ATTRLIST is a pointer to the list of attributes, which may be NULL
9853 if there are none; *ATTRLIST may be modified if attributes from inside
9854 the declarator should be applied to the declaration.
9856 When this function is called, scoping variables (such as
9857 CURRENT_CLASS_TYPE) should reflect the scope in which the
9858 declaration occurs, not the scope in which the new declaration will
9859 be placed. For example, on:
9863 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9866 Returns a DECL (if a declarator is present), a TYPE (if there is no
9867 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
9871 grokdeclarator (const cp_declarator
*declarator
,
9872 cp_decl_specifier_seq
*declspecs
,
9873 enum decl_context decl_context
,
9877 tree type
= NULL_TREE
;
9879 int explicit_intN
= 0;
9880 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9881 int explicit_int
= 0;
9882 int explicit_char
= 0;
9883 int defaulted_int
= 0;
9885 tree typedef_decl
= NULL_TREE
;
9886 const char *name
= NULL
;
9887 tree typedef_type
= NULL_TREE
;
9888 /* True if this declarator is a function definition. */
9889 bool funcdef_flag
= false;
9890 cp_declarator_kind innermost_code
= cdk_error
;
9893 /* See the code below that used this. */
9894 tree decl_attr
= NULL_TREE
;
9897 /* Keep track of what sort of function is being processed
9898 so that we can warn about default return values, or explicit
9899 return values which do not match prescribed defaults. */
9900 special_function_kind sfk
= sfk_none
;
9902 tree dname
= NULL_TREE
;
9903 tree ctor_return_type
= NULL_TREE
;
9904 enum overload_flags flags
= NO_SPECIAL
;
9905 /* cv-qualifiers that apply to the declarator, for a declaration of
9906 a member function. */
9907 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
9908 /* virt-specifiers that apply to the declarator, for a declaration of
9909 a member function. */
9910 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
9911 /* ref-qualifier that applies to the declarator, for a declaration of
9912 a member function. */
9913 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
9914 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
9915 int type_quals
= TYPE_UNQUALIFIED
;
9916 tree raises
= NULL_TREE
;
9917 int template_count
= 0;
9918 tree returned_attrs
= NULL_TREE
;
9919 tree parms
= NULL_TREE
;
9920 const cp_declarator
*id_declarator
;
9921 /* The unqualified name of the declarator; either an
9922 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
9923 tree unqualified_id
;
9924 /* The class type, if any, in which this entity is located,
9925 or NULL_TREE if none. Note that this value may be different from
9926 the current class type; for example if an attempt is made to declare
9927 "A::f" inside "B", this value will be "A". */
9928 tree ctype
= current_class_type
;
9929 /* The NAMESPACE_DECL for the namespace in which this entity is
9930 located. If an unqualified name is used to declare the entity,
9931 this value will be NULL_TREE, even if the entity is located at
9933 tree in_namespace
= NULL_TREE
;
9934 cp_storage_class storage_class
;
9935 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
9936 bool type_was_error_mark_node
= false;
9937 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
9938 bool template_type_arg
= false;
9939 bool template_parm_flag
= false;
9940 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
9941 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
9942 bool late_return_type_p
= false;
9943 bool array_parameter_p
= false;
9944 source_location saved_loc
= input_location
;
9945 tree reqs
= NULL_TREE
;
9947 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
9948 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
9949 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
9950 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
9951 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
9952 explicit_intN
= declspecs
->explicit_intN_p
;
9953 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
9955 // Was concept_p specified? Note that ds_concept
9956 // implies ds_constexpr!
9957 bool concept_p
= decl_spec_seq_has_spec_p (declspecs
, ds_concept
);
9961 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9962 type_quals
|= TYPE_QUAL_CONST
;
9963 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9964 type_quals
|= TYPE_QUAL_VOLATILE
;
9965 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9966 type_quals
|= TYPE_QUAL_RESTRICT
;
9968 if (decl_context
== FUNCDEF
)
9969 funcdef_flag
= true, decl_context
= NORMAL
;
9970 else if (decl_context
== MEMFUNCDEF
)
9971 funcdef_flag
= true, decl_context
= FIELD
;
9972 else if (decl_context
== BITFIELD
)
9973 bitfield
= 1, decl_context
= FIELD
;
9974 else if (decl_context
== TEMPLATE_TYPE_ARG
)
9975 template_type_arg
= true, decl_context
= TYPENAME
;
9976 else if (decl_context
== TPARM
)
9977 template_parm_flag
= true, decl_context
= PARM
;
9979 if (initialized
> 1)
9980 funcdef_flag
= true;
9982 location_t typespec_loc
= smallest_type_quals_location (type_quals
,
9983 declspecs
->locations
);
9984 if (typespec_loc
== UNKNOWN_LOCATION
)
9985 typespec_loc
= declspecs
->locations
[ds_type_spec
];
9986 if (typespec_loc
== UNKNOWN_LOCATION
)
9987 typespec_loc
= input_location
;
9989 /* Look inside a declarator for the name being declared
9990 and get it as a string, for an error message. */
9991 for (id_declarator
= declarator
;
9993 id_declarator
= id_declarator
->declarator
)
9995 if (id_declarator
->kind
!= cdk_id
)
9996 innermost_code
= id_declarator
->kind
;
9998 switch (id_declarator
->kind
)
10001 if (id_declarator
->declarator
10002 && id_declarator
->declarator
->kind
== cdk_id
)
10004 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
10005 if (sfk
== sfk_destructor
)
10012 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
10013 tree decl
= id_declarator
->u
.id
.unqualified_name
;
10016 if (qualifying_scope
)
10018 if (at_function_scope_p ())
10022 A declarator-id shall not be qualified except
10025 None of the cases are permitted in block
10027 if (qualifying_scope
== global_namespace
)
10028 error ("invalid use of qualified-name %<::%D%>",
10030 else if (TYPE_P (qualifying_scope
))
10031 error ("invalid use of qualified-name %<%T::%D%>",
10032 qualifying_scope
, decl
);
10034 error ("invalid use of qualified-name %<%D::%D%>",
10035 qualifying_scope
, decl
);
10036 return error_mark_node
;
10038 else if (TYPE_P (qualifying_scope
))
10040 ctype
= qualifying_scope
;
10041 if (!MAYBE_CLASS_TYPE_P (ctype
))
10043 error ("%q#T is not a class or a namespace", ctype
);
10046 else if (innermost_code
!= cdk_function
10047 && current_class_type
10048 && !uniquely_derived_from_p (ctype
,
10049 current_class_type
))
10051 error ("invalid use of qualified-name %<%T::%D%>",
10052 qualifying_scope
, decl
);
10053 return error_mark_node
;
10056 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
10057 in_namespace
= qualifying_scope
;
10059 switch (TREE_CODE (decl
))
10063 if (innermost_code
!= cdk_function
)
10065 error ("declaration of %qD as non-function", decl
);
10066 return error_mark_node
;
10068 else if (!qualifying_scope
10069 && !(current_class_type
&& at_class_scope_p ()))
10071 error ("declaration of %qD as non-member", decl
);
10072 return error_mark_node
;
10075 tree type
= TREE_OPERAND (decl
, 0);
10077 type
= constructor_name (type
);
10078 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
10083 case TEMPLATE_ID_EXPR
:
10085 tree fns
= TREE_OPERAND (decl
, 0);
10088 if (!identifier_p (dname
))
10089 dname
= OVL_NAME (dname
);
10091 /* Fall through. */
10093 case IDENTIFIER_NODE
:
10094 if (identifier_p (decl
))
10097 if (IDENTIFIER_KEYWORD_P (dname
))
10099 error ("declarator-id missing; using reserved word %qD",
10101 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10103 else if (!IDENTIFIER_CONV_OP_P (dname
))
10104 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10107 gcc_assert (flags
== NO_SPECIAL
);
10108 flags
= TYPENAME_FLAG
;
10109 sfk
= sfk_conversion
;
10110 tree glob
= get_global_binding (dname
);
10111 if (glob
&& TREE_CODE (glob
) == TYPE_DECL
)
10112 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10114 name
= "<invalid operator>";
10119 gcc_unreachable ();
10126 case cdk_reference
:
10131 name
= "structured binding";
10135 return error_mark_node
;
10138 gcc_unreachable ();
10140 if (id_declarator
->kind
== cdk_id
)
10146 The declarator in a function-definition shall have the form
10147 D1 ( parameter-declaration-clause) ... */
10148 if (funcdef_flag
&& innermost_code
!= cdk_function
)
10150 error ("function definition does not declare parameters");
10151 return error_mark_node
;
10154 if (flags
== TYPENAME_FLAG
10155 && innermost_code
!= cdk_function
10156 && ! (ctype
&& !declspecs
->any_specifiers_p
))
10158 error ("declaration of %qD as non-function", dname
);
10159 return error_mark_node
;
10162 if (dname
&& identifier_p (dname
))
10164 if (UDLIT_OPER_P (dname
)
10165 && innermost_code
!= cdk_function
)
10167 error ("declaration of %qD as non-function", dname
);
10168 return error_mark_node
;
10171 if (IDENTIFIER_ANY_OP_P (dname
))
10175 error ("declaration of %qD as %<typedef%>", dname
);
10176 return error_mark_node
;
10178 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10180 error ("declaration of %qD as parameter", dname
);
10181 return error_mark_node
;
10186 /* Anything declared one level down from the top level
10187 must be one of the parameters of a function
10188 (because the body is at least two levels down). */
10190 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10191 by not allowing C++ class definitions to specify their parameters
10192 with xdecls (must be spec.d in the parmlist).
10194 Since we now wait to push a class scope until we are sure that
10195 we are in a legitimate method context, we must set oldcname
10196 explicitly (since current_class_name is not yet alive).
10198 We also want to avoid calling this a PARM if it is in a namespace. */
10200 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
10202 cp_binding_level
*b
= current_binding_level
;
10203 current_binding_level
= b
->level_chain
;
10204 if (current_binding_level
!= 0 && toplevel_bindings_p ())
10205 decl_context
= PARM
;
10206 current_binding_level
= b
;
10210 name
= decl_context
== PARM
? "parameter" : "type name";
10212 if (concept_p
&& typedef_p
)
10214 error ("%<concept%> cannot appear in a typedef declaration");
10215 return error_mark_node
;
10218 if (constexpr_p
&& typedef_p
)
10220 error ("%<constexpr%> cannot appear in a typedef declaration");
10221 return error_mark_node
;
10224 /* If there were multiple types specified in the decl-specifier-seq,
10225 issue an error message. */
10226 if (declspecs
->multiple_types_p
)
10228 error ("two or more data types in declaration of %qs", name
);
10229 return error_mark_node
;
10232 if (declspecs
->conflicting_specifiers_p
)
10234 error ("conflicting specifiers in declaration of %qs", name
);
10235 return error_mark_node
;
10238 /* Extract the basic type from the decl-specifier-seq. */
10239 type
= declspecs
->type
;
10240 if (type
== error_mark_node
)
10243 type_was_error_mark_node
= true;
10245 /* If the entire declaration is itself tagged as deprecated then
10246 suppress reports of deprecated items. */
10247 if (type
&& TREE_DEPRECATED (type
)
10248 && deprecated_state
!= DEPRECATED_SUPPRESS
)
10249 warn_deprecated_use (type
, NULL_TREE
);
10250 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
10252 typedef_decl
= type
;
10253 type
= TREE_TYPE (typedef_decl
);
10254 if (TREE_DEPRECATED (type
)
10255 && DECL_ARTIFICIAL (typedef_decl
)
10256 && deprecated_state
!= DEPRECATED_SUPPRESS
)
10257 warn_deprecated_use (type
, NULL_TREE
);
10259 /* No type at all: default to `int', and set DEFAULTED_INT
10260 because it was not a user-defined typedef. */
10261 if (type
== NULL_TREE
)
10263 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
10265 /* These imply 'int'. */
10266 type
= integer_type_node
;
10269 /* If we just have "complex", it is equivalent to "complex double". */
10270 else if (!longlong
&& !explicit_intN
10271 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
10273 type
= double_type_node
;
10274 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
10275 "ISO C++ does not support plain %<complex%> meaning "
10276 "%<double complex%>");
10279 /* Gather flags. */
10280 explicit_int
= declspecs
->explicit_int_p
;
10281 explicit_char
= declspecs
->explicit_char_p
;
10284 /* See the code below that used this. */
10286 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
10288 typedef_type
= type
;
10290 if (sfk
== sfk_conversion
|| sfk
== sfk_deduction_guide
)
10291 ctor_return_type
= TREE_TYPE (dname
);
10293 ctor_return_type
= ctype
;
10295 if (sfk
!= sfk_none
)
10297 type
= check_special_function_return_type (sfk
, type
,
10300 declspecs
->locations
);
10301 type_quals
= TYPE_UNQUALIFIED
;
10303 else if (type
== NULL_TREE
)
10309 /* We handle `main' specially here, because 'main () { }' is so
10310 common. With no options, it is allowed. With -Wreturn-type,
10311 it is a warning. It is only an error with -pedantic-errors. */
10312 is_main
= (funcdef_flag
10313 && dname
&& identifier_p (dname
)
10314 && MAIN_NAME_P (dname
)
10315 && ctype
== NULL_TREE
10316 && in_namespace
== NULL_TREE
10317 && current_namespace
== global_namespace
);
10319 if (type_was_error_mark_node
)
10320 /* We've already issued an error, don't complain more. */;
10321 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
10322 /* Allow it, sigh. */;
10323 else if (! is_main
)
10324 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
10326 pedwarn (input_location
, OPT_Wpedantic
,
10327 "ISO C++ forbids declaration of %qs with no type", name
);
10329 warning (OPT_Wreturn_type
,
10330 "ISO C++ forbids declaration of %qs with no type", name
);
10332 if (type_was_error_mark_node
&& template_parm_flag
)
10333 /* FIXME we should be able to propagate the error_mark_node as is
10334 for other contexts too. */
10335 type
= error_mark_node
;
10337 type
= integer_type_node
;
10344 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
10346 error ("%<__int%d%> is not supported by this target",
10347 int_n_data
[declspecs
->int_n_idx
].bitsize
);
10348 explicit_intN
= false;
10350 else if (pedantic
&& ! in_system_header_at (input_location
))
10351 pedwarn (input_location
, OPT_Wpedantic
,
10352 "ISO C++ does not support %<__int%d%> for %qs",
10353 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
10356 /* Now process the modifiers that were specified
10357 and check for invalid combinations. */
10359 /* Long double is a special combination. */
10360 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
10363 type
= cp_build_qualified_type (long_double_type_node
,
10364 cp_type_quals (type
));
10367 /* Check all other uses of type modifiers. */
10369 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
10373 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
10374 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
10375 else if (signed_p
&& unsigned_p
)
10376 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
10377 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
10378 error ("%<long long%> invalid for %qs", name
);
10379 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
10380 error ("%<long%> invalid for %qs", name
);
10381 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
10382 error ("%<short%> invalid for %qs", name
);
10383 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
10384 error ("%<long%> or %<short%> invalid for %qs", name
);
10385 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_intN
)
10386 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
10387 else if ((long_p
|| short_p
) && explicit_char
)
10388 error ("%<long%> or %<short%> specified with char for %qs", name
);
10389 else if (long_p
&& short_p
)
10390 error ("%<long%> and %<short%> specified together for %qs", name
);
10391 else if (type
== char16_type_node
|| type
== char32_type_node
)
10393 if (signed_p
|| unsigned_p
)
10394 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
10395 else if (short_p
|| long_p
)
10396 error ("%<short%> or %<long%> invalid for %qs", name
);
10401 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_intN
&& pedantic
)
10403 pedwarn (input_location
, OPT_Wpedantic
,
10404 "long, short, signed or unsigned used invalidly for %qs",
10406 if (flag_pedantic_errors
)
10411 /* Discard the type modifiers if they are invalid. */
10414 unsigned_p
= false;
10422 /* Decide whether an integer type is signed or not.
10423 Optionally treat bitfields as signed by default. */
10427 It is implementation-defined whether a plain (neither
10428 explicitly signed or unsigned) char, short, int, or long
10429 bit-field is signed or unsigned.
10431 Naturally, we extend this to long long as well. Note that
10432 this does not include wchar_t. */
10433 || (bitfield
&& !flag_signed_bitfields
10435 /* A typedef for plain `int' without `signed' can be
10436 controlled just like plain `int', but a typedef for
10437 `signed int' cannot be so controlled. */
10439 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
10440 && TREE_CODE (type
) == INTEGER_TYPE
10441 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
10444 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
10446 type
= long_long_unsigned_type_node
;
10448 type
= long_unsigned_type_node
;
10450 type
= short_unsigned_type_node
;
10451 else if (type
== char_type_node
)
10452 type
= unsigned_char_type_node
;
10453 else if (typedef_decl
)
10454 type
= unsigned_type_for (type
);
10456 type
= unsigned_type_node
;
10458 else if (signed_p
&& type
== char_type_node
)
10459 type
= signed_char_type_node
;
10460 else if (explicit_intN
)
10461 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
10463 type
= long_long_integer_type_node
;
10465 type
= long_integer_type_node
;
10467 type
= short_integer_type_node
;
10469 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
10471 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
10472 error ("complex invalid for %qs", name
);
10473 /* If a modifier is specified, the resulting complex is the complex
10474 form of TYPE. E.g, "complex short" is "complex short int". */
10475 else if (type
== integer_type_node
)
10476 type
= complex_integer_type_node
;
10477 else if (type
== float_type_node
)
10478 type
= complex_float_type_node
;
10479 else if (type
== double_type_node
)
10480 type
= complex_double_type_node
;
10481 else if (type
== long_double_type_node
)
10482 type
= complex_long_double_type_node
;
10484 type
= build_complex_type (type
);
10487 /* If we're using the injected-class-name to form a compound type or a
10488 declaration, replace it with the underlying class so we don't get
10489 redundant typedefs in the debug output. But if we are returning the
10490 type unchanged, leave it alone so that it's available to
10491 maybe_get_template_decl_from_type_decl. */
10492 if (CLASS_TYPE_P (type
)
10493 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
10494 && type
== TREE_TYPE (TYPE_NAME (type
))
10495 && (declarator
|| type_quals
))
10496 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
10498 type_quals
|= cp_type_quals (type
);
10499 type
= cp_build_qualified_type_real
10500 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
10501 || declspecs
->decltype_p
)
10502 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
10503 /* We might have ignored or rejected some of the qualifiers. */
10504 type_quals
= cp_type_quals (type
);
10506 if (cxx_dialect
>= cxx17
&& type
&& is_auto (type
)
10507 && innermost_code
!= cdk_function
10508 && id_declarator
&& declarator
!= id_declarator
)
10509 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (type
))
10511 error_at (typespec_loc
, "template placeholder type %qT must be followed "
10512 "by a simple declarator-id", type
);
10513 inform (DECL_SOURCE_LOCATION (tmpl
), "%qD declared here", tmpl
);
10517 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
10518 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
10519 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
10521 storage_class
= declspecs
->storage_class
;
10522 if (storage_class
== sc_static
)
10523 staticp
= 1 + (decl_context
== FIELD
);
10529 error ("member %qD cannot be declared both %<virtual%> "
10530 "and %<static%>", dname
);
10531 storage_class
= sc_none
;
10535 error ("member %qD cannot be declared both %<virtual%> "
10536 "and %<constexpr%>", dname
);
10538 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
10540 /* Issue errors about use of storage classes for parameters. */
10541 if (decl_context
== PARM
)
10545 error ("typedef declaration invalid in parameter declaration");
10546 return error_mark_node
;
10548 else if (template_parm_flag
&& storage_class
!= sc_none
)
10550 error ("storage class specified for template parameter %qs", name
);
10551 return error_mark_node
;
10553 else if (storage_class
== sc_static
10554 || storage_class
== sc_extern
10556 error ("storage class specifiers invalid in parameter declarations");
10558 /* Function parameters cannot be concept. */
10560 error ("a parameter cannot be declared %<concept%>");
10561 /* Function parameters cannot be constexpr. If we saw one, moan
10562 and pretend it wasn't there. */
10563 else if (constexpr_p
)
10565 error ("a parameter cannot be declared %<constexpr%>");
10570 /* Give error if `virtual' is used outside of class declaration. */
10572 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
10574 error_at (declspecs
->locations
[ds_virtual
],
10575 "%<virtual%> outside class declaration");
10579 if (innermost_code
== cdk_decomp
)
10581 location_t loc
= (declarator
->kind
== cdk_reference
10582 ? declarator
->declarator
->id_loc
: declarator
->id_loc
);
10584 error_at (declspecs
->locations
[ds_inline
],
10585 "structured binding declaration cannot be %<inline%>");
10587 error_at (declspecs
->locations
[ds_typedef
],
10588 "structured binding declaration cannot be %<typedef%>");
10590 error_at (declspecs
->locations
[ds_constexpr
], "structured "
10591 "binding declaration cannot be %<constexpr%>");
10593 error_at (declspecs
->locations
[ds_thread
],
10594 "structured binding declaration cannot be %qs",
10595 declspecs
->gnu_thread_keyword_p
10596 ? "__thread" : "thread_local");
10598 error_at (declspecs
->locations
[ds_concept
],
10599 "structured binding declaration cannot be %<concept%>");
10600 switch (storage_class
)
10605 error_at (loc
, "structured binding declaration cannot be "
10609 error_at (loc
, "structured binding declaration cannot be "
10613 error_at (loc
, "structured binding declaration cannot be "
10617 error_at (loc
, "structured binding declaration cannot be "
10621 error_at (loc
, "structured binding declaration cannot be "
10625 gcc_unreachable ();
10627 if (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
10628 || TYPE_IDENTIFIER (type
) != auto_identifier
)
10630 if (type
!= error_mark_node
)
10632 error_at (loc
, "structured binding declaration cannot have "
10635 "type must be cv-qualified %<auto%> or reference to "
10636 "cv-qualified %<auto%>");
10638 type
= build_qualified_type (make_auto (), type_quals
);
10639 declspecs
->type
= type
;
10646 storage_class
= sc_none
;
10648 declspecs
->storage_class
= sc_none
;
10649 declspecs
->locations
[ds_thread
] = UNKNOWN_LOCATION
;
10652 /* Static anonymous unions are dealt with here. */
10653 if (staticp
&& decl_context
== TYPENAME
10655 && ANON_AGGR_TYPE_P (declspecs
->type
))
10656 decl_context
= FIELD
;
10658 /* Warn about storage classes that are invalid for certain
10659 kinds of declarations (parameters, typenames, etc.). */
10662 && storage_class
!= sc_extern
10663 && storage_class
!= sc_static
)
10666 error ("multiple storage classes in declaration of %qs", name
);
10669 if (decl_context
!= NORMAL
10670 && ((storage_class
!= sc_none
10671 && storage_class
!= sc_mutable
)
10674 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
10675 && (storage_class
== sc_register
10676 || storage_class
== sc_auto
))
10678 else if (typedef_p
)
10680 else if (decl_context
== FIELD
10681 /* C++ allows static class elements. */
10682 && storage_class
== sc_static
)
10683 /* C++ also allows inlines and signed and unsigned elements,
10684 but in those cases we don't come in here. */
10688 if (decl_context
== FIELD
)
10689 error ("storage class specified for %qs", name
);
10692 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10693 error ("storage class specified for parameter %qs", name
);
10695 error ("storage class specified for typename");
10697 if (storage_class
== sc_register
10698 || storage_class
== sc_auto
10699 || storage_class
== sc_extern
10701 storage_class
= sc_none
;
10704 else if (storage_class
== sc_extern
&& funcdef_flag
10705 && ! toplevel_bindings_p ())
10706 error ("nested function %qs declared %<extern%>", name
);
10707 else if (toplevel_bindings_p ())
10709 if (storage_class
== sc_auto
)
10710 error ("top-level declaration of %qs specifies %<auto%>", name
);
10713 && storage_class
!= sc_extern
10714 && storage_class
!= sc_static
)
10716 if (declspecs
->gnu_thread_keyword_p
)
10717 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
10718 "declared %<__thread%>", name
);
10720 /* When thread_local is applied to a variable of block scope the
10721 storage-class-specifier static is implied if it does not appear
10723 storage_class
= declspecs
->storage_class
= sc_static
;
10727 if (storage_class
&& friendp
)
10729 error ("storage class specifiers invalid in friend function declarations");
10730 storage_class
= sc_none
;
10734 if (!id_declarator
)
10735 unqualified_id
= NULL_TREE
;
10738 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
10739 switch (TREE_CODE (unqualified_id
))
10742 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
10743 if (TYPE_P (unqualified_id
))
10744 unqualified_id
= constructor_name (unqualified_id
);
10747 case IDENTIFIER_NODE
:
10748 case TEMPLATE_ID_EXPR
:
10752 gcc_unreachable ();
10756 if (declspecs
->std_attributes
)
10758 /* Apply the c++11 attributes to the type preceding them. */
10759 input_location
= declspecs
->locations
[ds_std_attribute
];
10760 decl_attributes (&type
, declspecs
->std_attributes
, 0);
10761 input_location
= saved_loc
;
10764 /* Determine the type of the entity declared by recurring on the
10766 for (; declarator
; declarator
= declarator
->declarator
)
10768 const cp_declarator
*inner_declarator
;
10771 if (type
== error_mark_node
)
10772 return error_mark_node
;
10774 attrs
= declarator
->attributes
;
10780 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
10781 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
10782 if (declarator
->kind
== cdk_function
)
10783 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
10784 if (declarator
->kind
== cdk_array
)
10785 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
10786 returned_attrs
= decl_attributes (&type
,
10787 chainon (returned_attrs
, attrs
),
10791 /* We don't want to warn in parmeter context because we don't
10792 yet know if the parse will succeed, and this might turn out
10793 to be a constructor call. */
10794 if (decl_context
!= PARM
10795 && declarator
->parenthesized
!= UNKNOWN_LOCATION
)
10796 warning_at (declarator
->parenthesized
, OPT_Wparentheses
,
10797 "unnecessary parentheses in declaration of %qs", name
);
10798 if (declarator
->kind
== cdk_id
|| declarator
->kind
== cdk_decomp
)
10801 inner_declarator
= declarator
->declarator
;
10803 switch (declarator
->kind
)
10806 type
= create_array_type_for_decl (dname
, type
,
10807 declarator
->u
.array
.bounds
);
10808 if (!valid_array_size_p (input_location
, type
, dname
))
10809 type
= error_mark_node
;
10811 if (declarator
->std_attributes
)
10814 The optional attribute-specifier-seq appertains to the
10816 returned_attrs
= chainon (returned_attrs
,
10817 declarator
->std_attributes
);
10825 /* Declaring a function type. */
10827 input_location
= declspecs
->locations
[ds_type_spec
];
10828 abstract_virtuals_error (ACU_RETURN
, type
);
10829 input_location
= saved_loc
;
10831 /* Pick up type qualifiers which should be applied to `this'. */
10832 memfn_quals
= declarator
->u
.function
.qualifiers
;
10833 /* Pick up virt-specifiers. */
10834 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
10835 /* And ref-qualifier, too */
10836 rqual
= declarator
->u
.function
.ref_qualifier
;
10837 /* And tx-qualifier. */
10838 tree tx_qual
= declarator
->u
.function
.tx_qualifier
;
10839 /* Pick up the exception specifications. */
10840 raises
= declarator
->u
.function
.exception_specification
;
10841 /* If the exception-specification is ill-formed, let's pretend
10842 there wasn't one. */
10843 if (raises
== error_mark_node
)
10844 raises
= NULL_TREE
;
10847 error_at (location_of (reqs
), "requires-clause on return type");
10848 reqs
= declarator
->u
.function
.requires_clause
;
10850 /* Say it's a definition only for the CALL_EXPR
10851 closest to the identifier. */
10852 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
10854 /* Handle a late-specified return type. */
10855 tree late_return_type
= declarator
->u
.function
.late_return_type
;
10858 if (tree auto_node
= type_uses_auto (type
))
10860 if (!late_return_type
)
10862 if (current_class_type
10863 && LAMBDA_TYPE_P (current_class_type
))
10864 /* OK for C++11 lambdas. */;
10865 else if (cxx_dialect
< cxx14
)
10867 error ("%qs function uses "
10868 "%<auto%> type specifier without trailing "
10869 "return type", name
);
10870 inform (input_location
, "deduced return type "
10871 "only available with -std=c++14 or "
10876 error ("virtual function cannot "
10877 "have deduced return type");
10881 else if (!is_auto (type
) && sfk
!= sfk_conversion
)
10883 error ("%qs function with trailing return type has"
10884 " %qT as its type rather than plain %<auto%>",
10886 return error_mark_node
;
10888 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
10890 if (!late_return_type
)
10892 if (dguide_name_p (unqualified_id
))
10893 error_at (declarator
->id_loc
, "deduction guide "
10894 "for %qT must have trailing return "
10895 "type", TREE_TYPE (tmpl
));
10897 error_at (declarator
->id_loc
, "deduced class "
10898 "type %qT in function return type",
10900 inform (DECL_SOURCE_LOCATION (tmpl
),
10901 "%qD declared here", tmpl
);
10903 else if (CLASS_TYPE_P (late_return_type
)
10904 && CLASSTYPE_TEMPLATE_INFO (late_return_type
)
10905 && (CLASSTYPE_TI_TEMPLATE (late_return_type
)
10909 error ("trailing return type %qT of deduction guide "
10910 "is not a specialization of %qT",
10911 late_return_type
, TREE_TYPE (tmpl
));
10914 else if (late_return_type
10915 && sfk
!= sfk_conversion
)
10917 if (cxx_dialect
< cxx11
)
10918 /* Not using maybe_warn_cpp0x because this should
10919 always be an error. */
10920 error ("trailing return type only available with "
10921 "-std=c++11 or -std=gnu++11");
10923 error ("%qs function with trailing return type not "
10924 "declared with %<auto%> type specifier", name
);
10925 return error_mark_node
;
10928 type
= splice_late_return_type (type
, late_return_type
);
10929 if (type
== error_mark_node
)
10930 return error_mark_node
;
10932 if (late_return_type
)
10934 late_return_type_p
= true;
10935 type_quals
= cp_type_quals (type
);
10938 if (type_quals
!= TYPE_UNQUALIFIED
)
10940 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
10941 warning_at (typespec_loc
, OPT_Wignored_qualifiers
, "type "
10942 "qualifiers ignored on function return type");
10943 /* We now know that the TYPE_QUALS don't apply to the
10944 decl, but to its return type. */
10945 type_quals
= TYPE_UNQUALIFIED
;
10948 /* Error about some types functions can't return. */
10950 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10952 error_at (typespec_loc
, "%qs declared as function returning "
10953 "a function", name
);
10954 return error_mark_node
;
10956 if (TREE_CODE (type
) == ARRAY_TYPE
)
10958 error_at (typespec_loc
, "%qs declared as function returning "
10960 return error_mark_node
;
10963 if (ctype
== NULL_TREE
10964 && decl_context
== FIELD
10967 ctype
= current_class_type
;
10969 if (ctype
&& (sfk
== sfk_constructor
10970 || sfk
== sfk_destructor
))
10972 /* We are within a class's scope. If our declarator name
10973 is the same as the class name, and we are defining
10974 a function, then it is a constructor/destructor, and
10975 therefore returns a void type. */
10977 /* ISO C++ 12.4/2. A destructor may not be declared
10978 const or volatile. A destructor may not be static.
10979 A destructor may not be declared with ref-qualifier.
10981 ISO C++ 12.1. A constructor may not be declared
10982 const or volatile. A constructor may not be
10983 virtual. A constructor may not be static.
10984 A constructor may not be declared with ref-qualifier. */
10986 error ((flags
== DTOR_FLAG
)
10987 ? G_("destructor cannot be static member function")
10988 : G_("constructor cannot be static member function"));
10991 error ((flags
== DTOR_FLAG
)
10992 ? G_("destructors may not be cv-qualified")
10993 : G_("constructors may not be cv-qualified"));
10994 memfn_quals
= TYPE_UNQUALIFIED
;
10999 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
11000 error ((flags
== DTOR_FLAG
)
11001 ? G_("destructors may not be ref-qualified")
11002 : G_("constructors may not be ref-qualified"));
11003 rqual
= REF_QUAL_NONE
;
11006 if (decl_context
== FIELD
11007 && !member_function_or_else (ctype
,
11008 current_class_type
,
11010 return error_mark_node
;
11012 if (flags
!= DTOR_FLAG
)
11014 /* It's a constructor. */
11015 if (explicitp
== 1)
11019 permerror (input_location
,
11020 "constructors cannot be declared %<virtual%>");
11023 if (decl_context
== FIELD
11024 && sfk
!= sfk_constructor
)
11025 return error_mark_node
;
11027 if (decl_context
== FIELD
)
11034 /* Cannot be both friend and virtual. */
11035 error ("virtual functions cannot be friends");
11038 if (decl_context
== NORMAL
)
11039 error ("friend declaration not in class definition");
11040 if (current_function_decl
&& funcdef_flag
)
11041 error ("can%'t define friend function %qs in a local "
11042 "class definition",
11045 else if (ctype
&& sfk
== sfk_conversion
)
11047 if (explicitp
== 1)
11049 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
11052 if (late_return_type_p
)
11053 error ("a conversion function cannot have a trailing return type");
11055 else if (sfk
== sfk_deduction_guide
)
11057 if (explicitp
== 1)
11061 arg_types
= grokparms (declarator
->u
.function
.parameters
,
11064 if (inner_declarator
11065 && inner_declarator
->kind
== cdk_id
11066 && inner_declarator
->u
.id
.sfk
== sfk_destructor
11067 && arg_types
!= void_list_node
)
11069 error ("destructors may not have parameters");
11070 arg_types
= void_list_node
;
11074 type
= build_function_type (type
, arg_types
);
11076 tree attrs
= declarator
->std_attributes
;
11079 tree att
= build_tree_list (tx_qual
, NULL_TREE
);
11080 /* transaction_safe applies to the type, but
11081 transaction_safe_dynamic applies to the function. */
11082 if (is_attribute_p ("transaction_safe", tx_qual
))
11083 attrs
= chainon (attrs
, att
);
11085 returned_attrs
= chainon (returned_attrs
, att
);
11090 The optional attribute-specifier-seq appertains to
11091 the function type. */
11092 decl_attributes (&type
, attrs
, 0);
11095 type
= build_exception_variant (type
, raises
);
11100 case cdk_reference
:
11102 /* Filter out pointers-to-references and references-to-references.
11103 We can get these if a TYPE_DECL is used. */
11105 if (TREE_CODE (type
) == REFERENCE_TYPE
)
11107 if (declarator
->kind
!= cdk_reference
)
11109 error ("cannot declare pointer to %q#T", type
);
11110 type
= TREE_TYPE (type
);
11113 /* In C++0x, we allow reference to reference declarations
11114 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
11115 and template type arguments [14.3.1/4 temp.arg.type]. The
11116 check for direct reference to reference declarations, which
11117 are still forbidden, occurs below. Reasoning behind the change
11118 can be found in DR106, DR540, and the rvalue reference
11120 else if (cxx_dialect
== cxx98
)
11122 error ("cannot declare reference to %q#T", type
);
11123 type
= TREE_TYPE (type
);
11126 else if (VOID_TYPE_P (type
))
11128 if (declarator
->kind
== cdk_reference
)
11129 error ("cannot declare reference to %q#T", type
);
11130 else if (declarator
->kind
== cdk_ptrmem
)
11131 error ("cannot declare pointer to %q#T member", type
);
11134 /* We now know that the TYPE_QUALS don't apply to the decl,
11135 but to the target of the pointer. */
11136 type_quals
= TYPE_UNQUALIFIED
;
11138 /* This code used to handle METHOD_TYPE, but I don't think it's
11139 possible to get it here anymore. */
11140 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
11141 if (declarator
->kind
== cdk_ptrmem
11142 && TREE_CODE (type
) == FUNCTION_TYPE
)
11144 memfn_quals
|= type_memfn_quals (type
);
11145 type
= build_memfn_type (type
,
11146 declarator
->u
.pointer
.class_type
,
11149 if (type
== error_mark_node
)
11150 return error_mark_node
;
11152 rqual
= REF_QUAL_NONE
;
11153 memfn_quals
= TYPE_UNQUALIFIED
;
11156 if (TREE_CODE (type
) == FUNCTION_TYPE
11157 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
11158 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
11159 error (declarator
->kind
== cdk_reference
11160 ? G_("cannot declare reference to qualified function type %qT")
11161 : G_("cannot declare pointer to qualified function type %qT"),
11164 /* When the pointed-to type involves components of variable size,
11165 care must be taken to ensure that the size evaluation code is
11166 emitted early enough to dominate all the possible later uses
11167 and late enough for the variables on which it depends to have
11170 This is expected to happen automatically when the pointed-to
11171 type has a name/declaration of it's own, but special attention
11172 is required if the type is anonymous.
11174 We handle the NORMAL and FIELD contexts here by inserting a
11175 dummy statement that just evaluates the size at a safe point
11176 and ensures it is not deferred until e.g. within a deeper
11177 conditional context (c++/43555).
11179 We expect nothing to be needed here for PARM or TYPENAME.
11180 Evaluating the size at this point for TYPENAME would
11181 actually be incorrect, as we might be in the middle of an
11182 expression with side effects on the pointed-to type size
11183 "arguments" prior to the pointer declaration point and the
11184 size evaluation could end up prior to the side effects. */
11186 if (!TYPE_NAME (type
)
11187 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
11188 && at_function_scope_p ()
11189 && variably_modified_type_p (type
, NULL_TREE
))
11191 TYPE_NAME (type
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
11193 add_decl_expr (TYPE_NAME (type
));
11196 if (declarator
->kind
== cdk_reference
)
11198 /* In C++0x, the type we are creating a reference to might be
11199 a typedef which is itself a reference type. In that case,
11200 we follow the reference collapsing rules in
11201 [7.1.3/8 dcl.typedef] to create the final reference type:
11203 "If a typedef TD names a type that is a reference to a type
11204 T, an attempt to create the type 'lvalue reference to cv TD'
11205 creates the type 'lvalue reference to T,' while an attempt
11206 to create the type "rvalue reference to cv TD' creates the
11209 if (VOID_TYPE_P (type
))
11210 /* We already gave an error. */;
11211 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
11213 if (declarator
->u
.reference
.rvalue_ref
)
11214 /* Leave type alone. */;
11216 type
= cp_build_reference_type (TREE_TYPE (type
), false);
11219 type
= cp_build_reference_type
11220 (type
, declarator
->u
.reference
.rvalue_ref
);
11222 /* In C++0x, we need this check for direct reference to
11223 reference declarations, which are forbidden by
11224 [8.3.2/5 dcl.ref]. Reference to reference declarations
11225 are only allowed indirectly through typedefs and template
11226 type arguments. Example:
11228 void foo(int & &); // invalid ref-to-ref decl
11230 typedef int & int_ref;
11231 void foo(int_ref &); // valid ref-to-ref decl
11233 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
11234 error ("cannot declare reference to %q#T, which is not "
11235 "a typedef or a template type argument", type
);
11237 else if (TREE_CODE (type
) == METHOD_TYPE
)
11238 type
= build_ptrmemfunc_type (build_pointer_type (type
));
11239 else if (declarator
->kind
== cdk_ptrmem
)
11241 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
11242 != NAMESPACE_DECL
);
11243 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
11244 /* We will already have complained. */
11245 type
= error_mark_node
;
11247 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
11251 type
= build_pointer_type (type
);
11253 /* Process a list of type modifier keywords (such as
11254 const or volatile) that were given inside the `*' or `&'. */
11256 if (declarator
->u
.pointer
.qualifiers
)
11259 = cp_build_qualified_type (type
,
11260 declarator
->u
.pointer
.qualifiers
);
11261 type_quals
= cp_type_quals (type
);
11264 /* Apply C++11 attributes to the pointer, and not to the
11265 type pointed to. This is unlike what is done for GNU
11266 attributes above. It is to comply with [dcl.ptr]/1:
11268 [the optional attribute-specifier-seq (7.6.1) appertains
11269 to the pointer and not to the object pointed to]. */
11270 if (declarator
->std_attributes
)
11271 decl_attributes (&type
, declarator
->std_attributes
,
11281 gcc_unreachable ();
11285 /* A `constexpr' specifier used in an object declaration declares
11286 the object as `const'. */
11287 if (constexpr_p
&& innermost_code
!= cdk_function
)
11289 /* DR1688 says that a `constexpr' specifier in combination with
11290 `volatile' is valid. */
11292 if (TREE_CODE (type
) != REFERENCE_TYPE
)
11294 type_quals
|= TYPE_QUAL_CONST
;
11295 type
= cp_build_qualified_type (type
, type_quals
);
11299 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
11300 && TREE_CODE (type
) != FUNCTION_TYPE
11301 && TREE_CODE (type
) != METHOD_TYPE
11302 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
11304 error ("template-id %qD used as a declarator",
11306 unqualified_id
= dname
;
11309 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
11310 qualified with a class-name, turn it into a METHOD_TYPE, unless
11311 we know that the function is static. We take advantage of this
11312 opportunity to do other processing that pertains to entities
11313 explicitly declared to be class members. Note that if DECLARATOR
11314 is non-NULL, we know it is a cdk_id declarator; otherwise, we
11315 would not have exited the loop above. */
11317 && declarator
->kind
== cdk_id
11318 && declarator
->u
.id
.qualifying_scope
11319 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
11321 ctype
= declarator
->u
.id
.qualifying_scope
;
11322 ctype
= TYPE_MAIN_VARIANT (ctype
);
11323 template_count
= num_template_headers_for_class (ctype
);
11325 if (ctype
== current_class_type
)
11329 permerror (input_location
, "member functions are implicitly "
11330 "friends of their class");
11334 permerror (declarator
->id_loc
,
11335 "extra qualification %<%T::%> on member %qs",
11338 else if (/* If the qualifying type is already complete, then we
11339 can skip the following checks. */
11340 !COMPLETE_TYPE_P (ctype
)
11341 && (/* If the function is being defined, then
11342 qualifying type must certainly be complete. */
11344 /* A friend declaration of "T::f" is OK, even if
11345 "T" is a template parameter. But, if this
11346 function is not a friend, the qualifying type
11347 must be a class. */
11348 || (!friendp
&& !CLASS_TYPE_P (ctype
))
11349 /* For a declaration, the type need not be
11350 complete, if either it is dependent (since there
11351 is no meaningful definition of complete in that
11352 case) or the qualifying class is currently being
11354 || !(dependent_type_p (ctype
)
11355 || currently_open_class (ctype
)))
11356 /* Check that the qualifying type is complete. */
11357 && !complete_type_or_else (ctype
, NULL_TREE
))
11358 return error_mark_node
;
11359 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11361 if (current_class_type
11362 && (!friendp
|| funcdef_flag
|| initialized
))
11364 error (funcdef_flag
|| initialized
11365 ? G_("cannot define member function %<%T::%s%> "
11367 : G_("cannot declare member function %<%T::%s%> "
11369 ctype
, name
, current_class_type
);
11370 return error_mark_node
;
11373 else if (typedef_p
&& current_class_type
)
11375 error ("cannot declare member %<%T::%s%> within %qT",
11376 ctype
, name
, current_class_type
);
11377 return error_mark_node
;
11381 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
11382 ctype
= current_class_type
;
11384 /* Now TYPE has the actual type. */
11386 if (returned_attrs
)
11389 *attrlist
= chainon (returned_attrs
, *attrlist
);
11391 attrlist
= &returned_attrs
;
11395 && declarator
->kind
== cdk_id
11396 && declarator
->std_attributes
11397 && attrlist
!= NULL
)
11398 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
11399 a declarator-id appertains to the entity that is declared. */
11400 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
11402 /* Handle parameter packs. */
11403 if (parameter_pack_p
)
11405 if (decl_context
== PARM
)
11406 /* Turn the type into a pack expansion.*/
11407 type
= make_pack_expansion (type
);
11409 error ("non-parameter %qs cannot be a parameter pack", name
);
11412 if ((decl_context
== FIELD
|| decl_context
== PARM
)
11413 && !processing_template_decl
11414 && variably_modified_type_p (type
, NULL_TREE
))
11416 if (decl_context
== FIELD
)
11417 error ("data member may not have variably modified type %qT", type
);
11419 error ("parameter may not have variably modified type %qT", type
);
11420 type
= error_mark_node
;
11423 if (explicitp
== 1 || (explicitp
&& friendp
))
11425 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
11426 in the declaration of a constructor or conversion function within
11427 a class definition. */
11428 if (!current_class_type
)
11429 error_at (declspecs
->locations
[ds_explicit
],
11430 "%<explicit%> outside class declaration");
11432 error_at (declspecs
->locations
[ds_explicit
],
11433 "%<explicit%> in friend declaration");
11435 error_at (declspecs
->locations
[ds_explicit
],
11436 "only declarations of constructors and conversion operators "
11437 "can be %<explicit%>");
11441 if (storage_class
== sc_mutable
)
11443 if (decl_context
!= FIELD
|| friendp
)
11445 error ("non-member %qs cannot be declared %<mutable%>", name
);
11446 storage_class
= sc_none
;
11448 else if (decl_context
== TYPENAME
|| typedef_p
)
11450 error ("non-object member %qs cannot be declared %<mutable%>", name
);
11451 storage_class
= sc_none
;
11453 else if (TREE_CODE (type
) == FUNCTION_TYPE
11454 || TREE_CODE (type
) == METHOD_TYPE
)
11456 error ("function %qs cannot be declared %<mutable%>", name
);
11457 storage_class
= sc_none
;
11461 error ("static %qs cannot be declared %<mutable%>", name
);
11462 storage_class
= sc_none
;
11464 else if (type_quals
& TYPE_QUAL_CONST
)
11466 error ("const %qs cannot be declared %<mutable%>", name
);
11467 storage_class
= sc_none
;
11469 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
11471 permerror (input_location
, "reference %qs cannot be declared "
11472 "%<mutable%>", name
);
11473 storage_class
= sc_none
;
11477 /* If this is declaring a typedef name, return a TYPE_DECL. */
11478 if (typedef_p
&& decl_context
!= TYPENAME
)
11482 /* This declaration:
11484 typedef void f(int) const;
11486 declares a function type which is not a member of any
11487 particular class, but which is cv-qualified; for
11488 example "f S::*" declares a pointer to a const-qualified
11489 member function of S. We record the cv-qualification in the
11491 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
11493 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
11495 /* We have now dealt with these qualifiers. */
11496 memfn_quals
= TYPE_UNQUALIFIED
;
11497 rqual
= REF_QUAL_NONE
;
11500 if (type_uses_auto (type
))
11502 error ("typedef declared %<auto%>");
11503 type
= error_mark_node
;
11507 error_at (location_of (reqs
), "requires-clause on typedef");
11509 if (decl_context
== FIELD
)
11510 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
11512 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
11513 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
11514 error_at (DECL_SOURCE_LOCATION (decl
),
11515 "typedef name may not be a nested-name-specifier");
11516 TREE_TYPE (decl
) = error_mark_node
;
11519 if (decl_context
!= FIELD
)
11521 if (!current_function_decl
)
11522 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
11523 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
11524 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
11525 (current_function_decl
)))
11526 /* The TYPE_DECL is "abstract" because there will be
11527 clones of this constructor/destructor, and there will
11528 be copies of this TYPE_DECL generated in those
11529 clones. The decloning optimization (for space) may
11530 revert this subsequently if it determines that
11531 the clones should share a common implementation. */
11532 DECL_ABSTRACT_P (decl
) = true;
11534 else if (current_class_type
11535 && constructor_name_p (unqualified_id
, current_class_type
))
11536 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
11537 "as enclosing class",
11540 /* If the user declares "typedef struct {...} foo" then the
11541 struct will have an anonymous name. Fill that name in now.
11542 Nothing can refer to it, so nothing needs know about the name
11544 if (type
!= error_mark_node
11546 && TYPE_NAME (type
)
11547 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
11548 && TYPE_UNNAMED_P (type
)
11549 && declspecs
->type_definition_p
11550 && attributes_naming_typedef_ok (*attrlist
)
11551 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
11552 name_unnamed_type (type
, decl
);
11555 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
11556 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
11558 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
11559 memfn_quals
!= TYPE_UNQUALIFIED
,
11560 inlinep
, friendp
, raises
!= NULL_TREE
);
11562 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
11563 /* Acknowledge that this was written:
11564 `using analias = atype;'. */
11565 TYPE_DECL_ALIAS_P (decl
) = 1;
11570 /* Detect the case of an array type of unspecified size
11571 which came, as such, direct from a typedef name.
11572 We must copy the type, so that the array's domain can be
11573 individually set by the object's initializer. */
11575 if (type
&& typedef_type
11576 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
11577 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
11578 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
11580 /* Detect where we're using a typedef of function type to declare a
11581 function. PARMS will not be set, so we must create it now. */
11583 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
11585 tree decls
= NULL_TREE
;
11588 for (args
= TYPE_ARG_TYPES (type
);
11589 args
&& args
!= void_list_node
;
11590 args
= TREE_CHAIN (args
))
11592 tree decl
= cp_build_parm_decl (NULL_TREE
, NULL_TREE
,
11593 TREE_VALUE (args
));
11595 DECL_CHAIN (decl
) = decls
;
11599 parms
= nreverse (decls
);
11601 if (decl_context
!= TYPENAME
)
11603 /* The qualifiers on the function type become the qualifiers on
11604 the non-static member function. */
11605 memfn_quals
|= type_memfn_quals (type
);
11606 rqual
= type_memfn_rqual (type
);
11607 type_quals
= TYPE_UNQUALIFIED
;
11611 /* If this is a type name (such as, in a cast or sizeof),
11612 compute the type and return it now. */
11614 if (decl_context
== TYPENAME
)
11616 /* Note that here we don't care about type_quals. */
11618 /* Special case: "friend class foo" looks like a TYPENAME context. */
11623 error ("%<inline%> specified for friend class declaration");
11629 /* Don't allow friend declaration without a class-key. */
11630 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11631 permerror (input_location
, "template parameters cannot be friends");
11632 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
11633 permerror (input_location
, "friend declaration requires class-key, "
11634 "i.e. %<friend class %T::%D%>",
11635 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
11637 permerror (input_location
, "friend declaration requires class-key, "
11638 "i.e. %<friend %#T%>",
11642 /* Only try to do this stuff if we didn't already give up. */
11643 if (type
!= integer_type_node
)
11645 /* A friendly class? */
11646 if (current_class_type
)
11647 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
11648 /*complain=*/true);
11650 error ("trying to make class %qT a friend of global scope",
11653 type
= void_type_node
;
11656 else if (memfn_quals
|| rqual
)
11658 if (ctype
== NULL_TREE
11659 && TREE_CODE (type
) == METHOD_TYPE
)
11660 ctype
= TYPE_METHOD_BASETYPE (type
);
11663 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
11664 /* Core issue #547: need to allow this in template type args.
11665 Allow it in general in C++11 for alias-declarations. */
11666 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
11667 && TREE_CODE (type
) == FUNCTION_TYPE
)
11668 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
11670 error ("invalid qualifiers on non-member function type");
11674 error_at (location_of (reqs
), "requires-clause on type-id");
11678 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
11679 && decl_context
!= CATCHPARM
11680 && TREE_CODE (type
) != UNION_TYPE
11682 && innermost_code
!= cdk_decomp
)
11684 error ("abstract declarator %qT used as declaration", type
);
11685 return error_mark_node
;
11688 if (!FUNC_OR_METHOD_TYPE_P (type
))
11690 /* Only functions may be declared using an operator-function-id. */
11691 if (dname
&& IDENTIFIER_ANY_OP_P (dname
))
11693 error ("declaration of %qD as non-function", dname
);
11694 return error_mark_node
;
11698 error_at (location_of (reqs
),
11699 "requires-clause on declaration of non-function type %qT",
11703 /* We don't check parameter types here because we can emit a better
11704 error message later. */
11705 if (decl_context
!= PARM
)
11707 type
= check_var_type (unqualified_id
, type
);
11708 if (type
== error_mark_node
)
11709 return error_mark_node
;
11712 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11713 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11715 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
11717 if (ctype
|| in_namespace
)
11718 error ("cannot use %<::%> in parameter declaration");
11720 if (type_uses_auto (type
)
11721 && !(cxx_dialect
>= cxx17
&& template_parm_flag
))
11723 if (cxx_dialect
>= cxx14
)
11724 error ("%<auto%> parameter not permitted in this context");
11726 error ("parameter declared %<auto%>");
11727 type
= error_mark_node
;
11730 /* A parameter declared as an array of T is really a pointer to T.
11731 One declared as a function is really a pointer to a function.
11732 One declared as a member is really a pointer to member. */
11734 if (TREE_CODE (type
) == ARRAY_TYPE
)
11736 /* Transfer const-ness of array into that of type pointed to. */
11737 type
= build_pointer_type (TREE_TYPE (type
));
11738 type_quals
= TYPE_UNQUALIFIED
;
11739 array_parameter_p
= true;
11741 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11742 type
= build_pointer_type (type
);
11745 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
11746 && !(identifier_p (unqualified_id
)
11747 && IDENTIFIER_NEWDEL_OP_P (unqualified_id
)))
11749 cp_cv_quals real_quals
= memfn_quals
;
11750 if (cxx_dialect
< cxx14
&& constexpr_p
11751 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
11752 real_quals
|= TYPE_QUAL_CONST
;
11753 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
11757 tree decl
= NULL_TREE
;
11759 if (decl_context
== PARM
)
11761 decl
= cp_build_parm_decl (NULL_TREE
, unqualified_id
, type
);
11762 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
11764 bad_specifiers (decl
, BSP_PARM
, virtualp
,
11765 memfn_quals
!= TYPE_UNQUALIFIED
,
11766 inlinep
, friendp
, raises
!= NULL_TREE
);
11768 else if (decl_context
== FIELD
)
11770 if (!staticp
&& !friendp
&& TREE_CODE (type
) != METHOD_TYPE
)
11771 if (tree auto_node
= type_uses_auto (type
))
11773 location_t loc
= declspecs
->locations
[ds_type_spec
];
11774 if (CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
11775 error_at (loc
, "invalid use of template-name %qE without an "
11777 CLASS_PLACEHOLDER_TEMPLATE (auto_node
));
11779 error_at (loc
, "non-static data member declared with "
11780 "placeholder %qT", auto_node
);
11781 type
= error_mark_node
;
11784 /* The C99 flexible array extension. */
11785 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
11786 && TYPE_DOMAIN (type
) == NULL_TREE
)
11789 && (TREE_CODE (ctype
) == UNION_TYPE
11790 || TREE_CODE (ctype
) == QUAL_UNION_TYPE
))
11792 error ("flexible array member in union");
11793 type
= error_mark_node
;
11797 /* Array is a flexible member. */
11798 if (in_system_header_at (input_location
))
11799 /* Do not warn on flexible array members in system
11800 headers because glibc uses them. */;
11802 pedwarn (input_location
, OPT_Wpedantic
,
11803 "ISO C++ forbids flexible array member %qs", name
);
11805 pedwarn (input_location
, OPT_Wpedantic
,
11806 "ISO C++ forbids flexible array members");
11808 /* Flexible array member has a null domain. */
11809 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
11813 if (type
== error_mark_node
)
11815 /* Happens when declaring arrays of sizes which
11816 are error_mark_node, for example. */
11819 else if (in_namespace
&& !friendp
)
11821 /* Something like struct S { int N::j; }; */
11822 error ("invalid use of %<::%>");
11823 return error_mark_node
;
11825 else if (TREE_CODE (type
) == FUNCTION_TYPE
11826 || TREE_CODE (type
) == METHOD_TYPE
)
11829 tree function_context
;
11833 /* This should never happen in pure C++ (the check
11834 could be an assert). It could happen in
11835 Objective-C++ if someone writes invalid code that
11836 uses a function declaration for an instance
11837 variable or property (instance variables and
11838 properties are parsed as FIELD_DECLs, but they are
11839 part of an Objective-C class, not a C++ class).
11840 That code is invalid and is caught by this
11844 error ("declaration of function %qD in invalid context",
11846 return error_mark_node
;
11849 /* ``A union may [ ... ] not [ have ] virtual functions.''
11851 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11853 error ("function %qD declared %<virtual%> inside a union",
11855 return error_mark_node
;
11859 && identifier_p (unqualified_id
)
11860 && IDENTIFIER_NEWDEL_OP_P (unqualified_id
))
11862 error ("%qD cannot be declared %<virtual%>, since it "
11863 "is always static", unqualified_id
);
11868 /* Check that the name used for a destructor makes sense. */
11869 if (sfk
== sfk_destructor
)
11871 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
11875 gcc_assert (friendp
);
11876 error ("expected qualified name in friend declaration "
11877 "for destructor %qD", uqname
);
11878 return error_mark_node
;
11881 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
11883 error ("declaration of %qD as member of %qT",
11885 return error_mark_node
;
11889 error ("a destructor cannot be %<concept%>");
11890 return error_mark_node
;
11894 error ("a destructor cannot be %<constexpr%>");
11895 return error_mark_node
;
11898 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
11900 error ("expected qualified name in friend declaration "
11901 "for constructor %qD",
11902 id_declarator
->u
.id
.unqualified_name
);
11903 return error_mark_node
;
11905 if (sfk
== sfk_constructor
)
11908 error ("a constructor cannot be %<concept%>");
11909 return error_mark_node
;
11913 error ("a concept cannot be a member function");
11917 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
11919 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
11920 if (variable_template_p (tmpl
))
11922 error ("specialization of variable template %qD "
11923 "declared as function", tmpl
);
11924 inform (DECL_SOURCE_LOCATION (tmpl
),
11925 "variable template declared here");
11926 return error_mark_node
;
11930 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11931 function_context
= (ctype
!= NULL_TREE
) ?
11932 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11933 publicp
= (! friendp
|| ! staticp
)
11934 && function_context
== NULL_TREE
;
11936 if (late_return_type_p
)
11937 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11939 decl
= grokfndecl (ctype
, type
,
11940 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
11941 ? unqualified_id
: dname
,
11945 virtualp
, flags
, memfn_quals
, rqual
, raises
,
11946 friendp
? -1 : 0, friendp
, publicp
,
11947 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
11948 initialized
== SD_DELETED
, sfk
,
11949 funcdef_flag
, template_count
, in_namespace
,
11950 attrlist
, declarator
->id_loc
);
11951 decl
= set_virt_specifiers (decl
, virt_specifiers
);
11952 if (decl
== NULL_TREE
)
11953 return error_mark_node
;
11955 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11956 /* The decl and setting of decl_attr is also turned off. */
11957 decl
= build_decl_attribute_variant (decl
, decl_attr
);
11960 /* [class.conv.ctor]
11962 A constructor declared without the function-specifier
11963 explicit that can be called with a single parameter
11964 specifies a conversion from the type of its first
11965 parameter to the type of its class. Such a constructor
11966 is called a converting constructor. */
11967 if (explicitp
== 2)
11968 DECL_NONCONVERTING_P (decl
) = 1;
11970 else if (!staticp
&& !dependent_type_p (type
)
11971 && !COMPLETE_TYPE_P (complete_type (type
))
11972 && (!complete_or_array_type_p (type
)
11973 || initialized
== 0))
11975 if (TREE_CODE (type
) != ARRAY_TYPE
11976 || !COMPLETE_TYPE_P (TREE_TYPE (type
)))
11978 if (unqualified_id
)
11980 error ("field %qD has incomplete type %qT",
11981 unqualified_id
, type
);
11982 cxx_incomplete_type_inform (strip_array_types (type
));
11985 error ("name %qT has incomplete type", type
);
11987 type
= error_mark_node
;
11995 error ("%qE is neither function nor member function; "
11996 "cannot be declared friend", unqualified_id
);
12004 /* Friends are treated specially. */
12005 if (ctype
== current_class_type
)
12006 ; /* We already issued a permerror. */
12007 else if (decl
&& DECL_NAME (decl
))
12009 if (template_class_depth (current_class_type
) == 0)
12011 decl
= check_explicit_specialization
12012 (unqualified_id
, decl
, template_count
,
12013 2 * funcdef_flag
+ 4);
12014 if (decl
== error_mark_node
)
12015 return error_mark_node
;
12018 decl
= do_friend (ctype
, unqualified_id
, decl
,
12024 return error_mark_node
;
12027 /* Structure field. It may not be a function, except for C++. */
12029 if (decl
== NULL_TREE
)
12033 /* C++ allows static class members. All other work
12034 for this is done by grokfield. */
12035 decl
= build_lang_decl_loc (declarator
12036 ? declarator
->id_loc
12038 VAR_DECL
, unqualified_id
, type
);
12039 set_linkage_for_static_data_member (decl
);
12041 error ("static data member %qE declared %<concept%>",
12043 else if (constexpr_p
&& !initialized
)
12045 error ("constexpr static data member %qD must have an "
12046 "initializer", decl
);
12047 constexpr_p
= false;
12051 mark_inline_variable (decl
);
12053 if (!DECL_VAR_DECLARED_INLINE_P (decl
)
12054 && !(cxx_dialect
>= cxx17
&& constexpr_p
))
12055 /* Even if there is an in-class initialization, DECL
12056 is considered undefined until an out-of-class
12057 definition is provided, unless this is an inline
12059 DECL_EXTERNAL (decl
) = 1;
12063 CP_DECL_THREAD_LOCAL_P (decl
) = true;
12064 if (!processing_template_decl
)
12065 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
12066 if (declspecs
->gnu_thread_keyword_p
)
12067 SET_DECL_GNU_TLS_P (decl
);
12073 error ("non-static data member %qE declared %<concept%>",
12075 else if (constexpr_p
)
12077 error ("non-static data member %qE declared %<constexpr%>",
12079 constexpr_p
= false;
12081 decl
= build_decl (input_location
,
12082 FIELD_DECL
, unqualified_id
, type
);
12083 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
12084 if (bitfield
&& !unqualified_id
)
12085 TREE_NO_WARNING (decl
) = 1;
12087 if (storage_class
== sc_mutable
)
12089 DECL_MUTABLE_P (decl
) = 1;
12090 storage_class
= sc_none
;
12095 /* An attempt is being made to initialize a non-static
12096 member. This is new in C++11. */
12097 maybe_warn_cpp0x (CPP0X_NSDMI
);
12099 /* If this has been parsed with static storage class, but
12100 errors forced staticp to be cleared, ensure NSDMI is
12102 if (declspecs
->storage_class
== sc_static
)
12103 DECL_INITIAL (decl
) = error_mark_node
;
12107 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
12108 memfn_quals
!= TYPE_UNQUALIFIED
,
12109 staticp
? false : inlinep
, friendp
,
12110 raises
!= NULL_TREE
);
12113 else if (TREE_CODE (type
) == FUNCTION_TYPE
12114 || TREE_CODE (type
) == METHOD_TYPE
)
12116 tree original_name
;
12119 if (!unqualified_id
)
12120 return error_mark_node
;
12122 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
12123 original_name
= dname
;
12125 original_name
= unqualified_id
;
12126 // FIXME:gcc_assert (original_name == dname);
12128 if (storage_class
== sc_auto
)
12129 error ("storage class %<auto%> invalid for function %qs", name
);
12130 else if (storage_class
== sc_register
)
12131 error ("storage class %<register%> invalid for function %qs", name
);
12134 if (declspecs
->gnu_thread_keyword_p
)
12135 error ("storage class %<__thread%> invalid for function %qs",
12138 error ("storage class %<thread_local%> invalid for function %qs",
12142 if (virt_specifiers
)
12143 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
12144 /* Function declaration not at top level.
12145 Storage classes other than `extern' are not allowed
12146 and `extern' makes no difference. */
12147 if (! toplevel_bindings_p ()
12148 && (storage_class
== sc_static
12149 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
12152 if (storage_class
== sc_static
)
12153 pedwarn (input_location
, OPT_Wpedantic
,
12154 "%<static%> specifier invalid for function %qs "
12155 "declared out of global scope", name
);
12157 pedwarn (input_location
, OPT_Wpedantic
,
12158 "%<inline%> specifier invalid for function %qs "
12159 "declared out of global scope", name
);
12162 if (ctype
== NULL_TREE
)
12166 error ("virtual non-class function %qs", name
);
12169 else if (sfk
== sfk_constructor
12170 || sfk
== sfk_destructor
)
12172 error (funcdef_flag
12173 ? G_("%qs defined in a non-class scope")
12174 : G_("%qs declared in a non-class scope"), name
);
12179 /* Record whether the function is public. */
12180 publicp
= (ctype
!= NULL_TREE
12181 || storage_class
!= sc_static
);
12183 if (late_return_type_p
)
12184 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
12186 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
12187 reqs
, virtualp
, flags
, memfn_quals
, rqual
, raises
,
12190 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
12191 initialized
== SD_DELETED
,
12194 template_count
, in_namespace
, attrlist
,
12195 declarator
->id_loc
);
12196 if (decl
== NULL_TREE
)
12197 return error_mark_node
;
12199 if (explicitp
== 2)
12200 DECL_NONCONVERTING_P (decl
) = 1;
12203 int invalid_static
= 0;
12205 /* Don't allow a static member function in a class, and forbid
12206 declaring main to be static. */
12207 if (TREE_CODE (type
) == METHOD_TYPE
)
12209 permerror (input_location
, "cannot declare member function %qD to have "
12210 "static linkage", decl
);
12211 invalid_static
= 1;
12213 else if (current_function_decl
)
12215 /* 7.1.1: There can be no static function declarations within a
12217 error ("cannot declare static function inside another function");
12218 invalid_static
= 1;
12221 if (invalid_static
)
12224 storage_class
= sc_none
;
12230 /* It's a variable. */
12232 /* An uninitialized decl with `extern' is a reference. */
12233 decl
= grokvardecl (type
, dname
, unqualified_id
,
12240 ctype
? ctype
: in_namespace
);
12241 if (decl
== NULL_TREE
)
12242 return error_mark_node
;
12244 bad_specifiers (decl
, BSP_VAR
, virtualp
,
12245 memfn_quals
!= TYPE_UNQUALIFIED
,
12246 inlinep
, friendp
, raises
!= NULL_TREE
);
12250 DECL_CONTEXT (decl
) = ctype
;
12253 permerror (input_location
, "%<static%> may not be used when defining "
12254 "(as opposed to declaring) a static data member");
12256 storage_class
= sc_none
;
12258 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
12260 error ("static member %qD declared %<register%>", decl
);
12261 storage_class
= sc_none
;
12263 if (storage_class
== sc_extern
&& pedantic
)
12265 pedwarn (input_location
, OPT_Wpedantic
,
12266 "cannot explicitly declare member %q#D to have "
12267 "extern linkage", decl
);
12268 storage_class
= sc_none
;
12271 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
12273 error ("declaration of constexpr variable %qD is not a definition",
12275 constexpr_p
= false;
12279 mark_inline_variable (decl
);
12280 if (innermost_code
== cdk_decomp
)
12282 gcc_assert (declarator
&& declarator
->kind
== cdk_decomp
);
12283 DECL_SOURCE_LOCATION (decl
) = declarator
->id_loc
;
12284 DECL_ARTIFICIAL (decl
) = 1;
12285 fit_decomposition_lang_decl (decl
, NULL_TREE
);
12289 if (VAR_P (decl
) && !initialized
)
12290 if (tree auto_node
= type_uses_auto (type
))
12291 if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
12293 location_t loc
= declspecs
->locations
[ds_type_spec
];
12294 error_at (loc
, "declaration of %q#D has no initializer", decl
);
12295 TREE_TYPE (decl
) = error_mark_node
;
12298 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
12300 if (toplevel_bindings_p ())
12302 /* It's common practice (and completely valid) to have a const
12303 be initialized and declared extern. */
12304 if (!(type_quals
& TYPE_QUAL_CONST
))
12305 warning (0, "%qs initialized and declared %<extern%>", name
);
12309 error ("%qs has both %<extern%> and initializer", name
);
12310 return error_mark_node
;
12314 /* Record `register' declaration for warnings on &
12315 and in case doing stupid register allocation. */
12317 if (storage_class
== sc_register
)
12319 DECL_REGISTER (decl
) = 1;
12320 /* Warn about register storage specifiers on PARM_DECLs. */
12321 if (TREE_CODE (decl
) == PARM_DECL
)
12323 if (cxx_dialect
>= cxx17
)
12324 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
12325 "ISO C++17 does not allow %<register%> storage "
12326 "class specifier");
12328 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
12329 "%<register%> storage class specifier used");
12332 else if (storage_class
== sc_extern
)
12333 DECL_THIS_EXTERN (decl
) = 1;
12334 else if (storage_class
== sc_static
)
12335 DECL_THIS_STATIC (decl
) = 1;
12337 /* Set constexpr flag on vars (functions got it in grokfndecl). */
12338 if (constexpr_p
&& VAR_P (decl
))
12339 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
12341 /* Record constancy and volatility on the DECL itself . There's
12342 no need to do this when processing a template; we'll do this
12343 for the instantiated declaration based on the type of DECL. */
12344 if (!processing_template_decl
)
12345 cp_apply_type_quals_to_decl (type_quals
, decl
);
12351 /* Subroutine of start_function. Ensure that each of the parameter
12352 types (as listed in PARMS) is complete, as is required for a
12353 function definition. */
12356 require_complete_types_for_parms (tree parms
)
12358 for (; parms
; parms
= DECL_CHAIN (parms
))
12360 if (dependent_type_p (TREE_TYPE (parms
)))
12362 if (!VOID_TYPE_P (TREE_TYPE (parms
))
12363 && complete_type_or_else (TREE_TYPE (parms
), parms
))
12365 relayout_decl (parms
);
12366 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
12368 maybe_warn_parm_abi (TREE_TYPE (parms
),
12369 DECL_SOURCE_LOCATION (parms
));
12372 /* grokparms or complete_type_or_else will have already issued
12374 TREE_TYPE (parms
) = error_mark_node
;
12378 /* Returns nonzero if T is a local variable. */
12381 local_variable_p (const_tree t
)
12384 /* A VAR_DECL with a context that is a _TYPE is a static data
12386 && !TYPE_P (CP_DECL_CONTEXT (t
))
12387 /* Any other non-local variable must be at namespace scope. */
12388 && !DECL_NAMESPACE_SCOPE_P (t
))
12389 || (TREE_CODE (t
) == PARM_DECL
))
12395 /* Like local_variable_p, but suitable for use as a tree-walking
12399 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
12402 if (local_variable_p (*tp
)
12403 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
12405 else if (TYPE_P (*tp
))
12406 *walk_subtrees
= 0;
12411 /* Check that ARG, which is a default-argument expression for a
12412 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
12413 something goes wrong. DECL may also be a _TYPE node, rather than a
12414 DECL, if there is no DECL available. */
12417 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
12422 if (TREE_CODE (arg
) == DEFAULT_ARG
)
12423 /* We get a DEFAULT_ARG when looking at an in-class declaration
12424 with a default argument. Ignore the argument for now; we'll
12425 deal with it after the class is complete. */
12434 decl_type
= TREE_TYPE (decl
);
12436 if (arg
== error_mark_node
12437 || decl
== error_mark_node
12438 || TREE_TYPE (arg
) == error_mark_node
12439 || decl_type
== error_mark_node
)
12440 /* Something already went wrong. There's no need to check
12442 return error_mark_node
;
12444 /* [dcl.fct.default]
12446 A default argument expression is implicitly converted to the
12448 ++cp_unevaluated_operand
;
12449 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
12451 --cp_unevaluated_operand
;
12453 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
12455 if (TYPE_PTR_OR_PTRMEM_P (decl_type
)
12456 && null_ptr_cst_p (arg
))
12457 return nullptr_node
;
12459 /* [dcl.fct.default]
12461 Local variables shall not be used in default argument
12464 The keyword `this' shall not be used in a default argument of a
12465 member function. */
12466 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
12469 if (complain
& tf_warning_or_error
)
12471 if (DECL_NAME (var
) == this_identifier
)
12472 permerror (input_location
, "default argument %qE uses %qD",
12475 error ("default argument %qE uses local variable %qD", arg
, var
);
12477 return error_mark_node
;
12484 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
12487 type_is_deprecated (tree type
)
12489 enum tree_code code
;
12490 if (TREE_DEPRECATED (type
))
12492 if (TYPE_NAME (type
))
12494 if (TREE_DEPRECATED (TYPE_NAME (type
)))
12500 /* Do warn about using typedefs to a deprecated class. */
12501 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
12502 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
12504 code
= TREE_CODE (type
);
12506 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
12507 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
12508 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
12509 return type_is_deprecated (TREE_TYPE (type
));
12511 if (TYPE_PTRMEMFUNC_P (type
))
12512 return type_is_deprecated
12513 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
12518 /* Decode the list of parameter types for a function type.
12519 Given the list of things declared inside the parens,
12520 return a list of types.
12522 If this parameter does not end with an ellipsis, we append
12525 *PARMS is set to the chain of PARM_DECLs created. */
12528 grokparms (tree parmlist
, tree
*parms
)
12530 tree result
= NULL_TREE
;
12531 tree decls
= NULL_TREE
;
12535 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
12537 tree type
= NULL_TREE
;
12538 tree init
= TREE_PURPOSE (parm
);
12539 tree decl
= TREE_VALUE (parm
);
12541 if (parm
== void_list_node
)
12544 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
12547 type
= TREE_TYPE (decl
);
12548 if (VOID_TYPE_P (type
))
12550 if (same_type_p (type
, void_type_node
)
12552 && !DECL_NAME (decl
) && !result
12553 && TREE_CHAIN (parm
) == void_list_node
)
12554 /* DR 577: A parameter list consisting of a single
12555 unnamed parameter of non-dependent type 'void'. */
12557 else if (cv_qualified_p (type
))
12558 error_at (DECL_SOURCE_LOCATION (decl
),
12559 "invalid use of cv-qualified type %qT in "
12560 "parameter declaration", type
);
12562 error_at (DECL_SOURCE_LOCATION (decl
),
12563 "invalid use of type %<void%> in parameter "
12565 /* It's not a good idea to actually create parameters of
12566 type `void'; other parts of the compiler assume that a
12567 void type terminates the parameter list. */
12568 type
= error_mark_node
;
12569 TREE_TYPE (decl
) = error_mark_node
;
12572 if (type
!= error_mark_node
)
12574 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
12576 tree deptype
= type_is_deprecated (type
);
12578 warn_deprecated_use (deptype
, NULL_TREE
);
12581 /* Top-level qualifiers on the parameters are
12582 ignored for function types. */
12583 type
= cp_build_qualified_type (type
, 0);
12584 if (TREE_CODE (type
) == METHOD_TYPE
)
12586 error ("parameter %qD invalidly declared method type", decl
);
12587 type
= build_pointer_type (type
);
12588 TREE_TYPE (decl
) = type
;
12590 else if (abstract_virtuals_error (decl
, type
))
12591 any_error
= 1; /* Seems like a good idea. */
12592 else if (cxx_dialect
< cxx17
&& POINTER_TYPE_P (type
))
12594 /* Before C++17 DR 393:
12595 [dcl.fct]/6, parameter types cannot contain pointers
12596 (references) to arrays of unknown bound. */
12597 tree t
= TREE_TYPE (type
);
12598 int ptr
= TYPE_PTR_P (type
);
12602 if (TYPE_PTR_P (t
))
12604 else if (TREE_CODE (t
) != ARRAY_TYPE
)
12606 else if (!TYPE_DOMAIN (t
))
12610 if (TREE_CODE (t
) == ARRAY_TYPE
)
12611 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
12613 ? G_("parameter %qD includes pointer to array of "
12614 "unknown bound %qT")
12615 : G_("parameter %qD includes reference to array of "
12616 "unknown bound %qT"),
12622 else if (init
&& !processing_template_decl
)
12623 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
12626 DECL_CHAIN (decl
) = decls
;
12628 result
= tree_cons (init
, type
, result
);
12630 decls
= nreverse (decls
);
12631 result
= nreverse (result
);
12633 result
= chainon (result
, void_list_node
);
12640 /* D is a constructor or overloaded `operator='.
12642 Let T be the class in which D is declared. Then, this function
12645 -1 if D's is an ill-formed constructor or copy assignment operator
12646 whose first parameter is of type `T'.
12647 0 if D is not a copy constructor or copy assignment
12649 1 if D is a copy constructor or copy assignment operator whose
12650 first parameter is a reference to non-const qualified T.
12651 2 if D is a copy constructor or copy assignment operator whose
12652 first parameter is a reference to const qualified T.
12654 This function can be used as a predicate. Positive values indicate
12655 a copy constructor and nonzero values indicate a copy assignment
12659 copy_fn_p (const_tree d
)
12665 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
12667 if (TREE_CODE (d
) == TEMPLATE_DECL
12668 || (DECL_TEMPLATE_INFO (d
)
12669 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
12670 /* Instantiations of template member functions are never copy
12671 functions. Note that member functions of templated classes are
12672 represented as template functions internally, and we must
12673 accept those as copy functions. */
12676 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
12680 arg_type
= TREE_VALUE (args
);
12681 if (arg_type
== error_mark_node
)
12684 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
12686 /* Pass by value copy assignment operator. */
12689 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
12690 && !TYPE_REF_IS_RVALUE (arg_type
)
12691 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
12693 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
12699 args
= TREE_CHAIN (args
);
12701 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
12702 /* There are more non-optional args. */
12708 /* D is a constructor or overloaded `operator='.
12710 Let T be the class in which D is declared. Then, this function
12711 returns true when D is a move constructor or move assignment
12712 operator, false otherwise. */
12715 move_fn_p (const_tree d
)
12717 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
12719 if (cxx_dialect
== cxx98
)
12720 /* There are no move constructors if we are in C++98 mode. */
12723 if (TREE_CODE (d
) == TEMPLATE_DECL
12724 || (DECL_TEMPLATE_INFO (d
)
12725 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
12726 /* Instantiations of template member functions are never move
12727 functions. Note that member functions of templated classes are
12728 represented as template functions internally, and we must
12729 accept those as move functions. */
12732 return move_signature_fn_p (d
);
12735 /* D is a constructor or overloaded `operator='.
12737 Then, this function returns true when D has the same signature as a move
12738 constructor or move assignment operator (because either it is such a
12739 ctor/op= or it is a template specialization with the same signature),
12740 false otherwise. */
12743 move_signature_fn_p (const_tree d
)
12747 bool result
= false;
12749 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
12753 arg_type
= TREE_VALUE (args
);
12754 if (arg_type
== error_mark_node
)
12757 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
12758 && TYPE_REF_IS_RVALUE (arg_type
)
12759 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
12763 args
= TREE_CHAIN (args
);
12765 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
12766 /* There are more non-optional args. */
12772 /* Remember any special properties of member function DECL. */
12775 grok_special_member_properties (tree decl
)
12779 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
12782 class_type
= DECL_CONTEXT (decl
);
12783 if (IDENTIFIER_CTOR_P (DECL_NAME (decl
)))
12785 int ctor
= copy_fn_p (decl
);
12787 if (!DECL_ARTIFICIAL (decl
))
12788 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
12794 A non-template constructor for class X is a copy
12795 constructor if its first parameter is of type X&, const
12796 X&, volatile X& or const volatile X&, and either there
12797 are no other parameters or else all other parameters have
12798 default arguments. */
12799 TYPE_HAS_COPY_CTOR (class_type
) = 1;
12800 if (user_provided_p (decl
))
12801 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
12803 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
12805 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
12806 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
12807 else if (move_fn_p (decl
) && user_provided_p (decl
))
12808 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
12809 else if (is_list_ctor (decl
))
12810 TYPE_HAS_LIST_CTOR (class_type
) = 1;
12812 if (DECL_DECLARED_CONSTEXPR_P (decl
)
12813 && !ctor
&& !move_fn_p (decl
))
12814 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
12816 else if (DECL_NAME (decl
) == assign_op_identifier
)
12820 A non-template assignment operator for class X is a copy
12821 assignment operator if its parameter is of type X, X&, const
12822 X&, volatile X& or const volatile X&. */
12824 int assop
= copy_fn_p (decl
);
12828 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
12829 if (user_provided_p (decl
))
12830 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
12832 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
12834 else if (move_fn_p (decl
) && user_provided_p (decl
))
12835 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
12837 else if (IDENTIFIER_CONV_OP_P (DECL_NAME (decl
)))
12838 TYPE_HAS_CONVERSION (class_type
) = true;
12840 /* Destructors are handled in check_methods. */
12843 /* Check a constructor DECL has the correct form. Complains
12844 if the class has a constructor of the form X(X). */
12847 grok_ctor_properties (const_tree ctype
, const_tree decl
)
12849 int ctor_parm
= copy_fn_p (decl
);
12855 A declaration of a constructor for a class X is ill-formed if
12856 its first parameter is of type (optionally cv-qualified) X
12857 and either there are no other parameters or else all other
12858 parameters have default arguments.
12860 We *don't* complain about member template instantiations that
12861 have this form, though; they can occur as we try to decide
12862 what constructor to use during overload resolution. Since
12863 overload resolution will never prefer such a constructor to
12864 the non-template copy constructor (which is either explicitly
12865 or implicitly defined), there's no need to worry about their
12866 existence. Theoretically, they should never even be
12867 instantiated, but that's hard to forestall. */
12868 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
12876 /* DECL is a declaration for an overloaded or conversion operator. If
12877 COMPLAIN is true, errors are issued for invalid declarations. */
12880 grok_op_properties (tree decl
, bool complain
)
12882 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
12883 bool methodp
= TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
;
12884 tree name
= DECL_NAME (decl
);
12886 tree class_type
= DECL_CONTEXT (decl
);
12887 if (class_type
&& !CLASS_TYPE_P (class_type
))
12888 class_type
= NULL_TREE
;
12890 tree_code operator_code
;
12892 if (IDENTIFIER_CONV_OP_P (name
))
12894 /* Conversion operators are TYPE_EXPR for the purposes of this
12896 operator_code
= TYPE_EXPR
;
12897 op_flags
= OVL_OP_FLAG_UNARY
;
12901 const ovl_op_info_t
*ovl_op
= IDENTIFIER_OVL_OP_INFO (name
);
12903 operator_code
= ovl_op
->tree_code
;
12904 op_flags
= ovl_op
->flags
;
12905 gcc_checking_assert (operator_code
!= ERROR_MARK
);
12906 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op
->ovl_op_code
;
12909 if (op_flags
& OVL_OP_FLAG_ALLOC
)
12911 /* operator new and operator delete are quite special. */
12915 case OVL_OP_FLAG_ALLOC
:
12916 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
12919 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_DELETE
:
12920 TYPE_GETS_DELETE (class_type
) |= 1;
12923 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_VEC
:
12924 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
12927 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_DELETE
| OVL_OP_FLAG_VEC
:
12928 TYPE_GETS_DELETE (class_type
) |= 2;
12932 gcc_unreachable ();
12935 /* [basic.std.dynamic.allocation]/1:
12937 A program is ill-formed if an allocation function is declared
12938 in a namespace scope other than global scope or declared
12939 static in global scope.
12941 The same also holds true for deallocation functions. */
12942 if (DECL_NAMESPACE_SCOPE_P (decl
))
12944 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
12946 error ("%qD may not be declared within a namespace", decl
);
12950 if (!TREE_PUBLIC (decl
))
12952 error ("%qD may not be declared as static", decl
);
12957 if (op_flags
& OVL_OP_FLAG_DELETE
)
12958 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
12961 DECL_IS_OPERATOR_NEW (decl
) = 1;
12962 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
12968 /* An operator function must either be a non-static member function
12969 or have at least one parameter of a class, a reference to a class,
12970 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12971 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
12973 if (operator_code
== TYPE_EXPR
12974 || operator_code
== CALL_EXPR
12975 || operator_code
== COMPONENT_REF
12976 || operator_code
== ARRAY_REF
12977 || operator_code
== NOP_EXPR
)
12979 error ("%qD must be a nonstatic member function", decl
);
12983 if (DECL_STATIC_FUNCTION_P (decl
))
12985 error ("%qD must be either a non-static member "
12986 "function or a non-member function", decl
);
12990 for (tree arg
= argtypes
; ; arg
= TREE_CHAIN (arg
))
12992 if (!arg
|| arg
== void_list_node
)
12995 error ("%qD must have an argument of class or "
12996 "enumerated type", decl
);
13000 tree type
= non_reference (TREE_VALUE (arg
));
13001 if (type
== error_mark_node
)
13004 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
13005 because these checks are performed even on template
13007 if (MAYBE_CLASS_TYPE_P (type
)
13008 || TREE_CODE (type
) == ENUMERAL_TYPE
)
13013 if (operator_code
== CALL_EXPR
)
13014 /* There are no further restrictions on the arguments to an overloaded
13018 if (operator_code
== COND_EXPR
)
13021 error ("ISO C++ prohibits overloading operator ?:");
13025 /* Count the number of arguments and check for ellipsis. */
13027 for (tree arg
= argtypes
; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
13032 error ("%qD must not have variable number of arguments", decl
);
13038 /* Verify correct number of arguments. */
13041 case OVL_OP_FLAG_AMBIARY
:
13044 /* We have a unary instance of an ambi-ary op. Remap to the
13046 unsigned alt
= ovl_op_alternate
[ovl_op_mapping
[operator_code
]];
13047 const ovl_op_info_t
*ovl_op
= &ovl_op_info
[false][alt
];
13048 gcc_checking_assert (ovl_op
->flags
== OVL_OP_FLAG_UNARY
);
13049 operator_code
= ovl_op
->tree_code
;
13050 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op
->ovl_op_code
;
13052 else if (arity
!= 2)
13054 /* This was an ambiguous operator but is invalid. */
13056 ? G_("%qD must have either zero or one argument")
13057 : G_("%qD must have either one or two arguments"), decl
);
13060 else if ((operator_code
== POSTINCREMENT_EXPR
13061 || operator_code
== POSTDECREMENT_EXPR
)
13062 && ! processing_template_decl
13063 /* x++ and x--'s second argument must be an int. */
13064 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)),
13065 integer_type_node
))
13068 ? G_("postfix %qD must have %<int%> as its argument")
13069 : G_("postfix %qD must have %<int%> as its second argument"),
13075 case OVL_OP_FLAG_UNARY
:
13079 ? G_("%qD must have no arguments")
13080 : G_("%qD must have exactly one argument"), decl
);
13085 case OVL_OP_FLAG_BINARY
:
13089 ? G_("%qD must have exactly one argument")
13090 : G_("%qD must have exactly two arguments"), decl
);
13096 gcc_unreachable ();
13099 /* There can be no default arguments. */
13100 for (tree arg
= argtypes
; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
13101 if (TREE_PURPOSE (arg
))
13103 TREE_PURPOSE (arg
) = NULL_TREE
;
13104 if (operator_code
== POSTINCREMENT_EXPR
13105 || operator_code
== POSTDECREMENT_EXPR
)
13106 pedwarn (input_location
, OPT_Wpedantic
,
13107 "%qD cannot have default arguments", decl
);
13110 error ("%qD cannot have default arguments", decl
);
13115 /* At this point the declaration is well-formed. It may not be
13116 sensible though. */
13118 /* Check member function warnings only on the in-class declaration.
13119 There's no point warning on an out-of-class definition. */
13120 if (class_type
&& class_type
!= current_class_type
)
13123 /* Warn about conversion operators that will never be used. */
13124 if (IDENTIFIER_CONV_OP_P (name
)
13125 && ! DECL_TEMPLATE_INFO (decl
)
13126 && warn_conversion
)
13128 tree t
= TREE_TYPE (name
);
13129 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
13132 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
13134 if (VOID_TYPE_P (t
))
13135 warning (OPT_Wconversion
,
13137 ? G_("conversion to a reference to void "
13138 "will never use a type conversion operator")
13139 : G_("conversion to void "
13140 "will never use a type conversion operator"));
13141 else if (class_type
)
13143 if (t
== class_type
)
13144 warning (OPT_Wconversion
,
13146 ? G_("conversion to a reference to the same type "
13147 "will never use a type conversion operator")
13148 : G_("conversion to the same type "
13149 "will never use a type conversion operator"));
13150 /* Don't force t to be complete here. */
13151 else if (MAYBE_CLASS_TYPE_P (t
)
13152 && COMPLETE_TYPE_P (t
)
13153 && DERIVED_FROM_P (t
, class_type
))
13154 warning (OPT_Wconversion
,
13156 ? G_("conversion to a reference to a base class "
13157 "will never use a type conversion operator")
13158 : G_("conversion to a base class "
13159 "will never use a type conversion operator"));
13166 /* Effective C++ rules below. */
13168 /* More Effective C++ rule 7. */
13169 if (operator_code
== TRUTH_ANDIF_EXPR
13170 || operator_code
== TRUTH_ORIF_EXPR
13171 || operator_code
== COMPOUND_EXPR
)
13172 warning (OPT_Weffc__
,
13173 "user-defined %qD always evaluates both arguments", decl
);
13175 /* More Effective C++ rule 6. */
13176 if (operator_code
== POSTINCREMENT_EXPR
13177 || operator_code
== POSTDECREMENT_EXPR
13178 || operator_code
== PREINCREMENT_EXPR
13179 || operator_code
== PREDECREMENT_EXPR
)
13181 tree arg
= TREE_VALUE (argtypes
);
13182 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
13183 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
13184 arg
= TREE_TYPE (arg
);
13185 arg
= TYPE_MAIN_VARIANT (arg
);
13187 if (operator_code
== PREINCREMENT_EXPR
13188 || operator_code
== PREDECREMENT_EXPR
)
13190 if (TREE_CODE (ret
) != REFERENCE_TYPE
13191 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)), arg
))
13192 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
13193 build_reference_type (arg
));
13197 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
13198 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
13202 /* Effective C++ rule 23. */
13203 if (!DECL_ASSIGNMENT_OPERATOR_P (decl
)
13204 && (operator_code
== PLUS_EXPR
13205 || operator_code
== MINUS_EXPR
13206 || operator_code
== TRUNC_DIV_EXPR
13207 || operator_code
== MULT_EXPR
13208 || operator_code
== TRUNC_MOD_EXPR
)
13209 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
13210 warning (OPT_Weffc__
, "%qD should return by value", decl
);
13215 /* Return a string giving the keyword associate with CODE. */
13217 static const char *
13218 tag_name (enum tag_types code
)
13230 case typename_type
:
13233 gcc_unreachable ();
13237 /* Name lookup in an elaborated-type-specifier (after the keyword
13238 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
13239 elaborated-type-specifier is invalid, issue a diagnostic and return
13240 error_mark_node; otherwise, return the *_TYPE to which it referred.
13241 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
13244 check_elaborated_type_specifier (enum tag_types tag_code
,
13246 bool allow_template_p
)
13252 struct S { struct S *p; };
13254 name lookup will find the TYPE_DECL for the implicit "S::S"
13255 typedef. Adjust for that here. */
13256 if (DECL_SELF_REFERENCE_P (decl
))
13257 decl
= TYPE_NAME (TREE_TYPE (decl
));
13259 type
= TREE_TYPE (decl
);
13261 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
13262 is false for this case as well. */
13263 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
13265 error ("using template type parameter %qT after %qs",
13266 type
, tag_name (tag_code
));
13267 return error_mark_node
;
13269 /* Accept template template parameters. */
13270 else if (allow_template_p
13271 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
13272 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
13276 If the identifier resolves to a typedef-name or the
13277 simple-template-id resolves to an alias template
13278 specialization, the elaborated-type-specifier is ill-formed.
13280 In other words, the only legitimate declaration to use in the
13281 elaborated type specifier is the implicit typedef created when
13282 the type is declared. */
13283 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
13284 && !DECL_SELF_REFERENCE_P (decl
)
13285 && tag_code
!= typename_type
)
13287 if (alias_template_specialization_p (type
))
13288 error ("using alias template specialization %qT after %qs",
13289 type
, tag_name (tag_code
));
13291 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
13292 inform (DECL_SOURCE_LOCATION (decl
),
13293 "%qD has a previous declaration here", decl
);
13294 return error_mark_node
;
13296 else if (TREE_CODE (type
) != RECORD_TYPE
13297 && TREE_CODE (type
) != UNION_TYPE
13298 && tag_code
!= enum_type
13299 && tag_code
!= typename_type
)
13301 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
13302 inform (location_of (type
), "%qT has a previous declaration here", type
);
13303 return error_mark_node
;
13305 else if (TREE_CODE (type
) != ENUMERAL_TYPE
13306 && tag_code
== enum_type
)
13308 error ("%qT referred to as enum", type
);
13309 inform (location_of (type
), "%qT has a previous declaration here", type
);
13310 return error_mark_node
;
13312 else if (!allow_template_p
13313 && TREE_CODE (type
) == RECORD_TYPE
13314 && CLASSTYPE_IS_TEMPLATE (type
))
13316 /* If a class template appears as elaborated type specifier
13317 without a template header such as:
13319 template <class T> class C {};
13320 void f(class C); // No template header here
13322 then the required template argument is missing. */
13323 error ("template argument required for %<%s %T%>",
13324 tag_name (tag_code
),
13325 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
13326 return error_mark_node
;
13332 /* Lookup NAME in elaborate type specifier in scope according to
13333 SCOPE and issue diagnostics if necessary.
13334 Return *_TYPE node upon success, NULL_TREE when the NAME is not
13335 found, and ERROR_MARK_NODE for type error. */
13338 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
13339 tag_scope scope
, bool template_header_p
)
13343 if (scope
== ts_global
)
13345 /* First try ordinary name lookup, ignoring hidden class name
13346 injected via friend declaration. */
13347 decl
= lookup_name_prefer_type (name
, 2);
13348 decl
= strip_using_decl (decl
);
13349 /* If that fails, the name will be placed in the smallest
13350 non-class, non-function-prototype scope according to 3.3.1/5.
13351 We may already have a hidden name declared as friend in this
13352 scope. So lookup again but not ignoring hidden names.
13353 If we find one, that name will be made visible rather than
13354 creating a new tag. */
13356 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
13359 decl
= lookup_type_scope (name
, scope
);
13362 && (DECL_CLASS_TEMPLATE_P (decl
)
13363 /* If scope is ts_current we're defining a class, so ignore a
13364 template template parameter. */
13365 || (scope
!= ts_current
13366 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
13367 decl
= DECL_TEMPLATE_RESULT (decl
);
13369 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
13371 /* Look for invalid nested type:
13375 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
13377 error ("%qD has the same name as the class in which it is "
13380 return error_mark_node
;
13383 /* Two cases we need to consider when deciding if a class
13384 template is allowed as an elaborated type specifier:
13385 1. It is a self reference to its own class.
13386 2. It comes with a template header.
13390 template <class T> class C {
13391 class C *c1; // DECL_SELF_REFERENCE_P is true
13394 template <class U> class C; // template_header_p is true
13395 template <class T> class C<T>::D {
13396 class C *c2; // DECL_SELF_REFERENCE_P is true
13399 t
= check_elaborated_type_specifier (tag_code
,
13402 | DECL_SELF_REFERENCE_P (decl
));
13403 if (template_header_p
&& t
&& CLASS_TYPE_P (t
)
13404 && (!CLASSTYPE_TEMPLATE_INFO (t
)
13405 || (!PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))))
13407 error ("%qT is not a template", t
);
13408 inform (location_of (t
), "previous declaration here");
13409 if (TYPE_CLASS_SCOPE_P (t
)
13410 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (t
)))
13411 inform (input_location
,
13412 "perhaps you want to explicitly add %<%T::%>",
13414 t
= error_mark_node
;
13419 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
13421 error ("reference to %qD is ambiguous", name
);
13422 print_candidates (decl
);
13423 return error_mark_node
;
13429 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
13430 Define the tag as a forward-reference if it is not defined.
13432 If a declaration is given, process it here, and report an error if
13433 multiple declarations are not identical.
13435 SCOPE is TS_CURRENT when this is also a definition. Only look in
13436 the current frame for the name (since C++ allows new names in any
13437 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
13438 declaration. Only look beginning from the current scope outward up
13439 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
13441 TEMPLATE_HEADER_P is true when this declaration is preceded by
13442 a set of template parameters. */
13445 xref_tag_1 (enum tag_types tag_code
, tree name
,
13446 tag_scope scope
, bool template_header_p
)
13448 enum tree_code code
;
13449 tree context
= NULL_TREE
;
13451 gcc_assert (identifier_p (name
));
13457 code
= RECORD_TYPE
;
13463 code
= ENUMERAL_TYPE
;
13466 gcc_unreachable ();
13469 /* In case of anonymous name, xref_tag is only called to
13470 make type node and push name. Name lookup is not required. */
13471 tree t
= NULL_TREE
;
13472 if (scope
!= ts_lambda
&& !anon_aggrname_p (name
))
13473 t
= lookup_and_check_tag (tag_code
, name
, scope
, template_header_p
);
13475 if (t
== error_mark_node
)
13476 return error_mark_node
;
13478 if (scope
!= ts_current
&& t
&& current_class_type
13479 && template_class_depth (current_class_type
)
13480 && template_header_p
)
13482 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
13485 /* Since SCOPE is not TS_CURRENT, we are not looking at a
13486 definition of this tag. Since, in addition, we are currently
13487 processing a (member) template declaration of a template
13488 class, we must be very careful; consider:
13495 { template <class V>
13496 friend struct S1; };
13498 Here, the S2::S1 declaration should not be confused with the
13499 outer declaration. In particular, the inner version should
13500 have a template parameter of level 2, not level 1. This
13501 would be particularly important if the member declaration
13504 template <class V = U> friend struct S1;
13506 say, when we should tsubst into `U' when instantiating
13507 S2. On the other hand, when presented with:
13517 we must find the inner binding eventually. We
13518 accomplish this by making sure that the new type we
13519 create to represent this declaration has the right
13521 context
= TYPE_CONTEXT (t
);
13527 /* If no such tag is yet defined, create a forward-reference node
13528 and record it as the "definition".
13529 When a real declaration of this type is found,
13530 the forward-reference will be altered into a real type. */
13531 if (code
== ENUMERAL_TYPE
)
13533 error ("use of enum %q#D without previous declaration", name
);
13534 return error_mark_node
;
13538 t
= make_class_type (code
);
13539 TYPE_CONTEXT (t
) = context
;
13540 if (scope
== ts_lambda
)
13541 /* Mark it as a lambda type. */
13542 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
13543 t
= pushtag (name
, t
, scope
);
13548 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
13550 /* Check that we aren't trying to overload a class with different
13552 tree constr
= NULL_TREE
;
13553 if (current_template_parms
)
13555 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
13556 constr
= build_constraints (reqs
, NULL_TREE
);
13558 if (!redeclare_class_template (t
, current_template_parms
, constr
))
13559 return error_mark_node
;
13561 else if (!processing_template_decl
13562 && CLASS_TYPE_P (t
)
13563 && CLASSTYPE_IS_TEMPLATE (t
))
13565 error ("redeclaration of %qT as a non-template", t
);
13566 inform (location_of (t
), "previous declaration %qD", t
);
13567 return error_mark_node
;
13570 /* Make injected friend class visible. */
13571 if (scope
!= ts_within_enclosing_non_class
&& TYPE_HIDDEN_P (t
))
13573 tree decl
= TYPE_NAME (t
);
13575 DECL_ANTICIPATED (decl
) = false;
13576 DECL_FRIEND_P (decl
) = false;
13578 if (TYPE_TEMPLATE_INFO (t
))
13580 tree tmpl
= TYPE_TI_TEMPLATE (t
);
13581 DECL_ANTICIPATED (tmpl
) = false;
13582 DECL_FRIEND_P (tmpl
) = false;
13590 /* Wrapper for xref_tag_1. */
13593 xref_tag (enum tag_types tag_code
, tree name
,
13594 tag_scope scope
, bool template_header_p
)
13598 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
13599 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
13600 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
13606 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
13608 enum tag_types tag_kind
;
13610 if (TREE_CODE (old
) == RECORD_TYPE
)
13611 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
13613 tag_kind
= union_type
;
13615 if (id
== NULL_TREE
)
13616 id
= TYPE_IDENTIFIER (old
);
13618 return xref_tag (tag_kind
, id
, scope
, false);
13621 /* Create the binfo hierarchy for REF with (possibly NULL) base list
13622 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
13623 access_* node, and the TREE_VALUE is the type of the base-class.
13624 Non-NULL TREE_TYPE indicates virtual inheritance. */
13627 xref_basetypes (tree ref
, tree base_list
)
13630 tree binfo
, base_binfo
;
13631 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
13632 unsigned max_bases
= 0; /* Maximum direct bases. */
13633 unsigned max_dvbases
= 0; /* Maximum direct virtual bases. */
13635 tree default_access
;
13636 tree igo_prev
; /* Track Inheritance Graph Order. */
13638 if (ref
== error_mark_node
)
13641 /* The base of a derived class is private by default, all others are
13643 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
13644 && CLASSTYPE_DECLARED_CLASS (ref
)
13645 ? access_private_node
: access_public_node
);
13647 /* First, make sure that any templates in base-classes are
13648 instantiated. This ensures that if we call ourselves recursively
13649 we do not get confused about which classes are marked and which
13651 basep
= &base_list
;
13654 tree basetype
= TREE_VALUE (*basep
);
13656 /* The dependent_type_p call below should really be dependent_scope_p
13657 so that we give a hard error about using an incomplete type as a
13658 base, but we allow it with a pedwarn for backward
13660 if (processing_template_decl
13661 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
13662 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
13663 if (!dependent_type_p (basetype
)
13664 && !complete_type_or_else (basetype
, NULL
))
13665 /* An incomplete type. Remove it from the list. */
13666 *basep
= TREE_CHAIN (*basep
);
13670 if (TREE_TYPE (*basep
))
13672 if (CLASS_TYPE_P (basetype
))
13673 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
13674 basep
= &TREE_CHAIN (*basep
);
13677 max_vbases
+= max_dvbases
;
13679 TYPE_MARKED_P (ref
) = 1;
13681 /* The binfo slot should be empty, unless this is an (ill-formed)
13683 gcc_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
));
13685 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
13687 binfo
= make_tree_binfo (max_bases
);
13689 TYPE_BINFO (ref
) = binfo
;
13690 BINFO_OFFSET (binfo
) = size_zero_node
;
13691 BINFO_TYPE (binfo
) = ref
;
13693 /* Apply base-class info set up to the variants of this type. */
13694 fixup_type_variants (ref
);
13698 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
13699 /* A C++98 POD cannot have base classes. */
13700 CLASSTYPE_NON_LAYOUT_POD_P (ref
) = true;
13702 if (TREE_CODE (ref
) == UNION_TYPE
)
13703 error ("derived union %qT invalid", ref
);
13707 warning (OPT_Wmultiple_inheritance
,
13708 "%qT defined with multiple direct bases", ref
);
13712 /* An aggregate can't have virtual base classes. */
13713 CLASSTYPE_NON_AGGREGATE (ref
) = true;
13715 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
13718 warning (OPT_Wvirtual_inheritance
,
13719 "%qT defined with direct virtual base", ref
);
13722 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
13724 tree access
= TREE_PURPOSE (base_list
);
13725 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
13726 tree basetype
= TREE_VALUE (base_list
);
13728 if (access
== access_default_node
)
13729 access
= default_access
;
13731 /* Before C++17, an aggregate cannot have base classes. In C++17, an
13732 aggregate can't have virtual, private, or protected base classes. */
13733 if (cxx_dialect
< cxx17
13734 || access
!= access_public_node
13736 CLASSTYPE_NON_AGGREGATE (ref
) = true;
13738 if (PACK_EXPANSION_P (basetype
))
13739 basetype
= PACK_EXPANSION_PATTERN (basetype
);
13740 if (TREE_CODE (basetype
) == TYPE_DECL
)
13741 basetype
= TREE_TYPE (basetype
);
13742 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
13744 error ("base type %qT fails to be a struct or class type",
13749 base_binfo
= NULL_TREE
;
13750 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
13752 base_binfo
= TYPE_BINFO (basetype
);
13753 /* The original basetype could have been a typedef'd type. */
13754 basetype
= BINFO_TYPE (base_binfo
);
13756 /* Inherit flags from the base. */
13757 TYPE_HAS_NEW_OPERATOR (ref
)
13758 |= TYPE_HAS_NEW_OPERATOR (basetype
);
13759 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
13760 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
13761 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
13762 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
13763 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
13764 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
13765 CLASSTYPE_REPEATED_BASE_P (ref
)
13766 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
13769 /* We must do this test after we've seen through a typedef
13771 if (TYPE_MARKED_P (basetype
))
13773 if (basetype
== ref
)
13774 error ("recursive type %qT undefined", basetype
);
13776 error ("duplicate base type %qT invalid", basetype
);
13780 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
13781 /* Regenerate the pack expansion for the bases. */
13782 basetype
= make_pack_expansion (basetype
);
13784 TYPE_MARKED_P (basetype
) = 1;
13786 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
13787 &igo_prev
, via_virtual
);
13788 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
13789 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
13791 BINFO_BASE_APPEND (binfo
, base_binfo
);
13792 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
13796 /* Update max_vbases to reflect the reality that we are dropping
13797 this base: if it reaches zero we want to undo the vec_alloc
13798 above to avoid inconsistencies during error-recovery: eg, in
13799 build_special_member_call, CLASSTYPE_VBASECLASSES non null
13800 and vtt null (c++/27952). */
13803 if (CLASS_TYPE_P (basetype
))
13805 -= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
13808 if (CLASSTYPE_VBASECLASSES (ref
)
13809 && max_vbases
== 0)
13810 vec_free (CLASSTYPE_VBASECLASSES (ref
));
13812 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
13813 /* If we didn't get max_vbases vbases, we must have shared at
13814 least one of them, and are therefore diamond shaped. */
13815 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
13817 /* Unmark all the types. */
13818 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
13819 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
13820 TYPE_MARKED_P (ref
) = 0;
13822 /* Now see if we have a repeated base type. */
13823 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
13825 for (base_binfo
= binfo
; base_binfo
;
13826 base_binfo
= TREE_CHAIN (base_binfo
))
13828 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
13830 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
13833 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
13835 for (base_binfo
= binfo
; base_binfo
;
13836 base_binfo
= TREE_CHAIN (base_binfo
))
13837 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
13838 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
13845 /* Copies the enum-related properties from type SRC to type DST.
13846 Used with the underlying type of an enum and the enum itself. */
13848 copy_type_enum (tree dst
, tree src
)
13851 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
13853 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
13854 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
13855 TYPE_SIZE (t
) = TYPE_SIZE (src
);
13856 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
13857 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
13858 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
13859 unsigned valign
= TYPE_ALIGN (src
);
13860 if (TYPE_USER_ALIGN (t
))
13861 valign
= MAX (valign
, TYPE_ALIGN (t
));
13863 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
13864 SET_TYPE_ALIGN (t
, valign
);
13865 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
13869 /* Begin compiling the definition of an enumeration type.
13872 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
13874 UNDERLYING_TYPE is the type that will be used as the storage for
13875 the enumeration type. This should be NULL_TREE if no storage type
13878 ATTRIBUTES are any attributes specified after the enum-key.
13880 SCOPED_ENUM_P is true if this is a scoped enumeration type.
13882 if IS_NEW is not NULL, gets TRUE iff a new type is created.
13884 Returns the type object, as yet incomplete.
13885 Also records info about it so that build_enumerator
13886 may be used to declare the individual values as they are read. */
13889 start_enum (tree name
, tree enumtype
, tree underlying_type
,
13890 tree attributes
, bool scoped_enum_p
, bool *is_new
)
13892 tree prevtype
= NULL_TREE
;
13893 gcc_assert (identifier_p (name
));
13897 /* [C++0x dcl.enum]p5:
13899 If not explicitly specified, the underlying type of a scoped
13900 enumeration type is int. */
13901 if (!underlying_type
&& scoped_enum_p
)
13902 underlying_type
= integer_type_node
;
13904 if (underlying_type
)
13905 underlying_type
= cv_unqualified (underlying_type
);
13907 /* If this is the real definition for a previous forward reference,
13908 fill in the contents in the same object that used to be the
13909 forward reference. */
13911 enumtype
= lookup_and_check_tag (enum_type
, name
,
13912 /*tag_scope=*/ts_current
,
13913 /*template_header_p=*/false);
13915 /* In case of a template_decl, the only check that should be deferred
13916 to instantiation time is the comparison of underlying types. */
13917 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
13919 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
13921 error_at (input_location
, "scoped/unscoped mismatch "
13922 "in enum %q#T", enumtype
);
13923 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13924 "previous definition here");
13925 enumtype
= error_mark_node
;
13927 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
13929 error_at (input_location
, "underlying type mismatch "
13930 "in enum %q#T", enumtype
);
13931 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13932 "previous definition here");
13933 enumtype
= error_mark_node
;
13935 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
13936 && !dependent_type_p (underlying_type
)
13937 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
13938 && !same_type_p (underlying_type
,
13939 ENUM_UNDERLYING_TYPE (enumtype
)))
13941 error_at (input_location
, "different underlying type "
13942 "in enum %q#T", enumtype
);
13943 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13944 "previous definition here");
13945 underlying_type
= NULL_TREE
;
13949 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
13950 || processing_template_decl
)
13952 /* In case of error, make a dummy enum to allow parsing to
13954 if (enumtype
== error_mark_node
)
13956 name
= make_anon_name ();
13957 enumtype
= NULL_TREE
;
13960 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
13961 of an opaque enum, or an opaque enum of an already defined
13962 enumeration (C++0x only).
13963 In any other case, it'll be NULL_TREE. */
13969 prevtype
= enumtype
;
13971 /* Do not push the decl more than once, unless we need to
13972 compare underlying types at instantiation time */
13974 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
13975 || (underlying_type
13976 && dependent_type_p (underlying_type
))
13977 || (ENUM_UNDERLYING_TYPE (enumtype
)
13978 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
13980 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
13981 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
13983 /* std::byte aliases anything. */
13984 if (enumtype
!= error_mark_node
13985 && TYPE_CONTEXT (enumtype
) == std_node
13986 && !strcmp ("byte", TYPE_NAME_STRING (enumtype
)))
13987 TYPE_ALIAS_SET (enumtype
) = 0;
13990 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
13993 if (enumtype
== error_mark_node
)
13994 return error_mark_node
;
13996 /* The enum is considered opaque until the opening '{' of the
13997 enumerator list. */
13998 SET_OPAQUE_ENUM_P (enumtype
, true);
13999 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
14002 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
14004 cplus_decl_attributes (&enumtype
, attributes
, (int)ATTR_FLAG_TYPE_IN_PLACE
);
14006 if (underlying_type
)
14008 if (ENUM_UNDERLYING_TYPE (enumtype
))
14009 /* We already checked that it matches, don't change it to a different
14010 typedef variant. */;
14011 else if (CP_INTEGRAL_TYPE_P (underlying_type
))
14013 copy_type_enum (enumtype
, underlying_type
);
14014 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
14016 else if (dependent_type_p (underlying_type
))
14017 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
14019 error ("underlying type %qT of %qT must be an integral type",
14020 underlying_type
, enumtype
);
14023 /* If into a template class, the returned enum is always the first
14024 declaration (opaque or not) seen. This way all the references to
14025 this type will be to the same declaration. The following ones are used
14026 only to check for definition errors. */
14027 if (prevtype
&& processing_template_decl
)
14033 /* After processing and defining all the values of an enumeration type,
14034 install their decls in the enumeration type.
14035 ENUMTYPE is the type object. */
14038 finish_enum_value_list (tree enumtype
)
14041 tree underlying_type
;
14044 tree minnode
, maxnode
;
14047 bool fixed_underlying_type_p
14048 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
14050 /* We built up the VALUES in reverse order. */
14051 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
14053 /* For an enum defined in a template, just set the type of the values;
14054 all further processing is postponed until the template is
14055 instantiated. We need to set the type so that tsubst of a CONST_DECL
14057 if (processing_template_decl
)
14059 for (values
= TYPE_VALUES (enumtype
);
14061 values
= TREE_CHAIN (values
))
14062 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
14066 /* Determine the minimum and maximum values of the enumerators. */
14067 if (TYPE_VALUES (enumtype
))
14069 minnode
= maxnode
= NULL_TREE
;
14071 for (values
= TYPE_VALUES (enumtype
);
14073 values
= TREE_CHAIN (values
))
14075 decl
= TREE_VALUE (values
);
14077 /* [dcl.enum]: Following the closing brace of an enum-specifier,
14078 each enumerator has the type of its enumeration. Prior to the
14079 closing brace, the type of each enumerator is the type of its
14080 initializing value. */
14081 TREE_TYPE (decl
) = enumtype
;
14083 /* Update the minimum and maximum values, if appropriate. */
14084 value
= DECL_INITIAL (decl
);
14085 if (value
== error_mark_node
)
14086 value
= integer_zero_node
;
14087 /* Figure out what the minimum and maximum values of the
14088 enumerators are. */
14090 minnode
= maxnode
= value
;
14091 else if (tree_int_cst_lt (maxnode
, value
))
14093 else if (tree_int_cst_lt (value
, minnode
))
14100 If the enumerator-list is empty, the underlying type is as if
14101 the enumeration had a single enumerator with value 0. */
14102 minnode
= maxnode
= integer_zero_node
;
14104 if (!fixed_underlying_type_p
)
14106 /* Compute the number of bits require to represent all values of the
14107 enumeration. We must do this before the type of MINNODE and
14108 MAXNODE are transformed, since tree_int_cst_min_precision relies
14109 on the TREE_TYPE of the value it is passed. */
14110 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
14111 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
14112 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
14113 int precision
= MAX (lowprec
, highprec
);
14115 bool use_short_enum
;
14117 /* Determine the underlying type of the enumeration.
14121 The underlying type of an enumeration is an integral type that
14122 can represent all the enumerator values defined in the
14123 enumeration. It is implementation-defined which integral type is
14124 used as the underlying type for an enumeration except that the
14125 underlying type shall not be larger than int unless the value of
14126 an enumerator cannot fit in an int or unsigned int.
14128 We use "int" or an "unsigned int" as the underlying type, even if
14129 a smaller integral type would work, unless the user has
14130 explicitly requested that we use the smallest possible type. The
14131 user can request that for all enumerations with a command line
14132 flag, or for just one enumeration with an attribute. */
14134 use_short_enum
= flag_short_enums
14135 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
14137 /* If the precision of the type was specified with an attribute and it
14138 was too small, give an error. Otherwise, use it. */
14139 if (TYPE_PRECISION (enumtype
))
14141 if (precision
> TYPE_PRECISION (enumtype
))
14142 error ("specified mode too small for enumeral values");
14145 use_short_enum
= true;
14146 precision
= TYPE_PRECISION (enumtype
);
14150 for (itk
= (use_short_enum
? itk_char
: itk_int
);
14154 underlying_type
= integer_types
[itk
];
14155 if (underlying_type
!= NULL_TREE
14156 && TYPE_PRECISION (underlying_type
) >= precision
14157 && TYPE_SIGN (underlying_type
) == sgn
)
14160 if (itk
== itk_none
)
14164 IF no integral type can represent all the enumerator values, the
14165 enumeration is ill-formed. */
14166 error ("no integral type can represent all of the enumerator values "
14167 "for %qT", enumtype
);
14168 precision
= TYPE_PRECISION (long_long_integer_type_node
);
14169 underlying_type
= integer_types
[itk_unsigned_long_long
];
14174 The value of sizeof() applied to an enumeration type, an object
14175 of an enumeration type, or an enumerator, is the value of sizeof()
14176 applied to the underlying type. */
14177 copy_type_enum (enumtype
, underlying_type
);
14179 /* Compute the minimum and maximum values for the type.
14183 For an enumeration where emin is the smallest enumerator and emax
14184 is the largest, the values of the enumeration are the values of the
14185 underlying type in the range bmin to bmax, where bmin and bmax are,
14186 respectively, the smallest and largest values of the smallest bit-
14187 field that can store emin and emax. */
14189 /* The middle-end currently assumes that types with TYPE_PRECISION
14190 narrower than their underlying type are suitably zero or sign
14191 extended to fill their mode. Similarly, it assumes that the front
14192 end assures that a value of a particular type must be within
14193 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
14195 We used to set these fields based on bmin and bmax, but that led
14196 to invalid assumptions like optimizing away bounds checking. So
14197 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
14198 TYPE_MAX_VALUE to the values for the mode above and only restrict
14199 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
14200 ENUM_UNDERLYING_TYPE (enumtype
)
14201 = build_distinct_type_copy (underlying_type
);
14202 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
14203 set_min_and_max_values_for_integral_type
14204 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
14206 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
14207 if (flag_strict_enums
)
14208 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
14211 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
14213 /* Convert each of the enumerators to the type of the underlying
14214 type of the enumeration. */
14215 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
14217 location_t saved_location
;
14219 decl
= TREE_VALUE (values
);
14220 saved_location
= input_location
;
14221 input_location
= DECL_SOURCE_LOCATION (decl
);
14222 if (fixed_underlying_type_p
)
14223 /* If the enumeration type has a fixed underlying type, we
14224 already checked all of the enumerator values. */
14225 value
= DECL_INITIAL (decl
);
14227 value
= perform_implicit_conversion (underlying_type
,
14228 DECL_INITIAL (decl
),
14229 tf_warning_or_error
);
14230 input_location
= saved_location
;
14232 /* Do not clobber shared ints. */
14233 if (value
!= error_mark_node
)
14235 value
= copy_node (value
);
14237 TREE_TYPE (value
) = enumtype
;
14239 DECL_INITIAL (decl
) = value
;
14242 /* Fix up all variant types of this enum type. */
14243 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
14244 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
14246 if (at_class_scope_p ()
14247 && COMPLETE_TYPE_P (current_class_type
)
14248 && UNSCOPED_ENUM_P (enumtype
))
14250 insert_late_enum_def_bindings (current_class_type
, enumtype
);
14251 /* TYPE_FIELDS needs fixup. */
14252 fixup_type_variants (current_class_type
);
14255 /* Finish debugging output for this type. */
14256 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
14258 /* Each enumerator now has the type of its enumeration. Clear the cache
14259 so that this change in types doesn't confuse us later on. */
14260 clear_cv_and_fold_caches ();
14263 /* Finishes the enum type. This is called only the first time an
14264 enumeration is seen, be it opaque or odinary.
14265 ENUMTYPE is the type object. */
14268 finish_enum (tree enumtype
)
14270 if (processing_template_decl
)
14272 if (at_function_scope_p ())
14273 add_stmt (build_min (TAG_DEFN
, enumtype
));
14277 /* If this is a forward declaration, there should not be any variants,
14278 though we can get a variant in the middle of an enum-specifier with
14279 wacky code like 'enum E { e = sizeof(const E*) };' */
14280 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
14281 && (TYPE_VALUES (enumtype
)
14282 || !TYPE_NEXT_VARIANT (enumtype
)));
14285 /* Build and install a CONST_DECL for an enumeration constant of the
14286 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
14287 Apply ATTRIBUTES if available. LOC is the location of NAME.
14288 Assignment of sequential values by default is handled here. */
14291 build_enumerator (tree name
, tree value
, tree enumtype
, tree attributes
,
14298 /* scalar_constant_value will pull out this expression, so make sure
14299 it's folded as appropriate. */
14300 if (processing_template_decl
)
14301 value
= fold_non_dependent_expr (value
);
14303 /* If the VALUE was erroneous, pretend it wasn't there; that will
14304 result in the enum being assigned the next value in sequence. */
14305 if (value
== error_mark_node
)
14308 /* Remove no-op casts from the value. */
14310 STRIP_TYPE_NOPS (value
);
14312 if (! processing_template_decl
)
14314 /* Validate and default VALUE. */
14315 if (value
!= NULL_TREE
)
14317 if (!ENUM_UNDERLYING_TYPE (enumtype
))
14319 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
14324 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14325 (TREE_TYPE (value
)))
14326 value
= perform_implicit_conversion_flags
14327 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
14328 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
14330 if (value
== error_mark_node
)
14333 if (value
!= NULL_TREE
)
14335 if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14336 (TREE_TYPE (value
)))
14338 error ("enumerator value for %qD must have integral or "
14339 "unscoped enumeration type", name
);
14344 value
= cxx_constant_value (value
);
14346 if (TREE_CODE (value
) != INTEGER_CST
)
14348 error ("enumerator value for %qD is not an integer "
14356 /* Default based on previous value. */
14357 if (value
== NULL_TREE
)
14359 if (TYPE_VALUES (enumtype
))
14364 /* C++03 7.2/4: If no initializer is specified for the first
14365 enumerator, the type is an unspecified integral
14366 type. Otherwise the type is the same as the type of the
14367 initializing value of the preceding enumerator unless the
14368 incremented value is not representable in that type, in
14369 which case the type is an unspecified integral type
14370 sufficient to contain the incremented value. */
14371 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
14372 if (error_operand_p (prev_value
))
14373 value
= error_mark_node
;
14376 tree type
= TREE_TYPE (prev_value
);
14377 signop sgn
= TYPE_SIGN (type
);
14378 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
14382 bool pos
= !wi::neg_p (wi
, sgn
);
14383 if (!wi::fits_to_tree_p (wi
, type
))
14386 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
14388 type
= integer_types
[itk
];
14389 if (type
!= NULL_TREE
14390 && (pos
|| !TYPE_UNSIGNED (type
))
14391 && wi::fits_to_tree_p (wi
, type
))
14394 if (type
&& cxx_dialect
< cxx11
14395 && itk
> itk_unsigned_long
)
14396 pedwarn (input_location
, OPT_Wlong_long
,
14398 incremented enumerator value is too large for %<unsigned long%>") : G_("\
14399 incremented enumerator value is too large for %<long%>"));
14401 if (type
== NULL_TREE
)
14404 value
= wide_int_to_tree (type
, wi
);
14409 error ("overflow in enumeration values at %qD", name
);
14410 value
= error_mark_node
;
14415 value
= integer_zero_node
;
14418 /* Remove no-op casts from the value. */
14419 STRIP_TYPE_NOPS (value
);
14421 /* If the underlying type of the enum is fixed, check whether
14422 the enumerator values fits in the underlying type. If it
14423 does not fit, the program is ill-formed [C++0x dcl.enum]. */
14424 if (ENUM_UNDERLYING_TYPE (enumtype
)
14426 && TREE_CODE (value
) == INTEGER_CST
)
14428 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
14429 error ("enumerator value %qE is outside the range of underlying "
14430 "type %qT", value
, ENUM_UNDERLYING_TYPE (enumtype
));
14432 /* Convert the value to the appropriate type. */
14433 value
= fold_convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
14437 /* C++ associates enums with global, function, or class declarations. */
14438 context
= current_scope ();
14440 /* Build the actual enumeration constant. Note that the enumeration
14441 constants have the underlying type of the enum (if it is fixed)
14442 or the type of their initializer (if the underlying type of the
14443 enum is not fixed):
14447 If the underlying type is fixed, the type of each enumerator
14448 prior to the closing brace is the underlying type; if the
14449 initializing value of an enumerator cannot be represented by
14450 the underlying type, the program is ill-formed. If the
14451 underlying type is not fixed, the type of each enumerator is
14452 the type of its initializing value.
14454 If the underlying type is not fixed, it will be computed by
14455 finish_enum and we will reset the type of this enumerator. Of
14456 course, if we're processing a template, there may be no value. */
14457 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
14459 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
14461 DECL_CONTEXT (decl
) = enumtype
;
14462 TREE_CONSTANT (decl
) = 1;
14463 TREE_READONLY (decl
) = 1;
14464 DECL_INITIAL (decl
) = value
;
14467 cplus_decl_attributes (&decl
, attributes
, 0);
14469 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
14471 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
14472 on the TYPE_FIELDS list for `S'. (That's so that you can say
14473 things like `S::i' later.) */
14475 /* The enumerator may be getting declared outside of its enclosing
14478 class S { public: enum E : int; }; enum S::E : int { i = 7; };
14480 For which case we need to make sure that the access of `S::i'
14481 matches the access of `S::E'. */
14482 tree saved_cas
= current_access_specifier
;
14483 if (TREE_PRIVATE (TYPE_NAME (enumtype
)))
14484 current_access_specifier
= access_private_node
;
14485 else if (TREE_PROTECTED (TYPE_NAME (enumtype
)))
14486 current_access_specifier
= access_protected_node
;
14488 current_access_specifier
= access_public_node
;
14490 finish_member_declaration (decl
);
14492 current_access_specifier
= saved_cas
;
14497 /* Add this enumeration constant to the list for this type. */
14498 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
14501 /* Look for an enumerator with the given NAME within the enumeration
14502 type ENUMTYPE. This routine is used primarily for qualified name
14503 lookup into an enumerator in C++0x, e.g.,
14505 enum class Color { Red, Green, Blue };
14507 Color color = Color::Red;
14509 Returns the value corresponding to the enumerator, or
14510 NULL_TREE if no such enumerator was found. */
14512 lookup_enumerator (tree enumtype
, tree name
)
14515 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
14517 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
14518 return e
? TREE_VALUE (e
) : NULL_TREE
;
14522 /* We're defining DECL. Make sure that its type is OK. */
14525 check_function_type (tree decl
, tree current_function_parms
)
14527 tree fntype
= TREE_TYPE (decl
);
14528 tree return_type
= complete_type (TREE_TYPE (fntype
));
14530 /* In a function definition, arg types must be complete. */
14531 require_complete_types_for_parms (current_function_parms
);
14533 if (dependent_type_p (return_type
)
14534 || type_uses_auto (return_type
))
14536 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
14538 tree args
= TYPE_ARG_TYPES (fntype
);
14540 error ("return type %q#T is incomplete", return_type
);
14542 /* Make it return void instead. */
14543 if (TREE_CODE (fntype
) == METHOD_TYPE
)
14544 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
14546 TREE_CHAIN (args
));
14548 fntype
= build_function_type (void_type_node
, args
);
14550 = build_exception_variant (fntype
,
14551 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
14552 fntype
= (cp_build_type_attribute_variant
14553 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
14554 TREE_TYPE (decl
) = fntype
;
14558 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
14559 maybe_warn_parm_abi (TREE_TYPE (fntype
),
14560 DECL_SOURCE_LOCATION (decl
));
14564 /* True iff FN is an implicitly-defined default constructor. */
14567 implicit_default_ctor_p (tree fn
)
14569 return (DECL_CONSTRUCTOR_P (fn
)
14570 && !user_provided_p (fn
)
14571 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)));
14574 /* Clobber the contents of *this to let the back end know that the object
14575 storage is dead when we enter the constructor or leave the destructor. */
14578 build_clobber_this ()
14580 /* Clobbering an empty base is pointless, and harmful if its one byte
14581 TYPE_SIZE overlays real data. */
14582 if (is_empty_class (current_class_type
))
14585 /* If we have virtual bases, clobber the whole object, but only if we're in
14586 charge. If we don't have virtual bases, clobber the as-base type so we
14587 don't mess with tail padding. */
14588 bool vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
14590 tree ctype
= current_class_type
;
14592 ctype
= CLASSTYPE_AS_BASE (ctype
);
14594 tree clobber
= build_constructor (ctype
, NULL
);
14595 TREE_THIS_VOLATILE (clobber
) = true;
14597 tree thisref
= current_class_ref
;
14598 if (ctype
!= current_class_type
)
14600 thisref
= build_nop (build_reference_type (ctype
), current_class_ptr
);
14601 thisref
= convert_from_reference (thisref
);
14604 tree exprstmt
= build2 (MODIFY_EXPR
, void_type_node
, thisref
, clobber
);
14606 exprstmt
= build_if_in_charge (exprstmt
);
14611 /* Create the FUNCTION_DECL for a function definition.
14612 DECLSPECS and DECLARATOR are the parts of the declaration;
14613 they describe the function's name and the type it returns,
14614 but twisted together in a fashion that parallels the syntax of C.
14616 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
14617 DECLARATOR is really the DECL for the function we are about to
14618 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
14619 indicating that the function is an inline defined in-class.
14621 This function creates a binding context for the function body
14622 as well as setting up the FUNCTION_DECL in current_function_decl.
14624 For C++, we must first check whether that datum makes any sense.
14625 For example, "class A local_a(1,2);" means that variable local_a
14626 is an aggregate of type A, which should have a constructor
14627 applied to it with the argument list [1, 2].
14629 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
14630 or may be a BLOCK if the function has been defined previously
14631 in this translation unit. On exit, DECL_INITIAL (decl1) will be
14632 error_mark_node if the function has never been defined, or
14633 a BLOCK if the function has been defined somewhere. */
14636 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
14638 tree ctype
= NULL_TREE
;
14641 int doing_friend
= 0;
14642 cp_binding_level
*bl
;
14643 tree current_function_parms
;
14644 struct c_fileinfo
*finfo
14645 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
14646 bool honor_interface
;
14648 /* Sanity check. */
14649 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
14650 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
14652 fntype
= TREE_TYPE (decl1
);
14653 if (TREE_CODE (fntype
) == METHOD_TYPE
)
14654 ctype
= TYPE_METHOD_BASETYPE (fntype
);
14656 /* ISO C++ 11.4/5. A friend function defined in a class is in
14657 the (lexical) scope of the class in which it is defined. */
14658 if (!ctype
&& DECL_FRIEND_P (decl1
))
14660 ctype
= DECL_FRIEND_CONTEXT (decl1
);
14662 /* CTYPE could be null here if we're dealing with a template;
14663 for example, `inline friend float foo()' inside a template
14664 will have no CTYPE set. */
14665 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
14671 if (DECL_DECLARED_INLINE_P (decl1
)
14672 && lookup_attribute ("noinline", attrs
))
14673 warning_at (DECL_SOURCE_LOCATION (decl1
), 0,
14674 "inline function %qD given attribute noinline", decl1
);
14676 /* Handle gnu_inline attribute. */
14677 if (GNU_INLINE_P (decl1
))
14679 DECL_EXTERNAL (decl1
) = 1;
14680 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
14681 DECL_INTERFACE_KNOWN (decl1
) = 1;
14682 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
14685 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
14686 /* This is a constructor, we must ensure that any default args
14687 introduced by this definition are propagated to the clones
14688 now. The clones are used directly in overload resolution. */
14689 adjust_clone_args (decl1
);
14691 /* Sometimes we don't notice that a function is a static member, and
14692 build a METHOD_TYPE for it. Fix that up now. */
14693 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
14694 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
14696 /* Set up current_class_type, and enter the scope of the class, if
14699 push_nested_class (ctype
);
14700 else if (DECL_STATIC_FUNCTION_P (decl1
))
14701 push_nested_class (DECL_CONTEXT (decl1
));
14703 /* Now that we have entered the scope of the class, we must restore
14704 the bindings for any template parameters surrounding DECL1, if it
14705 is an inline member template. (Order is important; consider the
14706 case where a template parameter has the same name as a field of
14707 the class.) It is not until after this point that
14708 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
14709 if (flags
& SF_INCLASS_INLINE
)
14710 maybe_begin_member_template_processing (decl1
);
14712 /* Effective C++ rule 15. */
14714 && DECL_ASSIGNMENT_OPERATOR_P (decl1
)
14715 && DECL_OVERLOADED_OPERATOR_IS (decl1
, NOP_EXPR
)
14716 && VOID_TYPE_P (TREE_TYPE (fntype
)))
14717 warning (OPT_Weffc__
,
14718 "%<operator=%> should return a reference to %<*this%>");
14720 /* Make the init_value nonzero so pushdecl knows this is not tentative.
14721 error_mark_node is replaced below (in poplevel) with the BLOCK. */
14722 if (!DECL_INITIAL (decl1
))
14723 DECL_INITIAL (decl1
) = error_mark_node
;
14725 /* This function exists in static storage.
14726 (This does not mean `static' in the C sense!) */
14727 TREE_STATIC (decl1
) = 1;
14729 /* We must call push_template_decl after current_class_type is set
14730 up. (If we are processing inline definitions after exiting a
14731 class scope, current_class_type will be NULL_TREE until set above
14732 by push_nested_class.) */
14733 if (processing_template_decl
)
14735 tree newdecl1
= push_template_decl (decl1
);
14736 if (newdecl1
== error_mark_node
)
14738 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
14739 pop_nested_class ();
14745 /* Make sure the parameter and return types are reasonable. When
14746 you declare a function, these types can be incomplete, but they
14747 must be complete when you define the function. */
14748 check_function_type (decl1
, DECL_ARGUMENTS (decl1
));
14750 /* Build the return declaration for the function. */
14751 restype
= TREE_TYPE (fntype
);
14753 if (DECL_RESULT (decl1
) == NULL_TREE
)
14757 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
14758 DECL_ARTIFICIAL (resdecl
) = 1;
14759 DECL_IGNORED_P (resdecl
) = 1;
14760 DECL_RESULT (decl1
) = resdecl
;
14762 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
14765 /* Record the decl so that the function name is defined.
14766 If we already have a decl for this name, and it is a FUNCTION_DECL,
14767 use the old decl. */
14768 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
14770 /* A specialization is not used to guide overload resolution. */
14771 if (!DECL_FUNCTION_MEMBER_P (decl1
)
14772 && !(DECL_USE_TEMPLATE (decl1
) &&
14773 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
14775 tree olddecl
= pushdecl (decl1
);
14777 if (olddecl
== error_mark_node
)
14778 /* If something went wrong when registering the declaration,
14779 use DECL1; we have to have a FUNCTION_DECL to use when
14780 parsing the body of the function. */
14784 /* Otherwise, OLDDECL is either a previous declaration
14785 of the same function or DECL1 itself. */
14787 if (warn_missing_declarations
14788 && olddecl
== decl1
14789 && !DECL_MAIN_P (decl1
)
14790 && TREE_PUBLIC (decl1
)
14791 && !DECL_DECLARED_INLINE_P (decl1
))
14795 /* Check whether DECL1 is in an anonymous
14797 for (context
= DECL_CONTEXT (decl1
);
14799 context
= DECL_CONTEXT (context
))
14801 if (TREE_CODE (context
) == NAMESPACE_DECL
14802 && DECL_NAME (context
) == NULL_TREE
)
14806 if (context
== NULL
)
14807 warning_at (DECL_SOURCE_LOCATION (decl1
),
14808 OPT_Wmissing_declarations
,
14809 "no previous declaration for %qD", decl1
);
14817 /* We need to set the DECL_CONTEXT. */
14818 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
14819 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
14821 fntype
= TREE_TYPE (decl1
);
14822 restype
= TREE_TYPE (fntype
);
14824 /* If #pragma weak applies, mark the decl appropriately now.
14825 The pragma only applies to global functions. Because
14826 determining whether or not the #pragma applies involves
14827 computing the mangled name for the declaration, we cannot
14828 apply the pragma until after we have merged this declaration
14829 with any previous declarations; if the original declaration
14830 has a linkage specification, that specification applies to
14831 the definition as well, and may affect the mangled name. */
14832 if (DECL_FILE_SCOPE_P (decl1
))
14833 maybe_apply_pragma_weak (decl1
);
14836 /* We are now in the scope of the function being defined. */
14837 current_function_decl
= decl1
;
14839 /* Save the parm names or decls from this function's declarator
14840 where store_parm_decls will find them. */
14841 current_function_parms
= DECL_ARGUMENTS (decl1
);
14843 /* Let the user know we're compiling this function. */
14844 announce_function (decl1
);
14846 gcc_assert (DECL_INITIAL (decl1
));
14848 /* This function may already have been parsed, in which case just
14849 return; our caller will skip over the body without parsing. */
14850 if (DECL_INITIAL (decl1
) != error_mark_node
)
14853 /* Initialize RTL machinery. We cannot do this until
14854 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
14855 even when processing a template; this is how we get
14856 CFUN set up, and our per-function variables initialized.
14857 FIXME factor out the non-RTL stuff. */
14858 bl
= current_binding_level
;
14859 allocate_struct_function (decl1
, processing_template_decl
);
14861 /* Initialize the language data structures. Whenever we start
14862 a new function, we destroy temporaries in the usual way. */
14863 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
14864 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
14865 current_binding_level
= bl
;
14867 if (!processing_template_decl
&& type_uses_auto (restype
))
14869 FNDECL_USED_AUTO (decl1
) = true;
14870 current_function_auto_return_pattern
= restype
;
14873 /* Start the statement-tree, start the tree now. */
14874 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
14876 /* If we are (erroneously) defining a function that we have already
14877 defined before, wipe out what we knew before. */
14878 if (!DECL_PENDING_INLINE_P (decl1
))
14879 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
14881 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
14883 /* We know that this was set up by `grokclassfn'. We do not
14884 wait until `store_parm_decls', since evil parse errors may
14885 never get us to that point. Here we keep the consistency
14886 between `current_class_type' and `current_class_ptr'. */
14887 tree t
= DECL_ARGUMENTS (decl1
);
14889 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
14890 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
14892 cp_function_chain
->x_current_class_ref
14893 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
14894 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
14895 cp_function_chain
->x_current_class_ptr
= t
;
14897 /* Constructors and destructors need to know whether they're "in
14898 charge" of initializing virtual base classes. */
14899 t
= DECL_CHAIN (t
);
14900 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
14902 current_in_charge_parm
= t
;
14903 t
= DECL_CHAIN (t
);
14905 if (DECL_HAS_VTT_PARM_P (decl1
))
14907 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
14908 current_vtt_parm
= t
;
14912 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
14913 /* Implicitly-defined methods (like the
14914 destructor for a class in which no destructor
14915 is explicitly declared) must not be defined
14916 until their definition is needed. So, we
14917 ignore interface specifications for
14918 compiler-generated functions. */
14919 && !DECL_ARTIFICIAL (decl1
));
14921 if (processing_template_decl
)
14922 /* Don't mess with interface flags. */;
14923 else if (DECL_INTERFACE_KNOWN (decl1
))
14925 tree ctx
= decl_function_context (decl1
);
14927 if (DECL_NOT_REALLY_EXTERN (decl1
))
14928 DECL_EXTERNAL (decl1
) = 0;
14930 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
14931 /* This is a function in a local class in an extern inline
14932 or template function. */
14933 comdat_linkage (decl1
);
14935 /* If this function belongs to an interface, it is public.
14936 If it belongs to someone else's interface, it is also external.
14937 This only affects inlines and template instantiations. */
14938 else if (!finfo
->interface_unknown
&& honor_interface
)
14940 if (DECL_DECLARED_INLINE_P (decl1
)
14941 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14943 DECL_EXTERNAL (decl1
)
14944 = (finfo
->interface_only
14945 || (DECL_DECLARED_INLINE_P (decl1
)
14946 && ! flag_implement_inlines
14947 && !DECL_VINDEX (decl1
)));
14949 /* For WIN32 we also want to put these in linkonce sections. */
14950 maybe_make_one_only (decl1
);
14953 DECL_EXTERNAL (decl1
) = 0;
14954 DECL_INTERFACE_KNOWN (decl1
) = 1;
14955 /* If this function is in an interface implemented in this file,
14956 make sure that the back end knows to emit this function
14958 if (!DECL_EXTERNAL (decl1
))
14959 mark_needed (decl1
);
14961 else if (finfo
->interface_unknown
&& finfo
->interface_only
14962 && honor_interface
)
14964 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
14965 interface, we will have both finfo->interface_unknown and
14966 finfo->interface_only set. In that case, we don't want to
14967 use the normal heuristics because someone will supply a
14968 #pragma implementation elsewhere, and deducing it here would
14969 produce a conflict. */
14970 comdat_linkage (decl1
);
14971 DECL_EXTERNAL (decl1
) = 0;
14972 DECL_INTERFACE_KNOWN (decl1
) = 1;
14973 DECL_DEFER_OUTPUT (decl1
) = 1;
14977 /* This is a definition, not a reference.
14978 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
14979 if (!GNU_INLINE_P (decl1
))
14980 DECL_EXTERNAL (decl1
) = 0;
14982 if ((DECL_DECLARED_INLINE_P (decl1
)
14983 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14984 && ! DECL_INTERFACE_KNOWN (decl1
))
14985 DECL_DEFER_OUTPUT (decl1
) = 1;
14987 DECL_INTERFACE_KNOWN (decl1
) = 1;
14990 /* Determine the ELF visibility attribute for the function. We must not
14991 do this before calling "pushdecl", as we must allow "duplicate_decls"
14992 to merge any attributes appropriately. We also need to wait until
14994 if (!DECL_CLONED_FUNCTION_P (decl1
))
14995 determine_visibility (decl1
);
14997 if (!processing_template_decl
)
14998 maybe_instantiate_noexcept (decl1
);
15000 begin_scope (sk_function_parms
, decl1
);
15004 if (DECL_DESTRUCTOR_P (decl1
)
15005 || (DECL_CONSTRUCTOR_P (decl1
)
15006 && targetm
.cxx
.cdtor_returns_this ()))
15008 cdtor_label
= create_artificial_label (input_location
);
15009 LABEL_DECL_CDTOR (cdtor_label
) = true;
15012 start_fname_decls ();
15014 store_parm_decls (current_function_parms
);
15016 if (!processing_template_decl
15017 && (flag_lifetime_dse
> 1)
15018 && DECL_CONSTRUCTOR_P (decl1
)
15019 && !DECL_CLONED_FUNCTION_P (decl1
)
15020 /* Clobbering an empty base is harmful if it overlays real data. */
15021 && !is_empty_class (current_class_type
)
15022 /* We can't clobber safely for an implicitly-defined default constructor
15023 because part of the initialization might happen before we enter the
15024 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
15025 && !implicit_default_ctor_p (decl1
))
15026 finish_expr_stmt (build_clobber_this ());
15028 if (!processing_template_decl
15029 && DECL_CONSTRUCTOR_P (decl1
)
15030 && sanitize_flags_p (SANITIZE_VPTR
)
15031 && !DECL_CLONED_FUNCTION_P (decl1
)
15032 && !implicit_default_ctor_p (decl1
))
15033 cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr
);
15035 start_lambda_scope (decl1
);
15041 /* Like start_preparsed_function, except that instead of a
15042 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
15044 Returns true on success. If the DECLARATOR is not suitable
15045 for a function, we return false, which tells the parser to
15046 skip the entire function. */
15049 start_function (cp_decl_specifier_seq
*declspecs
,
15050 const cp_declarator
*declarator
,
15055 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
15056 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
15057 if (decl1
== error_mark_node
)
15059 /* If the declarator is not suitable for a function definition,
15060 cause a syntax error. */
15061 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
15063 error ("invalid function declaration");
15067 if (DECL_MAIN_P (decl1
))
15068 /* main must return int. grokfndecl should have corrected it
15069 (and issued a diagnostic) if the user got it wrong. */
15070 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
15071 integer_type_node
));
15073 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
15076 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
15080 use_eh_spec_block (tree fn
)
15082 return (flag_exceptions
&& flag_enforce_eh_specs
15083 && !processing_template_decl
15084 && !type_throw_all_p (TREE_TYPE (fn
))
15085 /* We insert the EH_SPEC_BLOCK only in the original
15086 function; then, it is copied automatically to the
15088 && !DECL_CLONED_FUNCTION_P (fn
)
15089 /* Implicitly-generated constructors and destructors have
15090 exception specifications. However, those specifications
15091 are the union of the possible exceptions specified by the
15092 constructors/destructors for bases and members, so no
15093 unallowed exception will ever reach this function. By
15094 not creating the EH_SPEC_BLOCK we save a little memory,
15095 and we avoid spurious warnings about unreachable
15097 && !DECL_DEFAULTED_FN (fn
));
15100 /* Store the parameter declarations into the current function declaration.
15101 This is called after parsing the parameter declarations, before
15102 digesting the body of the function.
15104 Also install to binding contour return value identifier, if any. */
15107 store_parm_decls (tree current_function_parms
)
15109 tree fndecl
= current_function_decl
;
15112 /* This is a chain of any other decls that came in among the parm
15113 declarations. If a parm is declared with enum {foo, bar} x;
15114 then CONST_DECLs for foo and bar are put here. */
15115 tree nonparms
= NULL_TREE
;
15117 if (current_function_parms
)
15119 /* This case is when the function was defined with an ANSI prototype.
15120 The parms already have decls, so we need not do anything here
15121 except record them as in effect
15122 and complain if any redundant old-style parm decls were written. */
15124 tree specparms
= current_function_parms
;
15127 /* Must clear this because it might contain TYPE_DECLs declared
15129 current_binding_level
->names
= NULL
;
15131 /* If we're doing semantic analysis, then we'll call pushdecl
15132 for each of these. We must do them in reverse order so that
15133 they end in the correct forward order. */
15134 specparms
= nreverse (specparms
);
15136 for (parm
= specparms
; parm
; parm
= next
)
15138 next
= DECL_CHAIN (parm
);
15139 if (TREE_CODE (parm
) == PARM_DECL
)
15143 /* If we find an enum constant or a type tag,
15144 put it aside for the moment. */
15145 TREE_CHAIN (parm
) = NULL_TREE
;
15146 nonparms
= chainon (nonparms
, parm
);
15150 /* Get the decls in their original chain order and record in the
15151 function. This is all and only the PARM_DECLs that were
15152 pushed into scope by the loop above. */
15153 DECL_ARGUMENTS (fndecl
) = get_local_decls ();
15156 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
15158 /* Now store the final chain of decls for the arguments
15159 as the decl-chain of the current lexical scope.
15160 Put the enumerators in as well, at the front so that
15161 DECL_ARGUMENTS is not modified. */
15162 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
15164 if (use_eh_spec_block (current_function_decl
))
15165 current_eh_spec_block
= begin_eh_spec_block ();
15169 /* We have finished doing semantic analysis on DECL, but have not yet
15170 generated RTL for its body. Save away our current state, so that
15171 when we want to generate RTL later we know what to do. */
15174 save_function_data (tree decl
)
15176 struct language_function
*f
;
15178 /* Save the language-specific per-function data so that we can
15179 get it back when we really expand this function. */
15180 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
15183 f
= ggc_alloc
<language_function
> ();
15184 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
15185 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
15187 /* Clear out the bits we don't need. */
15188 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
15189 f
->bindings
= NULL
;
15190 f
->x_local_names
= NULL
;
15191 f
->base
.local_typedefs
= NULL
;
15195 /* Set the return value of the constructor (if present). */
15198 finish_constructor_body (void)
15203 if (targetm
.cxx
.cdtor_returns_this ())
15205 /* Any return from a constructor will end up here. */
15206 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
15208 val
= DECL_ARGUMENTS (current_function_decl
);
15209 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
15210 DECL_RESULT (current_function_decl
), val
);
15211 /* Return the address of the object. */
15212 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
15213 add_stmt (exprstmt
);
15217 /* Do all the processing for the beginning of a destructor; set up the
15218 vtable pointers and cleanups for bases and members. */
15221 begin_destructor_body (void)
15223 tree compound_stmt
;
15225 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
15226 issued an error message. We still want to try to process the
15227 body of the function, but initialize_vtbl_ptrs will crash if
15228 TYPE_BINFO is NULL. */
15229 if (COMPLETE_TYPE_P (current_class_type
))
15231 compound_stmt
= begin_compound_stmt (0);
15232 /* Make all virtual function table pointers in non-virtual base
15233 classes point to CURRENT_CLASS_TYPE's virtual function
15235 initialize_vtbl_ptrs (current_class_ptr
);
15236 finish_compound_stmt (compound_stmt
);
15238 if (flag_lifetime_dse
15239 /* Clobbering an empty base is harmful if it overlays real data. */
15240 && !is_empty_class (current_class_type
))
15241 finish_decl_cleanup (NULL_TREE
, build_clobber_this ());
15243 /* And insert cleanups for our bases and members so that they
15244 will be properly destroyed if we throw. */
15245 push_base_cleanups ();
15249 /* At the end of every destructor we generate code to delete the object if
15250 necessary. Do that now. */
15253 finish_destructor_body (void)
15257 /* Any return from a destructor will end up here; that way all base
15258 and member cleanups will be run when the function returns. */
15259 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
15261 if (targetm
.cxx
.cdtor_returns_this ())
15265 val
= DECL_ARGUMENTS (current_function_decl
);
15266 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
15267 DECL_RESULT (current_function_decl
), val
);
15268 /* Return the address of the object. */
15269 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
15270 add_stmt (exprstmt
);
15274 /* Do the necessary processing for the beginning of a function body, which
15275 in this case includes member-initializers, but not the catch clauses of
15276 a function-try-block. Currently, this means opening a binding level
15277 for the member-initializers (in a ctor), member cleanups (in a dtor),
15278 and capture proxies (in a lambda operator()). */
15281 begin_function_body (void)
15285 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
15288 if (processing_template_decl
)
15289 /* Do nothing now. */;
15291 /* Always keep the BLOCK node associated with the outermost pair of
15292 curly braces of a function. These are needed for correct
15293 operation of dwarfout.c. */
15294 keep_next_level (true);
15296 stmt
= begin_compound_stmt (BCS_FN_BODY
);
15298 if (processing_template_decl
)
15299 /* Do nothing now. */;
15300 else if (DECL_DESTRUCTOR_P (current_function_decl
))
15301 begin_destructor_body ();
15306 /* Do the processing for the end of a function body. Currently, this means
15307 closing out the cleanups for fully-constructed bases and members, and in
15308 the case of the destructor, deleting the object if desired. Again, this
15309 is only meaningful for [cd]tors, since they are the only functions where
15310 there is a significant distinction between the main body and any
15311 function catch clauses. Handling, say, main() return semantics here
15312 would be wrong, as flowing off the end of a function catch clause for
15313 main() would also need to return 0. */
15316 finish_function_body (tree compstmt
)
15318 if (compstmt
== NULL_TREE
)
15321 /* Close the block. */
15322 finish_compound_stmt (compstmt
);
15324 if (processing_template_decl
)
15325 /* Do nothing now. */;
15326 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
15327 finish_constructor_body ();
15328 else if (DECL_DESTRUCTOR_P (current_function_decl
))
15329 finish_destructor_body ();
15332 /* Given a function, returns the BLOCK corresponding to the outermost level
15333 of curly braces, skipping the artificial block created for constructor
15337 outer_curly_brace_block (tree fndecl
)
15339 tree block
= DECL_INITIAL (fndecl
);
15340 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
15342 block
= BLOCK_SUBBLOCKS (block
);
15343 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
15345 block
= BLOCK_SUBBLOCKS (block
);
15346 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block
));
15350 /* If FNDECL is a class's key method, add the class to the list of
15351 keyed classes that should be emitted. */
15354 record_key_method_defined (tree fndecl
)
15356 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
15357 && DECL_VIRTUAL_P (fndecl
)
15358 && !processing_template_decl
)
15360 tree fnclass
= DECL_CONTEXT (fndecl
);
15361 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
15362 vec_safe_push (keyed_classes
, fnclass
);
15366 /* Subroutine of finish_function.
15367 Save the body of constexpr functions for possible
15368 future compile time evaluation. */
15371 maybe_save_function_definition (tree fun
)
15373 if (!processing_template_decl
15374 && DECL_DECLARED_CONSTEXPR_P (fun
)
15375 && !cp_function_chain
->invalid_constexpr
15376 && !DECL_CLONED_FUNCTION_P (fun
))
15377 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
15380 /* Finish up a function declaration and compile that function
15381 all the way to assembler language output. The free the storage
15382 for the function definition. INLINE_P is TRUE if we just
15383 finished processing the body of an in-class inline function
15384 definition. (This processing will have taken place after the
15385 class definition is complete.) */
15388 finish_function (bool inline_p
)
15390 tree fndecl
= current_function_decl
;
15391 tree fntype
, ctype
= NULL_TREE
;
15393 /* When we get some parse errors, we can end up without a
15394 current_function_decl, so cope. */
15395 if (fndecl
== NULL_TREE
)
15396 return error_mark_node
;
15398 finish_lambda_scope ();
15400 if (c_dialect_objc ())
15401 objc_finish_function ();
15403 record_key_method_defined (fndecl
);
15405 fntype
= TREE_TYPE (fndecl
);
15407 /* TREE_READONLY (fndecl) = 1;
15408 This caused &foo to be of type ptr-to-const-function
15409 which then got a warning when stored in a ptr-to-function variable. */
15411 gcc_assert (building_stmt_list_p ());
15412 /* The current function is being defined, so its DECL_INITIAL should
15413 be set, and unless there's a multiple definition, it should be
15414 error_mark_node. */
15415 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
15417 /* For a cloned function, we've already got all the code we need;
15418 there's no need to add any extra bits. */
15419 if (!DECL_CLONED_FUNCTION_P (fndecl
))
15421 /* Make it so that `main' always returns 0 by default. */
15422 if (DECL_MAIN_P (current_function_decl
))
15423 finish_return_stmt (integer_zero_node
);
15425 if (use_eh_spec_block (current_function_decl
))
15426 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
15427 (TREE_TYPE (current_function_decl
)),
15428 current_eh_spec_block
);
15431 /* If we're saving up tree structure, tie off the function now. */
15432 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
15434 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
15435 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
15437 finish_fname_decls ();
15439 /* If this function can't throw any exceptions, remember that. */
15440 if (!processing_template_decl
15441 && !cp_function_chain
->can_throw
15442 && !flag_non_call_exceptions
15443 && !decl_replaceable_p (fndecl
))
15444 TREE_NOTHROW (fndecl
) = 1;
15446 /* This must come after expand_function_end because cleanups might
15447 have declarations (from inline functions) that need to go into
15448 this function's blocks. */
15450 /* If the current binding level isn't the outermost binding level
15451 for this function, either there is a bug, or we have experienced
15452 syntax errors and the statement tree is malformed. */
15453 if (current_binding_level
->kind
!= sk_function_parms
)
15455 /* Make sure we have already experienced errors. */
15456 gcc_assert (errorcount
);
15458 /* Throw away the broken statement tree and extra binding
15460 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
15462 while (current_binding_level
->kind
!= sk_function_parms
)
15464 if (current_binding_level
->kind
== sk_class
)
15465 pop_nested_class ();
15467 poplevel (0, 0, 0);
15470 poplevel (1, 0, 1);
15472 /* Statements should always be full-expressions at the outermost set
15473 of curly braces for a function. */
15474 gcc_assert (stmts_are_full_exprs_p ());
15476 /* If there are no return statements in a function with auto return type,
15477 the return type is void. But if the declared type is something like
15478 auto*, this is an error. */
15479 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
15480 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
15482 if (is_auto (current_function_auto_return_pattern
))
15484 apply_deduced_return_type (fndecl
, void_type_node
);
15485 fntype
= TREE_TYPE (fndecl
);
15487 else if (!current_function_returns_value
15488 && !current_function_returns_null
)
15490 error ("no return statements in function returning %qT",
15491 current_function_auto_return_pattern
);
15492 inform (input_location
, "only plain %<auto%> return type can be "
15493 "deduced to %<void%>");
15497 // If this is a concept, check that the definition is reasonable.
15498 if (DECL_DECLARED_CONCEPT_P (fndecl
))
15499 check_function_concept (fndecl
);
15501 /* Lambda closure members are implicitly constexpr if possible. */
15502 if (cxx_dialect
>= cxx17
15503 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fndecl
)))
15504 DECL_DECLARED_CONSTEXPR_P (fndecl
)
15505 = ((processing_template_decl
15506 || is_valid_constexpr_fn (fndecl
, /*complain*/false))
15507 && potential_constant_expression (DECL_SAVED_TREE (fndecl
)));
15509 /* Save constexpr function body before it gets munged by
15510 the NRV transformation. */
15511 maybe_save_function_definition (fndecl
);
15513 /* Invoke the pre-genericize plugin before we start munging things. */
15514 if (!processing_template_decl
)
15515 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
15517 /* Perform delayed folding before NRV transformation. */
15518 if (!processing_template_decl
)
15519 cp_fold_function (fndecl
);
15521 /* Set up the named return value optimization, if we can. Candidate
15522 variables are selected in check_return_expr. */
15523 if (current_function_return_value
)
15525 tree r
= current_function_return_value
;
15528 if (r
!= error_mark_node
15529 /* This is only worth doing for fns that return in memory--and
15530 simpler, since we don't have to worry about promoted modes. */
15531 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
15532 /* Only allow this for variables declared in the outer scope of
15533 the function so we know that their lifetime always ends with a
15534 return; see g++.dg/opt/nrv6.C. We could be more flexible if
15535 we were to do this optimization in tree-ssa. */
15536 && (outer
= outer_curly_brace_block (fndecl
))
15537 && chain_member (r
, BLOCK_VARS (outer
)))
15538 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
15540 current_function_return_value
= NULL_TREE
;
15543 /* Remember that we were in class scope. */
15544 if (current_class_name
)
15545 ctype
= current_class_type
;
15547 /* Must mark the RESULT_DECL as being in this function. */
15548 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
15550 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
15551 to the FUNCTION_DECL node itself. */
15552 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
15554 /* Save away current state, if appropriate. */
15555 if (!processing_template_decl
)
15556 save_function_data (fndecl
);
15558 /* Complain if there's just no return statement. */
15559 if (warn_return_type
15560 && !VOID_TYPE_P (TREE_TYPE (fntype
))
15561 && !dependent_type_p (TREE_TYPE (fntype
))
15562 && !current_function_returns_value
&& !current_function_returns_null
15563 /* Don't complain if we abort or throw. */
15564 && !current_function_returns_abnormally
15565 /* Don't complain if there's an infinite loop. */
15566 && !current_function_infinite_loop
15567 /* Don't complain if we are declared noreturn. */
15568 && !TREE_THIS_VOLATILE (fndecl
)
15569 && !DECL_NAME (DECL_RESULT (fndecl
))
15570 && !TREE_NO_WARNING (fndecl
)
15571 /* Structor return values (if any) are set by the compiler. */
15572 && !DECL_CONSTRUCTOR_P (fndecl
)
15573 && !DECL_DESTRUCTOR_P (fndecl
)
15574 && targetm
.warn_func_return (fndecl
))
15576 warning (OPT_Wreturn_type
,
15577 "no return statement in function returning non-void");
15578 TREE_NO_WARNING (fndecl
) = 1;
15581 /* Store the end of the function, so that we get good line number
15582 info for the epilogue. */
15583 cfun
->function_end_locus
= input_location
;
15585 /* Complain about parameters that are only set, but never otherwise used. */
15586 if (warn_unused_but_set_parameter
15587 && !processing_template_decl
15588 && errorcount
== unused_but_set_errorcount
15589 && !DECL_CLONED_FUNCTION_P (fndecl
))
15593 for (decl
= DECL_ARGUMENTS (fndecl
);
15595 decl
= DECL_CHAIN (decl
))
15596 if (TREE_USED (decl
)
15597 && TREE_CODE (decl
) == PARM_DECL
15598 && !DECL_READ_P (decl
)
15599 && DECL_NAME (decl
)
15600 && !DECL_ARTIFICIAL (decl
)
15601 && !TREE_NO_WARNING (decl
)
15602 && !DECL_IN_SYSTEM_HEADER (decl
)
15603 && TREE_TYPE (decl
) != error_mark_node
15604 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
15605 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
15606 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
15607 warning_at (DECL_SOURCE_LOCATION (decl
),
15608 OPT_Wunused_but_set_parameter
,
15609 "parameter %qD set but not used", decl
);
15610 unused_but_set_errorcount
= errorcount
;
15613 /* Complain about locally defined typedefs that are not used in this
15615 maybe_warn_unused_local_typedefs ();
15617 /* Possibly warn about unused parameters. */
15618 if (warn_unused_parameter
15619 && !processing_template_decl
15620 && !DECL_CLONED_FUNCTION_P (fndecl
))
15621 do_warn_unused_parameter (fndecl
);
15623 /* Genericize before inlining. */
15624 if (!processing_template_decl
)
15626 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
15627 cp_genericize (fndecl
);
15628 /* Clear out the bits we don't need. */
15629 f
->x_current_class_ptr
= NULL
;
15630 f
->x_current_class_ref
= NULL
;
15631 f
->x_eh_spec_block
= NULL
;
15632 f
->x_in_charge_parm
= NULL
;
15633 f
->x_vtt_parm
= NULL
;
15634 f
->x_return_value
= NULL
;
15635 f
->bindings
= NULL
;
15636 f
->extern_decl_map
= NULL
;
15637 f
->infinite_loops
= NULL
;
15639 /* Clear out the bits we don't need. */
15640 local_names
= NULL
;
15642 /* We're leaving the context of this function, so zap cfun. It's still in
15643 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
15645 current_function_decl
= NULL
;
15647 /* If this is an in-class inline definition, we may have to pop the
15648 bindings for the template parameters that we added in
15649 maybe_begin_member_template_processing when start_function was
15652 maybe_end_member_template_processing ();
15654 /* Leave the scope of the class. */
15656 pop_nested_class ();
15661 current_function_decl
= NULL_TREE
;
15663 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, fndecl
);
15667 /* Create the FUNCTION_DECL for a function definition.
15668 DECLSPECS and DECLARATOR are the parts of the declaration;
15669 they describe the return type and the name of the function,
15670 but twisted together in a fashion that parallels the syntax of C.
15672 This function creates a binding context for the function body
15673 as well as setting up the FUNCTION_DECL in current_function_decl.
15675 Returns a FUNCTION_DECL on success.
15677 If the DECLARATOR is not suitable for a function (it defines a datum
15678 instead), we return 0, which tells yyparse to report a parse error.
15680 May return void_type_node indicating that this method is actually
15681 a friend. See grokfield for more details.
15683 Came here with a `.pushlevel' .
15685 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
15686 CHANGES TO CODE IN `grokfield'. */
15689 grokmethod (cp_decl_specifier_seq
*declspecs
,
15690 const cp_declarator
*declarator
, tree attrlist
)
15692 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
15695 if (fndecl
== error_mark_node
)
15696 return error_mark_node
;
15698 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
15700 error ("invalid member function declaration");
15701 return error_mark_node
;
15705 cplus_decl_attributes (&fndecl
, attrlist
, 0);
15707 /* Pass friends other than inline friend functions back. */
15708 if (fndecl
== void_type_node
)
15711 if (DECL_IN_AGGR_P (fndecl
))
15713 if (DECL_CLASS_SCOPE_P (fndecl
))
15714 error ("%qD is already defined in class %qT", fndecl
,
15715 DECL_CONTEXT (fndecl
));
15716 return error_mark_node
;
15719 check_template_shadow (fndecl
);
15721 if (TREE_PUBLIC (fndecl
))
15722 DECL_COMDAT (fndecl
) = 1;
15723 DECL_DECLARED_INLINE_P (fndecl
) = 1;
15724 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
15726 /* We process method specializations in finish_struct_1. */
15727 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
15729 fndecl
= push_template_decl (fndecl
);
15730 if (fndecl
== error_mark_node
)
15734 if (! DECL_FRIEND_P (fndecl
))
15736 if (DECL_CHAIN (fndecl
))
15738 fndecl
= copy_node (fndecl
);
15739 TREE_CHAIN (fndecl
) = NULL_TREE
;
15743 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
15745 DECL_IN_AGGR_P (fndecl
) = 1;
15750 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
15751 we can lay it out later, when and if its type becomes complete.
15753 Also handle constexpr variables where the initializer involves
15754 an unlowered PTRMEM_CST because the class isn't complete yet. */
15757 maybe_register_incomplete_var (tree var
)
15759 gcc_assert (VAR_P (var
));
15761 /* Keep track of variables with incomplete types. */
15762 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
15763 && DECL_EXTERNAL (var
))
15765 tree inner_type
= TREE_TYPE (var
);
15767 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
15768 inner_type
= TREE_TYPE (inner_type
);
15769 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
15771 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
15772 /* RTTI TD entries are created while defining the type_info. */
15773 || (TYPE_LANG_SPECIFIC (inner_type
)
15774 && TYPE_BEING_DEFINED (inner_type
)))
15776 incomplete_var iv
= {var
, inner_type
};
15777 vec_safe_push (incomplete_vars
, iv
);
15779 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
15780 && decl_constant_var_p (var
)
15781 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
15783 /* When the outermost open class is complete we can resolve any
15784 pointers-to-members. */
15785 tree context
= outermost_open_class ();
15786 incomplete_var iv
= {var
, context
};
15787 vec_safe_push (incomplete_vars
, iv
);
15792 /* Called when a class type (given by TYPE) is defined. If there are
15793 any existing VAR_DECLs whose type has been completed by this
15794 declaration, update them now. */
15797 complete_vars (tree type
)
15800 incomplete_var
*iv
;
15802 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
15804 if (same_type_p (type
, iv
->incomplete_type
))
15806 tree var
= iv
->decl
;
15807 tree type
= TREE_TYPE (var
);
15809 if (type
!= error_mark_node
15810 && (TYPE_MAIN_VARIANT (strip_array_types (type
))
15811 == iv
->incomplete_type
))
15813 /* Complete the type of the variable. The VAR_DECL itself
15814 will be laid out in expand_expr. */
15815 complete_type (type
);
15816 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
15819 /* Remove this entry from the list. */
15820 incomplete_vars
->unordered_remove (ix
);
15826 /* Check for pending declarations which may have abstract type. */
15827 complete_type_check_abstract (type
);
15830 /* If DECL is of a type which needs a cleanup, build and return an
15831 expression to perform that cleanup here. Return NULL_TREE if no
15832 cleanup need be done. DECL can also be a _REF when called from
15833 split_nonconstant_init_1. */
15836 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
15842 /* Assume no cleanup is required. */
15843 cleanup
= NULL_TREE
;
15845 if (error_operand_p (decl
))
15848 /* Handle "__attribute__((cleanup))". We run the cleanup function
15849 before the destructor since the destructor is what actually
15850 terminates the lifetime of the object. */
15852 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
15861 /* Get the name specified by the user for the cleanup function. */
15862 id
= TREE_VALUE (TREE_VALUE (attr
));
15863 /* Look up the name to find the cleanup function to call. It is
15864 important to use lookup_name here because that is what is
15865 used in c-common.c:handle_cleanup_attribute when performing
15866 initial checks on the attribute. Note that those checks
15867 include ensuring that the function found is not an overloaded
15868 function, or an object with an overloaded call operator,
15869 etc.; we can rely on the fact that the function found is an
15870 ordinary FUNCTION_DECL. */
15871 fn
= lookup_name (id
);
15872 arg
= build_address (decl
);
15873 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
15874 return error_mark_node
;
15875 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
15876 if (cleanup
== error_mark_node
)
15877 return error_mark_node
;
15879 /* Handle ordinary C++ destructors. */
15880 type
= TREE_TYPE (decl
);
15881 if (type_build_dtor_call (type
))
15883 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
15887 if (TREE_CODE (type
) == ARRAY_TYPE
)
15890 addr
= build_address (decl
);
15892 call
= build_delete (TREE_TYPE (addr
), addr
,
15893 sfk_complete_destructor
, flags
, 0, complain
);
15894 if (call
== error_mark_node
)
15895 cleanup
= error_mark_node
;
15896 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
15897 /* Discard the call. */;
15899 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
15904 /* build_delete sets the location of the destructor call to the
15905 current location, even though the destructor is going to be
15906 called later, at the end of the current scope. This can lead to
15907 a "jumpy" behavior for users of debuggers when they step around
15908 the end of the block. So let's unset the location of the
15909 destructor call instead. */
15910 protected_set_expr_location (cleanup
, UNKNOWN_LOCATION
);
15914 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
)))
15915 /* Treat objects with destructors as used; the destructor may do
15916 something substantive. */
15917 && !mark_used (decl
, complain
) && !(complain
& tf_error
))
15918 return error_mark_node
;
15924 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
15925 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
15926 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
15929 static_fn_type (tree memfntype
)
15934 if (TYPE_PTRMEMFUNC_P (memfntype
))
15935 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
15936 if (POINTER_TYPE_P (memfntype
)
15937 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
15938 memfntype
= TREE_TYPE (memfntype
);
15939 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
15941 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
15942 args
= TYPE_ARG_TYPES (memfntype
);
15943 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
15944 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
15945 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
15946 fntype
= (cp_build_type_attribute_variant
15947 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
15948 fntype
= (build_exception_variant
15949 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
15950 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype
))
15951 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
15955 /* DECL was originally constructed as a non-static member function,
15956 but turned out to be static. Update it accordingly. */
15959 revert_static_member_fn (tree decl
)
15961 tree stype
= static_fn_type (decl
);
15962 cp_cv_quals quals
= type_memfn_quals (stype
);
15963 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
15965 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
15966 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
15968 TREE_TYPE (decl
) = stype
;
15970 if (DECL_ARGUMENTS (decl
))
15971 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
15972 DECL_STATIC_FUNCTION_P (decl
) = 1;
15975 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
15976 one of the language-independent trees. */
15978 enum cp_tree_node_structure_enum
15979 cp_tree_node_structure (union lang_tree_node
* t
)
15981 switch (TREE_CODE (&t
->generic
))
15983 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
15984 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
15985 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
15986 case OVERLOAD
: return TS_CP_OVERLOAD
;
15987 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
15988 case PTRMEM_CST
: return TS_CP_PTRMEM
;
15989 case BASELINK
: return TS_CP_BASELINK
;
15990 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
15991 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
15992 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
15993 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
15994 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
15995 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
15996 case CONSTRAINT_INFO
: return TS_CP_CONSTRAINT_INFO
;
15997 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
15998 default: return TS_CP_GENERIC
;
16002 /* Build the void_list_node (void_type_node having been created). */
16004 build_void_list_node (void)
16006 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
16011 cp_missing_noreturn_ok_p (tree decl
)
16013 /* A missing noreturn is ok for the `main' function. */
16014 return DECL_MAIN_P (decl
);
16017 /* Return the decl used to identify the COMDAT group into which DECL should
16021 cxx_comdat_group (tree decl
)
16023 /* Virtual tables, construction virtual tables, and virtual table
16024 tables all go in a single COMDAT group, named after the primary
16026 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
16027 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
16028 /* For all other DECLs, the COMDAT group is the mangled name of the
16029 declaration itself. */
16032 while (DECL_THUNK_P (decl
))
16034 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
16035 into the same section as the target function. In that case
16036 we must return target's name. */
16037 tree target
= THUNK_TARGET (decl
);
16038 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
16039 && DECL_SECTION_NAME (target
) != NULL
16040 && DECL_ONE_ONLY (target
))
16050 /* Returns the return type for FN as written by the user, which may include
16051 a placeholder for a deduced return type. */
16054 fndecl_declared_return_type (tree fn
)
16056 fn
= STRIP_TEMPLATE (fn
);
16057 if (FNDECL_USED_AUTO (fn
))
16059 struct language_function
*f
= NULL
;
16060 if (DECL_STRUCT_FUNCTION (fn
))
16061 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
16063 f
= DECL_SAVED_FUNCTION_DATA (fn
);
16064 return f
->x_auto_return_pattern
;
16066 return TREE_TYPE (TREE_TYPE (fn
));
16069 /* Returns true iff DECL was declared with an auto type and it has
16070 not yet been deduced to a real type. */
16073 undeduced_auto_decl (tree decl
)
16075 if (cxx_dialect
< cxx11
)
16077 return type_uses_auto (TREE_TYPE (decl
));
16080 /* Complain if DECL has an undeduced return type. */
16083 require_deduced_type (tree decl
, tsubst_flags_t complain
)
16085 if (undeduced_auto_decl (decl
))
16087 if (complain
& tf_error
)
16088 error ("use of %qD before deduction of %<auto%>", decl
);
16094 #include "gt-cp-decl.h"