1 /* Process declarations and variables for -*- C++ -*- compiler.
2 Copyright (C) 1988-2019 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"
54 #include "gcc-rich-location.h"
55 #include "langhooks.h"
57 /* Possible cases of bad specifiers type used by bad_specifiers. */
59 BSP_VAR
, /* variable */
60 BSP_PARM
, /* parameter */
65 static const char *redeclaration_error_message (tree
, tree
);
67 static int decl_jump_unsafe (tree
);
68 static void require_complete_types_for_parms (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
, location_t
);
72 static void 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 tree
local_variable_p_walkfn (tree
*, int *, void *);
77 static const char *tag_name (enum tag_types
);
78 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
79 static void maybe_deduce_size_from_array_init (tree
, tree
);
80 static void layout_var_decl (tree
);
81 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
82 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
83 static void copy_type_enum (tree
, tree
);
84 static void check_function_type (tree
, tree
);
85 static void finish_constructor_body (void);
86 static void begin_destructor_body (void);
87 static void finish_destructor_body (void);
88 static void record_key_method_defined (tree
);
89 static tree
create_array_type_for_decl (tree
, tree
, tree
, location_t
);
90 static tree
get_atexit_node (void);
91 static tree
get_dso_handle_node (void);
92 static tree
start_cleanup_fn (void);
93 static void end_cleanup_fn (void);
94 static tree
cp_make_fname_decl (location_t
, tree
, int);
95 static void initialize_predefined_identifiers (void);
96 static tree check_special_function_return_type
97 (special_function_kind
, tree
, tree
, int, const location_t
*);
98 static tree
push_cp_library_fn (enum tree_code
, tree
, int);
99 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
100 static void store_parm_decls (tree
);
101 static void initialize_local_var (tree
, tree
);
102 static void expand_static_init (tree
, tree
);
104 /* The following symbols are subsumed in the cp_global_trees array, and
105 listed here individually for documentation purposes.
108 tree wchar_decl_node;
110 tree vtable_entry_type;
111 tree delta_type_node;
112 tree __t_desc_type_node;
114 tree class_type_node;
115 tree unknown_type_node;
117 Array type `vtable_entry_type[]'
120 tree vtbl_ptr_type_node;
127 A FUNCTION_DECL which can call `abort'. Not necessarily the
128 one that the user will declare, but sufficient to be called
129 by routines that want to abort the program.
134 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
135 tree tinfo_var_id; */
137 tree cp_global_trees
[CPTI_MAX
];
139 /* A list of objects which have constructors or destructors
140 which reside in the global scope. The decl is stored in
141 the TREE_VALUE slot and the initializer is stored
142 in the TREE_PURPOSE slot. */
143 tree static_aggregates
;
145 /* Like static_aggregates, but for thread_local variables. */
150 /* A node for the integer constant 2. */
152 tree integer_two_node
;
154 /* vector of static decls. */
155 vec
<tree
, va_gc
> *static_decls
;
157 /* vector of keyed classes. */
158 vec
<tree
, va_gc
> *keyed_classes
;
160 /* Used only for jumps to as-yet undefined labels, since jumps to
161 defined labels can have their validity checked immediately. */
163 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
164 struct named_label_use_entry
*next
;
165 /* The binding level to which this entry is *currently* attached.
166 This is initially the binding level in which the goto appeared,
167 but is modified as scopes are closed. */
168 cp_binding_level
*binding_level
;
169 /* The head of the names list that was current when the goto appeared,
170 or the inner scope popped. These are the decls that will *not* be
171 skipped when jumping to the label. */
173 /* The location of the goto, for error reporting. */
174 location_t o_goto_locus
;
175 /* True if an OpenMP structured block scope has been closed since
176 the goto appeared. This means that the branch from the label will
177 illegally exit an OpenMP scope. */
181 /* A list of all LABEL_DECLs in the function that have names. Here so
182 we can clear out their names' definitions at the end of the
183 function, and so we can check the validity of jumps to these labels. */
185 struct GTY((for_user
)) named_label_entry
{
187 tree name
; /* Name of decl. */
189 tree label_decl
; /* LABEL_DECL, unless deleted local label. */
191 named_label_entry
*outer
; /* Outer shadowed chain. */
193 /* The binding level to which the label is *currently* attached.
194 This is initially set to the binding level in which the label
195 is defined, but is modified as scopes are closed. */
196 cp_binding_level
*binding_level
;
198 /* The head of the names list that was current when the label was
199 defined, or the inner scope popped. These are the decls that will
200 be skipped when jumping to the label. */
203 /* A vector of all decls from all binding levels that would be
204 crossed by a backward branch to the label. */
205 vec
<tree
, va_gc
> *bad_decls
;
207 /* A list of uses of the label, before the label is defined. */
208 named_label_use_entry
*uses
;
210 /* The following bits are set after the label is defined, and are
211 updated as scopes are popped. They indicate that a jump to the
212 label will illegally enter a scope of the given flavor. */
216 bool in_transaction_scope
;
217 bool in_constexpr_if
;
220 #define named_labels cp_function_chain->x_named_labels
222 /* The number of function bodies which we are currently processing.
223 (Zero if we are at namespace scope, one inside the body of a
224 function, two inside the body of a function in a local class, etc.) */
227 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
228 bool flag_noexcept_type
;
230 /* States indicating how grokdeclarator() should handle declspecs marked
231 with __attribute__((deprecated)). An object declared as
232 __attribute__((deprecated)) suppresses warnings of uses of other
234 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
237 /* A list of VAR_DECLs whose type was incomplete at the time the
238 variable was declared. */
240 struct GTY(()) incomplete_var
{
242 tree incomplete_type
;
246 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
248 /* Returns the kind of template specialization we are currently
249 processing, given that it's declaration contained N_CLASS_SCOPES
250 explicit scope qualifications. */
253 current_tmpl_spec_kind (int n_class_scopes
)
255 int n_template_parm_scopes
= 0;
256 int seen_specialization_p
= 0;
257 int innermost_specialization_p
= 0;
260 /* Scan through the template parameter scopes. */
261 for (b
= current_binding_level
;
262 b
->kind
== sk_template_parms
;
265 /* If we see a specialization scope inside a parameter scope,
266 then something is wrong. That corresponds to a declaration
269 template <class T> template <> ...
271 which is always invalid since [temp.expl.spec] forbids the
272 specialization of a class member template if the enclosing
273 class templates are not explicitly specialized as well. */
274 if (b
->explicit_spec_p
)
276 if (n_template_parm_scopes
== 0)
277 innermost_specialization_p
= 1;
279 seen_specialization_p
= 1;
281 else if (seen_specialization_p
== 1)
282 return tsk_invalid_member_spec
;
284 ++n_template_parm_scopes
;
287 /* Handle explicit instantiations. */
288 if (processing_explicit_instantiation
)
290 if (n_template_parm_scopes
!= 0)
291 /* We've seen a template parameter list during an explicit
292 instantiation. For example:
294 template <class T> template void f(int);
296 This is erroneous. */
297 return tsk_invalid_expl_inst
;
299 return tsk_expl_inst
;
302 if (n_template_parm_scopes
< n_class_scopes
)
303 /* We've not seen enough template headers to match all the
304 specialized classes present. For example:
306 template <class T> void R<T>::S<T>::f(int);
308 This is invalid; there needs to be one set of template
309 parameters for each class. */
310 return tsk_insufficient_parms
;
311 else if (n_template_parm_scopes
== n_class_scopes
)
312 /* We're processing a non-template declaration (even though it may
313 be a member of a template class.) For example:
315 template <class T> void S<T>::f(int);
317 The `class T' matches the `S<T>', leaving no template headers
318 corresponding to the `f'. */
320 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
321 /* We've got too many template headers. For example:
323 template <> template <class T> void f (T);
325 There need to be more enclosing classes. */
326 return tsk_excessive_parms
;
328 /* This must be a template. It's of the form:
330 template <class T> template <class U> void S<T>::f(U);
332 This is a specialization if the innermost level was a
333 specialization; otherwise it's just a definition of the
335 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
338 /* Exit the current scope. */
346 /* When a label goes out of scope, check to see if that label was used
347 in a valid manner, and issue any appropriate warnings or errors. */
350 check_label_used (tree label
)
352 if (!processing_template_decl
)
354 if (DECL_INITIAL (label
) == NULL_TREE
)
358 error ("label %q+D used but not defined", label
);
359 location
= input_location
;
360 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
361 /* Avoid crashing later. */
362 define_label (location
, DECL_NAME (label
));
365 warn_for_unused_label (label
);
369 /* Helper function to sort named label entries in a vector by DECL_UID. */
372 sort_labels (const void *a
, const void *b
)
374 tree label1
= *(tree
const *) a
;
375 tree label2
= *(tree
const *) b
;
377 /* DECL_UIDs can never be equal. */
378 return DECL_UID (label1
) > DECL_UID (label2
) ? -1 : +1;
381 /* At the end of a function, all labels declared within the function
382 go out of scope. BLOCK is the top-level block for the
386 pop_labels (tree block
)
391 /* We need to add the labels to the block chain, so debug
392 information is emitted. But, we want the order to be stable so
393 need to sort them first. Otherwise the debug output could be
394 randomly ordered. I guess it's mostly stable, unless the hash
395 table implementation changes. */
396 auto_vec
<tree
, 32> labels (named_labels
->elements ());
397 hash_table
<named_label_hash
>::iterator
end (named_labels
->end ());
398 for (hash_table
<named_label_hash
>::iterator iter
399 (named_labels
->begin ()); iter
!= end
; ++iter
)
401 named_label_entry
*ent
= *iter
;
403 gcc_checking_assert (!ent
->outer
);
405 labels
.quick_push (ent
->label_decl
);
409 labels
.qsort (sort_labels
);
411 while (labels
.length ())
413 tree label
= labels
.pop ();
415 DECL_CHAIN (label
) = BLOCK_VARS (block
);
416 BLOCK_VARS (block
) = label
;
418 check_label_used (label
);
422 /* At the end of a block with local labels, restore the outer definition. */
425 pop_local_label (tree id
, tree label
)
427 check_label_used (label
);
428 named_label_entry
**slot
= named_labels
->find_slot_with_hash
429 (id
, IDENTIFIER_HASH_VALUE (id
), NO_INSERT
);
430 named_label_entry
*ent
= *slot
;
436 ent
= ggc_cleared_alloc
<named_label_entry
> ();
442 /* The following two routines are used to interface to Objective-C++.
443 The binding level is purposely treated as an opaque type. */
446 objc_get_current_scope (void)
448 return current_binding_level
;
451 /* The following routine is used by the NeXT-style SJLJ exceptions;
452 variables get marked 'volatile' so as to not be clobbered by
453 _setjmp()/_longjmp() calls. All variables in the current scope,
454 as well as parent scopes up to (but not including) ENCLOSING_BLK
455 shall be thusly marked. */
458 objc_mark_locals_volatile (void *enclosing_blk
)
460 cp_binding_level
*scope
;
462 for (scope
= current_binding_level
;
463 scope
&& scope
!= enclosing_blk
;
464 scope
= scope
->level_chain
)
468 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
469 objc_volatilize_decl (decl
);
471 /* Do not climb up past the current function. */
472 if (scope
->kind
== sk_function_parms
)
477 /* True if B is the level for the condition of a constexpr if. */
480 level_for_constexpr_if (cp_binding_level
*b
)
482 return (b
->kind
== sk_cond
&& b
->this_entity
483 && TREE_CODE (b
->this_entity
) == IF_STMT
484 && IF_STMT_CONSTEXPR_P (b
->this_entity
));
487 /* Update data for defined and undefined labels when leaving a scope. */
490 poplevel_named_label_1 (named_label_entry
**slot
, cp_binding_level
*bl
)
492 named_label_entry
*ent
= *slot
;
493 cp_binding_level
*obl
= bl
->level_chain
;
495 if (ent
->binding_level
== bl
)
499 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
500 TREE_LISTs representing OVERLOADs, so be careful. */
501 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
503 : TREE_CHAIN (decl
)))
504 if (decl_jump_unsafe (decl
))
505 vec_safe_push (ent
->bad_decls
, decl
);
507 ent
->binding_level
= obl
;
508 ent
->names_in_scope
= obl
->names
;
512 ent
->in_try_scope
= true;
515 ent
->in_catch_scope
= true;
518 ent
->in_omp_scope
= true;
521 ent
->in_transaction_scope
= true;
524 if (level_for_constexpr_if (bl
->level_chain
))
525 ent
->in_constexpr_if
= true;
533 struct named_label_use_entry
*use
;
535 for (use
= ent
->uses
; use
; use
= use
->next
)
536 if (use
->binding_level
== bl
)
538 use
->binding_level
= obl
;
539 use
->names_in_scope
= obl
->names
;
540 if (bl
->kind
== sk_omp
)
541 use
->in_omp_scope
= true;
548 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
549 when errors were reported, except for -Werror-unused-but-set-*. */
550 static int unused_but_set_errorcount
;
552 /* Exit a binding level.
553 Pop the level off, and restore the state of the identifier-decl mappings
554 that were in effect when this level was entered.
556 If KEEP == 1, this level had explicit declarations, so
557 and create a "block" (a BLOCK node) for the level
558 to record its declarations and subblocks for symbol table output.
560 If FUNCTIONBODY is nonzero, this level is the body of a function,
561 so create a block as if KEEP were set and also clear out all
564 If REVERSE is nonzero, reverse the order of decls before putting
565 them into the BLOCK. */
568 poplevel (int keep
, int reverse
, int functionbody
)
571 /* The chain of decls was accumulated in reverse order.
572 Put it into forward order, just for cleanliness. */
579 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
584 gcc_assert (current_binding_level
->kind
!= sk_class
585 && current_binding_level
->kind
!= sk_namespace
);
587 if (current_binding_level
->kind
== sk_cleanup
)
589 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
591 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
593 /* We used to use KEEP == 2 to indicate that the new block should go
594 at the beginning of the list of blocks at this binding level,
595 rather than the end. This hack is no longer used. */
596 gcc_assert (keep
== 0 || keep
== 1);
598 if (current_binding_level
->keep
)
601 /* Any uses of undefined labels, and any defined labels, now operate
602 under constraints of next binding contour. */
603 if (cfun
&& !functionbody
&& named_labels
)
604 named_labels
->traverse
<cp_binding_level
*, poplevel_named_label_1
>
605 (current_binding_level
);
607 /* Get the decls in the order they were written.
608 Usually current_binding_level->names is in reverse order.
609 But parameter decls were previously put in forward order. */
611 decls
= current_binding_level
->names
;
614 decls
= nreverse (decls
);
615 current_binding_level
->names
= decls
;
618 /* If there were any declarations or structure tags in that level,
619 or if this level is a function body,
620 create a BLOCK to record them for the life of this function. */
622 /* Avoid function body block if possible. */
623 if (functionbody
&& subblocks
&& BLOCK_CHAIN (subblocks
) == NULL_TREE
)
625 else if (keep
== 1 || functionbody
)
626 block
= make_node (BLOCK
);
627 if (block
!= NULL_TREE
)
629 BLOCK_VARS (block
) = decls
;
630 BLOCK_SUBBLOCKS (block
) = subblocks
;
633 /* In each subblock, record that this is its superior. */
635 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
636 BLOCK_SUPERCONTEXT (link
) = block
;
638 /* Before we remove the declarations first check for unused variables. */
639 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
640 && current_binding_level
->kind
!= sk_template_parms
641 && !processing_template_decl
)
642 for (tree d
= get_local_decls (); d
; d
= TREE_CHAIN (d
))
644 /* There are cases where D itself is a TREE_LIST. See in
645 push_local_binding where the list of decls returned by
646 getdecls is built. */
647 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
649 tree type
= TREE_TYPE (decl
);
651 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
652 && ! DECL_IN_SYSTEM_HEADER (decl
)
653 /* For structured bindings, consider only real variables, not
655 && (DECL_DECOMPOSITION_P (decl
) ? !DECL_DECOMP_BASE (decl
)
656 : (DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
)))
657 && type
!= error_mark_node
658 && (!CLASS_TYPE_P (type
)
659 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
660 || lookup_attribute ("warn_unused",
661 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
663 if (! TREE_USED (decl
))
665 if (!DECL_NAME (decl
) && DECL_DECOMPOSITION_P (decl
))
666 warning_at (DECL_SOURCE_LOCATION (decl
),
667 OPT_Wunused_variable
,
668 "unused structured binding declaration");
670 warning_at (DECL_SOURCE_LOCATION (decl
),
671 OPT_Wunused_variable
, "unused variable %qD", decl
);
673 else if (DECL_CONTEXT (decl
) == current_function_decl
674 // For -Wunused-but-set-variable leave references alone.
675 && !TYPE_REF_P (TREE_TYPE (decl
))
676 && errorcount
== unused_but_set_errorcount
)
678 if (!DECL_NAME (decl
) && DECL_DECOMPOSITION_P (decl
))
679 warning_at (DECL_SOURCE_LOCATION (decl
),
680 OPT_Wunused_but_set_variable
, "structured "
681 "binding declaration set but not used");
683 warning_at (DECL_SOURCE_LOCATION (decl
),
684 OPT_Wunused_but_set_variable
,
685 "variable %qD set but not used", decl
);
686 unused_but_set_errorcount
= errorcount
;
691 /* Remove declarations for all the DECLs in this level. */
692 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
694 decl
= TREE_CODE (link
) == TREE_LIST
? TREE_VALUE (link
) : link
;
695 tree name
= OVL_NAME (decl
);
697 /* Remove the binding. */
698 if (TREE_CODE (decl
) == LABEL_DECL
)
699 pop_local_label (name
, decl
);
701 pop_local_binding (name
, decl
);
704 /* Restore the IDENTIFIER_TYPE_VALUEs. */
705 for (link
= current_binding_level
->type_shadowed
;
706 link
; link
= TREE_CHAIN (link
))
707 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
709 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
710 list if a `using' declaration put them there. The debugging
711 back ends won't understand OVERLOAD, so we remove them here.
712 Because the BLOCK_VARS are (temporarily) shared with
713 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
714 popped all the bindings. Also remove undeduced 'auto' decls,
715 which LTO doesn't understand, and can't have been used by anything. */
720 for (d
= &BLOCK_VARS (block
); *d
; )
722 if (TREE_CODE (*d
) == TREE_LIST
723 || (!processing_template_decl
724 && undeduced_auto_decl (*d
)))
725 *d
= TREE_CHAIN (*d
);
727 d
= &DECL_CHAIN (*d
);
731 /* If the level being exited is the top level of a function,
732 check over all the labels. */
737 /* Since this is the top level block of a function, the vars are
738 the function's parameters. Don't leave them in the BLOCK
739 because they are found in the FUNCTION_DECL instead. */
740 BLOCK_VARS (block
) = 0;
744 pop_labels (subblocks
);
747 kind
= current_binding_level
->kind
;
748 if (kind
== sk_cleanup
)
752 /* If this is a temporary binding created for a cleanup, then we'll
753 have pushed a statement list level. Pop that, create a new
754 BIND_EXPR for the block, and insert it into the stream. */
755 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
756 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
763 /* The current function is being defined, so its DECL_INITIAL
764 should be error_mark_node. */
765 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
766 DECL_INITIAL (current_function_decl
) = block
? block
: subblocks
;
769 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
771 if (BLOCK_SUBBLOCKS (subblocks
))
772 BLOCK_OUTER_CURLY_BRACE_P (BLOCK_SUBBLOCKS (subblocks
)) = 1;
775 BLOCK_OUTER_CURLY_BRACE_P (subblocks
) = 1;
779 current_binding_level
->blocks
780 = block_chainon (current_binding_level
->blocks
, block
);
782 /* If we did not make a block for the level just exited,
783 any blocks made for inner levels
784 (since they cannot be recorded as subblocks in that level)
785 must be carried forward so they will later become subblocks
786 of something else. */
788 current_binding_level
->blocks
789 = block_chainon (current_binding_level
->blocks
, subblocks
);
791 /* Each and every BLOCK node created here in `poplevel' is important
792 (e.g. for proper debugging information) so if we created one
793 earlier, mark it as "used". */
795 TREE_USED (block
) = 1;
797 /* All temporary bindings created for cleanups are popped silently. */
798 if (kind
== sk_cleanup
)
801 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
805 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
806 /* Diagnose odr-used extern inline variables without definitions
807 in the current TU. */
810 wrapup_namespace_globals ()
812 if (vec
<tree
, va_gc
> *statics
= static_decls
)
816 FOR_EACH_VEC_ELT (*statics
, i
, decl
)
818 if (warn_unused_function
819 && TREE_CODE (decl
) == FUNCTION_DECL
820 && DECL_INITIAL (decl
) == 0
821 && DECL_EXTERNAL (decl
)
822 && !TREE_PUBLIC (decl
)
823 && !DECL_ARTIFICIAL (decl
)
824 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl
)
825 && !TREE_NO_WARNING (decl
))
826 warning_at (DECL_SOURCE_LOCATION (decl
),
827 OPT_Wunused_function
,
828 "%qF declared %<static%> but never defined", decl
);
831 && DECL_EXTERNAL (decl
)
832 && DECL_INLINE_VAR_P (decl
)
833 && DECL_ODR_USED (decl
))
834 error_at (DECL_SOURCE_LOCATION (decl
),
835 "odr-used inline variable %qD is not defined", decl
);
838 /* Clear out the list, so we don't rescan next time. */
841 /* Write out any globals that need to be output. */
842 return wrapup_global_declarations (statics
->address (),
848 /* In C++, you don't have to write `struct S' to refer to `S'; you
849 can just use `S'. We accomplish this by creating a TYPE_DECL as
850 if the user had written `typedef struct S S'. Create and return
851 the TYPE_DECL for TYPE. */
854 create_implicit_typedef (tree name
, tree type
)
858 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
859 DECL_ARTIFICIAL (decl
) = 1;
860 /* There are other implicit type declarations, like the one *within*
861 a class that allows you to write `S::S'. We must distinguish
863 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
864 TYPE_NAME (type
) = decl
;
865 TYPE_STUB_DECL (type
) = decl
;
870 /* Function-scope local entities that need discriminators. Each entry
871 is a {decl,name} pair. VAR_DECLs for anon unions get their name
872 smashed, so we cannot rely on DECL_NAME. */
874 static GTY((deletable
)) vec
<tree
, va_gc
> *local_entities
;
876 /* Determine the mangling discriminator of local DECL. There are
877 generally very few of these in any particular function. */
880 determine_local_discriminator (tree decl
)
882 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
883 retrofit_lang_decl (decl
);
884 tree ctx
= DECL_CONTEXT (decl
);
885 tree name
= (TREE_CODE (decl
) == TYPE_DECL
886 && TYPE_UNNAMED_P (TREE_TYPE (decl
))
887 ? NULL_TREE
: DECL_NAME (decl
));
888 size_t nelts
= vec_safe_length (local_entities
);
889 for (size_t i
= 0; i
< nelts
; i
+= 2)
891 tree
*pair
= &(*local_entities
)[i
];
894 gcc_checking_assert (d
!= decl
);
896 && TREE_CODE (decl
) == TREE_CODE (d
)
897 && ctx
== DECL_CONTEXT (d
))
899 tree disc
= integer_one_node
;
900 if (DECL_DISCRIMINATOR (d
))
901 disc
= build_int_cst (TREE_TYPE (disc
),
902 TREE_INT_CST_LOW (DECL_DISCRIMINATOR (d
)) + 1);
903 DECL_DISCRIMINATOR (decl
) = disc
;
904 /* Replace the saved decl. */
913 vec_safe_reserve (local_entities
, 2);
914 local_entities
->quick_push (decl
);
915 local_entities
->quick_push (name
);
918 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
922 /* Subroutine of duplicate_decls: return truthvalue of whether
923 or not types of these decls match.
925 For C++, we must compare the parameter list so that `int' can match
926 `int&' in a parameter position, but `int&' is not confused with
930 decls_match (tree newdecl
, tree olddecl
, bool record_versions
/* = true */)
934 if (newdecl
== olddecl
)
937 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
938 /* If the two DECLs are not even the same kind of thing, we're not
939 interested in their types. */
942 gcc_assert (DECL_P (newdecl
));
944 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
946 tree f1
= TREE_TYPE (newdecl
);
947 tree f2
= TREE_TYPE (olddecl
);
948 tree p1
= TYPE_ARG_TYPES (f1
);
949 tree p2
= TYPE_ARG_TYPES (f2
);
952 /* Specializations of different templates are different functions
953 even if they have the same type. */
954 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
955 ? DECL_TI_TEMPLATE (newdecl
)
957 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
958 ? DECL_TI_TEMPLATE (olddecl
)
963 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
964 && ! (DECL_EXTERN_C_P (newdecl
)
965 && DECL_EXTERN_C_P (olddecl
)))
968 /* A new declaration doesn't match a built-in one unless it
969 is also extern "C". */
970 if (DECL_IS_BUILTIN (olddecl
)
971 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
974 if (TREE_CODE (f1
) != TREE_CODE (f2
))
977 /* A declaration with deduced return type should use its pre-deduction
978 type for declaration matching. */
979 r2
= fndecl_declared_return_type (olddecl
);
981 if (same_type_p (TREE_TYPE (f1
), r2
))
983 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
984 && fndecl_built_in_p (olddecl
))
986 types_match
= self_promoting_args_p (p1
);
987 if (p1
== void_list_node
)
988 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
993 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
994 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
995 || comp_type_attributes (TREE_TYPE (newdecl
),
996 TREE_TYPE (olddecl
)) != 0);
1001 /* The decls dont match if they correspond to two different versions
1002 of the same function. Disallow extern "C" functions to be
1003 versions for now. */
1005 && !DECL_EXTERN_C_P (newdecl
)
1006 && !DECL_EXTERN_C_P (olddecl
)
1008 && maybe_version_functions (newdecl
, olddecl
,
1009 (!DECL_FUNCTION_VERSIONED (newdecl
)
1010 || !DECL_FUNCTION_VERSIONED (olddecl
))))
1013 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1015 tree oldres
= DECL_TEMPLATE_RESULT (olddecl
);
1016 tree newres
= DECL_TEMPLATE_RESULT (newdecl
);
1018 if (TREE_CODE (newres
) != TREE_CODE (oldres
))
1021 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1022 DECL_TEMPLATE_PARMS (olddecl
)))
1025 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1026 types_match
= (same_type_p (TREE_TYPE (oldres
), TREE_TYPE (newres
))
1027 && equivalently_constrained (olddecl
, newdecl
));
1029 // We don't need to check equivalently_constrained for variable and
1030 // function templates because we check it on the results.
1031 types_match
= decls_match (oldres
, newres
);
1035 /* Need to check scope for variable declaration (VAR_DECL).
1036 For typedef (TYPE_DECL), scope is ignored. */
1038 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1040 Two declarations for an object with C language linkage
1041 with the same name (ignoring the namespace that qualify
1042 it) that appear in different namespace scopes refer to
1044 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1047 if (TREE_TYPE (newdecl
) == error_mark_node
)
1048 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1049 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1050 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1051 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1054 types_match
= comptypes (TREE_TYPE (newdecl
),
1055 TREE_TYPE (olddecl
),
1056 COMPARE_REDECLARATION
);
1059 // Normal functions can be constrained, as can variable partial
1061 if (types_match
&& VAR_OR_FUNCTION_DECL_P (newdecl
))
1062 types_match
= equivalently_constrained (newdecl
, olddecl
);
1067 /* NEWDECL and OLDDECL have identical signatures. If they are
1068 different versions adjust them and return true.
1069 If RECORD is set to true, record function versions. */
1072 maybe_version_functions (tree newdecl
, tree olddecl
, bool record
)
1074 if (!targetm
.target_option
.function_versions (newdecl
, olddecl
))
1077 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1079 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1080 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1081 mangle_decl (olddecl
);
1084 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1086 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1087 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1088 mangle_decl (newdecl
);
1092 cgraph_node::record_function_versions (olddecl
, newdecl
);
1097 /* If NEWDECL is `static' and an `extern' was seen previously,
1098 warn about it. OLDDECL is the previous declaration.
1100 Note that this does not apply to the C++ case of declaring
1101 a variable `extern const' and then later `const'.
1103 Don't complain about built-in functions, since they are beyond
1104 the user's control. */
1107 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1109 if (TREE_CODE (newdecl
) == TYPE_DECL
1110 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1111 || TREE_CODE (newdecl
) == CONST_DECL
1112 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1115 /* Don't get confused by static member functions; that's a different
1117 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1118 && DECL_STATIC_FUNCTION_P (newdecl
))
1121 /* If the old declaration was `static', or the new one isn't, then
1122 everything is OK. */
1123 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1126 /* It's OK to declare a builtin function as `static'. */
1127 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1128 && DECL_ARTIFICIAL (olddecl
))
1131 auto_diagnostic_group d
;
1132 if (permerror (DECL_SOURCE_LOCATION (newdecl
),
1133 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1134 inform (DECL_SOURCE_LOCATION (olddecl
),
1135 "previous declaration of %qD", olddecl
);
1138 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1139 function templates. If their exception specifications do not
1140 match, issue a diagnostic. */
1143 check_redeclaration_exception_specification (tree new_decl
,
1146 tree new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1147 tree old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1149 /* Two default specs are equivalent, don't force evaluation. */
1150 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions
)
1151 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions
))
1154 if (!type_dependent_expression_p (old_decl
))
1156 maybe_instantiate_noexcept (new_decl
);
1157 maybe_instantiate_noexcept (old_decl
);
1159 new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1160 old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1164 If any declaration of a function has an exception-specification,
1165 all declarations, including the definition and an explicit
1166 specialization, of that function shall have an
1167 exception-specification with the same set of type-ids. */
1168 if (! DECL_IS_BUILTIN (old_decl
)
1169 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1171 const char *const msg
1172 = G_("declaration of %qF has a different exception specifier");
1173 bool complained
= true;
1174 location_t new_loc
= DECL_SOURCE_LOCATION (new_decl
);
1175 auto_diagnostic_group d
;
1176 if (DECL_IN_SYSTEM_HEADER (old_decl
))
1177 complained
= pedwarn (new_loc
, OPT_Wsystem_headers
, msg
, new_decl
);
1178 else if (!flag_exceptions
)
1179 /* We used to silently permit mismatched eh specs with
1180 -fno-exceptions, so make them a pedwarn now. */
1181 complained
= pedwarn (new_loc
, OPT_Wpedantic
, msg
, new_decl
);
1183 error_at (new_loc
, msg
, new_decl
);
1185 inform (DECL_SOURCE_LOCATION (old_decl
),
1186 "from previous declaration %qF", old_decl
);
1190 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1191 Otherwise issue diagnostics. */
1194 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1196 old_decl
= STRIP_TEMPLATE (old_decl
);
1197 new_decl
= STRIP_TEMPLATE (new_decl
);
1198 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1199 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1201 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1202 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1204 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1206 if (fndecl_built_in_p (old_decl
))
1208 /* Hide a built-in declaration. */
1209 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1210 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1213 /* 7.1.5 [dcl.constexpr]
1214 Note: An explicit specialization can differ from the template
1215 declaration with respect to the constexpr specifier. */
1216 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1217 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1220 error_at (DECL_SOURCE_LOCATION (new_decl
),
1221 "redeclaration %qD differs in %<constexpr%> "
1222 "from previous declaration", new_decl
);
1223 inform (DECL_SOURCE_LOCATION (old_decl
),
1224 "previous declaration %qD", old_decl
);
1230 // If OLDDECL and NEWDECL are concept declarations with the same type
1231 // (i.e., and template parameters), but different requirements,
1232 // emit diagnostics and return true. Otherwise, return false.
1234 check_concept_refinement (tree olddecl
, tree newdecl
)
1236 if (!DECL_DECLARED_CONCEPT_P (olddecl
) || !DECL_DECLARED_CONCEPT_P (newdecl
))
1239 tree d1
= DECL_TEMPLATE_RESULT (olddecl
);
1240 tree d2
= DECL_TEMPLATE_RESULT (newdecl
);
1241 if (TREE_CODE (d1
) != TREE_CODE (d2
))
1244 tree t1
= TREE_TYPE (d1
);
1245 tree t2
= TREE_TYPE (d2
);
1246 if (TREE_CODE (d1
) == FUNCTION_DECL
)
1248 if (compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
))
1249 && comp_template_parms (DECL_TEMPLATE_PARMS (olddecl
),
1250 DECL_TEMPLATE_PARMS (newdecl
))
1251 && !equivalently_constrained (olddecl
, newdecl
))
1253 error ("cannot specialize concept %q#D", olddecl
);
1260 /* DECL is a redeclaration of a function or function template. If
1261 it does have default arguments issue a diagnostic. Note: this
1262 function is used to enforce the requirements in C++11 8.3.6 about
1263 no default arguments in redeclarations. */
1266 check_redeclaration_no_default_args (tree decl
)
1268 gcc_assert (DECL_DECLARES_FUNCTION_P (decl
));
1270 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
1271 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1272 if (TREE_PURPOSE (t
))
1274 permerror (DECL_SOURCE_LOCATION (decl
),
1275 "redeclaration of %q#D may not have default "
1281 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1282 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1283 the TEMPLATE_DECLs in case of function templates). This function is used
1284 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1285 "If a friend declaration specifies a default argument expression, that
1286 declaration shall be a definition and shall be the only declaration of
1287 the function or function template in the translation unit." */
1290 check_no_redeclaration_friend_default_args (tree olddecl
, tree newdecl
,
1291 bool olddecl_hidden_friend_p
)
1293 if (!olddecl_hidden_friend_p
&& !DECL_FRIEND_P (newdecl
))
1296 tree t1
= FUNCTION_FIRST_USER_PARMTYPE (olddecl
);
1297 tree t2
= FUNCTION_FIRST_USER_PARMTYPE (newdecl
);
1299 for (; t1
&& t1
!= void_list_node
;
1300 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1301 if ((olddecl_hidden_friend_p
&& TREE_PURPOSE (t1
))
1302 || (DECL_FRIEND_P (newdecl
) && TREE_PURPOSE (t2
)))
1304 auto_diagnostic_group d
;
1305 if (permerror (DECL_SOURCE_LOCATION (newdecl
),
1306 "friend declaration of %q#D specifies default "
1307 "arguments and isn%'t the only declaration", newdecl
))
1308 inform (DECL_SOURCE_LOCATION (olddecl
),
1309 "previous declaration of %q#D", olddecl
);
1314 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1315 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1318 merge_attribute_bits (tree newdecl
, tree olddecl
)
1320 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1321 TREE_THIS_VOLATILE (olddecl
) |= TREE_THIS_VOLATILE (newdecl
);
1322 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
1323 TREE_NOTHROW (olddecl
) |= TREE_NOTHROW (newdecl
);
1324 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
1325 TREE_READONLY (olddecl
) |= TREE_READONLY (newdecl
);
1326 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1327 DECL_IS_MALLOC (olddecl
) |= DECL_IS_MALLOC (newdecl
);
1328 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
1329 DECL_PURE_P (olddecl
) |= DECL_PURE_P (newdecl
);
1330 DECL_UNINLINABLE (newdecl
) |= DECL_UNINLINABLE (olddecl
);
1331 DECL_UNINLINABLE (olddecl
) |= DECL_UNINLINABLE (newdecl
);
1334 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1335 && lookup_attribute ("gnu_inline", \
1336 DECL_ATTRIBUTES (fn)))
1338 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1339 If the redeclaration is invalid, a diagnostic is issued, and the
1340 error_mark_node is returned. Otherwise, OLDDECL is returned.
1342 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1345 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1348 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1350 unsigned olddecl_uid
= DECL_UID (olddecl
);
1351 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1352 int olddecl_hidden_friend
= 0;
1353 int new_defines_function
= 0;
1354 tree new_template_info
;
1355 location_t olddecl_loc
= DECL_SOURCE_LOCATION (olddecl
);
1356 location_t newdecl_loc
= DECL_SOURCE_LOCATION (newdecl
);
1358 if (newdecl
== olddecl
)
1361 types_match
= decls_match (newdecl
, olddecl
);
1363 /* If either the type of the new decl or the type of the old decl is an
1364 error_mark_node, then that implies that we have already issued an
1365 error (earlier) for some bogus type specification, and in that case,
1366 it is rather pointless to harass the user with yet more error message
1367 about the same declaration, so just pretend the types match here. */
1368 if (TREE_TYPE (newdecl
) == error_mark_node
1369 || TREE_TYPE (olddecl
) == error_mark_node
)
1370 return error_mark_node
;
1372 /* Check for redeclaration and other discrepancies. */
1373 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1374 && DECL_ARTIFICIAL (olddecl
))
1376 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1377 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1379 /* Avoid warnings redeclaring built-ins which have not been
1380 explicitly declared. */
1381 if (DECL_ANTICIPATED (olddecl
))
1383 if (TREE_PUBLIC (newdecl
)
1384 && CP_DECL_CONTEXT (newdecl
) == global_namespace
)
1385 warning_at (newdecl_loc
,
1386 OPT_Wbuiltin_declaration_mismatch
,
1387 "built-in function %qD declared as non-function",
1392 /* If you declare a built-in or predefined function name as static,
1393 the old definition is overridden, but optionally warn this was a
1394 bad choice of name. */
1395 if (! TREE_PUBLIC (newdecl
))
1397 warning_at (newdecl_loc
,
1399 fndecl_built_in_p (olddecl
)
1400 ? G_("shadowing built-in function %q#D")
1401 : G_("shadowing library function %q#D"), olddecl
);
1402 /* Discard the old built-in function. */
1405 /* If the built-in is not ansi, then programs can override
1406 it even globally without an error. */
1407 else if (! fndecl_built_in_p (olddecl
))
1408 warning_at (newdecl_loc
, 0,
1409 "library function %q#D redeclared as non-function %q#D",
1412 error_at (newdecl_loc
,
1413 "declaration of %q#D conflicts with built-in "
1414 "declaration %q#D", newdecl
, olddecl
);
1417 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1419 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1420 error_at (newdecl_loc
,
1421 "redeclaration of %<pragma omp declare reduction%>");
1422 inform (olddecl_loc
,
1423 "previous %<pragma omp declare reduction%> declaration");
1424 return error_mark_node
;
1426 else if (!types_match
)
1428 /* Avoid warnings redeclaring built-ins which have not been
1429 explicitly declared. */
1430 if (DECL_ANTICIPATED (olddecl
))
1434 /* A new declaration doesn't match a built-in one unless it
1435 is also extern "C". */
1436 gcc_assert (DECL_IS_BUILTIN (olddecl
));
1437 gcc_assert (DECL_EXTERN_C_P (olddecl
));
1438 if (!DECL_EXTERN_C_P (newdecl
))
1441 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1442 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1444 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1448 /* FILE, tm types are not known at the time
1449 we create the builtins. */
1450 for (unsigned i
= 0;
1451 i
< sizeof (builtin_structptr_types
)
1452 / sizeof (builtin_structptr_type
);
1454 if (TREE_VALUE (t2
) == builtin_structptr_types
[i
].node
)
1456 tree t
= TREE_VALUE (t1
);
1459 && TYPE_IDENTIFIER (TREE_TYPE (t
))
1460 == get_identifier (builtin_structptr_types
[i
].str
)
1461 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1463 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1465 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1466 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1467 types_match
= decls_match (newdecl
, olddecl
);
1469 return duplicate_decls (newdecl
, olddecl
,
1471 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1476 if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1481 warning_at (newdecl_loc
,
1482 OPT_Wbuiltin_declaration_mismatch
,
1483 "declaration of %q#D conflicts with built-in "
1484 "declaration %q#D", newdecl
, olddecl
);
1486 else if ((DECL_EXTERN_C_P (newdecl
)
1487 && DECL_EXTERN_C_P (olddecl
))
1488 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1489 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1491 /* Don't really override olddecl for __* prefixed builtins
1492 except for __[^b]*_chk, the compiler might be using those
1494 if (fndecl_built_in_p (olddecl
))
1496 tree id
= DECL_NAME (olddecl
);
1497 const char *name
= IDENTIFIER_POINTER (id
);
1502 && (strncmp (name
+ 2, "builtin_",
1503 strlen ("builtin_")) == 0
1504 || (len
= strlen (name
)) <= strlen ("___chk")
1505 || memcmp (name
+ len
- strlen ("_chk"),
1506 "_chk", strlen ("_chk") + 1) != 0))
1508 if (DECL_INITIAL (newdecl
))
1510 error_at (newdecl_loc
,
1511 "definition of %q#D ambiguates built-in "
1512 "declaration %q#D", newdecl
, olddecl
);
1513 return error_mark_node
;
1515 auto_diagnostic_group d
;
1516 if (permerror (newdecl_loc
,
1517 "new declaration %q#D ambiguates built-in"
1518 " declaration %q#D", newdecl
, olddecl
)
1520 inform (newdecl_loc
,
1521 "ignoring the %q#D declaration", newdecl
);
1522 return flag_permissive
? olddecl
: error_mark_node
;
1526 /* A near match; override the builtin. */
1528 if (TREE_PUBLIC (newdecl
))
1529 warning_at (newdecl_loc
,
1530 OPT_Wbuiltin_declaration_mismatch
,
1531 "new declaration %q#D ambiguates built-in "
1532 "declaration %q#D", newdecl
, olddecl
);
1534 warning (OPT_Wshadow
,
1535 fndecl_built_in_p (olddecl
)
1536 ? G_("shadowing built-in function %q#D")
1537 : G_("shadowing library function %q#D"), olddecl
);
1540 /* Discard the old built-in function. */
1543 /* Replace the old RTL to avoid problems with inlining. */
1544 COPY_DECL_RTL (newdecl
, olddecl
);
1546 /* Even if the types match, prefer the new declarations type for
1547 built-ins which have not been explicitly declared, for
1548 exception lists, etc... */
1549 else if (DECL_IS_BUILTIN (olddecl
))
1551 tree type
= TREE_TYPE (newdecl
);
1552 tree attribs
= (*targetm
.merge_type_attributes
)
1553 (TREE_TYPE (olddecl
), type
);
1555 type
= cp_build_type_attribute_variant (type
, attribs
);
1556 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1559 /* If a function is explicitly declared "throw ()", propagate that to
1560 the corresponding builtin. */
1561 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1562 && DECL_ANTICIPATED (olddecl
)
1563 && TREE_NOTHROW (newdecl
)
1564 && !TREE_NOTHROW (olddecl
))
1566 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1567 tree tmpdecl
= builtin_decl_explicit (fncode
);
1568 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1569 TREE_NOTHROW (tmpdecl
) = 1;
1572 /* Whether or not the builtin can throw exceptions has no
1573 bearing on this declarator. */
1574 TREE_NOTHROW (olddecl
) = 0;
1576 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1578 /* If a builtin function is redeclared as `static', merge
1579 the declarations, but make the original one static. */
1580 DECL_THIS_STATIC (olddecl
) = 1;
1581 TREE_PUBLIC (olddecl
) = 0;
1583 /* Make the old declaration consistent with the new one so
1584 that all remnants of the builtin-ness of this function
1585 will be banished. */
1586 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1587 COPY_DECL_RTL (newdecl
, olddecl
);
1590 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1592 /* C++ Standard, 3.3, clause 4:
1593 "[Note: a namespace name or a class template name must be unique
1594 in its declarative region (7.3.2, clause 14). ]" */
1595 if (TREE_CODE (olddecl
) == NAMESPACE_DECL
1596 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1597 /* Namespace conflicts with not namespace. */;
1598 else if (DECL_TYPE_TEMPLATE_P (olddecl
)
1599 || DECL_TYPE_TEMPLATE_P (newdecl
))
1600 /* Class template conflicts. */;
1601 else if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1602 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1603 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1604 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1606 /* One is a function and the other is a template
1608 if (!UDLIT_OPER_P (DECL_NAME (newdecl
)))
1611 /* There can only be one! */
1612 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1613 && check_raw_literal_operator (olddecl
))
1614 error_at (newdecl_loc
,
1615 "literal operator %q#D conflicts with"
1616 " raw literal operator", newdecl
);
1617 else if (check_raw_literal_operator (newdecl
))
1618 error_at (newdecl_loc
,
1619 "raw literal operator %q#D conflicts with"
1620 " literal operator template", newdecl
);
1624 inform (olddecl_loc
, "previous declaration %q#D", olddecl
);
1625 return error_mark_node
;
1627 else if (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1628 || DECL_IMPLICIT_TYPEDEF_P (newdecl
))
1629 /* One is an implicit typedef, that's ok. */
1632 error ("%q#D redeclared as different kind of entity", newdecl
);
1633 inform (olddecl_loc
, "previous declaration %q#D", olddecl
);
1635 return error_mark_node
;
1637 else if (!types_match
)
1639 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1640 /* These are certainly not duplicate declarations; they're
1641 from different scopes. */
1644 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1646 /* The name of a class template may not be declared to refer to
1647 any other template, class, function, object, namespace, value,
1648 or type in the same scope. */
1649 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1650 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1652 error_at (newdecl_loc
,
1653 "conflicting declaration of template %q#D", newdecl
);
1654 inform (olddecl_loc
,
1655 "previous declaration %q#D", olddecl
);
1656 return error_mark_node
;
1658 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1659 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1660 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1661 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1662 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1663 DECL_TEMPLATE_PARMS (olddecl
))
1664 /* Template functions can be disambiguated by
1666 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1667 TREE_TYPE (TREE_TYPE (olddecl
)))
1668 /* Template functions can also be disambiguated by
1670 && equivalently_constrained (olddecl
, newdecl
))
1672 error_at (newdecl_loc
, "ambiguating new declaration %q#D",
1674 inform (olddecl_loc
,
1675 "old declaration %q#D", olddecl
);
1677 else if (check_concept_refinement (olddecl
, newdecl
))
1678 return error_mark_node
;
1681 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1683 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1685 error_at (newdecl_loc
,
1686 "conflicting declaration of C function %q#D",
1688 inform (olddecl_loc
,
1689 "previous declaration %q#D", olddecl
);
1692 /* For function versions, params and types match, but they
1693 are not ambiguous. */
1694 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1695 && !DECL_FUNCTION_VERSIONED (olddecl
))
1696 // The functions have the same parameter types.
1697 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1698 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)))
1699 // And the same constraints.
1700 && equivalently_constrained (newdecl
, olddecl
))
1702 error_at (newdecl_loc
,
1703 "ambiguating new declaration of %q#D", newdecl
);
1704 inform (olddecl_loc
,
1705 "old declaration %q#D", olddecl
);
1706 return error_mark_node
;
1713 error_at (newdecl_loc
, "conflicting declaration %q#D", newdecl
);
1714 inform (olddecl_loc
,
1715 "previous declaration as %q#D", olddecl
);
1716 return error_mark_node
;
1719 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1720 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1721 && (!DECL_TEMPLATE_INFO (newdecl
)
1722 || (DECL_TI_TEMPLATE (newdecl
)
1723 != DECL_TI_TEMPLATE (olddecl
))))
1724 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1725 && (!DECL_TEMPLATE_INFO (olddecl
)
1726 || (DECL_TI_TEMPLATE (olddecl
)
1727 != DECL_TI_TEMPLATE (newdecl
))))))
1728 /* It's OK to have a template specialization and a non-template
1729 with the same type, or to have specializations of two
1730 different templates with the same type. Note that if one is a
1731 specialization, and the other is an instantiation of the same
1732 template, that we do not exit at this point. That situation
1733 can occur if we instantiate a template class, and then
1734 specialize one of its methods. This situation is valid, but
1735 the declarations must be merged in the usual way. */
1737 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1738 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1739 && !DECL_USE_TEMPLATE (newdecl
))
1740 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1741 && !DECL_USE_TEMPLATE (olddecl
))))
1742 /* One of the declarations is a template instantiation, and the
1743 other is not a template at all. That's OK. */
1745 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1747 /* In [namespace.alias] we have:
1749 In a declarative region, a namespace-alias-definition can be
1750 used to redefine a namespace-alias declared in that declarative
1751 region to refer only to the namespace to which it already
1754 Therefore, if we encounter a second alias directive for the same
1755 alias, we can just ignore the second directive. */
1756 if (DECL_NAMESPACE_ALIAS (newdecl
)
1757 && (DECL_NAMESPACE_ALIAS (newdecl
)
1758 == DECL_NAMESPACE_ALIAS (olddecl
)))
1761 /* Leave it to update_binding to merge or report error. */
1766 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1769 auto_diagnostic_group d
;
1770 error_at (newdecl_loc
, errmsg
, newdecl
);
1771 if (DECL_NAME (olddecl
) != NULL_TREE
)
1772 inform (olddecl_loc
,
1773 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1774 ? G_("%q#D previously defined here")
1775 : G_("%q#D previously declared here"), olddecl
);
1776 return error_mark_node
;
1778 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1779 && DECL_INITIAL (olddecl
) != NULL_TREE
1780 && !prototype_p (TREE_TYPE (olddecl
))
1781 && prototype_p (TREE_TYPE (newdecl
)))
1783 /* Prototype decl follows defn w/o prototype. */
1784 auto_diagnostic_group d
;
1785 if (warning_at (newdecl_loc
, 0,
1786 "prototype specified for %q#D", newdecl
))
1787 inform (olddecl_loc
,
1788 "previous non-prototype definition here");
1790 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1791 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1794 If two declarations of the same function or object
1795 specify different linkage-specifications ..., the program
1796 is ill-formed.... Except for functions with C++ linkage,
1797 a function declaration without a linkage specification
1798 shall not precede the first linkage specification for
1799 that function. A function can be declared without a
1800 linkage specification after an explicit linkage
1801 specification has been seen; the linkage explicitly
1802 specified in the earlier declaration is not affected by
1803 such a function declaration.
1805 DR 563 raises the question why the restrictions on
1806 functions should not also apply to objects. Older
1807 versions of G++ silently ignore the linkage-specification
1815 which is clearly wrong. Therefore, we now treat objects
1817 if (current_lang_depth () == 0)
1819 /* There is no explicit linkage-specification, so we use
1820 the linkage from the previous declaration. */
1821 retrofit_lang_decl (newdecl
);
1822 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1826 auto_diagnostic_group d
;
1827 error_at (newdecl_loc
,
1828 "conflicting declaration of %q#D with %qL linkage",
1829 newdecl
, DECL_LANGUAGE (newdecl
));
1830 inform (olddecl_loc
,
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 (simple_cst_equal (TREE_PURPOSE (t1
),
1862 TREE_PURPOSE (t2
)) == 1)
1864 auto_diagnostic_group d
;
1865 if (permerror (newdecl_loc
,
1866 "default argument given for parameter "
1867 "%d of %q#D", i
, newdecl
))
1868 inform (olddecl_loc
,
1869 "previous specification in %q#D here",
1874 auto_diagnostic_group d
;
1875 error_at (newdecl_loc
,
1876 "default argument given for parameter %d "
1877 "of %q#D", i
, newdecl
);
1878 inform (olddecl_loc
,
1879 "previous specification in %q#D here",
1884 /* C++17 11.3.6/4: "If a friend declaration specifies a default
1885 argument expression, that declaration... shall be the only
1886 declaration of the function or function template in the
1887 translation unit." */
1888 check_no_redeclaration_friend_default_args
1889 (olddecl
, newdecl
, DECL_HIDDEN_FRIEND_P (olddecl
));
1894 /* Do not merge an implicit typedef with an explicit one. In:
1898 typedef class A A __attribute__ ((foo));
1900 the attribute should apply only to the typedef. */
1901 if (TREE_CODE (olddecl
) == TYPE_DECL
1902 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1903 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1906 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1907 return error_mark_node
;
1909 /* We have committed to returning OLDDECL at this point. */
1911 /* If new decl is `static' and an `extern' was seen previously,
1913 warn_extern_redeclared_static (newdecl
, olddecl
);
1915 /* True to merge attributes between the declarations, false to
1916 set OLDDECL's attributes to those of NEWDECL (for template
1917 explicit specializations that specify their own attributes
1918 independent of those specified for the primary template). */
1919 const bool merge_attr
= (TREE_CODE (newdecl
) != FUNCTION_DECL
1920 || !DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1921 || DECL_TEMPLATE_SPECIALIZATION (olddecl
));
1923 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1925 if (merge_attr
&& diagnose_mismatched_attributes (olddecl
, newdecl
))
1926 inform (olddecl_loc
, DECL_INITIAL (olddecl
)
1927 ? G_("previous definition of %qD here")
1928 : G_("previous declaration of %qD here"), olddecl
);
1930 /* Now that functions must hold information normally held
1931 by field decls, there is extra work to do so that
1932 declaration information does not get destroyed during
1934 if (DECL_VINDEX (olddecl
))
1935 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1936 if (DECL_CONTEXT (olddecl
))
1937 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1938 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1939 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1940 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1941 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1942 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1943 DECL_FINAL_P (newdecl
) |= DECL_FINAL_P (olddecl
);
1944 DECL_OVERRIDE_P (newdecl
) |= DECL_OVERRIDE_P (olddecl
);
1945 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1946 if (DECL_OVERLOADED_OPERATOR_P (olddecl
))
1947 DECL_OVERLOADED_OPERATOR_CODE_RAW (newdecl
)
1948 = DECL_OVERLOADED_OPERATOR_CODE_RAW (olddecl
);
1949 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1951 /* Optionally warn about more than one declaration for the same
1952 name, but don't warn about a function declaration followed by a
1954 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1955 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1956 /* Don't warn about extern decl followed by definition. */
1957 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1958 /* Don't warn about friends, let add_friend take care of it. */
1959 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1960 /* Don't warn about declaration followed by specialization. */
1961 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1962 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1964 auto_diagnostic_group d
;
1965 if (warning_at (newdecl_loc
,
1966 OPT_Wredundant_decls
,
1967 "redundant redeclaration of %qD in same scope",
1969 inform (olddecl_loc
,
1970 "previous declaration of %qD", olddecl
);
1973 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1974 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1976 if (DECL_DELETED_FN (newdecl
))
1978 auto_diagnostic_group d
;
1979 error_at (newdecl_loc
, "deleted definition of %qD", newdecl
);
1980 inform (olddecl_loc
,
1981 "previous declaration of %qD", olddecl
);
1983 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1987 /* Deal with C++: must preserve virtual function table size. */
1988 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1990 tree newtype
= TREE_TYPE (newdecl
);
1991 tree oldtype
= TREE_TYPE (olddecl
);
1993 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1994 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1995 CLASSTYPE_FRIEND_CLASSES (newtype
)
1996 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1998 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
2001 /* Copy all the DECL_... slots specified in the new decl except for
2002 any that we copy here from the old type. */
2004 DECL_ATTRIBUTES (newdecl
)
2005 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
2007 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2009 if (DECL_DECLARES_FUNCTION_P (olddecl
))
2011 olddecl_friend
= DECL_FRIEND_P (olddecl
);
2012 olddecl_hidden_friend
= DECL_HIDDEN_FRIEND_P (olddecl
);
2013 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
2014 && DECL_HIDDEN_FRIEND_P (olddecl
)
2015 && newdecl_is_friend
);
2018 DECL_ANTICIPATED (olddecl
) = 0;
2019 DECL_HIDDEN_FRIEND_P (olddecl
) = 0;
2023 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2025 tree old_result
= DECL_TEMPLATE_RESULT (olddecl
);
2026 tree new_result
= DECL_TEMPLATE_RESULT (newdecl
);
2027 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
2029 /* The new decl should not already have gathered any
2031 gcc_assert (!DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
2033 DECL_ATTRIBUTES (old_result
)
2034 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
2036 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
2038 if (DECL_SOURCE_LOCATION (newdecl
)
2039 != DECL_SOURCE_LOCATION (olddecl
))
2041 /* Per C++11 8.3.6/4, default arguments cannot be added in
2042 later declarations of a function template. */
2043 check_redeclaration_no_default_args (newdecl
);
2044 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2045 argument expression, that declaration... shall be the only
2046 declaration of the function or function template in the
2047 translation unit." */
2048 check_no_redeclaration_friend_default_args
2049 (old_result
, new_result
, olddecl_hidden_friend
);
2052 check_default_args (newdecl
);
2054 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
2055 && DECL_INITIAL (new_result
))
2057 if (DECL_INITIAL (old_result
))
2058 DECL_UNINLINABLE (old_result
) = 1;
2060 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
2061 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
2062 DECL_NOT_REALLY_EXTERN (old_result
)
2063 = DECL_NOT_REALLY_EXTERN (new_result
);
2064 DECL_INTERFACE_KNOWN (old_result
)
2065 = DECL_INTERFACE_KNOWN (new_result
);
2066 DECL_DECLARED_INLINE_P (old_result
)
2067 = DECL_DECLARED_INLINE_P (new_result
);
2068 DECL_DISREGARD_INLINE_LIMITS (old_result
)
2069 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
2074 DECL_DECLARED_INLINE_P (old_result
)
2075 |= DECL_DECLARED_INLINE_P (new_result
);
2076 DECL_DISREGARD_INLINE_LIMITS (old_result
)
2077 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
2078 check_redeclaration_exception_specification (newdecl
, olddecl
);
2080 merge_attribute_bits (new_result
, old_result
);
2084 /* If the new declaration is a definition, update the file and
2085 line information on the declaration, and also make
2086 the old declaration the same definition. */
2087 if (DECL_INITIAL (new_result
) != NULL_TREE
)
2089 DECL_SOURCE_LOCATION (olddecl
)
2090 = DECL_SOURCE_LOCATION (old_result
)
2091 = DECL_SOURCE_LOCATION (newdecl
);
2092 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
2093 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
2096 DECL_ARGUMENTS (old_result
)
2097 = DECL_ARGUMENTS (new_result
);
2098 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
2099 parm
= DECL_CHAIN (parm
))
2100 DECL_CONTEXT (parm
) = old_result
;
2109 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2110 check_redeclaration_exception_specification (newdecl
, olddecl
);
2112 /* Automatically handles default parameters. */
2113 tree oldtype
= TREE_TYPE (olddecl
);
2116 /* For typedefs use the old type, as the new type's DECL_NAME points
2117 at newdecl, which will be ggc_freed. */
2118 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2120 /* But NEWTYPE might have an attribute, honor that. */
2121 tree tem
= TREE_TYPE (newdecl
);
2124 if (TYPE_USER_ALIGN (tem
))
2126 if (TYPE_ALIGN (tem
) > TYPE_ALIGN (newtype
))
2127 SET_TYPE_ALIGN (newtype
, TYPE_ALIGN (tem
));
2128 TYPE_USER_ALIGN (newtype
) = true;
2131 /* And remove the new type from the variants list. */
2132 if (TYPE_NAME (TREE_TYPE (newdecl
)) == newdecl
)
2134 tree remove
= TREE_TYPE (newdecl
);
2135 if (TYPE_MAIN_VARIANT (remove
) == remove
)
2137 gcc_assert (TYPE_NEXT_VARIANT (remove
) == NULL_TREE
);
2138 /* If remove is the main variant, no need to remove that
2139 from the list. One of the DECL_ORIGINAL_TYPE
2140 variants, e.g. created for aligned attribute, might still
2141 refer to the newdecl TYPE_DECL though, so remove that one
2143 if (tree orig
= DECL_ORIGINAL_TYPE (newdecl
))
2145 for (tree t
= TYPE_MAIN_VARIANT (orig
); t
;
2146 t
= TYPE_MAIN_VARIANT (t
))
2147 if (TYPE_NAME (TYPE_NEXT_VARIANT (t
)) == newdecl
)
2149 TYPE_NEXT_VARIANT (t
)
2150 = TYPE_NEXT_VARIANT (TYPE_NEXT_VARIANT (t
));
2155 for (tree t
= TYPE_MAIN_VARIANT (remove
); ;
2156 t
= TYPE_NEXT_VARIANT (t
))
2157 if (TYPE_NEXT_VARIANT (t
) == remove
)
2159 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (remove
);
2164 else if (merge_attr
)
2165 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
2167 newtype
= TREE_TYPE (newdecl
);
2169 if (VAR_P (newdecl
))
2171 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
2172 /* For already initialized vars, TREE_READONLY could have been
2173 cleared in cp_finish_decl, because the var needs runtime
2174 initialization or destruction. Make sure not to set
2175 TREE_READONLY on it again. */
2176 if (DECL_INITIALIZED_P (olddecl
)
2177 && !DECL_EXTERNAL (olddecl
)
2178 && !TREE_READONLY (olddecl
))
2179 TREE_READONLY (newdecl
) = 0;
2180 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
2181 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
2182 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
2183 if (DECL_DEPENDENT_INIT_P (olddecl
))
2184 SET_DECL_DEPENDENT_INIT_P (newdecl
, true);
2185 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
2186 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
2187 if (DECL_CLASS_SCOPE_P (olddecl
))
2188 DECL_DECLARED_CONSTEXPR_P (newdecl
)
2189 |= DECL_DECLARED_CONSTEXPR_P (olddecl
);
2191 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2192 if (DECL_LANG_SPECIFIC (olddecl
)
2193 && CP_DECL_THREADPRIVATE_P (olddecl
))
2195 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2196 retrofit_lang_decl (newdecl
);
2197 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
2201 /* An explicit specialization of a function template or of a member
2202 function of a class template can be declared transaction_safe
2203 independently of whether the corresponding template entity is declared
2204 transaction_safe. */
2205 if (flag_tm
&& TREE_CODE (newdecl
) == FUNCTION_DECL
2206 && DECL_TEMPLATE_INSTANTIATION (olddecl
)
2207 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2208 && tx_safe_fn_type_p (newtype
)
2209 && !tx_safe_fn_type_p (TREE_TYPE (newdecl
)))
2210 newtype
= tx_unsafe_fn_variant (newtype
);
2212 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
2214 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2215 check_default_args (newdecl
);
2217 /* Lay the type out, unless already done. */
2218 if (! same_type_p (newtype
, oldtype
)
2219 && TREE_TYPE (newdecl
) != error_mark_node
2220 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2221 layout_type (TREE_TYPE (newdecl
));
2223 if ((VAR_P (newdecl
)
2224 || TREE_CODE (newdecl
) == PARM_DECL
2225 || TREE_CODE (newdecl
) == RESULT_DECL
2226 || TREE_CODE (newdecl
) == FIELD_DECL
2227 || TREE_CODE (newdecl
) == TYPE_DECL
)
2228 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2229 layout_decl (newdecl
, 0);
2231 /* Merge deprecatedness. */
2232 if (TREE_DEPRECATED (newdecl
))
2233 TREE_DEPRECATED (olddecl
) = 1;
2235 /* Preserve function specific target and optimization options */
2236 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2238 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2239 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2240 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2241 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2243 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2244 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2245 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2246 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2250 /* Merge the const type qualifier. */
2251 if (TREE_READONLY (newdecl
))
2252 TREE_READONLY (olddecl
) = 1;
2253 /* Merge the volatile type qualifier. */
2254 if (TREE_THIS_VOLATILE (newdecl
))
2255 TREE_THIS_VOLATILE (olddecl
) = 1;
2258 /* Merge the initialization information. */
2259 if (DECL_INITIAL (newdecl
) == NULL_TREE
2260 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2262 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2263 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2264 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2266 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2267 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2271 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2273 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2274 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2275 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2276 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2277 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2278 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2281 merge_attribute_bits (newdecl
, olddecl
);
2284 /* Merge the noreturn bit. */
2285 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2286 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2287 TREE_NOTHROW (olddecl
) = TREE_NOTHROW (newdecl
);
2288 DECL_IS_MALLOC (olddecl
) = DECL_IS_MALLOC (newdecl
);
2289 DECL_PURE_P (olddecl
) = DECL_PURE_P (newdecl
);
2291 /* Keep the old RTL. */
2292 COPY_DECL_RTL (olddecl
, newdecl
);
2294 else if (VAR_P (newdecl
)
2295 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2297 /* Keep the old RTL. We cannot keep the old RTL if the old
2298 declaration was for an incomplete object and the new
2299 declaration is not since many attributes of the RTL will
2301 COPY_DECL_RTL (olddecl
, newdecl
);
2304 /* If cannot merge, then use the new type and qualifiers,
2305 and don't preserve the old rtl. */
2308 /* Clean out any memory we had of the old declaration. */
2309 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2311 TREE_VALUE (oldstatic
) = error_mark_node
;
2313 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2314 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2315 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2316 TREE_NOTHROW (olddecl
) = TREE_NOTHROW (newdecl
);
2317 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2320 /* Merge the storage class information. */
2321 merge_weak (newdecl
, olddecl
);
2323 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2324 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2325 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2326 if (! DECL_EXTERNAL (olddecl
))
2327 DECL_EXTERNAL (newdecl
) = 0;
2328 if (! DECL_COMDAT (olddecl
))
2329 DECL_COMDAT (newdecl
) = 0;
2331 new_template_info
= NULL_TREE
;
2332 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2334 bool new_redefines_gnu_inline
= false;
2336 if (new_defines_function
2337 && ((DECL_INTERFACE_KNOWN (olddecl
)
2338 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2339 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2340 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2341 == FUNCTION_DECL
))))
2345 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2346 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2348 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2351 if (!new_redefines_gnu_inline
)
2353 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2354 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2355 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2357 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2358 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2359 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2361 /* If the OLDDECL is an instantiation and/or specialization,
2362 then the NEWDECL must be too. But, it may not yet be marked
2363 as such if the caller has created NEWDECL, but has not yet
2364 figured out that it is a redeclaration. */
2365 if (!DECL_USE_TEMPLATE (newdecl
))
2366 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2368 /* Don't really know how much of the language-specific
2369 values we should copy from old to new. */
2370 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2371 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2372 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2373 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2375 if (LANG_DECL_HAS_MIN (newdecl
))
2377 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
2378 if (DECL_TEMPLATE_INFO (newdecl
))
2380 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2381 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2382 && DECL_TEMPLATE_SPECIALIZATION (newdecl
))
2383 /* Remember the presence of explicit specialization args. */
2384 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl
))
2385 = TINFO_USED_TEMPLATE_ID (new_template_info
);
2387 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2390 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2392 /* Only functions have these fields. */
2393 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2394 DECL_BEFRIENDING_CLASSES (newdecl
)
2395 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2396 DECL_BEFRIENDING_CLASSES (olddecl
));
2397 /* DECL_THUNKS is only valid for virtual functions,
2398 otherwise it is a DECL_FRIEND_CONTEXT. */
2399 if (DECL_VIRTUAL_P (newdecl
))
2400 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2402 else if (VAR_P (newdecl
))
2404 /* Only variables have this field. */
2405 if (VAR_HAD_UNKNOWN_BOUND (olddecl
))
2406 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2410 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2414 /* Merge parameter attributes. */
2415 tree oldarg
, newarg
;
2416 for (oldarg
= DECL_ARGUMENTS(olddecl
), newarg
= DECL_ARGUMENTS(newdecl
);
2418 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
))
2420 DECL_ATTRIBUTES (newarg
)
2421 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2422 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2425 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2426 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2428 /* If newdecl is not a specialization, then it is not a
2429 template-related function at all. And that means that we
2430 should have exited above, returning 0. */
2431 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2433 if (DECL_ODR_USED (olddecl
))
2434 /* From [temp.expl.spec]:
2436 If a template, a member template or the member of a class
2437 template is explicitly specialized then that
2438 specialization shall be declared before the first use of
2439 that specialization that would cause an implicit
2440 instantiation to take place, in every translation unit in
2441 which such a use occurs. */
2442 error ("explicit specialization of %qD after first use",
2445 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2446 DECL_COMDAT (newdecl
) = (TREE_PUBLIC (newdecl
)
2447 && DECL_DECLARED_INLINE_P (newdecl
));
2449 /* Don't propagate visibility from the template to the
2450 specialization here. We'll do that in determine_visibility if
2452 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2454 /* [temp.expl.spec/14] We don't inline explicit specialization
2455 just because the primary template says so. */
2456 gcc_assert (!merge_attr
);
2458 DECL_DECLARED_INLINE_P (olddecl
)
2459 = DECL_DECLARED_INLINE_P (newdecl
);
2461 DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2462 = DECL_DISREGARD_INLINE_LIMITS (newdecl
);
2464 DECL_UNINLINABLE (olddecl
) = DECL_UNINLINABLE (newdecl
);
2466 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2468 /* Never inline re-defined extern inline functions.
2469 FIXME: this could be better handled by keeping both
2470 function as separate declarations. */
2471 DECL_UNINLINABLE (newdecl
) = 1;
2475 if (DECL_PENDING_INLINE_P (olddecl
))
2477 DECL_PENDING_INLINE_P (newdecl
) = 1;
2478 DECL_PENDING_INLINE_INFO (newdecl
)
2479 = DECL_PENDING_INLINE_INFO (olddecl
);
2481 else if (DECL_PENDING_INLINE_P (newdecl
))
2483 else if (DECL_SAVED_AUTO_RETURN_TYPE (newdecl
) == NULL
)
2484 DECL_SAVED_AUTO_RETURN_TYPE (newdecl
)
2485 = DECL_SAVED_AUTO_RETURN_TYPE (olddecl
);
2487 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2489 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2490 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2492 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2493 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2494 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2495 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2498 /* Preserve abstractness on cloned [cd]tors. */
2499 DECL_ABSTRACT_P (newdecl
) = DECL_ABSTRACT_P (olddecl
);
2501 /* Update newdecl's parms to point at olddecl. */
2502 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2503 parm
= DECL_CHAIN (parm
))
2504 DECL_CONTEXT (parm
) = olddecl
;
2508 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2509 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2510 COPY_DECL_RTL (newdecl
, olddecl
);
2512 if (! types_match
|| new_defines_function
)
2514 /* These need to be copied so that the names are available.
2515 Note that if the types do match, we'll preserve inline
2516 info and other bits, but if not, we won't. */
2517 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2518 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2520 /* If redeclaring a builtin function, it stays built in
2521 if newdecl is a gnu_inline definition, or if newdecl is just
2523 if (fndecl_built_in_p (olddecl
)
2524 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2526 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2527 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2528 /* If we're keeping the built-in definition, keep the rtl,
2529 regardless of declaration matches. */
2530 COPY_DECL_RTL (olddecl
, newdecl
);
2531 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2533 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2536 /* If a compatible prototype of these builtin functions
2537 is seen, assume the runtime implements it with the
2538 expected semantics. */
2539 case BUILT_IN_STPCPY
:
2540 if (builtin_decl_explicit_p (fncode
))
2541 set_builtin_decl_implicit_p (fncode
, true);
2544 if (builtin_decl_explicit_p (fncode
))
2545 set_builtin_decl_declared_p (fncode
, true);
2550 copy_attributes_to_builtin (newdecl
);
2552 if (new_defines_function
)
2553 /* If defining a function declared with other language
2554 linkage, use the previously declared language linkage. */
2555 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2556 else if (types_match
)
2558 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2559 /* Don't clear out the arguments if we're just redeclaring a
2561 if (DECL_ARGUMENTS (olddecl
))
2562 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2565 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2566 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2568 /* Now preserve various other info from the definition. */
2569 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2570 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2571 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2572 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2574 /* Warn about conflicting visibility specifications. */
2575 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2576 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2577 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2579 auto_diagnostic_group d
;
2580 if (warning_at (newdecl_loc
, OPT_Wattributes
,
2581 "%qD: visibility attribute ignored because it "
2582 "conflicts with previous declaration", newdecl
))
2583 inform (olddecl_loc
,
2584 "previous declaration of %qD", olddecl
);
2586 /* Choose the declaration which specified visibility. */
2587 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2589 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2590 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2592 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2593 so keep this behavior. */
2594 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2596 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2597 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2599 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2600 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2602 SET_DECL_ALIGN (newdecl
, DECL_ALIGN (olddecl
));
2603 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2605 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2606 if (DECL_WARN_IF_NOT_ALIGN (olddecl
)
2607 > DECL_WARN_IF_NOT_ALIGN (newdecl
))
2608 SET_DECL_WARN_IF_NOT_ALIGN (newdecl
,
2609 DECL_WARN_IF_NOT_ALIGN (olddecl
));
2610 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2611 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2613 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2614 with that from NEWDECL below. */
2615 if (DECL_LANG_SPECIFIC (olddecl
))
2617 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2618 != DECL_LANG_SPECIFIC (newdecl
));
2619 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2622 /* Merge the USED information. */
2623 if (TREE_USED (olddecl
))
2624 TREE_USED (newdecl
) = 1;
2625 else if (TREE_USED (newdecl
))
2626 TREE_USED (olddecl
) = 1;
2627 if (VAR_P (newdecl
))
2629 if (DECL_READ_P (olddecl
))
2630 DECL_READ_P (newdecl
) = 1;
2631 else if (DECL_READ_P (newdecl
))
2632 DECL_READ_P (olddecl
) = 1;
2634 if (DECL_PRESERVE_P (olddecl
))
2635 DECL_PRESERVE_P (newdecl
) = 1;
2636 else if (DECL_PRESERVE_P (newdecl
))
2637 DECL_PRESERVE_P (olddecl
) = 1;
2639 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2640 to olddecl and deleted. */
2641 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2642 && DECL_FUNCTION_VERSIONED (olddecl
))
2644 /* Set the flag for newdecl so that it gets copied to olddecl. */
2645 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2646 /* newdecl will be purged after copying to olddecl and is no longer
2648 cgraph_node::delete_function_version_by_decl (newdecl
);
2651 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2654 struct symtab_node
*snode
= symtab_node::get (olddecl
);
2656 function_size
= sizeof (struct tree_decl_common
);
2658 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2659 (char *) newdecl
+ sizeof (struct tree_common
),
2660 function_size
- sizeof (struct tree_common
));
2662 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2663 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2664 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2666 /* Preserve symtab node mapping. */
2667 olddecl
->decl_with_vis
.symtab_node
= snode
;
2669 if (new_template_info
)
2670 /* If newdecl is a template instantiation, it is possible that
2671 the following sequence of events has occurred:
2673 o A friend function was declared in a class template. The
2674 class template was instantiated.
2676 o The instantiation of the friend declaration was
2677 recorded on the instantiation list, and is newdecl.
2679 o Later, however, instantiate_class_template called pushdecl
2680 on the newdecl to perform name injection. But, pushdecl in
2681 turn called duplicate_decls when it discovered that another
2682 declaration of a global function with the same name already
2685 o Here, in duplicate_decls, we decided to clobber newdecl.
2687 If we're going to do that, we'd better make sure that
2688 olddecl, and not newdecl, is on the list of
2689 instantiations so that if we try to do the instantiation
2690 again we won't get the clobbered declaration. */
2691 reregister_specialization (newdecl
,
2697 size_t size
= tree_code_size (TREE_CODE (newdecl
));
2699 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2700 (char *) newdecl
+ sizeof (struct tree_common
),
2701 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2702 switch (TREE_CODE (newdecl
))
2712 struct symtab_node
*snode
= NULL
;
2715 && (TREE_STATIC (olddecl
) || TREE_PUBLIC (olddecl
)
2716 || DECL_EXTERNAL (olddecl
)))
2717 snode
= symtab_node::get (olddecl
);
2718 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2719 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2720 size
- sizeof (struct tree_decl_common
)
2721 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2722 if (VAR_P (newdecl
))
2723 olddecl
->decl_with_vis
.symtab_node
= snode
;
2727 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2728 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2729 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2730 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2735 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2737 if (DECL_EXTERNAL (olddecl
)
2738 || TREE_PUBLIC (olddecl
)
2739 || TREE_STATIC (olddecl
))
2741 /* Merge the section attribute.
2742 We want to issue an error if the sections conflict but that must be
2743 done later in decl_attributes since we are called before attributes
2745 if (DECL_SECTION_NAME (newdecl
) != NULL
)
2746 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2748 if (DECL_ONE_ONLY (newdecl
))
2750 struct symtab_node
*oldsym
, *newsym
;
2751 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2752 oldsym
= cgraph_node::get_create (olddecl
);
2754 oldsym
= varpool_node::get_create (olddecl
);
2755 newsym
= symtab_node::get (newdecl
);
2756 oldsym
->set_comdat_group (newsym
->get_comdat_group ());
2761 && CP_DECL_THREAD_LOCAL_P (newdecl
))
2763 CP_DECL_THREAD_LOCAL_P (olddecl
) = true;
2764 if (!processing_template_decl
)
2765 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2769 DECL_UID (olddecl
) = olddecl_uid
;
2771 DECL_FRIEND_P (olddecl
) = 1;
2774 DECL_ANTICIPATED (olddecl
) = 1;
2775 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2778 /* NEWDECL contains the merged attribute lists.
2779 Update OLDDECL to be the same. */
2780 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2782 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2783 so that encode_section_info has a chance to look at the new decl
2784 flags and attributes. */
2785 if (DECL_RTL_SET_P (olddecl
)
2786 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2788 && TREE_STATIC (olddecl
))))
2789 make_decl_rtl (olddecl
);
2791 /* The NEWDECL will no longer be needed. Because every out-of-class
2792 declaration of a member results in a call to duplicate_decls,
2793 freeing these nodes represents in a significant savings.
2795 Before releasing the node, be sore to remove function from symbol
2796 table that might have been inserted there to record comdat group.
2797 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2798 structure is shared in between newdecl and oldecl. */
2799 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2800 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2801 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2803 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2808 /* Remove the associated constraints for newdecl, if any, before
2809 reclaiming memory. */
2811 remove_constraints (newdecl
);
2818 /* Return zero if the declaration NEWDECL is valid
2819 when the declaration OLDDECL (assumed to be for the same name)
2820 has already been seen.
2821 Otherwise return an error message format string with a %s
2822 where the identifier should go. */
2825 redeclaration_error_message (tree newdecl
, tree olddecl
)
2827 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2829 /* Because C++ can put things into name space for free,
2830 constructs like "typedef struct foo { ... } foo"
2831 would look like an erroneous redeclaration. */
2832 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2835 return G_("redefinition of %q#D");
2837 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2839 /* If this is a pure function, its olddecl will actually be
2840 the original initialization to `0' (which we force to call
2841 abort()). Don't complain about redefinition in this case. */
2842 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2843 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2846 /* If both functions come from different namespaces, this is not
2847 a redeclaration - this is a conflict with a used function. */
2848 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2849 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2850 && ! decls_match (olddecl
, newdecl
))
2851 return G_("%qD conflicts with used function");
2853 /* We'll complain about linkage mismatches in
2854 warn_extern_redeclared_static. */
2856 /* Defining the same name twice is no good. */
2857 if (decl_defined_p (olddecl
)
2858 && decl_defined_p (newdecl
))
2860 if (DECL_NAME (olddecl
) == NULL_TREE
)
2861 return G_("%q#D not declared in class");
2862 else if (!GNU_INLINE_P (olddecl
)
2863 || GNU_INLINE_P (newdecl
))
2864 return G_("redefinition of %q#D");
2867 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2869 bool olda
= GNU_INLINE_P (olddecl
);
2870 bool newa
= GNU_INLINE_P (newdecl
);
2875 return G_("%q+D redeclared inline with "
2876 "%<gnu_inline%> attribute");
2878 return G_("%q+D redeclared inline without "
2879 "%<gnu_inline%> attribute");
2883 check_abi_tag_redeclaration
2884 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2885 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2889 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2893 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2895 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2896 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2897 return G_("redefinition of %q#D");
2901 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2902 || (DECL_TEMPLATE_RESULT (newdecl
)
2903 == DECL_TEMPLATE_RESULT (olddecl
)))
2906 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2907 if (DECL_TEMPLATE_INFO (nt
))
2908 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2909 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2910 if (DECL_TEMPLATE_INFO (ot
))
2911 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2912 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2913 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2914 return G_("redefinition of %q#D");
2916 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2918 bool olda
= GNU_INLINE_P (ot
);
2919 bool newa
= GNU_INLINE_P (nt
);
2924 return G_("%q+D redeclared inline with "
2925 "%<gnu_inline%> attribute");
2927 return G_("%q+D redeclared inline without "
2928 "%<gnu_inline%> attribute");
2932 /* Core issue #226 (C++0x):
2934 If a friend function template declaration specifies a
2935 default template-argument, that declaration shall be a
2936 definition and shall be the only declaration of the
2937 function template in the translation unit. */
2938 if ((cxx_dialect
!= cxx98
)
2939 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2940 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2941 /*is_primary=*/true,
2942 /*is_partial=*/false,
2943 /*is_friend_decl=*/2))
2944 return G_("redeclaration of friend %q#D "
2945 "may not have default template arguments");
2949 else if (VAR_P (newdecl
)
2950 && CP_DECL_THREAD_LOCAL_P (newdecl
) != CP_DECL_THREAD_LOCAL_P (olddecl
)
2951 && (! DECL_LANG_SPECIFIC (olddecl
)
2952 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2953 || CP_DECL_THREAD_LOCAL_P (newdecl
)))
2955 /* Only variables can be thread-local, and all declarations must
2956 agree on this property. */
2957 if (CP_DECL_THREAD_LOCAL_P (newdecl
))
2958 return G_("thread-local declaration of %q#D follows "
2959 "non-thread-local declaration");
2961 return G_("non-thread-local declaration of %q#D follows "
2962 "thread-local declaration");
2964 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2966 /* The objects have been declared at namespace scope. If either
2967 is a member of an anonymous union, then this is an invalid
2968 redeclaration. For example:
2974 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2975 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2976 return G_("redeclaration of %q#D");
2977 /* If at least one declaration is a reference, there is no
2978 conflict. For example:
2984 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2987 /* Static data member declared outside a class definition
2988 if the variable is defined within the class with constexpr
2989 specifier is declaration rather than definition (and
2991 if (cxx_dialect
>= cxx17
2993 && DECL_CLASS_SCOPE_P (olddecl
)
2994 && DECL_DECLARED_CONSTEXPR_P (olddecl
)
2995 && !DECL_INITIAL (newdecl
))
2997 DECL_EXTERNAL (newdecl
) = 1;
2998 /* For now, only warn with explicit -Wdeprecated. */
2999 if (global_options_set
.x_warn_deprecated
)
3001 auto_diagnostic_group d
;
3002 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wdeprecated
,
3003 "redundant redeclaration of %<constexpr%> "
3004 "static data member %qD", newdecl
))
3005 inform (DECL_SOURCE_LOCATION (olddecl
),
3006 "previous declaration of %qD", olddecl
);
3011 /* Reject two definitions. */
3012 return G_("redefinition of %q#D");
3016 /* Objects declared with block scope: */
3017 /* Reject two definitions, and reject a definition
3018 together with an external reference. */
3019 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
3020 return G_("redeclaration of %q#D");
3026 /* Hash and equality functions for the named_label table. */
3029 named_label_hash::hash (const value_type entry
)
3031 return IDENTIFIER_HASH_VALUE (entry
->name
);
3035 named_label_hash::equal (const value_type entry
, compare_type name
)
3037 return name
== entry
->name
;
3040 /* Look for a label named ID in the current function. If one cannot
3041 be found, create one. Return the named_label_entry, or NULL on
3044 static named_label_entry
*
3045 lookup_label_1 (tree id
, bool making_local_p
)
3047 /* You can't use labels at global scope. */
3048 if (current_function_decl
== NULL_TREE
)
3050 error ("label %qE referenced outside of any function", id
);
3055 named_labels
= hash_table
<named_label_hash
>::create_ggc (13);
3057 hashval_t hash
= IDENTIFIER_HASH_VALUE (id
);
3058 named_label_entry
**slot
3059 = named_labels
->find_slot_with_hash (id
, hash
, INSERT
);
3060 named_label_entry
*old
= *slot
;
3062 if (old
&& old
->label_decl
)
3064 if (!making_local_p
)
3067 if (old
->binding_level
== current_binding_level
)
3069 error ("local label %qE conflicts with existing label", id
);
3070 inform (DECL_SOURCE_LOCATION (old
->label_decl
), "previous label");
3075 /* We are making a new decl, create or reuse the named_label_entry */
3076 named_label_entry
*ent
= NULL
;
3077 if (old
&& !old
->label_decl
)
3081 ent
= ggc_cleared_alloc
<named_label_entry
> ();
3087 /* Now create the LABEL_DECL. */
3088 tree decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
3090 DECL_CONTEXT (decl
) = current_function_decl
;
3091 SET_DECL_MODE (decl
, VOIDmode
);
3094 C_DECLARED_LABEL_FLAG (decl
) = true;
3095 DECL_CHAIN (decl
) = current_binding_level
->names
;
3096 current_binding_level
->names
= decl
;
3099 ent
->label_decl
= decl
;
3104 /* Wrapper for lookup_label_1. */
3107 lookup_label (tree id
)
3109 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3110 named_label_entry
*ent
= lookup_label_1 (id
, false);
3111 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3112 return ent
? ent
->label_decl
: NULL_TREE
;
3116 declare_local_label (tree id
)
3118 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3119 named_label_entry
*ent
= lookup_label_1 (id
, true);
3120 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3121 return ent
? ent
->label_decl
: NULL_TREE
;
3124 /* Returns nonzero if it is ill-formed to jump past the declaration of
3125 DECL. Returns 2 if it's also a real problem. */
3128 decl_jump_unsafe (tree decl
)
3130 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3131 with automatic storage duration is not in scope to a point where it is
3132 in scope is ill-formed unless the variable has scalar type, class type
3133 with a trivial default constructor and a trivial destructor, a
3134 cv-qualified version of one of these types, or an array of one of the
3135 preceding types and is declared without an initializer (8.5). */
3136 tree type
= TREE_TYPE (decl
);
3138 if (!VAR_P (decl
) || TREE_STATIC (decl
)
3139 || type
== error_mark_node
)
3142 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
3143 || variably_modified_type_p (type
, NULL_TREE
))
3146 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3152 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3156 identify_goto (tree decl
, location_t loc
, const location_t
*locus
,
3157 diagnostic_t diag_kind
)
3160 = emit_diagnostic (diag_kind
, loc
, 0,
3161 decl
? N_("jump to label %qD")
3162 : N_("jump to case label"), decl
);
3163 if (complained
&& locus
)
3164 inform (*locus
, " from here");
3168 /* Check that a single previously seen jump to a newly defined label
3169 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3170 the jump context; NAMES are the names in scope in LEVEL at the jump
3171 context; LOCUS is the source position of the jump or 0. Returns
3172 true if all is well. */
3175 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
3176 bool exited_omp
, const location_t
*locus
)
3178 cp_binding_level
*b
;
3179 bool complained
= false;
3181 bool saw_eh
= false, saw_omp
= false, saw_tm
= false, saw_cxif
= false;
3185 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3187 inform (input_location
, " exits OpenMP structured block");
3192 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3194 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
3196 for (new_decls
= b
->names
; new_decls
!= old_decls
;
3197 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
3198 : TREE_CHAIN (new_decls
)))
3200 int problem
= decl_jump_unsafe (new_decls
);
3206 complained
= identify_goto (decl
, input_location
, locus
,
3208 ? DK_ERROR
: DK_PERMERROR
);
3214 inform (DECL_SOURCE_LOCATION (new_decls
),
3215 " crosses initialization of %q#D", new_decls
);
3217 inform (DECL_SOURCE_LOCATION (new_decls
),
3218 " enters scope of %q#D, which has "
3219 "non-trivial destructor", new_decls
);
3226 const char *inf
= NULL
;
3227 location_t loc
= input_location
;
3232 inf
= G_(" enters %<try%> block");
3238 inf
= G_(" enters %<catch%> block");
3244 inf
= G_(" enters OpenMP structured block");
3248 case sk_transaction
:
3250 inf
= G_(" enters synchronized or atomic statement");
3255 if (!saw_cxif
&& level_for_constexpr_if (b
->level_chain
))
3257 inf
= G_(" enters %<constexpr if%> statement");
3258 loc
= EXPR_LOCATION (b
->level_chain
->this_entity
);
3270 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3281 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
3283 check_previous_goto_1 (decl
, use
->binding_level
,
3284 use
->names_in_scope
, use
->in_omp_scope
,
3285 &use
->o_goto_locus
);
3289 check_switch_goto (cp_binding_level
* level
)
3291 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
3294 /* Check that a new jump to a label DECL is OK. Called by
3295 finish_goto_stmt. */
3298 check_goto (tree decl
)
3300 /* We can't know where a computed goto is jumping.
3301 So we assume that it's OK. */
3302 if (TREE_CODE (decl
) != LABEL_DECL
)
3305 /* We didn't record any information about this label when we created it,
3306 and there's not much point since it's trivial to analyze as a return. */
3307 if (decl
== cdtor_label
)
3310 hashval_t hash
= IDENTIFIER_HASH_VALUE (DECL_NAME (decl
));
3311 named_label_entry
**slot
3312 = named_labels
->find_slot_with_hash (DECL_NAME (decl
), hash
, NO_INSERT
);
3313 named_label_entry
*ent
= *slot
;
3315 /* If the label hasn't been defined yet, defer checking. */
3316 if (! DECL_INITIAL (decl
))
3318 /* Don't bother creating another use if the last goto had the
3319 same data, and will therefore create the same set of errors. */
3321 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
3324 named_label_use_entry
*new_use
3325 = ggc_alloc
<named_label_use_entry
> ();
3326 new_use
->binding_level
= current_binding_level
;
3327 new_use
->names_in_scope
= current_binding_level
->names
;
3328 new_use
->o_goto_locus
= input_location
;
3329 new_use
->in_omp_scope
= false;
3331 new_use
->next
= ent
->uses
;
3332 ent
->uses
= new_use
;
3336 bool saw_catch
= false, complained
= false;
3341 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_transaction_scope
3342 || ent
->in_constexpr_if
3343 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
3345 diagnostic_t diag_kind
= DK_PERMERROR
;
3346 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_constexpr_if
3347 || ent
->in_transaction_scope
|| ent
->in_omp_scope
)
3348 diag_kind
= DK_ERROR
;
3349 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3350 &input_location
, diag_kind
);
3351 identified
= 1 + (diag_kind
== DK_ERROR
);
3354 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
3356 int u
= decl_jump_unsafe (bad
);
3358 if (u
> 1 && DECL_ARTIFICIAL (bad
))
3360 /* Can't skip init of __exception_info. */
3361 if (identified
== 1)
3363 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3364 &input_location
, DK_ERROR
);
3368 inform (DECL_SOURCE_LOCATION (bad
), " enters %<catch%> block");
3371 else if (complained
)
3374 inform (DECL_SOURCE_LOCATION (bad
),
3375 " skips initialization of %q#D", bad
);
3377 inform (DECL_SOURCE_LOCATION (bad
),
3378 " enters scope of %q#D which has "
3379 "non-trivial destructor", bad
);
3385 if (ent
->in_try_scope
)
3386 inform (input_location
, " enters %<try%> block");
3387 else if (ent
->in_catch_scope
&& !saw_catch
)
3388 inform (input_location
, " enters %<catch%> block");
3389 else if (ent
->in_transaction_scope
)
3390 inform (input_location
, " enters synchronized or atomic statement");
3391 else if (ent
->in_constexpr_if
)
3392 inform (input_location
, " enters %<constexpr if%> statement");
3395 if (ent
->in_omp_scope
)
3398 inform (input_location
, " enters OpenMP structured block");
3400 else if (flag_openmp
)
3401 for (cp_binding_level
*b
= current_binding_level
; b
; b
= b
->level_chain
)
3403 if (b
== ent
->binding_level
)
3405 if (b
->kind
== sk_omp
)
3409 complained
= identify_goto (decl
,
3410 DECL_SOURCE_LOCATION (decl
),
3411 &input_location
, DK_ERROR
);
3415 inform (input_location
, " exits OpenMP structured block");
3421 /* Check that a return is ok wrt OpenMP structured blocks.
3422 Called by finish_return_stmt. Returns true if all is well. */
3425 check_omp_return (void)
3427 for (cp_binding_level
*b
= current_binding_level
; b
; b
= b
->level_chain
)
3428 if (b
->kind
== sk_omp
)
3430 error ("invalid exit from OpenMP structured block");
3433 else if (b
->kind
== sk_function_parms
)
3438 /* Define a label, specifying the location in the source file.
3439 Return the LABEL_DECL node for the label. */
3442 define_label_1 (location_t location
, tree name
)
3444 /* After labels, make any new cleanups in the function go into their
3445 own new (temporary) binding contour. */
3446 for (cp_binding_level
*p
= current_binding_level
;
3447 p
->kind
!= sk_function_parms
;
3449 p
->more_cleanups_ok
= 0;
3451 named_label_entry
*ent
= lookup_label_1 (name
, false);
3452 tree decl
= ent
->label_decl
;
3454 if (DECL_INITIAL (decl
) != NULL_TREE
)
3456 error ("duplicate label %qD", decl
);
3457 return error_mark_node
;
3461 /* Mark label as having been defined. */
3462 DECL_INITIAL (decl
) = error_mark_node
;
3463 /* Say where in the source. */
3464 DECL_SOURCE_LOCATION (decl
) = location
;
3466 ent
->binding_level
= current_binding_level
;
3467 ent
->names_in_scope
= current_binding_level
->names
;
3469 for (named_label_use_entry
*use
= ent
->uses
; use
; use
= use
->next
)
3470 check_previous_goto (decl
, use
);
3477 /* Wrapper for define_label_1. */
3480 define_label (location_t location
, tree name
)
3482 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3483 tree ret
= define_label_1 (location
, name
);
3484 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3491 cp_binding_level
*level
;
3492 struct cp_switch
*next
;
3493 /* The SWITCH_STMT being built. */
3495 /* A splay-tree mapping the low element of a case range to the high
3496 element, or NULL_TREE if there is no high element. Used to
3497 determine whether or not a new case label duplicates an old case
3498 label. We need a tree, rather than simply a hash table, because
3499 of the GNU case range extension. */
3501 /* Remember whether a default: case label has been seen. */
3503 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
3504 bool break_stmt_seen_p
;
3505 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
3506 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
3507 bool in_loop_body_p
;
3510 /* A stack of the currently active switch statements. The innermost
3511 switch statement is on the top of the stack. There is no need to
3512 mark the stack for garbage collection because it is only active
3513 during the processing of the body of a function, and we never
3514 collect at that point. */
3516 static struct cp_switch
*switch_stack
;
3518 /* Called right after a switch-statement condition is parsed.
3519 SWITCH_STMT is the switch statement being parsed. */
3522 push_switch (tree switch_stmt
)
3524 struct cp_switch
*p
= XNEW (struct cp_switch
);
3525 p
->level
= current_binding_level
;
3526 p
->next
= switch_stack
;
3527 p
->switch_stmt
= switch_stmt
;
3528 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3529 p
->has_default_p
= false;
3530 p
->break_stmt_seen_p
= false;
3531 p
->in_loop_body_p
= false;
3538 struct cp_switch
*cs
= switch_stack
;
3539 location_t switch_location
;
3541 /* Emit warnings as needed. */
3542 switch_location
= cp_expr_loc_or_loc (cs
->switch_stmt
, input_location
);
3543 const bool bool_cond_p
3544 = (SWITCH_STMT_TYPE (cs
->switch_stmt
)
3545 && TREE_CODE (SWITCH_STMT_TYPE (cs
->switch_stmt
)) == BOOLEAN_TYPE
);
3546 if (!processing_template_decl
)
3547 c_do_switch_warnings (cs
->cases
, switch_location
,
3548 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3549 SWITCH_STMT_COND (cs
->switch_stmt
), bool_cond_p
);
3551 /* For the benefit of block_may_fallthru remember if the switch body
3552 case labels cover all possible values and if there are break; stmts. */
3553 if (cs
->has_default_p
3554 || (!processing_template_decl
3555 && c_switch_covers_all_cases_p (cs
->cases
,
3556 SWITCH_STMT_TYPE (cs
->switch_stmt
))))
3557 SWITCH_STMT_ALL_CASES_P (cs
->switch_stmt
) = 1;
3558 if (!cs
->break_stmt_seen_p
)
3559 SWITCH_STMT_NO_BREAK_P (cs
->switch_stmt
) = 1;
3560 gcc_assert (!cs
->in_loop_body_p
);
3561 splay_tree_delete (cs
->cases
);
3562 switch_stack
= switch_stack
->next
;
3566 /* Note that a BREAK_STMT is about to be added. If it is inside of
3567 a SWITCH_STMT and not inside of a loop body inside of it, note
3568 in switch_stack we've seen a BREAK_STMT. */
3571 note_break_stmt (void)
3573 if (switch_stack
&& !switch_stack
->in_loop_body_p
)
3574 switch_stack
->break_stmt_seen_p
= true;
3577 /* Note the start of processing of an iteration statement's body.
3578 The note_break_stmt function will do nothing while processing it.
3579 Return a flag that should be passed to note_iteration_stmt_body_end. */
3582 note_iteration_stmt_body_start (void)
3586 bool ret
= switch_stack
->in_loop_body_p
;
3587 switch_stack
->in_loop_body_p
= true;
3591 /* Note the end of processing of an iteration statement's body. */
3594 note_iteration_stmt_body_end (bool prev
)
3597 switch_stack
->in_loop_body_p
= prev
;
3600 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3601 condition. Note that if TYPE and VALUE are already integral we don't
3602 really do the conversion because the language-independent
3603 warning/optimization code will work better that way. */
3606 case_conversion (tree type
, tree value
)
3608 if (value
== NULL_TREE
)
3611 value
= mark_rvalue_use (value
);
3613 if (cxx_dialect
>= cxx11
3614 && (SCOPED_ENUM_P (type
)
3615 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3617 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3618 type
= type_promotes_to (type
);
3619 value
= (perform_implicit_conversion_flags
3620 (type
, value
, tf_warning_or_error
,
3621 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3623 return cxx_constant_value (value
);
3626 /* Note that we've seen a definition of a case label, and complain if this
3627 is a bad place for one. */
3630 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3633 cp_binding_level
*p
;
3636 if (low_value
== NULL_TREE
&& high_value
== NULL_TREE
)
3637 switch_stack
->has_default_p
= true;
3639 if (processing_template_decl
)
3643 /* For templates, just add the case label; we'll do semantic
3644 analysis at instantiation-time. */
3645 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, void_type_node
);
3646 return add_stmt (build_case_label (low_value
, high_value
, label
));
3649 /* Find the condition on which this switch statement depends. */
3650 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3651 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3652 cond
= TREE_VALUE (cond
);
3654 if (!check_switch_goto (switch_stack
->level
))
3655 return error_mark_node
;
3657 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3658 if (type
== error_mark_node
)
3659 return error_mark_node
;
3661 low_value
= case_conversion (type
, low_value
);
3662 high_value
= case_conversion (type
, high_value
);
3664 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, low_value
, high_value
);
3666 /* After labels, make any new cleanups in the function go into their
3667 own new (temporary) binding contour. */
3668 for (p
= current_binding_level
;
3669 p
->kind
!= sk_function_parms
;
3671 p
->more_cleanups_ok
= 0;
3676 struct typename_info
{
3684 struct typename_hasher
: ggc_ptr_hash
<tree_node
>
3686 typedef typename_info
*compare_type
;
3688 /* Hash a TYPENAME_TYPE. */
3695 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3696 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3701 /* Compare two TYPENAME_TYPEs. */
3704 equal (tree t1
, const typename_info
*t2
)
3706 return (TYPE_IDENTIFIER (t1
) == t2
->name
3707 && TYPE_CONTEXT (t1
) == t2
->scope
3708 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3709 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3710 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3714 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3715 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3717 Returns the new TYPENAME_TYPE. */
3719 static GTY (()) hash_table
<typename_hasher
> *typename_htab
;
3722 build_typename_type (tree context
, tree name
, tree fullname
,
3723 enum tag_types tag_type
)
3731 if (typename_htab
== NULL
)
3732 typename_htab
= hash_table
<typename_hasher
>::create_ggc (61);
3734 ti
.scope
= FROB_CONTEXT (context
);
3736 ti
.template_id
= fullname
;
3737 ti
.enum_p
= tag_type
== enum_type
;
3738 ti
.class_p
= (tag_type
== class_type
3739 || tag_type
== record_type
3740 || tag_type
== union_type
);
3741 hash
= (htab_hash_pointer (ti
.scope
)
3742 ^ htab_hash_pointer (ti
.name
));
3744 /* See if we already have this type. */
3745 e
= typename_htab
->find_slot_with_hash (&ti
, hash
, INSERT
);
3750 /* Build the TYPENAME_TYPE. */
3751 t
= cxx_make_type (TYPENAME_TYPE
);
3752 TYPE_CONTEXT (t
) = ti
.scope
;
3753 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3754 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3755 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3757 /* Build the corresponding TYPE_DECL. */
3758 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3759 TYPE_NAME (TREE_TYPE (d
)) = d
;
3760 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3761 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3762 DECL_ARTIFICIAL (d
) = 1;
3764 /* Store it in the hash table. */
3767 /* TYPENAME_TYPEs must always be compared structurally, because
3768 they may or may not resolve down to another type depending on
3769 the currently open classes. */
3770 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3776 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3777 provided to name the type. Returns an appropriate type, unless an
3778 error occurs, in which case error_mark_node is returned. If we
3779 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3780 return that, rather than the _TYPE it corresponds to, in other
3781 cases we look through the type decl. If TF_ERROR is set, complain
3782 about errors, otherwise be quiet. */
3785 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3786 tsubst_flags_t complain
)
3792 if (name
== error_mark_node
3793 || context
== NULL_TREE
3794 || context
== error_mark_node
)
3795 return error_mark_node
;
3799 if (!(TYPE_LANG_SPECIFIC (name
)
3800 && (CLASSTYPE_IS_TEMPLATE (name
)
3801 || CLASSTYPE_USE_TEMPLATE (name
))))
3802 name
= TYPE_IDENTIFIER (name
);
3804 /* Create a TEMPLATE_ID_EXPR for the type. */
3805 name
= build_nt (TEMPLATE_ID_EXPR
,
3806 CLASSTYPE_TI_TEMPLATE (name
),
3807 CLASSTYPE_TI_ARGS (name
));
3809 else if (TREE_CODE (name
) == TYPE_DECL
)
3810 name
= DECL_NAME (name
);
3814 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3816 name
= TREE_OPERAND (name
, 0);
3817 if (DECL_TYPE_TEMPLATE_P (name
))
3818 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3819 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
3821 if (complain
& tf_error
)
3822 error ("%qD is not a type", name
);
3823 return error_mark_node
;
3826 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3828 if (complain
& tf_error
)
3829 error ("%qD used without template arguments", name
);
3830 return error_mark_node
;
3832 gcc_assert (identifier_p (name
));
3833 gcc_assert (TYPE_P (context
));
3835 if (TREE_CODE (context
) == TYPE_PACK_EXPANSION
)
3836 /* This can happen for C++17 variadic using (c++/88986). */;
3837 else if (!MAYBE_CLASS_TYPE_P (context
))
3839 if (complain
& tf_error
)
3840 error ("%q#T is not a class", context
);
3841 return error_mark_node
;
3844 /* When the CONTEXT is a dependent type, NAME could refer to a
3845 dependent base class of CONTEXT. But look inside it anyway
3846 if CONTEXT is a currently open scope, in case it refers to a
3847 member of the current instantiation or a non-dependent base;
3848 lookup will stop when we hit a dependent base. */
3849 if (!dependent_scope_p (context
))
3850 /* We should only set WANT_TYPE when we're a nested typename type.
3851 Then we can give better diagnostics if we find a non-type. */
3852 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3856 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3857 return build_typename_type (context
, name
, fullname
, tag_type
);
3859 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3863 if (complain
& tf_error
)
3865 if (!COMPLETE_TYPE_P (context
))
3866 cxx_incomplete_type_error (NULL_TREE
, context
);
3868 error (want_template
? G_("no class template named %q#T in %q#T")
3869 : G_("no type named %q#T in %q#T"), name
, context
);
3871 return error_mark_node
;
3874 /* Pull out the template from an injected-class-name (or multiple). */
3876 t
= maybe_get_template_decl_from_type_decl (t
);
3878 if (TREE_CODE (t
) == TREE_LIST
)
3880 if (complain
& tf_error
)
3882 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3883 print_candidates (t
);
3885 return error_mark_node
;
3888 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3890 if (complain
& tf_error
)
3891 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3893 return error_mark_node
;
3895 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3897 if (complain
& tf_error
)
3898 error ("%<typename %T::%D%> names %q#T, which is not a type",
3900 return error_mark_node
;
3903 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3904 return error_mark_node
;
3906 /* If we are currently parsing a template and if T is a typedef accessed
3907 through CONTEXT then we need to remember and check access of T at
3908 template instantiation time. */
3909 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3912 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3914 /*entering_scope=*/0,
3915 complain
| tf_user
);
3917 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3920 maybe_record_typedef_use (t
);
3925 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3926 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3927 in which case error_mark_node is returned.
3929 If PARM_LIST is non-NULL, also make sure that the template parameter
3930 list of TEMPLATE_DECL matches.
3932 If COMPLAIN zero, don't complain about any errors that occur. */
3935 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3936 tsubst_flags_t complain
)
3942 name
= TYPE_IDENTIFIER (name
);
3943 else if (DECL_P (name
))
3944 name
= DECL_NAME (name
);
3945 gcc_assert (identifier_p (name
));
3947 if (!dependent_type_p (context
)
3948 || currently_open_class (context
))
3950 tree tmpl
= NULL_TREE
;
3952 if (MAYBE_CLASS_TYPE_P (context
))
3953 tmpl
= lookup_field (context
, name
, 0, false);
3955 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3956 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3958 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3960 if (complain
& tf_error
)
3961 error ("no class template named %q#T in %q#T", name
, context
);
3962 return error_mark_node
;
3966 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3968 if (complain
& tf_error
)
3970 error ("template parameters do not match template %qD", tmpl
);
3971 inform (DECL_SOURCE_LOCATION (tmpl
),
3972 "%qD declared here", tmpl
);
3974 return error_mark_node
;
3977 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3979 return error_mark_node
;
3984 /* Build the UNBOUND_CLASS_TEMPLATE. */
3985 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3986 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3987 TREE_TYPE (t
) = NULL_TREE
;
3988 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3990 /* Build the corresponding TEMPLATE_DECL. */
3991 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3992 TYPE_NAME (TREE_TYPE (d
)) = d
;
3993 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3994 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3995 DECL_ARTIFICIAL (d
) = 1;
3996 DECL_TEMPLATE_PARMS (d
) = parm_list
;
4003 /* Push the declarations of builtin types into the global namespace.
4004 RID_INDEX is the index of the builtin type in the array
4005 RID_POINTERS. NAME is the name used when looking up the builtin
4006 type. TYPE is the _TYPE node for the builtin type.
4008 The calls to set_global_binding below should be
4009 eliminated. Built-in types should not be looked up name; their
4010 names are keywords that the parser can recognize. However, there
4011 is code in c-common.c that uses identifier_global_value to look up
4012 built-in types by name. */
4015 record_builtin_type (enum rid rid_index
,
4019 tree decl
= NULL_TREE
;
4023 tree tname
= get_identifier (name
);
4024 tree tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
4025 DECL_ARTIFICIAL (tdecl
) = 1;
4026 set_global_binding (tdecl
);
4030 if ((int) rid_index
< (int) RID_MAX
)
4031 if (tree rname
= ridpointers
[(int) rid_index
])
4032 if (!decl
|| DECL_NAME (decl
) != rname
)
4034 tree rdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
4035 DECL_ARTIFICIAL (rdecl
) = 1;
4036 set_global_binding (rdecl
);
4043 if (!TYPE_NAME (type
))
4044 TYPE_NAME (type
) = decl
;
4045 debug_hooks
->type_decl (decl
, 0);
4049 /* Push a type into the namespace so that the back ends ignore it. */
4052 record_unknown_type (tree type
, const char* name
)
4054 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
4055 TYPE_DECL
, get_identifier (name
), type
));
4056 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4057 DECL_IGNORED_P (decl
) = 1;
4058 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
4059 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
4060 SET_TYPE_ALIGN (type
, 1);
4061 TYPE_USER_ALIGN (type
) = 0;
4062 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
4065 /* Create all the predefined identifiers. */
4068 initialize_predefined_identifiers (void)
4070 struct predefined_identifier
4072 const char *name
; /* Name. */
4073 tree
*node
; /* Node to store it in. */
4074 cp_identifier_kind kind
; /* Kind of identifier. */
4077 /* A table of identifiers to create at startup. */
4078 static const predefined_identifier predefined_identifiers
[] = {
4079 {"C++", &lang_name_cplusplus
, cik_normal
},
4080 {"C", &lang_name_c
, cik_normal
},
4081 /* Some of these names have a trailing space so that it is
4082 impossible for them to conflict with names written by users. */
4083 {"__ct ", &ctor_identifier
, cik_ctor
},
4084 {"__ct_base ", &base_ctor_identifier
, cik_ctor
},
4085 {"__ct_comp ", &complete_ctor_identifier
, cik_ctor
},
4086 {"__dt ", &dtor_identifier
, cik_dtor
},
4087 {"__dt_base ", &base_dtor_identifier
, cik_dtor
},
4088 {"__dt_comp ", &complete_dtor_identifier
, cik_dtor
},
4089 {"__dt_del ", &deleting_dtor_identifier
, cik_dtor
},
4090 {"__conv_op ", &conv_op_identifier
, cik_conv_op
},
4091 {"__in_chrg", &in_charge_identifier
, cik_normal
},
4092 {"this", &this_identifier
, cik_normal
},
4093 {"__delta", &delta_identifier
, cik_normal
},
4094 {"__pfn", &pfn_identifier
, cik_normal
},
4095 {"_vptr", &vptr_identifier
, cik_normal
},
4096 {"__vtt_parm", &vtt_parm_identifier
, cik_normal
},
4097 {"::", &global_identifier
, cik_normal
},
4098 {"std", &std_identifier
, cik_normal
},
4099 /* The demangler expects anonymous namespaces to be called
4100 something starting with '_GLOBAL__N_'. It no longer needs
4101 to be unique to the TU. */
4102 {"_GLOBAL__N_1", &anon_identifier
, cik_normal
},
4103 {"auto", &auto_identifier
, cik_normal
},
4104 {"decltype(auto)", &decltype_auto_identifier
, cik_normal
},
4105 {"initializer_list", &init_list_identifier
, cik_normal
},
4106 {"__for_range ", &for_range__identifier
, cik_normal
},
4107 {"__for_begin ", &for_begin__identifier
, cik_normal
},
4108 {"__for_end ", &for_end__identifier
, cik_normal
},
4109 {"__for_range", &for_range_identifier
, cik_normal
},
4110 {"__for_begin", &for_begin_identifier
, cik_normal
},
4111 {"__for_end", &for_end_identifier
, cik_normal
},
4112 {"abi_tag", &abi_tag_identifier
, cik_normal
},
4113 {"aligned", &aligned_identifier
, cik_normal
},
4114 {"begin", &begin_identifier
, cik_normal
},
4115 {"end", &end_identifier
, cik_normal
},
4116 {"get", &get__identifier
, cik_normal
},
4117 {"gnu", &gnu_identifier
, cik_normal
},
4118 {"tuple_element", &tuple_element_identifier
, cik_normal
},
4119 {"tuple_size", &tuple_size_identifier
, cik_normal
},
4120 {"type", &type_identifier
, cik_normal
},
4121 {"value", &value_identifier
, cik_normal
},
4122 {"_FUN", &fun_identifier
, cik_normal
},
4123 {"__closure", &closure_identifier
, cik_normal
},
4124 {NULL
, NULL
, cik_normal
}
4127 for (const predefined_identifier
*pid
= predefined_identifiers
;
4130 *pid
->node
= get_identifier (pid
->name
);
4131 /* Some of these identifiers already have a special kind. */
4132 if (pid
->kind
!= cik_normal
)
4133 set_identifier_kind (*pid
->node
, pid
->kind
);
4137 /* Create the predefined scalar types of C,
4138 and some nodes representing standard constants (0, 1, (void *)0).
4139 Initialize the global binding level.
4140 Make definitions for built-in primitive functions. */
4143 cxx_init_decl_processing (void)
4146 tree void_ftype_ptr
;
4148 /* Create all the identifiers we need. */
4149 initialize_predefined_identifiers ();
4151 /* Create the global variables. */
4152 push_to_top_level ();
4154 current_function_decl
= NULL_TREE
;
4155 current_binding_level
= NULL
;
4156 /* Enter the global namespace. */
4157 gcc_assert (global_namespace
== NULL_TREE
);
4158 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_identifier
,
4160 TREE_PUBLIC (global_namespace
) = 1;
4161 DECL_CONTEXT (global_namespace
)
4162 = build_translation_unit_decl (get_identifier (main_input_filename
));
4163 /* Remember whether we want the empty class passing ABI change warning
4165 TRANSLATION_UNIT_WARN_EMPTY_P (DECL_CONTEXT (global_namespace
))
4166 = warn_abi
&& abi_version_crosses (12);
4167 debug_hooks
->register_main_translation_unit
4168 (DECL_CONTEXT (global_namespace
));
4169 begin_scope (sk_namespace
, global_namespace
);
4170 current_namespace
= global_namespace
;
4172 if (flag_visibility_ms_compat
)
4173 default_visibility
= VISIBILITY_HIDDEN
;
4176 current_lang_name
= lang_name_c
;
4178 /* Create the `std' namespace. */
4179 push_namespace (std_identifier
);
4180 std_node
= current_namespace
;
4183 flag_noexcept_type
= (cxx_dialect
>= cxx17
);
4185 c_common_nodes_and_builtins ();
4187 tree bool_ftype
= build_function_type_list (boolean_type_node
, NULL_TREE
);
4189 = add_builtin_function ("__builtin_is_constant_evaluated",
4190 bool_ftype
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
4191 BUILT_IN_FRONTEND
, NULL
, NULL_TREE
);
4192 set_call_expr_flags (decl
, ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
4194 integer_two_node
= build_int_cst (NULL_TREE
, 2);
4196 /* Guess at the initial static decls size. */
4197 vec_alloc (static_decls
, 500);
4199 /* ... and keyed classes. */
4200 vec_alloc (keyed_classes
, 100);
4202 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
4203 truthvalue_type_node
= boolean_type_node
;
4204 truthvalue_false_node
= boolean_false_node
;
4205 truthvalue_true_node
= boolean_true_node
;
4207 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
4208 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
4209 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
4210 noexcept_deferred_spec
= build_tree_list (make_node (DEFERRED_NOEXCEPT
),
4214 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
4217 delta_type_node
= ptrdiff_type_node
;
4218 vtable_index_type
= ptrdiff_type_node
;
4220 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
4221 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
4222 void_ftype_ptr
= build_function_type_list (void_type_node
,
4223 ptr_type_node
, NULL_TREE
);
4225 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
4227 /* Create the conversion operator marker. This operator's DECL_NAME
4228 is in the identifier table, so we can use identifier equality to
4230 conv_op_marker
= build_lang_decl (FUNCTION_DECL
, conv_op_identifier
,
4233 /* C++ extensions */
4235 unknown_type_node
= make_node (LANG_TYPE
);
4236 record_unknown_type (unknown_type_node
, "unknown type");
4238 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4239 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
4241 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4243 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
4244 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
4246 init_list_type_node
= make_node (LANG_TYPE
);
4247 record_unknown_type (init_list_type_node
, "init list");
4250 /* Make sure we get a unique function type, so we can give
4251 its pointer type a name. (This wins for gdb.) */
4252 tree vfunc_type
= make_node (FUNCTION_TYPE
);
4253 TREE_TYPE (vfunc_type
) = integer_type_node
;
4254 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
4255 layout_type (vfunc_type
);
4257 vtable_entry_type
= build_pointer_type (vfunc_type
);
4259 record_builtin_type (RID_MAX
, "__vtbl_ptr_type", vtable_entry_type
);
4262 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
4263 layout_type (vtbl_type_node
);
4264 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
4265 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
4266 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
4267 layout_type (vtbl_ptr_type_node
);
4268 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
4270 push_namespace (get_identifier ("__cxxabiv1"));
4271 abi_node
= current_namespace
;
4274 global_type_node
= make_node (LANG_TYPE
);
4275 record_unknown_type (global_type_node
, "global type");
4277 any_targ_node
= make_node (LANG_TYPE
);
4278 record_unknown_type (any_targ_node
, "any type");
4281 current_lang_name
= lang_name_cplusplus
;
4283 if (aligned_new_threshold
> 1
4284 && !pow2p_hwi (aligned_new_threshold
))
4286 error ("%<-faligned-new=%d%> is not a power of two",
4287 aligned_new_threshold
);
4288 aligned_new_threshold
= 1;
4290 if (aligned_new_threshold
== -1)
4291 aligned_new_threshold
= (cxx_dialect
>= cxx17
) ? 1 : 0;
4292 if (aligned_new_threshold
== 1)
4293 aligned_new_threshold
= malloc_alignment () / BITS_PER_UNIT
;
4296 tree newattrs
, extvisattr
;
4297 tree newtype
, deltype
;
4298 tree ptr_ftype_sizetype
;
4302 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
4303 if (cxx_dialect
== cxx98
)
4306 tree bad_alloc_type_node
;
4307 tree bad_alloc_decl
;
4309 push_namespace (std_identifier
);
4310 bad_alloc_id
= get_identifier ("bad_alloc");
4311 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
4312 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
4314 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
4315 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
4319 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
4322 new_eh_spec
= noexcept_false_spec
;
4324 /* Ensure attribs.c is initialized. */
4327 /* Ensure constraint.cc is initialized. */
4328 init_constraint_processing ();
4330 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
4332 newattrs
= tree_cons (get_identifier ("alloc_size"),
4333 build_tree_list (NULL_TREE
, integer_one_node
),
4335 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
4336 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4337 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
4338 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4339 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4340 DECL_IS_MALLOC (opnew
) = 1;
4341 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4342 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4343 DECL_IS_MALLOC (opnew
) = 1;
4344 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4345 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4346 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4347 if (flag_sized_deallocation
)
4349 /* Also push the sized deallocation variants:
4350 void operator delete(void*, std::size_t) throw();
4351 void operator delete[](void*, std::size_t) throw(); */
4352 tree void_ftype_ptr_size
4353 = build_function_type_list (void_type_node
, ptr_type_node
,
4354 size_type_node
, NULL_TREE
);
4355 deltype
= cp_build_type_attribute_variant (void_ftype_ptr_size
,
4357 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4358 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4359 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4362 if (aligned_new_threshold
)
4364 push_namespace (std_identifier
);
4365 tree align_id
= get_identifier ("align_val_t");
4366 align_type_node
= start_enum (align_id
, NULL_TREE
, size_type_node
,
4367 NULL_TREE
, /*scoped*/true, NULL
);
4370 /* operator new (size_t, align_val_t); */
4371 newtype
= build_function_type_list (ptr_type_node
, size_type_node
,
4372 align_type_node
, NULL_TREE
);
4373 newtype
= cp_build_type_attribute_variant (newtype
, newattrs
);
4374 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4375 opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4376 DECL_IS_MALLOC (opnew
) = 1;
4377 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4378 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4379 DECL_IS_MALLOC (opnew
) = 1;
4380 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4382 /* operator delete (void *, align_val_t); */
4383 deltype
= build_function_type_list (void_type_node
, ptr_type_node
,
4384 align_type_node
, NULL_TREE
);
4385 deltype
= cp_build_type_attribute_variant (deltype
, extvisattr
);
4386 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4387 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4388 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4390 if (flag_sized_deallocation
)
4392 /* operator delete (void *, size_t, align_val_t); */
4393 deltype
= build_function_type_list (void_type_node
, ptr_type_node
,
4394 size_type_node
, align_type_node
,
4396 deltype
= cp_build_type_attribute_variant (deltype
, extvisattr
);
4397 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4398 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4399 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4403 nullptr_type_node
= make_node (NULLPTR_TYPE
);
4404 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
4405 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
4406 TYPE_UNSIGNED (nullptr_type_node
) = 1;
4407 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
4408 if (abi_version_at_least (9))
4409 SET_TYPE_ALIGN (nullptr_type_node
, GET_MODE_ALIGNMENT (ptr_mode
));
4410 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
4411 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
4412 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
4416 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
4417 ECF_NORETURN
| ECF_NOTHROW
| ECF_COLD
);
4419 /* Perform other language dependent initializations. */
4420 init_class_processing ();
4421 init_rtti_processing ();
4422 init_template_processing ();
4424 if (flag_exceptions
)
4425 init_exception_processing ();
4427 if (! supports_one_only ())
4430 make_fname_decl
= cp_make_fname_decl
;
4431 start_fname_decls ();
4433 /* Show we use EH for cleanups. */
4434 if (flag_exceptions
)
4435 using_eh_for_cleanups ();
4438 /* Generate an initializer for a function naming variable from
4439 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4440 filled in with the type of the init. */
4443 cp_fname_init (const char* name
, tree
*type_p
)
4445 tree domain
= NULL_TREE
;
4447 tree init
= NULL_TREE
;
4452 length
= strlen (name
);
4453 domain
= build_index_type (size_int (length
));
4454 init
= build_string (length
+ 1, name
);
4457 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
4458 type
= build_cplus_array_type (type
, domain
);
4463 TREE_TYPE (init
) = type
;
4465 init
= error_mark_node
;
4470 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4471 the decl, LOC is the location to give the decl, NAME is the
4472 initialization string and TYPE_DEP indicates whether NAME depended
4473 on the type of the function. We make use of that to detect
4474 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4475 at the point of first use, so we mustn't push the decl now. */
4478 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4480 const char *const name
= (type_dep
&& in_template_function ()
4481 ? NULL
: fname_as_string (type_dep
));
4483 tree init
= cp_fname_init (name
, &type
);
4484 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4487 free (CONST_CAST (char *, name
));
4489 /* As we're using pushdecl_with_scope, we must set the context. */
4490 DECL_CONTEXT (decl
) = current_function_decl
;
4492 TREE_READONLY (decl
) = 1;
4493 DECL_ARTIFICIAL (decl
) = 1;
4494 DECL_DECLARED_CONSTEXPR_P (decl
) = 1;
4495 TREE_STATIC (decl
) = 1;
4497 TREE_USED (decl
) = 1;
4501 SET_DECL_VALUE_EXPR (decl
, init
);
4502 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
4503 /* For decl_constant_var_p. */
4504 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
4507 if (current_function_decl
)
4509 DECL_CONTEXT (decl
) = current_function_decl
;
4510 decl
= pushdecl_outermost_localscope (decl
);
4511 if (decl
!= error_mark_node
)
4512 add_decl_expr (decl
);
4516 DECL_THIS_STATIC (decl
) = true;
4517 pushdecl_top_level_and_finish (decl
, NULL_TREE
);
4524 builtin_function_1 (tree decl
, tree context
, bool is_global
)
4526 tree id
= DECL_NAME (decl
);
4527 const char *name
= IDENTIFIER_POINTER (id
);
4529 retrofit_lang_decl (decl
);
4531 DECL_ARTIFICIAL (decl
) = 1;
4532 SET_DECL_LANGUAGE (decl
, lang_c
);
4533 /* Runtime library routines are, by definition, available in an
4534 external shared object. */
4535 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4536 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4538 DECL_CONTEXT (decl
) = context
;
4540 /* A function in the user's namespace should have an explicit
4541 declaration before it is used. Mark the built-in function as
4542 anticipated but not actually declared. */
4543 if (name
[0] != '_' || name
[1] != '_')
4544 DECL_ANTICIPATED (decl
) = 1;
4545 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4547 size_t len
= strlen (name
);
4549 /* Treat __*_chk fortification functions as anticipated as well,
4550 unless they are __builtin_*. */
4551 if (len
> strlen ("___chk")
4552 && memcmp (name
+ len
- strlen ("_chk"),
4553 "_chk", strlen ("_chk") + 1) == 0)
4554 DECL_ANTICIPATED (decl
) = 1;
4558 return pushdecl_top_level (decl
);
4560 return pushdecl (decl
);
4564 cxx_builtin_function (tree decl
)
4566 tree id
= DECL_NAME (decl
);
4567 const char *name
= IDENTIFIER_POINTER (id
);
4568 /* All builtins that don't begin with an '_' should additionally
4569 go in the 'std' namespace. */
4572 tree decl2
= copy_node(decl
);
4573 push_namespace (std_identifier
);
4574 builtin_function_1 (decl2
, std_node
, false);
4578 return builtin_function_1 (decl
, NULL_TREE
, false);
4581 /* Like cxx_builtin_function, but guarantee the function is added to the global
4582 scope. This is to allow function specific options to add new machine
4583 dependent builtins when the target ISA changes via attribute((target(...)))
4584 which saves space on program startup if the program does not use non-generic
4588 cxx_builtin_function_ext_scope (tree decl
)
4591 tree id
= DECL_NAME (decl
);
4592 const char *name
= IDENTIFIER_POINTER (id
);
4593 /* All builtins that don't begin with an '_' should additionally
4594 go in the 'std' namespace. */
4597 tree decl2
= copy_node(decl
);
4598 push_namespace (std_identifier
);
4599 builtin_function_1 (decl2
, std_node
, true);
4603 return builtin_function_1 (decl
, NULL_TREE
, true);
4606 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4607 function. Not called directly. */
4610 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4613 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4614 DECL_EXTERNAL (fn
) = 1;
4615 TREE_PUBLIC (fn
) = 1;
4616 DECL_ARTIFICIAL (fn
) = 1;
4617 DECL_OVERLOADED_OPERATOR_CODE_RAW (fn
)
4618 = OVL_OP_INFO (false, operator_code
)->ovl_op_code
;
4619 SET_DECL_LANGUAGE (fn
, lang_c
);
4620 /* Runtime library routines are, by definition, available in an
4621 external shared object. */
4622 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4623 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4624 set_call_expr_flags (fn
, ecf_flags
);
4628 /* Returns the _DECL for a library function with C++ linkage. */
4631 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4634 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4635 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4636 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4640 /* Like build_library_fn, but takes a C string instead of an
4644 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4646 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4649 /* Like build_cp_library_fn, but takes a C string instead of an
4653 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4655 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4659 /* Like build_library_fn, but also pushes the function so that we will
4660 be able to find it via get_global_binding. Also, the function
4661 may throw exceptions listed in RAISES. */
4664 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4669 type
= build_exception_variant (type
, raises
);
4671 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4672 pushdecl_top_level (fn
);
4676 /* Like build_cp_library_fn, but also pushes the function so that it
4677 will be found by normal lookup. */
4680 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4683 tree fn
= build_cp_library_fn (ovl_op_identifier (false, operator_code
),
4684 operator_code
, type
, ecf_flags
);
4687 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4691 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4695 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4697 tree type
= build_function_type (void_type_node
, parmtypes
);
4698 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4701 /* Like push_library_fn, but also note that this function throws
4702 and does not return. Used for __throw_foo and the like. */
4705 push_throw_library_fn (tree name
, tree type
)
4707 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
| ECF_COLD
);
4711 /* When we call finish_struct for an anonymous union, we create
4712 default copy constructors and such. But, an anonymous union
4713 shouldn't have such things; this function undoes the damage to the
4714 anonymous union type T.
4716 (The reason that we create the synthesized methods is that we don't
4717 distinguish `union { int i; }' from `typedef union { int i; } U'.
4718 The first is an anonymous union; the second is just an ordinary
4722 fixup_anonymous_aggr (tree t
)
4724 /* Wipe out memory of synthesized methods. */
4725 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4726 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4727 TYPE_HAS_COPY_CTOR (t
) = 0;
4728 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4729 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4730 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4732 /* Splice the implicitly generated functions out of TYPE_FIELDS. */
4733 for (tree probe
, *prev_p
= &TYPE_FIELDS (t
); (probe
= *prev_p
);)
4734 if (TREE_CODE (probe
) == FUNCTION_DECL
&& DECL_ARTIFICIAL (probe
))
4735 *prev_p
= DECL_CHAIN (probe
);
4737 prev_p
= &DECL_CHAIN (probe
);
4739 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4740 assignment operators (because they cannot have these methods themselves).
4741 For anonymous unions this is already checked because they are not allowed
4742 in any union, otherwise we have to check it. */
4743 if (TREE_CODE (t
) != UNION_TYPE
)
4747 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4748 if (TREE_CODE (field
) == FIELD_DECL
)
4750 type
= TREE_TYPE (field
);
4751 if (CLASS_TYPE_P (type
))
4753 if (TYPE_NEEDS_CONSTRUCTING (type
))
4754 error ("member %q+#D with constructor not allowed "
4755 "in anonymous aggregate", field
);
4756 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4757 error ("member %q+#D with destructor not allowed "
4758 "in anonymous aggregate", field
);
4759 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4760 error ("member %q+#D with copy assignment operator "
4761 "not allowed in anonymous aggregate", field
);
4767 /* Warn for an attribute located at LOCATION that appertains to the
4768 class type CLASS_TYPE that has not been properly placed after its
4769 class-key, in it class-specifier. */
4772 warn_misplaced_attr_for_class_type (location_t location
,
4775 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4777 auto_diagnostic_group d
;
4778 if (warning_at (location
, OPT_Wattributes
,
4779 "attribute ignored in declaration "
4780 "of %q#T", class_type
))
4782 "attribute for %q#T must follow the %qs keyword",
4783 class_type
, class_key_or_enum_as_string (class_type
));
4786 /* Make sure that a declaration with no declarator is well-formed, i.e.
4787 just declares a tagged type or anonymous union.
4789 Returns the type declared; or NULL_TREE if none. */
4792 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4793 bool explicit_type_instantiation_p
)
4795 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4796 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4797 /* If a class, struct, or enum type is declared by the DECLSPECS
4798 (i.e, if a class-specifier, enum-specifier, or non-typename
4799 elaborated-type-specifier appears in the DECLSPECS),
4800 DECLARED_TYPE is set to the corresponding type. */
4801 tree declared_type
= NULL_TREE
;
4802 bool error_p
= false;
4804 if (declspecs
->multiple_types_p
)
4805 error ("multiple types in one declaration");
4806 else if (declspecs
->redefined_builtin_type
)
4808 if (!in_system_header_at (input_location
))
4809 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4810 "redeclaration of C++ built-in type %qT",
4811 declspecs
->redefined_builtin_type
);
4816 && TYPE_P (declspecs
->type
)
4817 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4818 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4819 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4820 declared_type
= declspecs
->type
;
4821 else if (declspecs
->type
== error_mark_node
)
4824 if (type_uses_auto (declared_type
))
4826 error_at (declspecs
->locations
[ds_type_spec
],
4827 "%<auto%> can only be specified for variables "
4828 "or function declarations");
4829 return error_mark_node
;
4832 if (declared_type
&& !OVERLOAD_TYPE_P (declared_type
))
4833 declared_type
= NULL_TREE
;
4835 if (!declared_type
&& !saw_friend
&& !error_p
)
4836 permerror (input_location
, "declaration does not declare anything");
4837 /* Check for an anonymous union. */
4838 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4839 && TYPE_UNNAMED_P (declared_type
))
4841 /* 7/3 In a simple-declaration, the optional init-declarator-list
4842 can be omitted only when declaring a class (clause 9) or
4843 enumeration (7.2), that is, when the decl-specifier-seq contains
4844 either a class-specifier, an elaborated-type-specifier with
4845 a class-key (9.1), or an enum-specifier. In these cases and
4846 whenever a class-specifier or enum-specifier is present in the
4847 decl-specifier-seq, the identifiers in these specifiers are among
4848 the names being declared by the declaration (as class-name,
4849 enum-names, or enumerators, depending on the syntax). In such
4850 cases, and except for the declaration of an unnamed bit-field (9.6),
4851 the decl-specifier-seq shall introduce one or more names into the
4852 program, or shall redeclare a name introduced by a previous
4853 declaration. [Example:
4854 enum { }; // ill-formed
4855 typedef class { }; // ill-formed
4859 error ("missing type-name in typedef-declaration");
4862 /* Anonymous unions are objects, so they can have specifiers. */;
4863 SET_ANON_AGGR_TYPE_P (declared_type
);
4865 if (TREE_CODE (declared_type
) != UNION_TYPE
4866 && !in_system_header_at (input_location
))
4867 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4872 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
4873 error_at (declspecs
->locations
[ds_inline
],
4874 "%<inline%> can only be specified for functions");
4875 else if (decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4876 error_at (declspecs
->locations
[ds_virtual
],
4877 "%<virtual%> can only be specified for functions");
4879 && (!current_class_type
4880 || current_scope () != current_class_type
))
4881 error_at (declspecs
->locations
[ds_friend
],
4882 "%<friend%> can only be specified inside a class");
4883 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4884 error_at (declspecs
->locations
[ds_explicit
],
4885 "%<explicit%> can only be specified for constructors");
4886 else if (declspecs
->storage_class
)
4887 error_at (declspecs
->locations
[ds_storage_class
],
4888 "a storage class can only be specified for objects "
4890 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
4891 error_at (declspecs
->locations
[ds_const
],
4892 "%<const%> can only be specified for objects and "
4894 else if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
4895 error_at (declspecs
->locations
[ds_volatile
],
4896 "%<volatile%> can only be specified for objects and "
4898 else if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
4899 error_at (declspecs
->locations
[ds_restrict
],
4900 "%<__restrict%> can only be specified for objects and "
4902 else if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4903 error_at (declspecs
->locations
[ds_thread
],
4904 "%<__thread%> can only be specified for objects "
4906 else if (saw_typedef
)
4907 warning_at (declspecs
->locations
[ds_typedef
], 0,
4908 "%<typedef%> was ignored in this declaration");
4909 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4910 error_at (declspecs
->locations
[ds_constexpr
],
4911 "%<constexpr%> cannot be used for type declarations");
4914 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4917 if (!CLASS_TYPE_P (declared_type
)
4918 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4919 /* For a non-template class, use the name location. */
4920 loc
= location_of (declared_type
);
4922 /* For a template class (an explicit instantiation), use the
4923 current location. */
4924 loc
= input_location
;
4926 if (explicit_type_instantiation_p
)
4927 /* [dcl.attr.grammar]/4:
4929 No attribute-specifier-seq shall appertain to an explicit
4932 if (warning_at (loc
, OPT_Wattributes
,
4933 "attribute ignored in explicit instantiation %q#T",
4936 "no attribute can be applied to "
4937 "an explicit instantiation");
4940 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4943 return declared_type
;
4946 /* Called when a declaration is seen that contains no names to declare.
4947 If its type is a reference to a structure, union or enum inherited
4948 from a containing scope, shadow that tag name for the current scope
4949 with a forward reference.
4950 If its type defines a new named structure or union
4951 or defines an enum, it is valid but we need not do anything here.
4952 Otherwise, it is an error.
4954 C++: may have to grok the declspecs to learn about static,
4955 complain for anonymous unions.
4957 Returns the TYPE declared -- or NULL_TREE if none. */
4960 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4962 tree t
= check_tag_decl (declspecs
,
4963 /*explicit_type_instantiation_p=*/false);
4968 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4971 /* This is where the variables in an anonymous union are
4972 declared. An anonymous union declaration looks like:
4974 because there is no declarator after the union, the parser
4975 sends that declaration here. */
4976 if (ANON_AGGR_TYPE_P (t
))
4978 fixup_anonymous_aggr (t
);
4980 if (TYPE_FIELDS (t
))
4982 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4983 declspecs
, NORMAL
, 0, NULL
);
4984 finish_anon_union (decl
);
4991 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4994 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4995 const cp_declarator
*declarator
,
4996 bool is_template_arg
)
5000 enum decl_context context
5001 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
5002 attrs
= type_specifiers
->attributes
;
5003 type_specifiers
->attributes
= NULL_TREE
;
5004 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
5005 if (attrs
&& type
!= error_mark_node
)
5007 if (CLASS_TYPE_P (type
))
5008 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
5009 "outside of definition", type
);
5010 else if (MAYBE_CLASS_TYPE_P (type
))
5011 /* A template type parameter or other dependent type. */
5012 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
5013 "type %qT without an associated declaration", type
);
5015 cplus_decl_attributes (&type
, attrs
, 0);
5020 /* Process a DECLARATOR for a function-scope variable declaration,
5021 namespace-scope variable declaration, or function declaration.
5022 (Function definitions go through start_function; class member
5023 declarations appearing in the body of the class go through
5024 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5025 If an error occurs, the error_mark_node is returned instead.
5027 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5028 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5029 for an explicitly defaulted function, or SD_DELETED for an explicitly
5030 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5031 implicitly initialized via a default constructor. ATTRIBUTES and
5032 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
5034 The scope represented by the context of the returned DECL is pushed
5035 (if it is not the global namespace) and is assigned to
5036 *PUSHED_SCOPE_P. The caller is then responsible for calling
5037 pop_scope on *PUSHED_SCOPE_P if it is set. */
5040 start_decl (const cp_declarator
*declarator
,
5041 cp_decl_specifier_seq
*declspecs
,
5044 tree prefix_attributes
,
5045 tree
*pushed_scope_p
)
5053 *pushed_scope_p
= NULL_TREE
;
5055 /* An object declared as __attribute__((deprecated)) suppresses
5056 warnings of uses of other deprecated items. */
5057 if (lookup_attribute ("deprecated", attributes
))
5058 deprecated_state
= DEPRECATED_SUPPRESS
;
5060 attributes
= chainon (attributes
, prefix_attributes
);
5062 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
5065 deprecated_state
= DEPRECATED_NORMAL
;
5067 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
5068 || decl
== error_mark_node
)
5069 return error_mark_node
;
5071 context
= CP_DECL_CONTEXT (decl
);
5072 if (context
!= global_namespace
)
5073 *pushed_scope_p
= push_scope (context
);
5075 /* Is it valid for this decl to have an initializer at all?
5076 If not, set INITIALIZED to zero, which will indirectly
5077 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
5079 && TREE_CODE (decl
) == TYPE_DECL
)
5081 error_at (DECL_SOURCE_LOCATION (decl
),
5082 "typedef %qD is initialized (use %qs instead)",
5084 return error_mark_node
;
5089 if (! toplevel_bindings_p ()
5090 && DECL_EXTERNAL (decl
))
5091 warning (0, "declaration of %q#D has %<extern%> and is initialized",
5093 DECL_EXTERNAL (decl
) = 0;
5094 if (toplevel_bindings_p ())
5095 TREE_STATIC (decl
) = 1;
5097 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
5099 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
5100 record_key_method_defined (decl
);
5102 /* If this is a typedef that names the class for linkage purposes
5103 (7.1.3p8), apply any attributes directly to the type. */
5104 if (TREE_CODE (decl
) == TYPE_DECL
5105 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
5106 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
5107 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
5111 /* Set attributes here so if duplicate decl, will have proper attributes. */
5112 cplus_decl_attributes (&decl
, attributes
, flags
);
5114 /* Dllimported symbols cannot be defined. Static data members (which
5115 can be initialized in-class and dllimported) go through grokfield,
5116 not here, so we don't need to exclude those decls when checking for
5118 if (initialized
&& DECL_DLLIMPORT_P (decl
))
5120 error_at (DECL_SOURCE_LOCATION (decl
),
5121 "definition of %q#D is marked %<dllimport%>", decl
);
5122 DECL_DLLIMPORT_P (decl
) = 0;
5125 /* If #pragma weak was used, mark the decl weak now. */
5126 if (!processing_template_decl
&& !DECL_DECOMPOSITION_P (decl
))
5127 maybe_apply_pragma_weak (decl
);
5129 if (TREE_CODE (decl
) == FUNCTION_DECL
5130 && DECL_DECLARED_INLINE_P (decl
)
5131 && DECL_UNINLINABLE (decl
)
5132 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
5133 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5134 "inline function %qD given attribute %qs", decl
, "noinline");
5136 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
5138 bool this_tmpl
= (processing_template_decl
5139 > template_class_depth (context
));
5142 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
5143 if (field
== NULL_TREE
5144 || !(VAR_P (field
) || variable_template_p (field
)))
5145 error ("%q+#D is not a static data member of %q#T", decl
, context
);
5146 else if (variable_template_p (field
)
5147 && (DECL_LANG_SPECIFIC (decl
)
5148 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
5149 /* OK, specialization was already checked. */;
5150 else if (variable_template_p (field
) && !this_tmpl
)
5152 error_at (DECL_SOURCE_LOCATION (decl
),
5153 "non-member-template declaration of %qD", decl
);
5154 inform (DECL_SOURCE_LOCATION (field
), "does not match "
5155 "member template declaration here");
5156 return error_mark_node
;
5160 if (variable_template_p (field
))
5161 field
= DECL_TEMPLATE_RESULT (field
);
5163 if (DECL_CONTEXT (field
) != context
)
5165 if (!same_type_p (DECL_CONTEXT (field
), context
))
5166 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
5167 "to be defined as %<%T::%D%>",
5168 DECL_CONTEXT (field
), DECL_NAME (decl
),
5169 context
, DECL_NAME (decl
));
5170 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
5172 /* Static data member are tricky; an in-class initialization
5173 still doesn't provide a definition, so the in-class
5174 declaration will have DECL_EXTERNAL set, but will have an
5175 initialization. Thus, duplicate_decls won't warn
5176 about this situation, and so we check here. */
5177 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
5178 error ("duplicate initialization of %qD", decl
);
5179 field
= duplicate_decls (decl
, field
,
5180 /*newdecl_is_friend=*/false);
5181 if (field
== error_mark_node
)
5182 return error_mark_node
;
5189 tree field
= check_classfn (context
, decl
,
5191 ? current_template_parms
5193 if (field
&& field
!= error_mark_node
5194 && duplicate_decls (decl
, field
,
5195 /*newdecl_is_friend=*/false))
5199 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5200 DECL_IN_AGGR_P (decl
) = 0;
5201 /* Do not mark DECL as an explicit specialization if it was not
5202 already marked as an instantiation; a declaration should
5203 never be marked as a specialization unless we know what
5204 template is being specialized. */
5205 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
5207 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
5208 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5209 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
5210 && DECL_DECLARED_INLINE_P (decl
));
5212 DECL_COMDAT (decl
) = false;
5214 /* [temp.expl.spec] An explicit specialization of a static data
5215 member of a template is a definition if the declaration
5216 includes an initializer; otherwise, it is a declaration.
5218 We check for processing_specialization so this only applies
5219 to the new specialization syntax. */
5220 if (!initialized
&& processing_specialization
)
5221 DECL_EXTERNAL (decl
) = 1;
5224 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
5225 /* Aliases are definitions. */
5227 permerror (declarator
->id_loc
,
5228 "declaration of %q#D outside of class is not definition",
5232 was_public
= TREE_PUBLIC (decl
);
5234 /* Enter this declaration into the symbol table. Don't push the plain
5235 VAR_DECL for a variable template. */
5236 if (!template_parm_scope_p ()
5238 decl
= maybe_push_decl (decl
);
5240 if (processing_template_decl
)
5241 decl
= push_template_decl (decl
);
5242 if (decl
== error_mark_node
)
5243 return error_mark_node
;
5246 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
5247 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
5249 /* This is a const variable with implicit 'static'. Set
5250 DECL_THIS_STATIC so we can tell it from variables that are
5251 !TREE_PUBLIC because of the anonymous namespace. */
5252 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
5253 DECL_THIS_STATIC (decl
) = 1;
5256 if (current_function_decl
&& VAR_P (decl
)
5257 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
5260 if (CP_DECL_THREAD_LOCAL_P (decl
))
5261 error_at (DECL_SOURCE_LOCATION (decl
),
5262 "%qD declared %<thread_local%> in %<constexpr%> function",
5264 else if (TREE_STATIC (decl
))
5265 error_at (DECL_SOURCE_LOCATION (decl
),
5266 "%qD declared %<static%> in %<constexpr%> function", decl
);
5270 cp_function_chain
->invalid_constexpr
= true;
5273 if (!processing_template_decl
&& VAR_P (decl
))
5274 start_decl_1 (decl
, initialized
);
5279 /* Process the declaration of a variable DECL. INITIALIZED is true
5280 iff DECL is explicitly initialized. (INITIALIZED is false if the
5281 variable is initialized via an implicitly-called constructor.)
5282 This function must be called for ordinary variables (including, for
5283 example, implicit instantiations of templates), but must not be
5284 called for template declarations. */
5287 start_decl_1 (tree decl
, bool initialized
)
5291 bool aggregate_definition_p
;
5293 gcc_assert (!processing_template_decl
);
5295 if (error_operand_p (decl
))
5298 gcc_assert (VAR_P (decl
));
5300 type
= TREE_TYPE (decl
);
5301 complete_p
= COMPLETE_TYPE_P (type
);
5302 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
5304 /* If an explicit initializer is present, or if this is a definition
5305 of an aggregate, then we need a complete type at this point.
5306 (Scalars are always complete types, so there is nothing to
5307 check.) This code just sets COMPLETE_P; errors (if necessary)
5308 are issued below. */
5309 if ((initialized
|| aggregate_definition_p
)
5311 && COMPLETE_TYPE_P (complete_type (type
)))
5314 /* We will not yet have set TREE_READONLY on DECL if the type
5315 was "const", but incomplete, before this point. But, now, we
5316 have a complete type, so we can try again. */
5317 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
5321 /* Is it valid for this decl to have an initializer at all? */
5323 /* Don't allow initializations for incomplete types except for
5324 arrays which might be completed by the initialization. */
5326 ; /* A complete type is ok. */
5327 else if (type_uses_auto (type
))
5328 ; /* An auto type is ok. */
5329 else if (TREE_CODE (type
) != ARRAY_TYPE
)
5331 error ("variable %q#D has initializer but incomplete type", decl
);
5332 type
= TREE_TYPE (decl
) = error_mark_node
;
5334 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
5336 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
5337 error ("elements of array %q#D have incomplete type", decl
);
5338 /* else we already gave an error in start_decl. */
5341 else if (aggregate_definition_p
&& !complete_p
)
5343 if (type_uses_auto (type
))
5344 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (type
));
5347 error ("aggregate %q#D has incomplete type and cannot be defined",
5349 /* Change the type so that assemble_variable will give
5350 DECL an rtl we can live with: (mem (const_int 0)). */
5351 type
= TREE_TYPE (decl
) = error_mark_node
;
5355 /* Create a new scope to hold this declaration if necessary.
5356 Whether or not a new scope is necessary cannot be determined
5357 until after the type has been completed; if the type is a
5358 specialization of a class template it is not until after
5359 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5360 will be set correctly. */
5361 maybe_push_cleanup_level (type
);
5364 /* Handle initialization of references. DECL, TYPE, and INIT have the
5365 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5366 but will be set to a new CLEANUP_STMT if a temporary is created
5367 that must be destroyed subsequently.
5369 Returns an initializer expression to use to initialize DECL, or
5370 NULL if the initialization can be performed statically.
5372 Quotes on semantics can be found in ARM 8.4.3. */
5375 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
5377 if (init
== NULL_TREE
)
5379 if ((DECL_LANG_SPECIFIC (decl
) == 0
5380 || DECL_IN_AGGR_P (decl
) == 0)
5381 && ! DECL_THIS_EXTERN (decl
))
5382 error_at (DECL_SOURCE_LOCATION (decl
),
5383 "%qD declared as reference but not initialized", decl
);
5387 if (TREE_CODE (init
) == TREE_LIST
)
5388 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5389 tf_warning_or_error
);
5391 tree ttype
= TREE_TYPE (type
);
5392 if (TREE_CODE (ttype
) != ARRAY_TYPE
5393 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
5394 /* Note: default conversion is only called in very special cases. */
5395 init
= decay_conversion (init
, tf_warning_or_error
);
5397 /* check_initializer handles this for non-reference variables, but for
5398 references we need to do it here or the initializer will get the
5399 incomplete array type and confuse later calls to
5400 cp_complete_array_type. */
5401 if (TREE_CODE (ttype
) == ARRAY_TYPE
5402 && TYPE_DOMAIN (ttype
) == NULL_TREE
5403 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
5404 || TREE_CODE (init
) == STRING_CST
))
5406 cp_complete_array_type (&ttype
, init
, false);
5407 if (ttype
!= TREE_TYPE (type
))
5408 type
= cp_build_reference_type (ttype
, TYPE_REF_IS_RVALUE (type
));
5411 /* Convert INIT to the reference type TYPE. This may involve the
5412 creation of a temporary, whose lifetime must be the same as that
5413 of the reference. If so, a DECL_EXPR for the temporary will be
5414 added just after the DECL_EXPR for DECL. That's why we don't set
5415 DECL_INITIAL for local references (instead assigning to them
5416 explicitly); we need to allow the temporary to be initialized
5418 return initialize_reference (type
, init
, flags
,
5419 tf_warning_or_error
);
5422 /* Designated initializers in arrays are not supported in GNU C++.
5423 The parser cannot detect this error since it does not know whether
5424 a given brace-enclosed initializer is for a class type or for an
5425 array. This function checks that CE does not use a designated
5426 initializer. If it does, an error is issued. Returns true if CE
5427 is valid, i.e., does not have a designated initializer. */
5430 check_array_designated_initializer (constructor_elt
*ce
,
5431 unsigned HOST_WIDE_INT index
)
5433 /* Designated initializers for array elements are not supported. */
5436 /* The parser only allows identifiers as designated
5438 if (ce
->index
== error_mark_node
)
5440 error ("name used in a GNU-style designated "
5441 "initializer for an array");
5444 else if (identifier_p (ce
->index
))
5446 error ("name %qD used in a GNU-style designated "
5447 "initializer for an array", ce
->index
);
5451 tree ce_index
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
5454 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index
))
5455 && (TREE_CODE (ce_index
= fold_non_dependent_expr (ce_index
))
5458 /* A C99 designator is OK if it matches the current index. */
5459 if (wi::to_wide (ce_index
) == index
)
5461 ce
->index
= ce_index
;
5465 sorry ("non-trivial designated initializers not supported");
5468 error ("C99 designator %qE is not an integral constant-expression",
5477 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5478 array until we finish parsing the initializer. If that's the
5479 situation we're in, update DECL accordingly. */
5482 maybe_deduce_size_from_array_init (tree decl
, tree init
)
5484 tree type
= TREE_TYPE (decl
);
5486 if (TREE_CODE (type
) == ARRAY_TYPE
5487 && TYPE_DOMAIN (type
) == NULL_TREE
5488 && TREE_CODE (decl
) != TYPE_DECL
)
5490 /* do_default is really a C-ism to deal with tentative definitions.
5491 But let's leave it here to ease the eventual merge. */
5492 int do_default
= !DECL_EXTERNAL (decl
);
5493 tree initializer
= init
? init
: DECL_INITIAL (decl
);
5496 /* Check that there are no designated initializers in INIT, as
5497 those are not supported in GNU C++, and as the middle-end
5498 will crash if presented with a non-numeric designated
5500 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
5502 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
5503 constructor_elt
*ce
;
5505 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
5507 if (instantiation_dependent_expression_p (ce
->index
))
5509 if (!check_array_designated_initializer (ce
, i
))
5515 TREE_TYPE (decl
) = error_mark_node
;
5518 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
5522 error_at (cp_expr_loc_or_loc (initializer
,
5523 DECL_SOURCE_LOCATION (decl
)),
5524 "initializer fails to determine size of %qD", decl
);
5526 else if (failure
== 2)
5530 error_at (DECL_SOURCE_LOCATION (decl
),
5531 "array size missing in %qD", decl
);
5533 /* If a `static' var's size isn't known, make it extern as
5534 well as static, so it does not get allocated. If it's not
5535 `static', then don't mark it extern; finish_incomplete_decl
5536 will give it a default size and it will get allocated. */
5537 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
5538 DECL_EXTERNAL (decl
) = 1;
5540 else if (failure
== 3)
5542 error_at (DECL_SOURCE_LOCATION (decl
),
5543 "zero-size array %qD", decl
);
5547 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
5549 relayout_decl (decl
);
5553 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5554 any appropriate error messages regarding the layout. */
5557 layout_var_decl (tree decl
)
5561 type
= TREE_TYPE (decl
);
5562 if (type
== error_mark_node
)
5565 /* If we haven't already laid out this declaration, do so now.
5566 Note that we must not call complete type for an external object
5567 because it's type might involve templates that we are not
5568 supposed to instantiate yet. (And it's perfectly valid to say
5569 `extern X x' for some incomplete type `X'.) */
5570 if (!DECL_EXTERNAL (decl
))
5571 complete_type (type
);
5572 if (!DECL_SIZE (decl
)
5573 && TREE_TYPE (decl
) != error_mark_node
5574 && complete_or_array_type_p (type
))
5575 layout_decl (decl
, 0);
5577 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
5579 /* An automatic variable with an incomplete type: that is an error.
5580 Don't talk about array types here, since we took care of that
5581 message in grokdeclarator. */
5582 error_at (DECL_SOURCE_LOCATION (decl
),
5583 "storage size of %qD isn%'t known", decl
);
5584 TREE_TYPE (decl
) = error_mark_node
;
5587 /* Keep this code around in case we later want to control debug info
5588 based on whether a type is "used". (jason 1999-11-11) */
5590 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
5591 /* Let debugger know it should output info for this type. */
5592 note_debug_info_needed (ttype
);
5594 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
5595 note_debug_info_needed (DECL_CONTEXT (decl
));
5598 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
5599 && DECL_SIZE (decl
) != NULL_TREE
5600 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
5602 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
5603 constant_expression_warning (DECL_SIZE (decl
));
5606 error_at (DECL_SOURCE_LOCATION (decl
),
5607 "storage size of %qD isn%'t constant", decl
);
5608 TREE_TYPE (decl
) = error_mark_node
;
5613 /* If a local static variable is declared in an inline function, or if
5614 we have a weak definition, we must endeavor to create only one
5615 instance of the variable at link-time. */
5618 maybe_commonize_var (tree decl
)
5620 /* Don't mess with __FUNCTION__ and similar. */
5621 if (DECL_ARTIFICIAL (decl
))
5624 /* Static data in a function with comdat linkage also has comdat
5626 if ((TREE_STATIC (decl
)
5627 && DECL_FUNCTION_SCOPE_P (decl
)
5628 && vague_linkage_p (DECL_CONTEXT (decl
)))
5629 || (TREE_PUBLIC (decl
) && DECL_INLINE_VAR_P (decl
)))
5633 /* With weak symbols, we simply make the variable COMDAT;
5634 that will cause copies in multiple translations units to
5636 comdat_linkage (decl
);
5640 if (DECL_INITIAL (decl
) == NULL_TREE
5641 || DECL_INITIAL (decl
) == error_mark_node
)
5643 /* Without weak symbols, we can use COMMON to merge
5644 uninitialized variables. */
5645 TREE_PUBLIC (decl
) = 1;
5646 DECL_COMMON (decl
) = 1;
5650 /* While for initialized variables, we must use internal
5651 linkage -- which means that multiple copies will not
5653 TREE_PUBLIC (decl
) = 0;
5654 DECL_COMMON (decl
) = 0;
5655 DECL_INTERFACE_KNOWN (decl
) = 1;
5657 if (DECL_INLINE_VAR_P (decl
))
5658 msg
= G_("sorry: semantics of inline variable "
5659 "%q#D are wrong (you%'ll wind up with "
5660 "multiple copies)");
5662 msg
= G_("sorry: semantics of inline function "
5663 "static data %q#D are wrong (you%'ll wind "
5664 "up with multiple copies)");
5665 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5667 inform (DECL_SOURCE_LOCATION (decl
),
5668 "you can work around this by removing the initializer");
5674 /* Issue an error message if DECL is an uninitialized const variable.
5675 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
5676 context from potential_constant_expression. Returns true if all is well,
5680 check_for_uninitialized_const_var (tree decl
, bool constexpr_context_p
,
5681 tsubst_flags_t complain
)
5683 tree type
= strip_array_types (TREE_TYPE (decl
));
5685 /* ``Unless explicitly declared extern, a const object does not have
5686 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5689 && !TYPE_REF_P (type
)
5690 && (constexpr_context_p
5691 || CP_TYPE_CONST_P (type
) || var_in_constexpr_fn (decl
))
5692 && !DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
5694 tree field
= default_init_uninitialized_part (type
);
5698 bool show_notes
= true;
5700 if (!constexpr_context_p
)
5702 if (CP_TYPE_CONST_P (type
))
5704 if (complain
& tf_error
)
5705 show_notes
= permerror (DECL_SOURCE_LOCATION (decl
),
5706 "uninitialized %<const %D%>", decl
);
5710 if (!is_instantiation_of_constexpr (current_function_decl
)
5711 && (complain
& tf_error
))
5712 error_at (DECL_SOURCE_LOCATION (decl
),
5713 "uninitialized variable %qD in %<constexpr%> "
5717 cp_function_chain
->invalid_constexpr
= true;
5720 else if (complain
& tf_error
)
5721 error_at (DECL_SOURCE_LOCATION (decl
),
5722 "uninitialized variable %qD in %<constexpr%> context",
5725 if (show_notes
&& CLASS_TYPE_P (type
) && (complain
& tf_error
))
5727 tree defaulted_ctor
;
5729 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5730 "%q#T has no user-provided default constructor", type
);
5731 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5733 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5734 "constructor is not user-provided because it is "
5735 "explicitly defaulted in the class body");
5736 inform (DECL_SOURCE_LOCATION (field
),
5737 "and the implicitly-defined constructor does not "
5738 "initialize %q#D", field
);
5747 /* Structure holding the current initializer being processed by reshape_init.
5748 CUR is a pointer to the current element being processed, END is a pointer
5749 after the last element present in the initializer. */
5752 constructor_elt
*cur
;
5753 constructor_elt
*end
;
5756 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5758 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5759 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5760 initialized. If there are no more such fields, the return value
5764 next_initializable_field (tree field
)
5767 && (TREE_CODE (field
) != FIELD_DECL
5768 || DECL_UNNAMED_BIT_FIELD (field
)
5769 || (DECL_ARTIFICIAL (field
)
5770 && !(cxx_dialect
>= cxx17
&& DECL_FIELD_IS_BASE (field
)))))
5771 field
= DECL_CHAIN (field
);
5776 /* Return true for [dcl.init.list] direct-list-initialization from
5777 single element of enumeration with a fixed underlying type. */
5780 is_direct_enum_init (tree type
, tree init
)
5782 if (cxx_dialect
>= cxx17
5783 && TREE_CODE (type
) == ENUMERAL_TYPE
5784 && ENUM_FIXED_UNDERLYING_TYPE_P (type
)
5785 && TREE_CODE (init
) == CONSTRUCTOR
5786 && CONSTRUCTOR_IS_DIRECT_INIT (init
)
5787 && CONSTRUCTOR_NELTS (init
) == 1)
5792 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5793 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5794 INTEGER_CST representing the size of the array minus one (the maximum index),
5795 or NULL_TREE if the array was declared without specifying the size. D is
5796 the iterator within the constructor. */
5799 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5800 tsubst_flags_t complain
)
5803 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5804 unsigned HOST_WIDE_INT max_index_cst
= 0;
5805 unsigned HOST_WIDE_INT index
;
5807 /* The initializer for an array is always a CONSTRUCTOR. */
5808 new_init
= build_constructor (init_list_type_node
, NULL
);
5812 /* Minus 1 is used for zero sized arrays. */
5813 if (integer_all_onesp (max_index
))
5816 if (tree_fits_uhwi_p (max_index
))
5817 max_index_cst
= tree_to_uhwi (max_index
);
5818 /* sizetype is sign extended, not zero extended. */
5820 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5823 /* Set to the index of the last element with a non-zero initializer.
5824 Zero initializers for elements past this one can be dropped. */
5825 unsigned HOST_WIDE_INT last_nonzero
= -1;
5826 /* Loop until there are no more initializers. */
5828 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5832 constructor_elt
*old_cur
= d
->cur
;
5834 check_array_designated_initializer (d
->cur
, index
);
5835 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5837 if (elt_init
== error_mark_node
)
5838 return error_mark_node
;
5839 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5840 size_int (index
), elt_init
);
5841 if (!TREE_CONSTANT (elt_init
))
5842 TREE_CONSTANT (new_init
) = false;
5844 /* Pointers initialized to strings must be treated as non-zero
5845 even if the string is empty. */
5846 tree init_type
= TREE_TYPE (elt_init
);
5847 if ((POINTER_TYPE_P (elt_type
) != POINTER_TYPE_P (init_type
))
5848 || !initializer_zerop (elt_init
))
5849 last_nonzero
= index
;
5851 /* This can happen with an invalid initializer (c++/54501). */
5852 if (d
->cur
== old_cur
&& !sized_array_p
)
5856 if (sized_array_p
&& trivial_type_p (elt_type
))
5858 /* Strip trailing zero-initializers from an array of a trivial
5859 type of known size. They are redundant and get in the way
5860 of telling them apart from those with implicit zero value. */
5861 unsigned HOST_WIDE_INT nelts
= CONSTRUCTOR_NELTS (new_init
);
5862 if (last_nonzero
> nelts
)
5864 else if (last_nonzero
< nelts
- 1)
5865 nelts
= last_nonzero
+ 1;
5867 vec_safe_truncate (CONSTRUCTOR_ELTS (new_init
), nelts
);
5873 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5874 Parameters are the same of reshape_init_r. */
5877 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5879 tree max_index
= NULL_TREE
;
5881 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5883 if (TYPE_DOMAIN (type
))
5884 max_index
= array_type_nelts (type
);
5886 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5889 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5890 Parameters are the same of reshape_init_r. */
5893 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5895 tree max_index
= NULL_TREE
;
5897 gcc_assert (VECTOR_TYPE_P (type
));
5899 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5901 tree value
= d
->cur
->value
;
5902 if (!same_type_p (TREE_TYPE (value
), type
))
5904 if (complain
& tf_error
)
5905 error ("invalid type %qT as initializer for a vector of type %qT",
5906 TREE_TYPE (d
->cur
->value
), type
);
5907 value
= error_mark_node
;
5913 /* For a vector, we initialize it as an array of the appropriate size. */
5914 if (VECTOR_TYPE_P (type
))
5915 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5917 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5920 /* Subroutine of reshape_init_r, processes the initializers for classes
5921 or union. Parameters are the same of reshape_init_r. */
5924 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5925 tsubst_flags_t complain
)
5930 gcc_assert (CLASS_TYPE_P (type
));
5932 /* The initializer for a class is always a CONSTRUCTOR. */
5933 new_init
= build_constructor (init_list_type_node
, NULL
);
5934 field
= next_initializable_field (TYPE_FIELDS (type
));
5940 An initializer for an aggregate member that is an
5941 empty class shall have the form of an empty
5942 initializer-list {}. */
5943 if (!first_initializer_p
)
5945 if (complain
& tf_error
)
5946 error ("initializer for %qT must be brace-enclosed", type
);
5947 return error_mark_node
;
5952 /* Loop through the initializable fields, gathering initializers. */
5953 while (d
->cur
!= d
->end
)
5956 constructor_elt
*old_cur
= d
->cur
;
5958 /* Handle designated initializers, as an extension. */
5961 if (d
->cur
->index
== error_mark_node
)
5962 return error_mark_node
;
5964 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5966 /* We already reshaped this. */
5967 if (field
!= d
->cur
->index
)
5969 tree id
= DECL_NAME (d
->cur
->index
);
5971 gcc_checking_assert (d
->cur
->index
5972 == get_class_binding (type
, id
));
5973 field
= d
->cur
->index
;
5976 else if (TREE_CODE (d
->cur
->index
) == IDENTIFIER_NODE
)
5977 field
= get_class_binding (type
, d
->cur
->index
);
5980 if (complain
& tf_error
)
5981 error ("%<[%E] =%> used in a GNU-style designated initializer"
5982 " for class %qT", d
->cur
->index
, type
);
5983 return error_mark_node
;
5986 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5988 if (complain
& tf_error
)
5989 error ("%qT has no non-static data member named %qD", type
,
5991 return error_mark_node
;
5995 /* If we processed all the member of the class, we are done. */
5999 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
6000 /*first_initializer_p=*/false, complain
);
6001 if (field_init
== error_mark_node
)
6002 return error_mark_node
;
6004 if (d
->cur
== old_cur
&& d
->cur
->index
)
6006 /* This can happen with an invalid initializer for a flexible
6007 array member (c++/54441). */
6008 if (complain
& tf_error
)
6009 error ("invalid initializer for %q#D", field
);
6010 return error_mark_node
;
6013 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
6017 When a union is initialized with a brace-enclosed
6018 initializer, the braces shall only contain an
6019 initializer for the first member of the union. */
6020 if (TREE_CODE (type
) == UNION_TYPE
)
6023 field
= next_initializable_field (DECL_CHAIN (field
));
6029 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
6030 designators are not valid; either complain or return true to indicate
6031 that reshape_init_r should return error_mark_node. */
6034 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
6038 if (complain
& tf_error
)
6039 error ("C99 designator %qE outside aggregate initializer",
6047 /* Subroutine of reshape_init, which processes a single initializer (part of
6048 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
6049 iterator within the CONSTRUCTOR which points to the initializer to process.
6050 FIRST_INITIALIZER_P is true if this is the first initializer of the
6051 outermost CONSTRUCTOR node. */
6054 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
6055 tsubst_flags_t complain
)
6057 tree init
= d
->cur
->value
;
6059 if (error_operand_p (init
))
6060 return error_mark_node
;
6062 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
6063 && has_designator_problem (d
, complain
))
6064 return error_mark_node
;
6066 tree stripped_init
= tree_strip_any_location_wrapper (init
);
6068 if (TREE_CODE (type
) == COMPLEX_TYPE
)
6070 /* A complex type can be initialized from one or two initializers,
6071 but braces are not elided. */
6073 if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init
))
6075 if (CONSTRUCTOR_NELTS (stripped_init
) > 2)
6077 if (complain
& tf_error
)
6078 error ("too many initializers for %qT", type
);
6080 return error_mark_node
;
6083 else if (first_initializer_p
&& d
->cur
!= d
->end
)
6085 vec
<constructor_elt
, va_gc
> *v
= 0;
6086 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
6087 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
6088 if (has_designator_problem (d
, complain
))
6089 return error_mark_node
;
6091 init
= build_constructor (init_list_type_node
, v
);
6096 /* A non-aggregate type is always initialized with a single
6098 if (!CP_AGGREGATE_TYPE_P (type
))
6100 /* It is invalid to initialize a non-aggregate type with a
6101 brace-enclosed initializer before C++0x.
6102 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
6103 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
6104 a CONSTRUCTOR (with a record type). */
6105 if (TREE_CODE (stripped_init
) == CONSTRUCTOR
6106 /* Don't complain about a capture-init. */
6107 && !CONSTRUCTOR_IS_DIRECT_INIT (stripped_init
)
6108 && BRACE_ENCLOSED_INITIALIZER_P (stripped_init
)) /* p7626.C */
6110 if (SCALAR_TYPE_P (type
))
6112 if (cxx_dialect
< cxx11
)
6114 if (complain
& tf_error
)
6115 error ("braces around scalar initializer for type %qT",
6117 init
= error_mark_node
;
6119 else if (first_initializer_p
6120 || (CONSTRUCTOR_NELTS (stripped_init
) > 0
6121 && (BRACE_ENCLOSED_INITIALIZER_P
6122 (CONSTRUCTOR_ELT (stripped_init
,0)->value
))))
6124 if (complain
& tf_error
)
6125 error ("too many braces around scalar initializer"
6126 "for type %qT", type
);
6127 init
= error_mark_node
;
6131 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6138 /* "If T is a class type and the initializer list has a single element of
6139 type cv U, where U is T or a class derived from T, the object is
6140 initialized from that element." Even if T is an aggregate. */
6141 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
6142 && first_initializer_p
6143 && d
->end
- d
->cur
== 1
6144 && reference_related_p (type
, TREE_TYPE (init
)))
6152 All implicit type conversions (clause _conv_) are considered when
6153 initializing the aggregate member with an initializer from an
6154 initializer-list. If the initializer can initialize a member,
6155 the member is initialized. Otherwise, if the member is itself a
6156 non-empty subaggregate, brace elision is assumed and the
6157 initializer is considered for the initialization of the first
6158 member of the subaggregate. */
6159 if (TREE_CODE (init
) != CONSTRUCTOR
6160 /* But don't try this for the first initializer, since that would be
6161 looking through the outermost braces; A a2 = { a1 }; is not a
6162 valid aggregate initialization. */
6163 && !first_initializer_p
6164 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
6165 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
6172 /* [dcl.init.string]
6174 A char array (whether plain char, signed char, or unsigned char)
6175 can be initialized by a string-literal (optionally enclosed in
6176 braces); a wchar_t array can be initialized by a wide
6177 string-literal (optionally enclosed in braces). */
6178 if (TREE_CODE (type
) == ARRAY_TYPE
6179 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
6181 tree str_init
= init
;
6182 tree stripped_str_init
= stripped_init
;
6184 /* Strip one level of braces if and only if they enclose a single
6185 element (as allowed by [dcl.init.string]). */
6186 if (!first_initializer_p
6187 && TREE_CODE (stripped_str_init
) == CONSTRUCTOR
6188 && CONSTRUCTOR_NELTS (stripped_str_init
) == 1)
6190 str_init
= (*CONSTRUCTOR_ELTS (stripped_str_init
))[0].value
;
6191 stripped_str_init
= tree_strip_any_location_wrapper (str_init
);
6194 /* If it's a string literal, then it's the initializer for the array
6195 as a whole. Otherwise, continue with normal initialization for
6196 array types (one value per array element). */
6197 if (TREE_CODE (stripped_str_init
) == STRING_CST
)
6199 if (has_designator_problem (d
, complain
))
6200 return error_mark_node
;
6206 /* The following cases are about aggregates. If we are not within a full
6207 initializer already, and there is not a CONSTRUCTOR, it means that there
6208 is a missing set of braces (that is, we are processing the case for
6209 which reshape_init exists). */
6210 if (!first_initializer_p
)
6212 if (TREE_CODE (stripped_init
) == CONSTRUCTOR
)
6214 tree init_type
= TREE_TYPE (init
);
6215 if (init_type
&& TYPE_PTRMEMFUNC_P (init_type
))
6216 /* There is no need to call reshape_init for pointer-to-member
6217 function initializers, as they are always constructed correctly
6218 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
6219 which is missing outermost braces. We should warn below, and
6220 one of the routines below will wrap it in additional { }. */;
6221 /* For a nested compound literal, there is no need to reshape since
6222 we called reshape_init in finish_compound_literal, before calling
6224 else if (COMPOUND_LITERAL_P (stripped_init
)
6225 /* Similarly, a CONSTRUCTOR of the target's type is a
6226 previously digested initializer. */
6227 || same_type_ignoring_top_level_qualifiers_p (type
,
6231 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (stripped_init
));
6236 /* Something that hasn't been reshaped yet. */
6238 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (stripped_init
));
6239 return reshape_init (type
, init
, complain
);
6243 if (complain
& tf_warning
)
6244 warning (OPT_Wmissing_braces
,
6245 "missing braces around initializer for %qT",
6249 /* Dispatch to specialized routines. */
6250 if (CLASS_TYPE_P (type
))
6251 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
6252 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6253 return reshape_init_array (type
, d
, complain
);
6254 else if (VECTOR_TYPE_P (type
))
6255 return reshape_init_vector (type
, d
, complain
);
6260 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
6261 brace-enclosed aggregate initializer.
6263 INIT is the CONSTRUCTOR containing the list of initializers describing
6264 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
6265 It may not presently match the shape of the TYPE; for example:
6267 struct S { int a; int b; };
6268 struct S a[] = { 1, 2, 3, 4 };
6270 Here INIT will hold a vector of four elements, rather than a
6271 vector of two elements, each itself a vector of two elements. This
6272 routine transforms INIT from the former form into the latter. The
6273 revised CONSTRUCTOR node is returned. */
6276 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
6278 vec
<constructor_elt
, va_gc
> *v
;
6282 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
6284 v
= CONSTRUCTOR_ELTS (init
);
6286 /* An empty constructor does not need reshaping, and it is always a valid
6288 if (vec_safe_is_empty (v
))
6291 /* Handle [dcl.init.list] direct-list-initialization from
6292 single element of enumeration with a fixed underlying type. */
6293 if (is_direct_enum_init (type
, init
))
6295 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
6296 type
= cv_unqualified (type
);
6297 if (check_narrowing (ENUM_UNDERLYING_TYPE (type
), elt
, complain
))
6299 warning_sentinel
w (warn_useless_cast
);
6300 warning_sentinel
w2 (warn_ignored_qualifiers
);
6301 return cp_build_c_cast (type
, elt
, tf_warning_or_error
);
6304 return error_mark_node
;
6307 /* Recurse on this CONSTRUCTOR. */
6309 d
.end
= d
.cur
+ v
->length ();
6311 new_init
= reshape_init_r (type
, &d
, true, complain
);
6312 if (new_init
== error_mark_node
)
6313 return error_mark_node
;
6315 /* Make sure all the element of the constructor were used. Otherwise,
6316 issue an error about exceeding initializers. */
6319 if (complain
& tf_error
)
6320 error ("too many initializers for %qT", type
);
6321 return error_mark_node
;
6324 if (CONSTRUCTOR_IS_DIRECT_INIT (init
)
6325 && BRACE_ENCLOSED_INITIALIZER_P (new_init
))
6326 CONSTRUCTOR_IS_DIRECT_INIT (new_init
) = true;
6327 if (CONSTRUCTOR_IS_DESIGNATED_INIT (init
)
6328 && BRACE_ENCLOSED_INITIALIZER_P (new_init
))
6329 CONSTRUCTOR_IS_DESIGNATED_INIT (new_init
) = true;
6334 /* Verify array initializer. Returns true if errors have been reported. */
6337 check_array_initializer (tree decl
, tree type
, tree init
)
6339 tree element_type
= TREE_TYPE (type
);
6341 /* The array type itself need not be complete, because the
6342 initializer may tell us how many elements are in the array.
6343 But, the elements of the array must be complete. */
6344 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
6347 error_at (DECL_SOURCE_LOCATION (decl
),
6348 "elements of array %q#D have incomplete type", decl
);
6350 error ("elements of array %q#T have incomplete type", type
);
6353 /* A compound literal can't have variable size. */
6355 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
6356 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
6358 error ("variable-sized compound literal");
6364 /* Subroutine of check_initializer; args are passed down from that function.
6365 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
6368 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
6371 gcc_assert (stmts_are_full_exprs_p ());
6372 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
6375 /* Verify INIT (the initializer for DECL), and record the
6376 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
6377 grok_reference_init.
6379 If the return value is non-NULL, it is an expression that must be
6380 evaluated dynamically to initialize DECL. */
6383 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
6385 tree type
= TREE_TYPE (decl
);
6386 tree init_code
= NULL
;
6389 /* Things that are going to be initialized need to have complete
6391 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
6393 if (DECL_HAS_VALUE_EXPR_P (decl
))
6395 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
6396 it doesn't have storage to be initialized. */
6397 gcc_assert (init
== NULL_TREE
);
6401 if (type
== error_mark_node
)
6402 /* We will have already complained. */
6405 if (TREE_CODE (type
) == ARRAY_TYPE
)
6407 if (check_array_initializer (decl
, type
, init
))
6410 else if (!COMPLETE_TYPE_P (type
))
6412 error_at (DECL_SOURCE_LOCATION (decl
),
6413 "%q#D has incomplete type", decl
);
6414 TREE_TYPE (decl
) = error_mark_node
;
6418 /* There is no way to make a variable-sized class type in GNU C++. */
6419 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
6421 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
6423 int init_len
= CONSTRUCTOR_NELTS (init
);
6424 if (SCALAR_TYPE_P (type
))
6428 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6429 init
= build_zero_init (type
, NULL_TREE
, false);
6431 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
6433 error_at (cp_expr_loc_or_loc (init
, DECL_SOURCE_LOCATION (decl
)),
6434 "scalar object %qD requires one element in "
6435 "initializer", decl
);
6436 TREE_TYPE (decl
) = error_mark_node
;
6442 if (TREE_CODE (decl
) == CONST_DECL
)
6444 gcc_assert (!TYPE_REF_P (type
));
6446 DECL_INITIAL (decl
) = init
;
6448 gcc_assert (init
!= NULL_TREE
);
6451 else if (!init
&& DECL_REALLY_EXTERN (decl
))
6453 else if (init
|| type_build_ctor_call (type
)
6454 || TYPE_REF_P (type
))
6456 if (TYPE_REF_P (type
))
6458 init
= grok_reference_init (decl
, type
, init
, flags
);
6459 flags
|= LOOKUP_ALREADY_DIGESTED
;
6462 check_for_uninitialized_const_var (decl
, /*constexpr_context_p=*/false,
6463 tf_warning_or_error
);
6464 /* Do not reshape constructors of vectors (they don't need to be
6466 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
6468 if (is_std_init_list (type
))
6470 init
= perform_implicit_conversion (type
, init
,
6471 tf_warning_or_error
);
6472 flags
|= LOOKUP_ALREADY_DIGESTED
;
6474 else if (TYPE_NON_AGGREGATE_CLASS (type
))
6476 /* Don't reshape if the class has constructors. */
6477 if (cxx_dialect
== cxx98
)
6478 error_at (cp_expr_loc_or_loc (init
, DECL_SOURCE_LOCATION (decl
)),
6479 "in C++98 %qD must be initialized by "
6480 "constructor, not by %<{...}%>",
6483 else if (VECTOR_TYPE_P (type
) && TYPE_VECTOR_OPAQUE (type
))
6485 error ("opaque vector types cannot be initialized");
6486 init
= error_mark_node
;
6490 init
= reshape_init (type
, init
, tf_warning_or_error
);
6491 flags
|= LOOKUP_NO_NARROWING
;
6494 else if (TREE_CODE (init
) == TREE_LIST
6495 && TREE_TYPE (init
) != unknown_type_node
6496 && !MAYBE_CLASS_TYPE_P (type
))
6498 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6500 /* We get here with code like `int a (2);' */
6501 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6502 tf_warning_or_error
);
6505 /* If DECL has an array type without a specific bound, deduce the
6506 array size from the initializer. */
6507 maybe_deduce_size_from_array_init (decl
, init
);
6508 type
= TREE_TYPE (decl
);
6509 if (type
== error_mark_node
)
6512 if (((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
6513 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
6514 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
6515 && CP_AGGREGATE_TYPE_P (type
)
6516 && (CLASS_TYPE_P (type
)
6517 || !TYPE_NEEDS_CONSTRUCTING (type
)
6518 || type_has_extended_temps (type
))))
6519 || (DECL_DECOMPOSITION_P (decl
) && TREE_CODE (type
) == ARRAY_TYPE
))
6521 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
6523 /* A constructor call is a non-trivial initializer even if
6524 it isn't explicitly written. */
6525 if (TREE_SIDE_EFFECTS (init_code
))
6526 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
6528 /* If this is a constexpr initializer, expand_default_init will
6529 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6530 case, pull the initializer back out and pass it down into
6531 store_init_value. */
6532 while (TREE_CODE (init_code
) == EXPR_STMT
6533 || TREE_CODE (init_code
) == CONVERT_EXPR
)
6534 init_code
= TREE_OPERAND (init_code
, 0);
6535 if (TREE_CODE (init_code
) == INIT_EXPR
)
6537 init
= TREE_OPERAND (init_code
, 1);
6538 init_code
= NULL_TREE
;
6539 /* Don't call digest_init; it's unnecessary and will complain
6540 about aggregate initialization of non-aggregate classes. */
6541 flags
|= LOOKUP_ALREADY_DIGESTED
;
6543 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
6545 /* Declared constexpr, but no suitable initializer; massage
6546 init appropriately so we can pass it into store_init_value
6548 if (CLASS_TYPE_P (type
)
6549 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
6551 init
= build_functional_cast (type
, init
, tf_none
);
6552 if (TREE_CODE (init
) == TARGET_EXPR
)
6553 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
6555 init_code
= NULL_TREE
;
6561 if (init
&& TREE_CODE (init
) != TREE_VEC
)
6563 /* In aggregate initialization of a variable, each element
6564 initialization is a full-expression because there is no
6565 enclosing expression. */
6566 gcc_assert (stmts_are_full_exprs_p ());
6568 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
6570 if (DECL_INITIAL (decl
)
6571 && TREE_CODE (DECL_INITIAL (decl
)) == CONSTRUCTOR
6572 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (DECL_INITIAL (decl
))))
6574 tree elt
= CONSTRUCTOR_ELTS (DECL_INITIAL (decl
))->last ().value
;
6575 if (TREE_CODE (TREE_TYPE (elt
)) == ARRAY_TYPE
6576 && TYPE_SIZE (TREE_TYPE (elt
)) == NULL_TREE
)
6577 cp_complete_array_type (&TREE_TYPE (elt
), elt
, false);
6580 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
6581 && DECL_INITIAL (decl
)
6582 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
6583 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
6584 warning_at (cp_expr_loc_or_loc (DECL_INITIAL (decl
),
6585 DECL_SOURCE_LOCATION (decl
)),
6586 0, "array %qD initialized by parenthesized "
6587 "string literal %qE",
6588 decl
, DECL_INITIAL (decl
));
6594 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
6595 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
6596 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
6597 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
6600 check_for_uninitialized_const_var (decl
, /*constexpr_context_p=*/false,
6601 tf_warning_or_error
);
6604 if (init
&& init
!= error_mark_node
)
6605 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
6609 /* We might have set these in cp_finish_decl. */
6610 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
6611 TREE_CONSTANT (decl
) = false;
6615 && DECL_IN_AGGR_P (decl
)
6616 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6618 static int explained
= 0;
6620 if (cxx_dialect
< cxx11
)
6621 error ("initializer invalid for static member with constructor");
6622 else if (cxx_dialect
< cxx17
)
6623 error ("non-constant in-class initialization invalid for static "
6624 "member %qD", decl
);
6626 error ("non-constant in-class initialization invalid for non-inline "
6627 "static member %qD", decl
);
6630 inform (input_location
,
6631 "(an out of class initialization is required)");
6640 /* If DECL is not a local variable, give it RTL. */
6643 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6645 int toplev
= toplevel_bindings_p ();
6648 /* Set the DECL_ASSEMBLER_NAME for the object. */
6651 /* The `register' keyword, when used together with an
6652 asm-specification, indicates that the variable should be
6653 placed in a particular register. */
6654 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6656 set_user_assembler_name (decl
, asmspec
);
6657 DECL_HARD_REGISTER (decl
) = 1;
6661 if (TREE_CODE (decl
) == FUNCTION_DECL
6662 && fndecl_built_in_p (decl
, BUILT_IN_NORMAL
))
6663 set_builtin_user_assembler_name (decl
, asmspec
);
6664 set_user_assembler_name (decl
, asmspec
);
6668 /* Handle non-variables up front. */
6671 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6675 /* If we see a class member here, it should be a static data
6677 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6679 gcc_assert (TREE_STATIC (decl
));
6680 /* An in-class declaration of a static data member should be
6681 external; it is only a declaration, and not a definition. */
6682 if (init
== NULL_TREE
)
6683 gcc_assert (DECL_EXTERNAL (decl
)
6684 || !TREE_PUBLIC (decl
));
6687 /* We don't create any RTL for local variables. */
6688 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6691 /* We defer emission of local statics until the corresponding
6692 DECL_EXPR is expanded. But with constexpr its function might never
6693 be expanded, so go ahead and tell cgraph about the variable now. */
6694 defer_p
= ((DECL_FUNCTION_SCOPE_P (decl
)
6695 && !var_in_maybe_constexpr_fn (decl
))
6696 || DECL_VIRTUAL_P (decl
));
6698 /* Defer template instantiations. */
6699 if (DECL_LANG_SPECIFIC (decl
)
6700 && DECL_IMPLICIT_INSTANTIATION (decl
))
6703 /* If we're not deferring, go ahead and assemble the variable. */
6705 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6708 /* walk_tree helper for wrap_temporary_cleanups, below. */
6711 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6713 /* Stop at types or full-expression boundaries. */
6714 if (TYPE_P (*stmt_p
)
6715 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6721 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6723 tree guard
= (tree
)data
;
6724 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6726 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6727 /* Tell honor_protect_cleanup_actions to handle this as a separate
6729 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6731 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6737 /* We're initializing a local variable which has a cleanup GUARD. If there
6738 are any temporaries used in the initializer INIT of this variable, we
6739 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6740 variable will be cleaned up properly if one of them throws.
6742 Unfortunately, there's no way to express this properly in terms of
6743 nesting, as the regions for the temporaries overlap the region for the
6744 variable itself; if there are two temporaries, the variable needs to be
6745 the first thing destroyed if either of them throws. However, we only
6746 want to run the variable's cleanup if it actually got constructed. So
6747 we need to guard the temporary cleanups with the variable's cleanup if
6748 they are run on the normal path, but not if they are run on the
6749 exceptional path. We implement this by telling
6750 honor_protect_cleanup_actions to strip the variable cleanup from the
6751 exceptional path. */
6754 wrap_temporary_cleanups (tree init
, tree guard
)
6756 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6759 /* Generate code to initialize DECL (a local variable). */
6762 initialize_local_var (tree decl
, tree init
)
6764 tree type
= TREE_TYPE (decl
);
6768 gcc_assert (VAR_P (decl
)
6769 || TREE_CODE (decl
) == RESULT_DECL
);
6770 gcc_assert (!TREE_STATIC (decl
));
6772 if (DECL_SIZE (decl
) == NULL_TREE
)
6774 /* If we used it already as memory, it must stay in memory. */
6775 DECL_INITIAL (decl
) = NULL_TREE
;
6776 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6780 if (type
== error_mark_node
)
6783 /* Compute and store the initial value. */
6784 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6785 if (TREE_USED (type
))
6786 DECL_READ_P (decl
) = 1;
6788 /* Generate a cleanup, if necessary. */
6789 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6791 /* Perform the initialization. */
6794 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6795 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6796 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6798 /* Stick simple initializers in DECL_INITIAL so that
6799 -Wno-init-self works (c++/34772). */
6800 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6801 DECL_INITIAL (decl
) = rinit
;
6803 if (warn_init_self
&& TYPE_REF_P (type
))
6807 warning_at (DECL_SOURCE_LOCATION (decl
),
6809 "reference %qD is initialized with itself", decl
);
6814 int saved_stmts_are_full_exprs_p
;
6816 /* If we're only initializing a single object, guard the
6817 destructors of any temporaries used in its initializer with
6818 its destructor. This isn't right for arrays because each
6819 element initialization is a full-expression. */
6820 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6821 wrap_temporary_cleanups (init
, cleanup
);
6823 gcc_assert (building_stmt_list_p ());
6824 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6825 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6826 finish_expr_stmt (init
);
6827 current_stmt_tree ()->stmts_are_full_exprs_p
=
6828 saved_stmts_are_full_exprs_p
;
6832 /* Set this to 0 so we can tell whether an aggregate which was
6833 initialized was ever used. Don't do this if it has a
6834 destructor, so we don't complain about the 'resource
6835 allocation is initialization' idiom. Now set
6836 attribute((unused)) on types so decls of that type will be
6837 marked used. (see TREE_USED, above.) */
6838 if (TYPE_NEEDS_CONSTRUCTING (type
)
6840 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6841 && DECL_NAME (decl
))
6842 TREE_USED (decl
) = 0;
6843 else if (already_used
)
6844 TREE_USED (decl
) = 1;
6847 finish_decl_cleanup (decl
, cleanup
);
6850 /* DECL is a VAR_DECL for a compiler-generated variable with static
6851 storage duration (like a virtual table) whose initializer is a
6852 compile-time constant. Initialize the variable and provide it to the
6856 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6859 gcc_assert (DECL_ARTIFICIAL (decl
));
6860 init
= build_constructor (TREE_TYPE (decl
), v
);
6861 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6862 DECL_INITIAL (decl
) = init
;
6863 DECL_INITIALIZED_P (decl
) = 1;
6864 /* Mark the decl as constexpr so that we can access its content
6866 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
6867 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
6868 determine_visibility (decl
);
6869 layout_var_decl (decl
);
6870 maybe_commonize_var (decl
);
6871 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6874 /* INIT is the initializer for a variable, as represented by the
6875 parser. Returns true iff INIT is value-dependent. */
6878 value_dependent_init_p (tree init
)
6880 if (TREE_CODE (init
) == TREE_LIST
)
6881 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6882 return any_value_dependent_elements_p (init
);
6883 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6884 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6886 if (dependent_type_p (TREE_TYPE (init
)))
6889 vec
<constructor_elt
, va_gc
> *elts
;
6893 elts
= CONSTRUCTOR_ELTS (init
);
6894 nelts
= vec_safe_length (elts
);
6895 for (i
= 0; i
< nelts
; ++i
)
6896 if (value_dependent_init_p ((*elts
)[i
].value
))
6900 /* It must be a simple expression, e.g., int i = 3; */
6901 return value_dependent_expression_p (init
);
6906 // Returns true if a DECL is VAR_DECL with the concept specifier.
6908 is_concept_var (tree decl
)
6910 return (VAR_P (decl
)
6911 // Not all variables have DECL_LANG_SPECIFIC.
6912 && DECL_LANG_SPECIFIC (decl
)
6913 && DECL_DECLARED_CONCEPT_P (decl
));
6916 /* A helper function to be called via walk_tree. If any label exists
6917 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
6920 notice_forced_label_r (tree
*tp
, int *walk_subtrees
, void *)
6924 if (TREE_CODE (*tp
) == LABEL_DECL
)
6925 cfun
->has_forced_label_in_static
= 1;
6929 /* Finish processing of a declaration;
6930 install its line number and initial value.
6931 If the length of an array type is not known before,
6932 it must be determined now, from the initial value, or it is an error.
6934 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6935 true, then INIT is an integral constant expression.
6937 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6938 if the (init) syntax was used. */
6941 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6942 tree asmspec_tree
, int flags
)
6945 vec
<tree
, va_gc
> *cleanups
= NULL
;
6946 const char *asmspec
= NULL
;
6947 int was_readonly
= 0;
6948 bool var_definition_p
= false;
6951 if (decl
== error_mark_node
)
6956 error ("assignment (not initialization) in declaration");
6960 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6961 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6962 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6964 type
= TREE_TYPE (decl
);
6965 if (type
== error_mark_node
)
6968 /* Warn about register storage specifiers except when in GNU global
6969 or local register variable extension. */
6970 if (VAR_P (decl
) && DECL_REGISTER (decl
) && asmspec_tree
== NULL_TREE
)
6972 if (cxx_dialect
>= cxx17
)
6973 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
6974 "ISO C++17 does not allow %<register%> storage "
6977 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
6978 "%<register%> storage class specifier used");
6981 /* If a name was specified, get the string. */
6982 if (at_namespace_scope_p ())
6983 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6984 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6985 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6987 if (current_class_type
6988 && CP_DECL_CONTEXT (decl
) == current_class_type
6989 && TYPE_BEING_DEFINED (current_class_type
)
6990 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6991 && (DECL_INITIAL (decl
) || init
))
6992 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6994 /* Do auto deduction unless decl is a function or an uninstantiated
6995 template specialization. */
6996 if (TREE_CODE (decl
) != FUNCTION_DECL
6997 && !(init
== NULL_TREE
6998 && DECL_LANG_SPECIFIC (decl
)
6999 && DECL_TEMPLATE_INSTANTIATION (decl
)
7000 && !DECL_TEMPLATE_INSTANTIATED (decl
))
7001 && (auto_node
= type_uses_auto (type
)))
7004 if (init
== NULL_TREE
)
7005 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (auto_node
));
7009 if (TREE_CODE (d_init
) == TREE_LIST
7010 && !CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
7011 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
7012 tf_warning_or_error
);
7013 d_init
= resolve_nondeduced_context (d_init
, tf_warning_or_error
);
7015 enum auto_deduction_context adc
= adc_variable_type
;
7016 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
7017 adc
= adc_decomp_type
;
7018 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
, auto_node
,
7019 tf_warning_or_error
, adc
,
7021 if (type
== error_mark_node
)
7023 if (TREE_CODE (type
) == FUNCTION_TYPE
)
7025 error ("initializer for %<decltype(auto) %D%> has function type; "
7026 "did you forget the %<()%>?", decl
);
7027 TREE_TYPE (decl
) = error_mark_node
;
7030 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
7033 if (ensure_literal_type_for_constexpr_object (decl
) == error_mark_node
)
7035 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
7036 if (VAR_P (decl
) && DECL_CLASS_SCOPE_P (decl
))
7039 DECL_EXTERNAL (decl
) = 1;
7044 && DECL_CLASS_SCOPE_P (decl
)
7045 && DECL_INITIALIZED_IN_CLASS_P (decl
))
7046 check_static_variable_definition (decl
, type
);
7048 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
7051 if (init
== ridpointers
[(int)RID_DELETE
])
7053 /* FIXME check this is 1st decl. */
7054 DECL_DELETED_FN (decl
) = 1;
7055 DECL_DECLARED_INLINE_P (decl
) = 1;
7056 DECL_INITIAL (decl
) = error_mark_node
;
7057 FOR_EACH_CLONE (clone
, decl
)
7059 DECL_DELETED_FN (clone
) = 1;
7060 DECL_DECLARED_INLINE_P (clone
) = 1;
7061 DECL_INITIAL (clone
) = error_mark_node
;
7065 else if (init
== ridpointers
[(int)RID_DEFAULT
])
7067 if (defaultable_fn_check (decl
))
7068 DECL_DEFAULTED_FN (decl
) = 1;
7070 DECL_INITIAL (decl
) = NULL_TREE
;
7074 if (init
&& VAR_P (decl
))
7076 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
7077 /* If DECL is a reference, then we want to know whether init is a
7078 reference constant; init_const_expr_p as passed tells us whether
7079 it's an rvalue constant. */
7080 if (TYPE_REF_P (type
))
7081 init_const_expr_p
= potential_constant_expression (init
);
7082 if (init_const_expr_p
)
7084 /* Set these flags now for templates. We'll update the flags in
7085 store_init_value for instantiations. */
7086 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
7087 if (decl_maybe_constant_var_p (decl
)
7088 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
7089 && !TYPE_REF_P (type
))
7090 TREE_CONSTANT (decl
) = 1;
7094 if (processing_template_decl
)
7096 bool type_dependent_p
;
7098 /* Add this declaration to the statement-tree. */
7099 if (at_function_scope_p ())
7100 add_decl_expr (decl
);
7102 type_dependent_p
= dependent_type_p (type
);
7104 if (check_for_bare_parameter_packs (init
))
7107 DECL_INITIAL (decl
) = NULL_TREE
;
7110 /* Generally, initializers in templates are expanded when the
7111 template is instantiated. But, if DECL is a variable constant
7112 then it can be used in future constant expressions, so its value
7113 must be available. */
7115 bool dep_init
= false;
7117 if (!VAR_P (decl
) || type_dependent_p
)
7118 /* We can't do anything if the decl has dependent type. */;
7119 else if (!init
&& is_concept_var (decl
))
7121 error ("variable concept has no initializer");
7122 init
= boolean_true_node
;
7125 && init_const_expr_p
7126 && !TYPE_REF_P (type
)
7127 && decl_maybe_constant_var_p (decl
)
7128 && !(dep_init
= value_dependent_init_p (init
)))
7130 /* This variable seems to be a non-dependent constant, so process
7131 its initializer. If check_initializer returns non-null the
7132 initialization wasn't constant after all. */
7134 cleanups
= make_tree_vector ();
7135 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
7136 if (init_code
== NULL_TREE
)
7138 release_tree_vector (cleanups
);
7142 gcc_assert (!DECL_PRETTY_FUNCTION_P (decl
));
7143 /* Deduce array size even if the initializer is dependent. */
7144 maybe_deduce_size_from_array_init (decl
, init
);
7145 /* And complain about multiple initializers. */
7146 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
7147 && !MAYBE_CLASS_TYPE_P (type
))
7148 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
7149 tf_warning_or_error
);
7153 DECL_INITIAL (decl
) = init
;
7157 retrofit_lang_decl (decl
);
7158 SET_DECL_DEPENDENT_INIT_P (decl
, true);
7163 /* Just store non-static data member initializers for later. */
7164 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
7165 DECL_INITIAL (decl
) = init
;
7167 /* Take care of TYPE_DECLs up front. */
7168 if (TREE_CODE (decl
) == TYPE_DECL
)
7170 if (type
!= error_mark_node
7171 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
7173 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7174 warning (0, "shadowing previous type declaration of %q#D", decl
);
7175 set_identifier_type_value (DECL_NAME (decl
), decl
);
7178 /* If we have installed this as the canonical typedef for this
7179 type, and that type has not been defined yet, delay emitting
7180 the debug information for it, as we will emit it later. */
7181 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7182 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
7183 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
7185 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
7190 /* A reference will be modified here, as it is initialized. */
7191 if (! DECL_EXTERNAL (decl
)
7192 && TREE_READONLY (decl
)
7193 && TYPE_REF_P (type
))
7196 TREE_READONLY (decl
) = 0;
7201 /* If this is a local variable that will need a mangled name,
7202 register it now. We must do this before processing the
7203 initializer for the variable, since the initialization might
7204 require a guard variable, and since the mangled name of the
7205 guard variable will depend on the mangled name of this
7207 if (DECL_FUNCTION_SCOPE_P (decl
)
7208 && TREE_STATIC (decl
)
7209 && !DECL_ARTIFICIAL (decl
))
7211 /* The variable holding an anonymous union will have had its
7212 discriminator set in finish_anon_union, after which it's
7213 NAME will have been cleared. */
7214 if (DECL_NAME (decl
))
7215 determine_local_discriminator (decl
);
7216 /* Normally has_forced_label_in_static is set during GIMPLE
7217 lowering, but [cd]tors are never actually compiled directly.
7218 We need to set this early so we can deal with the label
7219 address extension. */
7220 if ((DECL_CONSTRUCTOR_P (current_function_decl
)
7221 || DECL_DESTRUCTOR_P (current_function_decl
))
7224 walk_tree (&init
, notice_forced_label_r
, NULL
, NULL
);
7225 add_local_decl (cfun
, decl
);
7227 /* And make sure it's in the symbol table for
7228 c_parse_final_cleanups to find. */
7229 varpool_node::get_create (decl
);
7232 /* Convert the initializer to the type of DECL, if we have not
7233 already initialized DECL. */
7234 if (!DECL_INITIALIZED_P (decl
)
7235 /* If !DECL_EXTERNAL then DECL is being defined. In the
7236 case of a static data member initialized inside the
7237 class-specifier, there can be an initializer even if DECL
7238 is *not* defined. */
7239 && (!DECL_EXTERNAL (decl
) || init
))
7241 cleanups
= make_tree_vector ();
7242 init
= check_initializer (decl
, init
, flags
, &cleanups
);
7248 The memory occupied by any object of static storage
7249 duration is zero-initialized at program startup before
7250 any other initialization takes place.
7252 We cannot create an appropriate initializer until after
7253 the type of DECL is finalized. If DECL_INITIAL is set,
7254 then the DECL is statically initialized, and any
7255 necessary zero-initialization has already been performed. */
7256 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
7257 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
7258 /*nelts=*/NULL_TREE
,
7259 /*static_storage_p=*/true);
7260 /* Remember that the initialization for this variable has
7262 DECL_INITIALIZED_P (decl
) = 1;
7263 /* This declaration is the definition of this variable,
7264 unless we are initializing a static data member within
7265 the class specifier. */
7266 if (!DECL_EXTERNAL (decl
))
7267 var_definition_p
= true;
7269 /* If the variable has an array type, lay out the type, even if
7270 there is no initializer. It is valid to index through the
7271 array, and we must get TYPE_ALIGN set correctly on the array
7273 else if (TREE_CODE (type
) == ARRAY_TYPE
)
7276 if (TREE_STATIC (decl
)
7277 && !at_function_scope_p ()
7278 && current_function_decl
== NULL
)
7279 /* So decl is a global variable or a static member of a
7280 non local class. Record the types it uses
7281 so that we can decide later to emit debug info for them. */
7282 record_types_used_by_current_var_decl (decl
);
7285 /* Add this declaration to the statement-tree. This needs to happen
7286 after the call to check_initializer so that the DECL_EXPR for a
7287 reference temp is added before the DECL_EXPR for the reference itself. */
7288 if (DECL_FUNCTION_SCOPE_P (decl
))
7290 /* If we're building a variable sized type, and we might be
7291 reachable other than via the top of the current binding
7292 level, then create a new BIND_EXPR so that we deallocate
7293 the object at the right time. */
7296 && !TREE_CONSTANT (DECL_SIZE (decl
))
7297 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
7300 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
7301 TREE_SIDE_EFFECTS (bind
) = 1;
7303 BIND_EXPR_BODY (bind
) = push_stmt_list ();
7305 add_decl_expr (decl
);
7308 /* Let the middle end know about variables and functions -- but not
7309 static data members in uninstantiated class templates. */
7310 if (VAR_OR_FUNCTION_DECL_P (decl
))
7314 layout_var_decl (decl
);
7315 maybe_commonize_var (decl
);
7318 /* This needs to happen after the linkage is set. */
7319 determine_visibility (decl
);
7321 if (var_definition_p
&& TREE_STATIC (decl
))
7323 /* If a TREE_READONLY variable needs initialization
7324 at runtime, it is no longer readonly and we need to
7325 avoid MEM_READONLY_P being set on RTL created for it. */
7328 if (TREE_READONLY (decl
))
7329 TREE_READONLY (decl
) = 0;
7332 else if (was_readonly
)
7333 TREE_READONLY (decl
) = 1;
7335 /* Likewise if it needs destruction. */
7336 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
7337 TREE_READONLY (decl
) = 0;
7340 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
7342 /* Check for abstractness of the type. Notice that there is no
7343 need to strip array types here since the check for those types
7344 is already done within create_array_type_for_decl. */
7345 abstract_virtuals_error (decl
, type
);
7347 if (TREE_TYPE (decl
) == error_mark_node
)
7348 /* No initialization required. */
7350 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
7354 if (init
== ridpointers
[(int)RID_DEFAULT
])
7356 /* An out-of-class default definition is defined at
7357 the point where it is explicitly defaulted. */
7358 if (DECL_DELETED_FN (decl
))
7359 maybe_explain_implicit_delete (decl
);
7360 else if (DECL_INITIAL (decl
) == error_mark_node
)
7361 synthesize_method (decl
);
7364 error_at (cp_expr_loc_or_loc (init
,
7365 DECL_SOURCE_LOCATION (decl
)),
7366 "function %q#D is initialized like a variable",
7369 /* else no initialization required. */
7371 else if (DECL_EXTERNAL (decl
)
7372 && ! (DECL_LANG_SPECIFIC (decl
)
7373 && DECL_NOT_REALLY_EXTERN (decl
)))
7375 /* check_initializer will have done any constant initialization. */
7377 /* A variable definition. */
7378 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
7379 /* Initialize the local variable. */
7380 initialize_local_var (decl
, init
);
7382 /* If a variable is defined, and then a subsequent
7383 definition with external linkage is encountered, we will
7384 get here twice for the same variable. We want to avoid
7385 calling expand_static_init more than once. For variables
7386 that are not static data members, we can call
7387 expand_static_init only when we actually process the
7388 initializer. It is not legal to redeclare a static data
7389 member, so this issue does not arise in that case. */
7390 else if (var_definition_p
&& TREE_STATIC (decl
))
7391 expand_static_init (decl
, init
);
7394 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
7395 reference, insert it in the statement-tree now. */
7399 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
7400 push_cleanup (decl
, t
, false);
7401 release_tree_vector (cleanups
);
7405 TREE_READONLY (decl
) = 1;
7409 && lookup_attribute ("omp declare target implicit",
7410 DECL_ATTRIBUTES (decl
)))
7412 DECL_ATTRIBUTES (decl
)
7413 = remove_attribute ("omp declare target implicit",
7414 DECL_ATTRIBUTES (decl
));
7415 complete_type (TREE_TYPE (decl
));
7416 if (!cp_omp_mappable_type (TREE_TYPE (decl
)))
7417 error ("%q+D in declare target directive does not have mappable type",
7419 else if (!lookup_attribute ("omp declare target",
7420 DECL_ATTRIBUTES (decl
))
7421 && !lookup_attribute ("omp declare target link",
7422 DECL_ATTRIBUTES (decl
)))
7423 DECL_ATTRIBUTES (decl
)
7424 = tree_cons (get_identifier ("omp declare target"),
7425 NULL_TREE
, DECL_ATTRIBUTES (decl
));
7428 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
7431 /* For class TYPE return itself or some its bases that contain
7432 any direct non-static data members. Return error_mark_node if an
7433 error has been diagnosed. */
7436 find_decomp_class_base (location_t loc
, tree type
, tree ret
)
7438 bool member_seen
= false;
7439 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
7440 if (TREE_CODE (field
) != FIELD_DECL
7441 || DECL_ARTIFICIAL (field
)
7442 || DECL_UNNAMED_BIT_FIELD (field
))
7446 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
7448 if (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
)
7449 error_at (loc
, "cannot decompose class type %qT because it has an "
7450 "anonymous struct member", type
);
7452 error_at (loc
, "cannot decompose class type %qT because it has an "
7453 "anonymous union member", type
);
7454 inform (DECL_SOURCE_LOCATION (field
), "declared here");
7455 return error_mark_node
;
7457 else if (!accessible_p (type
, field
, true))
7459 error_at (loc
, "cannot decompose inaccessible member %qD of %qT",
7461 inform (DECL_SOURCE_LOCATION (field
),
7462 TREE_PRIVATE (field
)
7463 ? G_("declared private here")
7464 : G_("declared protected here"));
7465 return error_mark_node
;
7470 tree base_binfo
, binfo
;
7471 tree orig_ret
= ret
;
7475 for (binfo
= TYPE_BINFO (type
), i
= 0;
7476 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
7478 tree t
= find_decomp_class_base (loc
, TREE_TYPE (base_binfo
), ret
);
7479 if (t
== error_mark_node
)
7480 return error_mark_node
;
7481 if (t
!= NULL_TREE
&& t
!= ret
)
7485 error_at (loc
, "cannot decompose class type %qT: both it and "
7486 "its base class %qT have non-static data members",
7488 return error_mark_node
;
7490 else if (orig_ret
!= NULL_TREE
)
7492 else if (ret
!= NULL_TREE
)
7494 error_at (loc
, "cannot decompose class type %qT: its base "
7495 "classes %qT and %qT have non-static data "
7496 "members", type
, ret
, t
);
7497 return error_mark_node
;
7506 /* Return std::tuple_size<TYPE>::value. */
7509 get_tuple_size (tree type
)
7511 tree args
= make_tree_vec (1);
7512 TREE_VEC_ELT (args
, 0) = type
;
7513 tree inst
= lookup_template_class (tuple_size_identifier
, args
,
7514 /*in_decl*/NULL_TREE
,
7515 /*context*/std_node
,
7516 /*entering_scope*/false, tf_none
);
7517 inst
= complete_type (inst
);
7518 if (inst
== error_mark_node
|| !COMPLETE_TYPE_P (inst
))
7520 tree val
= lookup_qualified_name (inst
, value_identifier
,
7521 /*type*/false, /*complain*/false);
7522 if (TREE_CODE (val
) == VAR_DECL
|| TREE_CODE (val
) == CONST_DECL
)
7523 val
= maybe_constant_value (val
);
7524 if (TREE_CODE (val
) == INTEGER_CST
)
7527 return error_mark_node
;
7530 /* Return std::tuple_element<I,TYPE>::type. */
7533 get_tuple_element_type (tree type
, unsigned i
)
7535 tree args
= make_tree_vec (2);
7536 TREE_VEC_ELT (args
, 0) = build_int_cst (integer_type_node
, i
);
7537 TREE_VEC_ELT (args
, 1) = type
;
7538 tree inst
= lookup_template_class (tuple_element_identifier
, args
,
7539 /*in_decl*/NULL_TREE
,
7540 /*context*/std_node
,
7541 /*entering_scope*/false,
7542 tf_warning_or_error
);
7543 return make_typename_type (inst
, type_identifier
,
7544 none_type
, tf_warning_or_error
);
7547 /* Return e.get<i>() or get<i>(e). */
7550 get_tuple_decomp_init (tree decl
, unsigned i
)
7552 tree targs
= make_tree_vec (1);
7553 TREE_VEC_ELT (targs
, 0) = build_int_cst (integer_type_node
, i
);
7555 tree etype
= TREE_TYPE (decl
);
7556 tree e
= convert_from_reference (decl
);
7558 /* [The id-expression] e is an lvalue if the type of the entity e is an
7559 lvalue reference and an xvalue otherwise. */
7560 if (!TYPE_REF_P (etype
)
7561 || TYPE_REF_IS_RVALUE (etype
))
7564 tree fns
= lookup_qualified_name (TREE_TYPE (e
), get__identifier
,
7565 /*type*/false, /*complain*/false);
7566 bool use_member_get
= false;
7568 /* To use a member get, member lookup must find at least one
7569 declaration that is a function template
7570 whose first template parameter is a non-type parameter. */
7571 for (lkp_iterator
iter (MAYBE_BASELINK_FUNCTIONS (fns
)); iter
; ++iter
)
7574 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
7576 tree tparms
= DECL_TEMPLATE_PARMS (fn
);
7577 tree parm
= TREE_VEC_ELT (INNERMOST_TEMPLATE_PARMS (tparms
), 0);
7578 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
7580 use_member_get
= true;
7588 fns
= lookup_template_function (fns
, targs
);
7589 return build_new_method_call (e
, fns
, /*args*/NULL
,
7590 /*path*/NULL_TREE
, LOOKUP_NORMAL
,
7591 /*fn_p*/NULL
, tf_warning_or_error
);
7595 releasing_vec
args (make_tree_vector_single (e
));
7596 fns
= lookup_template_function (get__identifier
, targs
);
7597 fns
= perform_koenig_lookup (fns
, args
, tf_warning_or_error
);
7598 return finish_call_expr (fns
, &args
, /*novirt*/false,
7599 /*koenig*/true, tf_warning_or_error
);
7603 /* It's impossible to recover the decltype of a tuple decomposition variable
7604 based on the actual type of the variable, so store it in a hash table. */
7606 static GTY((cache
)) tree_cache_map
*decomp_type_table
;
7608 store_decomp_type (tree v
, tree t
)
7610 if (!decomp_type_table
)
7611 decomp_type_table
= tree_cache_map::create_ggc (13);
7612 decomp_type_table
->put (v
, t
);
7616 lookup_decomp_type (tree v
)
7618 return *decomp_type_table
->get (v
);
7621 /* Mangle a decomposition declaration if needed. Arguments like
7622 in cp_finish_decomp. */
7625 cp_maybe_mangle_decomp (tree decl
, tree first
, unsigned int count
)
7627 if (!processing_template_decl
7628 && !error_operand_p (decl
)
7629 && TREE_STATIC (decl
))
7631 auto_vec
<tree
, 16> v
;
7632 v
.safe_grow (count
);
7634 for (unsigned int i
= 0; i
< count
; i
++, d
= DECL_CHAIN (d
))
7635 v
[count
- i
- 1] = d
;
7636 SET_DECL_ASSEMBLER_NAME (decl
, mangle_decomp (decl
, v
));
7637 maybe_apply_pragma_weak (decl
);
7641 /* Finish a decomposition declaration. DECL is the underlying declaration
7642 "e", FIRST is the head of a chain of decls for the individual identifiers
7643 chained through DECL_CHAIN in reverse order and COUNT is the number of
7647 cp_finish_decomp (tree decl
, tree first
, unsigned int count
)
7649 if (error_operand_p (decl
))
7654 TREE_TYPE (first
) = error_mark_node
;
7655 if (DECL_HAS_VALUE_EXPR_P (first
))
7657 SET_DECL_VALUE_EXPR (first
, NULL_TREE
);
7658 DECL_HAS_VALUE_EXPR_P (first
) = 0;
7660 first
= DECL_CHAIN (first
);
7662 if (DECL_P (decl
) && DECL_NAMESPACE_SCOPE_P (decl
))
7663 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier ("<decomp>"));
7667 location_t loc
= DECL_SOURCE_LOCATION (decl
);
7668 if (type_dependent_expression_p (decl
)
7669 /* This happens for range for when not in templates.
7670 Still add the DECL_VALUE_EXPRs for later processing. */
7671 || (!processing_template_decl
7672 && type_uses_auto (TREE_TYPE (decl
))))
7674 for (unsigned int i
= 0; i
< count
; i
++)
7676 if (!DECL_HAS_VALUE_EXPR_P (first
))
7678 tree v
= build_nt (ARRAY_REF
, decl
,
7679 size_int (count
- i
- 1),
7680 NULL_TREE
, NULL_TREE
);
7681 SET_DECL_VALUE_EXPR (first
, v
);
7682 DECL_HAS_VALUE_EXPR_P (first
) = 1;
7684 if (processing_template_decl
)
7685 fit_decomposition_lang_decl (first
, decl
);
7686 first
= DECL_CHAIN (first
);
7691 auto_vec
<tree
, 16> v
;
7692 v
.safe_grow (count
);
7694 for (unsigned int i
= 0; i
< count
; i
++, d
= DECL_CHAIN (d
))
7696 v
[count
- i
- 1] = d
;
7697 fit_decomposition_lang_decl (d
, decl
);
7700 tree type
= TREE_TYPE (decl
);
7703 if (TYPE_REF_P (type
))
7705 dexp
= convert_from_reference (dexp
);
7706 type
= complete_type (TREE_TYPE (type
));
7707 if (type
== error_mark_node
)
7709 if (!COMPLETE_TYPE_P (type
))
7711 error_at (loc
, "structured binding refers to incomplete type %qT",
7717 tree eltype
= NULL_TREE
;
7718 unsigned HOST_WIDE_INT eltscnt
= 0;
7719 if (TREE_CODE (type
) == ARRAY_TYPE
)
7722 nelts
= array_type_nelts_top (type
);
7723 if (nelts
== error_mark_node
)
7725 if (!tree_fits_uhwi_p (nelts
))
7727 error_at (loc
, "cannot decompose variable length array %qT", type
);
7730 eltscnt
= tree_to_uhwi (nelts
);
7731 if (count
!= eltscnt
)
7734 if (count
> eltscnt
)
7735 error_n (loc
, count
,
7736 "%u name provided for structured binding",
7737 "%u names provided for structured binding", count
);
7739 error_n (loc
, count
,
7740 "only %u name provided for structured binding",
7741 "only %u names provided for structured binding", count
);
7742 inform_n (loc
, eltscnt
,
7743 "while %qT decomposes into %wu element",
7744 "while %qT decomposes into %wu elements",
7748 eltype
= TREE_TYPE (type
);
7749 for (unsigned int i
= 0; i
< count
; i
++)
7751 TREE_TYPE (v
[i
]) = eltype
;
7752 layout_decl (v
[i
], 0);
7753 if (processing_template_decl
)
7755 tree t
= unshare_expr (dexp
);
7756 t
= build4_loc (DECL_SOURCE_LOCATION (v
[i
]), ARRAY_REF
,
7757 eltype
, t
, size_int (i
), NULL_TREE
,
7759 SET_DECL_VALUE_EXPR (v
[i
], t
);
7760 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7763 /* 2 GNU extensions. */
7764 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
7767 if (count
!= eltscnt
)
7769 eltype
= cp_build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
7770 for (unsigned int i
= 0; i
< count
; i
++)
7772 TREE_TYPE (v
[i
]) = eltype
;
7773 layout_decl (v
[i
], 0);
7774 if (processing_template_decl
)
7776 tree t
= unshare_expr (dexp
);
7777 t
= build1_loc (DECL_SOURCE_LOCATION (v
[i
]),
7778 i
? IMAGPART_EXPR
: REALPART_EXPR
, eltype
,
7780 SET_DECL_VALUE_EXPR (v
[i
], t
);
7781 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7784 else if (TREE_CODE (type
) == VECTOR_TYPE
)
7786 if (!TYPE_VECTOR_SUBPARTS (type
).is_constant (&eltscnt
))
7788 error_at (loc
, "cannot decompose variable length vector %qT", type
);
7791 if (count
!= eltscnt
)
7793 eltype
= cp_build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
7794 for (unsigned int i
= 0; i
< count
; i
++)
7796 TREE_TYPE (v
[i
]) = eltype
;
7797 layout_decl (v
[i
], 0);
7798 if (processing_template_decl
)
7800 tree t
= unshare_expr (dexp
);
7801 convert_vector_to_array_for_subscript (DECL_SOURCE_LOCATION (v
[i
]),
7803 t
= build4_loc (DECL_SOURCE_LOCATION (v
[i
]), ARRAY_REF
,
7804 eltype
, t
, size_int (i
), NULL_TREE
,
7806 SET_DECL_VALUE_EXPR (v
[i
], t
);
7807 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7810 else if (tree tsize
= get_tuple_size (type
))
7812 if (tsize
== error_mark_node
)
7814 error_at (loc
, "%<std::tuple_size<%T>::value%> is not an integral "
7815 "constant expression", type
);
7818 if (!tree_fits_uhwi_p (tsize
))
7820 error_n (loc
, count
,
7821 "%u name provided for structured binding",
7822 "%u names provided for structured binding", count
);
7823 inform (loc
, "while %qT decomposes into %E elements",
7827 eltscnt
= tree_to_uhwi (tsize
);
7828 if (count
!= eltscnt
)
7830 int save_read
= DECL_READ_P (decl
);
7831 for (unsigned i
= 0; i
< count
; ++i
)
7833 location_t sloc
= input_location
;
7834 location_t dloc
= DECL_SOURCE_LOCATION (v
[i
]);
7836 input_location
= dloc
;
7837 tree init
= get_tuple_decomp_init (decl
, i
);
7838 tree eltype
= (init
== error_mark_node
? error_mark_node
7839 : get_tuple_element_type (type
, i
));
7840 input_location
= sloc
;
7842 if (init
== error_mark_node
|| eltype
== error_mark_node
)
7844 inform (dloc
, "in initialization of structured binding "
7845 "variable %qD", v
[i
]);
7848 /* Save the decltype away before reference collapse. */
7849 store_decomp_type (v
[i
], eltype
);
7850 eltype
= cp_build_reference_type (eltype
, !lvalue_p (init
));
7851 TREE_TYPE (v
[i
]) = eltype
;
7852 layout_decl (v
[i
], 0);
7853 if (DECL_HAS_VALUE_EXPR_P (v
[i
]))
7855 /* In this case the names are variables, not just proxies. */
7856 SET_DECL_VALUE_EXPR (v
[i
], NULL_TREE
);
7857 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 0;
7859 if (!processing_template_decl
)
7861 TREE_PUBLIC (v
[i
]) = TREE_PUBLIC (decl
);
7862 TREE_STATIC (v
[i
]) = TREE_STATIC (decl
);
7863 DECL_COMMON (v
[i
]) = DECL_COMMON (decl
);
7864 DECL_COMDAT (v
[i
]) = DECL_COMDAT (decl
);
7865 if (TREE_STATIC (v
[i
]))
7867 CP_DECL_THREAD_LOCAL_P (v
[i
])
7868 = CP_DECL_THREAD_LOCAL_P (decl
);
7869 set_decl_tls_model (v
[i
], DECL_TLS_MODEL (decl
));
7870 if (DECL_ONE_ONLY (decl
))
7871 make_decl_one_only (v
[i
], cxx_comdat_group (v
[i
]));
7872 if (TREE_PUBLIC (decl
))
7873 DECL_WEAK (v
[i
]) = DECL_WEAK (decl
);
7874 DECL_VISIBILITY (v
[i
]) = DECL_VISIBILITY (decl
);
7875 DECL_VISIBILITY_SPECIFIED (v
[i
])
7876 = DECL_VISIBILITY_SPECIFIED (decl
);
7878 cp_finish_decl (v
[i
], init
, /*constexpr*/false,
7879 /*asm*/NULL_TREE
, LOOKUP_NORMAL
);
7882 /* Ignore reads from the underlying decl performed during initialization
7883 of the individual variables. If those will be read, we'll mark
7884 the underlying decl as read at that point. */
7885 DECL_READ_P (decl
) = save_read
;
7887 else if (TREE_CODE (type
) == UNION_TYPE
)
7889 error_at (loc
, "cannot decompose union type %qT", type
);
7892 else if (!CLASS_TYPE_P (type
))
7894 error_at (loc
, "cannot decompose non-array non-class type %qT", type
);
7897 else if (LAMBDA_TYPE_P (type
))
7899 error_at (loc
, "cannot decompose lambda closure type %qT", type
);
7902 else if (processing_template_decl
&& !COMPLETE_TYPE_P (type
))
7903 pedwarn (loc
, 0, "structured binding refers to incomplete class type %qT",
7907 tree btype
= find_decomp_class_base (loc
, type
, NULL_TREE
);
7908 if (btype
== error_mark_node
)
7910 else if (btype
== NULL_TREE
)
7912 error_at (loc
, "cannot decompose class type %qT without non-static "
7913 "data members", type
);
7916 for (tree field
= TYPE_FIELDS (btype
); field
; field
= TREE_CHAIN (field
))
7917 if (TREE_CODE (field
) != FIELD_DECL
7918 || DECL_ARTIFICIAL (field
)
7919 || DECL_UNNAMED_BIT_FIELD (field
))
7923 if (count
!= eltscnt
)
7928 t
= convert_to_base (t
, btype
, /*check_access*/true,
7929 /*nonnull*/false, tf_warning_or_error
);
7933 for (tree field
= TYPE_FIELDS (btype
); field
; field
= TREE_CHAIN (field
))
7934 if (TREE_CODE (field
) != FIELD_DECL
7935 || DECL_ARTIFICIAL (field
)
7936 || DECL_UNNAMED_BIT_FIELD (field
))
7940 tree tt
= finish_non_static_data_member (field
, unshare_expr (t
),
7942 if (REFERENCE_REF_P (tt
))
7943 tt
= TREE_OPERAND (tt
, 0);
7944 TREE_TYPE (v
[i
]) = TREE_TYPE (tt
);
7945 layout_decl (v
[i
], 0);
7946 if (!processing_template_decl
)
7948 SET_DECL_VALUE_EXPR (v
[i
], tt
);
7949 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7954 if (processing_template_decl
)
7956 for (unsigned int i
= 0; i
< count
; i
++)
7957 if (!DECL_HAS_VALUE_EXPR_P (v
[i
]))
7959 tree a
= build_nt (ARRAY_REF
, decl
, size_int (i
),
7960 NULL_TREE
, NULL_TREE
);
7961 SET_DECL_VALUE_EXPR (v
[i
], a
);
7962 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7967 /* Returns a declaration for a VAR_DECL as if:
7969 extern "C" TYPE NAME;
7971 had been seen. Used to create compiler-generated global
7975 declare_global_var (tree name
, tree type
)
7979 push_to_top_level ();
7980 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7981 TREE_PUBLIC (decl
) = 1;
7982 DECL_EXTERNAL (decl
) = 1;
7983 DECL_ARTIFICIAL (decl
) = 1;
7984 DECL_CONTEXT (decl
) = FROB_CONTEXT (global_namespace
);
7985 /* If the user has explicitly declared this variable (perhaps
7986 because the code we are compiling is part of a low-level runtime
7987 library), then it is possible that our declaration will be merged
7988 with theirs by pushdecl. */
7989 decl
= pushdecl (decl
);
7990 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
7991 pop_from_top_level ();
7996 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
7997 if "__cxa_atexit" is not being used) corresponding to the function
7998 to be called when the program exits. */
8001 get_atexit_fn_ptr_type (void)
8005 if (!atexit_fn_ptr_type_node
)
8008 if (flag_use_cxa_atexit
8009 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
8010 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
8011 arg_type
= ptr_type_node
;
8013 /* The parameter to "atexit" is "void (*)(void)". */
8014 arg_type
= NULL_TREE
;
8016 fn_type
= build_function_type_list (void_type_node
,
8017 arg_type
, NULL_TREE
);
8018 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
8021 return atexit_fn_ptr_type_node
;
8024 /* Returns a pointer to the `atexit' function. Note that if
8025 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
8026 `__cxa_atexit' function specified in the IA64 C++ ABI. */
8029 get_atexit_node (void)
8035 bool use_aeabi_atexit
;
8040 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
8042 /* The declaration for `__cxa_atexit' is:
8044 int __cxa_atexit (void (*)(void *), void *, void *)
8046 We build up the argument types and then the function type
8048 tree argtype0
, argtype1
, argtype2
;
8050 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
8051 /* First, build the pointer-to-function type for the first
8053 fn_ptr_type
= get_atexit_fn_ptr_type ();
8054 /* Then, build the rest of the argument types. */
8055 argtype2
= ptr_type_node
;
8056 if (use_aeabi_atexit
)
8058 argtype1
= fn_ptr_type
;
8059 argtype0
= ptr_type_node
;
8063 argtype1
= ptr_type_node
;
8064 argtype0
= fn_ptr_type
;
8066 /* And the final __cxa_atexit type. */
8067 fn_type
= build_function_type_list (integer_type_node
,
8068 argtype0
, argtype1
, argtype2
,
8070 if (use_aeabi_atexit
)
8071 name
= "__aeabi_atexit";
8073 name
= "__cxa_atexit";
8077 /* The declaration for `atexit' is:
8079 int atexit (void (*)());
8081 We build up the argument types and then the function type
8083 fn_ptr_type
= get_atexit_fn_ptr_type ();
8084 /* Build the final atexit type. */
8085 fn_type
= build_function_type_list (integer_type_node
,
8086 fn_ptr_type
, NULL_TREE
);
8090 /* Now, build the function declaration. */
8091 push_lang_context (lang_name_c
);
8092 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
8093 mark_used (atexit_fndecl
);
8094 pop_lang_context ();
8095 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
8100 /* Like get_atexit_node, but for thread-local cleanups. */
8103 get_thread_atexit_node (void)
8105 /* The declaration for `__cxa_thread_atexit' is:
8107 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
8108 tree fn_type
= build_function_type_list (integer_type_node
,
8109 get_atexit_fn_ptr_type (),
8110 ptr_type_node
, ptr_type_node
,
8113 /* Now, build the function declaration. */
8114 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
8115 ECF_LEAF
| ECF_NOTHROW
);
8116 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
8119 /* Returns the __dso_handle VAR_DECL. */
8122 get_dso_handle_node (void)
8124 if (dso_handle_node
)
8125 return dso_handle_node
;
8127 /* Declare the variable. */
8128 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
8131 #ifdef HAVE_GAS_HIDDEN
8132 if (dso_handle_node
!= error_mark_node
)
8134 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
8135 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
8139 return dso_handle_node
;
8142 /* Begin a new function with internal linkage whose job will be simply
8143 to destroy some particular variable. */
8145 static GTY(()) int start_cleanup_cnt
;
8148 start_cleanup_fn (void)
8153 bool use_cxa_atexit
= flag_use_cxa_atexit
8154 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
8156 push_to_top_level ();
8158 /* No need to mangle this. */
8159 push_lang_context (lang_name_c
);
8161 /* Build the name of the function. */
8162 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
8163 /* Build the function declaration. */
8164 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
8165 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
8166 /* It's a function with internal linkage, generated by the
8168 TREE_PUBLIC (fndecl
) = 0;
8169 DECL_ARTIFICIAL (fndecl
) = 1;
8170 /* Make the function `inline' so that it is only emitted if it is
8171 actually needed. It is unlikely that it will be inlined, since
8172 it is only called via a function pointer, but we avoid unnecessary
8173 emissions this way. */
8174 DECL_DECLARED_INLINE_P (fndecl
) = 1;
8175 DECL_INTERFACE_KNOWN (fndecl
) = 1;
8176 /* Build the parameter. */
8179 tree parmdecl
= cp_build_parm_decl (fndecl
, NULL_TREE
, ptr_type_node
);
8180 TREE_USED (parmdecl
) = 1;
8181 DECL_READ_P (parmdecl
) = 1;
8182 DECL_ARGUMENTS (fndecl
) = parmdecl
;
8186 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
8188 pop_lang_context ();
8190 return current_function_decl
;
8193 /* Finish the cleanup function begun by start_cleanup_fn. */
8196 end_cleanup_fn (void)
8198 expand_or_defer_fn (finish_function (/*inline_p=*/false));
8200 pop_from_top_level ();
8203 /* Generate code to handle the destruction of DECL, an object with
8204 static storage duration. */
8207 register_dtor_fn (tree decl
)
8214 bool ob_parm
, dso_parm
, use_dtor
;
8215 tree arg0
, arg1
, arg2
;
8218 type
= TREE_TYPE (decl
);
8219 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
8222 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
8223 "__aeabi_atexit"), and DECL is a class object, we can just pass the
8224 destructor to "__cxa_atexit"; we don't have to build a temporary
8225 function to do the cleanup. */
8226 dso_parm
= (flag_use_cxa_atexit
8227 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
8228 ob_parm
= (CP_DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
8229 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
8232 cleanup
= get_class_binding (type
, complete_dtor_identifier
);
8234 /* Make sure it is accessible. */
8235 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
8236 tf_warning_or_error
);
8240 /* Call build_cleanup before we enter the anonymous function so
8241 that any access checks will be done relative to the current
8242 scope, rather than the scope of the anonymous function. */
8243 build_cleanup (decl
);
8245 /* Now start the function. */
8246 cleanup
= start_cleanup_fn ();
8248 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8249 to the original function, rather than the anonymous one. That
8250 will make the back end think that nested functions are in use,
8251 which causes confusion. */
8252 push_deferring_access_checks (dk_no_check
);
8253 fcall
= build_cleanup (decl
);
8254 pop_deferring_access_checks ();
8256 /* Create the body of the anonymous function. */
8257 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
8258 finish_expr_stmt (fcall
);
8259 finish_compound_stmt (compound_stmt
);
8263 /* Call atexit with the cleanup function. */
8264 mark_used (cleanup
);
8265 cleanup
= build_address (cleanup
);
8267 if (CP_DECL_THREAD_LOCAL_P (decl
))
8268 atex_node
= get_thread_atexit_node ();
8270 atex_node
= get_atexit_node ();
8274 /* We must convert CLEANUP to the type that "__cxa_atexit"
8276 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
8277 /* "__cxa_atexit" will pass the address of DECL to the
8278 cleanup function. */
8280 addr
= build_address (decl
);
8281 /* The declared type of the parameter to "__cxa_atexit" is
8282 "void *". For plain "T*", we could just let the
8283 machinery in cp_build_function_call convert it -- but if the
8284 type is "cv-qualified T *", then we need to convert it
8285 before passing it in, to avoid spurious errors. */
8286 addr
= build_nop (ptr_type_node
, addr
);
8289 /* Since the cleanup functions we build ignore the address
8290 they're given, there's no reason to pass the actual address
8291 in, and, in general, it's cheaper to pass NULL than any
8293 addr
= null_pointer_node
;
8296 arg2
= cp_build_addr_expr (get_dso_handle_node (),
8297 tf_warning_or_error
);
8299 /* Just pass NULL to the dso handle parm if we don't actually
8300 have a DSO handle on this target. */
8301 arg2
= null_pointer_node
;
8307 if (!CP_DECL_THREAD_LOCAL_P (decl
)
8308 && targetm
.cxx
.use_aeabi_atexit ())
8324 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
8325 arg0
, arg1
, arg2
, NULL_TREE
);
8328 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
8329 is its initializer. Generate code to handle the construction
8330 and destruction of DECL. */
8333 expand_static_init (tree decl
, tree init
)
8335 gcc_assert (VAR_P (decl
));
8336 gcc_assert (TREE_STATIC (decl
));
8338 /* Some variables require no dynamic initialization. */
8339 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
8341 /* Make sure the destructor is callable. */
8342 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
8347 if (CP_DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
8348 && !DECL_FUNCTION_SCOPE_P (decl
))
8350 location_t dloc
= DECL_SOURCE_LOCATION (decl
);
8352 error_at (dloc
, "non-local variable %qD declared %<__thread%> "
8353 "needs dynamic initialization", decl
);
8355 error_at (dloc
, "non-local variable %qD declared %<__thread%> "
8356 "has a non-trivial destructor", decl
);
8357 static bool informed
;
8360 inform (dloc
, "C++11 %<thread_local%> allows dynamic "
8361 "initialization and destruction");
8367 if (DECL_FUNCTION_SCOPE_P (decl
))
8369 /* Emit code to perform this initialization but once. */
8370 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
8371 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
8372 tree guard
, guard_addr
;
8374 /* We don't need thread-safety code for thread-local vars. */
8375 bool thread_guard
= (flag_threadsafe_statics
8376 && !CP_DECL_THREAD_LOCAL_P (decl
));
8378 /* Emit code to perform this initialization but once. This code
8381 static <type> guard;
8382 if (!__atomic_load (guard.first_byte)) {
8383 if (__cxa_guard_acquire (&guard)) {
8386 // Do initialization.
8387 flag = true; __cxa_guard_release (&guard);
8388 // Register variable for destruction at end of program.
8390 if (!flag) __cxa_guard_abort (&guard);
8395 Note that the `flag' variable is only set to 1 *after* the
8396 initialization is complete. This ensures that an exception,
8397 thrown during the construction, will cause the variable to
8398 reinitialized when we pass through this code again, as per:
8402 If the initialization exits by throwing an exception, the
8403 initialization is not complete, so it will be tried again
8404 the next time control enters the declaration.
8406 This process should be thread-safe, too; multiple threads
8407 should not be able to initialize the variable more than
8410 /* Create the guard variable. */
8411 guard
= get_guard (decl
);
8413 /* Begin the conditional initialization. */
8414 if_stmt
= begin_if_stmt ();
8416 finish_if_stmt_cond (get_guard_cond (guard
, thread_guard
), if_stmt
);
8417 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
8421 tree vfntype
= NULL_TREE
;
8422 tree acquire_name
, release_name
, abort_name
;
8423 tree acquire_fn
, release_fn
, abort_fn
;
8424 guard_addr
= build_address (guard
);
8426 acquire_name
= get_identifier ("__cxa_guard_acquire");
8427 release_name
= get_identifier ("__cxa_guard_release");
8428 abort_name
= get_identifier ("__cxa_guard_abort");
8429 acquire_fn
= get_global_binding (acquire_name
);
8430 release_fn
= get_global_binding (release_name
);
8431 abort_fn
= get_global_binding (abort_name
);
8433 acquire_fn
= push_library_fn
8434 (acquire_name
, build_function_type_list (integer_type_node
,
8435 TREE_TYPE (guard_addr
),
8437 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
8438 if (!release_fn
|| !abort_fn
)
8439 vfntype
= build_function_type_list (void_type_node
,
8440 TREE_TYPE (guard_addr
),
8443 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
8444 ECF_NOTHROW
| ECF_LEAF
);
8446 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
8447 ECF_NOTHROW
| ECF_LEAF
);
8449 inner_if_stmt
= begin_if_stmt ();
8450 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
8453 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
8454 begin
= get_target_expr (boolean_false_node
);
8455 flag
= TARGET_EXPR_SLOT (begin
);
8457 TARGET_EXPR_CLEANUP (begin
)
8458 = build3 (COND_EXPR
, void_type_node
, flag
,
8460 build_call_n (abort_fn
, 1, guard_addr
));
8461 CLEANUP_EH_ONLY (begin
) = 1;
8463 /* Do the initialization itself. */
8464 init
= add_stmt_to_compound (begin
, init
);
8465 init
= add_stmt_to_compound
8466 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
8467 init
= add_stmt_to_compound
8468 (init
, build_call_n (release_fn
, 1, guard_addr
));
8471 init
= add_stmt_to_compound (init
, set_guard (guard
));
8473 /* Use atexit to register a function for destroying this static
8475 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
8477 finish_expr_stmt (init
);
8481 finish_compound_stmt (inner_then_clause
);
8482 finish_then_clause (inner_if_stmt
);
8483 finish_if_stmt (inner_if_stmt
);
8486 finish_compound_stmt (then_clause
);
8487 finish_then_clause (if_stmt
);
8488 finish_if_stmt (if_stmt
);
8490 else if (CP_DECL_THREAD_LOCAL_P (decl
))
8491 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
8493 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
8497 /* Make TYPE a complete type based on INITIAL_VALUE.
8498 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8499 2 if there was no information (in which case assume 0 if DO_DEFAULT),
8500 3 if the initializer list is empty (in pedantic mode). */
8503 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
8506 tree type
, elt_type
;
8508 /* Don't get confused by a CONSTRUCTOR for some other type. */
8509 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
8510 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
)
8511 && TREE_CODE (TREE_TYPE (initial_value
)) != ARRAY_TYPE
)
8516 unsigned HOST_WIDE_INT i
;
8519 /* An array of character type can be initialized from a
8520 brace-enclosed string constant.
8522 FIXME: this code is duplicated from reshape_init. Probably
8523 we should just call reshape_init here? */
8524 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
8525 && TREE_CODE (initial_value
) == CONSTRUCTOR
8526 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
8528 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
8529 tree value
= (*v
)[0].value
;
8530 STRIP_ANY_LOCATION_WRAPPER (value
);
8532 if (TREE_CODE (value
) == STRING_CST
8533 && v
->length () == 1)
8534 initial_value
= value
;
8537 /* If any of the elements are parameter packs, we can't actually
8538 complete this type now because the array size is dependent. */
8539 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8541 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
8544 if (PACK_EXPANSION_P (value
))
8550 failure
= complete_array_type (ptype
, initial_value
, do_default
);
8552 /* We can create the array before the element type is complete, which
8553 means that we didn't have these two bits set in the original type
8554 either. In completing the type, we are expected to propagate these
8555 bits. See also complete_type which does the same thing for arrays
8558 if (type
!= error_mark_node
&& TYPE_DOMAIN (type
))
8560 elt_type
= TREE_TYPE (type
);
8561 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
8562 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
8563 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
8569 /* As above, but either give an error or reject zero-size arrays, depending
8573 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
8574 bool do_default
, tsubst_flags_t complain
)
8577 bool sfinae
= !(complain
& tf_error
);
8578 /* In SFINAE context we can't be lenient about zero-size arrays. */
8581 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
8587 /* Not an error. */;
8588 else if (failure
== 1)
8589 error ("initializer fails to determine size of %qT", *ptype
);
8590 else if (failure
== 2)
8593 error ("array size missing in %qT", *ptype
);
8595 else if (failure
== 3)
8596 error ("zero-size array %qT", *ptype
);
8597 *ptype
= error_mark_node
;
8602 /* Return zero if something is declared to be a member of type
8603 CTYPE when in the context of CUR_TYPE. STRING is the error
8604 message to print in that case. Otherwise, quietly return 1. */
8607 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
8609 if (ctype
&& ctype
!= cur_type
)
8611 if (flags
== DTOR_FLAG
)
8612 error ("destructor for alien class %qT cannot be a member", ctype
);
8614 error ("constructor for alien class %qT cannot be a member", ctype
);
8620 /* Subroutine of `grokdeclarator'. */
8622 /* Generate errors possibly applicable for a given set of specifiers.
8623 This is for ARM $7.1.2. */
8626 bad_specifiers (tree object
,
8627 enum bad_spec_place type
,
8633 const location_t
* locations
)
8639 error_at (locations
[ds_virtual
],
8640 "%qD declared as a %<virtual%> variable", object
);
8642 error ("%<const%> and %<volatile%> function specifiers on "
8643 "%qD invalid in variable declaration", object
);
8647 error_at (locations
[ds_virtual
],
8648 "%qD declared as a %<virtual%> parameter", object
);
8650 error_at (locations
[ds_inline
],
8651 "%qD declared as an %<inline%> parameter", object
);
8653 error ("%<const%> and %<volatile%> function specifiers on "
8654 "%qD invalid in parameter declaration", object
);
8658 error_at (locations
[ds_virtual
],
8659 "%qD declared as a %<virtual%> type", object
);
8661 error_at (locations
[ds_inline
],
8662 "%qD declared as an %<inline%> type", object
);
8664 error ("%<const%> and %<volatile%> function specifiers on "
8665 "%qD invalid in type declaration", object
);
8669 error_at (locations
[ds_virtual
],
8670 "%qD declared as a %<virtual%> field", object
);
8672 error_at (locations
[ds_inline
],
8673 "%qD declared as an %<inline%> field", object
);
8675 error ("%<const%> and %<volatile%> function specifiers on "
8676 "%qD invalid in field declaration", object
);
8682 error ("%q+D declared as a friend", object
);
8684 && !flag_noexcept_type
8685 && (TREE_CODE (object
) == TYPE_DECL
8686 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
8687 && !TYPE_REFFN_P (TREE_TYPE (object
))
8688 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
8689 error ("%q+D declared with an exception specification", object
);
8692 /* DECL is a member function or static data member and is presently
8693 being defined. Check that the definition is taking place in a
8697 check_class_member_definition_namespace (tree decl
)
8699 /* These checks only apply to member functions and static data
8701 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
8702 /* We check for problems with specializations in pt.c in
8703 check_specialization_namespace, where we can issue better
8705 if (processing_specialization
)
8707 /* We check this in check_explicit_instantiation_namespace. */
8708 if (processing_explicit_instantiation
)
8712 A member function definition that appears outside of the
8713 class definition shall appear in a namespace scope enclosing
8714 the class definition.
8718 The definition for a static data member shall appear in a
8719 namespace scope enclosing the member's class definition. */
8720 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
8721 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
8722 decl
, DECL_CONTEXT (decl
));
8725 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
8726 METHOD_TYPE for a non-static member function; QUALS are the
8727 cv-qualifiers that apply to the function. */
8730 build_this_parm (tree fn
, tree type
, cp_cv_quals quals
)
8735 cp_cv_quals this_quals
;
8737 if (CLASS_TYPE_P (type
))
8740 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
8741 this_type
= build_pointer_type (this_type
);
8744 this_type
= type_of_this_parm (type
);
8745 /* The `this' parameter is implicitly `const'; it cannot be
8747 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
8748 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
8749 parm
= build_artificial_parm (fn
, this_identifier
, qual_type
);
8750 cp_apply_type_quals_to_decl (this_quals
, parm
);
8754 /* DECL is a static member function. Complain if it was declared
8755 with function-cv-quals. */
8758 check_static_quals (tree decl
, cp_cv_quals quals
)
8760 if (quals
!= TYPE_UNQUALIFIED
)
8761 error ("static member function %q#D declared with type qualifiers",
8765 // Check that FN takes no arguments and returns bool.
8767 check_concept_fn (tree fn
)
8769 // A constraint is nullary.
8770 if (DECL_ARGUMENTS (fn
))
8771 error_at (DECL_SOURCE_LOCATION (fn
),
8772 "concept %q#D declared with function parameters", fn
);
8774 // The declared return type of the concept shall be bool, and
8775 // it shall not be deduced from it definition.
8776 tree type
= TREE_TYPE (TREE_TYPE (fn
));
8778 error_at (DECL_SOURCE_LOCATION (fn
),
8779 "concept %q#D declared with a deduced return type", fn
);
8780 else if (type
!= boolean_type_node
)
8781 error_at (DECL_SOURCE_LOCATION (fn
),
8782 "concept %q#D with non-%<bool%> return type %qT", fn
, type
);
8785 /* Helper function. Replace the temporary this parameter injected
8786 during cp_finish_omp_declare_simd with the real this parameter. */
8789 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
8791 tree this_parm
= (tree
) data
;
8792 if (TREE_CODE (*tp
) == PARM_DECL
8793 && DECL_NAME (*tp
) == this_identifier
8794 && *tp
!= this_parm
)
8796 else if (TYPE_P (*tp
))
8801 /* CTYPE is class type, or null if non-class.
8802 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8804 DECLARATOR is the function's name.
8805 PARMS is a chain of PARM_DECLs for the function.
8806 VIRTUALP is truthvalue of whether the function is virtual or not.
8807 FLAGS are to be passed through to `grokclassfn'.
8808 QUALS are qualifiers indicating whether the function is `const'
8810 RAISES is a list of exceptions that this function can raise.
8811 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8812 not look, and -1 if we should not call `grokclassfn' at all.
8814 SFK is the kind of special function (if any) for the new function.
8816 Returns `NULL_TREE' if something goes wrong, after issuing
8817 applicable error messages. */
8820 grokfndecl (tree ctype
,
8824 tree orig_declarator
,
8825 const cp_decl_specifier_seq
*declspecs
,
8828 enum overload_flags flags
,
8830 cp_ref_qualifier rqual
,
8837 special_function_kind sfk
,
8839 bool late_return_type_p
,
8843 location_t location
)
8846 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8849 if (location
== UNKNOWN_LOCATION
)
8850 location
= input_location
;
8852 // Was the concept specifier present?
8853 bool concept_p
= inlinep
& 4;
8855 // Concept declarations must have a corresponding definition.
8856 if (concept_p
&& !funcdef_flag
)
8858 error_at (location
, "concept %qD has no definition", declarator
);
8862 type
= build_cp_fntype_variant (type
, rqual
, raises
, late_return_type_p
);
8864 decl
= build_lang_decl_loc (location
, FUNCTION_DECL
, declarator
, type
);
8866 /* Set the constraints on the declaration. */
8869 tree tmpl_reqs
= NULL_TREE
;
8870 if (processing_template_decl
> template_class_depth (ctype
))
8871 tmpl_reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
8873 /* Adjust the required expression into a constraint. */
8875 decl_reqs
= normalize_expression (decl_reqs
);
8877 tree ci
= build_constraints (tmpl_reqs
, decl_reqs
);
8878 set_constraints (decl
, ci
);
8881 if (TREE_CODE (type
) == METHOD_TYPE
)
8883 tree parm
= build_this_parm (decl
, type
, quals
);
8884 DECL_CHAIN (parm
) = parms
;
8887 /* Allocate space to hold the vptr bit if needed. */
8888 SET_DECL_ALIGN (decl
, MINIMUM_METHOD_BOUNDARY
);
8891 DECL_ARGUMENTS (decl
) = parms
;
8892 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
8893 DECL_CONTEXT (t
) = decl
;
8895 /* Propagate volatile out from type to decl. */
8896 if (TYPE_VOLATILE (type
))
8897 TREE_THIS_VOLATILE (decl
) = 1;
8899 /* Setup decl according to sfk. */
8902 case sfk_constructor
:
8903 case sfk_copy_constructor
:
8904 case sfk_move_constructor
:
8905 DECL_CXX_CONSTRUCTOR_P (decl
) = 1;
8906 DECL_NAME (decl
) = ctor_identifier
;
8908 case sfk_destructor
:
8909 DECL_CXX_DESTRUCTOR_P (decl
) = 1;
8910 DECL_NAME (decl
) = dtor_identifier
;
8916 if (friendp
&& TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8920 "defining explicit specialization %qD in friend declaration",
8924 tree fns
= TREE_OPERAND (orig_declarator
, 0);
8925 tree args
= TREE_OPERAND (orig_declarator
, 1);
8927 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8929 /* Something like `template <class T> friend void f<T>()'. */
8931 "invalid use of template-id %qD in declaration "
8932 "of primary template",
8938 /* A friend declaration of the form friend void f<>(). Record
8939 the information in the TEMPLATE_ID_EXPR. */
8940 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8942 gcc_assert (identifier_p (fns
) || OVL_P (fns
));
8943 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
8945 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8946 if (TREE_PURPOSE (t
)
8947 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8949 error_at (defarg_location (TREE_PURPOSE (t
)),
8950 "default arguments are not allowed in declaration "
8951 "of friend template specialization %qD",
8958 error_at (declspecs
->locations
[ds_inline
],
8959 "%<inline%> is not allowed in declaration of friend "
8960 "template specialization %qD",
8967 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
8968 expression, that declaration shall be a definition..." */
8969 if (friendp
&& !funcdef_flag
)
8971 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
8972 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
8973 if (TREE_PURPOSE (t
))
8975 permerror (DECL_SOURCE_LOCATION (decl
),
8976 "friend declaration of %qD specifies default "
8977 "arguments and isn%'t a definition", decl
);
8982 /* If this decl has namespace scope, set that up. */
8984 set_decl_namespace (decl
, in_namespace
, friendp
);
8986 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
8988 /* `main' and builtins have implicit 'C' linkage. */
8989 if (ctype
== NULL_TREE
8990 && DECL_FILE_SCOPE_P (decl
)
8991 && current_lang_name
== lang_name_cplusplus
8992 && (MAIN_NAME_P (declarator
)
8993 || (IDENTIFIER_LENGTH (declarator
) > 10
8994 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8995 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8996 && strncmp (IDENTIFIER_POINTER (declarator
)+2,
8997 "builtin_", 8) == 0)
8998 || (targetcm
.cxx_implicit_extern_c
8999 && (targetcm
.cxx_implicit_extern_c
9000 (IDENTIFIER_POINTER (declarator
))))))
9001 SET_DECL_LANGUAGE (decl
, lang_c
);
9003 /* Should probably propagate const out from type to decl I bet (mrs). */
9006 DECL_STATIC_FUNCTION_P (decl
) = 1;
9007 DECL_CONTEXT (decl
) = ctype
;
9011 DECL_DELETED_FN (decl
) = 1;
9015 DECL_CONTEXT (decl
) = ctype
;
9017 check_class_member_definition_namespace (decl
);
9020 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
9022 if (PROCESSING_REAL_TEMPLATE_DECL_P())
9023 error_at (location
, "cannot declare %<::main%> to be a template");
9025 error_at (declspecs
->locations
[ds_inline
],
9026 "cannot declare %<::main%> to be inline");
9028 error_at (declspecs
->locations
[ds_constexpr
],
9029 "cannot declare %<::main%> to be %<constexpr%>");
9031 error_at (location
, "cannot declare %<::main%> to be static");
9036 /* Members of anonymous types and local classes have no linkage; make
9037 them internal. If a typedef is made later, this will be changed. */
9038 if (ctype
&& (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype
))
9039 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
9042 if (publicp
&& cxx_dialect
== cxx98
)
9044 /* [basic.link]: A name with no linkage (notably, the name of a class
9045 or enumeration declared in a local scope) shall not be used to
9046 declare an entity with linkage.
9048 DR 757 relaxes this restriction for C++0x. */
9049 no_linkage_error (decl
);
9052 TREE_PUBLIC (decl
) = publicp
;
9055 DECL_INTERFACE_KNOWN (decl
) = 1;
9056 DECL_NOT_REALLY_EXTERN (decl
) = 1;
9059 /* If the declaration was declared inline, mark it as such. */
9062 DECL_DECLARED_INLINE_P (decl
) = 1;
9064 DECL_COMDAT (decl
) = 1;
9067 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
9069 // If the concept declaration specifier was found, check
9070 // that the declaration satisfies the necessary requirements.
9073 DECL_DECLARED_CONCEPT_P (decl
) = true;
9074 check_concept_fn (decl
);
9077 DECL_EXTERNAL (decl
) = 1;
9078 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9081 TREE_TYPE (decl
) = apply_memfn_quals (TREE_TYPE (decl
),
9088 ? G_("static member function %qD cannot have cv-qualifier")
9089 : G_("non-member function %qD cannot have cv-qualifier"),
9091 quals
= TYPE_UNQUALIFIED
;
9097 ? G_("static member function %qD cannot have ref-qualifier")
9098 : G_("non-member function %qD cannot have ref-qualifier"),
9100 rqual
= REF_QUAL_NONE
;
9104 if (deduction_guide_p (decl
))
9106 if (!DECL_NAMESPACE_SCOPE_P (decl
))
9108 error_at (location
, "deduction guide %qD must be declared at "
9109 "namespace scope", decl
);
9114 "deduction guide %qD must not have a function body", decl
);
9116 else if (IDENTIFIER_ANY_OP_P (DECL_NAME (decl
))
9117 && !grok_op_properties (decl
, /*complain=*/true))
9119 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
9121 bool long_long_unsigned_p
;
9123 const char *suffix
= NULL
;
9124 /* [over.literal]/6: Literal operators shall not have C linkage. */
9125 if (DECL_LANGUAGE (decl
) == lang_c
)
9127 error_at (location
, "literal operator with C linkage");
9128 maybe_show_extern_c_location ();
9132 if (DECL_NAMESPACE_SCOPE_P (decl
))
9134 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
9137 error_at (location
, "%qD has invalid argument list", decl
);
9141 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
9142 if (long_long_unsigned_p
)
9144 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
9145 warning_at (location
, 0, "integer suffix %qs"
9146 " shadowed by implementation", suffix
);
9148 else if (long_double_p
)
9150 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
9151 warning_at (location
, 0, "floating-point suffix %qs"
9152 " shadowed by implementation", suffix
);
9155 if (suffix
[0] != '_'
9156 && !in_system_header_at (location
)
9157 && !current_function_decl
&& !(friendp
&& !funcdef_flag
))
9158 warning_at (location
, OPT_Wliteral_suffix
,
9159 "literal operator suffixes not preceded by %<_%>"
9160 " are reserved for future standardization");
9164 error_at (location
, "%qD must be a non-member function", decl
);
9170 /* Make the init_value nonzero so pushdecl knows this is not
9171 tentative. error_mark_node is replaced later with the BLOCK. */
9172 DECL_INITIAL (decl
) = error_mark_node
;
9174 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
9175 TREE_NOTHROW (decl
) = 1;
9177 if (flag_openmp
|| flag_openmp_simd
)
9179 /* Adjust "omp declare simd" attributes. */
9180 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
9184 for (attr
= ods
; attr
;
9185 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
9187 if (TREE_CODE (type
) == METHOD_TYPE
)
9188 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
9189 DECL_ARGUMENTS (decl
), NULL
);
9190 if (TREE_VALUE (attr
) != NULL_TREE
)
9192 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
9193 cl
= c_omp_declare_simd_clauses_to_numbers
9194 (DECL_ARGUMENTS (decl
), cl
);
9196 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
9198 TREE_VALUE (attr
) = NULL_TREE
;
9204 /* Caller will do the rest of this. */
9208 if (ctype
!= NULL_TREE
)
9209 grokclassfn (ctype
, decl
, flags
);
9212 if (cxx_dialect
>= cxx11
9213 && DECL_DESTRUCTOR_P (decl
)
9214 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
9215 && !processing_template_decl
)
9216 deduce_noexcept_on_destructor (decl
);
9218 decl
= check_explicit_specialization (orig_declarator
, decl
,
9221 4 * (friendp
!= 0) +
9224 if (decl
== error_mark_node
)
9227 if (DECL_STATIC_FUNCTION_P (decl
))
9228 check_static_quals (decl
, quals
);
9232 cplus_decl_attributes (&decl
, *attrlist
, 0);
9233 *attrlist
= NULL_TREE
;
9236 /* Check main's type after attributes have been applied. */
9237 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
9239 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
9242 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
9244 error_at (declspecs
->locations
[ds_type_spec
],
9245 "%<::main%> must return %<int%>");
9246 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
9247 TREE_TYPE (decl
) = newtype
;
9250 check_main_parameter_types (decl
);
9253 if (ctype
!= NULL_TREE
&& check
)
9255 tree old_decl
= check_classfn (ctype
, decl
,
9256 (processing_template_decl
9257 > template_class_depth (ctype
))
9258 ? current_template_parms
9261 if (old_decl
== error_mark_node
)
9269 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
9270 /* Because grokfndecl is always supposed to return a
9271 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9272 here. We depend on our callers to figure out that its
9273 really a template that's being returned. */
9274 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
9276 if (DECL_STATIC_FUNCTION_P (old_decl
)
9277 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
9279 /* Remove the `this' parm added by grokclassfn. */
9280 revert_static_member_fn (decl
);
9281 check_static_quals (decl
, quals
);
9283 if (DECL_ARTIFICIAL (old_decl
))
9285 error ("definition of implicitly-declared %qD", old_decl
);
9288 else if (DECL_DEFAULTED_FN (old_decl
))
9290 error ("definition of explicitly-defaulted %q+D", decl
);
9291 inform (DECL_SOURCE_LOCATION (old_decl
),
9292 "%q#D explicitly defaulted here", old_decl
);
9296 /* Since we've smashed OLD_DECL to its
9297 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
9298 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9299 decl
= DECL_TEMPLATE_RESULT (decl
);
9301 /* Attempt to merge the declarations. This can fail, in
9302 the case of some invalid specialization declarations. */
9303 pushed_scope
= push_scope (ctype
);
9304 ok
= duplicate_decls (decl
, old_decl
, friendp
);
9306 pop_scope (pushed_scope
);
9309 error ("no %q#D member function declared in class %qT",
9313 if (ok
== error_mark_node
)
9319 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
9322 if (ctype
== NULL_TREE
|| check
)
9326 DECL_VIRTUAL_P (decl
) = 1;
9331 /* decl is a FUNCTION_DECL.
9332 specifiers are the parsed virt-specifiers.
9334 Set flags to reflect the virt-specifiers.
9339 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
9341 if (decl
== NULL_TREE
)
9343 if (specifiers
& VIRT_SPEC_OVERRIDE
)
9344 DECL_OVERRIDE_P (decl
) = 1;
9345 if (specifiers
& VIRT_SPEC_FINAL
)
9346 DECL_FINAL_P (decl
) = 1;
9350 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
9351 the linkage that DECL will receive in the object file. */
9354 set_linkage_for_static_data_member (tree decl
)
9356 /* A static data member always has static storage duration and
9357 external linkage. Note that static data members are forbidden in
9358 local classes -- the only situation in which a class has
9359 non-external linkage. */
9360 TREE_PUBLIC (decl
) = 1;
9361 TREE_STATIC (decl
) = 1;
9362 /* For non-template classes, static data members are always put
9363 out in exactly those files where they are defined, just as
9364 with ordinary namespace-scope variables. */
9365 if (!processing_template_decl
)
9366 DECL_INTERFACE_KNOWN (decl
) = 1;
9369 /* Create a VAR_DECL named NAME with the indicated TYPE.
9371 If SCOPE is non-NULL, it is the class type or namespace containing
9372 the variable. If SCOPE is NULL, the variable should is created in
9373 the innermost enclosing scope. */
9376 grokvardecl (tree type
,
9378 tree orig_declarator
,
9379 const cp_decl_specifier_seq
*declspecs
,
9386 location_t location
)
9389 tree explicit_scope
;
9391 gcc_assert (!name
|| identifier_p (name
));
9393 bool constp
= (type_quals
& TYPE_QUAL_CONST
) != 0;
9394 bool volatilep
= (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
9396 /* Compute the scope in which to place the variable, but remember
9397 whether or not that scope was explicitly specified by the user. */
9398 explicit_scope
= scope
;
9401 /* An explicit "extern" specifier indicates a namespace-scope
9403 if (declspecs
->storage_class
== sc_extern
)
9404 scope
= current_decl_namespace ();
9405 else if (!at_function_scope_p ())
9406 scope
= current_scope ();
9410 && (/* If the variable is a namespace-scope variable declared in a
9411 template, we need DECL_LANG_SPECIFIC. */
9412 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
9413 /* Similarly for namespace-scope variables with language linkage
9415 || (TREE_CODE (scope
) == NAMESPACE_DECL
9416 && current_lang_name
!= lang_name_cplusplus
)
9417 /* Similarly for static data members. */
9419 /* Similarly for explicit specializations. */
9421 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
9422 decl
= build_lang_decl_loc (location
, VAR_DECL
, name
, type
);
9424 decl
= build_decl (location
, VAR_DECL
, name
, type
);
9426 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
9427 set_decl_namespace (decl
, explicit_scope
, 0);
9429 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
9431 if (declspecs
->storage_class
== sc_extern
)
9433 DECL_THIS_EXTERN (decl
) = 1;
9434 DECL_EXTERNAL (decl
) = !initialized
;
9437 if (DECL_CLASS_SCOPE_P (decl
))
9439 set_linkage_for_static_data_member (decl
);
9440 /* This function is only called with out-of-class definitions. */
9441 DECL_EXTERNAL (decl
) = 0;
9442 check_class_member_definition_namespace (decl
);
9444 /* At top level, either `static' or no s.c. makes a definition
9445 (perhaps tentative), and absence of `static' makes it public. */
9446 else if (toplevel_bindings_p ())
9448 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
9449 && (DECL_THIS_EXTERN (decl
)
9453 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
9455 /* Not at top level, only `static' makes a static definition. */
9458 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
9459 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
9462 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
9464 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
9466 CP_DECL_THREAD_LOCAL_P (decl
) = true;
9467 if (!processing_template_decl
)
9468 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
9470 if (declspecs
->gnu_thread_keyword_p
)
9471 SET_DECL_GNU_TLS_P (decl
);
9474 /* If the type of the decl has no linkage, make sure that we'll
9475 notice that in mark_used. */
9476 if (cxx_dialect
> cxx98
9477 && decl_linkage (decl
) != lk_none
9478 && DECL_LANG_SPECIFIC (decl
) == NULL
9479 && !DECL_EXTERN_C_P (decl
)
9480 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
9481 retrofit_lang_decl (decl
);
9483 if (TREE_PUBLIC (decl
))
9485 /* [basic.link]: A name with no linkage (notably, the name of a class
9486 or enumeration declared in a local scope) shall not be used to
9487 declare an entity with linkage.
9489 DR 757 relaxes this restriction for C++0x. */
9490 if (cxx_dialect
< cxx11
)
9491 no_linkage_error (decl
);
9494 DECL_INTERFACE_KNOWN (decl
) = 1;
9496 if (DECL_NAME (decl
)
9497 && MAIN_NAME_P (DECL_NAME (decl
))
9498 && scope
== global_namespace
)
9499 error_at (DECL_SOURCE_LOCATION (decl
),
9500 "cannot declare %<::main%> to be a global variable");
9502 /* Check that the variable can be safely declared as a concept.
9503 Note that this also forbids explicit specializations. */
9506 if (!processing_template_decl
)
9508 error_at (declspecs
->locations
[ds_concept
],
9509 "a non-template variable cannot be %<concept%>");
9513 DECL_DECLARED_CONCEPT_P (decl
) = true;
9514 if (!same_type_ignoring_top_level_qualifiers_p (type
, boolean_type_node
))
9515 error_at (declspecs
->locations
[ds_type_spec
],
9516 "concept must have type %<bool%>");
9518 else if (flag_concepts
9519 && processing_template_decl
> template_class_depth (scope
))
9521 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
9522 tree ci
= build_constraints (reqs
, NULL_TREE
);
9523 set_constraints (decl
, ci
);
9526 // Handle explicit specializations and instantiations of variable templates.
9527 if (orig_declarator
)
9528 decl
= check_explicit_specialization (orig_declarator
, decl
,
9529 template_count
, conceptp
* 8);
9531 return decl
!= error_mark_node
? decl
: NULL_TREE
;
9534 /* Create and return a canonical pointer to member function type, for
9535 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9538 build_ptrmemfunc_type (tree type
)
9543 if (type
== error_mark_node
)
9546 /* Make sure that we always have the unqualified pointer-to-member
9548 if (cp_cv_quals quals
= cp_type_quals (type
))
9550 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
9551 return cp_build_qualified_type (unqual
, quals
);
9554 /* If a canonical type already exists for this type, use it. We use
9555 this method instead of type_hash_canon, because it only does a
9556 simple equality check on the list of field members. */
9558 t
= TYPE_PTRMEMFUNC_TYPE (type
);
9562 t
= make_node (RECORD_TYPE
);
9564 /* Let the front end know this is a pointer to member function. */
9565 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
9567 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
9570 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
9572 DECL_CHAIN (field
) = fields
;
9575 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
9577 /* Zap out the name so that the back end will give us the debugging
9578 information for this anonymous RECORD_TYPE. */
9579 TYPE_NAME (t
) = NULL_TREE
;
9581 /* Cache this pointer-to-member type so that we can find it again
9583 TYPE_PTRMEMFUNC_TYPE (type
) = t
;
9585 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
9586 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9587 else if (TYPE_CANONICAL (type
) != type
)
9588 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
9593 /* Create and return a pointer to data member type. */
9596 build_ptrmem_type (tree class_type
, tree member_type
)
9598 if (TREE_CODE (member_type
) == METHOD_TYPE
)
9600 cp_cv_quals quals
= type_memfn_quals (member_type
);
9601 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
9602 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
9603 return build_ptrmemfunc_type (build_pointer_type (member_type
));
9607 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
9608 return build_offset_type (class_type
, member_type
);
9612 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9613 Check to see that the definition is valid. Issue appropriate error
9617 check_static_variable_definition (tree decl
, tree type
)
9619 /* Avoid redundant diagnostics on out-of-class definitions. */
9620 if (!current_class_type
|| !TYPE_BEING_DEFINED (current_class_type
))
9622 /* Can't check yet if we don't know the type. */
9623 else if (dependent_type_p (type
))
9625 /* If DECL is declared constexpr, we'll do the appropriate checks
9626 in check_initializer. Similarly for inline static data members. */
9627 else if (DECL_P (decl
)
9628 && (DECL_DECLARED_CONSTEXPR_P (decl
)
9629 || undeduced_auto_decl (decl
)
9630 || DECL_VAR_DECLARED_INLINE_P (decl
)))
9632 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
9634 if (!COMPLETE_TYPE_P (type
))
9635 error_at (DECL_SOURCE_LOCATION (decl
),
9636 "in-class initialization of static data member %q#D of "
9637 "incomplete type", decl
);
9638 else if (literal_type_p (type
))
9639 permerror (DECL_SOURCE_LOCATION (decl
),
9640 "%<constexpr%> needed for in-class initialization of "
9641 "static data member %q#D of non-integral type", decl
);
9643 error_at (DECL_SOURCE_LOCATION (decl
),
9644 "in-class initialization of static data member %q#D of "
9645 "non-literal type", decl
);
9647 /* Motion 10 at San Diego: If a static const integral data member is
9648 initialized with an integral constant expression, the initializer
9649 may appear either in the declaration (within the class), or in
9650 the definition, but not both. If it appears in the class, the
9651 member is a member constant. The file-scope definition is always
9653 else if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
9654 error_at (DECL_SOURCE_LOCATION (decl
),
9655 "invalid in-class initialization of static data member "
9656 "of non-integral type %qT",
9658 else if (!CP_TYPE_CONST_P (type
))
9659 error_at (DECL_SOURCE_LOCATION (decl
),
9660 "ISO C++ forbids in-class initialization of non-const "
9661 "static member %qD",
9663 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
9664 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
9665 "ISO C++ forbids initialization of member constant "
9666 "%qD of non-integral type %qT", decl
, type
);
9669 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
9670 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
9671 expressions out into temporary variables so that walk_tree doesn't
9672 step into them (c++/15764). */
9675 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
9677 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
9678 tree expr
= *expr_p
;
9679 if (TREE_CODE (expr
) == SAVE_EXPR
)
9681 tree op
= TREE_OPERAND (expr
, 0);
9682 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
9683 if (TREE_SIDE_EFFECTS (op
))
9684 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
9687 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
9692 /* Entry point for the above. */
9695 stabilize_vla_size (tree size
)
9697 hash_set
<tree
> pset
;
9698 /* Break out any function calls into temporary variables. */
9699 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
9702 /* Reduce a SIZEOF_EXPR to its value. */
9705 fold_sizeof_expr (tree t
)
9708 if (SIZEOF_EXPR_TYPE_P (t
))
9709 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
9710 SIZEOF_EXPR
, false, false);
9711 else if (TYPE_P (TREE_OPERAND (t
, 0)))
9712 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
9715 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
9717 if (r
== error_mark_node
)
9722 /* Given the SIZE (i.e., number of elements) in an array, compute
9723 an appropriate index type for the array. If non-NULL, NAME is
9724 the name of the entity being declared. */
9727 compute_array_index_type_loc (location_t name_loc
, tree name
, tree size
,
9728 tsubst_flags_t complain
)
9730 if (error_operand_p (size
))
9731 return error_mark_node
;
9733 /* The type of the index being computed. */
9736 /* The original numeric size as seen in the source code before
9737 conversion to size_t. */
9738 tree origsize
= size
;
9740 location_t loc
= cp_expr_loc_or_loc (size
, name
? name_loc
: input_location
);
9742 if (!type_dependent_expression_p (size
))
9744 origsize
= size
= mark_rvalue_use (size
);
9746 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
9747 && TREE_SIDE_EFFECTS (size
))
9748 /* In C++98, we mark a non-constant array bound with a magic
9749 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
9752 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
9753 size
= build_converted_constant_expr (size_type_node
, size
, complain
);
9754 /* Pedantically a constant expression is required here and so
9755 __builtin_is_constant_evaluated () should fold to true if it
9756 is successfully folded into a constant. */
9757 size
= maybe_constant_value (size
, NULL_TREE
,
9758 /*manifestly_const_eval=*/true);
9760 if (!TREE_CONSTANT (size
))
9764 if (error_operand_p (size
))
9765 return error_mark_node
;
9767 /* The array bound must be an integer type. */
9768 tree type
= TREE_TYPE (size
);
9769 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
9771 if (!(complain
& tf_error
))
9772 return error_mark_node
;
9774 error_at (loc
, "size of array %qD has non-integral type %qT",
9777 error_at (loc
, "size of array has non-integral type %qT", type
);
9778 size
= integer_one_node
;
9782 /* A type is dependent if it is...an array type constructed from any
9783 dependent type or whose size is specified by a constant expression
9784 that is value-dependent. */
9785 /* We can only call value_dependent_expression_p on integral constant
9786 expressions; treat non-constant expressions as dependent, too. */
9787 if (processing_template_decl
9788 && (type_dependent_expression_p (size
)
9789 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
9791 /* We cannot do any checking for a SIZE that isn't known to be
9792 constant. Just build the index type and mark that it requires
9793 structural equality checks. */
9794 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
9795 size
, size_one_node
));
9796 TYPE_DEPENDENT_P (itype
) = 1;
9797 TYPE_DEPENDENT_P_VALID (itype
) = 1;
9798 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
9802 if (TREE_CODE (size
) != INTEGER_CST
)
9804 tree folded
= cp_fully_fold (size
);
9805 if (TREE_CODE (folded
) == INTEGER_CST
)
9808 pedwarn (loc
, OPT_Wpedantic
, "size of array %qD is not an "
9809 "integral constant-expression", name
);
9811 pedwarn (loc
, OPT_Wpedantic
,
9812 "size of array is not an integral constant-expression");
9814 /* Use the folded result for VLAs, too; it will have resolved
9819 /* Normally, the array-bound will be a constant. */
9820 if (TREE_CODE (size
) == INTEGER_CST
)
9822 /* The size to use in diagnostics that reflects the constant
9823 size used in the source, rather than SIZE massaged above. */
9824 tree diagsize
= size
;
9826 /* If the original size before conversion to size_t was signed
9827 and negative, convert it to ssizetype to restore the sign. */
9828 if (!TYPE_UNSIGNED (TREE_TYPE (origsize
))
9829 && TREE_CODE (size
) == INTEGER_CST
9830 && tree_int_cst_sign_bit (size
))
9832 diagsize
= fold_convert (ssizetype
, size
);
9834 /* Clear the overflow bit that may have been set as a result
9835 of the conversion from the sizetype of the new size to
9837 TREE_OVERFLOW (diagsize
) = false;
9840 /* Verify that the array has a positive number of elements
9841 and issue the appropriate diagnostic if it doesn't. */
9842 if (!valid_array_size_p (loc
, diagsize
, name
, (complain
& tf_error
)))
9844 if (!(complain
& tf_error
))
9845 return error_mark_node
;
9846 size
= integer_one_node
;
9848 /* As an extension we allow zero-sized arrays. */
9849 else if (integer_zerop (size
))
9851 if (!(complain
& tf_error
))
9852 /* We must fail if performing argument deduction (as
9853 indicated by the state of complain), so that
9854 another substitution can be found. */
9855 return error_mark_node
;
9856 else if (in_system_header_at (input_location
))
9857 /* Allow them in system headers because glibc uses them. */;
9859 pedwarn (loc
, OPT_Wpedantic
,
9860 "ISO C++ forbids zero-size array %qD", name
);
9862 pedwarn (loc
, OPT_Wpedantic
,
9863 "ISO C++ forbids zero-size array");
9866 else if (TREE_CONSTANT (size
)
9867 /* We don't allow VLAs at non-function scopes, or during
9868 tentative template substitution. */
9869 || !at_function_scope_p ()
9870 || !(complain
& tf_error
))
9872 if (!(complain
& tf_error
))
9873 return error_mark_node
;
9874 /* `(int) &fn' is not a valid array bound. */
9877 "size of array %qD is not an integral constant-expression",
9880 error_at (loc
, "size of array is not an integral constant-expression");
9881 size
= integer_one_node
;
9883 else if (pedantic
&& warn_vla
!= 0)
9886 pedwarn (name_loc
, OPT_Wvla
,
9887 "ISO C++ forbids variable length array %qD", name
);
9889 pedwarn (input_location
, OPT_Wvla
,
9890 "ISO C++ forbids variable length array");
9892 else if (warn_vla
> 0)
9895 warning_at (name_loc
, OPT_Wvla
,
9896 "variable length array %qD is used", name
);
9899 "variable length array is used");
9902 if (processing_template_decl
&& !TREE_CONSTANT (size
))
9903 /* A variable sized array. */
9904 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
9907 /* Compute the index of the largest element in the array. It is
9908 one less than the number of elements in the array. We save
9909 and restore PROCESSING_TEMPLATE_DECL so that computations in
9910 cp_build_binary_op will be appropriately folded. */
9912 processing_template_decl_sentinel s
;
9913 itype
= cp_build_binary_op (input_location
,
9915 cp_convert (ssizetype
, size
, complain
),
9916 cp_convert (ssizetype
, integer_one_node
,
9919 itype
= maybe_constant_value (itype
);
9922 if (!TREE_CONSTANT (itype
))
9924 /* A variable sized array. */
9925 itype
= variable_size (itype
);
9927 stabilize_vla_size (itype
);
9929 if (sanitize_flags_p (SANITIZE_VLA
)
9930 && current_function_decl
!= NULL_TREE
)
9932 /* We have to add 1 -- in the ubsan routine we generate
9933 LE_EXPR rather than LT_EXPR. */
9934 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
9935 build_one_cst (TREE_TYPE (itype
)));
9936 t
= ubsan_instrument_vla (input_location
, t
);
9937 finish_expr_stmt (t
);
9940 /* Make sure that there was no overflow when creating to a signed
9941 index type. (For example, on a 32-bit machine, an array with
9942 size 2^32 - 1 is too big.) */
9943 else if (TREE_CODE (itype
) == INTEGER_CST
9944 && TREE_OVERFLOW (itype
))
9946 if (!(complain
& tf_error
))
9947 return error_mark_node
;
9948 error ("overflow in array dimension");
9949 TREE_OVERFLOW (itype
) = 0;
9953 /* Create and return the appropriate index type. */
9954 itype
= build_index_type (itype
);
9956 /* If the index type were dependent, we would have returned early, so
9957 remember that it isn't. */
9958 TYPE_DEPENDENT_P (itype
) = 0;
9959 TYPE_DEPENDENT_P_VALID (itype
) = 1;
9964 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
9966 return compute_array_index_type_loc (input_location
, name
, size
, complain
);
9969 /* Returns the scope (if any) in which the entity declared by
9970 DECLARATOR will be located. If the entity was declared with an
9971 unqualified name, NULL_TREE is returned. */
9974 get_scope_of_declarator (const cp_declarator
*declarator
)
9976 while (declarator
&& declarator
->kind
!= cdk_id
)
9977 declarator
= declarator
->declarator
;
9979 /* If the declarator-id is a SCOPE_REF, the scope in which the
9980 declaration occurs is the first operand. */
9982 && declarator
->u
.id
.qualifying_scope
)
9983 return declarator
->u
.id
.qualifying_scope
;
9985 /* Otherwise, the declarator is not a qualified name; the entity will
9986 be declared in the current scope. */
9990 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9991 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9995 create_array_type_for_decl (tree name
, tree type
, tree size
, location_t loc
)
9997 tree itype
= NULL_TREE
;
9999 /* If things have already gone awry, bail now. */
10000 if (type
== error_mark_node
|| size
== error_mark_node
)
10001 return error_mark_node
;
10003 /* 8.3.4/1: If the type of the identifier of D contains the auto
10004 type-specifier, the program is ill-formed. */
10005 if (type_uses_auto (type
))
10008 error_at (loc
, "%qD declared as array of %qT", name
, type
);
10010 error ("creating array of %qT", type
);
10011 return error_mark_node
;
10014 /* If there are some types which cannot be array elements,
10015 issue an error-message and return. */
10016 switch (TREE_CODE (type
))
10020 error_at (loc
, "declaration of %qD as array of void", name
);
10022 error ("creating array of void");
10023 return error_mark_node
;
10025 case FUNCTION_TYPE
:
10027 error_at (loc
, "declaration of %qD as array of functions", name
);
10029 error ("creating array of functions");
10030 return error_mark_node
;
10032 case REFERENCE_TYPE
:
10034 error_at (loc
, "declaration of %qD as array of references", name
);
10036 error ("creating array of references");
10037 return error_mark_node
;
10041 error_at (loc
, "declaration of %qD as array of function members",
10044 error ("creating array of function members");
10045 return error_mark_node
;
10053 The constant expressions that specify the bounds of the arrays
10054 can be omitted only for the first member of the sequence. */
10055 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
10058 error_at (loc
, "declaration of %qD as multidimensional array must "
10059 "have bounds for all dimensions except the first",
10062 error ("multidimensional array must have bounds for all "
10063 "dimensions except the first");
10065 return error_mark_node
;
10068 /* Figure out the index type for the array. */
10070 itype
= compute_array_index_type_loc (loc
, name
, size
,
10071 tf_warning_or_error
);
10074 T is called the array element type; this type shall not be [...] an
10075 abstract class type. */
10076 abstract_virtuals_error (name
, type
);
10078 return build_cplus_array_type (type
, itype
);
10081 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
10084 min_location (location_t loca
, location_t locb
)
10086 if (loca
== UNKNOWN_LOCATION
10087 || (locb
!= UNKNOWN_LOCATION
10088 && linemap_location_before_p (line_table
, locb
, loca
)))
10093 /* Returns the smallest location != UNKNOWN_LOCATION among the
10094 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
10095 and LOCATIONS[ds_restrict]. */
10098 smallest_type_quals_location (int type_quals
, const location_t
* locations
)
10100 location_t loc
= UNKNOWN_LOCATION
;
10102 if (type_quals
& TYPE_QUAL_CONST
)
10103 loc
= locations
[ds_const
];
10105 if (type_quals
& TYPE_QUAL_VOLATILE
)
10106 loc
= min_location (loc
, locations
[ds_volatile
]);
10108 if (type_quals
& TYPE_QUAL_RESTRICT
)
10109 loc
= min_location (loc
, locations
[ds_restrict
]);
10114 /* Returns the smallest among the latter and locations[ds_type_spec]. */
10117 smallest_type_location (int type_quals
, const location_t
* locations
)
10119 location_t loc
= smallest_type_quals_location (type_quals
, locations
);
10120 return min_location (loc
, locations
[ds_type_spec
]);
10123 /* Check that it's OK to declare a function with the indicated TYPE
10124 and TYPE_QUALS. SFK indicates the kind of special function (if any)
10125 that this function is. OPTYPE is the type given in a conversion
10126 operator declaration, or the class type for a constructor/destructor.
10127 Returns the actual return type of the function; that may be different
10128 than TYPE if an error occurs, or for certain special functions. */
10131 check_special_function_return_type (special_function_kind sfk
,
10135 const location_t
* locations
)
10139 case sfk_constructor
:
10141 error_at (smallest_type_location (type_quals
, locations
),
10142 "return type specification for constructor invalid");
10143 else if (type_quals
!= TYPE_UNQUALIFIED
)
10144 error_at (smallest_type_quals_location (type_quals
, locations
),
10145 "qualifiers are not allowed on constructor declaration");
10147 if (targetm
.cxx
.cdtor_returns_this ())
10148 type
= build_pointer_type (optype
);
10150 type
= void_type_node
;
10153 case sfk_destructor
:
10155 error_at (smallest_type_location (type_quals
, locations
),
10156 "return type specification for destructor invalid");
10157 else if (type_quals
!= TYPE_UNQUALIFIED
)
10158 error_at (smallest_type_quals_location (type_quals
, locations
),
10159 "qualifiers are not allowed on destructor declaration");
10161 /* We can't use the proper return type here because we run into
10162 problems with ambiguous bases and covariant returns. */
10163 if (targetm
.cxx
.cdtor_returns_this ())
10164 type
= build_pointer_type (void_type_node
);
10166 type
= void_type_node
;
10169 case sfk_conversion
:
10171 error_at (smallest_type_location (type_quals
, locations
),
10172 "return type specified for %<operator %T%>", optype
);
10173 else if (type_quals
!= TYPE_UNQUALIFIED
)
10174 error_at (smallest_type_quals_location (type_quals
, locations
),
10175 "qualifiers are not allowed on declaration of "
10176 "%<operator %T%>", optype
);
10181 case sfk_deduction_guide
:
10183 error_at (smallest_type_location (type_quals
, locations
),
10184 "return type specified for deduction guide");
10185 else if (type_quals
!= TYPE_UNQUALIFIED
)
10186 error_at (smallest_type_quals_location (type_quals
, locations
),
10187 "qualifiers are not allowed on declaration of "
10188 "deduction guide");
10189 if (TREE_CODE (optype
) == TEMPLATE_TEMPLATE_PARM
)
10191 error ("template template parameter %qT in declaration of "
10192 "deduction guide", optype
);
10193 type
= error_mark_node
;
10196 type
= make_template_placeholder (CLASSTYPE_TI_TEMPLATE (optype
));
10197 for (int i
= 0; i
< ds_last
; ++i
)
10198 if (i
!= ds_explicit
&& locations
[i
])
10199 error_at (locations
[i
],
10200 "%<decl-specifier%> in declaration of deduction guide");
10204 gcc_unreachable ();
10210 /* A variable or data member (whose unqualified name is IDENTIFIER)
10211 has been declared with the indicated TYPE. If the TYPE is not
10212 acceptable, issue an error message and return a type to use for
10213 error-recovery purposes. */
10216 check_var_type (tree identifier
, tree type
)
10218 if (VOID_TYPE_P (type
))
10221 error ("unnamed variable or field declared void");
10222 else if (identifier_p (identifier
))
10224 gcc_assert (!IDENTIFIER_ANY_OP_P (identifier
));
10225 error ("variable or field %qE declared void", identifier
);
10228 error ("variable or field declared void");
10229 type
= error_mark_node
;
10235 /* Handle declaring DECL as an inline variable. */
10238 mark_inline_variable (tree decl
, location_t loc
)
10240 bool inlinep
= true;
10241 if (! toplevel_bindings_p ())
10243 error_at (loc
, "%<inline%> specifier invalid for variable "
10244 "%qD declared at block scope", decl
);
10247 else if (cxx_dialect
< cxx17
)
10248 pedwarn (loc
, 0, "inline variables are only available "
10249 "with %<-std=c++17%> or %<-std=gnu++17%>");
10252 retrofit_lang_decl (decl
);
10253 SET_DECL_VAR_DECLARED_INLINE_P (decl
);
10258 /* Assign a typedef-given name to a class or enumeration type declared
10259 as anonymous at first. This was split out of grokdeclarator
10260 because it is also used in libcc1. */
10263 name_unnamed_type (tree type
, tree decl
)
10265 gcc_assert (TYPE_UNNAMED_P (type
));
10267 /* Replace the anonymous name with the real name everywhere. */
10268 for (tree t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10269 if (IDENTIFIER_ANON_P (TYPE_IDENTIFIER (t
)))
10270 /* We do not rename the debug info representing the unnamed
10271 tagged type because the standard says in [dcl.typedef] that
10272 the naming applies only for linkage purposes. */
10273 /*debug_hooks->set_name (t, decl);*/
10274 TYPE_NAME (t
) = decl
;
10276 if (TYPE_LANG_SPECIFIC (type
))
10277 TYPE_WAS_UNNAMED (type
) = 1;
10279 /* If this is a typedef within a template class, the nested
10280 type is a (non-primary) template. The name for the
10281 template needs updating as well. */
10282 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10283 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10284 = TYPE_IDENTIFIER (type
);
10286 /* Adjust linkage now that we aren't unnamed anymore. */
10287 reset_type_linkage (type
);
10289 /* FIXME remangle member functions; member functions of a
10290 type with external linkage have external linkage. */
10292 /* Check that our job is done, and that it would fail if we
10293 attempted to do it again. */
10294 gcc_assert (!TYPE_UNNAMED_P (type
));
10297 /* Given declspecs and a declarator (abstract or otherwise), determine
10298 the name and type of the object declared and construct a DECL node
10301 DECLSPECS points to the representation of declaration-specifier
10302 sequence that precedes declarator.
10304 DECL_CONTEXT says which syntactic context this declaration is in:
10305 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
10306 FUNCDEF for a function definition. Like NORMAL but a few different
10307 error messages in each case. Return value may be zero meaning
10308 this definition is too screwy to try to parse.
10309 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
10310 handle member functions (which have FIELD context).
10311 Return value may be zero meaning this definition is too screwy to
10313 PARM for a parameter declaration (either within a function prototype
10314 or before a function body). Make a PARM_DECL, or return void_type_node.
10315 TPARM for a template parameter declaration.
10316 CATCHPARM for a parameter declaration before a catch clause.
10317 TYPENAME if for a typename (in a cast or sizeof).
10318 Don't make a DECL node; just return the ..._TYPE node.
10319 FIELD for a struct or union field; make a FIELD_DECL.
10320 BITFIELD for a field with specified width.
10322 INITIALIZED is as for start_decl.
10324 ATTRLIST is a pointer to the list of attributes, which may be NULL
10325 if there are none; *ATTRLIST may be modified if attributes from inside
10326 the declarator should be applied to the declaration.
10328 When this function is called, scoping variables (such as
10329 CURRENT_CLASS_TYPE) should reflect the scope in which the
10330 declaration occurs, not the scope in which the new declaration will
10331 be placed. For example, on:
10333 void S::f() { ... }
10335 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
10338 Returns a DECL (if a declarator is present), a TYPE (if there is no
10339 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
10343 grokdeclarator (const cp_declarator
*declarator
,
10344 cp_decl_specifier_seq
*declspecs
,
10345 enum decl_context decl_context
,
10349 tree type
= NULL_TREE
;
10351 int explicit_intN
= 0;
10352 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
10353 int explicit_int
= 0;
10354 int explicit_char
= 0;
10355 int defaulted_int
= 0;
10357 tree typedef_decl
= NULL_TREE
;
10358 const char *name
= NULL
;
10359 tree typedef_type
= NULL_TREE
;
10360 /* True if this declarator is a function definition. */
10361 bool funcdef_flag
= false;
10362 cp_declarator_kind innermost_code
= cdk_error
;
10365 /* See the code below that used this. */
10366 tree decl_attr
= NULL_TREE
;
10369 /* Keep track of what sort of function is being processed
10370 so that we can warn about default return values, or explicit
10371 return values which do not match prescribed defaults. */
10372 special_function_kind sfk
= sfk_none
;
10374 tree dname
= NULL_TREE
;
10375 tree ctor_return_type
= NULL_TREE
;
10376 enum overload_flags flags
= NO_SPECIAL
;
10377 /* cv-qualifiers that apply to the declarator, for a declaration of
10378 a member function. */
10379 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
10380 /* virt-specifiers that apply to the declarator, for a declaration of
10381 a member function. */
10382 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
10383 /* ref-qualifier that applies to the declarator, for a declaration of
10384 a member function. */
10385 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
10386 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
10387 int type_quals
= TYPE_UNQUALIFIED
;
10388 tree raises
= NULL_TREE
;
10389 int template_count
= 0;
10390 tree returned_attrs
= NULL_TREE
;
10391 tree parms
= NULL_TREE
;
10392 const cp_declarator
*id_declarator
;
10393 /* The unqualified name of the declarator; either an
10394 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
10395 tree unqualified_id
;
10396 /* The class type, if any, in which this entity is located,
10397 or NULL_TREE if none. Note that this value may be different from
10398 the current class type; for example if an attempt is made to declare
10399 "A::f" inside "B", this value will be "A". */
10400 tree ctype
= current_class_type
;
10401 /* The NAMESPACE_DECL for the namespace in which this entity is
10402 located. If an unqualified name is used to declare the entity,
10403 this value will be NULL_TREE, even if the entity is located at
10404 namespace scope. */
10405 tree in_namespace
= NULL_TREE
;
10406 cp_storage_class storage_class
;
10407 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
10408 bool type_was_error_mark_node
= false;
10409 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
10410 bool template_type_arg
= false;
10411 bool template_parm_flag
= false;
10412 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
10413 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
10414 bool late_return_type_p
= false;
10415 bool array_parameter_p
= false;
10416 location_t saved_loc
= input_location
;
10417 tree reqs
= NULL_TREE
;
10419 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
10420 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
10421 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
10422 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
10423 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
10424 explicit_intN
= declspecs
->explicit_intN_p
;
10425 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
10427 // Was concept_p specified? Note that ds_concept
10428 // implies ds_constexpr!
10429 bool concept_p
= decl_spec_seq_has_spec_p (declspecs
, ds_concept
);
10431 constexpr_p
= true;
10433 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
10434 type_quals
|= TYPE_QUAL_CONST
;
10435 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
10436 type_quals
|= TYPE_QUAL_VOLATILE
;
10437 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
10438 type_quals
|= TYPE_QUAL_RESTRICT
;
10440 if (decl_context
== FUNCDEF
)
10441 funcdef_flag
= true, decl_context
= NORMAL
;
10442 else if (decl_context
== MEMFUNCDEF
)
10443 funcdef_flag
= true, decl_context
= FIELD
;
10444 else if (decl_context
== BITFIELD
)
10445 bitfield
= 1, decl_context
= FIELD
;
10446 else if (decl_context
== TEMPLATE_TYPE_ARG
)
10447 template_type_arg
= true, decl_context
= TYPENAME
;
10448 else if (decl_context
== TPARM
)
10449 template_parm_flag
= true, decl_context
= PARM
;
10451 if (initialized
> 1)
10452 funcdef_flag
= true;
10454 location_t typespec_loc
= smallest_type_location (type_quals
,
10455 declspecs
->locations
);
10456 if (typespec_loc
== UNKNOWN_LOCATION
)
10457 typespec_loc
= input_location
;
10459 location_t id_loc
= declarator
? declarator
->id_loc
: input_location
;
10460 if (id_loc
== UNKNOWN_LOCATION
)
10461 id_loc
= input_location
;
10463 /* Look inside a declarator for the name being declared
10464 and get it as a string, for an error message. */
10465 for (id_declarator
= declarator
;
10467 id_declarator
= id_declarator
->declarator
)
10469 if (id_declarator
->kind
!= cdk_id
)
10470 innermost_code
= id_declarator
->kind
;
10472 switch (id_declarator
->kind
)
10475 if (id_declarator
->declarator
10476 && id_declarator
->declarator
->kind
== cdk_id
)
10478 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
10479 if (sfk
== sfk_destructor
)
10486 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
10487 tree decl
= id_declarator
->u
.id
.unqualified_name
;
10490 if (qualifying_scope
)
10492 if (check_for_bare_parameter_packs (qualifying_scope
,
10493 id_declarator
->id_loc
))
10494 return error_mark_node
;
10495 if (at_function_scope_p ())
10499 A declarator-id shall not be qualified except
10502 None of the cases are permitted in block
10504 if (qualifying_scope
== global_namespace
)
10505 error ("invalid use of qualified-name %<::%D%>",
10507 else if (TYPE_P (qualifying_scope
))
10508 error ("invalid use of qualified-name %<%T::%D%>",
10509 qualifying_scope
, decl
);
10511 error ("invalid use of qualified-name %<%D::%D%>",
10512 qualifying_scope
, decl
);
10513 return error_mark_node
;
10515 else if (TYPE_P (qualifying_scope
))
10517 ctype
= qualifying_scope
;
10518 if (!MAYBE_CLASS_TYPE_P (ctype
))
10520 error ("%q#T is not a class or a namespace", ctype
);
10523 else if (innermost_code
!= cdk_function
10524 && current_class_type
10525 && !uniquely_derived_from_p (ctype
,
10526 current_class_type
))
10528 error ("invalid use of qualified-name %<%T::%D%>",
10529 qualifying_scope
, decl
);
10530 return error_mark_node
;
10533 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
10534 in_namespace
= qualifying_scope
;
10536 switch (TREE_CODE (decl
))
10540 if (innermost_code
!= cdk_function
)
10542 error ("declaration of %qD as non-function", decl
);
10543 return error_mark_node
;
10545 else if (!qualifying_scope
10546 && !(current_class_type
&& at_class_scope_p ()))
10548 error ("declaration of %qD as non-member", decl
);
10549 return error_mark_node
;
10552 tree type
= TREE_OPERAND (decl
, 0);
10554 type
= constructor_name (type
);
10555 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
10560 case TEMPLATE_ID_EXPR
:
10562 tree fns
= TREE_OPERAND (decl
, 0);
10565 if (!identifier_p (dname
))
10566 dname
= OVL_NAME (dname
);
10568 /* Fall through. */
10570 case IDENTIFIER_NODE
:
10571 if (identifier_p (decl
))
10574 if (IDENTIFIER_KEYWORD_P (dname
))
10576 error ("declarator-id missing; using reserved word %qD",
10578 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10580 else if (!IDENTIFIER_CONV_OP_P (dname
))
10581 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10584 gcc_assert (flags
== NO_SPECIAL
);
10585 flags
= TYPENAME_FLAG
;
10586 sfk
= sfk_conversion
;
10587 tree glob
= get_global_binding (dname
);
10588 if (glob
&& TREE_CODE (glob
) == TYPE_DECL
)
10589 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10591 name
= "<invalid operator>";
10596 gcc_unreachable ();
10603 case cdk_reference
:
10608 name
= "structured binding";
10612 return error_mark_node
;
10615 gcc_unreachable ();
10617 if (id_declarator
->kind
== cdk_id
)
10623 The declarator in a function-definition shall have the form
10624 D1 ( parameter-declaration-clause) ... */
10625 if (funcdef_flag
&& innermost_code
!= cdk_function
)
10627 error_at (id_loc
, "function definition does not declare parameters");
10628 return error_mark_node
;
10631 if (flags
== TYPENAME_FLAG
10632 && innermost_code
!= cdk_function
10633 && ! (ctype
&& !declspecs
->any_specifiers_p
))
10635 error_at (id_loc
, "declaration of %qD as non-function", dname
);
10636 return error_mark_node
;
10639 if (dname
&& identifier_p (dname
))
10641 if (UDLIT_OPER_P (dname
)
10642 && innermost_code
!= cdk_function
)
10644 error_at (id_loc
, "declaration of %qD as non-function", dname
);
10645 return error_mark_node
;
10648 if (IDENTIFIER_ANY_OP_P (dname
))
10652 error_at (id_loc
, "declaration of %qD as %<typedef%>", dname
);
10653 return error_mark_node
;
10655 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10657 error_at (id_loc
, "declaration of %qD as parameter", dname
);
10658 return error_mark_node
;
10663 /* Anything declared one level down from the top level
10664 must be one of the parameters of a function
10665 (because the body is at least two levels down). */
10667 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10668 by not allowing C++ class definitions to specify their parameters
10669 with xdecls (must be spec.d in the parmlist).
10671 Since we now wait to push a class scope until we are sure that
10672 we are in a legitimate method context, we must set oldcname
10673 explicitly (since current_class_name is not yet alive).
10675 We also want to avoid calling this a PARM if it is in a namespace. */
10677 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
10679 cp_binding_level
*b
= current_binding_level
;
10680 current_binding_level
= b
->level_chain
;
10681 if (current_binding_level
!= 0 && toplevel_bindings_p ())
10682 decl_context
= PARM
;
10683 current_binding_level
= b
;
10687 name
= decl_context
== PARM
? "parameter" : "type name";
10689 if (concept_p
&& typedef_p
)
10691 error_at (declspecs
->locations
[ds_concept
],
10692 "%<concept%> cannot appear in a typedef declaration");
10693 return error_mark_node
;
10696 if (constexpr_p
&& typedef_p
)
10698 error_at (declspecs
->locations
[ds_constexpr
],
10699 "%<constexpr%> cannot appear in a typedef declaration");
10700 return error_mark_node
;
10703 /* If there were multiple types specified in the decl-specifier-seq,
10704 issue an error message. */
10705 if (declspecs
->multiple_types_p
)
10707 error_at (typespec_loc
,
10708 "two or more data types in declaration of %qs", name
);
10709 return error_mark_node
;
10712 if (declspecs
->conflicting_specifiers_p
)
10714 error_at (min_location (declspecs
->locations
[ds_typedef
],
10715 declspecs
->locations
[ds_storage_class
]),
10716 "conflicting specifiers in declaration of %qs", name
);
10717 return error_mark_node
;
10720 /* Extract the basic type from the decl-specifier-seq. */
10721 type
= declspecs
->type
;
10722 if (type
== error_mark_node
)
10725 type_was_error_mark_node
= true;
10727 cp_warn_deprecated_use (type
);
10728 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
10730 typedef_decl
= type
;
10731 type
= TREE_TYPE (typedef_decl
);
10732 if (DECL_ARTIFICIAL (typedef_decl
))
10733 cp_warn_deprecated_use (type
);
10735 /* No type at all: default to `int', and set DEFAULTED_INT
10736 because it was not a user-defined typedef. */
10737 if (type
== NULL_TREE
)
10739 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
10741 /* These imply 'int'. */
10742 type
= integer_type_node
;
10745 /* If we just have "complex", it is equivalent to "complex double". */
10746 else if (!longlong
&& !explicit_intN
10747 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
10749 type
= double_type_node
;
10750 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
10751 "ISO C++ does not support plain %<complex%> meaning "
10752 "%<double complex%>");
10755 /* Gather flags. */
10756 explicit_int
= declspecs
->explicit_int_p
;
10757 explicit_char
= declspecs
->explicit_char_p
;
10760 /* See the code below that used this. */
10762 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
10764 typedef_type
= type
;
10766 if (sfk
== sfk_conversion
|| sfk
== sfk_deduction_guide
)
10767 ctor_return_type
= TREE_TYPE (dname
);
10769 ctor_return_type
= ctype
;
10771 if (sfk
!= sfk_none
)
10773 type
= check_special_function_return_type (sfk
, type
,
10776 declspecs
->locations
);
10777 type_quals
= TYPE_UNQUALIFIED
;
10779 else if (type
== NULL_TREE
)
10785 /* We handle `main' specially here, because 'main () { }' is so
10786 common. With no options, it is allowed. With -Wreturn-type,
10787 it is a warning. It is only an error with -pedantic-errors. */
10788 is_main
= (funcdef_flag
10789 && dname
&& identifier_p (dname
)
10790 && MAIN_NAME_P (dname
)
10791 && ctype
== NULL_TREE
10792 && in_namespace
== NULL_TREE
10793 && current_namespace
== global_namespace
);
10795 if (type_was_error_mark_node
)
10796 /* We've already issued an error, don't complain more. */;
10797 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
10798 /* Allow it, sigh. */;
10799 else if (! is_main
)
10800 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
10802 pedwarn (input_location
, OPT_Wpedantic
,
10803 "ISO C++ forbids declaration of %qs with no type", name
);
10805 warning (OPT_Wreturn_type
,
10806 "ISO C++ forbids declaration of %qs with no type", name
);
10808 if (type_was_error_mark_node
&& template_parm_flag
)
10809 /* FIXME we should be able to propagate the error_mark_node as is
10810 for other contexts too. */
10811 type
= error_mark_node
;
10813 type
= integer_type_node
;
10820 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
10822 error ("%<__int%d%> is not supported by this target",
10823 int_n_data
[declspecs
->int_n_idx
].bitsize
);
10824 explicit_intN
= false;
10826 else if (pedantic
&& ! in_system_header_at (input_location
))
10827 pedwarn (input_location
, OPT_Wpedantic
,
10828 "ISO C++ does not support %<__int%d%> for %qs",
10829 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
10832 /* Now process the modifiers that were specified
10833 and check for invalid combinations. */
10835 /* Long double is a special combination. */
10836 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
10839 type
= cp_build_qualified_type (long_double_type_node
,
10840 cp_type_quals (type
));
10843 /* Check all other uses of type modifiers. */
10845 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
10852 loc
= declspecs
->locations
[ds_unsigned
];
10857 loc
= declspecs
->locations
[ds_signed
];
10862 loc
= declspecs
->locations
[ds_long_long
];
10867 loc
= declspecs
->locations
[ds_long
];
10869 else /* if (short_p) */
10872 loc
= declspecs
->locations
[ds_short
];
10877 if (signed_p
&& unsigned_p
)
10879 gcc_rich_location
richloc (declspecs
->locations
[ds_signed
]);
10880 richloc
.add_range (declspecs
->locations
[ds_unsigned
]);
10881 error_at (&richloc
,
10882 "%<signed%> and %<unsigned%> specified together");
10884 else if (long_p
&& short_p
)
10886 gcc_rich_location
richloc (declspecs
->locations
[ds_long
]);
10887 richloc
.add_range (declspecs
->locations
[ds_short
]);
10888 error_at (&richloc
, "%<long%> and %<short%> specified together");
10890 else if (TREE_CODE (type
) != INTEGER_TYPE
10891 || type
== char8_type_node
10892 || type
== char16_type_node
10893 || type
== char32_type_node
10894 || ((long_p
|| short_p
)
10895 && (explicit_char
|| explicit_intN
)))
10896 error_at (loc
, "%qs specified with %qT", key
, type
);
10897 else if (!explicit_int
&& !defaulted_int
10898 && !explicit_char
&& !explicit_intN
)
10902 pedwarn (loc
, OPT_Wpedantic
, "%qs specified with %qT",
10904 ok
= !flag_pedantic_errors
;
10906 else if (declspecs
->decltype_p
)
10907 error_at (loc
, "%qs specified with %<decltype%>", key
);
10909 error_at (loc
, "%qs specified with %<typeof%>", key
);
10914 /* Discard the type modifiers if they are invalid. */
10917 unsigned_p
= false;
10925 /* Decide whether an integer type is signed or not.
10926 Optionally treat bitfields as signed by default. */
10930 It is implementation-defined whether a plain (neither
10931 explicitly signed or unsigned) char, short, int, or long
10932 bit-field is signed or unsigned.
10934 Naturally, we extend this to long long as well. Note that
10935 this does not include wchar_t. */
10936 || (bitfield
&& !flag_signed_bitfields
10938 /* A typedef for plain `int' without `signed' can be
10939 controlled just like plain `int', but a typedef for
10940 `signed int' cannot be so controlled. */
10942 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
10943 && TREE_CODE (type
) == INTEGER_TYPE
10944 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
10947 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
10949 type
= long_long_unsigned_type_node
;
10951 type
= long_unsigned_type_node
;
10953 type
= short_unsigned_type_node
;
10954 else if (type
== char_type_node
)
10955 type
= unsigned_char_type_node
;
10956 else if (typedef_decl
)
10957 type
= unsigned_type_for (type
);
10959 type
= unsigned_type_node
;
10961 else if (signed_p
&& type
== char_type_node
)
10962 type
= signed_char_type_node
;
10963 else if (explicit_intN
)
10964 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
10966 type
= long_long_integer_type_node
;
10968 type
= long_integer_type_node
;
10970 type
= short_integer_type_node
;
10972 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
10974 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
10975 error ("complex invalid for %qs", name
);
10976 /* If a modifier is specified, the resulting complex is the complex
10977 form of TYPE. E.g, "complex short" is "complex short int". */
10978 else if (type
== integer_type_node
)
10979 type
= complex_integer_type_node
;
10980 else if (type
== float_type_node
)
10981 type
= complex_float_type_node
;
10982 else if (type
== double_type_node
)
10983 type
= complex_double_type_node
;
10984 else if (type
== long_double_type_node
)
10985 type
= complex_long_double_type_node
;
10987 type
= build_complex_type (type
);
10990 /* If we're using the injected-class-name to form a compound type or a
10991 declaration, replace it with the underlying class so we don't get
10992 redundant typedefs in the debug output. But if we are returning the
10993 type unchanged, leave it alone so that it's available to
10994 maybe_get_template_decl_from_type_decl. */
10995 if (CLASS_TYPE_P (type
)
10996 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
10997 && type
== TREE_TYPE (TYPE_NAME (type
))
10998 && (declarator
|| type_quals
))
10999 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
11001 type_quals
|= cp_type_quals (type
);
11002 type
= cp_build_qualified_type_real
11003 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
11004 || declspecs
->decltype_p
)
11005 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
11006 /* We might have ignored or rejected some of the qualifiers. */
11007 type_quals
= cp_type_quals (type
);
11009 if (cxx_dialect
>= cxx17
&& type
&& is_auto (type
)
11010 && innermost_code
!= cdk_function
11011 && id_declarator
&& declarator
!= id_declarator
)
11012 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (type
))
11014 error_at (typespec_loc
, "template placeholder type %qT must be followed "
11015 "by a simple declarator-id", type
);
11016 inform (DECL_SOURCE_LOCATION (tmpl
), "%qD declared here", tmpl
);
11017 type
= error_mark_node
;
11021 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
11022 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
11023 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
11025 storage_class
= declspecs
->storage_class
;
11026 if (storage_class
== sc_static
)
11027 staticp
= 1 + (decl_context
== FIELD
);
11033 gcc_rich_location
richloc (declspecs
->locations
[ds_virtual
]);
11034 richloc
.add_range (declspecs
->locations
[ds_storage_class
]);
11035 error_at (&richloc
, "member %qD cannot be declared both %<virtual%> "
11036 "and %<static%>", dname
);
11037 storage_class
= sc_none
;
11040 if (constexpr_p
&& cxx_dialect
< cxx2a
)
11042 gcc_rich_location
richloc (declspecs
->locations
[ds_virtual
]);
11043 richloc
.add_range (declspecs
->locations
[ds_constexpr
]);
11044 pedwarn (&richloc
, OPT_Wpedantic
, "member %qD can be declared both "
11045 "%<virtual%> and %<constexpr%> only in %<-std=c++2a%> or "
11046 "%<-std=gnu++2a%>", dname
);
11049 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
11051 /* Issue errors about use of storage classes for parameters. */
11052 if (decl_context
== PARM
)
11056 error_at (declspecs
->locations
[ds_typedef
],
11057 "typedef declaration invalid in parameter declaration");
11058 return error_mark_node
;
11060 else if (template_parm_flag
&& storage_class
!= sc_none
)
11062 error_at (min_location (declspecs
->locations
[ds_thread
],
11063 declspecs
->locations
[ds_storage_class
]),
11064 "storage class specified for template parameter %qs",
11066 return error_mark_node
;
11068 else if (storage_class
== sc_static
11069 || storage_class
== sc_extern
11072 error_at (min_location (declspecs
->locations
[ds_thread
],
11073 declspecs
->locations
[ds_storage_class
]),
11074 "storage class specified for parameter %qs", name
);
11075 return error_mark_node
;
11078 /* Function parameters cannot be concept. */
11080 error_at (declspecs
->locations
[ds_concept
],
11081 "a parameter cannot be declared %<concept%>");
11082 /* Function parameters cannot be constexpr. If we saw one, moan
11083 and pretend it wasn't there. */
11084 else if (constexpr_p
)
11086 error_at (declspecs
->locations
[ds_constexpr
],
11087 "a parameter cannot be declared %<constexpr%>");
11092 /* Give error if `virtual' is used outside of class declaration. */
11094 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
11096 error_at (declspecs
->locations
[ds_virtual
],
11097 "%<virtual%> outside class declaration");
11101 if (innermost_code
== cdk_decomp
)
11103 location_t loc
= (declarator
->kind
== cdk_reference
11104 ? declarator
->declarator
->id_loc
: declarator
->id_loc
);
11106 error_at (declspecs
->locations
[ds_inline
],
11107 "structured binding declaration cannot be %qs", "inline");
11109 error_at (declspecs
->locations
[ds_typedef
],
11110 "structured binding declaration cannot be %qs", "typedef");
11112 error_at (declspecs
->locations
[ds_constexpr
], "structured "
11113 "binding declaration cannot be %qs", "constexpr");
11114 if (thread_p
&& cxx_dialect
< cxx2a
)
11115 pedwarn (declspecs
->locations
[ds_thread
], 0,
11116 "structured binding declaration can be %qs only in "
11117 "%<-std=c++2a%> or %<-std=gnu++2a%>",
11118 declspecs
->gnu_thread_keyword_p
11119 ? "__thread" : "thread_local");
11121 error_at (declspecs
->locations
[ds_concept
],
11122 "structured binding declaration cannot be %qs", "concept");
11123 switch (storage_class
)
11128 error_at (loc
, "structured binding declaration cannot be %qs",
11132 if (cxx_dialect
< cxx2a
)
11134 "structured binding declaration can be %qs only in "
11135 "%<-std=c++2a%> or %<-std=gnu++2a%>", "static");
11138 error_at (loc
, "structured binding declaration cannot be %qs",
11142 error_at (loc
, "structured binding declaration cannot be %qs",
11146 error_at (loc
, "structured binding declaration cannot be "
11150 gcc_unreachable ();
11152 if (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
11153 || TYPE_IDENTIFIER (type
) != auto_identifier
)
11155 if (type
!= error_mark_node
)
11157 error_at (loc
, "structured binding declaration cannot have "
11160 "type must be cv-qualified %<auto%> or reference to "
11161 "cv-qualified %<auto%>");
11163 type
= build_qualified_type (make_auto (), type_quals
);
11164 declspecs
->type
= type
;
11170 if (storage_class
!= sc_static
)
11172 storage_class
= sc_none
;
11173 declspecs
->storage_class
= sc_none
;
11177 /* Static anonymous unions are dealt with here. */
11178 if (staticp
&& decl_context
== TYPENAME
11180 && ANON_AGGR_TYPE_P (declspecs
->type
))
11181 decl_context
= FIELD
;
11183 /* Warn about storage classes that are invalid for certain
11184 kinds of declarations (parameters, typenames, etc.). */
11187 && storage_class
!= sc_extern
11188 && storage_class
!= sc_static
)
11191 error ("multiple storage classes in declaration of %qs", name
);
11194 if (decl_context
!= NORMAL
11195 && ((storage_class
!= sc_none
11196 && storage_class
!= sc_mutable
)
11199 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
11200 && (storage_class
== sc_register
11201 || storage_class
== sc_auto
))
11203 else if (typedef_p
)
11205 else if (decl_context
== FIELD
11206 /* C++ allows static class elements. */
11207 && storage_class
== sc_static
)
11208 /* C++ also allows inlines and signed and unsigned elements,
11209 but in those cases we don't come in here. */
11214 = min_location (declspecs
->locations
[ds_thread
],
11215 declspecs
->locations
[ds_storage_class
]);
11216 if (decl_context
== FIELD
)
11217 error_at (loc
, "storage class specified for %qs", name
);
11218 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
11219 error_at (loc
, "storage class specified for parameter %qs", name
);
11221 error_at (loc
, "storage class specified for typename");
11222 if (storage_class
== sc_register
11223 || storage_class
== sc_auto
11224 || storage_class
== sc_extern
11226 storage_class
= sc_none
;
11229 else if (storage_class
== sc_extern
&& funcdef_flag
11230 && ! toplevel_bindings_p ())
11231 error ("nested function %qs declared %<extern%>", name
);
11232 else if (toplevel_bindings_p ())
11234 if (storage_class
== sc_auto
)
11235 error ("top-level declaration of %qs specifies %<auto%>", name
);
11238 && storage_class
!= sc_extern
11239 && storage_class
!= sc_static
)
11241 if (declspecs
->gnu_thread_keyword_p
)
11242 pedwarn (declspecs
->locations
[ds_thread
],
11243 0, "function-scope %qs implicitly auto and "
11244 "declared %<__thread%>", name
);
11246 /* When thread_local is applied to a variable of block scope the
11247 storage-class-specifier static is implied if it does not appear
11249 storage_class
= declspecs
->storage_class
= sc_static
;
11253 if (storage_class
&& friendp
)
11255 error_at (min_location (declspecs
->locations
[ds_thread
],
11256 declspecs
->locations
[ds_storage_class
]),
11257 "storage class specifiers invalid in friend function "
11259 storage_class
= sc_none
;
11263 if (!id_declarator
)
11264 unqualified_id
= NULL_TREE
;
11267 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
11268 switch (TREE_CODE (unqualified_id
))
11271 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
11272 if (TYPE_P (unqualified_id
))
11273 unqualified_id
= constructor_name (unqualified_id
);
11276 case IDENTIFIER_NODE
:
11277 case TEMPLATE_ID_EXPR
:
11281 gcc_unreachable ();
11285 if (declspecs
->std_attributes
)
11287 location_t attr_loc
= declspecs
->locations
[ds_std_attribute
];
11288 if (warning_at (attr_loc
, OPT_Wattributes
, "attribute ignored"))
11289 inform (attr_loc
, "an attribute that appertains to a type-specifier "
11293 /* Determine the type of the entity declared by recurring on the
11295 for (; declarator
; declarator
= declarator
->declarator
)
11297 const cp_declarator
*inner_declarator
;
11300 if (type
== error_mark_node
)
11301 return error_mark_node
;
11303 attrs
= declarator
->attributes
;
11309 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
11310 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
11311 if (declarator
->kind
== cdk_function
)
11312 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
11313 if (declarator
->kind
== cdk_array
)
11314 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
11315 returned_attrs
= decl_attributes (&type
,
11316 chainon (returned_attrs
, attrs
),
11320 inner_declarator
= declarator
->declarator
;
11322 /* We don't want to warn in parameter context because we don't
11323 yet know if the parse will succeed, and this might turn out
11324 to be a constructor call. */
11325 if (decl_context
!= PARM
11326 && decl_context
!= TYPENAME
11328 && declarator
->parenthesized
!= UNKNOWN_LOCATION
11329 /* If the type is class-like and the inner name used a
11330 global namespace qualifier, we need the parens.
11331 Unfortunately all we can tell is whether a qualified name
11332 was used or not. */
11333 && !(inner_declarator
11334 && inner_declarator
->kind
== cdk_id
11335 && inner_declarator
->u
.id
.qualifying_scope
11336 && (MAYBE_CLASS_TYPE_P (type
)
11337 || TREE_CODE (type
) == ENUMERAL_TYPE
)))
11338 warning_at (declarator
->parenthesized
, OPT_Wparentheses
,
11339 "unnecessary parentheses in declaration of %qs", name
);
11340 if (declarator
->kind
== cdk_id
|| declarator
->kind
== cdk_decomp
)
11343 switch (declarator
->kind
)
11346 type
= create_array_type_for_decl (dname
, type
,
11347 declarator
->u
.array
.bounds
,
11348 declarator
->id_loc
);
11349 if (!valid_array_size_p (input_location
, type
, dname
))
11350 type
= error_mark_node
;
11352 if (declarator
->std_attributes
)
11355 The optional attribute-specifier-seq appertains to the
11357 returned_attrs
= chainon (returned_attrs
,
11358 declarator
->std_attributes
);
11366 /* Declaring a function type. */
11368 input_location
= declspecs
->locations
[ds_type_spec
];
11369 abstract_virtuals_error (ACU_RETURN
, type
);
11370 input_location
= saved_loc
;
11372 /* Pick up type qualifiers which should be applied to `this'. */
11373 memfn_quals
= declarator
->u
.function
.qualifiers
;
11374 /* Pick up virt-specifiers. */
11375 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
11376 /* And ref-qualifier, too */
11377 rqual
= declarator
->u
.function
.ref_qualifier
;
11378 /* And tx-qualifier. */
11379 tree tx_qual
= declarator
->u
.function
.tx_qualifier
;
11380 /* Pick up the exception specifications. */
11381 raises
= declarator
->u
.function
.exception_specification
;
11382 /* If the exception-specification is ill-formed, let's pretend
11383 there wasn't one. */
11384 if (raises
== error_mark_node
)
11385 raises
= NULL_TREE
;
11388 error_at (location_of (reqs
), "requires-clause on return type");
11389 reqs
= declarator
->u
.function
.requires_clause
;
11391 /* Say it's a definition only for the CALL_EXPR
11392 closest to the identifier. */
11393 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
11395 /* Handle a late-specified return type. */
11396 tree late_return_type
= declarator
->u
.function
.late_return_type
;
11398 /* This is the case e.g. for
11399 using T = auto () -> int. */
11400 || inner_declarator
== NULL
)
11402 if (tree auto_node
= type_uses_auto (type
))
11404 if (!late_return_type
)
11406 if (current_class_type
11407 && LAMBDA_TYPE_P (current_class_type
))
11408 /* OK for C++11 lambdas. */;
11409 else if (cxx_dialect
< cxx14
)
11411 error_at (typespec_loc
, "%qs function uses "
11412 "%<auto%> type specifier without "
11413 "trailing return type", name
);
11414 inform (typespec_loc
,
11415 "deduced return type only available "
11416 "with %<-std=c++14%> or %<-std=gnu++14%>");
11420 error_at (typespec_loc
, "virtual function "
11421 "cannot have deduced return type");
11425 else if (!is_auto (type
) && sfk
!= sfk_conversion
)
11427 error_at (typespec_loc
, "%qs function with trailing "
11428 "return type has %qT as its type rather "
11429 "than plain %<auto%>", name
, type
);
11430 return error_mark_node
;
11432 else if (is_auto (type
) && AUTO_IS_DECLTYPE (type
))
11435 error_at (typespec_loc
,
11436 "%qs function with trailing return type "
11437 "has %<decltype(auto)%> as its type "
11438 "rather than plain %<auto%>", name
);
11440 error_at (typespec_loc
,
11441 "invalid use of %<decltype(auto)%>");
11442 return error_mark_node
;
11444 tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
);
11446 if (tree late_auto
= type_uses_auto (late_return_type
))
11447 tmpl
= CLASS_PLACEHOLDER_TEMPLATE (late_auto
);
11448 if (tmpl
&& funcdecl_p
)
11450 if (!dguide_name_p (unqualified_id
))
11452 error_at (declarator
->id_loc
, "deduced class "
11453 "type %qD in function return type",
11455 inform (DECL_SOURCE_LOCATION (tmpl
),
11456 "%qD declared here", tmpl
);
11457 return error_mark_node
;
11459 else if (!late_return_type
)
11461 error_at (declarator
->id_loc
, "deduction guide "
11462 "for %qT must have trailing return "
11463 "type", TREE_TYPE (tmpl
));
11464 inform (DECL_SOURCE_LOCATION (tmpl
),
11465 "%qD declared here", tmpl
);
11466 return error_mark_node
;
11468 else if (CLASS_TYPE_P (late_return_type
)
11469 && CLASSTYPE_TEMPLATE_INFO (late_return_type
)
11470 && (CLASSTYPE_TI_TEMPLATE (late_return_type
)
11474 error ("trailing return type %qT of deduction guide "
11475 "is not a specialization of %qT",
11476 late_return_type
, TREE_TYPE (tmpl
));
11479 else if (late_return_type
11480 && sfk
!= sfk_conversion
)
11482 if (cxx_dialect
< cxx11
)
11483 /* Not using maybe_warn_cpp0x because this should
11484 always be an error. */
11485 error_at (typespec_loc
,
11486 "trailing return type only available "
11487 "with %<-std=c++11%> or %<-std=gnu++11%>");
11489 error_at (typespec_loc
, "%qs function with trailing "
11490 "return type not declared with %<auto%> "
11491 "type specifier", name
);
11492 return error_mark_node
;
11495 type
= splice_late_return_type (type
, late_return_type
);
11496 if (type
== error_mark_node
)
11497 return error_mark_node
;
11499 if (late_return_type
)
11501 late_return_type_p
= true;
11502 type_quals
= cp_type_quals (type
);
11505 if (type_quals
!= TYPE_UNQUALIFIED
)
11507 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
11508 warning_at (typespec_loc
, OPT_Wignored_qualifiers
, "type "
11509 "qualifiers ignored on function return type");
11510 /* We now know that the TYPE_QUALS don't apply to the
11511 decl, but to its return type. */
11512 type_quals
= TYPE_UNQUALIFIED
;
11515 /* Error about some types functions can't return. */
11517 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11519 error_at (typespec_loc
, "%qs declared as function returning "
11520 "a function", name
);
11521 return error_mark_node
;
11523 if (TREE_CODE (type
) == ARRAY_TYPE
)
11525 error_at (typespec_loc
, "%qs declared as function returning "
11527 return error_mark_node
;
11530 if (ctype
== NULL_TREE
11531 && decl_context
== FIELD
11534 ctype
= current_class_type
;
11536 if (ctype
&& (sfk
== sfk_constructor
11537 || sfk
== sfk_destructor
))
11539 /* We are within a class's scope. If our declarator name
11540 is the same as the class name, and we are defining
11541 a function, then it is a constructor/destructor, and
11542 therefore returns a void type. */
11544 /* ISO C++ 12.4/2. A destructor may not be declared
11545 const or volatile. A destructor may not be static.
11546 A destructor may not be declared with ref-qualifier.
11548 ISO C++ 12.1. A constructor may not be declared
11549 const or volatile. A constructor may not be
11550 virtual. A constructor may not be static.
11551 A constructor may not be declared with ref-qualifier. */
11553 error ((flags
== DTOR_FLAG
)
11554 ? G_("destructor cannot be static member function")
11555 : G_("constructor cannot be static member function"));
11558 error ((flags
== DTOR_FLAG
)
11559 ? G_("destructors may not be cv-qualified")
11560 : G_("constructors may not be cv-qualified"));
11561 memfn_quals
= TYPE_UNQUALIFIED
;
11566 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
11567 error ((flags
== DTOR_FLAG
)
11568 ? G_("destructors may not be ref-qualified")
11569 : G_("constructors may not be ref-qualified"));
11570 rqual
= REF_QUAL_NONE
;
11573 if (decl_context
== FIELD
11574 && !member_function_or_else (ctype
,
11575 current_class_type
,
11577 return error_mark_node
;
11579 if (flags
!= DTOR_FLAG
)
11581 /* It's a constructor. */
11582 if (explicitp
== 1)
11586 permerror (declspecs
->locations
[ds_virtual
],
11587 "constructors cannot be declared %<virtual%>");
11590 if (decl_context
== FIELD
11591 && sfk
!= sfk_constructor
)
11592 return error_mark_node
;
11594 if (decl_context
== FIELD
)
11601 /* Cannot be both friend and virtual. */
11602 gcc_rich_location
richloc (declspecs
->locations
[ds_virtual
]);
11603 richloc
.add_range (declspecs
->locations
[ds_friend
]);
11604 error_at (&richloc
, "virtual functions cannot be friends");
11607 if (decl_context
== NORMAL
)
11608 error ("friend declaration not in class definition");
11609 if (current_function_decl
&& funcdef_flag
)
11611 error ("cannot define friend function %qs in a local "
11612 "class definition", name
);
11616 else if (ctype
&& sfk
== sfk_conversion
)
11618 if (explicitp
== 1)
11620 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
11623 if (late_return_type_p
)
11624 error ("a conversion function cannot have a trailing return type");
11626 else if (sfk
== sfk_deduction_guide
)
11628 if (explicitp
== 1)
11632 tree pushed_scope
= NULL_TREE
;
11634 && decl_context
!= FIELD
11635 && inner_declarator
->u
.id
.qualifying_scope
11636 && CLASS_TYPE_P (inner_declarator
->u
.id
.qualifying_scope
))
11638 = push_scope (inner_declarator
->u
.id
.qualifying_scope
);
11640 arg_types
= grokparms (declarator
->u
.function
.parameters
, &parms
);
11643 pop_scope (pushed_scope
);
11645 if (inner_declarator
11646 && inner_declarator
->kind
== cdk_id
11647 && inner_declarator
->u
.id
.sfk
== sfk_destructor
11648 && arg_types
!= void_list_node
)
11650 error ("destructors may not have parameters");
11651 arg_types
= void_list_node
;
11655 type
= build_function_type (type
, arg_types
);
11657 tree attrs
= declarator
->std_attributes
;
11660 tree att
= build_tree_list (tx_qual
, NULL_TREE
);
11661 /* transaction_safe applies to the type, but
11662 transaction_safe_dynamic applies to the function. */
11663 if (is_attribute_p ("transaction_safe", tx_qual
))
11664 attrs
= chainon (attrs
, att
);
11666 returned_attrs
= chainon (returned_attrs
, att
);
11671 The optional attribute-specifier-seq appertains to
11672 the function type. */
11673 decl_attributes (&type
, attrs
, 0);
11676 type
= build_exception_variant (type
, raises
);
11681 case cdk_reference
:
11683 /* Filter out pointers-to-references and references-to-references.
11684 We can get these if a TYPE_DECL is used. */
11686 if (TYPE_REF_P (type
))
11688 if (declarator
->kind
!= cdk_reference
)
11690 error ("cannot declare pointer to %q#T", type
);
11691 type
= TREE_TYPE (type
);
11694 /* In C++0x, we allow reference to reference declarations
11695 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
11696 and template type arguments [14.3.1/4 temp.arg.type]. The
11697 check for direct reference to reference declarations, which
11698 are still forbidden, occurs below. Reasoning behind the change
11699 can be found in DR106, DR540, and the rvalue reference
11701 else if (cxx_dialect
== cxx98
)
11703 error ("cannot declare reference to %q#T", type
);
11704 type
= TREE_TYPE (type
);
11707 else if (VOID_TYPE_P (type
))
11709 if (declarator
->kind
== cdk_reference
)
11710 error ("cannot declare reference to %q#T", type
);
11711 else if (declarator
->kind
== cdk_ptrmem
)
11712 error ("cannot declare pointer to %q#T member", type
);
11715 /* We now know that the TYPE_QUALS don't apply to the decl,
11716 but to the target of the pointer. */
11717 type_quals
= TYPE_UNQUALIFIED
;
11719 /* This code used to handle METHOD_TYPE, but I don't think it's
11720 possible to get it here anymore. */
11721 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
11722 if (declarator
->kind
== cdk_ptrmem
11723 && TREE_CODE (type
) == FUNCTION_TYPE
)
11725 memfn_quals
|= type_memfn_quals (type
);
11726 type
= build_memfn_type (type
,
11727 declarator
->u
.pointer
.class_type
,
11730 if (type
== error_mark_node
)
11731 return error_mark_node
;
11733 rqual
= REF_QUAL_NONE
;
11734 memfn_quals
= TYPE_UNQUALIFIED
;
11737 if (TREE_CODE (type
) == FUNCTION_TYPE
11738 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
11739 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
11740 error (declarator
->kind
== cdk_reference
11741 ? G_("cannot declare reference to qualified function type %qT")
11742 : G_("cannot declare pointer to qualified function type %qT"),
11745 /* When the pointed-to type involves components of variable size,
11746 care must be taken to ensure that the size evaluation code is
11747 emitted early enough to dominate all the possible later uses
11748 and late enough for the variables on which it depends to have
11751 This is expected to happen automatically when the pointed-to
11752 type has a name/declaration of it's own, but special attention
11753 is required if the type is anonymous.
11755 We handle the NORMAL and FIELD contexts here by inserting a
11756 dummy statement that just evaluates the size at a safe point
11757 and ensures it is not deferred until e.g. within a deeper
11758 conditional context (c++/43555).
11760 We expect nothing to be needed here for PARM or TYPENAME.
11761 Evaluating the size at this point for TYPENAME would
11762 actually be incorrect, as we might be in the middle of an
11763 expression with side effects on the pointed-to type size
11764 "arguments" prior to the pointer declaration point and the
11765 size evaluation could end up prior to the side effects. */
11767 if (!TYPE_NAME (type
)
11768 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
11769 && at_function_scope_p ()
11770 && variably_modified_type_p (type
, NULL_TREE
))
11772 TYPE_NAME (type
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
11774 add_decl_expr (TYPE_NAME (type
));
11777 if (declarator
->kind
== cdk_reference
)
11779 /* In C++0x, the type we are creating a reference to might be
11780 a typedef which is itself a reference type. In that case,
11781 we follow the reference collapsing rules in
11782 [7.1.3/8 dcl.typedef] to create the final reference type:
11784 "If a typedef TD names a type that is a reference to a type
11785 T, an attempt to create the type 'lvalue reference to cv TD'
11786 creates the type 'lvalue reference to T,' while an attempt
11787 to create the type "rvalue reference to cv TD' creates the
11790 if (VOID_TYPE_P (type
))
11791 /* We already gave an error. */;
11792 else if (TYPE_REF_P (type
))
11794 if (declarator
->u
.reference
.rvalue_ref
)
11795 /* Leave type alone. */;
11797 type
= cp_build_reference_type (TREE_TYPE (type
), false);
11800 type
= cp_build_reference_type
11801 (type
, declarator
->u
.reference
.rvalue_ref
);
11803 /* In C++0x, we need this check for direct reference to
11804 reference declarations, which are forbidden by
11805 [8.3.2/5 dcl.ref]. Reference to reference declarations
11806 are only allowed indirectly through typedefs and template
11807 type arguments. Example:
11809 void foo(int & &); // invalid ref-to-ref decl
11811 typedef int & int_ref;
11812 void foo(int_ref &); // valid ref-to-ref decl
11814 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
11815 error ("cannot declare reference to %q#T, which is not "
11816 "a typedef or a template type argument", type
);
11818 else if (TREE_CODE (type
) == METHOD_TYPE
)
11819 type
= build_ptrmemfunc_type (build_pointer_type (type
));
11820 else if (declarator
->kind
== cdk_ptrmem
)
11822 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
11823 != NAMESPACE_DECL
);
11824 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
11825 /* We will already have complained. */
11826 type
= error_mark_node
;
11828 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
11832 type
= build_pointer_type (type
);
11834 /* Process a list of type modifier keywords (such as
11835 const or volatile) that were given inside the `*' or `&'. */
11837 if (declarator
->u
.pointer
.qualifiers
)
11840 = cp_build_qualified_type (type
,
11841 declarator
->u
.pointer
.qualifiers
);
11842 type_quals
= cp_type_quals (type
);
11845 /* Apply C++11 attributes to the pointer, and not to the
11846 type pointed to. This is unlike what is done for GNU
11847 attributes above. It is to comply with [dcl.ptr]/1:
11849 [the optional attribute-specifier-seq (7.6.1) appertains
11850 to the pointer and not to the object pointed to]. */
11851 if (declarator
->std_attributes
)
11852 decl_attributes (&type
, declarator
->std_attributes
,
11862 gcc_unreachable ();
11866 id_loc
= declarator
? declarator
->id_loc
: input_location
;
11868 /* A `constexpr' specifier used in an object declaration declares
11869 the object as `const'. */
11870 if (constexpr_p
&& innermost_code
!= cdk_function
)
11872 /* DR1688 says that a `constexpr' specifier in combination with
11873 `volatile' is valid. */
11875 if (!TYPE_REF_P (type
))
11877 type_quals
|= TYPE_QUAL_CONST
;
11878 type
= cp_build_qualified_type (type
, type_quals
);
11882 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
11883 && !FUNC_OR_METHOD_TYPE_P (type
)
11884 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
11886 error ("template-id %qD used as a declarator",
11888 unqualified_id
= dname
;
11891 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
11892 qualified with a class-name, turn it into a METHOD_TYPE, unless
11893 we know that the function is static. We take advantage of this
11894 opportunity to do other processing that pertains to entities
11895 explicitly declared to be class members. Note that if DECLARATOR
11896 is non-NULL, we know it is a cdk_id declarator; otherwise, we
11897 would not have exited the loop above. */
11899 && declarator
->kind
== cdk_id
11900 && declarator
->u
.id
.qualifying_scope
11901 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
11903 ctype
= declarator
->u
.id
.qualifying_scope
;
11904 ctype
= TYPE_MAIN_VARIANT (ctype
);
11905 template_count
= num_template_headers_for_class (ctype
);
11907 if (ctype
== current_class_type
)
11911 permerror (declspecs
->locations
[ds_friend
],
11912 "member functions are implicitly "
11913 "friends of their class");
11917 permerror (id_loc
, "extra qualification %<%T::%> on member %qs",
11920 else if (/* If the qualifying type is already complete, then we
11921 can skip the following checks. */
11922 !COMPLETE_TYPE_P (ctype
)
11923 && (/* If the function is being defined, then
11924 qualifying type must certainly be complete. */
11926 /* A friend declaration of "T::f" is OK, even if
11927 "T" is a template parameter. But, if this
11928 function is not a friend, the qualifying type
11929 must be a class. */
11930 || (!friendp
&& !CLASS_TYPE_P (ctype
))
11931 /* For a declaration, the type need not be
11932 complete, if either it is dependent (since there
11933 is no meaningful definition of complete in that
11934 case) or the qualifying class is currently being
11936 || !(dependent_type_p (ctype
)
11937 || currently_open_class (ctype
)))
11938 /* Check that the qualifying type is complete. */
11939 && !complete_type_or_else (ctype
, NULL_TREE
))
11940 return error_mark_node
;
11941 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11943 if (current_class_type
11944 && (!friendp
|| funcdef_flag
|| initialized
))
11946 error_at (id_loc
, funcdef_flag
|| initialized
11947 ? G_("cannot define member function %<%T::%s%> "
11949 : G_("cannot declare member function %<%T::%s%> "
11951 ctype
, name
, current_class_type
);
11952 return error_mark_node
;
11955 else if (typedef_p
&& current_class_type
)
11957 error_at (id_loc
, "cannot declare member %<%T::%s%> within %qT",
11958 ctype
, name
, current_class_type
);
11959 return error_mark_node
;
11963 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
11964 ctype
= current_class_type
;
11966 /* Now TYPE has the actual type. */
11968 if (returned_attrs
)
11971 *attrlist
= chainon (returned_attrs
, *attrlist
);
11973 attrlist
= &returned_attrs
;
11977 && declarator
->kind
== cdk_id
11978 && declarator
->std_attributes
11979 && attrlist
!= NULL
)
11981 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
11982 a declarator-id appertains to the entity that is declared. */
11983 if (declarator
->std_attributes
!= error_mark_node
)
11984 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
11986 /* We should have already diagnosed the issue (c++/78344). */
11987 gcc_assert (seen_error ());
11990 /* Handle parameter packs. */
11991 if (parameter_pack_p
)
11993 if (decl_context
== PARM
)
11994 /* Turn the type into a pack expansion.*/
11995 type
= make_pack_expansion (type
);
11997 error ("non-parameter %qs cannot be a parameter pack", name
);
12000 if ((decl_context
== FIELD
|| decl_context
== PARM
)
12001 && !processing_template_decl
12002 && variably_modified_type_p (type
, NULL_TREE
))
12004 if (decl_context
== FIELD
)
12006 "data member may not have variably modified type %qT", type
);
12009 "parameter may not have variably modified type %qT", type
);
12010 type
= error_mark_node
;
12013 if (explicitp
== 1 || (explicitp
&& friendp
))
12015 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
12016 in the declaration of a constructor or conversion function within
12017 a class definition. */
12018 if (!current_class_type
)
12019 error_at (declspecs
->locations
[ds_explicit
],
12020 "%<explicit%> outside class declaration");
12022 error_at (declspecs
->locations
[ds_explicit
],
12023 "%<explicit%> in friend declaration");
12025 error_at (declspecs
->locations
[ds_explicit
],
12026 "only declarations of constructors and conversion operators "
12027 "can be %<explicit%>");
12031 if (storage_class
== sc_mutable
)
12033 location_t sloc
= declspecs
->locations
[ds_storage_class
];
12034 if (decl_context
!= FIELD
|| friendp
)
12036 error_at (sloc
, "non-member %qs cannot be declared %<mutable%>",
12038 storage_class
= sc_none
;
12040 else if (decl_context
== TYPENAME
|| typedef_p
)
12043 "non-object member %qs cannot be declared %<mutable%>",
12045 storage_class
= sc_none
;
12047 else if (FUNC_OR_METHOD_TYPE_P (type
))
12049 error_at (sloc
, "function %qs cannot be declared %<mutable%>",
12051 storage_class
= sc_none
;
12055 error_at (sloc
, "%<static%> %qs cannot be declared %<mutable%>",
12057 storage_class
= sc_none
;
12059 else if (type_quals
& TYPE_QUAL_CONST
)
12061 error_at (sloc
, "%<const%> %qs cannot be declared %<mutable%>",
12063 storage_class
= sc_none
;
12065 else if (TYPE_REF_P (type
))
12067 permerror (sloc
, "reference %qs cannot be declared %<mutable%>",
12069 storage_class
= sc_none
;
12073 /* If this is declaring a typedef name, return a TYPE_DECL. */
12074 if (typedef_p
&& decl_context
!= TYPENAME
)
12076 bool alias_p
= decl_spec_seq_has_spec_p (declspecs
, ds_alias
);
12079 /* This declaration:
12081 typedef void f(int) const;
12083 declares a function type which is not a member of any
12084 particular class, but which is cv-qualified; for
12085 example "f S::*" declares a pointer to a const-qualified
12086 member function of S. We record the cv-qualification in the
12088 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
12090 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
12092 /* We have now dealt with these qualifiers. */
12093 memfn_quals
= TYPE_UNQUALIFIED
;
12094 rqual
= REF_QUAL_NONE
;
12097 if (type_uses_auto (type
))
12100 error_at (declspecs
->locations
[ds_type_spec
],
12101 "%<auto%> not allowed in alias declaration");
12103 error_at (declspecs
->locations
[ds_type_spec
],
12104 "typedef declared %<auto%>");
12105 type
= error_mark_node
;
12109 error_at (location_of (reqs
), "requires-clause on typedef");
12111 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
)
12113 error_at (id_loc
, "typedef name may not be a nested-name-specifier");
12114 type
= error_mark_node
;
12117 if (decl_context
== FIELD
)
12118 decl
= build_lang_decl_loc (id_loc
, TYPE_DECL
, unqualified_id
, type
);
12120 decl
= build_decl (id_loc
, TYPE_DECL
, unqualified_id
, type
);
12122 if (decl_context
!= FIELD
)
12124 if (!current_function_decl
)
12125 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
12126 else if (DECL_MAYBE_IN_CHARGE_CDTOR_P (current_function_decl
))
12127 /* The TYPE_DECL is "abstract" because there will be
12128 clones of this constructor/destructor, and there will
12129 be copies of this TYPE_DECL generated in those
12130 clones. The decloning optimization (for space) may
12131 revert this subsequently if it determines that
12132 the clones should share a common implementation. */
12133 DECL_ABSTRACT_P (decl
) = true;
12135 else if (current_class_type
12136 && constructor_name_p (unqualified_id
, current_class_type
))
12137 permerror (id_loc
, "ISO C++ forbids nested type %qD with same name "
12138 "as enclosing class",
12141 /* If the user declares "typedef struct {...} foo" then the
12142 struct will have an anonymous name. Fill that name in now.
12143 Nothing can refer to it, so nothing needs know about the name
12145 if (type
!= error_mark_node
12147 && TYPE_NAME (type
)
12148 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12149 && TYPE_UNNAMED_P (type
)
12150 && declspecs
->type_definition_p
12151 && attributes_naming_typedef_ok (*attrlist
)
12152 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
12153 name_unnamed_type (type
, decl
);
12156 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
12157 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
12159 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
12160 memfn_quals
!= TYPE_UNQUALIFIED
,
12161 inlinep
, friendp
, raises
!= NULL_TREE
,
12162 declspecs
->locations
);
12165 /* Acknowledge that this was written:
12166 `using analias = atype;'. */
12167 TYPE_DECL_ALIAS_P (decl
) = 1;
12172 /* Detect the case of an array type of unspecified size
12173 which came, as such, direct from a typedef name.
12174 We must copy the type, so that the array's domain can be
12175 individually set by the object's initializer. */
12177 if (type
&& typedef_type
12178 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
12179 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
12180 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
12182 /* Detect where we're using a typedef of function type to declare a
12183 function. PARMS will not be set, so we must create it now. */
12185 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
12187 tree decls
= NULL_TREE
;
12190 for (args
= TYPE_ARG_TYPES (type
);
12191 args
&& args
!= void_list_node
;
12192 args
= TREE_CHAIN (args
))
12194 tree decl
= cp_build_parm_decl (NULL_TREE
, NULL_TREE
,
12195 TREE_VALUE (args
));
12197 DECL_CHAIN (decl
) = decls
;
12201 parms
= nreverse (decls
);
12203 if (decl_context
!= TYPENAME
)
12205 /* The qualifiers on the function type become the qualifiers on
12206 the non-static member function. */
12207 memfn_quals
|= type_memfn_quals (type
);
12208 rqual
= type_memfn_rqual (type
);
12209 type_quals
= TYPE_UNQUALIFIED
;
12213 /* If this is a type name (such as, in a cast or sizeof),
12214 compute the type and return it now. */
12216 if (decl_context
== TYPENAME
)
12218 /* Note that here we don't care about type_quals. */
12220 /* Special case: "friend class foo" looks like a TYPENAME context. */
12225 error ("%<inline%> specified for friend class declaration");
12231 /* Don't allow friend declaration without a class-key. */
12232 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
12233 permerror (input_location
, "template parameters cannot be friends");
12234 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
12235 permerror (input_location
, "friend declaration requires class-key, "
12236 "i.e. %<friend class %T::%D%>",
12237 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
12239 permerror (input_location
, "friend declaration requires class-key, "
12240 "i.e. %<friend %#T%>",
12244 /* Only try to do this stuff if we didn't already give up. */
12245 if (type
!= integer_type_node
)
12247 /* A friendly class? */
12248 if (current_class_type
)
12249 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
12250 /*complain=*/true);
12252 error ("trying to make class %qT a friend of global scope",
12255 type
= void_type_node
;
12258 else if (memfn_quals
|| rqual
)
12260 if (ctype
== NULL_TREE
12261 && TREE_CODE (type
) == METHOD_TYPE
)
12262 ctype
= TYPE_METHOD_BASETYPE (type
);
12265 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
12266 /* Core issue #547: need to allow this in template type args.
12267 Allow it in general in C++11 for alias-declarations. */
12268 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
12269 && TREE_CODE (type
) == FUNCTION_TYPE
)
12270 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
12272 error ("invalid qualifiers on non-member function type");
12276 error_at (location_of (reqs
), "requires-clause on type-id");
12280 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
12281 && decl_context
!= CATCHPARM
12282 && TREE_CODE (type
) != UNION_TYPE
12284 && innermost_code
!= cdk_decomp
)
12286 error ("abstract declarator %qT used as declaration", type
);
12287 return error_mark_node
;
12290 if (!FUNC_OR_METHOD_TYPE_P (type
))
12292 /* Only functions may be declared using an operator-function-id. */
12293 if (dname
&& IDENTIFIER_ANY_OP_P (dname
))
12295 error_at (id_loc
, "declaration of %qD as non-function", dname
);
12296 return error_mark_node
;
12300 error_at (location_of (reqs
),
12301 "requires-clause on declaration of non-function type %qT",
12305 /* We don't check parameter types here because we can emit a better
12306 error message later. */
12307 if (decl_context
!= PARM
)
12309 type
= check_var_type (unqualified_id
, type
);
12310 if (type
== error_mark_node
)
12311 return error_mark_node
;
12314 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
12315 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
12317 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
12319 if (ctype
|| in_namespace
)
12320 error ("cannot use %<::%> in parameter declaration");
12322 if (type_uses_auto (type
)
12323 && !(cxx_dialect
>= cxx17
&& template_parm_flag
))
12325 if (cxx_dialect
>= cxx14
)
12326 error ("%<auto%> parameter not permitted in this context");
12328 error ("parameter declared %<auto%>");
12329 type
= error_mark_node
;
12332 /* A parameter declared as an array of T is really a pointer to T.
12333 One declared as a function is really a pointer to a function.
12334 One declared as a member is really a pointer to member. */
12336 if (TREE_CODE (type
) == ARRAY_TYPE
)
12338 /* Transfer const-ness of array into that of type pointed to. */
12339 type
= build_pointer_type (TREE_TYPE (type
));
12340 type_quals
= TYPE_UNQUALIFIED
;
12341 array_parameter_p
= true;
12343 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
12344 type
= build_pointer_type (type
);
12347 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
12348 && !(unqualified_id
12349 && identifier_p (unqualified_id
)
12350 && IDENTIFIER_NEWDEL_OP_P (unqualified_id
)))
12352 cp_cv_quals real_quals
= memfn_quals
;
12353 if (cxx_dialect
< cxx14
&& constexpr_p
12354 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
12355 real_quals
|= TYPE_QUAL_CONST
;
12356 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
12360 tree decl
= NULL_TREE
;
12362 if (decl_context
== PARM
)
12364 decl
= cp_build_parm_decl (NULL_TREE
, unqualified_id
, type
);
12365 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
12367 bad_specifiers (decl
, BSP_PARM
, virtualp
,
12368 memfn_quals
!= TYPE_UNQUALIFIED
,
12369 inlinep
, friendp
, raises
!= NULL_TREE
,
12370 declspecs
->locations
);
12372 else if (decl_context
== FIELD
)
12374 if (!staticp
&& !friendp
&& TREE_CODE (type
) != METHOD_TYPE
)
12375 if (tree auto_node
= type_uses_auto (type
))
12377 location_t tloc
= declspecs
->locations
[ds_type_spec
];
12378 if (CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
12379 error_at (tloc
, "invalid use of template-name %qE without an "
12381 CLASS_PLACEHOLDER_TEMPLATE (auto_node
));
12383 error_at (tloc
, "non-static data member declared with "
12384 "placeholder %qT", auto_node
);
12385 type
= error_mark_node
;
12388 /* The C99 flexible array extension. */
12389 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
12390 && TYPE_DOMAIN (type
) == NULL_TREE
)
12393 && (TREE_CODE (ctype
) == UNION_TYPE
12394 || TREE_CODE (ctype
) == QUAL_UNION_TYPE
))
12396 error ("flexible array member in union");
12397 type
= error_mark_node
;
12401 /* Array is a flexible member. */
12402 if (in_system_header_at (input_location
))
12403 /* Do not warn on flexible array members in system
12404 headers because glibc uses them. */;
12406 pedwarn (id_loc
, OPT_Wpedantic
,
12407 "ISO C++ forbids flexible array member %qs", name
);
12409 pedwarn (input_location
, OPT_Wpedantic
,
12410 "ISO C++ forbids flexible array members");
12412 /* Flexible array member has a null domain. */
12413 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
12417 if (type
== error_mark_node
)
12419 /* Happens when declaring arrays of sizes which
12420 are error_mark_node, for example. */
12423 else if (in_namespace
&& !friendp
)
12425 /* Something like struct S { int N::j; }; */
12426 error ("invalid use of %<::%>");
12427 return error_mark_node
;
12429 else if (FUNC_OR_METHOD_TYPE_P (type
) && unqualified_id
)
12432 tree function_context
;
12436 /* This should never happen in pure C++ (the check
12437 could be an assert). It could happen in
12438 Objective-C++ if someone writes invalid code that
12439 uses a function declaration for an instance
12440 variable or property (instance variables and
12441 properties are parsed as FIELD_DECLs, but they are
12442 part of an Objective-C class, not a C++ class).
12443 That code is invalid and is caught by this
12447 error ("declaration of function %qD in invalid context",
12449 return error_mark_node
;
12452 /* ``A union may [ ... ] not [ have ] virtual functions.''
12454 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
12456 error_at (declspecs
->locations
[ds_virtual
],
12457 "function %qD declared %<virtual%> inside a union",
12459 return error_mark_node
;
12463 && identifier_p (unqualified_id
)
12464 && IDENTIFIER_NEWDEL_OP_P (unqualified_id
))
12466 error_at (declspecs
->locations
[ds_virtual
],
12467 "%qD cannot be declared %<virtual%>, since it "
12468 "is always static", unqualified_id
);
12473 /* Check that the name used for a destructor makes sense. */
12474 if (sfk
== sfk_destructor
)
12476 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
12480 gcc_assert (friendp
);
12481 error ("expected qualified name in friend declaration "
12482 "for destructor %qD", uqname
);
12483 return error_mark_node
;
12486 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
12488 error ("declaration of %qD as member of %qT",
12490 return error_mark_node
;
12494 error_at (declspecs
->locations
[ds_concept
],
12495 "a destructor cannot be %<concept%>");
12496 return error_mark_node
;
12500 error_at (declspecs
->locations
[ds_constexpr
],
12501 "a destructor cannot be %<constexpr%>");
12502 return error_mark_node
;
12505 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
12507 error ("expected qualified name in friend declaration "
12508 "for constructor %qD",
12509 id_declarator
->u
.id
.unqualified_name
);
12510 return error_mark_node
;
12512 if (sfk
== sfk_constructor
)
12515 error_at (declspecs
->locations
[ds_concept
],
12516 "a constructor cannot be %<concept%>");
12517 return error_mark_node
;
12521 error_at (declspecs
->locations
[ds_concept
],
12522 "a concept cannot be a member function");
12526 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
12528 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
12529 if (variable_template_p (tmpl
))
12531 error ("specialization of variable template %qD "
12532 "declared as function", tmpl
);
12533 inform (DECL_SOURCE_LOCATION (tmpl
),
12534 "variable template declared here");
12535 return error_mark_node
;
12539 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
12540 function_context
= (ctype
!= NULL_TREE
) ?
12541 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
12542 publicp
= (! friendp
|| ! staticp
)
12543 && function_context
== NULL_TREE
;
12545 decl
= grokfndecl (ctype
, type
,
12546 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
12547 ? unqualified_id
: dname
,
12552 virtualp
, flags
, memfn_quals
, rqual
, raises
,
12553 friendp
? -1 : 0, friendp
, publicp
,
12554 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
12555 initialized
== SD_DELETED
, sfk
,
12556 funcdef_flag
, late_return_type_p
,
12557 template_count
, in_namespace
,
12559 decl
= set_virt_specifiers (decl
, virt_specifiers
);
12560 if (decl
== NULL_TREE
)
12561 return error_mark_node
;
12563 /* This clobbers the attrs stored in `decl' from `attrlist'. */
12564 /* The decl and setting of decl_attr is also turned off. */
12565 decl
= build_decl_attribute_variant (decl
, decl_attr
);
12568 /* [class.conv.ctor]
12570 A constructor declared without the function-specifier
12571 explicit that can be called with a single parameter
12572 specifies a conversion from the type of its first
12573 parameter to the type of its class. Such a constructor
12574 is called a converting constructor. */
12575 if (explicitp
== 2)
12576 DECL_NONCONVERTING_P (decl
) = 1;
12578 if (declspecs
->explicit_specifier
)
12579 store_explicit_specifier (decl
, declspecs
->explicit_specifier
);
12581 else if (!staticp
&& !dependent_type_p (type
)
12582 && !COMPLETE_TYPE_P (complete_type (type
))
12583 && (!complete_or_array_type_p (type
)
12584 || initialized
== 0))
12586 if (TREE_CODE (type
) != ARRAY_TYPE
12587 || !COMPLETE_TYPE_P (TREE_TYPE (type
)))
12589 if (unqualified_id
)
12591 error_at (id_loc
, "field %qD has incomplete type %qT",
12592 unqualified_id
, type
);
12593 cxx_incomplete_type_inform (strip_array_types (type
));
12596 error ("name %qT has incomplete type", type
);
12598 type
= error_mark_node
;
12606 if (unqualified_id
)
12608 "%qE is neither function nor member function; "
12609 "cannot be declared friend", unqualified_id
);
12611 error ("unnamed field is neither function nor member "
12612 "function; cannot be declared friend");
12613 return error_mark_node
;
12620 /* Friends are treated specially. */
12621 if (ctype
== current_class_type
)
12622 ; /* We already issued a permerror. */
12623 else if (decl
&& DECL_NAME (decl
))
12625 if (template_class_depth (current_class_type
) == 0)
12627 decl
= check_explicit_specialization
12628 (unqualified_id
, decl
, template_count
,
12629 2 * funcdef_flag
+ 4);
12630 if (decl
== error_mark_node
)
12631 return error_mark_node
;
12634 decl
= do_friend (ctype
, unqualified_id
, decl
,
12640 return error_mark_node
;
12643 /* Structure field. It may not be a function, except for C++. */
12645 if (decl
== NULL_TREE
)
12649 /* C++ allows static class members. All other work
12650 for this is done by grokfield. */
12651 decl
= build_lang_decl_loc (id_loc
, VAR_DECL
,
12652 unqualified_id
, type
);
12653 set_linkage_for_static_data_member (decl
);
12655 error_at (declspecs
->locations
[ds_concept
],
12656 "static data member %qE declared %<concept%>",
12658 else if (constexpr_p
&& !initialized
)
12660 error_at (DECL_SOURCE_LOCATION (decl
),
12661 "%<constexpr%> static data member %qD must "
12662 "have an initializer", decl
);
12663 constexpr_p
= false;
12667 mark_inline_variable (decl
, declspecs
->locations
[ds_inline
]);
12669 if (!DECL_VAR_DECLARED_INLINE_P (decl
)
12670 && !(cxx_dialect
>= cxx17
&& constexpr_p
))
12671 /* Even if there is an in-class initialization, DECL
12672 is considered undefined until an out-of-class
12673 definition is provided, unless this is an inline
12675 DECL_EXTERNAL (decl
) = 1;
12679 CP_DECL_THREAD_LOCAL_P (decl
) = true;
12680 if (!processing_template_decl
)
12681 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
12682 if (declspecs
->gnu_thread_keyword_p
)
12683 SET_DECL_GNU_TLS_P (decl
);
12689 error_at (declspecs
->locations
[ds_concept
],
12690 "non-static data member %qE declared %<concept%>",
12692 else if (constexpr_p
)
12694 error_at (declspecs
->locations
[ds_constexpr
],
12695 "non-static data member %qE declared %<constexpr%>",
12697 constexpr_p
= false;
12699 decl
= build_decl (id_loc
, FIELD_DECL
, unqualified_id
, type
);
12700 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
12701 if (bitfield
&& !unqualified_id
)
12703 TREE_NO_WARNING (decl
) = 1;
12704 DECL_PADDING_P (decl
) = 1;
12707 if (storage_class
== sc_mutable
)
12709 DECL_MUTABLE_P (decl
) = 1;
12710 storage_class
= sc_none
;
12715 /* An attempt is being made to initialize a non-static
12716 member. This is new in C++11. */
12717 maybe_warn_cpp0x (CPP0X_NSDMI
);
12719 /* If this has been parsed with static storage class, but
12720 errors forced staticp to be cleared, ensure NSDMI is
12722 if (declspecs
->storage_class
== sc_static
)
12723 DECL_INITIAL (decl
) = error_mark_node
;
12727 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
12728 memfn_quals
!= TYPE_UNQUALIFIED
,
12729 staticp
? false : inlinep
, friendp
,
12730 raises
!= NULL_TREE
,
12731 declspecs
->locations
);
12734 else if (FUNC_OR_METHOD_TYPE_P (type
))
12736 tree original_name
;
12739 if (!unqualified_id
)
12740 return error_mark_node
;
12742 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
12743 original_name
= dname
;
12745 original_name
= unqualified_id
;
12746 // FIXME:gcc_assert (original_name == dname);
12748 if (storage_class
== sc_auto
)
12749 error ("storage class %<auto%> invalid for function %qs", name
);
12750 else if (storage_class
== sc_register
)
12751 error ("storage class %<register%> invalid for function %qs", name
);
12754 if (declspecs
->gnu_thread_keyword_p
)
12755 error_at (declspecs
->locations
[ds_thread
],
12756 "storage class %<__thread%> invalid for function %qs",
12759 error_at (declspecs
->locations
[ds_thread
],
12760 "storage class %<thread_local%> invalid for "
12761 "function %qs", name
);
12764 if (virt_specifiers
)
12765 error ("virt-specifiers in %qs not allowed outside a class "
12766 "definition", name
);
12767 /* Function declaration not at top level.
12768 Storage classes other than `extern' are not allowed
12769 and `extern' makes no difference. */
12770 if (! toplevel_bindings_p ()
12771 && (storage_class
== sc_static
12772 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
12775 if (storage_class
== sc_static
)
12776 pedwarn (declspecs
->locations
[ds_storage_class
], OPT_Wpedantic
,
12777 "%<static%> specifier invalid for function %qs "
12778 "declared out of global scope", name
);
12780 pedwarn (declspecs
->locations
[ds_inline
], OPT_Wpedantic
,
12781 "%<inline%> specifier invalid for function %qs "
12782 "declared out of global scope", name
);
12785 if (ctype
== NULL_TREE
)
12789 error ("virtual non-class function %qs", name
);
12792 else if (sfk
== sfk_constructor
12793 || sfk
== sfk_destructor
)
12795 error (funcdef_flag
12796 ? G_("%qs defined in a non-class scope")
12797 : G_("%qs declared in a non-class scope"), name
);
12802 /* Record whether the function is public. */
12803 publicp
= (ctype
!= NULL_TREE
12804 || storage_class
!= sc_static
);
12806 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
12808 reqs
, virtualp
, flags
, memfn_quals
, rqual
, raises
,
12811 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
12812 initialized
== SD_DELETED
,
12815 late_return_type_p
,
12816 template_count
, in_namespace
, attrlist
,
12818 if (decl
== NULL_TREE
)
12819 return error_mark_node
;
12821 if (explicitp
== 2)
12822 DECL_NONCONVERTING_P (decl
) = 1;
12825 int invalid_static
= 0;
12827 /* Don't allow a static member function in a class, and forbid
12828 declaring main to be static. */
12829 if (TREE_CODE (type
) == METHOD_TYPE
)
12831 permerror (input_location
, "cannot declare member function %qD to have "
12832 "static linkage", decl
);
12833 invalid_static
= 1;
12835 else if (current_function_decl
)
12837 /* 7.1.1: There can be no static function declarations within a
12839 error_at (declspecs
->locations
[ds_storage_class
],
12840 "cannot declare static function inside another function");
12841 invalid_static
= 1;
12844 if (invalid_static
)
12847 storage_class
= sc_none
;
12853 /* It's a variable. */
12855 /* An uninitialized decl with `extern' is a reference. */
12856 decl
= grokvardecl (type
, dname
, unqualified_id
,
12863 ctype
? ctype
: in_namespace
,
12865 if (decl
== NULL_TREE
)
12866 return error_mark_node
;
12868 bad_specifiers (decl
, BSP_VAR
, virtualp
,
12869 memfn_quals
!= TYPE_UNQUALIFIED
,
12870 inlinep
, friendp
, raises
!= NULL_TREE
,
12871 declspecs
->locations
);
12875 DECL_CONTEXT (decl
) = ctype
;
12878 permerror (declspecs
->locations
[ds_storage_class
],
12879 "%<static%> may not be used when defining "
12880 "(as opposed to declaring) a static data member");
12882 storage_class
= sc_none
;
12884 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
12886 error ("static member %qD declared %<register%>", decl
);
12887 storage_class
= sc_none
;
12889 if (storage_class
== sc_extern
&& pedantic
)
12891 pedwarn (input_location
, OPT_Wpedantic
,
12892 "cannot explicitly declare member %q#D to have "
12893 "extern linkage", decl
);
12894 storage_class
= sc_none
;
12897 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
12899 error_at (DECL_SOURCE_LOCATION (decl
),
12900 "declaration of %<constexpr%> variable %qD "
12901 "is not a definition", decl
);
12902 constexpr_p
= false;
12906 mark_inline_variable (decl
, declspecs
->locations
[ds_inline
]);
12907 if (innermost_code
== cdk_decomp
)
12909 gcc_assert (declarator
&& declarator
->kind
== cdk_decomp
);
12910 DECL_SOURCE_LOCATION (decl
) = id_loc
;
12911 DECL_ARTIFICIAL (decl
) = 1;
12912 fit_decomposition_lang_decl (decl
, NULL_TREE
);
12916 if (VAR_P (decl
) && !initialized
)
12917 if (tree auto_node
= type_uses_auto (type
))
12918 if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
12920 location_t loc
= declspecs
->locations
[ds_type_spec
];
12921 error_at (loc
, "declaration of %q#D has no initializer", decl
);
12922 TREE_TYPE (decl
) = error_mark_node
;
12925 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
12927 if (toplevel_bindings_p ())
12929 /* It's common practice (and completely valid) to have a const
12930 be initialized and declared extern. */
12931 if (!(type_quals
& TYPE_QUAL_CONST
))
12932 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
12933 "%qs initialized and declared %<extern%>", name
);
12937 error_at (DECL_SOURCE_LOCATION (decl
),
12938 "%qs has both %<extern%> and initializer", name
);
12939 return error_mark_node
;
12943 /* Record `register' declaration for warnings on &
12944 and in case doing stupid register allocation. */
12946 if (storage_class
== sc_register
)
12948 DECL_REGISTER (decl
) = 1;
12949 /* Warn about register storage specifiers on PARM_DECLs. */
12950 if (TREE_CODE (decl
) == PARM_DECL
)
12952 if (cxx_dialect
>= cxx17
)
12953 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
12954 "ISO C++17 does not allow %<register%> storage "
12955 "class specifier");
12957 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
12958 "%<register%> storage class specifier used");
12961 else if (storage_class
== sc_extern
)
12962 DECL_THIS_EXTERN (decl
) = 1;
12963 else if (storage_class
== sc_static
)
12964 DECL_THIS_STATIC (decl
) = 1;
12966 /* Set constexpr flag on vars (functions got it in grokfndecl). */
12967 if (constexpr_p
&& VAR_P (decl
))
12968 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
12970 /* Record constancy and volatility on the DECL itself . There's
12971 no need to do this when processing a template; we'll do this
12972 for the instantiated declaration based on the type of DECL. */
12973 if (!processing_template_decl
)
12974 cp_apply_type_quals_to_decl (type_quals
, decl
);
12980 /* Subroutine of start_function. Ensure that each of the parameter
12981 types (as listed in PARMS) is complete, as is required for a
12982 function definition. */
12985 require_complete_types_for_parms (tree parms
)
12987 for (; parms
; parms
= DECL_CHAIN (parms
))
12989 if (dependent_type_p (TREE_TYPE (parms
)))
12991 if (!VOID_TYPE_P (TREE_TYPE (parms
))
12992 && complete_type_or_else (TREE_TYPE (parms
), parms
))
12994 relayout_decl (parms
);
12995 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
12997 maybe_warn_parm_abi (TREE_TYPE (parms
),
12998 DECL_SOURCE_LOCATION (parms
));
13001 /* grokparms or complete_type_or_else will have already issued
13003 TREE_TYPE (parms
) = error_mark_node
;
13007 /* Returns nonzero if T is a local variable. */
13010 local_variable_p (const_tree t
)
13013 /* A VAR_DECL with a context that is a _TYPE is a static data
13015 && !TYPE_P (CP_DECL_CONTEXT (t
))
13016 /* Any other non-local variable must be at namespace scope. */
13017 && !DECL_NAMESPACE_SCOPE_P (t
))
13018 || (TREE_CODE (t
) == PARM_DECL
))
13024 /* Like local_variable_p, but suitable for use as a tree-walking
13028 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
13031 if (local_variable_p (*tp
)
13032 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
13034 else if (TYPE_P (*tp
))
13035 *walk_subtrees
= 0;
13040 /* Check that ARG, which is a default-argument expression for a
13041 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
13042 something goes wrong. DECL may also be a _TYPE node, rather than a
13043 DECL, if there is no DECL available. */
13046 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
13051 if (TREE_CODE (arg
) == DEFAULT_ARG
)
13052 /* We get a DEFAULT_ARG when looking at an in-class declaration
13053 with a default argument. Ignore the argument for now; we'll
13054 deal with it after the class is complete. */
13063 decl_type
= TREE_TYPE (decl
);
13065 if (arg
== error_mark_node
13066 || decl
== error_mark_node
13067 || TREE_TYPE (arg
) == error_mark_node
13068 || decl_type
== error_mark_node
)
13069 /* Something already went wrong. There's no need to check
13071 return error_mark_node
;
13073 /* [dcl.fct.default]
13075 A default argument expression is implicitly converted to the
13077 ++cp_unevaluated_operand
;
13078 /* Avoid digest_init clobbering the initializer. */
13079 tree carg
= BRACE_ENCLOSED_INITIALIZER_P (arg
) ? unshare_expr (arg
): arg
;
13080 perform_implicit_conversion_flags (decl_type
, carg
, complain
,
13082 --cp_unevaluated_operand
;
13084 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
13086 if (TYPE_PTR_OR_PTRMEM_P (decl_type
)
13087 && null_ptr_cst_p (arg
))
13088 return nullptr_node
;
13090 /* [dcl.fct.default]
13092 Local variables shall not be used in default argument
13095 The keyword `this' shall not be used in a default argument of a
13096 member function. */
13097 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
13100 if (complain
& tf_warning_or_error
)
13102 if (DECL_NAME (var
) == this_identifier
)
13103 permerror (input_location
, "default argument %qE uses %qD",
13106 error ("default argument %qE uses local variable %qD", arg
, var
);
13108 return error_mark_node
;
13115 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
13118 type_is_deprecated (tree type
)
13120 enum tree_code code
;
13121 if (TREE_DEPRECATED (type
))
13123 if (TYPE_NAME (type
))
13125 if (TREE_DEPRECATED (TYPE_NAME (type
)))
13131 /* Do warn about using typedefs to a deprecated class. */
13132 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
13133 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
13135 code
= TREE_CODE (type
);
13137 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
13138 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
13139 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
13140 return type_is_deprecated (TREE_TYPE (type
));
13142 if (TYPE_PTRMEMFUNC_P (type
))
13143 return type_is_deprecated
13144 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
13149 /* Decode the list of parameter types for a function type.
13150 Given the list of things declared inside the parens,
13151 return a list of types.
13153 If this parameter does not end with an ellipsis, we append
13156 *PARMS is set to the chain of PARM_DECLs created. */
13159 grokparms (tree parmlist
, tree
*parms
)
13161 tree result
= NULL_TREE
;
13162 tree decls
= NULL_TREE
;
13166 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
13168 tree type
= NULL_TREE
;
13169 tree init
= TREE_PURPOSE (parm
);
13170 tree decl
= TREE_VALUE (parm
);
13172 if (parm
== void_list_node
)
13175 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
13178 type
= TREE_TYPE (decl
);
13179 if (VOID_TYPE_P (type
))
13181 if (same_type_p (type
, void_type_node
)
13183 && !DECL_NAME (decl
) && !result
13184 && TREE_CHAIN (parm
) == void_list_node
)
13185 /* DR 577: A parameter list consisting of a single
13186 unnamed parameter of non-dependent type 'void'. */
13188 else if (cv_qualified_p (type
))
13189 error_at (DECL_SOURCE_LOCATION (decl
),
13190 "invalid use of cv-qualified type %qT in "
13191 "parameter declaration", type
);
13193 error_at (DECL_SOURCE_LOCATION (decl
),
13194 "invalid use of type %<void%> in parameter "
13196 /* It's not a good idea to actually create parameters of
13197 type `void'; other parts of the compiler assume that a
13198 void type terminates the parameter list. */
13199 type
= error_mark_node
;
13200 TREE_TYPE (decl
) = error_mark_node
;
13203 if (type
!= error_mark_node
)
13205 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
13207 tree deptype
= type_is_deprecated (type
);
13209 cp_warn_deprecated_use (deptype
);
13212 /* Top-level qualifiers on the parameters are
13213 ignored for function types. */
13214 type
= cp_build_qualified_type (type
, 0);
13215 if (TREE_CODE (type
) == METHOD_TYPE
)
13217 error ("parameter %qD invalidly declared method type", decl
);
13218 type
= build_pointer_type (type
);
13219 TREE_TYPE (decl
) = type
;
13221 else if (abstract_virtuals_error (decl
, type
))
13222 any_error
= 1; /* Seems like a good idea. */
13223 else if (cxx_dialect
< cxx17
&& INDIRECT_TYPE_P (type
))
13225 /* Before C++17 DR 393:
13226 [dcl.fct]/6, parameter types cannot contain pointers
13227 (references) to arrays of unknown bound. */
13228 tree t
= TREE_TYPE (type
);
13229 int ptr
= TYPE_PTR_P (type
);
13233 if (TYPE_PTR_P (t
))
13235 else if (TREE_CODE (t
) != ARRAY_TYPE
)
13237 else if (!TYPE_DOMAIN (t
))
13241 if (TREE_CODE (t
) == ARRAY_TYPE
)
13242 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
13244 ? G_("parameter %qD includes pointer to array of "
13245 "unknown bound %qT")
13246 : G_("parameter %qD includes reference to array of "
13247 "unknown bound %qT"),
13253 else if (init
&& !processing_template_decl
)
13254 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
13257 DECL_CHAIN (decl
) = decls
;
13259 result
= tree_cons (init
, type
, result
);
13261 decls
= nreverse (decls
);
13262 result
= nreverse (result
);
13264 result
= chainon (result
, void_list_node
);
13271 /* D is a constructor or overloaded `operator='.
13273 Let T be the class in which D is declared. Then, this function
13276 -1 if D's is an ill-formed constructor or copy assignment operator
13277 whose first parameter is of type `T'.
13278 0 if D is not a copy constructor or copy assignment
13280 1 if D is a copy constructor or copy assignment operator whose
13281 first parameter is a reference to non-const qualified T.
13282 2 if D is a copy constructor or copy assignment operator whose
13283 first parameter is a reference to const qualified T.
13285 This function can be used as a predicate. Positive values indicate
13286 a copy constructor and nonzero values indicate a copy assignment
13290 copy_fn_p (const_tree d
)
13296 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
13298 if (TREE_CODE (d
) == TEMPLATE_DECL
13299 || (DECL_TEMPLATE_INFO (d
)
13300 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
13301 /* Instantiations of template member functions are never copy
13302 functions. Note that member functions of templated classes are
13303 represented as template functions internally, and we must
13304 accept those as copy functions. */
13307 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
13311 arg_type
= TREE_VALUE (args
);
13312 if (arg_type
== error_mark_node
)
13315 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
13317 /* Pass by value copy assignment operator. */
13320 else if (TYPE_REF_P (arg_type
)
13321 && !TYPE_REF_IS_RVALUE (arg_type
)
13322 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
13324 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
13330 args
= TREE_CHAIN (args
);
13332 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
13333 /* There are more non-optional args. */
13339 /* D is a constructor or overloaded `operator='.
13341 Let T be the class in which D is declared. Then, this function
13342 returns true when D is a move constructor or move assignment
13343 operator, false otherwise. */
13346 move_fn_p (const_tree d
)
13348 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
13350 if (cxx_dialect
== cxx98
)
13351 /* There are no move constructors if we are in C++98 mode. */
13354 if (TREE_CODE (d
) == TEMPLATE_DECL
13355 || (DECL_TEMPLATE_INFO (d
)
13356 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
13357 /* Instantiations of template member functions are never move
13358 functions. Note that member functions of templated classes are
13359 represented as template functions internally, and we must
13360 accept those as move functions. */
13363 return move_signature_fn_p (d
);
13366 /* D is a constructor or overloaded `operator='.
13368 Then, this function returns true when D has the same signature as a move
13369 constructor or move assignment operator (because either it is such a
13370 ctor/op= or it is a template specialization with the same signature),
13371 false otherwise. */
13374 move_signature_fn_p (const_tree d
)
13378 bool result
= false;
13380 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
13384 arg_type
= TREE_VALUE (args
);
13385 if (arg_type
== error_mark_node
)
13388 if (TYPE_REF_P (arg_type
)
13389 && TYPE_REF_IS_RVALUE (arg_type
)
13390 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
13394 args
= TREE_CHAIN (args
);
13396 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
13397 /* There are more non-optional args. */
13403 /* Remember any special properties of member function DECL. */
13406 grok_special_member_properties (tree decl
)
13410 if (TREE_CODE (decl
) == USING_DECL
13411 || !DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
13414 class_type
= DECL_CONTEXT (decl
);
13415 if (IDENTIFIER_CTOR_P (DECL_NAME (decl
)))
13417 int ctor
= copy_fn_p (decl
);
13419 if (!DECL_ARTIFICIAL (decl
))
13420 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
13426 A non-template constructor for class X is a copy
13427 constructor if its first parameter is of type X&, const
13428 X&, volatile X& or const volatile X&, and either there
13429 are no other parameters or else all other parameters have
13430 default arguments. */
13431 TYPE_HAS_COPY_CTOR (class_type
) = 1;
13432 if (user_provided_p (decl
))
13433 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
13435 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
13437 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
13438 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
13439 else if (move_fn_p (decl
) && user_provided_p (decl
))
13440 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
13441 else if (is_list_ctor (decl
))
13442 TYPE_HAS_LIST_CTOR (class_type
) = 1;
13444 if (DECL_DECLARED_CONSTEXPR_P (decl
)
13445 && !ctor
&& !move_fn_p (decl
))
13446 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
13448 else if (DECL_NAME (decl
) == assign_op_identifier
)
13452 A non-template assignment operator for class X is a copy
13453 assignment operator if its parameter is of type X, X&, const
13454 X&, volatile X& or const volatile X&. */
13456 int assop
= copy_fn_p (decl
);
13460 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
13461 if (user_provided_p (decl
))
13462 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
13464 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
13466 else if (move_fn_p (decl
) && user_provided_p (decl
))
13467 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
13469 else if (IDENTIFIER_CONV_OP_P (DECL_NAME (decl
)))
13470 TYPE_HAS_CONVERSION (class_type
) = true;
13472 /* Destructors are handled in check_methods. */
13475 /* Check a constructor DECL has the correct form. Complains
13476 if the class has a constructor of the form X(X). */
13479 grok_ctor_properties (const_tree ctype
, const_tree decl
)
13481 int ctor_parm
= copy_fn_p (decl
);
13487 A declaration of a constructor for a class X is ill-formed if
13488 its first parameter is of type (optionally cv-qualified) X
13489 and either there are no other parameters or else all other
13490 parameters have default arguments.
13492 We *don't* complain about member template instantiations that
13493 have this form, though; they can occur as we try to decide
13494 what constructor to use during overload resolution. Since
13495 overload resolution will never prefer such a constructor to
13496 the non-template copy constructor (which is either explicitly
13497 or implicitly defined), there's no need to worry about their
13498 existence. Theoretically, they should never even be
13499 instantiated, but that's hard to forestall. */
13500 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
13508 /* DECL is a declaration for an overloaded or conversion operator. If
13509 COMPLAIN is true, errors are issued for invalid declarations. */
13512 grok_op_properties (tree decl
, bool complain
)
13514 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
13515 bool methodp
= TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
;
13516 tree name
= DECL_NAME (decl
);
13517 location_t loc
= DECL_SOURCE_LOCATION (decl
);
13519 tree class_type
= DECL_CONTEXT (decl
);
13520 if (class_type
&& !CLASS_TYPE_P (class_type
))
13521 class_type
= NULL_TREE
;
13523 tree_code operator_code
;
13525 if (IDENTIFIER_CONV_OP_P (name
))
13527 /* Conversion operators are TYPE_EXPR for the purposes of this
13529 operator_code
= TYPE_EXPR
;
13530 op_flags
= OVL_OP_FLAG_UNARY
;
13534 const ovl_op_info_t
*ovl_op
= IDENTIFIER_OVL_OP_INFO (name
);
13536 operator_code
= ovl_op
->tree_code
;
13537 op_flags
= ovl_op
->flags
;
13538 gcc_checking_assert (operator_code
!= ERROR_MARK
);
13539 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op
->ovl_op_code
;
13542 if (op_flags
& OVL_OP_FLAG_ALLOC
)
13544 /* operator new and operator delete are quite special. */
13548 case OVL_OP_FLAG_ALLOC
:
13549 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
13552 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_DELETE
:
13553 TYPE_GETS_DELETE (class_type
) |= 1;
13556 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_VEC
:
13557 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
13560 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_DELETE
| OVL_OP_FLAG_VEC
:
13561 TYPE_GETS_DELETE (class_type
) |= 2;
13565 gcc_unreachable ();
13568 /* [basic.std.dynamic.allocation]/1:
13570 A program is ill-formed if an allocation function is declared
13571 in a namespace scope other than global scope or declared
13572 static in global scope.
13574 The same also holds true for deallocation functions. */
13575 if (DECL_NAMESPACE_SCOPE_P (decl
))
13577 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
13579 error_at (loc
, "%qD may not be declared within a namespace",
13584 if (!TREE_PUBLIC (decl
))
13586 error_at (loc
, "%qD may not be declared as static", decl
);
13591 if (op_flags
& OVL_OP_FLAG_DELETE
)
13592 coerce_delete_type (decl
, loc
);
13595 DECL_IS_OPERATOR_NEW (decl
) = 1;
13596 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
), loc
);
13602 /* An operator function must either be a non-static member function
13603 or have at least one parameter of a class, a reference to a class,
13604 an enumeration, or a reference to an enumeration. 13.4.0.6 */
13605 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
13607 if (operator_code
== TYPE_EXPR
13608 || operator_code
== CALL_EXPR
13609 || operator_code
== COMPONENT_REF
13610 || operator_code
== ARRAY_REF
13611 || operator_code
== NOP_EXPR
)
13613 error_at (loc
, "%qD must be a nonstatic member function", decl
);
13617 if (DECL_STATIC_FUNCTION_P (decl
))
13619 error_at (loc
, "%qD must be either a non-static member "
13620 "function or a non-member function", decl
);
13624 for (tree arg
= argtypes
; ; arg
= TREE_CHAIN (arg
))
13626 if (!arg
|| arg
== void_list_node
)
13629 error_at(loc
, "%qD must have an argument of class or "
13630 "enumerated type", decl
);
13634 tree type
= non_reference (TREE_VALUE (arg
));
13635 if (type
== error_mark_node
)
13638 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
13639 because these checks are performed even on template
13641 if (MAYBE_CLASS_TYPE_P (type
)
13642 || TREE_CODE (type
) == ENUMERAL_TYPE
)
13647 if (operator_code
== CALL_EXPR
)
13648 /* There are no further restrictions on the arguments to an overloaded
13652 if (operator_code
== COND_EXPR
)
13655 error_at (loc
, "ISO C++ prohibits overloading %<operator ?:%>");
13659 /* Count the number of arguments and check for ellipsis. */
13661 for (tree arg
= argtypes
; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
13666 error_at (loc
, "%qD must not have variable number of arguments",
13673 /* Verify correct number of arguments. */
13676 case OVL_OP_FLAG_AMBIARY
:
13679 /* We have a unary instance of an ambi-ary op. Remap to the
13681 unsigned alt
= ovl_op_alternate
[ovl_op_mapping
[operator_code
]];
13682 const ovl_op_info_t
*ovl_op
= &ovl_op_info
[false][alt
];
13683 gcc_checking_assert (ovl_op
->flags
== OVL_OP_FLAG_UNARY
);
13684 operator_code
= ovl_op
->tree_code
;
13685 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op
->ovl_op_code
;
13687 else if (arity
!= 2)
13689 /* This was an ambiguous operator but is invalid. */
13692 ? G_("%qD must have either zero or one argument")
13693 : G_("%qD must have either one or two arguments"), decl
);
13696 else if ((operator_code
== POSTINCREMENT_EXPR
13697 || operator_code
== POSTDECREMENT_EXPR
)
13698 && ! processing_template_decl
13699 /* x++ and x--'s second argument must be an int. */
13700 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)),
13701 integer_type_node
))
13705 ? G_("postfix %qD must have %<int%> as its argument")
13706 : G_("postfix %qD must have %<int%> as its second argument"),
13712 case OVL_OP_FLAG_UNARY
:
13717 ? G_("%qD must have no arguments")
13718 : G_("%qD must have exactly one argument"), decl
);
13723 case OVL_OP_FLAG_BINARY
:
13728 ? G_("%qD must have exactly one argument")
13729 : G_("%qD must have exactly two arguments"), decl
);
13735 gcc_unreachable ();
13738 /* There can be no default arguments. */
13739 for (tree arg
= argtypes
; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
13740 if (TREE_PURPOSE (arg
))
13742 TREE_PURPOSE (arg
) = NULL_TREE
;
13743 error_at (loc
, "%qD cannot have default arguments", decl
);
13747 /* At this point the declaration is well-formed. It may not be
13748 sensible though. */
13750 /* Check member function warnings only on the in-class declaration.
13751 There's no point warning on an out-of-class definition. */
13752 if (class_type
&& class_type
!= current_class_type
)
13755 /* Warn about conversion operators that will never be used. */
13756 if (IDENTIFIER_CONV_OP_P (name
)
13757 && ! DECL_TEMPLATE_INFO (decl
)
13758 && warn_class_conversion
)
13760 tree t
= TREE_TYPE (name
);
13761 int ref
= TYPE_REF_P (t
);
13764 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
13766 if (VOID_TYPE_P (t
))
13767 warning_at (loc
, OPT_Wclass_conversion
, "converting %qT to %<void%> "
13768 "will never use a type conversion operator", class_type
);
13769 else if (class_type
)
13771 if (same_type_ignoring_top_level_qualifiers_p (t
, class_type
))
13772 warning_at (loc
, OPT_Wclass_conversion
,
13774 ? G_("converting %qT to a reference to the same type "
13775 "will never use a type conversion operator")
13776 : G_("converting %qT to the same type "
13777 "will never use a type conversion operator"),
13779 /* Don't force t to be complete here. */
13780 else if (MAYBE_CLASS_TYPE_P (t
)
13781 && COMPLETE_TYPE_P (t
)
13782 && DERIVED_FROM_P (t
, class_type
))
13783 warning_at (loc
, OPT_Wclass_conversion
,
13785 ? G_("converting %qT to a reference to a base class "
13786 "%qT will never use a type conversion operator")
13787 : G_("converting %qT to a base class %qT "
13788 "will never use a type conversion operator"),
13796 /* Effective C++ rules below. */
13798 /* More Effective C++ rule 7. */
13799 if (operator_code
== TRUTH_ANDIF_EXPR
13800 || operator_code
== TRUTH_ORIF_EXPR
13801 || operator_code
== COMPOUND_EXPR
)
13802 warning_at (loc
, OPT_Weffc__
,
13803 "user-defined %qD always evaluates both arguments", decl
);
13805 /* More Effective C++ rule 6. */
13806 if (operator_code
== POSTINCREMENT_EXPR
13807 || operator_code
== POSTDECREMENT_EXPR
13808 || operator_code
== PREINCREMENT_EXPR
13809 || operator_code
== PREDECREMENT_EXPR
)
13811 tree arg
= TREE_VALUE (argtypes
);
13812 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
13813 if (methodp
|| TYPE_REF_P (arg
))
13814 arg
= TREE_TYPE (arg
);
13815 arg
= TYPE_MAIN_VARIANT (arg
);
13817 if (operator_code
== PREINCREMENT_EXPR
13818 || operator_code
== PREDECREMENT_EXPR
)
13820 if (!TYPE_REF_P (ret
)
13821 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)), arg
))
13822 warning_at (loc
, OPT_Weffc__
, "prefix %qD should return %qT", decl
,
13823 build_reference_type (arg
));
13827 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
13828 warning_at (loc
, OPT_Weffc__
,
13829 "postfix %qD should return %qT", decl
, arg
);
13833 /* Effective C++ rule 23. */
13834 if (!DECL_ASSIGNMENT_OPERATOR_P (decl
)
13835 && (operator_code
== PLUS_EXPR
13836 || operator_code
== MINUS_EXPR
13837 || operator_code
== TRUNC_DIV_EXPR
13838 || operator_code
== MULT_EXPR
13839 || operator_code
== TRUNC_MOD_EXPR
)
13840 && TYPE_REF_P (TREE_TYPE (TREE_TYPE (decl
))))
13841 warning_at (loc
, OPT_Weffc__
, "%qD should return by value", decl
);
13846 /* Return a string giving the keyword associate with CODE. */
13848 static const char *
13849 tag_name (enum tag_types code
)
13861 case typename_type
:
13864 gcc_unreachable ();
13868 /* Name lookup in an elaborated-type-specifier (after the keyword
13869 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
13870 elaborated-type-specifier is invalid, issue a diagnostic and return
13871 error_mark_node; otherwise, return the *_TYPE to which it referred.
13872 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
13875 check_elaborated_type_specifier (enum tag_types tag_code
,
13877 bool allow_template_p
)
13883 struct S { struct S *p; };
13885 name lookup will find the TYPE_DECL for the implicit "S::S"
13886 typedef. Adjust for that here. */
13887 if (DECL_SELF_REFERENCE_P (decl
))
13888 decl
= TYPE_NAME (TREE_TYPE (decl
));
13890 type
= TREE_TYPE (decl
);
13892 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
13893 is false for this case as well. */
13894 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
13896 error ("using template type parameter %qT after %qs",
13897 type
, tag_name (tag_code
));
13898 return error_mark_node
;
13900 /* Accept template template parameters. */
13901 else if (allow_template_p
13902 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
13903 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
13907 If the identifier resolves to a typedef-name or the
13908 simple-template-id resolves to an alias template
13909 specialization, the elaborated-type-specifier is ill-formed.
13911 In other words, the only legitimate declaration to use in the
13912 elaborated type specifier is the implicit typedef created when
13913 the type is declared. */
13914 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
13915 && !DECL_SELF_REFERENCE_P (decl
)
13916 && tag_code
!= typename_type
)
13918 if (alias_template_specialization_p (type
))
13919 error ("using alias template specialization %qT after %qs",
13920 type
, tag_name (tag_code
));
13922 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
13923 inform (DECL_SOURCE_LOCATION (decl
),
13924 "%qD has a previous declaration here", decl
);
13925 return error_mark_node
;
13927 else if (TREE_CODE (type
) != RECORD_TYPE
13928 && TREE_CODE (type
) != UNION_TYPE
13929 && tag_code
!= enum_type
13930 && tag_code
!= typename_type
)
13932 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
13933 inform (location_of (type
), "%qT has a previous declaration here", type
);
13934 return error_mark_node
;
13936 else if (TREE_CODE (type
) != ENUMERAL_TYPE
13937 && tag_code
== enum_type
)
13939 error ("%qT referred to as enum", type
);
13940 inform (location_of (type
), "%qT has a previous declaration here", type
);
13941 return error_mark_node
;
13943 else if (!allow_template_p
13944 && TREE_CODE (type
) == RECORD_TYPE
13945 && CLASSTYPE_IS_TEMPLATE (type
))
13947 /* If a class template appears as elaborated type specifier
13948 without a template header such as:
13950 template <class T> class C {};
13951 void f(class C); // No template header here
13953 then the required template argument is missing. */
13954 error ("template argument required for %<%s %T%>",
13955 tag_name (tag_code
),
13956 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
13957 return error_mark_node
;
13963 /* Lookup NAME in elaborate type specifier in scope according to
13964 SCOPE and issue diagnostics if necessary.
13965 Return *_TYPE node upon success, NULL_TREE when the NAME is not
13966 found, and ERROR_MARK_NODE for type error. */
13969 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
13970 tag_scope scope
, bool template_header_p
)
13974 if (scope
== ts_global
)
13976 /* First try ordinary name lookup, ignoring hidden class name
13977 injected via friend declaration. */
13978 decl
= lookup_name_prefer_type (name
, 2);
13979 decl
= strip_using_decl (decl
);
13980 /* If that fails, the name will be placed in the smallest
13981 non-class, non-function-prototype scope according to 3.3.1/5.
13982 We may already have a hidden name declared as friend in this
13983 scope. So lookup again but not ignoring hidden names.
13984 If we find one, that name will be made visible rather than
13985 creating a new tag. */
13987 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
13990 decl
= lookup_type_scope (name
, scope
);
13993 && (DECL_CLASS_TEMPLATE_P (decl
)
13994 /* If scope is ts_current we're defining a class, so ignore a
13995 template template parameter. */
13996 || (scope
!= ts_current
13997 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
13998 decl
= DECL_TEMPLATE_RESULT (decl
);
14000 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
14002 /* Look for invalid nested type:
14006 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
14008 error ("%qD has the same name as the class in which it is "
14011 return error_mark_node
;
14014 /* Two cases we need to consider when deciding if a class
14015 template is allowed as an elaborated type specifier:
14016 1. It is a self reference to its own class.
14017 2. It comes with a template header.
14021 template <class T> class C {
14022 class C *c1; // DECL_SELF_REFERENCE_P is true
14025 template <class U> class C; // template_header_p is true
14026 template <class T> class C<T>::D {
14027 class C *c2; // DECL_SELF_REFERENCE_P is true
14030 t
= check_elaborated_type_specifier (tag_code
,
14033 | DECL_SELF_REFERENCE_P (decl
));
14034 if (template_header_p
&& t
&& CLASS_TYPE_P (t
)
14035 && (!CLASSTYPE_TEMPLATE_INFO (t
)
14036 || (!PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))))
14038 error ("%qT is not a template", t
);
14039 inform (location_of (t
), "previous declaration here");
14040 if (TYPE_CLASS_SCOPE_P (t
)
14041 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (t
)))
14042 inform (input_location
,
14043 "perhaps you want to explicitly add %<%T::%>",
14045 t
= error_mark_node
;
14050 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
14052 error ("reference to %qD is ambiguous", name
);
14053 print_candidates (decl
);
14054 return error_mark_node
;
14060 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
14061 Define the tag as a forward-reference if it is not defined.
14063 If a declaration is given, process it here, and report an error if
14064 multiple declarations are not identical.
14066 SCOPE is TS_CURRENT when this is also a definition. Only look in
14067 the current frame for the name (since C++ allows new names in any
14068 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
14069 declaration. Only look beginning from the current scope outward up
14070 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
14072 TEMPLATE_HEADER_P is true when this declaration is preceded by
14073 a set of template parameters. */
14076 xref_tag_1 (enum tag_types tag_code
, tree name
,
14077 tag_scope scope
, bool template_header_p
)
14079 enum tree_code code
;
14080 tree context
= NULL_TREE
;
14082 gcc_assert (identifier_p (name
));
14088 code
= RECORD_TYPE
;
14094 code
= ENUMERAL_TYPE
;
14097 gcc_unreachable ();
14100 /* In case of anonymous name, xref_tag is only called to
14101 make type node and push name. Name lookup is not required. */
14102 tree t
= NULL_TREE
;
14103 if (scope
!= ts_lambda
&& !IDENTIFIER_ANON_P (name
))
14104 t
= lookup_and_check_tag (tag_code
, name
, scope
, template_header_p
);
14106 if (t
== error_mark_node
)
14107 return error_mark_node
;
14109 if (scope
!= ts_current
&& t
&& current_class_type
14110 && template_class_depth (current_class_type
)
14111 && template_header_p
)
14113 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
14116 /* Since SCOPE is not TS_CURRENT, we are not looking at a
14117 definition of this tag. Since, in addition, we are currently
14118 processing a (member) template declaration of a template
14119 class, we must be very careful; consider:
14121 template <class X> struct S1
14123 template <class U> struct S2
14125 template <class V> friend struct S1;
14128 Here, the S2::S1 declaration should not be confused with the
14129 outer declaration. In particular, the inner version should
14130 have a template parameter of level 2, not level 1.
14132 On the other hand, when presented with:
14134 template <class T> struct S1
14136 template <class U> struct S2 {};
14137 template <class U> friend struct S2;
14140 the friend must find S1::S2 eventually. We accomplish this
14141 by making sure that the new type we create to represent this
14142 declaration has the right TYPE_CONTEXT. */
14143 context
= TYPE_CONTEXT (t
);
14149 /* If no such tag is yet defined, create a forward-reference node
14150 and record it as the "definition".
14151 When a real declaration of this type is found,
14152 the forward-reference will be altered into a real type. */
14153 if (code
== ENUMERAL_TYPE
)
14155 error ("use of enum %q#D without previous declaration", name
);
14156 return error_mark_node
;
14160 t
= make_class_type (code
);
14161 TYPE_CONTEXT (t
) = context
;
14162 if (scope
== ts_lambda
)
14164 /* Mark it as a lambda type. */
14165 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
14166 /* And push it into current scope. */
14167 scope
= ts_current
;
14169 t
= pushtag (name
, t
, scope
);
14174 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
14176 /* Check that we aren't trying to overload a class with different
14178 tree constr
= NULL_TREE
;
14179 if (current_template_parms
)
14181 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
14182 constr
= build_constraints (reqs
, NULL_TREE
);
14184 if (!redeclare_class_template (t
, current_template_parms
, constr
))
14185 return error_mark_node
;
14187 else if (!processing_template_decl
14188 && CLASS_TYPE_P (t
)
14189 && CLASSTYPE_IS_TEMPLATE (t
))
14191 error ("redeclaration of %qT as a non-template", t
);
14192 inform (location_of (t
), "previous declaration %qD", t
);
14193 return error_mark_node
;
14196 if (scope
!= ts_within_enclosing_non_class
&& TYPE_HIDDEN_P (t
))
14198 /* This is no longer an invisible friend. Make it
14200 tree decl
= TYPE_NAME (t
);
14202 DECL_ANTICIPATED (decl
) = false;
14203 DECL_FRIEND_P (decl
) = false;
14205 if (TYPE_TEMPLATE_INFO (t
))
14207 tree tmpl
= TYPE_TI_TEMPLATE (t
);
14208 DECL_ANTICIPATED (tmpl
) = false;
14209 DECL_FRIEND_P (tmpl
) = false;
14217 /* Wrapper for xref_tag_1. */
14220 xref_tag (enum tag_types tag_code
, tree name
,
14221 tag_scope scope
, bool template_header_p
)
14225 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
14226 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
14227 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
14233 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
14235 enum tag_types tag_kind
;
14237 if (TREE_CODE (old
) == RECORD_TYPE
)
14238 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
14240 tag_kind
= union_type
;
14242 if (id
== NULL_TREE
)
14243 id
= TYPE_IDENTIFIER (old
);
14245 return xref_tag (tag_kind
, id
, scope
, false);
14248 /* Create the binfo hierarchy for REF with (possibly NULL) base list
14249 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
14250 access_* node, and the TREE_VALUE is the type of the base-class.
14251 Non-NULL TREE_TYPE indicates virtual inheritance. */
14254 xref_basetypes (tree ref
, tree base_list
)
14257 tree binfo
, base_binfo
;
14258 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
14259 unsigned max_bases
= 0; /* Maximum direct bases. */
14260 unsigned max_dvbases
= 0; /* Maximum direct virtual bases. */
14262 tree default_access
;
14263 tree igo_prev
; /* Track Inheritance Graph Order. */
14265 if (ref
== error_mark_node
)
14268 /* The base of a derived class is private by default, all others are
14270 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
14271 && CLASSTYPE_DECLARED_CLASS (ref
)
14272 ? access_private_node
: access_public_node
);
14274 /* First, make sure that any templates in base-classes are
14275 instantiated. This ensures that if we call ourselves recursively
14276 we do not get confused about which classes are marked and which
14278 basep
= &base_list
;
14281 tree basetype
= TREE_VALUE (*basep
);
14283 /* The dependent_type_p call below should really be dependent_scope_p
14284 so that we give a hard error about using an incomplete type as a
14285 base, but we allow it with a pedwarn for backward
14287 if (processing_template_decl
14288 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
14289 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
14290 if (!dependent_type_p (basetype
)
14291 && !complete_type_or_else (basetype
, NULL
))
14292 /* An incomplete type. Remove it from the list. */
14293 *basep
= TREE_CHAIN (*basep
);
14297 if (TREE_TYPE (*basep
))
14299 if (CLASS_TYPE_P (basetype
))
14300 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
14301 basep
= &TREE_CHAIN (*basep
);
14304 max_vbases
+= max_dvbases
;
14306 TYPE_MARKED_P (ref
) = 1;
14308 /* The binfo slot should be empty, unless this is an (ill-formed)
14310 gcc_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
));
14312 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
14314 binfo
= make_tree_binfo (max_bases
);
14316 TYPE_BINFO (ref
) = binfo
;
14317 BINFO_OFFSET (binfo
) = size_zero_node
;
14318 BINFO_TYPE (binfo
) = ref
;
14320 /* Apply base-class info set up to the variants of this type. */
14321 fixup_type_variants (ref
);
14325 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
14326 /* A C++98 POD cannot have base classes. */
14327 CLASSTYPE_NON_LAYOUT_POD_P (ref
) = true;
14329 if (TREE_CODE (ref
) == UNION_TYPE
)
14331 error ("derived union %qT invalid", ref
);
14337 warning (OPT_Wmultiple_inheritance
,
14338 "%qT defined with multiple direct bases", ref
);
14342 /* An aggregate can't have virtual base classes. */
14343 CLASSTYPE_NON_AGGREGATE (ref
) = true;
14345 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
14348 warning (OPT_Wvirtual_inheritance
,
14349 "%qT defined with direct virtual base", ref
);
14352 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
14354 tree access
= TREE_PURPOSE (base_list
);
14355 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
14356 tree basetype
= TREE_VALUE (base_list
);
14358 if (access
== access_default_node
)
14359 access
= default_access
;
14361 /* Before C++17, an aggregate cannot have base classes. In C++17, an
14362 aggregate can't have virtual, private, or protected base classes. */
14363 if (cxx_dialect
< cxx17
14364 || access
!= access_public_node
14366 CLASSTYPE_NON_AGGREGATE (ref
) = true;
14368 if (PACK_EXPANSION_P (basetype
))
14369 basetype
= PACK_EXPANSION_PATTERN (basetype
);
14370 if (TREE_CODE (basetype
) == TYPE_DECL
)
14371 basetype
= TREE_TYPE (basetype
);
14372 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
14374 error ("base type %qT fails to be a struct or class type",
14379 base_binfo
= NULL_TREE
;
14380 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
14382 base_binfo
= TYPE_BINFO (basetype
);
14383 /* The original basetype could have been a typedef'd type. */
14384 basetype
= BINFO_TYPE (base_binfo
);
14386 /* Inherit flags from the base. */
14387 TYPE_HAS_NEW_OPERATOR (ref
)
14388 |= TYPE_HAS_NEW_OPERATOR (basetype
);
14389 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
14390 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
14391 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
14392 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
14393 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
14394 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
14395 CLASSTYPE_REPEATED_BASE_P (ref
)
14396 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
14399 /* We must do this test after we've seen through a typedef
14401 if (TYPE_MARKED_P (basetype
))
14403 if (basetype
== ref
)
14404 error ("recursive type %qT undefined", basetype
);
14406 error ("duplicate base type %qT invalid", basetype
);
14410 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
14411 /* Regenerate the pack expansion for the bases. */
14412 basetype
= make_pack_expansion (basetype
);
14414 TYPE_MARKED_P (basetype
) = 1;
14416 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
14417 &igo_prev
, via_virtual
);
14418 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
14419 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
14421 BINFO_BASE_APPEND (binfo
, base_binfo
);
14422 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
14426 /* Update max_vbases to reflect the reality that we are dropping
14427 this base: if it reaches zero we want to undo the vec_alloc
14428 above to avoid inconsistencies during error-recovery: eg, in
14429 build_special_member_call, CLASSTYPE_VBASECLASSES non null
14430 and vtt null (c++/27952). */
14433 if (CLASS_TYPE_P (basetype
))
14435 -= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
14438 if (CLASSTYPE_VBASECLASSES (ref
)
14439 && max_vbases
== 0)
14440 vec_free (CLASSTYPE_VBASECLASSES (ref
));
14442 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
14443 /* If we didn't get max_vbases vbases, we must have shared at
14444 least one of them, and are therefore diamond shaped. */
14445 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
14447 /* Unmark all the types. */
14448 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
14449 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
14450 TYPE_MARKED_P (ref
) = 0;
14452 /* Now see if we have a repeated base type. */
14453 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
14455 for (base_binfo
= binfo
; base_binfo
;
14456 base_binfo
= TREE_CHAIN (base_binfo
))
14458 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
14460 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
14463 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
14465 for (base_binfo
= binfo
; base_binfo
;
14466 base_binfo
= TREE_CHAIN (base_binfo
))
14467 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
14468 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
14475 /* Copies the enum-related properties from type SRC to type DST.
14476 Used with the underlying type of an enum and the enum itself. */
14478 copy_type_enum (tree dst
, tree src
)
14481 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
14483 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
14484 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
14485 TYPE_SIZE (t
) = TYPE_SIZE (src
);
14486 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
14487 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
14488 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
14489 unsigned valign
= TYPE_ALIGN (src
);
14490 if (TYPE_USER_ALIGN (t
))
14491 valign
= MAX (valign
, TYPE_ALIGN (t
));
14493 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
14494 SET_TYPE_ALIGN (t
, valign
);
14495 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
14499 /* Begin compiling the definition of an enumeration type.
14502 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
14504 UNDERLYING_TYPE is the type that will be used as the storage for
14505 the enumeration type. This should be NULL_TREE if no storage type
14508 ATTRIBUTES are any attributes specified after the enum-key.
14510 SCOPED_ENUM_P is true if this is a scoped enumeration type.
14512 if IS_NEW is not NULL, gets TRUE iff a new type is created.
14514 Returns the type object, as yet incomplete.
14515 Also records info about it so that build_enumerator
14516 may be used to declare the individual values as they are read. */
14519 start_enum (tree name
, tree enumtype
, tree underlying_type
,
14520 tree attributes
, bool scoped_enum_p
, bool *is_new
)
14522 tree prevtype
= NULL_TREE
;
14523 gcc_assert (identifier_p (name
));
14527 /* [C++0x dcl.enum]p5:
14529 If not explicitly specified, the underlying type of a scoped
14530 enumeration type is int. */
14531 if (!underlying_type
&& scoped_enum_p
)
14532 underlying_type
= integer_type_node
;
14534 if (underlying_type
)
14535 underlying_type
= cv_unqualified (underlying_type
);
14537 /* If this is the real definition for a previous forward reference,
14538 fill in the contents in the same object that used to be the
14539 forward reference. */
14541 enumtype
= lookup_and_check_tag (enum_type
, name
,
14542 /*tag_scope=*/ts_current
,
14543 /*template_header_p=*/false);
14545 /* In case of a template_decl, the only check that should be deferred
14546 to instantiation time is the comparison of underlying types. */
14547 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
14549 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
14551 error_at (input_location
, "scoped/unscoped mismatch "
14552 "in enum %q#T", enumtype
);
14553 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
14554 "previous definition here");
14555 enumtype
= error_mark_node
;
14557 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
14559 error_at (input_location
, "underlying type mismatch "
14560 "in enum %q#T", enumtype
);
14561 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
14562 "previous definition here");
14563 enumtype
= error_mark_node
;
14565 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
14566 && !same_type_p (underlying_type
,
14567 ENUM_UNDERLYING_TYPE (enumtype
)))
14569 error_at (input_location
, "different underlying type "
14570 "in enum %q#T", enumtype
);
14571 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
14572 "previous definition here");
14573 underlying_type
= NULL_TREE
;
14577 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
14578 || processing_template_decl
)
14580 /* In case of error, make a dummy enum to allow parsing to
14582 if (enumtype
== error_mark_node
)
14584 name
= make_anon_name ();
14585 enumtype
= NULL_TREE
;
14588 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
14589 of an opaque enum, or an opaque enum of an already defined
14590 enumeration (C++11).
14591 In any other case, it'll be NULL_TREE. */
14597 prevtype
= enumtype
;
14599 /* Do not push the decl more than once. */
14601 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
14603 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
14604 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
14606 /* std::byte aliases anything. */
14607 if (enumtype
!= error_mark_node
14608 && TYPE_CONTEXT (enumtype
) == std_node
14609 && !strcmp ("byte", TYPE_NAME_STRING (enumtype
)))
14610 TYPE_ALIAS_SET (enumtype
) = 0;
14613 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
14616 if (enumtype
== error_mark_node
)
14617 return error_mark_node
;
14619 /* The enum is considered opaque until the opening '{' of the
14620 enumerator list. */
14621 SET_OPAQUE_ENUM_P (enumtype
, true);
14622 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
14625 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
14627 cplus_decl_attributes (&enumtype
, attributes
, (int)ATTR_FLAG_TYPE_IN_PLACE
);
14629 if (underlying_type
)
14631 if (ENUM_UNDERLYING_TYPE (enumtype
))
14632 /* We already checked that it matches, don't change it to a different
14633 typedef variant. */;
14634 else if (CP_INTEGRAL_TYPE_P (underlying_type
))
14636 copy_type_enum (enumtype
, underlying_type
);
14637 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
14639 else if (dependent_type_p (underlying_type
))
14640 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
14642 error ("underlying type %qT of %qT must be an integral type",
14643 underlying_type
, enumtype
);
14646 /* If into a template class, the returned enum is always the first
14647 declaration (opaque or not) seen. This way all the references to
14648 this type will be to the same declaration. The following ones are used
14649 only to check for definition errors. */
14650 if (prevtype
&& processing_template_decl
)
14656 /* After processing and defining all the values of an enumeration type,
14657 install their decls in the enumeration type.
14658 ENUMTYPE is the type object. */
14661 finish_enum_value_list (tree enumtype
)
14664 tree underlying_type
;
14667 tree minnode
, maxnode
;
14670 bool fixed_underlying_type_p
14671 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
14673 /* We built up the VALUES in reverse order. */
14674 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
14676 /* For an enum defined in a template, just set the type of the values;
14677 all further processing is postponed until the template is
14678 instantiated. We need to set the type so that tsubst of a CONST_DECL
14680 if (processing_template_decl
)
14682 for (values
= TYPE_VALUES (enumtype
);
14684 values
= TREE_CHAIN (values
))
14685 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
14689 /* Determine the minimum and maximum values of the enumerators. */
14690 if (TYPE_VALUES (enumtype
))
14692 minnode
= maxnode
= NULL_TREE
;
14694 for (values
= TYPE_VALUES (enumtype
);
14696 values
= TREE_CHAIN (values
))
14698 decl
= TREE_VALUE (values
);
14700 /* [dcl.enum]: Following the closing brace of an enum-specifier,
14701 each enumerator has the type of its enumeration. Prior to the
14702 closing brace, the type of each enumerator is the type of its
14703 initializing value. */
14704 TREE_TYPE (decl
) = enumtype
;
14706 /* Update the minimum and maximum values, if appropriate. */
14707 value
= DECL_INITIAL (decl
);
14708 if (value
== error_mark_node
)
14709 value
= integer_zero_node
;
14710 /* Figure out what the minimum and maximum values of the
14711 enumerators are. */
14713 minnode
= maxnode
= value
;
14714 else if (tree_int_cst_lt (maxnode
, value
))
14716 else if (tree_int_cst_lt (value
, minnode
))
14723 If the enumerator-list is empty, the underlying type is as if
14724 the enumeration had a single enumerator with value 0. */
14725 minnode
= maxnode
= integer_zero_node
;
14727 if (!fixed_underlying_type_p
)
14729 /* Compute the number of bits require to represent all values of the
14730 enumeration. We must do this before the type of MINNODE and
14731 MAXNODE are transformed, since tree_int_cst_min_precision relies
14732 on the TREE_TYPE of the value it is passed. */
14733 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
14734 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
14735 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
14736 int precision
= MAX (lowprec
, highprec
);
14738 bool use_short_enum
;
14740 /* Determine the underlying type of the enumeration.
14744 The underlying type of an enumeration is an integral type that
14745 can represent all the enumerator values defined in the
14746 enumeration. It is implementation-defined which integral type is
14747 used as the underlying type for an enumeration except that the
14748 underlying type shall not be larger than int unless the value of
14749 an enumerator cannot fit in an int or unsigned int.
14751 We use "int" or an "unsigned int" as the underlying type, even if
14752 a smaller integral type would work, unless the user has
14753 explicitly requested that we use the smallest possible type. The
14754 user can request that for all enumerations with a command line
14755 flag, or for just one enumeration with an attribute. */
14757 use_short_enum
= flag_short_enums
14758 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
14760 /* If the precision of the type was specified with an attribute and it
14761 was too small, give an error. Otherwise, use it. */
14762 if (TYPE_PRECISION (enumtype
))
14764 if (precision
> TYPE_PRECISION (enumtype
))
14765 error ("specified mode too small for enumerated values");
14768 use_short_enum
= true;
14769 precision
= TYPE_PRECISION (enumtype
);
14773 for (itk
= (use_short_enum
? itk_char
: itk_int
);
14777 underlying_type
= integer_types
[itk
];
14778 if (underlying_type
!= NULL_TREE
14779 && TYPE_PRECISION (underlying_type
) >= precision
14780 && TYPE_SIGN (underlying_type
) == sgn
)
14783 if (itk
== itk_none
)
14787 IF no integral type can represent all the enumerator values, the
14788 enumeration is ill-formed. */
14789 error ("no integral type can represent all of the enumerator values "
14790 "for %qT", enumtype
);
14791 precision
= TYPE_PRECISION (long_long_integer_type_node
);
14792 underlying_type
= integer_types
[itk_unsigned_long_long
];
14797 The value of sizeof() applied to an enumeration type, an object
14798 of an enumeration type, or an enumerator, is the value of sizeof()
14799 applied to the underlying type. */
14800 copy_type_enum (enumtype
, underlying_type
);
14802 /* Compute the minimum and maximum values for the type.
14806 For an enumeration where emin is the smallest enumerator and emax
14807 is the largest, the values of the enumeration are the values of the
14808 underlying type in the range bmin to bmax, where bmin and bmax are,
14809 respectively, the smallest and largest values of the smallest bit-
14810 field that can store emin and emax. */
14812 /* The middle-end currently assumes that types with TYPE_PRECISION
14813 narrower than their underlying type are suitably zero or sign
14814 extended to fill their mode. Similarly, it assumes that the front
14815 end assures that a value of a particular type must be within
14816 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
14818 We used to set these fields based on bmin and bmax, but that led
14819 to invalid assumptions like optimizing away bounds checking. So
14820 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
14821 TYPE_MAX_VALUE to the values for the mode above and only restrict
14822 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
14823 ENUM_UNDERLYING_TYPE (enumtype
)
14824 = build_distinct_type_copy (underlying_type
);
14825 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
14826 set_min_and_max_values_for_integral_type
14827 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
14829 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
14830 if (flag_strict_enums
)
14831 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
14834 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
14836 /* Convert each of the enumerators to the type of the underlying
14837 type of the enumeration. */
14838 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
14840 location_t saved_location
;
14842 decl
= TREE_VALUE (values
);
14843 saved_location
= input_location
;
14844 input_location
= DECL_SOURCE_LOCATION (decl
);
14845 if (fixed_underlying_type_p
)
14846 /* If the enumeration type has a fixed underlying type, we
14847 already checked all of the enumerator values. */
14848 value
= DECL_INITIAL (decl
);
14850 value
= perform_implicit_conversion (underlying_type
,
14851 DECL_INITIAL (decl
),
14852 tf_warning_or_error
);
14853 input_location
= saved_location
;
14855 /* Do not clobber shared ints. */
14856 if (value
!= error_mark_node
)
14858 value
= copy_node (value
);
14860 TREE_TYPE (value
) = enumtype
;
14862 DECL_INITIAL (decl
) = value
;
14865 /* Fix up all variant types of this enum type. */
14866 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
14867 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
14869 if (at_class_scope_p ()
14870 && COMPLETE_TYPE_P (current_class_type
)
14871 && UNSCOPED_ENUM_P (enumtype
))
14873 insert_late_enum_def_bindings (current_class_type
, enumtype
);
14874 /* TYPE_FIELDS needs fixup. */
14875 fixup_type_variants (current_class_type
);
14878 /* Finish debugging output for this type. */
14879 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
14881 /* Each enumerator now has the type of its enumeration. Clear the cache
14882 so that this change in types doesn't confuse us later on. */
14883 clear_cv_and_fold_caches ();
14886 /* Finishes the enum type. This is called only the first time an
14887 enumeration is seen, be it opaque or odinary.
14888 ENUMTYPE is the type object. */
14891 finish_enum (tree enumtype
)
14893 if (processing_template_decl
)
14895 if (at_function_scope_p ())
14896 add_stmt (build_min (TAG_DEFN
, enumtype
));
14900 /* If this is a forward declaration, there should not be any variants,
14901 though we can get a variant in the middle of an enum-specifier with
14902 wacky code like 'enum E { e = sizeof(const E*) };' */
14903 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
14904 && (TYPE_VALUES (enumtype
)
14905 || !TYPE_NEXT_VARIANT (enumtype
)));
14908 /* Build and install a CONST_DECL for an enumeration constant of the
14909 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
14910 Apply ATTRIBUTES if available. LOC is the location of NAME.
14911 Assignment of sequential values by default is handled here. */
14914 build_enumerator (tree name
, tree value
, tree enumtype
, tree attributes
,
14921 /* scalar_constant_value will pull out this expression, so make sure
14922 it's folded as appropriate. */
14923 if (processing_template_decl
)
14924 value
= fold_non_dependent_expr (value
);
14926 /* If the VALUE was erroneous, pretend it wasn't there; that will
14927 result in the enum being assigned the next value in sequence. */
14928 if (value
== error_mark_node
)
14931 /* Remove no-op casts from the value. */
14933 STRIP_TYPE_NOPS (value
);
14935 if (! processing_template_decl
)
14937 /* Validate and default VALUE. */
14938 if (value
!= NULL_TREE
)
14940 if (!ENUM_UNDERLYING_TYPE (enumtype
))
14942 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
14947 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14948 (TREE_TYPE (value
)))
14949 value
= perform_implicit_conversion_flags
14950 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
14951 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
14953 if (value
== error_mark_node
)
14956 if (value
!= NULL_TREE
)
14958 if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14959 (TREE_TYPE (value
)))
14961 error ("enumerator value for %qD must have integral or "
14962 "unscoped enumeration type", name
);
14967 value
= cxx_constant_value (value
);
14969 if (TREE_CODE (value
) != INTEGER_CST
)
14971 error ("enumerator value for %qD is not an integer "
14979 /* Default based on previous value. */
14980 if (value
== NULL_TREE
)
14982 if (TYPE_VALUES (enumtype
))
14986 /* C++03 7.2/4: If no initializer is specified for the first
14987 enumerator, the type is an unspecified integral
14988 type. Otherwise the type is the same as the type of the
14989 initializing value of the preceding enumerator unless the
14990 incremented value is not representable in that type, in
14991 which case the type is an unspecified integral type
14992 sufficient to contain the incremented value. */
14993 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
14994 if (error_operand_p (prev_value
))
14995 value
= error_mark_node
;
14998 wi::overflow_type overflowed
;
14999 tree type
= TREE_TYPE (prev_value
);
15000 signop sgn
= TYPE_SIGN (type
);
15001 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
15005 bool pos
= !wi::neg_p (wi
, sgn
);
15006 if (!wi::fits_to_tree_p (wi
, type
))
15009 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
15011 type
= integer_types
[itk
];
15012 if (type
!= NULL_TREE
15013 && (pos
|| !TYPE_UNSIGNED (type
))
15014 && wi::fits_to_tree_p (wi
, type
))
15017 if (type
&& cxx_dialect
< cxx11
15018 && itk
> itk_unsigned_long
)
15019 pedwarn (input_location
, OPT_Wlong_long
,
15021 incremented enumerator value is too large for %<unsigned long%>") : G_("\
15022 incremented enumerator value is too large for %<long%>"));
15024 if (type
== NULL_TREE
)
15025 overflowed
= wi::OVF_UNKNOWN
;
15027 value
= wide_int_to_tree (type
, wi
);
15032 error ("overflow in enumeration values at %qD", name
);
15033 value
= error_mark_node
;
15038 value
= integer_zero_node
;
15041 /* Remove no-op casts from the value. */
15042 STRIP_TYPE_NOPS (value
);
15044 /* If the underlying type of the enum is fixed, check whether
15045 the enumerator values fits in the underlying type. If it
15046 does not fit, the program is ill-formed [C++0x dcl.enum]. */
15047 if (ENUM_UNDERLYING_TYPE (enumtype
)
15049 && TREE_CODE (value
) == INTEGER_CST
)
15051 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
15052 error ("enumerator value %qE is outside the range of underlying "
15053 "type %qT", value
, ENUM_UNDERLYING_TYPE (enumtype
));
15055 /* Convert the value to the appropriate type. */
15056 value
= fold_convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
15060 /* C++ associates enums with global, function, or class declarations. */
15061 context
= current_scope ();
15063 /* Build the actual enumeration constant. Note that the enumeration
15064 constants have the underlying type of the enum (if it is fixed)
15065 or the type of their initializer (if the underlying type of the
15066 enum is not fixed):
15070 If the underlying type is fixed, the type of each enumerator
15071 prior to the closing brace is the underlying type; if the
15072 initializing value of an enumerator cannot be represented by
15073 the underlying type, the program is ill-formed. If the
15074 underlying type is not fixed, the type of each enumerator is
15075 the type of its initializing value.
15077 If the underlying type is not fixed, it will be computed by
15078 finish_enum and we will reset the type of this enumerator. Of
15079 course, if we're processing a template, there may be no value. */
15080 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
15082 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
15084 DECL_CONTEXT (decl
) = enumtype
;
15085 TREE_CONSTANT (decl
) = 1;
15086 TREE_READONLY (decl
) = 1;
15087 DECL_INITIAL (decl
) = value
;
15090 cplus_decl_attributes (&decl
, attributes
, 0);
15092 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
15094 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
15095 on the TYPE_FIELDS list for `S'. (That's so that you can say
15096 things like `S::i' later.) */
15098 /* The enumerator may be getting declared outside of its enclosing
15101 class S { public: enum E : int; }; enum S::E : int { i = 7; };
15103 For which case we need to make sure that the access of `S::i'
15104 matches the access of `S::E'. */
15105 tree saved_cas
= current_access_specifier
;
15106 if (TREE_PRIVATE (TYPE_NAME (enumtype
)))
15107 current_access_specifier
= access_private_node
;
15108 else if (TREE_PROTECTED (TYPE_NAME (enumtype
)))
15109 current_access_specifier
= access_protected_node
;
15111 current_access_specifier
= access_public_node
;
15113 finish_member_declaration (decl
);
15115 current_access_specifier
= saved_cas
;
15120 /* Add this enumeration constant to the list for this type. */
15121 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
15124 /* Look for an enumerator with the given NAME within the enumeration
15125 type ENUMTYPE. This routine is used primarily for qualified name
15126 lookup into an enumerator in C++0x, e.g.,
15128 enum class Color { Red, Green, Blue };
15130 Color color = Color::Red;
15132 Returns the value corresponding to the enumerator, or
15133 NULL_TREE if no such enumerator was found. */
15135 lookup_enumerator (tree enumtype
, tree name
)
15138 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
15140 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
15141 return e
? TREE_VALUE (e
) : NULL_TREE
;
15145 /* We're defining DECL. Make sure that its type is OK. */
15148 check_function_type (tree decl
, tree current_function_parms
)
15150 tree fntype
= TREE_TYPE (decl
);
15151 tree return_type
= complete_type (TREE_TYPE (fntype
));
15153 /* In a function definition, arg types must be complete. */
15154 require_complete_types_for_parms (current_function_parms
);
15156 if (dependent_type_p (return_type
)
15157 || type_uses_auto (return_type
))
15159 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
15161 tree args
= TYPE_ARG_TYPES (fntype
);
15163 error ("return type %q#T is incomplete", return_type
);
15165 /* Make it return void instead. */
15166 if (TREE_CODE (fntype
) == METHOD_TYPE
)
15167 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
15169 TREE_CHAIN (args
));
15171 fntype
= build_function_type (void_type_node
, args
);
15172 fntype
= (cp_build_type_attribute_variant
15173 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
15174 fntype
= cxx_copy_lang_qualifiers (fntype
, TREE_TYPE (decl
));
15175 TREE_TYPE (decl
) = fntype
;
15179 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
15180 maybe_warn_parm_abi (TREE_TYPE (fntype
),
15181 DECL_SOURCE_LOCATION (decl
));
15185 /* True iff FN is an implicitly-defined default constructor. */
15188 implicit_default_ctor_p (tree fn
)
15190 return (DECL_CONSTRUCTOR_P (fn
)
15191 && !user_provided_p (fn
)
15192 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)));
15195 /* Clobber the contents of *this to let the back end know that the object
15196 storage is dead when we enter the constructor or leave the destructor. */
15199 build_clobber_this ()
15201 /* Clobbering an empty base is pointless, and harmful if its one byte
15202 TYPE_SIZE overlays real data. */
15203 if (is_empty_class (current_class_type
))
15206 /* If we have virtual bases, clobber the whole object, but only if we're in
15207 charge. If we don't have virtual bases, clobber the as-base type so we
15208 don't mess with tail padding. */
15209 bool vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
15211 tree ctype
= current_class_type
;
15213 ctype
= CLASSTYPE_AS_BASE (ctype
);
15215 tree clobber
= build_clobber (ctype
);
15217 tree thisref
= current_class_ref
;
15218 if (ctype
!= current_class_type
)
15220 thisref
= build_nop (build_reference_type (ctype
), current_class_ptr
);
15221 thisref
= convert_from_reference (thisref
);
15224 tree exprstmt
= build2 (MODIFY_EXPR
, void_type_node
, thisref
, clobber
);
15226 exprstmt
= build_if_in_charge (exprstmt
);
15231 /* Create the FUNCTION_DECL for a function definition.
15232 DECLSPECS and DECLARATOR are the parts of the declaration;
15233 they describe the function's name and the type it returns,
15234 but twisted together in a fashion that parallels the syntax of C.
15236 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
15237 DECLARATOR is really the DECL for the function we are about to
15238 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
15239 indicating that the function is an inline defined in-class.
15241 This function creates a binding context for the function body
15242 as well as setting up the FUNCTION_DECL in current_function_decl.
15244 For C++, we must first check whether that datum makes any sense.
15245 For example, "class A local_a(1,2);" means that variable local_a
15246 is an aggregate of type A, which should have a constructor
15247 applied to it with the argument list [1, 2].
15249 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
15250 or may be a BLOCK if the function has been defined previously
15251 in this translation unit. On exit, DECL_INITIAL (decl1) will be
15252 error_mark_node if the function has never been defined, or
15253 a BLOCK if the function has been defined somewhere. */
15256 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
15258 tree ctype
= NULL_TREE
;
15261 int doing_friend
= 0;
15262 cp_binding_level
*bl
;
15263 tree current_function_parms
;
15264 struct c_fileinfo
*finfo
15265 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
15266 bool honor_interface
;
15268 /* Sanity check. */
15269 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
15270 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
15272 fntype
= TREE_TYPE (decl1
);
15273 if (TREE_CODE (fntype
) == METHOD_TYPE
)
15274 ctype
= TYPE_METHOD_BASETYPE (fntype
);
15276 /* ISO C++ 11.4/5. A friend function defined in a class is in
15277 the (lexical) scope of the class in which it is defined. */
15278 if (!ctype
&& DECL_FRIEND_P (decl1
))
15280 ctype
= DECL_FRIEND_CONTEXT (decl1
);
15282 /* CTYPE could be null here if we're dealing with a template;
15283 for example, `inline friend float foo()' inside a template
15284 will have no CTYPE set. */
15285 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
15291 if (DECL_DECLARED_INLINE_P (decl1
)
15292 && lookup_attribute ("noinline", attrs
))
15293 warning_at (DECL_SOURCE_LOCATION (decl1
), 0,
15294 "inline function %qD given attribute %qs", decl1
, "noinline");
15296 /* Handle gnu_inline attribute. */
15297 if (GNU_INLINE_P (decl1
))
15299 DECL_EXTERNAL (decl1
) = 1;
15300 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
15301 DECL_INTERFACE_KNOWN (decl1
) = 1;
15302 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
15305 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
15306 /* This is a constructor, we must ensure that any default args
15307 introduced by this definition are propagated to the clones
15308 now. The clones are used directly in overload resolution. */
15309 adjust_clone_args (decl1
);
15311 /* Sometimes we don't notice that a function is a static member, and
15312 build a METHOD_TYPE for it. Fix that up now. */
15313 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
15314 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
15316 /* Set up current_class_type, and enter the scope of the class, if
15319 push_nested_class (ctype
);
15320 else if (DECL_STATIC_FUNCTION_P (decl1
))
15321 push_nested_class (DECL_CONTEXT (decl1
));
15323 /* Now that we have entered the scope of the class, we must restore
15324 the bindings for any template parameters surrounding DECL1, if it
15325 is an inline member template. (Order is important; consider the
15326 case where a template parameter has the same name as a field of
15327 the class.) It is not until after this point that
15328 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
15329 if (flags
& SF_INCLASS_INLINE
)
15330 maybe_begin_member_template_processing (decl1
);
15332 /* Effective C++ rule 15. */
15334 && DECL_ASSIGNMENT_OPERATOR_P (decl1
)
15335 && DECL_OVERLOADED_OPERATOR_IS (decl1
, NOP_EXPR
)
15336 && VOID_TYPE_P (TREE_TYPE (fntype
)))
15337 warning (OPT_Weffc__
,
15338 "%<operator=%> should return a reference to %<*this%>");
15340 /* Make the init_value nonzero so pushdecl knows this is not tentative.
15341 error_mark_node is replaced below (in poplevel) with the BLOCK. */
15342 if (!DECL_INITIAL (decl1
))
15343 DECL_INITIAL (decl1
) = error_mark_node
;
15345 /* This function exists in static storage.
15346 (This does not mean `static' in the C sense!) */
15347 TREE_STATIC (decl1
) = 1;
15349 /* We must call push_template_decl after current_class_type is set
15350 up. (If we are processing inline definitions after exiting a
15351 class scope, current_class_type will be NULL_TREE until set above
15352 by push_nested_class.) */
15353 if (processing_template_decl
)
15355 tree newdecl1
= push_template_decl (decl1
);
15356 if (newdecl1
== error_mark_node
)
15358 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
15359 pop_nested_class ();
15365 /* Make sure the parameter and return types are reasonable. When
15366 you declare a function, these types can be incomplete, but they
15367 must be complete when you define the function. */
15368 check_function_type (decl1
, DECL_ARGUMENTS (decl1
));
15370 /* Build the return declaration for the function. */
15371 restype
= TREE_TYPE (fntype
);
15373 if (DECL_RESULT (decl1
) == NULL_TREE
)
15377 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
15378 DECL_ARTIFICIAL (resdecl
) = 1;
15379 DECL_IGNORED_P (resdecl
) = 1;
15380 DECL_RESULT (decl1
) = resdecl
;
15382 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
15385 /* Record the decl so that the function name is defined.
15386 If we already have a decl for this name, and it is a FUNCTION_DECL,
15387 use the old decl. */
15388 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
15390 /* A specialization is not used to guide overload resolution. */
15391 if (!DECL_FUNCTION_MEMBER_P (decl1
)
15392 && !(DECL_USE_TEMPLATE (decl1
) &&
15393 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
15395 tree olddecl
= pushdecl (decl1
);
15397 if (olddecl
== error_mark_node
)
15398 /* If something went wrong when registering the declaration,
15399 use DECL1; we have to have a FUNCTION_DECL to use when
15400 parsing the body of the function. */
15404 /* Otherwise, OLDDECL is either a previous declaration
15405 of the same function or DECL1 itself. */
15407 if (warn_missing_declarations
15408 && olddecl
== decl1
15409 && !DECL_MAIN_P (decl1
)
15410 && TREE_PUBLIC (decl1
)
15411 && !DECL_DECLARED_INLINE_P (decl1
))
15415 /* Check whether DECL1 is in an anonymous
15417 for (context
= DECL_CONTEXT (decl1
);
15419 context
= DECL_CONTEXT (context
))
15421 if (TREE_CODE (context
) == NAMESPACE_DECL
15422 && DECL_NAME (context
) == NULL_TREE
)
15426 if (context
== NULL
)
15427 warning_at (DECL_SOURCE_LOCATION (decl1
),
15428 OPT_Wmissing_declarations
,
15429 "no previous declaration for %qD", decl1
);
15437 /* We need to set the DECL_CONTEXT. */
15438 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
15439 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
15441 fntype
= TREE_TYPE (decl1
);
15442 restype
= TREE_TYPE (fntype
);
15444 /* If #pragma weak applies, mark the decl appropriately now.
15445 The pragma only applies to global functions. Because
15446 determining whether or not the #pragma applies involves
15447 computing the mangled name for the declaration, we cannot
15448 apply the pragma until after we have merged this declaration
15449 with any previous declarations; if the original declaration
15450 has a linkage specification, that specification applies to
15451 the definition as well, and may affect the mangled name. */
15452 if (DECL_FILE_SCOPE_P (decl1
))
15453 maybe_apply_pragma_weak (decl1
);
15456 /* We are now in the scope of the function being defined. */
15457 current_function_decl
= decl1
;
15459 /* Save the parm names or decls from this function's declarator
15460 where store_parm_decls will find them. */
15461 current_function_parms
= DECL_ARGUMENTS (decl1
);
15463 /* Let the user know we're compiling this function. */
15464 announce_function (decl1
);
15466 gcc_assert (DECL_INITIAL (decl1
));
15468 /* This function may already have been parsed, in which case just
15469 return; our caller will skip over the body without parsing. */
15470 if (DECL_INITIAL (decl1
) != error_mark_node
)
15473 /* Initialize RTL machinery. We cannot do this until
15474 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
15475 even when processing a template; this is how we get
15476 CFUN set up, and our per-function variables initialized.
15477 FIXME factor out the non-RTL stuff. */
15478 bl
= current_binding_level
;
15479 allocate_struct_function (decl1
, processing_template_decl
);
15481 /* Initialize the language data structures. Whenever we start
15482 a new function, we destroy temporaries in the usual way. */
15483 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
15484 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
15485 current_binding_level
= bl
;
15487 /* If we are (erroneously) defining a function that we have already
15488 defined before, wipe out what we knew before. */
15489 gcc_checking_assert (!DECL_PENDING_INLINE_P (decl1
));
15490 FNDECL_USED_AUTO (decl1
) = false;
15491 DECL_SAVED_AUTO_RETURN_TYPE (decl1
) = NULL
;
15493 if (!processing_template_decl
&& type_uses_auto (restype
))
15495 FNDECL_USED_AUTO (decl1
) = true;
15496 DECL_SAVED_AUTO_RETURN_TYPE (decl1
) = restype
;
15499 /* Start the statement-tree, start the tree now. */
15500 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
15502 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
15504 /* We know that this was set up by `grokclassfn'. We do not
15505 wait until `store_parm_decls', since evil parse errors may
15506 never get us to that point. Here we keep the consistency
15507 between `current_class_type' and `current_class_ptr'. */
15508 tree t
= DECL_ARGUMENTS (decl1
);
15510 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
15511 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
15513 cp_function_chain
->x_current_class_ref
15514 = cp_build_fold_indirect_ref (t
);
15515 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
15516 cp_function_chain
->x_current_class_ptr
= t
;
15518 /* Constructors and destructors need to know whether they're "in
15519 charge" of initializing virtual base classes. */
15520 t
= DECL_CHAIN (t
);
15521 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
15523 current_in_charge_parm
= t
;
15524 t
= DECL_CHAIN (t
);
15526 if (DECL_HAS_VTT_PARM_P (decl1
))
15528 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
15529 current_vtt_parm
= t
;
15533 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
15534 /* Implicitly-defined methods (like the
15535 destructor for a class in which no destructor
15536 is explicitly declared) must not be defined
15537 until their definition is needed. So, we
15538 ignore interface specifications for
15539 compiler-generated functions. */
15540 && !DECL_ARTIFICIAL (decl1
));
15542 if (processing_template_decl
)
15543 /* Don't mess with interface flags. */;
15544 else if (DECL_INTERFACE_KNOWN (decl1
))
15546 tree ctx
= decl_function_context (decl1
);
15548 if (DECL_NOT_REALLY_EXTERN (decl1
))
15549 DECL_EXTERNAL (decl1
) = 0;
15551 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
15552 /* This is a function in a local class in an extern inline
15553 or template function. */
15554 comdat_linkage (decl1
);
15556 /* If this function belongs to an interface, it is public.
15557 If it belongs to someone else's interface, it is also external.
15558 This only affects inlines and template instantiations. */
15559 else if (!finfo
->interface_unknown
&& honor_interface
)
15561 if (DECL_DECLARED_INLINE_P (decl1
)
15562 || DECL_TEMPLATE_INSTANTIATION (decl1
))
15564 DECL_EXTERNAL (decl1
)
15565 = (finfo
->interface_only
15566 || (DECL_DECLARED_INLINE_P (decl1
)
15567 && ! flag_implement_inlines
15568 && !DECL_VINDEX (decl1
)));
15570 /* For WIN32 we also want to put these in linkonce sections. */
15571 maybe_make_one_only (decl1
);
15574 DECL_EXTERNAL (decl1
) = 0;
15575 DECL_INTERFACE_KNOWN (decl1
) = 1;
15576 /* If this function is in an interface implemented in this file,
15577 make sure that the back end knows to emit this function
15579 if (!DECL_EXTERNAL (decl1
))
15580 mark_needed (decl1
);
15582 else if (finfo
->interface_unknown
&& finfo
->interface_only
15583 && honor_interface
)
15585 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
15586 interface, we will have both finfo->interface_unknown and
15587 finfo->interface_only set. In that case, we don't want to
15588 use the normal heuristics because someone will supply a
15589 #pragma implementation elsewhere, and deducing it here would
15590 produce a conflict. */
15591 comdat_linkage (decl1
);
15592 DECL_EXTERNAL (decl1
) = 0;
15593 DECL_INTERFACE_KNOWN (decl1
) = 1;
15594 DECL_DEFER_OUTPUT (decl1
) = 1;
15598 /* This is a definition, not a reference.
15599 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
15600 if (!GNU_INLINE_P (decl1
))
15601 DECL_EXTERNAL (decl1
) = 0;
15603 if ((DECL_DECLARED_INLINE_P (decl1
)
15604 || DECL_TEMPLATE_INSTANTIATION (decl1
))
15605 && ! DECL_INTERFACE_KNOWN (decl1
))
15606 DECL_DEFER_OUTPUT (decl1
) = 1;
15608 DECL_INTERFACE_KNOWN (decl1
) = 1;
15611 /* Determine the ELF visibility attribute for the function. We must not
15612 do this before calling "pushdecl", as we must allow "duplicate_decls"
15613 to merge any attributes appropriately. We also need to wait until
15615 if (!DECL_CLONED_FUNCTION_P (decl1
))
15616 determine_visibility (decl1
);
15618 if (!processing_template_decl
)
15619 maybe_instantiate_noexcept (decl1
);
15621 begin_scope (sk_function_parms
, decl1
);
15625 if (DECL_DESTRUCTOR_P (decl1
)
15626 || (DECL_CONSTRUCTOR_P (decl1
)
15627 && targetm
.cxx
.cdtor_returns_this ()))
15629 cdtor_label
= create_artificial_label (input_location
);
15630 LABEL_DECL_CDTOR (cdtor_label
) = true;
15633 start_fname_decls ();
15635 store_parm_decls (current_function_parms
);
15637 push_operator_bindings ();
15639 if (!processing_template_decl
15640 && (flag_lifetime_dse
> 1)
15641 && DECL_CONSTRUCTOR_P (decl1
)
15642 && !DECL_CLONED_FUNCTION_P (decl1
)
15643 /* Clobbering an empty base is harmful if it overlays real data. */
15644 && !is_empty_class (current_class_type
)
15645 /* We can't clobber safely for an implicitly-defined default constructor
15646 because part of the initialization might happen before we enter the
15647 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
15648 && !implicit_default_ctor_p (decl1
))
15649 finish_expr_stmt (build_clobber_this ());
15651 if (!processing_template_decl
15652 && DECL_CONSTRUCTOR_P (decl1
)
15653 && sanitize_flags_p (SANITIZE_VPTR
)
15654 && !DECL_CLONED_FUNCTION_P (decl1
)
15655 && !implicit_default_ctor_p (decl1
))
15656 cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr
);
15658 start_lambda_scope (decl1
);
15664 /* Like start_preparsed_function, except that instead of a
15665 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
15667 Returns true on success. If the DECLARATOR is not suitable
15668 for a function, we return false, which tells the parser to
15669 skip the entire function. */
15672 start_function (cp_decl_specifier_seq
*declspecs
,
15673 const cp_declarator
*declarator
,
15678 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
15679 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
15680 if (decl1
== error_mark_node
)
15682 /* If the declarator is not suitable for a function definition,
15683 cause a syntax error. */
15684 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
15686 error ("invalid function declaration");
15690 if (DECL_MAIN_P (decl1
))
15691 /* main must return int. grokfndecl should have corrected it
15692 (and issued a diagnostic) if the user got it wrong. */
15693 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
15694 integer_type_node
));
15696 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
15699 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
15703 use_eh_spec_block (tree fn
)
15705 return (flag_exceptions
&& flag_enforce_eh_specs
15706 && !processing_template_decl
15707 && !type_throw_all_p (TREE_TYPE (fn
))
15708 /* We insert the EH_SPEC_BLOCK only in the original
15709 function; then, it is copied automatically to the
15711 && !DECL_CLONED_FUNCTION_P (fn
)
15712 /* Implicitly-generated constructors and destructors have
15713 exception specifications. However, those specifications
15714 are the union of the possible exceptions specified by the
15715 constructors/destructors for bases and members, so no
15716 unallowed exception will ever reach this function. By
15717 not creating the EH_SPEC_BLOCK we save a little memory,
15718 and we avoid spurious warnings about unreachable
15720 && !DECL_DEFAULTED_FN (fn
));
15723 /* Store the parameter declarations into the current function declaration.
15724 This is called after parsing the parameter declarations, before
15725 digesting the body of the function.
15727 Also install to binding contour return value identifier, if any. */
15730 store_parm_decls (tree current_function_parms
)
15732 tree fndecl
= current_function_decl
;
15735 /* This is a chain of any other decls that came in among the parm
15736 declarations. If a parm is declared with enum {foo, bar} x;
15737 then CONST_DECLs for foo and bar are put here. */
15738 tree nonparms
= NULL_TREE
;
15740 if (current_function_parms
)
15742 /* This case is when the function was defined with an ANSI prototype.
15743 The parms already have decls, so we need not do anything here
15744 except record them as in effect
15745 and complain if any redundant old-style parm decls were written. */
15747 tree specparms
= current_function_parms
;
15750 /* Must clear this because it might contain TYPE_DECLs declared
15752 current_binding_level
->names
= NULL
;
15754 /* If we're doing semantic analysis, then we'll call pushdecl
15755 for each of these. We must do them in reverse order so that
15756 they end in the correct forward order. */
15757 specparms
= nreverse (specparms
);
15759 for (parm
= specparms
; parm
; parm
= next
)
15761 next
= DECL_CHAIN (parm
);
15762 if (TREE_CODE (parm
) == PARM_DECL
)
15766 /* If we find an enum constant or a type tag,
15767 put it aside for the moment. */
15768 TREE_CHAIN (parm
) = NULL_TREE
;
15769 nonparms
= chainon (nonparms
, parm
);
15773 /* Get the decls in their original chain order and record in the
15774 function. This is all and only the PARM_DECLs that were
15775 pushed into scope by the loop above. */
15776 DECL_ARGUMENTS (fndecl
) = get_local_decls ();
15779 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
15781 /* Now store the final chain of decls for the arguments
15782 as the decl-chain of the current lexical scope.
15783 Put the enumerators in as well, at the front so that
15784 DECL_ARGUMENTS is not modified. */
15785 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
15787 if (use_eh_spec_block (current_function_decl
))
15788 current_eh_spec_block
= begin_eh_spec_block ();
15792 /* Set the return value of the constructor (if present). */
15795 finish_constructor_body (void)
15800 if (targetm
.cxx
.cdtor_returns_this ())
15802 /* Any return from a constructor will end up here. */
15803 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
15805 val
= DECL_ARGUMENTS (current_function_decl
);
15806 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
15807 DECL_RESULT (current_function_decl
), val
);
15808 /* Return the address of the object. */
15809 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
15810 add_stmt (exprstmt
);
15814 /* Do all the processing for the beginning of a destructor; set up the
15815 vtable pointers and cleanups for bases and members. */
15818 begin_destructor_body (void)
15820 tree compound_stmt
;
15822 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
15823 issued an error message. We still want to try to process the
15824 body of the function, but initialize_vtbl_ptrs will crash if
15825 TYPE_BINFO is NULL. */
15826 if (COMPLETE_TYPE_P (current_class_type
))
15828 compound_stmt
= begin_compound_stmt (0);
15829 /* Make all virtual function table pointers in non-virtual base
15830 classes point to CURRENT_CLASS_TYPE's virtual function
15832 initialize_vtbl_ptrs (current_class_ptr
);
15833 finish_compound_stmt (compound_stmt
);
15835 if (flag_lifetime_dse
15836 /* Clobbering an empty base is harmful if it overlays real data. */
15837 && !is_empty_class (current_class_type
))
15839 if (sanitize_flags_p (SANITIZE_VPTR
)
15840 && (flag_sanitize_recover
& SANITIZE_VPTR
) == 0
15841 && TYPE_CONTAINS_VPTR_P (current_class_type
))
15843 tree binfo
= TYPE_BINFO (current_class_type
);
15845 = cp_build_fold_indirect_ref (current_class_ptr
);
15847 tree vtbl_ptr
= build_vfield_ref (ref
, TREE_TYPE (binfo
));
15848 tree vtbl
= build_zero_cst (TREE_TYPE (vtbl_ptr
));
15849 tree stmt
= cp_build_modify_expr (input_location
, vtbl_ptr
,
15851 tf_warning_or_error
);
15852 /* If the vptr is shared with some virtual nearly empty base,
15853 don't clear it if not in charge, the dtor of the virtual
15854 nearly empty base will do that later. */
15855 if (CLASSTYPE_VBASECLASSES (current_class_type
)
15856 && CLASSTYPE_PRIMARY_BINFO (current_class_type
)
15858 (CLASSTYPE_PRIMARY_BINFO (current_class_type
)))
15860 stmt
= convert_to_void (stmt
, ICV_STATEMENT
,
15861 tf_warning_or_error
);
15862 stmt
= build_if_in_charge (stmt
);
15864 finish_decl_cleanup (NULL_TREE
, stmt
);
15867 finish_decl_cleanup (NULL_TREE
, build_clobber_this ());
15870 /* And insert cleanups for our bases and members so that they
15871 will be properly destroyed if we throw. */
15872 push_base_cleanups ();
15876 /* At the end of every destructor we generate code to delete the object if
15877 necessary. Do that now. */
15880 finish_destructor_body (void)
15884 /* Any return from a destructor will end up here; that way all base
15885 and member cleanups will be run when the function returns. */
15886 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
15888 if (targetm
.cxx
.cdtor_returns_this ())
15892 val
= DECL_ARGUMENTS (current_function_decl
);
15893 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
15894 DECL_RESULT (current_function_decl
), val
);
15895 /* Return the address of the object. */
15896 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
15897 add_stmt (exprstmt
);
15901 /* Do the necessary processing for the beginning of a function body, which
15902 in this case includes member-initializers, but not the catch clauses of
15903 a function-try-block. Currently, this means opening a binding level
15904 for the member-initializers (in a ctor), member cleanups (in a dtor),
15905 and capture proxies (in a lambda operator()). */
15908 begin_function_body (void)
15912 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
15915 if (processing_template_decl
)
15916 /* Do nothing now. */;
15918 /* Always keep the BLOCK node associated with the outermost pair of
15919 curly braces of a function. These are needed for correct
15920 operation of dwarfout.c. */
15921 keep_next_level (true);
15923 stmt
= begin_compound_stmt (BCS_FN_BODY
);
15925 if (processing_template_decl
)
15926 /* Do nothing now. */;
15927 else if (DECL_DESTRUCTOR_P (current_function_decl
))
15928 begin_destructor_body ();
15933 /* Do the processing for the end of a function body. Currently, this means
15934 closing out the cleanups for fully-constructed bases and members, and in
15935 the case of the destructor, deleting the object if desired. Again, this
15936 is only meaningful for [cd]tors, since they are the only functions where
15937 there is a significant distinction between the main body and any
15938 function catch clauses. Handling, say, main() return semantics here
15939 would be wrong, as flowing off the end of a function catch clause for
15940 main() would also need to return 0. */
15943 finish_function_body (tree compstmt
)
15945 if (compstmt
== NULL_TREE
)
15948 /* Close the block. */
15949 finish_compound_stmt (compstmt
);
15951 if (processing_template_decl
)
15952 /* Do nothing now. */;
15953 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
15954 finish_constructor_body ();
15955 else if (DECL_DESTRUCTOR_P (current_function_decl
))
15956 finish_destructor_body ();
15959 /* Given a function, returns the BLOCK corresponding to the outermost level
15960 of curly braces, skipping the artificial block created for constructor
15964 outer_curly_brace_block (tree fndecl
)
15966 tree block
= DECL_INITIAL (fndecl
);
15967 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
15969 block
= BLOCK_SUBBLOCKS (block
);
15970 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
15972 block
= BLOCK_SUBBLOCKS (block
);
15973 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block
));
15977 /* If FNDECL is a class's key method, add the class to the list of
15978 keyed classes that should be emitted. */
15981 record_key_method_defined (tree fndecl
)
15983 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
15984 && DECL_VIRTUAL_P (fndecl
)
15985 && !processing_template_decl
)
15987 tree fnclass
= DECL_CONTEXT (fndecl
);
15988 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
15989 vec_safe_push (keyed_classes
, fnclass
);
15993 /* Subroutine of finish_function.
15994 Save the body of constexpr functions for possible
15995 future compile time evaluation. */
15998 maybe_save_function_definition (tree fun
)
16000 if (!processing_template_decl
16001 && DECL_DECLARED_CONSTEXPR_P (fun
)
16002 && !cp_function_chain
->invalid_constexpr
16003 && !DECL_CLONED_FUNCTION_P (fun
))
16004 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
16007 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
16008 of "return *this;" immediately before its location, using FNDECL's
16009 first statement (if any) to give the indentation, if appropriate. */
16012 add_return_star_this_fixit (gcc_rich_location
*richloc
, tree fndecl
)
16014 location_t indent
= UNKNOWN_LOCATION
;
16015 tree stmts
= expr_first (DECL_SAVED_TREE (fndecl
));
16017 indent
= EXPR_LOCATION (stmts
);
16018 richloc
->add_fixit_insert_formatted ("return *this;",
16019 richloc
->get_loc (),
16023 /* Finish up a function declaration and compile that function
16024 all the way to assembler language output. The free the storage
16025 for the function definition. INLINE_P is TRUE if we just
16026 finished processing the body of an in-class inline function
16027 definition. (This processing will have taken place after the
16028 class definition is complete.) */
16031 finish_function (bool inline_p
)
16033 tree fndecl
= current_function_decl
;
16034 tree fntype
, ctype
= NULL_TREE
;
16036 /* When we get some parse errors, we can end up without a
16037 current_function_decl, so cope. */
16038 if (fndecl
== NULL_TREE
)
16039 return error_mark_node
;
16041 finish_lambda_scope ();
16043 if (c_dialect_objc ())
16044 objc_finish_function ();
16046 record_key_method_defined (fndecl
);
16048 fntype
= TREE_TYPE (fndecl
);
16050 /* TREE_READONLY (fndecl) = 1;
16051 This caused &foo to be of type ptr-to-const-function
16052 which then got a warning when stored in a ptr-to-function variable. */
16054 gcc_assert (building_stmt_list_p ());
16055 /* The current function is being defined, so its DECL_INITIAL should
16056 be set, and unless there's a multiple definition, it should be
16057 error_mark_node. */
16058 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
16060 /* For a cloned function, we've already got all the code we need;
16061 there's no need to add any extra bits. */
16062 if (!DECL_CLONED_FUNCTION_P (fndecl
))
16064 /* Make it so that `main' always returns 0 by default. */
16065 if (DECL_MAIN_P (current_function_decl
))
16066 finish_return_stmt (integer_zero_node
);
16068 if (use_eh_spec_block (current_function_decl
))
16069 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
16070 (TREE_TYPE (current_function_decl
)),
16071 current_eh_spec_block
);
16074 /* If we're saving up tree structure, tie off the function now. */
16075 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
16077 finish_fname_decls ();
16079 /* If this function can't throw any exceptions, remember that. */
16080 if (!processing_template_decl
16081 && !cp_function_chain
->can_throw
16082 && !flag_non_call_exceptions
16083 && !decl_replaceable_p (fndecl
))
16084 TREE_NOTHROW (fndecl
) = 1;
16086 /* This must come after expand_function_end because cleanups might
16087 have declarations (from inline functions) that need to go into
16088 this function's blocks. */
16090 /* If the current binding level isn't the outermost binding level
16091 for this function, either there is a bug, or we have experienced
16092 syntax errors and the statement tree is malformed. */
16093 if (current_binding_level
->kind
!= sk_function_parms
)
16095 /* Make sure we have already experienced errors. */
16096 gcc_assert (errorcount
);
16098 /* Throw away the broken statement tree and extra binding
16100 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
16102 while (current_binding_level
->kind
!= sk_function_parms
)
16104 if (current_binding_level
->kind
== sk_class
)
16105 pop_nested_class ();
16107 poplevel (0, 0, 0);
16110 poplevel (1, 0, 1);
16112 /* Statements should always be full-expressions at the outermost set
16113 of curly braces for a function. */
16114 gcc_assert (stmts_are_full_exprs_p ());
16116 /* If there are no return statements in a function with auto return type,
16117 the return type is void. But if the declared type is something like
16118 auto*, this is an error. */
16119 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
16120 && TREE_TYPE (fntype
) == DECL_SAVED_AUTO_RETURN_TYPE (fndecl
))
16122 if (is_auto (DECL_SAVED_AUTO_RETURN_TYPE (fndecl
)))
16124 apply_deduced_return_type (fndecl
, void_type_node
);
16125 fntype
= TREE_TYPE (fndecl
);
16127 else if (!current_function_returns_value
16128 && !current_function_returns_null
)
16130 error ("no return statements in function returning %qT",
16131 DECL_SAVED_AUTO_RETURN_TYPE (fndecl
));
16132 inform (input_location
, "only plain %<auto%> return type can be "
16133 "deduced to %<void%>");
16137 // If this is a concept, check that the definition is reasonable.
16138 if (DECL_DECLARED_CONCEPT_P (fndecl
))
16139 check_function_concept (fndecl
);
16141 /* Lambda closure members are implicitly constexpr if possible. */
16142 if (cxx_dialect
>= cxx17
16143 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fndecl
)))
16144 DECL_DECLARED_CONSTEXPR_P (fndecl
)
16145 = ((processing_template_decl
16146 || is_valid_constexpr_fn (fndecl
, /*complain*/false))
16147 && potential_constant_expression (DECL_SAVED_TREE (fndecl
)));
16149 /* Save constexpr function body before it gets munged by
16150 the NRV transformation. */
16151 maybe_save_function_definition (fndecl
);
16153 /* Invoke the pre-genericize plugin before we start munging things. */
16154 if (!processing_template_decl
)
16155 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
16157 /* Perform delayed folding before NRV transformation. */
16158 if (!processing_template_decl
)
16159 cp_fold_function (fndecl
);
16161 /* Set up the named return value optimization, if we can. Candidate
16162 variables are selected in check_return_expr. */
16163 if (current_function_return_value
)
16165 tree r
= current_function_return_value
;
16168 if (r
!= error_mark_node
16169 /* This is only worth doing for fns that return in memory--and
16170 simpler, since we don't have to worry about promoted modes. */
16171 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
16172 /* Only allow this for variables declared in the outer scope of
16173 the function so we know that their lifetime always ends with a
16174 return; see g++.dg/opt/nrv6.C. We could be more flexible if
16175 we were to do this optimization in tree-ssa. */
16176 && (outer
= outer_curly_brace_block (fndecl
))
16177 && chain_member (r
, BLOCK_VARS (outer
)))
16178 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
16180 current_function_return_value
= NULL_TREE
;
16183 /* Remember that we were in class scope. */
16184 if (current_class_name
)
16185 ctype
= current_class_type
;
16187 /* Must mark the RESULT_DECL as being in this function. */
16188 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
16190 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
16191 to the FUNCTION_DECL node itself. */
16192 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
16194 /* Complain if there's just no return statement. */
16195 if (warn_return_type
16196 && !VOID_TYPE_P (TREE_TYPE (fntype
))
16197 && !dependent_type_p (TREE_TYPE (fntype
))
16198 && !current_function_returns_value
&& !current_function_returns_null
16199 /* Don't complain if we abort or throw. */
16200 && !current_function_returns_abnormally
16201 /* Don't complain if there's an infinite loop. */
16202 && !current_function_infinite_loop
16203 /* Don't complain if we are declared noreturn. */
16204 && !TREE_THIS_VOLATILE (fndecl
)
16205 && !DECL_NAME (DECL_RESULT (fndecl
))
16206 && !TREE_NO_WARNING (fndecl
)
16207 /* Structor return values (if any) are set by the compiler. */
16208 && !DECL_CONSTRUCTOR_P (fndecl
)
16209 && !DECL_DESTRUCTOR_P (fndecl
)
16210 && targetm
.warn_func_return (fndecl
))
16212 gcc_rich_location
richloc (input_location
);
16213 /* Potentially add a "return *this;" fix-it hint for
16214 assignment operators. */
16215 if (IDENTIFIER_ASSIGN_OP_P (DECL_NAME (fndecl
)))
16217 tree valtype
= TREE_TYPE (DECL_RESULT (fndecl
));
16218 if (TREE_CODE (valtype
) == REFERENCE_TYPE
16219 && current_class_ref
16220 && same_type_ignoring_top_level_qualifiers_p
16221 (TREE_TYPE (valtype
), TREE_TYPE (current_class_ref
))
16222 && global_dc
->option_enabled (OPT_Wreturn_type
,
16223 global_dc
->option_state
))
16224 add_return_star_this_fixit (&richloc
, fndecl
);
16226 if (warning_at (&richloc
, OPT_Wreturn_type
,
16227 "no return statement in function returning non-void"))
16228 TREE_NO_WARNING (fndecl
) = 1;
16231 /* Store the end of the function, so that we get good line number
16232 info for the epilogue. */
16233 cfun
->function_end_locus
= input_location
;
16235 /* Complain about parameters that are only set, but never otherwise used. */
16236 if (warn_unused_but_set_parameter
16237 && !processing_template_decl
16238 && errorcount
== unused_but_set_errorcount
16239 && !DECL_CLONED_FUNCTION_P (fndecl
))
16243 for (decl
= DECL_ARGUMENTS (fndecl
);
16245 decl
= DECL_CHAIN (decl
))
16246 if (TREE_USED (decl
)
16247 && TREE_CODE (decl
) == PARM_DECL
16248 && !DECL_READ_P (decl
)
16249 && DECL_NAME (decl
)
16250 && !DECL_ARTIFICIAL (decl
)
16251 && !TREE_NO_WARNING (decl
)
16252 && !DECL_IN_SYSTEM_HEADER (decl
)
16253 && TREE_TYPE (decl
) != error_mark_node
16254 && !TYPE_REF_P (TREE_TYPE (decl
))
16255 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
16256 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
16257 warning_at (DECL_SOURCE_LOCATION (decl
),
16258 OPT_Wunused_but_set_parameter
,
16259 "parameter %qD set but not used", decl
);
16260 unused_but_set_errorcount
= errorcount
;
16263 /* Complain about locally defined typedefs that are not used in this
16265 maybe_warn_unused_local_typedefs ();
16267 /* Possibly warn about unused parameters. */
16268 if (warn_unused_parameter
16269 && !processing_template_decl
16270 && !DECL_CLONED_FUNCTION_P (fndecl
))
16271 do_warn_unused_parameter (fndecl
);
16273 /* Genericize before inlining. */
16274 if (!processing_template_decl
)
16275 cp_genericize (fndecl
);
16277 /* We're leaving the context of this function, so zap cfun. It's still in
16278 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
16280 current_function_decl
= NULL
;
16282 /* If this is an in-class inline definition, we may have to pop the
16283 bindings for the template parameters that we added in
16284 maybe_begin_member_template_processing when start_function was
16287 maybe_end_member_template_processing ();
16289 /* Leave the scope of the class. */
16291 pop_nested_class ();
16296 current_function_decl
= NULL_TREE
;
16298 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, fndecl
);
16302 /* Create the FUNCTION_DECL for a function definition.
16303 DECLSPECS and DECLARATOR are the parts of the declaration;
16304 they describe the return type and the name of the function,
16305 but twisted together in a fashion that parallels the syntax of C.
16307 This function creates a binding context for the function body
16308 as well as setting up the FUNCTION_DECL in current_function_decl.
16310 Returns a FUNCTION_DECL on success.
16312 If the DECLARATOR is not suitable for a function (it defines a datum
16313 instead), we return 0, which tells yyparse to report a parse error.
16315 May return void_type_node indicating that this method is actually
16316 a friend. See grokfield for more details.
16318 Came here with a `.pushlevel' .
16320 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
16321 CHANGES TO CODE IN `grokfield'. */
16324 grokmethod (cp_decl_specifier_seq
*declspecs
,
16325 const cp_declarator
*declarator
, tree attrlist
)
16327 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
16330 if (fndecl
== error_mark_node
)
16331 return error_mark_node
;
16333 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
16335 error ("invalid member function declaration");
16336 return error_mark_node
;
16340 cplus_decl_attributes (&fndecl
, attrlist
, 0);
16342 /* Pass friends other than inline friend functions back. */
16343 if (fndecl
== void_type_node
)
16346 if (DECL_IN_AGGR_P (fndecl
))
16348 if (DECL_CLASS_SCOPE_P (fndecl
))
16349 error ("%qD is already defined in class %qT", fndecl
,
16350 DECL_CONTEXT (fndecl
));
16351 return error_mark_node
;
16354 check_template_shadow (fndecl
);
16356 if (TREE_PUBLIC (fndecl
))
16357 DECL_COMDAT (fndecl
) = 1;
16358 DECL_DECLARED_INLINE_P (fndecl
) = 1;
16359 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
16361 /* We process method specializations in finish_struct_1. */
16362 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
16364 fndecl
= push_template_decl (fndecl
);
16365 if (fndecl
== error_mark_node
)
16369 if (! DECL_FRIEND_P (fndecl
))
16371 if (DECL_CHAIN (fndecl
))
16373 fndecl
= copy_node (fndecl
);
16374 TREE_CHAIN (fndecl
) = NULL_TREE
;
16378 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
16380 DECL_IN_AGGR_P (fndecl
) = 1;
16385 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
16386 we can lay it out later, when and if its type becomes complete.
16388 Also handle constexpr variables where the initializer involves
16389 an unlowered PTRMEM_CST because the class isn't complete yet. */
16392 maybe_register_incomplete_var (tree var
)
16394 gcc_assert (VAR_P (var
));
16396 /* Keep track of variables with incomplete types. */
16397 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
16398 && DECL_EXTERNAL (var
))
16400 tree inner_type
= TREE_TYPE (var
);
16402 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
16403 inner_type
= TREE_TYPE (inner_type
);
16404 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
16406 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
16407 /* RTTI TD entries are created while defining the type_info. */
16408 || (TYPE_LANG_SPECIFIC (inner_type
)
16409 && TYPE_BEING_DEFINED (inner_type
)))
16411 incomplete_var iv
= {var
, inner_type
};
16412 vec_safe_push (incomplete_vars
, iv
);
16414 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
16415 && decl_constant_var_p (var
)
16416 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
16418 /* When the outermost open class is complete we can resolve any
16419 pointers-to-members. */
16420 tree context
= outermost_open_class ();
16421 incomplete_var iv
= {var
, context
};
16422 vec_safe_push (incomplete_vars
, iv
);
16427 /* Called when a class type (given by TYPE) is defined. If there are
16428 any existing VAR_DECLs whose type has been completed by this
16429 declaration, update them now. */
16432 complete_vars (tree type
)
16435 incomplete_var
*iv
;
16437 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
16439 if (same_type_p (type
, iv
->incomplete_type
))
16441 tree var
= iv
->decl
;
16442 tree type
= TREE_TYPE (var
);
16444 if (type
!= error_mark_node
16445 && (TYPE_MAIN_VARIANT (strip_array_types (type
))
16446 == iv
->incomplete_type
))
16448 /* Complete the type of the variable. The VAR_DECL itself
16449 will be laid out in expand_expr. */
16450 complete_type (type
);
16451 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
16454 /* Remove this entry from the list. */
16455 incomplete_vars
->unordered_remove (ix
);
16461 /* Check for pending declarations which may have abstract type. */
16462 complete_type_check_abstract (type
);
16465 /* If DECL is of a type which needs a cleanup, build and return an
16466 expression to perform that cleanup here. Return NULL_TREE if no
16467 cleanup need be done. DECL can also be a _REF when called from
16468 split_nonconstant_init_1. */
16471 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
16477 /* Assume no cleanup is required. */
16478 cleanup
= NULL_TREE
;
16480 if (error_operand_p (decl
))
16483 /* Handle "__attribute__((cleanup))". We run the cleanup function
16484 before the destructor since the destructor is what actually
16485 terminates the lifetime of the object. */
16487 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
16496 /* Get the name specified by the user for the cleanup function. */
16497 id
= TREE_VALUE (TREE_VALUE (attr
));
16498 /* Look up the name to find the cleanup function to call. It is
16499 important to use lookup_name here because that is what is
16500 used in c-common.c:handle_cleanup_attribute when performing
16501 initial checks on the attribute. Note that those checks
16502 include ensuring that the function found is not an overloaded
16503 function, or an object with an overloaded call operator,
16504 etc.; we can rely on the fact that the function found is an
16505 ordinary FUNCTION_DECL. */
16506 fn
= lookup_name (id
);
16507 arg
= build_address (decl
);
16508 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
16509 return error_mark_node
;
16510 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
16511 if (cleanup
== error_mark_node
)
16512 return error_mark_node
;
16514 /* Handle ordinary C++ destructors. */
16515 type
= TREE_TYPE (decl
);
16516 if (type_build_dtor_call (type
))
16518 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
16522 if (TREE_CODE (type
) == ARRAY_TYPE
)
16525 addr
= build_address (decl
);
16527 call
= build_delete (TREE_TYPE (addr
), addr
,
16528 sfk_complete_destructor
, flags
, 0, complain
);
16529 if (call
== error_mark_node
)
16530 cleanup
= error_mark_node
;
16531 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
16532 /* Discard the call. */;
16534 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
16539 /* build_delete sets the location of the destructor call to the
16540 current location, even though the destructor is going to be
16541 called later, at the end of the current scope. This can lead to
16542 a "jumpy" behavior for users of debuggers when they step around
16543 the end of the block. So let's unset the location of the
16544 destructor call instead. */
16545 protected_set_expr_location (cleanup
, UNKNOWN_LOCATION
);
16549 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
)))
16550 /* Treat objects with destructors as used; the destructor may do
16551 something substantive. */
16552 && !mark_used (decl
, complain
) && !(complain
& tf_error
))
16553 return error_mark_node
;
16559 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
16560 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
16561 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
16564 static_fn_type (tree memfntype
)
16569 if (TYPE_PTRMEMFUNC_P (memfntype
))
16570 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
16571 if (INDIRECT_TYPE_P (memfntype
)
16572 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
16573 memfntype
= TREE_TYPE (memfntype
);
16574 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
16576 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
16577 args
= TYPE_ARG_TYPES (memfntype
);
16578 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
16579 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
));
16580 fntype
= (cp_build_type_attribute_variant
16581 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
16582 fntype
= cxx_copy_lang_qualifiers (fntype
, memfntype
);
16586 /* DECL was originally constructed as a non-static member function,
16587 but turned out to be static. Update it accordingly. */
16590 revert_static_member_fn (tree decl
)
16592 tree stype
= static_fn_type (decl
);
16593 cp_cv_quals quals
= type_memfn_quals (stype
);
16594 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
16596 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
16597 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
16599 TREE_TYPE (decl
) = stype
;
16601 if (DECL_ARGUMENTS (decl
))
16602 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
16603 DECL_STATIC_FUNCTION_P (decl
) = 1;
16606 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
16607 one of the language-independent trees. */
16609 enum cp_tree_node_structure_enum
16610 cp_tree_node_structure (union lang_tree_node
* t
)
16612 switch (TREE_CODE (&t
->generic
))
16614 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
16615 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
16616 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
16617 case OVERLOAD
: return TS_CP_OVERLOAD
;
16618 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
16619 case PTRMEM_CST
: return TS_CP_PTRMEM
;
16620 case BASELINK
: return TS_CP_BASELINK
;
16621 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
16622 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
16623 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
16624 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
16625 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
16626 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
16627 case CONSTRAINT_INFO
: return TS_CP_CONSTRAINT_INFO
;
16628 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
16629 default: return TS_CP_GENERIC
;
16633 /* Build the void_list_node (void_type_node having been created). */
16635 build_void_list_node (void)
16637 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
16642 cp_missing_noreturn_ok_p (tree decl
)
16644 /* A missing noreturn is ok for the `main' function. */
16645 return DECL_MAIN_P (decl
);
16648 /* Return the decl used to identify the COMDAT group into which DECL should
16652 cxx_comdat_group (tree decl
)
16654 /* Virtual tables, construction virtual tables, and virtual table
16655 tables all go in a single COMDAT group, named after the primary
16657 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
16658 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
16659 /* For all other DECLs, the COMDAT group is the mangled name of the
16660 declaration itself. */
16663 while (DECL_THUNK_P (decl
))
16665 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
16666 into the same section as the target function. In that case
16667 we must return target's name. */
16668 tree target
= THUNK_TARGET (decl
);
16669 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
16670 && DECL_SECTION_NAME (target
) != NULL
16671 && DECL_ONE_ONLY (target
))
16681 /* Returns the return type for FN as written by the user, which may include
16682 a placeholder for a deduced return type. */
16685 fndecl_declared_return_type (tree fn
)
16687 fn
= STRIP_TEMPLATE (fn
);
16688 if (FNDECL_USED_AUTO (fn
))
16689 return DECL_SAVED_AUTO_RETURN_TYPE (fn
);
16691 return TREE_TYPE (TREE_TYPE (fn
));
16694 /* Returns true iff DECL is a variable or function declared with an auto type
16695 that has not yet been deduced to a real type. */
16698 undeduced_auto_decl (tree decl
)
16700 if (cxx_dialect
< cxx11
)
16702 STRIP_ANY_LOCATION_WRAPPER (decl
);
16703 return ((VAR_OR_FUNCTION_DECL_P (decl
)
16704 || TREE_CODE (decl
) == TEMPLATE_DECL
)
16705 && type_uses_auto (TREE_TYPE (decl
)));
16708 /* Complain if DECL has an undeduced return type. */
16711 require_deduced_type (tree decl
, tsubst_flags_t complain
)
16713 if (undeduced_auto_decl (decl
))
16715 if (complain
& tf_error
)
16716 error ("use of %qD before deduction of %<auto%>", decl
);
16722 /* Create a representation of the explicit-specifier with
16723 constant-expression of EXPR. COMPLAIN is as for tsubst. */
16726 build_explicit_specifier (tree expr
, tsubst_flags_t complain
)
16728 if (instantiation_dependent_expression_p (expr
))
16729 /* Wait for instantiation, tsubst_function_decl will handle it. */
16732 expr
= instantiate_non_dependent_expr_sfinae (expr
, complain
);
16733 /* Don't let convert_like_real create more template codes. */
16734 processing_template_decl_sentinel s
;
16735 expr
= build_converted_constant_bool_expr (expr
, complain
);
16736 expr
= cxx_constant_value (expr
);
16740 #include "gt-cp-decl.h"