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 save_function_data (tree
);
84 static void copy_type_enum (tree
, tree
);
85 static void check_function_type (tree
, tree
);
86 static void finish_constructor_body (void);
87 static void begin_destructor_body (void);
88 static void finish_destructor_body (void);
89 static void record_key_method_defined (tree
);
90 static tree
create_array_type_for_decl (tree
, tree
, tree
, location_t
);
91 static tree
get_atexit_node (void);
92 static tree
get_dso_handle_node (void);
93 static tree
start_cleanup_fn (void);
94 static void end_cleanup_fn (void);
95 static tree
cp_make_fname_decl (location_t
, tree
, int);
96 static void initialize_predefined_identifiers (void);
97 static tree check_special_function_return_type
98 (special_function_kind
, tree
, tree
, int, const location_t
*);
99 static tree
push_cp_library_fn (enum tree_code
, tree
, int);
100 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
101 static void store_parm_decls (tree
);
102 static void initialize_local_var (tree
, tree
);
103 static void expand_static_init (tree
, tree
);
105 /* The following symbols are subsumed in the cp_global_trees array, and
106 listed here individually for documentation purposes.
109 tree wchar_decl_node;
111 tree vtable_entry_type;
112 tree delta_type_node;
113 tree __t_desc_type_node;
115 tree class_type_node;
116 tree unknown_type_node;
118 Array type `vtable_entry_type[]'
121 tree vtbl_ptr_type_node;
128 A FUNCTION_DECL which can call `abort'. Not necessarily the
129 one that the user will declare, but sufficient to be called
130 by routines that want to abort the program.
135 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
136 tree tinfo_var_id; */
138 tree cp_global_trees
[CPTI_MAX
];
140 /* A list of objects which have constructors or destructors
141 which reside in the global scope. The decl is stored in
142 the TREE_VALUE slot and the initializer is stored
143 in the TREE_PURPOSE slot. */
144 tree static_aggregates
;
146 /* Like static_aggregates, but for thread_local variables. */
151 /* A node for the integer constant 2. */
153 tree integer_two_node
;
155 /* vector of static decls. */
156 vec
<tree
, va_gc
> *static_decls
;
158 /* vector of keyed classes. */
159 vec
<tree
, va_gc
> *keyed_classes
;
161 /* Used only for jumps to as-yet undefined labels, since jumps to
162 defined labels can have their validity checked immediately. */
164 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
165 struct named_label_use_entry
*next
;
166 /* The binding level to which this entry is *currently* attached.
167 This is initially the binding level in which the goto appeared,
168 but is modified as scopes are closed. */
169 cp_binding_level
*binding_level
;
170 /* The head of the names list that was current when the goto appeared,
171 or the inner scope popped. These are the decls that will *not* be
172 skipped when jumping to the label. */
174 /* The location of the goto, for error reporting. */
175 location_t o_goto_locus
;
176 /* True if an OpenMP structured block scope has been closed since
177 the goto appeared. This means that the branch from the label will
178 illegally exit an OpenMP scope. */
182 /* A list of all LABEL_DECLs in the function that have names. Here so
183 we can clear out their names' definitions at the end of the
184 function, and so we can check the validity of jumps to these labels. */
186 struct GTY((for_user
)) named_label_entry
{
188 tree name
; /* Name of decl. */
190 tree label_decl
; /* LABEL_DECL, unless deleted local label. */
192 named_label_entry
*outer
; /* Outer shadowed chain. */
194 /* The binding level to which the label is *currently* attached.
195 This is initially set to the binding level in which the label
196 is defined, but is modified as scopes are closed. */
197 cp_binding_level
*binding_level
;
199 /* The head of the names list that was current when the label was
200 defined, or the inner scope popped. These are the decls that will
201 be skipped when jumping to the label. */
204 /* A vector of all decls from all binding levels that would be
205 crossed by a backward branch to the label. */
206 vec
<tree
, va_gc
> *bad_decls
;
208 /* A list of uses of the label, before the label is defined. */
209 named_label_use_entry
*uses
;
211 /* The following bits are set after the label is defined, and are
212 updated as scopes are popped. They indicate that a jump to the
213 label will illegally enter a scope of the given flavor. */
217 bool in_transaction_scope
;
218 bool in_constexpr_if
;
221 #define named_labels cp_function_chain->x_named_labels
223 /* The number of function bodies which we are currently processing.
224 (Zero if we are at namespace scope, one inside the body of a
225 function, two inside the body of a function in a local class, etc.) */
228 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
229 bool flag_noexcept_type
;
231 /* States indicating how grokdeclarator() should handle declspecs marked
232 with __attribute__((deprecated)). An object declared as
233 __attribute__((deprecated)) suppresses warnings of uses of other
235 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
238 /* A list of VAR_DECLs whose type was incomplete at the time the
239 variable was declared. */
241 struct GTY(()) incomplete_var
{
243 tree incomplete_type
;
247 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
249 /* Returns the kind of template specialization we are currently
250 processing, given that it's declaration contained N_CLASS_SCOPES
251 explicit scope qualifications. */
254 current_tmpl_spec_kind (int n_class_scopes
)
256 int n_template_parm_scopes
= 0;
257 int seen_specialization_p
= 0;
258 int innermost_specialization_p
= 0;
261 /* Scan through the template parameter scopes. */
262 for (b
= current_binding_level
;
263 b
->kind
== sk_template_parms
;
266 /* If we see a specialization scope inside a parameter scope,
267 then something is wrong. That corresponds to a declaration
270 template <class T> template <> ...
272 which is always invalid since [temp.expl.spec] forbids the
273 specialization of a class member template if the enclosing
274 class templates are not explicitly specialized as well. */
275 if (b
->explicit_spec_p
)
277 if (n_template_parm_scopes
== 0)
278 innermost_specialization_p
= 1;
280 seen_specialization_p
= 1;
282 else if (seen_specialization_p
== 1)
283 return tsk_invalid_member_spec
;
285 ++n_template_parm_scopes
;
288 /* Handle explicit instantiations. */
289 if (processing_explicit_instantiation
)
291 if (n_template_parm_scopes
!= 0)
292 /* We've seen a template parameter list during an explicit
293 instantiation. For example:
295 template <class T> template void f(int);
297 This is erroneous. */
298 return tsk_invalid_expl_inst
;
300 return tsk_expl_inst
;
303 if (n_template_parm_scopes
< n_class_scopes
)
304 /* We've not seen enough template headers to match all the
305 specialized classes present. For example:
307 template <class T> void R<T>::S<T>::f(int);
309 This is invalid; there needs to be one set of template
310 parameters for each class. */
311 return tsk_insufficient_parms
;
312 else if (n_template_parm_scopes
== n_class_scopes
)
313 /* We're processing a non-template declaration (even though it may
314 be a member of a template class.) For example:
316 template <class T> void S<T>::f(int);
318 The `class T' matches the `S<T>', leaving no template headers
319 corresponding to the `f'. */
321 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
322 /* We've got too many template headers. For example:
324 template <> template <class T> void f (T);
326 There need to be more enclosing classes. */
327 return tsk_excessive_parms
;
329 /* This must be a template. It's of the form:
331 template <class T> template <class U> void S<T>::f(U);
333 This is a specialization if the innermost level was a
334 specialization; otherwise it's just a definition of the
336 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
339 /* Exit the current scope. */
347 /* When a label goes out of scope, check to see if that label was used
348 in a valid manner, and issue any appropriate warnings or errors. */
351 check_label_used (tree label
)
353 if (!processing_template_decl
)
355 if (DECL_INITIAL (label
) == NULL_TREE
)
359 error ("label %q+D used but not defined", label
);
360 location
= input_location
;
361 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
362 /* Avoid crashing later. */
363 define_label (location
, DECL_NAME (label
));
366 warn_for_unused_label (label
);
370 /* Helper function to sort named label entries in a vector by DECL_UID. */
373 sort_labels (const void *a
, const void *b
)
375 tree label1
= *(tree
const *) a
;
376 tree label2
= *(tree
const *) b
;
378 /* DECL_UIDs can never be equal. */
379 return DECL_UID (label1
) > DECL_UID (label2
) ? -1 : +1;
382 /* At the end of a function, all labels declared within the function
383 go out of scope. BLOCK is the top-level block for the
387 pop_labels (tree block
)
392 /* We need to add the labels to the block chain, so debug
393 information is emitted. But, we want the order to be stable so
394 need to sort them first. Otherwise the debug output could be
395 randomly ordered. I guess it's mostly stable, unless the hash
396 table implementation changes. */
397 auto_vec
<tree
, 32> labels (named_labels
->elements ());
398 hash_table
<named_label_hash
>::iterator
end (named_labels
->end ());
399 for (hash_table
<named_label_hash
>::iterator iter
400 (named_labels
->begin ()); iter
!= end
; ++iter
)
402 named_label_entry
*ent
= *iter
;
404 gcc_checking_assert (!ent
->outer
);
406 labels
.quick_push (ent
->label_decl
);
410 labels
.qsort (sort_labels
);
412 while (labels
.length ())
414 tree label
= labels
.pop ();
416 DECL_CHAIN (label
) = BLOCK_VARS (block
);
417 BLOCK_VARS (block
) = label
;
419 check_label_used (label
);
423 /* At the end of a block with local labels, restore the outer definition. */
426 pop_local_label (tree id
, tree label
)
428 check_label_used (label
);
429 named_label_entry
**slot
= named_labels
->find_slot_with_hash
430 (id
, IDENTIFIER_HASH_VALUE (id
), NO_INSERT
);
431 named_label_entry
*ent
= *slot
;
437 ent
= ggc_cleared_alloc
<named_label_entry
> ();
443 /* The following two routines are used to interface to Objective-C++.
444 The binding level is purposely treated as an opaque type. */
447 objc_get_current_scope (void)
449 return current_binding_level
;
452 /* The following routine is used by the NeXT-style SJLJ exceptions;
453 variables get marked 'volatile' so as to not be clobbered by
454 _setjmp()/_longjmp() calls. All variables in the current scope,
455 as well as parent scopes up to (but not including) ENCLOSING_BLK
456 shall be thusly marked. */
459 objc_mark_locals_volatile (void *enclosing_blk
)
461 cp_binding_level
*scope
;
463 for (scope
= current_binding_level
;
464 scope
&& scope
!= enclosing_blk
;
465 scope
= scope
->level_chain
)
469 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
470 objc_volatilize_decl (decl
);
472 /* Do not climb up past the current function. */
473 if (scope
->kind
== sk_function_parms
)
478 /* True if B is the level for the condition of a constexpr if. */
481 level_for_constexpr_if (cp_binding_level
*b
)
483 return (b
->kind
== sk_cond
&& b
->this_entity
484 && TREE_CODE (b
->this_entity
) == IF_STMT
485 && IF_STMT_CONSTEXPR_P (b
->this_entity
));
488 /* Update data for defined and undefined labels when leaving a scope. */
491 poplevel_named_label_1 (named_label_entry
**slot
, cp_binding_level
*bl
)
493 named_label_entry
*ent
= *slot
;
494 cp_binding_level
*obl
= bl
->level_chain
;
496 if (ent
->binding_level
== bl
)
500 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
501 TREE_LISTs representing OVERLOADs, so be careful. */
502 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
504 : TREE_CHAIN (decl
)))
505 if (decl_jump_unsafe (decl
))
506 vec_safe_push (ent
->bad_decls
, decl
);
508 ent
->binding_level
= obl
;
509 ent
->names_in_scope
= obl
->names
;
513 ent
->in_try_scope
= true;
516 ent
->in_catch_scope
= true;
519 ent
->in_omp_scope
= true;
522 ent
->in_transaction_scope
= true;
525 if (level_for_constexpr_if (bl
->level_chain
))
526 ent
->in_constexpr_if
= true;
534 struct named_label_use_entry
*use
;
536 for (use
= ent
->uses
; use
; use
= use
->next
)
537 if (use
->binding_level
== bl
)
539 use
->binding_level
= obl
;
540 use
->names_in_scope
= obl
->names
;
541 if (bl
->kind
== sk_omp
)
542 use
->in_omp_scope
= true;
549 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
550 when errors were reported, except for -Werror-unused-but-set-*. */
551 static int unused_but_set_errorcount
;
553 /* Exit a binding level.
554 Pop the level off, and restore the state of the identifier-decl mappings
555 that were in effect when this level was entered.
557 If KEEP == 1, this level had explicit declarations, so
558 and create a "block" (a BLOCK node) for the level
559 to record its declarations and subblocks for symbol table output.
561 If FUNCTIONBODY is nonzero, this level is the body of a function,
562 so create a block as if KEEP were set and also clear out all
565 If REVERSE is nonzero, reverse the order of decls before putting
566 them into the BLOCK. */
569 poplevel (int keep
, int reverse
, int functionbody
)
572 /* The chain of decls was accumulated in reverse order.
573 Put it into forward order, just for cleanliness. */
580 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
585 gcc_assert (current_binding_level
->kind
!= sk_class
586 && current_binding_level
->kind
!= sk_namespace
);
588 if (current_binding_level
->kind
== sk_cleanup
)
590 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
592 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
594 /* We used to use KEEP == 2 to indicate that the new block should go
595 at the beginning of the list of blocks at this binding level,
596 rather than the end. This hack is no longer used. */
597 gcc_assert (keep
== 0 || keep
== 1);
599 if (current_binding_level
->keep
)
602 /* Any uses of undefined labels, and any defined labels, now operate
603 under constraints of next binding contour. */
604 if (cfun
&& !functionbody
&& named_labels
)
605 named_labels
->traverse
<cp_binding_level
*, poplevel_named_label_1
>
606 (current_binding_level
);
608 /* Get the decls in the order they were written.
609 Usually current_binding_level->names is in reverse order.
610 But parameter decls were previously put in forward order. */
612 decls
= current_binding_level
->names
;
615 decls
= nreverse (decls
);
616 current_binding_level
->names
= decls
;
619 /* If there were any declarations or structure tags in that level,
620 or if this level is a function body,
621 create a BLOCK to record them for the life of this function. */
623 /* Avoid function body block if possible. */
624 if (functionbody
&& subblocks
&& BLOCK_CHAIN (subblocks
) == NULL_TREE
)
626 else if (keep
== 1 || functionbody
)
627 block
= make_node (BLOCK
);
628 if (block
!= NULL_TREE
)
630 BLOCK_VARS (block
) = decls
;
631 BLOCK_SUBBLOCKS (block
) = subblocks
;
634 /* In each subblock, record that this is its superior. */
636 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
637 BLOCK_SUPERCONTEXT (link
) = block
;
639 /* Before we remove the declarations first check for unused variables. */
640 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
641 && current_binding_level
->kind
!= sk_template_parms
642 && !processing_template_decl
)
643 for (tree d
= get_local_decls (); d
; d
= TREE_CHAIN (d
))
645 /* There are cases where D itself is a TREE_LIST. See in
646 push_local_binding where the list of decls returned by
647 getdecls is built. */
648 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
650 tree type
= TREE_TYPE (decl
);
652 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
653 && ! DECL_IN_SYSTEM_HEADER (decl
)
654 /* For structured bindings, consider only real variables, not
656 && (DECL_DECOMPOSITION_P (decl
) ? !DECL_DECOMP_BASE (decl
)
657 : (DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
)))
658 && type
!= error_mark_node
659 && (!CLASS_TYPE_P (type
)
660 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
661 || lookup_attribute ("warn_unused",
662 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
664 if (! TREE_USED (decl
))
666 if (!DECL_NAME (decl
) && DECL_DECOMPOSITION_P (decl
))
667 warning_at (DECL_SOURCE_LOCATION (decl
),
668 OPT_Wunused_variable
,
669 "unused structured binding declaration");
671 warning_at (DECL_SOURCE_LOCATION (decl
),
672 OPT_Wunused_variable
, "unused variable %qD", decl
);
674 else if (DECL_CONTEXT (decl
) == current_function_decl
675 // For -Wunused-but-set-variable leave references alone.
676 && !TYPE_REF_P (TREE_TYPE (decl
))
677 && errorcount
== unused_but_set_errorcount
)
679 if (!DECL_NAME (decl
) && DECL_DECOMPOSITION_P (decl
))
680 warning_at (DECL_SOURCE_LOCATION (decl
),
681 OPT_Wunused_but_set_variable
, "structured "
682 "binding declaration set but not used");
684 warning_at (DECL_SOURCE_LOCATION (decl
),
685 OPT_Wunused_but_set_variable
,
686 "variable %qD set but not used", decl
);
687 unused_but_set_errorcount
= errorcount
;
692 /* Remove declarations for all the DECLs in this level. */
693 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
695 decl
= TREE_CODE (link
) == TREE_LIST
? TREE_VALUE (link
) : link
;
696 tree name
= OVL_NAME (decl
);
698 /* Remove the binding. */
699 if (TREE_CODE (decl
) == LABEL_DECL
)
700 pop_local_label (name
, decl
);
702 pop_local_binding (name
, decl
);
705 /* Restore the IDENTIFIER_TYPE_VALUEs. */
706 for (link
= current_binding_level
->type_shadowed
;
707 link
; link
= TREE_CHAIN (link
))
708 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
710 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
711 list if a `using' declaration put them there. The debugging
712 back ends won't understand OVERLOAD, so we remove them here.
713 Because the BLOCK_VARS are (temporarily) shared with
714 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
715 popped all the bindings. Also remove undeduced 'auto' decls,
716 which LTO doesn't understand, and can't have been used by anything. */
721 for (d
= &BLOCK_VARS (block
); *d
; )
723 if (TREE_CODE (*d
) == TREE_LIST
724 || (!processing_template_decl
725 && undeduced_auto_decl (*d
)))
726 *d
= TREE_CHAIN (*d
);
728 d
= &DECL_CHAIN (*d
);
732 /* If the level being exited is the top level of a function,
733 check over all the labels. */
738 /* Since this is the top level block of a function, the vars are
739 the function's parameters. Don't leave them in the BLOCK
740 because they are found in the FUNCTION_DECL instead. */
741 BLOCK_VARS (block
) = 0;
745 pop_labels (subblocks
);
748 kind
= current_binding_level
->kind
;
749 if (kind
== sk_cleanup
)
753 /* If this is a temporary binding created for a cleanup, then we'll
754 have pushed a statement list level. Pop that, create a new
755 BIND_EXPR for the block, and insert it into the stream. */
756 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
757 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
764 /* The current function is being defined, so its DECL_INITIAL
765 should be error_mark_node. */
766 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
767 DECL_INITIAL (current_function_decl
) = block
? block
: subblocks
;
770 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
772 if (BLOCK_SUBBLOCKS (subblocks
))
773 BLOCK_OUTER_CURLY_BRACE_P (BLOCK_SUBBLOCKS (subblocks
)) = 1;
776 BLOCK_OUTER_CURLY_BRACE_P (subblocks
) = 1;
780 current_binding_level
->blocks
781 = block_chainon (current_binding_level
->blocks
, block
);
783 /* If we did not make a block for the level just exited,
784 any blocks made for inner levels
785 (since they cannot be recorded as subblocks in that level)
786 must be carried forward so they will later become subblocks
787 of something else. */
789 current_binding_level
->blocks
790 = block_chainon (current_binding_level
->blocks
, subblocks
);
792 /* Each and every BLOCK node created here in `poplevel' is important
793 (e.g. for proper debugging information) so if we created one
794 earlier, mark it as "used". */
796 TREE_USED (block
) = 1;
798 /* All temporary bindings created for cleanups are popped silently. */
799 if (kind
== sk_cleanup
)
802 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
806 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
807 /* Diagnose odr-used extern inline variables without definitions
808 in the current TU. */
811 wrapup_namespace_globals ()
813 if (vec
<tree
, va_gc
> *statics
= static_decls
)
817 FOR_EACH_VEC_ELT (*statics
, i
, decl
)
819 if (warn_unused_function
820 && TREE_CODE (decl
) == FUNCTION_DECL
821 && DECL_INITIAL (decl
) == 0
822 && DECL_EXTERNAL (decl
)
823 && !TREE_PUBLIC (decl
)
824 && !DECL_ARTIFICIAL (decl
)
825 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl
)
826 && !TREE_NO_WARNING (decl
))
827 warning_at (DECL_SOURCE_LOCATION (decl
),
828 OPT_Wunused_function
,
829 "%qF declared %<static%> but never defined", decl
);
832 && DECL_EXTERNAL (decl
)
833 && DECL_INLINE_VAR_P (decl
)
834 && DECL_ODR_USED (decl
))
835 error_at (DECL_SOURCE_LOCATION (decl
),
836 "odr-used inline variable %qD is not defined", decl
);
839 /* Clear out the list, so we don't rescan next time. */
842 /* Write out any globals that need to be output. */
843 return wrapup_global_declarations (statics
->address (),
849 /* In C++, you don't have to write `struct S' to refer to `S'; you
850 can just use `S'. We accomplish this by creating a TYPE_DECL as
851 if the user had written `typedef struct S S'. Create and return
852 the TYPE_DECL for TYPE. */
855 create_implicit_typedef (tree name
, tree type
)
859 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
860 DECL_ARTIFICIAL (decl
) = 1;
861 /* There are other implicit type declarations, like the one *within*
862 a class that allows you to write `S::S'. We must distinguish
864 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
865 TYPE_NAME (type
) = decl
;
866 TYPE_STUB_DECL (type
) = decl
;
871 /* Function-scope local entities that need discriminators. Each entry
872 is a {decl,name} pair. VAR_DECLs for anon unions get their name
873 smashed, so we cannot rely on DECL_NAME. */
875 static GTY((deletable
)) vec
<tree
, va_gc
> *local_entities
;
877 /* Determine the mangling discriminator of local DECL. There are
878 generally very few of these in any particular function. */
881 determine_local_discriminator (tree decl
)
883 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
884 retrofit_lang_decl (decl
);
885 tree ctx
= DECL_CONTEXT (decl
);
886 tree name
= (TREE_CODE (decl
) == TYPE_DECL
887 && TYPE_UNNAMED_P (TREE_TYPE (decl
))
888 ? NULL_TREE
: DECL_NAME (decl
));
889 size_t nelts
= vec_safe_length (local_entities
);
890 for (size_t i
= 0; i
< nelts
; i
+= 2)
892 tree
*pair
= &(*local_entities
)[i
];
895 gcc_checking_assert (d
!= decl
);
897 && TREE_CODE (decl
) == TREE_CODE (d
)
898 && ctx
== DECL_CONTEXT (d
))
900 tree disc
= integer_one_node
;
901 if (DECL_DISCRIMINATOR (d
))
902 disc
= build_int_cst (TREE_TYPE (disc
),
903 TREE_INT_CST_LOW (DECL_DISCRIMINATOR (d
)) + 1);
904 DECL_DISCRIMINATOR (decl
) = disc
;
905 /* Replace the saved decl. */
914 vec_safe_reserve (local_entities
, 2);
915 local_entities
->quick_push (decl
);
916 local_entities
->quick_push (name
);
919 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
923 /* Subroutine of duplicate_decls: return truthvalue of whether
924 or not types of these decls match.
926 For C++, we must compare the parameter list so that `int' can match
927 `int&' in a parameter position, but `int&' is not confused with
931 decls_match (tree newdecl
, tree olddecl
, bool record_versions
/* = true */)
935 if (newdecl
== olddecl
)
938 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
939 /* If the two DECLs are not even the same kind of thing, we're not
940 interested in their types. */
943 gcc_assert (DECL_P (newdecl
));
945 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
947 tree f1
= TREE_TYPE (newdecl
);
948 tree f2
= TREE_TYPE (olddecl
);
949 tree p1
= TYPE_ARG_TYPES (f1
);
950 tree p2
= TYPE_ARG_TYPES (f2
);
953 /* Specializations of different templates are different functions
954 even if they have the same type. */
955 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
956 ? DECL_TI_TEMPLATE (newdecl
)
958 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
959 ? DECL_TI_TEMPLATE (olddecl
)
964 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
965 && ! (DECL_EXTERN_C_P (newdecl
)
966 && DECL_EXTERN_C_P (olddecl
)))
969 /* A new declaration doesn't match a built-in one unless it
970 is also extern "C". */
971 if (DECL_IS_BUILTIN (olddecl
)
972 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
975 if (TREE_CODE (f1
) != TREE_CODE (f2
))
978 /* A declaration with deduced return type should use its pre-deduction
979 type for declaration matching. */
980 r2
= fndecl_declared_return_type (olddecl
);
982 if (same_type_p (TREE_TYPE (f1
), r2
))
984 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
985 && fndecl_built_in_p (olddecl
))
987 types_match
= self_promoting_args_p (p1
);
988 if (p1
== void_list_node
)
989 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
994 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
995 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
996 || comp_type_attributes (TREE_TYPE (newdecl
),
997 TREE_TYPE (olddecl
)) != 0);
1002 /* The decls dont match if they correspond to two different versions
1003 of the same function. Disallow extern "C" functions to be
1004 versions for now. */
1006 && !DECL_EXTERN_C_P (newdecl
)
1007 && !DECL_EXTERN_C_P (olddecl
)
1009 && maybe_version_functions (newdecl
, olddecl
,
1010 (!DECL_FUNCTION_VERSIONED (newdecl
)
1011 || !DECL_FUNCTION_VERSIONED (olddecl
))))
1014 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1016 tree oldres
= DECL_TEMPLATE_RESULT (olddecl
);
1017 tree newres
= DECL_TEMPLATE_RESULT (newdecl
);
1019 if (TREE_CODE (newres
) != TREE_CODE (oldres
))
1022 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1023 DECL_TEMPLATE_PARMS (olddecl
)))
1026 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1027 types_match
= (same_type_p (TREE_TYPE (oldres
), TREE_TYPE (newres
))
1028 && equivalently_constrained (olddecl
, newdecl
));
1030 // We don't need to check equivalently_constrained for variable and
1031 // function templates because we check it on the results.
1032 types_match
= decls_match (oldres
, newres
);
1036 /* Need to check scope for variable declaration (VAR_DECL).
1037 For typedef (TYPE_DECL), scope is ignored. */
1039 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1041 Two declarations for an object with C language linkage
1042 with the same name (ignoring the namespace that qualify
1043 it) that appear in different namespace scopes refer to
1045 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1048 if (TREE_TYPE (newdecl
) == error_mark_node
)
1049 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1050 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1051 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1052 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1055 types_match
= comptypes (TREE_TYPE (newdecl
),
1056 TREE_TYPE (olddecl
),
1057 COMPARE_REDECLARATION
);
1060 // Normal functions can be constrained, as can variable partial
1062 if (types_match
&& VAR_OR_FUNCTION_DECL_P (newdecl
))
1063 types_match
= equivalently_constrained (newdecl
, olddecl
);
1068 /* NEWDECL and OLDDECL have identical signatures. If they are
1069 different versions adjust them and return true.
1070 If RECORD is set to true, record function versions. */
1073 maybe_version_functions (tree newdecl
, tree olddecl
, bool record
)
1075 if (!targetm
.target_option
.function_versions (newdecl
, olddecl
))
1078 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1080 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1081 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1082 mangle_decl (olddecl
);
1085 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1087 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1088 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1089 mangle_decl (newdecl
);
1093 cgraph_node::record_function_versions (olddecl
, newdecl
);
1098 /* If NEWDECL is `static' and an `extern' was seen previously,
1099 warn about it. OLDDECL is the previous declaration.
1101 Note that this does not apply to the C++ case of declaring
1102 a variable `extern const' and then later `const'.
1104 Don't complain about built-in functions, since they are beyond
1105 the user's control. */
1108 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1110 if (TREE_CODE (newdecl
) == TYPE_DECL
1111 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1112 || TREE_CODE (newdecl
) == CONST_DECL
1113 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1116 /* Don't get confused by static member functions; that's a different
1118 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1119 && DECL_STATIC_FUNCTION_P (newdecl
))
1122 /* If the old declaration was `static', or the new one isn't, then
1123 everything is OK. */
1124 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1127 /* It's OK to declare a builtin function as `static'. */
1128 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1129 && DECL_ARTIFICIAL (olddecl
))
1132 auto_diagnostic_group d
;
1133 if (permerror (DECL_SOURCE_LOCATION (newdecl
),
1134 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1135 inform (DECL_SOURCE_LOCATION (olddecl
),
1136 "previous declaration of %qD", olddecl
);
1139 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1140 function templates. If their exception specifications do not
1141 match, issue a diagnostic. */
1144 check_redeclaration_exception_specification (tree new_decl
,
1147 tree new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1148 tree old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1150 /* Two default specs are equivalent, don't force evaluation. */
1151 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions
)
1152 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions
))
1155 if (!type_dependent_expression_p (old_decl
))
1157 maybe_instantiate_noexcept (new_decl
);
1158 maybe_instantiate_noexcept (old_decl
);
1160 new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1161 old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1165 If any declaration of a function has an exception-specification,
1166 all declarations, including the definition and an explicit
1167 specialization, of that function shall have an
1168 exception-specification with the same set of type-ids. */
1169 if (! DECL_IS_BUILTIN (old_decl
)
1170 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1172 const char *const msg
1173 = G_("declaration of %qF has a different exception specifier");
1174 bool complained
= true;
1175 location_t new_loc
= DECL_SOURCE_LOCATION (new_decl
);
1176 auto_diagnostic_group d
;
1177 if (DECL_IN_SYSTEM_HEADER (old_decl
))
1178 complained
= pedwarn (new_loc
, OPT_Wsystem_headers
, msg
, new_decl
);
1179 else if (!flag_exceptions
)
1180 /* We used to silently permit mismatched eh specs with
1181 -fno-exceptions, so make them a pedwarn now. */
1182 complained
= pedwarn (new_loc
, OPT_Wpedantic
, msg
, new_decl
);
1184 error_at (new_loc
, msg
, new_decl
);
1186 inform (DECL_SOURCE_LOCATION (old_decl
),
1187 "from previous declaration %qF", old_decl
);
1191 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1192 Otherwise issue diagnostics. */
1195 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1197 old_decl
= STRIP_TEMPLATE (old_decl
);
1198 new_decl
= STRIP_TEMPLATE (new_decl
);
1199 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1200 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1202 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1203 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1205 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1207 if (fndecl_built_in_p (old_decl
))
1209 /* Hide a built-in declaration. */
1210 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1211 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1214 /* 7.1.5 [dcl.constexpr]
1215 Note: An explicit specialization can differ from the template
1216 declaration with respect to the constexpr specifier. */
1217 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1218 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1221 error_at (DECL_SOURCE_LOCATION (new_decl
),
1222 "redeclaration %qD differs in %<constexpr%> "
1223 "from previous declaration", new_decl
);
1224 inform (DECL_SOURCE_LOCATION (old_decl
),
1225 "previous declaration %qD", old_decl
);
1231 // If OLDDECL and NEWDECL are concept declarations with the same type
1232 // (i.e., and template parameters), but different requirements,
1233 // emit diagnostics and return true. Otherwise, return false.
1235 check_concept_refinement (tree olddecl
, tree newdecl
)
1237 if (!DECL_DECLARED_CONCEPT_P (olddecl
) || !DECL_DECLARED_CONCEPT_P (newdecl
))
1240 tree d1
= DECL_TEMPLATE_RESULT (olddecl
);
1241 tree d2
= DECL_TEMPLATE_RESULT (newdecl
);
1242 if (TREE_CODE (d1
) != TREE_CODE (d2
))
1245 tree t1
= TREE_TYPE (d1
);
1246 tree t2
= TREE_TYPE (d2
);
1247 if (TREE_CODE (d1
) == FUNCTION_DECL
)
1249 if (compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
))
1250 && comp_template_parms (DECL_TEMPLATE_PARMS (olddecl
),
1251 DECL_TEMPLATE_PARMS (newdecl
))
1252 && !equivalently_constrained (olddecl
, newdecl
))
1254 error ("cannot specialize concept %q#D", olddecl
);
1261 /* DECL is a redeclaration of a function or function template. If
1262 it does have default arguments issue a diagnostic. Note: this
1263 function is used to enforce the requirements in C++11 8.3.6 about
1264 no default arguments in redeclarations. */
1267 check_redeclaration_no_default_args (tree decl
)
1269 gcc_assert (DECL_DECLARES_FUNCTION_P (decl
));
1271 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
1272 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1273 if (TREE_PURPOSE (t
))
1275 permerror (DECL_SOURCE_LOCATION (decl
),
1276 "redeclaration of %q#D may not have default "
1282 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1283 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1284 the TEMPLATE_DECLs in case of function templates). This function is used
1285 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1286 "If a friend declaration specifies a default argument expression, that
1287 declaration shall be a definition and shall be the only declaration of
1288 the function or function template in the translation unit." */
1291 check_no_redeclaration_friend_default_args (tree olddecl
, tree newdecl
,
1292 bool olddecl_hidden_friend_p
)
1294 if (!olddecl_hidden_friend_p
&& !DECL_FRIEND_P (newdecl
))
1297 tree t1
= FUNCTION_FIRST_USER_PARMTYPE (olddecl
);
1298 tree t2
= FUNCTION_FIRST_USER_PARMTYPE (newdecl
);
1300 for (; t1
&& t1
!= void_list_node
;
1301 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1302 if ((olddecl_hidden_friend_p
&& TREE_PURPOSE (t1
))
1303 || (DECL_FRIEND_P (newdecl
) && TREE_PURPOSE (t2
)))
1305 auto_diagnostic_group d
;
1306 if (permerror (DECL_SOURCE_LOCATION (newdecl
),
1307 "friend declaration of %q#D specifies default "
1308 "arguments and isn't the only declaration", newdecl
))
1309 inform (DECL_SOURCE_LOCATION (olddecl
),
1310 "previous declaration of %q#D", olddecl
);
1315 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1316 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1319 merge_attribute_bits (tree newdecl
, tree olddecl
)
1321 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1322 TREE_THIS_VOLATILE (olddecl
) |= TREE_THIS_VOLATILE (newdecl
);
1323 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
1324 TREE_NOTHROW (olddecl
) |= TREE_NOTHROW (newdecl
);
1325 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
1326 TREE_READONLY (olddecl
) |= TREE_READONLY (newdecl
);
1327 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1328 DECL_IS_MALLOC (olddecl
) |= DECL_IS_MALLOC (newdecl
);
1329 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
1330 DECL_PURE_P (olddecl
) |= DECL_PURE_P (newdecl
);
1331 DECL_UNINLINABLE (newdecl
) |= DECL_UNINLINABLE (olddecl
);
1332 DECL_UNINLINABLE (olddecl
) |= DECL_UNINLINABLE (newdecl
);
1335 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1336 && lookup_attribute ("gnu_inline", \
1337 DECL_ATTRIBUTES (fn)))
1339 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1340 If the redeclaration is invalid, a diagnostic is issued, and the
1341 error_mark_node is returned. Otherwise, OLDDECL is returned.
1343 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1346 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1349 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1351 unsigned olddecl_uid
= DECL_UID (olddecl
);
1352 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1353 int olddecl_hidden_friend
= 0;
1354 int new_defines_function
= 0;
1355 tree new_template_info
;
1356 location_t olddecl_loc
= DECL_SOURCE_LOCATION (olddecl
);
1357 location_t newdecl_loc
= DECL_SOURCE_LOCATION (newdecl
);
1359 if (newdecl
== olddecl
)
1362 types_match
= decls_match (newdecl
, olddecl
);
1364 /* If either the type of the new decl or the type of the old decl is an
1365 error_mark_node, then that implies that we have already issued an
1366 error (earlier) for some bogus type specification, and in that case,
1367 it is rather pointless to harass the user with yet more error message
1368 about the same declaration, so just pretend the types match here. */
1369 if (TREE_TYPE (newdecl
) == error_mark_node
1370 || TREE_TYPE (olddecl
) == error_mark_node
)
1371 return error_mark_node
;
1373 /* Check for redeclaration and other discrepancies. */
1374 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1375 && DECL_ARTIFICIAL (olddecl
))
1377 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1378 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1380 /* Avoid warnings redeclaring built-ins which have not been
1381 explicitly declared. */
1382 if (DECL_ANTICIPATED (olddecl
))
1384 if (TREE_PUBLIC (newdecl
)
1385 && CP_DECL_CONTEXT (newdecl
) == global_namespace
)
1386 warning_at (newdecl_loc
,
1387 OPT_Wbuiltin_declaration_mismatch
,
1388 "built-in function %qD declared as non-function",
1393 /* If you declare a built-in or predefined function name as static,
1394 the old definition is overridden, but optionally warn this was a
1395 bad choice of name. */
1396 if (! TREE_PUBLIC (newdecl
))
1398 warning_at (newdecl_loc
,
1400 fndecl_built_in_p (olddecl
)
1401 ? G_("shadowing built-in function %q#D")
1402 : G_("shadowing library function %q#D"), olddecl
);
1403 /* Discard the old built-in function. */
1406 /* If the built-in is not ansi, then programs can override
1407 it even globally without an error. */
1408 else if (! fndecl_built_in_p (olddecl
))
1409 warning_at (newdecl_loc
, 0,
1410 "library function %q#D redeclared as non-function %q#D",
1413 error_at (newdecl_loc
,
1414 "declaration of %q#D conflicts with built-in "
1415 "declaration %q#D", newdecl
, olddecl
);
1418 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1420 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1421 error_at (newdecl_loc
,
1422 "redeclaration of %<pragma omp declare reduction%>");
1423 inform (olddecl_loc
,
1424 "previous %<pragma omp declare reduction%> declaration");
1425 return error_mark_node
;
1427 else if (!types_match
)
1429 /* Avoid warnings redeclaring built-ins which have not been
1430 explicitly declared. */
1431 if (DECL_ANTICIPATED (olddecl
))
1435 /* A new declaration doesn't match a built-in one unless it
1436 is also extern "C". */
1437 gcc_assert (DECL_IS_BUILTIN (olddecl
));
1438 gcc_assert (DECL_EXTERN_C_P (olddecl
));
1439 if (!DECL_EXTERN_C_P (newdecl
))
1442 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1443 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1445 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1449 /* FILE, tm types are not known at the time
1450 we create the builtins. */
1451 for (unsigned i
= 0;
1452 i
< sizeof (builtin_structptr_types
)
1453 / sizeof (builtin_structptr_type
);
1455 if (TREE_VALUE (t2
) == builtin_structptr_types
[i
].node
)
1457 tree t
= TREE_VALUE (t1
);
1460 && TYPE_IDENTIFIER (TREE_TYPE (t
))
1461 == get_identifier (builtin_structptr_types
[i
].str
)
1462 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1464 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1466 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1467 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1468 types_match
= decls_match (newdecl
, olddecl
);
1470 return duplicate_decls (newdecl
, olddecl
,
1472 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1477 if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1482 warning_at (newdecl_loc
,
1483 OPT_Wbuiltin_declaration_mismatch
,
1484 "declaration of %q#D conflicts with built-in "
1485 "declaration %q#D", newdecl
, olddecl
);
1487 else if ((DECL_EXTERN_C_P (newdecl
)
1488 && DECL_EXTERN_C_P (olddecl
))
1489 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1490 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1492 /* Don't really override olddecl for __* prefixed builtins
1493 except for __[^b]*_chk, the compiler might be using those
1495 if (fndecl_built_in_p (olddecl
))
1497 tree id
= DECL_NAME (olddecl
);
1498 const char *name
= IDENTIFIER_POINTER (id
);
1503 && (strncmp (name
+ 2, "builtin_",
1504 strlen ("builtin_")) == 0
1505 || (len
= strlen (name
)) <= strlen ("___chk")
1506 || memcmp (name
+ len
- strlen ("_chk"),
1507 "_chk", strlen ("_chk") + 1) != 0))
1509 if (DECL_INITIAL (newdecl
))
1511 error_at (newdecl_loc
,
1512 "definition of %q#D ambiguates built-in "
1513 "declaration %q#D", newdecl
, olddecl
);
1514 return error_mark_node
;
1516 auto_diagnostic_group d
;
1517 if (permerror (newdecl_loc
,
1518 "new declaration %q#D ambiguates built-in"
1519 " declaration %q#D", newdecl
, olddecl
)
1521 inform (newdecl_loc
,
1522 "ignoring the %q#D declaration", newdecl
);
1523 return flag_permissive
? olddecl
: error_mark_node
;
1527 /* A near match; override the builtin. */
1529 if (TREE_PUBLIC (newdecl
))
1530 warning_at (newdecl_loc
,
1531 OPT_Wbuiltin_declaration_mismatch
,
1532 "new declaration %q#D ambiguates built-in "
1533 "declaration %q#D", newdecl
, olddecl
);
1535 warning (OPT_Wshadow
,
1536 fndecl_built_in_p (olddecl
)
1537 ? G_("shadowing built-in function %q#D")
1538 : G_("shadowing library function %q#D"), olddecl
);
1541 /* Discard the old built-in function. */
1544 /* Replace the old RTL to avoid problems with inlining. */
1545 COPY_DECL_RTL (newdecl
, olddecl
);
1547 /* Even if the types match, prefer the new declarations type for
1548 built-ins which have not been explicitly declared, for
1549 exception lists, etc... */
1550 else if (DECL_IS_BUILTIN (olddecl
))
1552 tree type
= TREE_TYPE (newdecl
);
1553 tree attribs
= (*targetm
.merge_type_attributes
)
1554 (TREE_TYPE (olddecl
), type
);
1556 type
= cp_build_type_attribute_variant (type
, attribs
);
1557 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1560 /* If a function is explicitly declared "throw ()", propagate that to
1561 the corresponding builtin. */
1562 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1563 && DECL_ANTICIPATED (olddecl
)
1564 && TREE_NOTHROW (newdecl
)
1565 && !TREE_NOTHROW (olddecl
))
1567 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1568 tree tmpdecl
= builtin_decl_explicit (fncode
);
1569 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1570 TREE_NOTHROW (tmpdecl
) = 1;
1573 /* Whether or not the builtin can throw exceptions has no
1574 bearing on this declarator. */
1575 TREE_NOTHROW (olddecl
) = 0;
1577 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1579 /* If a builtin function is redeclared as `static', merge
1580 the declarations, but make the original one static. */
1581 DECL_THIS_STATIC (olddecl
) = 1;
1582 TREE_PUBLIC (olddecl
) = 0;
1584 /* Make the old declaration consistent with the new one so
1585 that all remnants of the builtin-ness of this function
1586 will be banished. */
1587 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1588 COPY_DECL_RTL (newdecl
, olddecl
);
1591 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1593 /* C++ Standard, 3.3, clause 4:
1594 "[Note: a namespace name or a class template name must be unique
1595 in its declarative region (7.3.2, clause 14). ]" */
1596 if (TREE_CODE (olddecl
) == NAMESPACE_DECL
1597 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1598 /* Namespace conflicts with not namespace. */;
1599 else if (DECL_TYPE_TEMPLATE_P (olddecl
)
1600 || DECL_TYPE_TEMPLATE_P (newdecl
))
1601 /* Class template conflicts. */;
1602 else if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1603 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1604 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1605 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1607 /* One is a function and the other is a template
1609 if (!UDLIT_OPER_P (DECL_NAME (newdecl
)))
1612 /* There can only be one! */
1613 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1614 && check_raw_literal_operator (olddecl
))
1615 error_at (newdecl_loc
,
1616 "literal operator %q#D conflicts with"
1617 " raw literal operator", newdecl
);
1618 else if (check_raw_literal_operator (newdecl
))
1619 error_at (newdecl_loc
,
1620 "raw literal operator %q#D conflicts with"
1621 " literal operator template", newdecl
);
1625 inform (olddecl_loc
, "previous declaration %q#D", olddecl
);
1626 return error_mark_node
;
1628 else if (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1629 || DECL_IMPLICIT_TYPEDEF_P (newdecl
))
1630 /* One is an implicit typedef, that's ok. */
1633 error ("%q#D redeclared as different kind of entity", newdecl
);
1634 inform (olddecl_loc
, "previous declaration %q#D", olddecl
);
1636 return error_mark_node
;
1638 else if (!types_match
)
1640 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1641 /* These are certainly not duplicate declarations; they're
1642 from different scopes. */
1645 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1647 /* The name of a class template may not be declared to refer to
1648 any other template, class, function, object, namespace, value,
1649 or type in the same scope. */
1650 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1651 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1653 error_at (newdecl_loc
,
1654 "conflicting declaration of template %q#D", newdecl
);
1655 inform (olddecl_loc
,
1656 "previous declaration %q#D", olddecl
);
1657 return error_mark_node
;
1659 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1660 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1661 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1662 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1663 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1664 DECL_TEMPLATE_PARMS (olddecl
))
1665 /* Template functions can be disambiguated by
1667 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1668 TREE_TYPE (TREE_TYPE (olddecl
)))
1669 /* Template functions can also be disambiguated by
1671 && equivalently_constrained (olddecl
, newdecl
))
1673 error_at (newdecl_loc
, "ambiguating new declaration %q#D",
1675 inform (olddecl_loc
,
1676 "old declaration %q#D", olddecl
);
1678 else if (check_concept_refinement (olddecl
, newdecl
))
1679 return error_mark_node
;
1682 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1684 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1686 error_at (newdecl_loc
,
1687 "conflicting declaration of C function %q#D",
1689 inform (olddecl_loc
,
1690 "previous declaration %q#D", olddecl
);
1693 /* For function versions, params and types match, but they
1694 are not ambiguous. */
1695 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1696 && !DECL_FUNCTION_VERSIONED (olddecl
))
1697 // The functions have the same parameter types.
1698 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1699 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)))
1700 // And the same constraints.
1701 && equivalently_constrained (newdecl
, olddecl
))
1703 error_at (newdecl_loc
,
1704 "ambiguating new declaration of %q#D", newdecl
);
1705 inform (olddecl_loc
,
1706 "old declaration %q#D", olddecl
);
1707 return error_mark_node
;
1714 error_at (newdecl_loc
, "conflicting declaration %q#D", newdecl
);
1715 inform (olddecl_loc
,
1716 "previous declaration as %q#D", olddecl
);
1717 return error_mark_node
;
1720 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1721 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1722 && (!DECL_TEMPLATE_INFO (newdecl
)
1723 || (DECL_TI_TEMPLATE (newdecl
)
1724 != DECL_TI_TEMPLATE (olddecl
))))
1725 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1726 && (!DECL_TEMPLATE_INFO (olddecl
)
1727 || (DECL_TI_TEMPLATE (olddecl
)
1728 != DECL_TI_TEMPLATE (newdecl
))))))
1729 /* It's OK to have a template specialization and a non-template
1730 with the same type, or to have specializations of two
1731 different templates with the same type. Note that if one is a
1732 specialization, and the other is an instantiation of the same
1733 template, that we do not exit at this point. That situation
1734 can occur if we instantiate a template class, and then
1735 specialize one of its methods. This situation is valid, but
1736 the declarations must be merged in the usual way. */
1738 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1739 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1740 && !DECL_USE_TEMPLATE (newdecl
))
1741 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1742 && !DECL_USE_TEMPLATE (olddecl
))))
1743 /* One of the declarations is a template instantiation, and the
1744 other is not a template at all. That's OK. */
1746 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1748 /* In [namespace.alias] we have:
1750 In a declarative region, a namespace-alias-definition can be
1751 used to redefine a namespace-alias declared in that declarative
1752 region to refer only to the namespace to which it already
1755 Therefore, if we encounter a second alias directive for the same
1756 alias, we can just ignore the second directive. */
1757 if (DECL_NAMESPACE_ALIAS (newdecl
)
1758 && (DECL_NAMESPACE_ALIAS (newdecl
)
1759 == DECL_NAMESPACE_ALIAS (olddecl
)))
1762 /* Leave it to update_binding to merge or report error. */
1767 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1770 auto_diagnostic_group d
;
1771 error_at (newdecl_loc
, errmsg
, newdecl
);
1772 if (DECL_NAME (olddecl
) != NULL_TREE
)
1773 inform (olddecl_loc
,
1774 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1775 ? G_("%q#D previously defined here")
1776 : G_("%q#D previously declared here"), olddecl
);
1777 return error_mark_node
;
1779 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1780 && DECL_INITIAL (olddecl
) != NULL_TREE
1781 && !prototype_p (TREE_TYPE (olddecl
))
1782 && prototype_p (TREE_TYPE (newdecl
)))
1784 /* Prototype decl follows defn w/o prototype. */
1785 auto_diagnostic_group d
;
1786 if (warning_at (newdecl_loc
, 0,
1787 "prototype specified for %q#D", newdecl
))
1788 inform (olddecl_loc
,
1789 "previous non-prototype definition here");
1791 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1792 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1795 If two declarations of the same function or object
1796 specify different linkage-specifications ..., the program
1797 is ill-formed.... Except for functions with C++ linkage,
1798 a function declaration without a linkage specification
1799 shall not precede the first linkage specification for
1800 that function. A function can be declared without a
1801 linkage specification after an explicit linkage
1802 specification has been seen; the linkage explicitly
1803 specified in the earlier declaration is not affected by
1804 such a function declaration.
1806 DR 563 raises the question why the restrictions on
1807 functions should not also apply to objects. Older
1808 versions of G++ silently ignore the linkage-specification
1816 which is clearly wrong. Therefore, we now treat objects
1818 if (current_lang_depth () == 0)
1820 /* There is no explicit linkage-specification, so we use
1821 the linkage from the previous declaration. */
1822 retrofit_lang_decl (newdecl
);
1823 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1827 auto_diagnostic_group d
;
1828 error_at (newdecl_loc
,
1829 "conflicting declaration of %q#D with %qL linkage",
1830 newdecl
, DECL_LANGUAGE (newdecl
));
1831 inform (olddecl_loc
,
1832 "previous declaration with %qL linkage",
1833 DECL_LANGUAGE (olddecl
));
1837 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1839 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1841 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1842 if (DECL_FUNCTION_MEMBER_P (olddecl
)
1843 && (/* grokfndecl passes member function templates too
1844 as FUNCTION_DECLs. */
1845 DECL_TEMPLATE_INFO (olddecl
)
1847 Default arguments for a member function of a class
1848 template shall be specified on the initial declaration
1849 of the member function within the class template. */
1850 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl
))))
1851 check_redeclaration_no_default_args (newdecl
);
1854 tree t1
= FUNCTION_FIRST_USER_PARMTYPE (olddecl
);
1855 tree t2
= FUNCTION_FIRST_USER_PARMTYPE (newdecl
);
1858 for (; t1
&& t1
!= void_list_node
;
1859 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1860 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1862 if (simple_cst_equal (TREE_PURPOSE (t1
),
1863 TREE_PURPOSE (t2
)) == 1)
1865 auto_diagnostic_group d
;
1866 if (permerror (newdecl_loc
,
1867 "default argument given for parameter "
1868 "%d of %q#D", i
, newdecl
))
1869 inform (olddecl_loc
,
1870 "previous specification in %q#D here",
1875 auto_diagnostic_group d
;
1876 error_at (newdecl_loc
,
1877 "default argument given for parameter %d "
1878 "of %q#D", i
, newdecl
);
1879 inform (olddecl_loc
,
1880 "previous specification in %q#D here",
1885 /* C++17 11.3.6/4: "If a friend declaration specifies a default
1886 argument expression, that declaration... shall be the only
1887 declaration of the function or function template in the
1888 translation unit." */
1889 check_no_redeclaration_friend_default_args
1890 (olddecl
, newdecl
, DECL_HIDDEN_FRIEND_P (olddecl
));
1895 /* Do not merge an implicit typedef with an explicit one. In:
1899 typedef class A A __attribute__ ((foo));
1901 the attribute should apply only to the typedef. */
1902 if (TREE_CODE (olddecl
) == TYPE_DECL
1903 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1904 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1907 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1908 return error_mark_node
;
1910 /* We have committed to returning OLDDECL at this point. */
1912 /* If new decl is `static' and an `extern' was seen previously,
1914 warn_extern_redeclared_static (newdecl
, olddecl
);
1916 /* True to merge attributes between the declarations, false to
1917 set OLDDECL's attributes to those of NEWDECL (for template
1918 explicit specializations that specify their own attributes
1919 independent of those specified for the primary template). */
1920 const bool merge_attr
= (TREE_CODE (newdecl
) != FUNCTION_DECL
1921 || !DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1922 || DECL_TEMPLATE_SPECIALIZATION (olddecl
));
1924 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1926 if (merge_attr
&& diagnose_mismatched_attributes (olddecl
, newdecl
))
1927 inform (olddecl_loc
, DECL_INITIAL (olddecl
)
1928 ? G_("previous definition of %qD here")
1929 : G_("previous declaration of %qD here"), olddecl
);
1931 /* Now that functions must hold information normally held
1932 by field decls, there is extra work to do so that
1933 declaration information does not get destroyed during
1935 if (DECL_VINDEX (olddecl
))
1936 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1937 if (DECL_CONTEXT (olddecl
))
1938 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1939 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1940 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1941 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1942 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1943 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1944 DECL_FINAL_P (newdecl
) |= DECL_FINAL_P (olddecl
);
1945 DECL_OVERRIDE_P (newdecl
) |= DECL_OVERRIDE_P (olddecl
);
1946 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1947 if (DECL_OVERLOADED_OPERATOR_P (olddecl
))
1948 DECL_OVERLOADED_OPERATOR_CODE_RAW (newdecl
)
1949 = DECL_OVERLOADED_OPERATOR_CODE_RAW (olddecl
);
1950 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1952 /* Optionally warn about more than one declaration for the same
1953 name, but don't warn about a function declaration followed by a
1955 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1956 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1957 /* Don't warn about extern decl followed by definition. */
1958 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1959 /* Don't warn about friends, let add_friend take care of it. */
1960 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1961 /* Don't warn about declaration followed by specialization. */
1962 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1963 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1965 auto_diagnostic_group d
;
1966 if (warning_at (newdecl_loc
,
1967 OPT_Wredundant_decls
,
1968 "redundant redeclaration of %qD in same scope",
1970 inform (olddecl_loc
,
1971 "previous declaration of %qD", olddecl
);
1974 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1975 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1977 if (DECL_DELETED_FN (newdecl
))
1979 auto_diagnostic_group d
;
1980 error_at (newdecl_loc
, "deleted definition of %qD", newdecl
);
1981 inform (olddecl_loc
,
1982 "previous declaration of %qD", olddecl
);
1984 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1988 /* Deal with C++: must preserve virtual function table size. */
1989 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1991 tree newtype
= TREE_TYPE (newdecl
);
1992 tree oldtype
= TREE_TYPE (olddecl
);
1994 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1995 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1996 CLASSTYPE_FRIEND_CLASSES (newtype
)
1997 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1999 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
2002 /* Copy all the DECL_... slots specified in the new decl except for
2003 any that we copy here from the old type. */
2005 DECL_ATTRIBUTES (newdecl
)
2006 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
2008 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2010 if (DECL_DECLARES_FUNCTION_P (olddecl
))
2012 olddecl_friend
= DECL_FRIEND_P (olddecl
);
2013 olddecl_hidden_friend
= DECL_HIDDEN_FRIEND_P (olddecl
);
2014 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
2015 && DECL_HIDDEN_FRIEND_P (olddecl
)
2016 && newdecl_is_friend
);
2019 DECL_ANTICIPATED (olddecl
) = 0;
2020 DECL_HIDDEN_FRIEND_P (olddecl
) = 0;
2024 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2026 tree old_result
= DECL_TEMPLATE_RESULT (olddecl
);
2027 tree new_result
= DECL_TEMPLATE_RESULT (newdecl
);
2028 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
2029 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
2030 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
2031 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 for (tree t
= TYPE_MAIN_VARIANT (remove
); ;
2136 t
= TYPE_NEXT_VARIANT (t
))
2137 if (TYPE_NEXT_VARIANT (t
) == remove
)
2139 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (remove
);
2144 else if (merge_attr
)
2145 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
2147 newtype
= TREE_TYPE (newdecl
);
2149 if (VAR_P (newdecl
))
2151 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
2152 /* For already initialized vars, TREE_READONLY could have been
2153 cleared in cp_finish_decl, because the var needs runtime
2154 initialization or destruction. Make sure not to set
2155 TREE_READONLY on it again. */
2156 if (DECL_INITIALIZED_P (olddecl
)
2157 && !DECL_EXTERNAL (olddecl
)
2158 && !TREE_READONLY (olddecl
))
2159 TREE_READONLY (newdecl
) = 0;
2160 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
2161 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
2162 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
2163 if (DECL_DEPENDENT_INIT_P (olddecl
))
2164 SET_DECL_DEPENDENT_INIT_P (newdecl
, true);
2165 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
2166 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
2167 if (DECL_CLASS_SCOPE_P (olddecl
))
2168 DECL_DECLARED_CONSTEXPR_P (newdecl
)
2169 |= DECL_DECLARED_CONSTEXPR_P (olddecl
);
2171 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2172 if (DECL_LANG_SPECIFIC (olddecl
)
2173 && CP_DECL_THREADPRIVATE_P (olddecl
))
2175 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2176 retrofit_lang_decl (newdecl
);
2177 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
2181 /* An explicit specialization of a function template or of a member
2182 function of a class template can be declared transaction_safe
2183 independently of whether the corresponding template entity is declared
2184 transaction_safe. */
2185 if (flag_tm
&& TREE_CODE (newdecl
) == FUNCTION_DECL
2186 && DECL_TEMPLATE_INSTANTIATION (olddecl
)
2187 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2188 && tx_safe_fn_type_p (newtype
)
2189 && !tx_safe_fn_type_p (TREE_TYPE (newdecl
)))
2190 newtype
= tx_unsafe_fn_variant (newtype
);
2192 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
2194 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2195 check_default_args (newdecl
);
2197 /* Lay the type out, unless already done. */
2198 if (! same_type_p (newtype
, oldtype
)
2199 && TREE_TYPE (newdecl
) != error_mark_node
2200 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2201 layout_type (TREE_TYPE (newdecl
));
2203 if ((VAR_P (newdecl
)
2204 || TREE_CODE (newdecl
) == PARM_DECL
2205 || TREE_CODE (newdecl
) == RESULT_DECL
2206 || TREE_CODE (newdecl
) == FIELD_DECL
2207 || TREE_CODE (newdecl
) == TYPE_DECL
)
2208 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2209 layout_decl (newdecl
, 0);
2211 /* Merge deprecatedness. */
2212 if (TREE_DEPRECATED (newdecl
))
2213 TREE_DEPRECATED (olddecl
) = 1;
2215 /* Preserve function specific target and optimization options */
2216 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2218 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2219 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2220 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2221 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2223 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2224 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2225 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2226 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2230 /* Merge the const type qualifier. */
2231 if (TREE_READONLY (newdecl
))
2232 TREE_READONLY (olddecl
) = 1;
2233 /* Merge the volatile type qualifier. */
2234 if (TREE_THIS_VOLATILE (newdecl
))
2235 TREE_THIS_VOLATILE (olddecl
) = 1;
2238 /* Merge the initialization information. */
2239 if (DECL_INITIAL (newdecl
) == NULL_TREE
2240 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2242 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2243 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2244 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2246 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2247 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2251 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2253 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2254 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2255 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2256 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2257 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2258 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2261 merge_attribute_bits (newdecl
, olddecl
);
2264 /* Merge the noreturn bit. */
2265 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2266 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2267 TREE_NOTHROW (olddecl
) = TREE_NOTHROW (newdecl
);
2268 DECL_IS_MALLOC (olddecl
) = DECL_IS_MALLOC (newdecl
);
2269 DECL_PURE_P (olddecl
) = DECL_PURE_P (newdecl
);
2271 /* Keep the old RTL. */
2272 COPY_DECL_RTL (olddecl
, newdecl
);
2274 else if (VAR_P (newdecl
)
2275 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2277 /* Keep the old RTL. We cannot keep the old RTL if the old
2278 declaration was for an incomplete object and the new
2279 declaration is not since many attributes of the RTL will
2281 COPY_DECL_RTL (olddecl
, newdecl
);
2284 /* If cannot merge, then use the new type and qualifiers,
2285 and don't preserve the old rtl. */
2288 /* Clean out any memory we had of the old declaration. */
2289 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2291 TREE_VALUE (oldstatic
) = error_mark_node
;
2293 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2294 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2295 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2296 TREE_NOTHROW (olddecl
) = TREE_NOTHROW (newdecl
);
2297 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2300 /* Merge the storage class information. */
2301 merge_weak (newdecl
, olddecl
);
2303 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2304 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2305 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2306 if (! DECL_EXTERNAL (olddecl
))
2307 DECL_EXTERNAL (newdecl
) = 0;
2308 if (! DECL_COMDAT (olddecl
))
2309 DECL_COMDAT (newdecl
) = 0;
2311 new_template_info
= NULL_TREE
;
2312 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2314 bool new_redefines_gnu_inline
= false;
2316 if (new_defines_function
2317 && ((DECL_INTERFACE_KNOWN (olddecl
)
2318 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2319 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2320 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2321 == FUNCTION_DECL
))))
2325 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2326 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2328 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2331 if (!new_redefines_gnu_inline
)
2333 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2334 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2335 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2337 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2338 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2339 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2341 /* If the OLDDECL is an instantiation and/or specialization,
2342 then the NEWDECL must be too. But, it may not yet be marked
2343 as such if the caller has created NEWDECL, but has not yet
2344 figured out that it is a redeclaration. */
2345 if (!DECL_USE_TEMPLATE (newdecl
))
2346 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2348 /* Don't really know how much of the language-specific
2349 values we should copy from old to new. */
2350 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2351 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2352 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2353 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2355 if (LANG_DECL_HAS_MIN (newdecl
))
2357 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
2358 if (DECL_TEMPLATE_INFO (newdecl
))
2360 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2361 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2362 && DECL_TEMPLATE_SPECIALIZATION (newdecl
))
2363 /* Remember the presence of explicit specialization args. */
2364 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl
))
2365 = TINFO_USED_TEMPLATE_ID (new_template_info
);
2367 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2369 /* Only functions have these fields. */
2370 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2372 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2373 DECL_BEFRIENDING_CLASSES (newdecl
)
2374 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2375 DECL_BEFRIENDING_CLASSES (olddecl
));
2376 /* DECL_THUNKS is only valid for virtual functions,
2377 otherwise it is a DECL_FRIEND_CONTEXT. */
2378 if (DECL_VIRTUAL_P (newdecl
))
2379 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2381 /* Only variables have this field. */
2382 else if (VAR_P (newdecl
)
2383 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2384 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2387 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2391 /* Merge parameter attributes. */
2392 tree oldarg
, newarg
;
2393 for (oldarg
= DECL_ARGUMENTS(olddecl
), newarg
= DECL_ARGUMENTS(newdecl
);
2395 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
))
2397 DECL_ATTRIBUTES (newarg
)
2398 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2399 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2402 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2403 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2405 /* If newdecl is not a specialization, then it is not a
2406 template-related function at all. And that means that we
2407 should have exited above, returning 0. */
2408 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2410 if (DECL_ODR_USED (olddecl
))
2411 /* From [temp.expl.spec]:
2413 If a template, a member template or the member of a class
2414 template is explicitly specialized then that
2415 specialization shall be declared before the first use of
2416 that specialization that would cause an implicit
2417 instantiation to take place, in every translation unit in
2418 which such a use occurs. */
2419 error ("explicit specialization of %qD after first use",
2422 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2423 DECL_COMDAT (newdecl
) = (TREE_PUBLIC (newdecl
)
2424 && DECL_DECLARED_INLINE_P (newdecl
));
2426 /* Don't propagate visibility from the template to the
2427 specialization here. We'll do that in determine_visibility if
2429 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2431 /* [temp.expl.spec/14] We don't inline explicit specialization
2432 just because the primary template says so. */
2433 gcc_assert (!merge_attr
);
2435 DECL_DECLARED_INLINE_P (olddecl
)
2436 = DECL_DECLARED_INLINE_P (newdecl
);
2438 DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2439 = DECL_DISREGARD_INLINE_LIMITS (newdecl
);
2441 DECL_UNINLINABLE (olddecl
) = DECL_UNINLINABLE (newdecl
);
2443 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2445 /* Never inline re-defined extern inline functions.
2446 FIXME: this could be better handled by keeping both
2447 function as separate declarations. */
2448 DECL_UNINLINABLE (newdecl
) = 1;
2452 if (DECL_PENDING_INLINE_P (olddecl
))
2454 DECL_PENDING_INLINE_P (newdecl
) = 1;
2455 DECL_PENDING_INLINE_INFO (newdecl
)
2456 = DECL_PENDING_INLINE_INFO (olddecl
);
2458 else if (DECL_PENDING_INLINE_P (newdecl
))
2460 else if (DECL_SAVED_FUNCTION_DATA (newdecl
) == NULL
)
2461 DECL_SAVED_FUNCTION_DATA (newdecl
)
2462 = DECL_SAVED_FUNCTION_DATA (olddecl
);
2464 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2466 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2467 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2469 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2470 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2471 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2472 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2475 /* Preserve abstractness on cloned [cd]tors. */
2476 DECL_ABSTRACT_P (newdecl
) = DECL_ABSTRACT_P (olddecl
);
2478 /* Update newdecl's parms to point at olddecl. */
2479 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2480 parm
= DECL_CHAIN (parm
))
2481 DECL_CONTEXT (parm
) = olddecl
;
2485 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2486 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2487 COPY_DECL_RTL (newdecl
, olddecl
);
2489 if (! types_match
|| new_defines_function
)
2491 /* These need to be copied so that the names are available.
2492 Note that if the types do match, we'll preserve inline
2493 info and other bits, but if not, we won't. */
2494 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2495 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2497 /* If redeclaring a builtin function, it stays built in
2498 if newdecl is a gnu_inline definition, or if newdecl is just
2500 if (fndecl_built_in_p (olddecl
)
2501 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2503 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2504 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2505 /* If we're keeping the built-in definition, keep the rtl,
2506 regardless of declaration matches. */
2507 COPY_DECL_RTL (olddecl
, newdecl
);
2508 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2510 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2513 /* If a compatible prototype of these builtin functions
2514 is seen, assume the runtime implements it with the
2515 expected semantics. */
2516 case BUILT_IN_STPCPY
:
2517 if (builtin_decl_explicit_p (fncode
))
2518 set_builtin_decl_implicit_p (fncode
, true);
2521 if (builtin_decl_explicit_p (fncode
))
2522 set_builtin_decl_declared_p (fncode
, true);
2527 copy_attributes_to_builtin (newdecl
);
2529 if (new_defines_function
)
2530 /* If defining a function declared with other language
2531 linkage, use the previously declared language linkage. */
2532 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2533 else if (types_match
)
2535 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2536 /* Don't clear out the arguments if we're just redeclaring a
2538 if (DECL_ARGUMENTS (olddecl
))
2539 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2542 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2543 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2545 /* Now preserve various other info from the definition. */
2546 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2547 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2548 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2549 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2551 /* Warn about conflicting visibility specifications. */
2552 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2553 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2554 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2556 auto_diagnostic_group d
;
2557 if (warning_at (newdecl_loc
, OPT_Wattributes
,
2558 "%qD: visibility attribute ignored because it "
2559 "conflicts with previous declaration", newdecl
))
2560 inform (olddecl_loc
,
2561 "previous declaration of %qD", olddecl
);
2563 /* Choose the declaration which specified visibility. */
2564 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2566 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2567 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2569 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2570 so keep this behavior. */
2571 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2573 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2574 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2576 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2577 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2579 SET_DECL_ALIGN (newdecl
, DECL_ALIGN (olddecl
));
2580 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2582 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2583 if (DECL_WARN_IF_NOT_ALIGN (olddecl
)
2584 > DECL_WARN_IF_NOT_ALIGN (newdecl
))
2585 SET_DECL_WARN_IF_NOT_ALIGN (newdecl
,
2586 DECL_WARN_IF_NOT_ALIGN (olddecl
));
2587 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2588 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2590 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2591 with that from NEWDECL below. */
2592 if (DECL_LANG_SPECIFIC (olddecl
))
2594 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2595 != DECL_LANG_SPECIFIC (newdecl
));
2596 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2599 /* Merge the USED information. */
2600 if (TREE_USED (olddecl
))
2601 TREE_USED (newdecl
) = 1;
2602 else if (TREE_USED (newdecl
))
2603 TREE_USED (olddecl
) = 1;
2604 if (VAR_P (newdecl
))
2606 if (DECL_READ_P (olddecl
))
2607 DECL_READ_P (newdecl
) = 1;
2608 else if (DECL_READ_P (newdecl
))
2609 DECL_READ_P (olddecl
) = 1;
2611 if (DECL_PRESERVE_P (olddecl
))
2612 DECL_PRESERVE_P (newdecl
) = 1;
2613 else if (DECL_PRESERVE_P (newdecl
))
2614 DECL_PRESERVE_P (olddecl
) = 1;
2616 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2617 to olddecl and deleted. */
2618 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2619 && DECL_FUNCTION_VERSIONED (olddecl
))
2621 /* Set the flag for newdecl so that it gets copied to olddecl. */
2622 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2623 /* newdecl will be purged after copying to olddecl and is no longer
2625 cgraph_node::delete_function_version_by_decl (newdecl
);
2628 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2631 struct symtab_node
*snode
= symtab_node::get (olddecl
);
2633 function_size
= sizeof (struct tree_decl_common
);
2635 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2636 (char *) newdecl
+ sizeof (struct tree_common
),
2637 function_size
- sizeof (struct tree_common
));
2639 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2640 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2641 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2643 /* Preserve symtab node mapping. */
2644 olddecl
->decl_with_vis
.symtab_node
= snode
;
2646 if (new_template_info
)
2647 /* If newdecl is a template instantiation, it is possible that
2648 the following sequence of events has occurred:
2650 o A friend function was declared in a class template. The
2651 class template was instantiated.
2653 o The instantiation of the friend declaration was
2654 recorded on the instantiation list, and is newdecl.
2656 o Later, however, instantiate_class_template called pushdecl
2657 on the newdecl to perform name injection. But, pushdecl in
2658 turn called duplicate_decls when it discovered that another
2659 declaration of a global function with the same name already
2662 o Here, in duplicate_decls, we decided to clobber newdecl.
2664 If we're going to do that, we'd better make sure that
2665 olddecl, and not newdecl, is on the list of
2666 instantiations so that if we try to do the instantiation
2667 again we won't get the clobbered declaration. */
2668 reregister_specialization (newdecl
,
2674 size_t size
= tree_code_size (TREE_CODE (newdecl
));
2676 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2677 (char *) newdecl
+ sizeof (struct tree_common
),
2678 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2679 switch (TREE_CODE (newdecl
))
2689 struct symtab_node
*snode
= NULL
;
2692 && (TREE_STATIC (olddecl
) || TREE_PUBLIC (olddecl
)
2693 || DECL_EXTERNAL (olddecl
)))
2694 snode
= symtab_node::get (olddecl
);
2695 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2696 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2697 size
- sizeof (struct tree_decl_common
)
2698 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2699 if (VAR_P (newdecl
))
2700 olddecl
->decl_with_vis
.symtab_node
= snode
;
2704 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2705 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2706 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2707 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2712 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2714 if (DECL_EXTERNAL (olddecl
)
2715 || TREE_PUBLIC (olddecl
)
2716 || TREE_STATIC (olddecl
))
2718 /* Merge the section attribute.
2719 We want to issue an error if the sections conflict but that must be
2720 done later in decl_attributes since we are called before attributes
2722 if (DECL_SECTION_NAME (newdecl
) != NULL
)
2723 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2725 if (DECL_ONE_ONLY (newdecl
))
2727 struct symtab_node
*oldsym
, *newsym
;
2728 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2729 oldsym
= cgraph_node::get_create (olddecl
);
2731 oldsym
= varpool_node::get_create (olddecl
);
2732 newsym
= symtab_node::get (newdecl
);
2733 oldsym
->set_comdat_group (newsym
->get_comdat_group ());
2738 && CP_DECL_THREAD_LOCAL_P (newdecl
))
2740 CP_DECL_THREAD_LOCAL_P (olddecl
) = true;
2741 if (!processing_template_decl
)
2742 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2746 DECL_UID (olddecl
) = olddecl_uid
;
2748 DECL_FRIEND_P (olddecl
) = 1;
2751 DECL_ANTICIPATED (olddecl
) = 1;
2752 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2755 /* NEWDECL contains the merged attribute lists.
2756 Update OLDDECL to be the same. */
2757 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2759 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2760 so that encode_section_info has a chance to look at the new decl
2761 flags and attributes. */
2762 if (DECL_RTL_SET_P (olddecl
)
2763 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2765 && TREE_STATIC (olddecl
))))
2766 make_decl_rtl (olddecl
);
2768 /* The NEWDECL will no longer be needed. Because every out-of-class
2769 declaration of a member results in a call to duplicate_decls,
2770 freeing these nodes represents in a significant savings.
2772 Before releasing the node, be sore to remove function from symbol
2773 table that might have been inserted there to record comdat group.
2774 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2775 structure is shared in between newdecl and oldecl. */
2776 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2777 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2778 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2780 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2785 /* Remove the associated constraints for newdecl, if any, before
2786 reclaiming memory. */
2788 remove_constraints (newdecl
);
2795 /* Return zero if the declaration NEWDECL is valid
2796 when the declaration OLDDECL (assumed to be for the same name)
2797 has already been seen.
2798 Otherwise return an error message format string with a %s
2799 where the identifier should go. */
2802 redeclaration_error_message (tree newdecl
, tree olddecl
)
2804 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2806 /* Because C++ can put things into name space for free,
2807 constructs like "typedef struct foo { ... } foo"
2808 would look like an erroneous redeclaration. */
2809 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2812 return G_("redefinition of %q#D");
2814 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2816 /* If this is a pure function, its olddecl will actually be
2817 the original initialization to `0' (which we force to call
2818 abort()). Don't complain about redefinition in this case. */
2819 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2820 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2823 /* If both functions come from different namespaces, this is not
2824 a redeclaration - this is a conflict with a used function. */
2825 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2826 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2827 && ! decls_match (olddecl
, newdecl
))
2828 return G_("%qD conflicts with used function");
2830 /* We'll complain about linkage mismatches in
2831 warn_extern_redeclared_static. */
2833 /* Defining the same name twice is no good. */
2834 if (decl_defined_p (olddecl
)
2835 && decl_defined_p (newdecl
))
2837 if (DECL_NAME (olddecl
) == NULL_TREE
)
2838 return G_("%q#D not declared in class");
2839 else if (!GNU_INLINE_P (olddecl
)
2840 || GNU_INLINE_P (newdecl
))
2841 return G_("redefinition of %q#D");
2844 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2846 bool olda
= GNU_INLINE_P (olddecl
);
2847 bool newa
= GNU_INLINE_P (newdecl
);
2852 return G_("%q+D redeclared inline with "
2853 "%<gnu_inline%> attribute");
2855 return G_("%q+D redeclared inline without "
2856 "%<gnu_inline%> attribute");
2860 check_abi_tag_redeclaration
2861 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2862 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2866 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2870 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2872 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2873 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2874 return G_("redefinition of %q#D");
2878 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2879 || (DECL_TEMPLATE_RESULT (newdecl
)
2880 == DECL_TEMPLATE_RESULT (olddecl
)))
2883 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2884 if (DECL_TEMPLATE_INFO (nt
))
2885 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2886 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2887 if (DECL_TEMPLATE_INFO (ot
))
2888 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2889 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2890 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2891 return G_("redefinition of %q#D");
2893 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2895 bool olda
= GNU_INLINE_P (ot
);
2896 bool newa
= GNU_INLINE_P (nt
);
2901 return G_("%q+D redeclared inline with "
2902 "%<gnu_inline%> attribute");
2904 return G_("%q+D redeclared inline without "
2905 "%<gnu_inline%> attribute");
2909 /* Core issue #226 (C++0x):
2911 If a friend function template declaration specifies a
2912 default template-argument, that declaration shall be a
2913 definition and shall be the only declaration of the
2914 function template in the translation unit. */
2915 if ((cxx_dialect
!= cxx98
)
2916 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2917 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2918 /*is_primary=*/true,
2919 /*is_partial=*/false,
2920 /*is_friend_decl=*/2))
2921 return G_("redeclaration of friend %q#D "
2922 "may not have default template arguments");
2926 else if (VAR_P (newdecl
)
2927 && CP_DECL_THREAD_LOCAL_P (newdecl
) != CP_DECL_THREAD_LOCAL_P (olddecl
)
2928 && (! DECL_LANG_SPECIFIC (olddecl
)
2929 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2930 || CP_DECL_THREAD_LOCAL_P (newdecl
)))
2932 /* Only variables can be thread-local, and all declarations must
2933 agree on this property. */
2934 if (CP_DECL_THREAD_LOCAL_P (newdecl
))
2935 return G_("thread-local declaration of %q#D follows "
2936 "non-thread-local declaration");
2938 return G_("non-thread-local declaration of %q#D follows "
2939 "thread-local declaration");
2941 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2943 /* The objects have been declared at namespace scope. If either
2944 is a member of an anonymous union, then this is an invalid
2945 redeclaration. For example:
2951 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2952 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2953 return G_("redeclaration of %q#D");
2954 /* If at least one declaration is a reference, there is no
2955 conflict. For example:
2961 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2964 /* Static data member declared outside a class definition
2965 if the variable is defined within the class with constexpr
2966 specifier is declaration rather than definition (and
2968 if (cxx_dialect
>= cxx17
2970 && DECL_CLASS_SCOPE_P (olddecl
)
2971 && DECL_DECLARED_CONSTEXPR_P (olddecl
)
2972 && !DECL_INITIAL (newdecl
))
2974 DECL_EXTERNAL (newdecl
) = 1;
2975 /* For now, only warn with explicit -Wdeprecated. */
2976 if (global_options_set
.x_warn_deprecated
)
2978 auto_diagnostic_group d
;
2979 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wdeprecated
,
2980 "redundant redeclaration of %<constexpr%> "
2981 "static data member %qD", newdecl
))
2982 inform (DECL_SOURCE_LOCATION (olddecl
),
2983 "previous declaration of %qD", olddecl
);
2988 /* Reject two definitions. */
2989 return G_("redefinition of %q#D");
2993 /* Objects declared with block scope: */
2994 /* Reject two definitions, and reject a definition
2995 together with an external reference. */
2996 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2997 return G_("redeclaration of %q#D");
3003 /* Hash and equality functions for the named_label table. */
3006 named_label_hash::hash (const value_type entry
)
3008 return IDENTIFIER_HASH_VALUE (entry
->name
);
3012 named_label_hash::equal (const value_type entry
, compare_type name
)
3014 return name
== entry
->name
;
3017 /* Look for a label named ID in the current function. If one cannot
3018 be found, create one. Return the named_label_entry, or NULL on
3021 static named_label_entry
*
3022 lookup_label_1 (tree id
, bool making_local_p
)
3024 /* You can't use labels at global scope. */
3025 if (current_function_decl
== NULL_TREE
)
3027 error ("label %qE referenced outside of any function", id
);
3032 named_labels
= hash_table
<named_label_hash
>::create_ggc (13);
3034 hashval_t hash
= IDENTIFIER_HASH_VALUE (id
);
3035 named_label_entry
**slot
3036 = named_labels
->find_slot_with_hash (id
, hash
, INSERT
);
3037 named_label_entry
*old
= *slot
;
3039 if (old
&& old
->label_decl
)
3041 if (!making_local_p
)
3044 if (old
->binding_level
== current_binding_level
)
3046 error ("local label %qE conflicts with existing label", id
);
3047 inform (DECL_SOURCE_LOCATION (old
->label_decl
), "previous label");
3052 /* We are making a new decl, create or reuse the named_label_entry */
3053 named_label_entry
*ent
= NULL
;
3054 if (old
&& !old
->label_decl
)
3058 ent
= ggc_cleared_alloc
<named_label_entry
> ();
3064 /* Now create the LABEL_DECL. */
3065 tree decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
3067 DECL_CONTEXT (decl
) = current_function_decl
;
3068 SET_DECL_MODE (decl
, VOIDmode
);
3071 C_DECLARED_LABEL_FLAG (decl
) = true;
3072 DECL_CHAIN (decl
) = current_binding_level
->names
;
3073 current_binding_level
->names
= decl
;
3076 ent
->label_decl
= decl
;
3081 /* Wrapper for lookup_label_1. */
3084 lookup_label (tree id
)
3086 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3087 named_label_entry
*ent
= lookup_label_1 (id
, false);
3088 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3089 return ent
? ent
->label_decl
: NULL_TREE
;
3093 declare_local_label (tree id
)
3095 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3096 named_label_entry
*ent
= lookup_label_1 (id
, true);
3097 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3098 return ent
? ent
->label_decl
: NULL_TREE
;
3101 /* Returns nonzero if it is ill-formed to jump past the declaration of
3102 DECL. Returns 2 if it's also a real problem. */
3105 decl_jump_unsafe (tree decl
)
3107 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3108 with automatic storage duration is not in scope to a point where it is
3109 in scope is ill-formed unless the variable has scalar type, class type
3110 with a trivial default constructor and a trivial destructor, a
3111 cv-qualified version of one of these types, or an array of one of the
3112 preceding types and is declared without an initializer (8.5). */
3113 tree type
= TREE_TYPE (decl
);
3115 if (!VAR_P (decl
) || TREE_STATIC (decl
)
3116 || type
== error_mark_node
)
3119 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
3120 || variably_modified_type_p (type
, NULL_TREE
))
3123 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3129 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3133 identify_goto (tree decl
, location_t loc
, const location_t
*locus
,
3134 diagnostic_t diag_kind
)
3137 = emit_diagnostic (diag_kind
, loc
, 0,
3138 decl
? N_("jump to label %qD")
3139 : N_("jump to case label"), decl
);
3140 if (complained
&& locus
)
3141 inform (*locus
, " from here");
3145 /* Check that a single previously seen jump to a newly defined label
3146 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3147 the jump context; NAMES are the names in scope in LEVEL at the jump
3148 context; LOCUS is the source position of the jump or 0. Returns
3149 true if all is well. */
3152 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
3153 bool exited_omp
, const location_t
*locus
)
3155 cp_binding_level
*b
;
3156 bool complained
= false;
3158 bool saw_eh
= false, saw_omp
= false, saw_tm
= false, saw_cxif
= false;
3162 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3164 inform (input_location
, " exits OpenMP structured block");
3169 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3171 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
3173 for (new_decls
= b
->names
; new_decls
!= old_decls
;
3174 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
3175 : TREE_CHAIN (new_decls
)))
3177 int problem
= decl_jump_unsafe (new_decls
);
3183 complained
= identify_goto (decl
, input_location
, locus
,
3185 ? DK_ERROR
: DK_PERMERROR
);
3191 inform (DECL_SOURCE_LOCATION (new_decls
),
3192 " crosses initialization of %q#D", new_decls
);
3194 inform (DECL_SOURCE_LOCATION (new_decls
),
3195 " enters scope of %q#D, which has "
3196 "non-trivial destructor", new_decls
);
3203 const char *inf
= NULL
;
3204 location_t loc
= input_location
;
3209 inf
= N_("enters try block");
3215 inf
= N_("enters catch block");
3221 inf
= N_("enters OpenMP structured block");
3225 case sk_transaction
:
3227 inf
= N_("enters synchronized or atomic statement");
3232 if (!saw_cxif
&& level_for_constexpr_if (b
->level_chain
))
3234 inf
= N_("enters constexpr if statement");
3235 loc
= EXPR_LOCATION (b
->level_chain
->this_entity
);
3247 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3250 inform (loc
, " %s", inf
);
3258 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
3260 check_previous_goto_1 (decl
, use
->binding_level
,
3261 use
->names_in_scope
, use
->in_omp_scope
,
3262 &use
->o_goto_locus
);
3266 check_switch_goto (cp_binding_level
* level
)
3268 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
3271 /* Check that a new jump to a label DECL is OK. Called by
3272 finish_goto_stmt. */
3275 check_goto (tree decl
)
3277 /* We can't know where a computed goto is jumping.
3278 So we assume that it's OK. */
3279 if (TREE_CODE (decl
) != LABEL_DECL
)
3282 /* We didn't record any information about this label when we created it,
3283 and there's not much point since it's trivial to analyze as a return. */
3284 if (decl
== cdtor_label
)
3287 hashval_t hash
= IDENTIFIER_HASH_VALUE (DECL_NAME (decl
));
3288 named_label_entry
**slot
3289 = named_labels
->find_slot_with_hash (DECL_NAME (decl
), hash
, NO_INSERT
);
3290 named_label_entry
*ent
= *slot
;
3292 /* If the label hasn't been defined yet, defer checking. */
3293 if (! DECL_INITIAL (decl
))
3295 /* Don't bother creating another use if the last goto had the
3296 same data, and will therefore create the same set of errors. */
3298 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
3301 named_label_use_entry
*new_use
3302 = ggc_alloc
<named_label_use_entry
> ();
3303 new_use
->binding_level
= current_binding_level
;
3304 new_use
->names_in_scope
= current_binding_level
->names
;
3305 new_use
->o_goto_locus
= input_location
;
3306 new_use
->in_omp_scope
= false;
3308 new_use
->next
= ent
->uses
;
3309 ent
->uses
= new_use
;
3313 bool saw_catch
= false, complained
= false;
3318 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_transaction_scope
3319 || ent
->in_constexpr_if
3320 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
3322 diagnostic_t diag_kind
= DK_PERMERROR
;
3323 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_constexpr_if
3324 || ent
->in_transaction_scope
|| ent
->in_omp_scope
)
3325 diag_kind
= DK_ERROR
;
3326 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3327 &input_location
, diag_kind
);
3328 identified
= 1 + (diag_kind
== DK_ERROR
);
3331 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
3333 int u
= decl_jump_unsafe (bad
);
3335 if (u
> 1 && DECL_ARTIFICIAL (bad
))
3337 /* Can't skip init of __exception_info. */
3338 if (identified
== 1)
3340 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3341 &input_location
, DK_ERROR
);
3345 inform (DECL_SOURCE_LOCATION (bad
), " enters catch block");
3348 else if (complained
)
3351 inform (DECL_SOURCE_LOCATION (bad
),
3352 " skips initialization of %q#D", bad
);
3354 inform (DECL_SOURCE_LOCATION (bad
),
3355 " enters scope of %q#D which has "
3356 "non-trivial destructor", bad
);
3362 if (ent
->in_try_scope
)
3363 inform (input_location
, " enters try block");
3364 else if (ent
->in_catch_scope
&& !saw_catch
)
3365 inform (input_location
, " enters catch block");
3366 else if (ent
->in_transaction_scope
)
3367 inform (input_location
, " enters synchronized or atomic statement");
3368 else if (ent
->in_constexpr_if
)
3369 inform (input_location
, " enters %<constexpr%> if statement");
3372 if (ent
->in_omp_scope
)
3375 inform (input_location
, " enters OpenMP structured block");
3377 else if (flag_openmp
)
3378 for (cp_binding_level
*b
= current_binding_level
; b
; b
= b
->level_chain
)
3380 if (b
== ent
->binding_level
)
3382 if (b
->kind
== sk_omp
)
3386 complained
= identify_goto (decl
,
3387 DECL_SOURCE_LOCATION (decl
),
3388 &input_location
, DK_ERROR
);
3392 inform (input_location
, " exits OpenMP structured block");
3398 /* Check that a return is ok wrt OpenMP structured blocks.
3399 Called by finish_return_stmt. Returns true if all is well. */
3402 check_omp_return (void)
3404 for (cp_binding_level
*b
= current_binding_level
; b
; b
= b
->level_chain
)
3405 if (b
->kind
== sk_omp
)
3407 error ("invalid exit from OpenMP structured block");
3410 else if (b
->kind
== sk_function_parms
)
3415 /* Define a label, specifying the location in the source file.
3416 Return the LABEL_DECL node for the label. */
3419 define_label_1 (location_t location
, tree name
)
3421 /* After labels, make any new cleanups in the function go into their
3422 own new (temporary) binding contour. */
3423 for (cp_binding_level
*p
= current_binding_level
;
3424 p
->kind
!= sk_function_parms
;
3426 p
->more_cleanups_ok
= 0;
3428 named_label_entry
*ent
= lookup_label_1 (name
, false);
3429 tree decl
= ent
->label_decl
;
3431 if (DECL_INITIAL (decl
) != NULL_TREE
)
3433 error ("duplicate label %qD", decl
);
3434 return error_mark_node
;
3438 /* Mark label as having been defined. */
3439 DECL_INITIAL (decl
) = error_mark_node
;
3440 /* Say where in the source. */
3441 DECL_SOURCE_LOCATION (decl
) = location
;
3443 ent
->binding_level
= current_binding_level
;
3444 ent
->names_in_scope
= current_binding_level
->names
;
3446 for (named_label_use_entry
*use
= ent
->uses
; use
; use
= use
->next
)
3447 check_previous_goto (decl
, use
);
3454 /* Wrapper for define_label_1. */
3457 define_label (location_t location
, tree name
)
3459 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3460 tree ret
= define_label_1 (location
, name
);
3461 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3468 cp_binding_level
*level
;
3469 struct cp_switch
*next
;
3470 /* The SWITCH_STMT being built. */
3472 /* A splay-tree mapping the low element of a case range to the high
3473 element, or NULL_TREE if there is no high element. Used to
3474 determine whether or not a new case label duplicates an old case
3475 label. We need a tree, rather than simply a hash table, because
3476 of the GNU case range extension. */
3478 /* Remember whether there was a case value that is outside the
3479 range of the original type of the controlling expression. */
3480 bool outside_range_p
;
3481 /* Remember whether a default: case label has been seen. */
3483 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
3484 bool break_stmt_seen_p
;
3485 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
3486 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
3487 bool in_loop_body_p
;
3490 /* A stack of the currently active switch statements. The innermost
3491 switch statement is on the top of the stack. There is no need to
3492 mark the stack for garbage collection because it is only active
3493 during the processing of the body of a function, and we never
3494 collect at that point. */
3496 static struct cp_switch
*switch_stack
;
3498 /* Called right after a switch-statement condition is parsed.
3499 SWITCH_STMT is the switch statement being parsed. */
3502 push_switch (tree switch_stmt
)
3504 struct cp_switch
*p
= XNEW (struct cp_switch
);
3505 p
->level
= current_binding_level
;
3506 p
->next
= switch_stack
;
3507 p
->switch_stmt
= switch_stmt
;
3508 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3509 p
->outside_range_p
= false;
3510 p
->has_default_p
= false;
3511 p
->break_stmt_seen_p
= false;
3512 p
->in_loop_body_p
= false;
3519 struct cp_switch
*cs
= switch_stack
;
3520 location_t switch_location
;
3522 /* Emit warnings as needed. */
3523 switch_location
= cp_expr_loc_or_loc (cs
->switch_stmt
, input_location
);
3524 const bool bool_cond_p
3525 = (SWITCH_STMT_TYPE (cs
->switch_stmt
)
3526 && TREE_CODE (SWITCH_STMT_TYPE (cs
->switch_stmt
)) == BOOLEAN_TYPE
);
3527 if (!processing_template_decl
)
3528 c_do_switch_warnings (cs
->cases
, switch_location
,
3529 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3530 SWITCH_STMT_COND (cs
->switch_stmt
),
3531 bool_cond_p
, cs
->outside_range_p
);
3533 /* For the benefit of block_may_fallthru remember if the switch body
3534 case labels cover all possible values and if there are break; stmts. */
3535 if (cs
->has_default_p
3536 || (!processing_template_decl
3537 && c_switch_covers_all_cases_p (cs
->cases
,
3538 SWITCH_STMT_TYPE (cs
->switch_stmt
))))
3539 SWITCH_STMT_ALL_CASES_P (cs
->switch_stmt
) = 1;
3540 if (!cs
->break_stmt_seen_p
)
3541 SWITCH_STMT_NO_BREAK_P (cs
->switch_stmt
) = 1;
3542 gcc_assert (!cs
->in_loop_body_p
);
3543 splay_tree_delete (cs
->cases
);
3544 switch_stack
= switch_stack
->next
;
3548 /* Note that a BREAK_STMT is about to be added. If it is inside of
3549 a SWITCH_STMT and not inside of a loop body inside of it, note
3550 in switch_stack we've seen a BREAK_STMT. */
3553 note_break_stmt (void)
3555 if (switch_stack
&& !switch_stack
->in_loop_body_p
)
3556 switch_stack
->break_stmt_seen_p
= true;
3559 /* Note the start of processing of an iteration statement's body.
3560 The note_break_stmt function will do nothing while processing it.
3561 Return a flag that should be passed to note_iteration_stmt_body_end. */
3564 note_iteration_stmt_body_start (void)
3568 bool ret
= switch_stack
->in_loop_body_p
;
3569 switch_stack
->in_loop_body_p
= true;
3573 /* Note the end of processing of an iteration statement's body. */
3576 note_iteration_stmt_body_end (bool prev
)
3579 switch_stack
->in_loop_body_p
= prev
;
3582 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3583 condition. Note that if TYPE and VALUE are already integral we don't
3584 really do the conversion because the language-independent
3585 warning/optimization code will work better that way. */
3588 case_conversion (tree type
, tree value
)
3590 if (value
== NULL_TREE
)
3593 value
= mark_rvalue_use (value
);
3595 if (cxx_dialect
>= cxx11
3596 && (SCOPED_ENUM_P (type
)
3597 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3599 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3600 type
= type_promotes_to (type
);
3601 value
= (perform_implicit_conversion_flags
3602 (type
, value
, tf_warning_or_error
,
3603 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3605 return cxx_constant_value (value
);
3608 /* Note that we've seen a definition of a case label, and complain if this
3609 is a bad place for one. */
3612 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3615 cp_binding_level
*p
;
3618 if (low_value
== NULL_TREE
&& high_value
== NULL_TREE
)
3619 switch_stack
->has_default_p
= true;
3621 if (processing_template_decl
)
3625 /* For templates, just add the case label; we'll do semantic
3626 analysis at instantiation-time. */
3627 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, void_type_node
);
3628 return add_stmt (build_case_label (low_value
, high_value
, label
));
3631 /* Find the condition on which this switch statement depends. */
3632 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3633 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3634 cond
= TREE_VALUE (cond
);
3636 if (!check_switch_goto (switch_stack
->level
))
3637 return error_mark_node
;
3639 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3640 if (type
== error_mark_node
)
3641 return error_mark_node
;
3643 low_value
= case_conversion (type
, low_value
);
3644 high_value
= case_conversion (type
, high_value
);
3646 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3647 low_value
, high_value
,
3648 &switch_stack
->outside_range_p
);
3650 /* After labels, make any new cleanups in the function go into their
3651 own new (temporary) binding contour. */
3652 for (p
= current_binding_level
;
3653 p
->kind
!= sk_function_parms
;
3655 p
->more_cleanups_ok
= 0;
3660 struct typename_info
{
3668 struct typename_hasher
: ggc_ptr_hash
<tree_node
>
3670 typedef typename_info
*compare_type
;
3672 /* Hash a TYPENAME_TYPE. */
3679 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3680 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3685 /* Compare two TYPENAME_TYPEs. */
3688 equal (tree t1
, const typename_info
*t2
)
3690 return (TYPE_IDENTIFIER (t1
) == t2
->name
3691 && TYPE_CONTEXT (t1
) == t2
->scope
3692 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3693 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3694 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3698 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3699 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3701 Returns the new TYPENAME_TYPE. */
3703 static GTY (()) hash_table
<typename_hasher
> *typename_htab
;
3706 build_typename_type (tree context
, tree name
, tree fullname
,
3707 enum tag_types tag_type
)
3715 if (typename_htab
== NULL
)
3716 typename_htab
= hash_table
<typename_hasher
>::create_ggc (61);
3718 ti
.scope
= FROB_CONTEXT (context
);
3720 ti
.template_id
= fullname
;
3721 ti
.enum_p
= tag_type
== enum_type
;
3722 ti
.class_p
= (tag_type
== class_type
3723 || tag_type
== record_type
3724 || tag_type
== union_type
);
3725 hash
= (htab_hash_pointer (ti
.scope
)
3726 ^ htab_hash_pointer (ti
.name
));
3728 /* See if we already have this type. */
3729 e
= typename_htab
->find_slot_with_hash (&ti
, hash
, INSERT
);
3734 /* Build the TYPENAME_TYPE. */
3735 t
= cxx_make_type (TYPENAME_TYPE
);
3736 TYPE_CONTEXT (t
) = ti
.scope
;
3737 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3738 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3739 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3741 /* Build the corresponding TYPE_DECL. */
3742 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3743 TYPE_NAME (TREE_TYPE (d
)) = d
;
3744 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3745 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3746 DECL_ARTIFICIAL (d
) = 1;
3748 /* Store it in the hash table. */
3751 /* TYPENAME_TYPEs must always be compared structurally, because
3752 they may or may not resolve down to another type depending on
3753 the currently open classes. */
3754 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3760 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3761 provided to name the type. Returns an appropriate type, unless an
3762 error occurs, in which case error_mark_node is returned. If we
3763 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3764 return that, rather than the _TYPE it corresponds to, in other
3765 cases we look through the type decl. If TF_ERROR is set, complain
3766 about errors, otherwise be quiet. */
3769 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3770 tsubst_flags_t complain
)
3776 if (name
== error_mark_node
3777 || context
== NULL_TREE
3778 || context
== error_mark_node
)
3779 return error_mark_node
;
3783 if (!(TYPE_LANG_SPECIFIC (name
)
3784 && (CLASSTYPE_IS_TEMPLATE (name
)
3785 || CLASSTYPE_USE_TEMPLATE (name
))))
3786 name
= TYPE_IDENTIFIER (name
);
3788 /* Create a TEMPLATE_ID_EXPR for the type. */
3789 name
= build_nt (TEMPLATE_ID_EXPR
,
3790 CLASSTYPE_TI_TEMPLATE (name
),
3791 CLASSTYPE_TI_ARGS (name
));
3793 else if (TREE_CODE (name
) == TYPE_DECL
)
3794 name
= DECL_NAME (name
);
3798 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3800 name
= TREE_OPERAND (name
, 0);
3801 if (DECL_TYPE_TEMPLATE_P (name
))
3802 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3803 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
3805 if (complain
& tf_error
)
3806 error ("%qD is not a type", name
);
3807 return error_mark_node
;
3810 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3812 if (complain
& tf_error
)
3813 error ("%qD used without template arguments", name
);
3814 return error_mark_node
;
3816 gcc_assert (identifier_p (name
));
3817 gcc_assert (TYPE_P (context
));
3819 if (!MAYBE_CLASS_TYPE_P (context
))
3821 if (complain
& tf_error
)
3822 error ("%q#T is not a class", context
);
3823 return error_mark_node
;
3826 /* When the CONTEXT is a dependent type, NAME could refer to a
3827 dependent base class of CONTEXT. But look inside it anyway
3828 if CONTEXT is a currently open scope, in case it refers to a
3829 member of the current instantiation or a non-dependent base;
3830 lookup will stop when we hit a dependent base. */
3831 if (!dependent_scope_p (context
))
3832 /* We should only set WANT_TYPE when we're a nested typename type.
3833 Then we can give better diagnostics if we find a non-type. */
3834 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3838 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3839 return build_typename_type (context
, name
, fullname
, tag_type
);
3841 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3845 if (complain
& tf_error
)
3847 if (!COMPLETE_TYPE_P (context
))
3848 cxx_incomplete_type_error (NULL_TREE
, context
);
3850 error (want_template
? G_("no class template named %q#T in %q#T")
3851 : G_("no type named %q#T in %q#T"), name
, context
);
3853 return error_mark_node
;
3856 /* Pull out the template from an injected-class-name (or multiple). */
3858 t
= maybe_get_template_decl_from_type_decl (t
);
3860 if (TREE_CODE (t
) == TREE_LIST
)
3862 if (complain
& tf_error
)
3864 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3865 print_candidates (t
);
3867 return error_mark_node
;
3870 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3872 if (complain
& tf_error
)
3873 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3875 return error_mark_node
;
3877 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3879 if (complain
& tf_error
)
3880 error ("%<typename %T::%D%> names %q#T, which is not a type",
3882 return error_mark_node
;
3885 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3886 return error_mark_node
;
3888 /* If we are currently parsing a template and if T is a typedef accessed
3889 through CONTEXT then we need to remember and check access of T at
3890 template instantiation time. */
3891 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3894 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3896 /*entering_scope=*/0,
3897 complain
| tf_user
);
3899 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3902 maybe_record_typedef_use (t
);
3907 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3908 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3909 in which case error_mark_node is returned.
3911 If PARM_LIST is non-NULL, also make sure that the template parameter
3912 list of TEMPLATE_DECL matches.
3914 If COMPLAIN zero, don't complain about any errors that occur. */
3917 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3918 tsubst_flags_t complain
)
3924 name
= TYPE_IDENTIFIER (name
);
3925 else if (DECL_P (name
))
3926 name
= DECL_NAME (name
);
3927 gcc_assert (identifier_p (name
));
3929 if (!dependent_type_p (context
)
3930 || currently_open_class (context
))
3932 tree tmpl
= NULL_TREE
;
3934 if (MAYBE_CLASS_TYPE_P (context
))
3935 tmpl
= lookup_field (context
, name
, 0, false);
3937 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3938 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3940 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3942 if (complain
& tf_error
)
3943 error ("no class template named %q#T in %q#T", name
, context
);
3944 return error_mark_node
;
3948 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3950 if (complain
& tf_error
)
3952 error ("template parameters do not match template %qD", tmpl
);
3953 inform (DECL_SOURCE_LOCATION (tmpl
),
3954 "%qD declared here", tmpl
);
3956 return error_mark_node
;
3959 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3961 return error_mark_node
;
3966 /* Build the UNBOUND_CLASS_TEMPLATE. */
3967 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3968 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3969 TREE_TYPE (t
) = NULL_TREE
;
3970 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3972 /* Build the corresponding TEMPLATE_DECL. */
3973 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3974 TYPE_NAME (TREE_TYPE (d
)) = d
;
3975 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3976 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3977 DECL_ARTIFICIAL (d
) = 1;
3978 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3985 /* Push the declarations of builtin types into the global namespace.
3986 RID_INDEX is the index of the builtin type in the array
3987 RID_POINTERS. NAME is the name used when looking up the builtin
3988 type. TYPE is the _TYPE node for the builtin type.
3990 The calls to set_global_binding below should be
3991 eliminated. Built-in types should not be looked up name; their
3992 names are keywords that the parser can recognize. However, there
3993 is code in c-common.c that uses identifier_global_value to look up
3994 built-in types by name. */
3997 record_builtin_type (enum rid rid_index
,
4001 tree decl
= NULL_TREE
;
4005 tree tname
= get_identifier (name
);
4006 tree tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
4007 DECL_ARTIFICIAL (tdecl
) = 1;
4008 set_global_binding (tdecl
);
4012 if ((int) rid_index
< (int) RID_MAX
)
4013 if (tree rname
= ridpointers
[(int) rid_index
])
4014 if (!decl
|| DECL_NAME (decl
) != rname
)
4016 tree rdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
4017 DECL_ARTIFICIAL (rdecl
) = 1;
4018 set_global_binding (rdecl
);
4025 if (!TYPE_NAME (type
))
4026 TYPE_NAME (type
) = decl
;
4027 debug_hooks
->type_decl (decl
, 0);
4031 /* Push a type into the namespace so that the back ends ignore it. */
4034 record_unknown_type (tree type
, const char* name
)
4036 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
4037 TYPE_DECL
, get_identifier (name
), type
));
4038 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4039 DECL_IGNORED_P (decl
) = 1;
4040 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
4041 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
4042 SET_TYPE_ALIGN (type
, 1);
4043 TYPE_USER_ALIGN (type
) = 0;
4044 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
4047 /* Create all the predefined identifiers. */
4050 initialize_predefined_identifiers (void)
4052 struct predefined_identifier
4054 const char *name
; /* Name. */
4055 tree
*node
; /* Node to store it in. */
4056 cp_identifier_kind kind
; /* Kind of identifier. */
4059 /* A table of identifiers to create at startup. */
4060 static const predefined_identifier predefined_identifiers
[] = {
4061 {"C++", &lang_name_cplusplus
, cik_normal
},
4062 {"C", &lang_name_c
, cik_normal
},
4063 /* Some of these names have a trailing space so that it is
4064 impossible for them to conflict with names written by users. */
4065 {"__ct ", &ctor_identifier
, cik_ctor
},
4066 {"__ct_base ", &base_ctor_identifier
, cik_ctor
},
4067 {"__ct_comp ", &complete_ctor_identifier
, cik_ctor
},
4068 {"__dt ", &dtor_identifier
, cik_dtor
},
4069 {"__dt_base ", &base_dtor_identifier
, cik_dtor
},
4070 {"__dt_comp ", &complete_dtor_identifier
, cik_dtor
},
4071 {"__dt_del ", &deleting_dtor_identifier
, cik_dtor
},
4072 {"__conv_op ", &conv_op_identifier
, cik_conv_op
},
4073 {"__in_chrg", &in_charge_identifier
, cik_normal
},
4074 {"this", &this_identifier
, cik_normal
},
4075 {"__delta", &delta_identifier
, cik_normal
},
4076 {"__pfn", &pfn_identifier
, cik_normal
},
4077 {"_vptr", &vptr_identifier
, cik_normal
},
4078 {"__vtt_parm", &vtt_parm_identifier
, cik_normal
},
4079 {"::", &global_identifier
, cik_normal
},
4080 {"std", &std_identifier
, cik_normal
},
4081 /* The demangler expects anonymous namespaces to be called
4082 something starting with '_GLOBAL__N_'. It no longer needs
4083 to be unique to the TU. */
4084 {"_GLOBAL__N_1", &anon_identifier
, cik_normal
},
4085 {"auto", &auto_identifier
, cik_normal
},
4086 {"decltype(auto)", &decltype_auto_identifier
, cik_normal
},
4087 {"initializer_list", &init_list_identifier
, cik_normal
},
4088 {"__for_range ", &for_range__identifier
, cik_normal
},
4089 {"__for_begin ", &for_begin__identifier
, cik_normal
},
4090 {"__for_end ", &for_end__identifier
, cik_normal
},
4091 {"__for_range", &for_range_identifier
, cik_normal
},
4092 {"__for_begin", &for_begin_identifier
, cik_normal
},
4093 {"__for_end", &for_end_identifier
, cik_normal
},
4094 {"abi_tag", &abi_tag_identifier
, cik_normal
},
4095 {"aligned", &aligned_identifier
, cik_normal
},
4096 {"begin", &begin_identifier
, cik_normal
},
4097 {"end", &end_identifier
, cik_normal
},
4098 {"get", &get__identifier
, cik_normal
},
4099 {"gnu", &gnu_identifier
, cik_normal
},
4100 {"tuple_element", &tuple_element_identifier
, cik_normal
},
4101 {"tuple_size", &tuple_size_identifier
, cik_normal
},
4102 {"type", &type_identifier
, cik_normal
},
4103 {"value", &value_identifier
, cik_normal
},
4104 {"_FUN", &fun_identifier
, cik_normal
},
4105 {"__closure", &closure_identifier
, cik_normal
},
4106 {NULL
, NULL
, cik_normal
}
4109 for (const predefined_identifier
*pid
= predefined_identifiers
;
4112 *pid
->node
= get_identifier (pid
->name
);
4113 /* Some of these identifiers already have a special kind. */
4114 if (pid
->kind
!= cik_normal
)
4115 set_identifier_kind (*pid
->node
, pid
->kind
);
4119 /* Create the predefined scalar types of C,
4120 and some nodes representing standard constants (0, 1, (void *)0).
4121 Initialize the global binding level.
4122 Make definitions for built-in primitive functions. */
4125 cxx_init_decl_processing (void)
4128 tree void_ftype_ptr
;
4130 /* Create all the identifiers we need. */
4131 initialize_predefined_identifiers ();
4133 /* Create the global variables. */
4134 push_to_top_level ();
4136 current_function_decl
= NULL_TREE
;
4137 current_binding_level
= NULL
;
4138 /* Enter the global namespace. */
4139 gcc_assert (global_namespace
== NULL_TREE
);
4140 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_identifier
,
4142 TREE_PUBLIC (global_namespace
) = 1;
4143 DECL_CONTEXT (global_namespace
)
4144 = build_translation_unit_decl (get_identifier (main_input_filename
));
4145 /* Remember whether we want the empty class passing ABI change warning
4147 TRANSLATION_UNIT_WARN_EMPTY_P (DECL_CONTEXT (global_namespace
))
4148 = warn_abi
&& abi_version_crosses (12);
4149 debug_hooks
->register_main_translation_unit
4150 (DECL_CONTEXT (global_namespace
));
4151 begin_scope (sk_namespace
, global_namespace
);
4152 current_namespace
= global_namespace
;
4154 if (flag_visibility_ms_compat
)
4155 default_visibility
= VISIBILITY_HIDDEN
;
4158 current_lang_name
= lang_name_c
;
4160 /* Create the `std' namespace. */
4161 push_namespace (std_identifier
);
4162 std_node
= current_namespace
;
4165 flag_noexcept_type
= (cxx_dialect
>= cxx17
);
4167 c_common_nodes_and_builtins ();
4169 tree bool_ftype
= build_function_type_list (boolean_type_node
, NULL_TREE
);
4171 = add_builtin_function ("__builtin_is_constant_evaluated",
4172 bool_ftype
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
4173 BUILT_IN_FRONTEND
, NULL
, NULL_TREE
);
4174 set_call_expr_flags (decl
, ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
4176 integer_two_node
= build_int_cst (NULL_TREE
, 2);
4178 /* Guess at the initial static decls size. */
4179 vec_alloc (static_decls
, 500);
4181 /* ... and keyed classes. */
4182 vec_alloc (keyed_classes
, 100);
4184 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
4185 truthvalue_type_node
= boolean_type_node
;
4186 truthvalue_false_node
= boolean_false_node
;
4187 truthvalue_true_node
= boolean_true_node
;
4189 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
4190 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
4191 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
4192 noexcept_deferred_spec
= build_tree_list (make_node (DEFERRED_NOEXCEPT
),
4196 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
4199 delta_type_node
= ptrdiff_type_node
;
4200 vtable_index_type
= ptrdiff_type_node
;
4202 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
4203 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
4204 void_ftype_ptr
= build_function_type_list (void_type_node
,
4205 ptr_type_node
, NULL_TREE
);
4207 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
4209 /* Create the conversion operator marker. This operator's DECL_NAME
4210 is in the identifier table, so we can use identifier equality to
4212 conv_op_marker
= build_lang_decl (FUNCTION_DECL
, conv_op_identifier
,
4215 /* C++ extensions */
4217 unknown_type_node
= make_node (LANG_TYPE
);
4218 record_unknown_type (unknown_type_node
, "unknown type");
4220 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4221 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
4223 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4225 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
4226 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
4228 init_list_type_node
= make_node (LANG_TYPE
);
4229 record_unknown_type (init_list_type_node
, "init list");
4232 /* Make sure we get a unique function type, so we can give
4233 its pointer type a name. (This wins for gdb.) */
4234 tree vfunc_type
= make_node (FUNCTION_TYPE
);
4235 TREE_TYPE (vfunc_type
) = integer_type_node
;
4236 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
4237 layout_type (vfunc_type
);
4239 vtable_entry_type
= build_pointer_type (vfunc_type
);
4241 record_builtin_type (RID_MAX
, "__vtbl_ptr_type", vtable_entry_type
);
4244 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
4245 layout_type (vtbl_type_node
);
4246 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
4247 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
4248 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
4249 layout_type (vtbl_ptr_type_node
);
4250 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
4252 push_namespace (get_identifier ("__cxxabiv1"));
4253 abi_node
= current_namespace
;
4256 global_type_node
= make_node (LANG_TYPE
);
4257 record_unknown_type (global_type_node
, "global type");
4259 any_targ_node
= make_node (LANG_TYPE
);
4260 record_unknown_type (any_targ_node
, "any type");
4263 current_lang_name
= lang_name_cplusplus
;
4265 if (aligned_new_threshold
> 1
4266 && !pow2p_hwi (aligned_new_threshold
))
4268 error ("-faligned-new=%d is not a power of two", aligned_new_threshold
);
4269 aligned_new_threshold
= 1;
4271 if (aligned_new_threshold
== -1)
4272 aligned_new_threshold
= (cxx_dialect
>= cxx17
) ? 1 : 0;
4273 if (aligned_new_threshold
== 1)
4274 aligned_new_threshold
= malloc_alignment () / BITS_PER_UNIT
;
4277 tree newattrs
, extvisattr
;
4278 tree newtype
, deltype
;
4279 tree ptr_ftype_sizetype
;
4283 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
4284 if (cxx_dialect
== cxx98
)
4287 tree bad_alloc_type_node
;
4288 tree bad_alloc_decl
;
4290 push_namespace (std_identifier
);
4291 bad_alloc_id
= get_identifier ("bad_alloc");
4292 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
4293 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
4295 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
4296 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
4300 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
4303 new_eh_spec
= noexcept_false_spec
;
4305 /* Ensure attribs.c is initialized. */
4308 /* Ensure constraint.cc is initialized. */
4309 init_constraint_processing ();
4311 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
4313 newattrs
= tree_cons (get_identifier ("alloc_size"),
4314 build_tree_list (NULL_TREE
, integer_one_node
),
4316 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
4317 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4318 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
4319 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4320 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4321 DECL_IS_MALLOC (opnew
) = 1;
4322 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4323 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4324 DECL_IS_MALLOC (opnew
) = 1;
4325 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4326 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4327 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4328 if (flag_sized_deallocation
)
4330 /* Also push the sized deallocation variants:
4331 void operator delete(void*, std::size_t) throw();
4332 void operator delete[](void*, std::size_t) throw(); */
4333 tree void_ftype_ptr_size
4334 = build_function_type_list (void_type_node
, ptr_type_node
,
4335 size_type_node
, NULL_TREE
);
4336 deltype
= cp_build_type_attribute_variant (void_ftype_ptr_size
,
4338 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4339 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4340 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4343 if (aligned_new_threshold
)
4345 push_namespace (std_identifier
);
4346 tree align_id
= get_identifier ("align_val_t");
4347 align_type_node
= start_enum (align_id
, NULL_TREE
, size_type_node
,
4348 NULL_TREE
, /*scoped*/true, NULL
);
4351 /* operator new (size_t, align_val_t); */
4352 newtype
= build_function_type_list (ptr_type_node
, size_type_node
,
4353 align_type_node
, NULL_TREE
);
4354 newtype
= cp_build_type_attribute_variant (newtype
, newattrs
);
4355 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4356 opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4357 DECL_IS_MALLOC (opnew
) = 1;
4358 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4359 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4360 DECL_IS_MALLOC (opnew
) = 1;
4361 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4363 /* operator delete (void *, align_val_t); */
4364 deltype
= build_function_type_list (void_type_node
, ptr_type_node
,
4365 align_type_node
, NULL_TREE
);
4366 deltype
= cp_build_type_attribute_variant (deltype
, extvisattr
);
4367 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4368 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4369 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4371 if (flag_sized_deallocation
)
4373 /* operator delete (void *, size_t, align_val_t); */
4374 deltype
= build_function_type_list (void_type_node
, ptr_type_node
,
4375 size_type_node
, align_type_node
,
4377 deltype
= cp_build_type_attribute_variant (deltype
, extvisattr
);
4378 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4379 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4380 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4384 nullptr_type_node
= make_node (NULLPTR_TYPE
);
4385 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
4386 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
4387 TYPE_UNSIGNED (nullptr_type_node
) = 1;
4388 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
4389 if (abi_version_at_least (9))
4390 SET_TYPE_ALIGN (nullptr_type_node
, GET_MODE_ALIGNMENT (ptr_mode
));
4391 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
4392 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
4393 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
4397 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
4398 ECF_NORETURN
| ECF_NOTHROW
| ECF_COLD
);
4400 /* Perform other language dependent initializations. */
4401 init_class_processing ();
4402 init_rtti_processing ();
4403 init_template_processing ();
4405 if (flag_exceptions
)
4406 init_exception_processing ();
4408 if (! supports_one_only ())
4411 make_fname_decl
= cp_make_fname_decl
;
4412 start_fname_decls ();
4414 /* Show we use EH for cleanups. */
4415 if (flag_exceptions
)
4416 using_eh_for_cleanups ();
4419 /* Generate an initializer for a function naming variable from
4420 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4421 filled in with the type of the init. */
4424 cp_fname_init (const char* name
, tree
*type_p
)
4426 tree domain
= NULL_TREE
;
4428 tree init
= NULL_TREE
;
4433 length
= strlen (name
);
4434 domain
= build_index_type (size_int (length
));
4435 init
= build_string (length
+ 1, name
);
4438 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
4439 type
= build_cplus_array_type (type
, domain
);
4444 TREE_TYPE (init
) = type
;
4446 init
= error_mark_node
;
4451 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4452 the decl, LOC is the location to give the decl, NAME is the
4453 initialization string and TYPE_DEP indicates whether NAME depended
4454 on the type of the function. We make use of that to detect
4455 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4456 at the point of first use, so we mustn't push the decl now. */
4459 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4461 const char *const name
= (type_dep
&& in_template_function ()
4462 ? NULL
: fname_as_string (type_dep
));
4464 tree init
= cp_fname_init (name
, &type
);
4465 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4468 free (CONST_CAST (char *, name
));
4470 /* As we're using pushdecl_with_scope, we must set the context. */
4471 DECL_CONTEXT (decl
) = current_function_decl
;
4473 TREE_READONLY (decl
) = 1;
4474 DECL_ARTIFICIAL (decl
) = 1;
4475 DECL_DECLARED_CONSTEXPR_P (decl
) = 1;
4476 TREE_STATIC (decl
) = 1;
4478 TREE_USED (decl
) = 1;
4482 SET_DECL_VALUE_EXPR (decl
, init
);
4483 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
4484 /* For decl_constant_var_p. */
4485 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
4488 if (current_function_decl
)
4490 DECL_CONTEXT (decl
) = current_function_decl
;
4491 decl
= pushdecl_outermost_localscope (decl
);
4492 if (decl
!= error_mark_node
)
4493 add_decl_expr (decl
);
4497 DECL_THIS_STATIC (decl
) = true;
4498 pushdecl_top_level_and_finish (decl
, NULL_TREE
);
4505 builtin_function_1 (tree decl
, tree context
, bool is_global
)
4507 tree id
= DECL_NAME (decl
);
4508 const char *name
= IDENTIFIER_POINTER (id
);
4510 retrofit_lang_decl (decl
);
4512 DECL_ARTIFICIAL (decl
) = 1;
4513 SET_DECL_LANGUAGE (decl
, lang_c
);
4514 /* Runtime library routines are, by definition, available in an
4515 external shared object. */
4516 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4517 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4519 DECL_CONTEXT (decl
) = context
;
4521 /* A function in the user's namespace should have an explicit
4522 declaration before it is used. Mark the built-in function as
4523 anticipated but not actually declared. */
4524 if (name
[0] != '_' || name
[1] != '_')
4525 DECL_ANTICIPATED (decl
) = 1;
4526 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4528 size_t len
= strlen (name
);
4530 /* Treat __*_chk fortification functions as anticipated as well,
4531 unless they are __builtin_*. */
4532 if (len
> strlen ("___chk")
4533 && memcmp (name
+ len
- strlen ("_chk"),
4534 "_chk", strlen ("_chk") + 1) == 0)
4535 DECL_ANTICIPATED (decl
) = 1;
4539 return pushdecl_top_level (decl
);
4541 return pushdecl (decl
);
4545 cxx_builtin_function (tree decl
)
4547 tree id
= DECL_NAME (decl
);
4548 const char *name
= IDENTIFIER_POINTER (id
);
4549 /* All builtins that don't begin with an '_' should additionally
4550 go in the 'std' namespace. */
4553 tree decl2
= copy_node(decl
);
4554 push_namespace (std_identifier
);
4555 builtin_function_1 (decl2
, std_node
, false);
4559 return builtin_function_1 (decl
, NULL_TREE
, false);
4562 /* Like cxx_builtin_function, but guarantee the function is added to the global
4563 scope. This is to allow function specific options to add new machine
4564 dependent builtins when the target ISA changes via attribute((target(...)))
4565 which saves space on program startup if the program does not use non-generic
4569 cxx_builtin_function_ext_scope (tree decl
)
4572 tree id
= DECL_NAME (decl
);
4573 const char *name
= IDENTIFIER_POINTER (id
);
4574 /* All builtins that don't begin with an '_' should additionally
4575 go in the 'std' namespace. */
4578 tree decl2
= copy_node(decl
);
4579 push_namespace (std_identifier
);
4580 builtin_function_1 (decl2
, std_node
, true);
4584 return builtin_function_1 (decl
, NULL_TREE
, true);
4587 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4588 function. Not called directly. */
4591 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4594 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4595 DECL_EXTERNAL (fn
) = 1;
4596 TREE_PUBLIC (fn
) = 1;
4597 DECL_ARTIFICIAL (fn
) = 1;
4598 DECL_OVERLOADED_OPERATOR_CODE_RAW (fn
)
4599 = OVL_OP_INFO (false, operator_code
)->ovl_op_code
;
4600 SET_DECL_LANGUAGE (fn
, lang_c
);
4601 /* Runtime library routines are, by definition, available in an
4602 external shared object. */
4603 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4604 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4605 set_call_expr_flags (fn
, ecf_flags
);
4609 /* Returns the _DECL for a library function with C++ linkage. */
4612 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4615 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4616 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4617 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4621 /* Like build_library_fn, but takes a C string instead of an
4625 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4627 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4630 /* Like build_cp_library_fn, but takes a C string instead of an
4634 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4636 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4640 /* Like build_library_fn, but also pushes the function so that we will
4641 be able to find it via get_global_binding. Also, the function
4642 may throw exceptions listed in RAISES. */
4645 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4650 type
= build_exception_variant (type
, raises
);
4652 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4653 pushdecl_top_level (fn
);
4657 /* Like build_cp_library_fn, but also pushes the function so that it
4658 will be found by normal lookup. */
4661 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4664 tree fn
= build_cp_library_fn (ovl_op_identifier (false, operator_code
),
4665 operator_code
, type
, ecf_flags
);
4668 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4672 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4676 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4678 tree type
= build_function_type (void_type_node
, parmtypes
);
4679 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4682 /* Like push_library_fn, but also note that this function throws
4683 and does not return. Used for __throw_foo and the like. */
4686 push_throw_library_fn (tree name
, tree type
)
4688 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
| ECF_COLD
);
4692 /* When we call finish_struct for an anonymous union, we create
4693 default copy constructors and such. But, an anonymous union
4694 shouldn't have such things; this function undoes the damage to the
4695 anonymous union type T.
4697 (The reason that we create the synthesized methods is that we don't
4698 distinguish `union { int i; }' from `typedef union { int i; } U'.
4699 The first is an anonymous union; the second is just an ordinary
4703 fixup_anonymous_aggr (tree t
)
4705 /* Wipe out memory of synthesized methods. */
4706 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4707 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4708 TYPE_HAS_COPY_CTOR (t
) = 0;
4709 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4710 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4711 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4713 /* Splice the implicitly generated functions out of TYPE_FIELDS. */
4714 for (tree probe
, *prev_p
= &TYPE_FIELDS (t
); (probe
= *prev_p
);)
4715 if (TREE_CODE (probe
) == FUNCTION_DECL
&& DECL_ARTIFICIAL (probe
))
4716 *prev_p
= DECL_CHAIN (probe
);
4718 prev_p
= &DECL_CHAIN (probe
);
4720 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4721 assignment operators (because they cannot have these methods themselves).
4722 For anonymous unions this is already checked because they are not allowed
4723 in any union, otherwise we have to check it. */
4724 if (TREE_CODE (t
) != UNION_TYPE
)
4728 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4729 if (TREE_CODE (field
) == FIELD_DECL
)
4731 type
= TREE_TYPE (field
);
4732 if (CLASS_TYPE_P (type
))
4734 if (TYPE_NEEDS_CONSTRUCTING (type
))
4735 error ("member %q+#D with constructor not allowed "
4736 "in anonymous aggregate", field
);
4737 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4738 error ("member %q+#D with destructor not allowed "
4739 "in anonymous aggregate", field
);
4740 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4741 error ("member %q+#D with copy assignment operator "
4742 "not allowed in anonymous aggregate", field
);
4748 /* Warn for an attribute located at LOCATION that appertains to the
4749 class type CLASS_TYPE that has not been properly placed after its
4750 class-key, in it class-specifier. */
4753 warn_misplaced_attr_for_class_type (location_t location
,
4756 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4758 auto_diagnostic_group d
;
4759 if (warning_at (location
, OPT_Wattributes
,
4760 "attribute ignored in declaration "
4761 "of %q#T", class_type
))
4763 "attribute for %q#T must follow the %qs keyword",
4764 class_type
, class_key_or_enum_as_string (class_type
));
4767 /* Make sure that a declaration with no declarator is well-formed, i.e.
4768 just declares a tagged type or anonymous union.
4770 Returns the type declared; or NULL_TREE if none. */
4773 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4774 bool explicit_type_instantiation_p
)
4776 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4777 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4778 /* If a class, struct, or enum type is declared by the DECLSPECS
4779 (i.e, if a class-specifier, enum-specifier, or non-typename
4780 elaborated-type-specifier appears in the DECLSPECS),
4781 DECLARED_TYPE is set to the corresponding type. */
4782 tree declared_type
= NULL_TREE
;
4783 bool error_p
= false;
4785 if (declspecs
->multiple_types_p
)
4786 error ("multiple types in one declaration");
4787 else if (declspecs
->redefined_builtin_type
)
4789 if (!in_system_header_at (input_location
))
4790 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4791 "redeclaration of C++ built-in type %qT",
4792 declspecs
->redefined_builtin_type
);
4797 && TYPE_P (declspecs
->type
)
4798 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4799 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4800 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4801 declared_type
= declspecs
->type
;
4802 else if (declspecs
->type
== error_mark_node
)
4805 if (type_uses_auto (declared_type
))
4807 error_at (declspecs
->locations
[ds_type_spec
],
4808 "%<auto%> can only be specified for variables "
4809 "or function declarations");
4810 return error_mark_node
;
4813 if (declared_type
&& !OVERLOAD_TYPE_P (declared_type
))
4814 declared_type
= NULL_TREE
;
4816 if (!declared_type
&& !saw_friend
&& !error_p
)
4817 permerror (input_location
, "declaration does not declare anything");
4818 /* Check for an anonymous union. */
4819 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4820 && TYPE_UNNAMED_P (declared_type
))
4822 /* 7/3 In a simple-declaration, the optional init-declarator-list
4823 can be omitted only when declaring a class (clause 9) or
4824 enumeration (7.2), that is, when the decl-specifier-seq contains
4825 either a class-specifier, an elaborated-type-specifier with
4826 a class-key (9.1), or an enum-specifier. In these cases and
4827 whenever a class-specifier or enum-specifier is present in the
4828 decl-specifier-seq, the identifiers in these specifiers are among
4829 the names being declared by the declaration (as class-name,
4830 enum-names, or enumerators, depending on the syntax). In such
4831 cases, and except for the declaration of an unnamed bit-field (9.6),
4832 the decl-specifier-seq shall introduce one or more names into the
4833 program, or shall redeclare a name introduced by a previous
4834 declaration. [Example:
4835 enum { }; // ill-formed
4836 typedef class { }; // ill-formed
4840 error ("missing type-name in typedef-declaration");
4843 /* Anonymous unions are objects, so they can have specifiers. */;
4844 SET_ANON_AGGR_TYPE_P (declared_type
);
4846 if (TREE_CODE (declared_type
) != UNION_TYPE
4847 && !in_system_header_at (input_location
))
4848 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4853 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
4854 error_at (declspecs
->locations
[ds_inline
],
4855 "%<inline%> can only be specified for functions");
4856 else if (decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4857 error_at (declspecs
->locations
[ds_virtual
],
4858 "%<virtual%> can only be specified for functions");
4860 && (!current_class_type
4861 || current_scope () != current_class_type
))
4862 error_at (declspecs
->locations
[ds_friend
],
4863 "%<friend%> can only be specified inside a class");
4864 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4865 error_at (declspecs
->locations
[ds_explicit
],
4866 "%<explicit%> can only be specified for constructors");
4867 else if (declspecs
->storage_class
)
4868 error_at (declspecs
->locations
[ds_storage_class
],
4869 "a storage class can only be specified for objects "
4871 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
4872 error_at (declspecs
->locations
[ds_const
],
4873 "%<const%> can only be specified for objects and "
4875 else if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
4876 error_at (declspecs
->locations
[ds_volatile
],
4877 "%<volatile%> can only be specified for objects and "
4879 else if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
4880 error_at (declspecs
->locations
[ds_restrict
],
4881 "%<__restrict%> can only be specified for objects and "
4883 else if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4884 error_at (declspecs
->locations
[ds_thread
],
4885 "%<__thread%> can only be specified for objects "
4887 else if (saw_typedef
)
4888 warning_at (declspecs
->locations
[ds_typedef
], 0,
4889 "%<typedef%> was ignored in this declaration");
4890 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4891 error_at (declspecs
->locations
[ds_constexpr
],
4892 "%<constexpr%> cannot be used for type declarations");
4895 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4898 if (!CLASS_TYPE_P (declared_type
)
4899 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4900 /* For a non-template class, use the name location. */
4901 loc
= location_of (declared_type
);
4903 /* For a template class (an explicit instantiation), use the
4904 current location. */
4905 loc
= input_location
;
4907 if (explicit_type_instantiation_p
)
4908 /* [dcl.attr.grammar]/4:
4910 No attribute-specifier-seq shall appertain to an explicit
4913 if (warning_at (loc
, OPT_Wattributes
,
4914 "attribute ignored in explicit instantiation %q#T",
4917 "no attribute can be applied to "
4918 "an explicit instantiation");
4921 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4924 return declared_type
;
4927 /* Called when a declaration is seen that contains no names to declare.
4928 If its type is a reference to a structure, union or enum inherited
4929 from a containing scope, shadow that tag name for the current scope
4930 with a forward reference.
4931 If its type defines a new named structure or union
4932 or defines an enum, it is valid but we need not do anything here.
4933 Otherwise, it is an error.
4935 C++: may have to grok the declspecs to learn about static,
4936 complain for anonymous unions.
4938 Returns the TYPE declared -- or NULL_TREE if none. */
4941 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4943 tree t
= check_tag_decl (declspecs
,
4944 /*explicit_type_instantiation_p=*/false);
4949 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4952 /* This is where the variables in an anonymous union are
4953 declared. An anonymous union declaration looks like:
4955 because there is no declarator after the union, the parser
4956 sends that declaration here. */
4957 if (ANON_AGGR_TYPE_P (t
))
4959 fixup_anonymous_aggr (t
);
4961 if (TYPE_FIELDS (t
))
4963 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4964 declspecs
, NORMAL
, 0, NULL
);
4965 finish_anon_union (decl
);
4972 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4975 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4976 const cp_declarator
*declarator
,
4977 bool is_template_arg
)
4981 enum decl_context context
4982 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4983 attrs
= type_specifiers
->attributes
;
4984 type_specifiers
->attributes
= NULL_TREE
;
4985 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4986 if (attrs
&& type
!= error_mark_node
)
4988 if (CLASS_TYPE_P (type
))
4989 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4990 "outside of definition", type
);
4991 else if (MAYBE_CLASS_TYPE_P (type
))
4992 /* A template type parameter or other dependent type. */
4993 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4994 "type %qT without an associated declaration", type
);
4996 cplus_decl_attributes (&type
, attrs
, 0);
5001 /* Process a DECLARATOR for a function-scope variable declaration,
5002 namespace-scope variable declaration, or function declaration.
5003 (Function definitions go through start_function; class member
5004 declarations appearing in the body of the class go through
5005 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5006 If an error occurs, the error_mark_node is returned instead.
5008 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5009 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5010 for an explicitly defaulted function, or SD_DELETED for an explicitly
5011 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5012 implicitly initialized via a default constructor. ATTRIBUTES and
5013 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
5015 The scope represented by the context of the returned DECL is pushed
5016 (if it is not the global namespace) and is assigned to
5017 *PUSHED_SCOPE_P. The caller is then responsible for calling
5018 pop_scope on *PUSHED_SCOPE_P if it is set. */
5021 start_decl (const cp_declarator
*declarator
,
5022 cp_decl_specifier_seq
*declspecs
,
5025 tree prefix_attributes
,
5026 tree
*pushed_scope_p
)
5034 *pushed_scope_p
= NULL_TREE
;
5036 /* An object declared as __attribute__((deprecated)) suppresses
5037 warnings of uses of other deprecated items. */
5038 if (lookup_attribute ("deprecated", attributes
))
5039 deprecated_state
= DEPRECATED_SUPPRESS
;
5041 attributes
= chainon (attributes
, prefix_attributes
);
5043 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
5046 deprecated_state
= DEPRECATED_NORMAL
;
5048 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
5049 || decl
== error_mark_node
)
5050 return error_mark_node
;
5052 context
= CP_DECL_CONTEXT (decl
);
5053 if (context
!= global_namespace
)
5054 *pushed_scope_p
= push_scope (context
);
5056 /* Is it valid for this decl to have an initializer at all?
5057 If not, set INITIALIZED to zero, which will indirectly
5058 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
5060 && TREE_CODE (decl
) == TYPE_DECL
)
5062 error ("typedef %qD is initialized (use decltype instead)", decl
);
5063 return error_mark_node
;
5068 if (! toplevel_bindings_p ()
5069 && DECL_EXTERNAL (decl
))
5070 warning (0, "declaration of %q#D has %<extern%> and is initialized",
5072 DECL_EXTERNAL (decl
) = 0;
5073 if (toplevel_bindings_p ())
5074 TREE_STATIC (decl
) = 1;
5076 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
5078 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
5079 record_key_method_defined (decl
);
5081 /* If this is a typedef that names the class for linkage purposes
5082 (7.1.3p8), apply any attributes directly to the type. */
5083 if (TREE_CODE (decl
) == TYPE_DECL
5084 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
5085 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
5086 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
5090 /* Set attributes here so if duplicate decl, will have proper attributes. */
5091 cplus_decl_attributes (&decl
, attributes
, flags
);
5093 /* Dllimported symbols cannot be defined. Static data members (which
5094 can be initialized in-class and dllimported) go through grokfield,
5095 not here, so we don't need to exclude those decls when checking for
5097 if (initialized
&& DECL_DLLIMPORT_P (decl
))
5099 error ("definition of %q#D is marked %<dllimport%>", decl
);
5100 DECL_DLLIMPORT_P (decl
) = 0;
5103 /* If #pragma weak was used, mark the decl weak now. */
5104 if (!processing_template_decl
&& !DECL_DECOMPOSITION_P (decl
))
5105 maybe_apply_pragma_weak (decl
);
5107 if (TREE_CODE (decl
) == FUNCTION_DECL
5108 && DECL_DECLARED_INLINE_P (decl
)
5109 && DECL_UNINLINABLE (decl
)
5110 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
5111 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5112 "inline function %qD given attribute noinline", decl
);
5114 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
5116 bool this_tmpl
= (processing_template_decl
5117 > template_class_depth (context
));
5120 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
5121 if (field
== NULL_TREE
5122 || !(VAR_P (field
) || variable_template_p (field
)))
5123 error ("%q+#D is not a static data member of %q#T", decl
, context
);
5124 else if (variable_template_p (field
)
5125 && (DECL_LANG_SPECIFIC (decl
)
5126 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
5127 /* OK, specialization was already checked. */;
5128 else if (variable_template_p (field
) && !this_tmpl
)
5130 error_at (DECL_SOURCE_LOCATION (decl
),
5131 "non-member-template declaration of %qD", decl
);
5132 inform (DECL_SOURCE_LOCATION (field
), "does not match "
5133 "member template declaration here");
5134 return error_mark_node
;
5138 if (variable_template_p (field
))
5139 field
= DECL_TEMPLATE_RESULT (field
);
5141 if (DECL_CONTEXT (field
) != context
)
5143 if (!same_type_p (DECL_CONTEXT (field
), context
))
5144 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
5145 "to be defined as %<%T::%D%>",
5146 DECL_CONTEXT (field
), DECL_NAME (decl
),
5147 context
, DECL_NAME (decl
));
5148 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
5150 /* Static data member are tricky; an in-class initialization
5151 still doesn't provide a definition, so the in-class
5152 declaration will have DECL_EXTERNAL set, but will have an
5153 initialization. Thus, duplicate_decls won't warn
5154 about this situation, and so we check here. */
5155 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
5156 error ("duplicate initialization of %qD", decl
);
5157 field
= duplicate_decls (decl
, field
,
5158 /*newdecl_is_friend=*/false);
5159 if (field
== error_mark_node
)
5160 return error_mark_node
;
5167 tree field
= check_classfn (context
, decl
,
5169 ? current_template_parms
5171 if (field
&& field
!= error_mark_node
5172 && duplicate_decls (decl
, field
,
5173 /*newdecl_is_friend=*/false))
5177 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5178 DECL_IN_AGGR_P (decl
) = 0;
5179 /* Do not mark DECL as an explicit specialization if it was not
5180 already marked as an instantiation; a declaration should
5181 never be marked as a specialization unless we know what
5182 template is being specialized. */
5183 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
5185 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
5186 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5187 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
5188 && DECL_DECLARED_INLINE_P (decl
));
5190 DECL_COMDAT (decl
) = false;
5192 /* [temp.expl.spec] An explicit specialization of a static data
5193 member of a template is a definition if the declaration
5194 includes an initializer; otherwise, it is a declaration.
5196 We check for processing_specialization so this only applies
5197 to the new specialization syntax. */
5198 if (!initialized
&& processing_specialization
)
5199 DECL_EXTERNAL (decl
) = 1;
5202 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
5203 /* Aliases are definitions. */
5205 permerror (declarator
->id_loc
,
5206 "declaration of %q#D outside of class is not definition",
5210 was_public
= TREE_PUBLIC (decl
);
5212 /* Enter this declaration into the symbol table. Don't push the plain
5213 VAR_DECL for a variable template. */
5214 if (!template_parm_scope_p ()
5216 decl
= maybe_push_decl (decl
);
5218 if (processing_template_decl
)
5219 decl
= push_template_decl (decl
);
5220 if (decl
== error_mark_node
)
5221 return error_mark_node
;
5224 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
5225 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
5227 /* This is a const variable with implicit 'static'. Set
5228 DECL_THIS_STATIC so we can tell it from variables that are
5229 !TREE_PUBLIC because of the anonymous namespace. */
5230 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
5231 DECL_THIS_STATIC (decl
) = 1;
5234 if (current_function_decl
&& VAR_P (decl
)
5235 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
5238 if (CP_DECL_THREAD_LOCAL_P (decl
))
5239 error_at (DECL_SOURCE_LOCATION (decl
),
5240 "%qD declared %<thread_local%> in %<constexpr%> function",
5242 else if (TREE_STATIC (decl
))
5243 error_at (DECL_SOURCE_LOCATION (decl
),
5244 "%qD declared %<static%> in %<constexpr%> function", decl
);
5248 cp_function_chain
->invalid_constexpr
= true;
5251 if (!processing_template_decl
&& VAR_P (decl
))
5252 start_decl_1 (decl
, initialized
);
5257 /* Process the declaration of a variable DECL. INITIALIZED is true
5258 iff DECL is explicitly initialized. (INITIALIZED is false if the
5259 variable is initialized via an implicitly-called constructor.)
5260 This function must be called for ordinary variables (including, for
5261 example, implicit instantiations of templates), but must not be
5262 called for template declarations. */
5265 start_decl_1 (tree decl
, bool initialized
)
5269 bool aggregate_definition_p
;
5271 gcc_assert (!processing_template_decl
);
5273 if (error_operand_p (decl
))
5276 gcc_assert (VAR_P (decl
));
5278 type
= TREE_TYPE (decl
);
5279 complete_p
= COMPLETE_TYPE_P (type
);
5280 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
5282 /* If an explicit initializer is present, or if this is a definition
5283 of an aggregate, then we need a complete type at this point.
5284 (Scalars are always complete types, so there is nothing to
5285 check.) This code just sets COMPLETE_P; errors (if necessary)
5286 are issued below. */
5287 if ((initialized
|| aggregate_definition_p
)
5289 && COMPLETE_TYPE_P (complete_type (type
)))
5292 /* We will not yet have set TREE_READONLY on DECL if the type
5293 was "const", but incomplete, before this point. But, now, we
5294 have a complete type, so we can try again. */
5295 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
5299 /* Is it valid for this decl to have an initializer at all? */
5301 /* Don't allow initializations for incomplete types except for
5302 arrays which might be completed by the initialization. */
5304 ; /* A complete type is ok. */
5305 else if (type_uses_auto (type
))
5306 ; /* An auto type is ok. */
5307 else if (TREE_CODE (type
) != ARRAY_TYPE
)
5309 error ("variable %q#D has initializer but incomplete type", decl
);
5310 type
= TREE_TYPE (decl
) = error_mark_node
;
5312 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
5314 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
5315 error ("elements of array %q#D have incomplete type", decl
);
5316 /* else we already gave an error in start_decl. */
5319 else if (aggregate_definition_p
&& !complete_p
)
5321 if (type_uses_auto (type
))
5322 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (type
));
5325 error ("aggregate %q#D has incomplete type and cannot be defined",
5327 /* Change the type so that assemble_variable will give
5328 DECL an rtl we can live with: (mem (const_int 0)). */
5329 type
= TREE_TYPE (decl
) = error_mark_node
;
5333 /* Create a new scope to hold this declaration if necessary.
5334 Whether or not a new scope is necessary cannot be determined
5335 until after the type has been completed; if the type is a
5336 specialization of a class template it is not until after
5337 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5338 will be set correctly. */
5339 maybe_push_cleanup_level (type
);
5342 /* Handle initialization of references. DECL, TYPE, and INIT have the
5343 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5344 but will be set to a new CLEANUP_STMT if a temporary is created
5345 that must be destroyed subsequently.
5347 Returns an initializer expression to use to initialize DECL, or
5348 NULL if the initialization can be performed statically.
5350 Quotes on semantics can be found in ARM 8.4.3. */
5353 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
5355 if (init
== NULL_TREE
)
5357 if ((DECL_LANG_SPECIFIC (decl
) == 0
5358 || DECL_IN_AGGR_P (decl
) == 0)
5359 && ! DECL_THIS_EXTERN (decl
))
5360 error_at (DECL_SOURCE_LOCATION (decl
),
5361 "%qD declared as reference but not initialized", decl
);
5365 if (TREE_CODE (init
) == TREE_LIST
)
5366 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5367 tf_warning_or_error
);
5369 tree ttype
= TREE_TYPE (type
);
5370 if (TREE_CODE (ttype
) != ARRAY_TYPE
5371 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
5372 /* Note: default conversion is only called in very special cases. */
5373 init
= decay_conversion (init
, tf_warning_or_error
);
5375 /* check_initializer handles this for non-reference variables, but for
5376 references we need to do it here or the initializer will get the
5377 incomplete array type and confuse later calls to
5378 cp_complete_array_type. */
5379 if (TREE_CODE (ttype
) == ARRAY_TYPE
5380 && TYPE_DOMAIN (ttype
) == NULL_TREE
5381 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
5382 || TREE_CODE (init
) == STRING_CST
))
5384 cp_complete_array_type (&ttype
, init
, false);
5385 if (ttype
!= TREE_TYPE (type
))
5386 type
= cp_build_reference_type (ttype
, TYPE_REF_IS_RVALUE (type
));
5389 /* Convert INIT to the reference type TYPE. This may involve the
5390 creation of a temporary, whose lifetime must be the same as that
5391 of the reference. If so, a DECL_EXPR for the temporary will be
5392 added just after the DECL_EXPR for DECL. That's why we don't set
5393 DECL_INITIAL for local references (instead assigning to them
5394 explicitly); we need to allow the temporary to be initialized
5396 return initialize_reference (type
, init
, flags
,
5397 tf_warning_or_error
);
5400 /* Designated initializers in arrays are not supported in GNU C++.
5401 The parser cannot detect this error since it does not know whether
5402 a given brace-enclosed initializer is for a class type or for an
5403 array. This function checks that CE does not use a designated
5404 initializer. If it does, an error is issued. Returns true if CE
5405 is valid, i.e., does not have a designated initializer. */
5408 check_array_designated_initializer (constructor_elt
*ce
,
5409 unsigned HOST_WIDE_INT index
)
5411 /* Designated initializers for array elements are not supported. */
5414 /* The parser only allows identifiers as designated
5416 if (ce
->index
== error_mark_node
)
5418 error ("name used in a GNU-style designated "
5419 "initializer for an array");
5422 else if (identifier_p (ce
->index
))
5424 error ("name %qD used in a GNU-style designated "
5425 "initializer for an array", ce
->index
);
5429 tree ce_index
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
5432 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index
))
5433 && (TREE_CODE (ce_index
= fold_non_dependent_expr (ce_index
))
5436 /* A C99 designator is OK if it matches the current index. */
5437 if (wi::to_wide (ce_index
) == index
)
5439 ce
->index
= ce_index
;
5443 sorry ("non-trivial designated initializers not supported");
5446 error ("C99 designator %qE is not an integral constant-expression",
5455 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5456 array until we finish parsing the initializer. If that's the
5457 situation we're in, update DECL accordingly. */
5460 maybe_deduce_size_from_array_init (tree decl
, tree init
)
5462 tree type
= TREE_TYPE (decl
);
5464 if (TREE_CODE (type
) == ARRAY_TYPE
5465 && TYPE_DOMAIN (type
) == NULL_TREE
5466 && TREE_CODE (decl
) != TYPE_DECL
)
5468 /* do_default is really a C-ism to deal with tentative definitions.
5469 But let's leave it here to ease the eventual merge. */
5470 int do_default
= !DECL_EXTERNAL (decl
);
5471 tree initializer
= init
? init
: DECL_INITIAL (decl
);
5474 /* Check that there are no designated initializers in INIT, as
5475 those are not supported in GNU C++, and as the middle-end
5476 will crash if presented with a non-numeric designated
5478 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
5480 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
5481 constructor_elt
*ce
;
5483 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
5485 if (instantiation_dependent_expression_p (ce
->index
))
5487 if (!check_array_designated_initializer (ce
, i
))
5493 TREE_TYPE (decl
) = error_mark_node
;
5496 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
5500 error_at (cp_expr_loc_or_loc (initializer
,
5501 DECL_SOURCE_LOCATION (decl
)),
5502 "initializer fails to determine size of %qD", decl
);
5504 else if (failure
== 2)
5508 error_at (DECL_SOURCE_LOCATION (decl
),
5509 "array size missing in %qD", decl
);
5511 /* If a `static' var's size isn't known, make it extern as
5512 well as static, so it does not get allocated. If it's not
5513 `static', then don't mark it extern; finish_incomplete_decl
5514 will give it a default size and it will get allocated. */
5515 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
5516 DECL_EXTERNAL (decl
) = 1;
5518 else if (failure
== 3)
5520 error_at (DECL_SOURCE_LOCATION (decl
),
5521 "zero-size array %qD", decl
);
5525 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
5527 relayout_decl (decl
);
5531 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5532 any appropriate error messages regarding the layout. */
5535 layout_var_decl (tree decl
)
5539 type
= TREE_TYPE (decl
);
5540 if (type
== error_mark_node
)
5543 /* If we haven't already laid out this declaration, do so now.
5544 Note that we must not call complete type for an external object
5545 because it's type might involve templates that we are not
5546 supposed to instantiate yet. (And it's perfectly valid to say
5547 `extern X x' for some incomplete type `X'.) */
5548 if (!DECL_EXTERNAL (decl
))
5549 complete_type (type
);
5550 if (!DECL_SIZE (decl
)
5551 && TREE_TYPE (decl
) != error_mark_node
5552 && complete_or_array_type_p (type
))
5553 layout_decl (decl
, 0);
5555 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
5557 /* An automatic variable with an incomplete type: that is an error.
5558 Don't talk about array types here, since we took care of that
5559 message in grokdeclarator. */
5560 error_at (DECL_SOURCE_LOCATION (decl
),
5561 "storage size of %qD isn%'t known", decl
);
5562 TREE_TYPE (decl
) = error_mark_node
;
5565 /* Keep this code around in case we later want to control debug info
5566 based on whether a type is "used". (jason 1999-11-11) */
5568 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
5569 /* Let debugger know it should output info for this type. */
5570 note_debug_info_needed (ttype
);
5572 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
5573 note_debug_info_needed (DECL_CONTEXT (decl
));
5576 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
5577 && DECL_SIZE (decl
) != NULL_TREE
5578 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
5580 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
5581 constant_expression_warning (DECL_SIZE (decl
));
5584 error_at (DECL_SOURCE_LOCATION (decl
),
5585 "storage size of %qD isn%'t constant", decl
);
5586 TREE_TYPE (decl
) = error_mark_node
;
5591 /* If a local static variable is declared in an inline function, or if
5592 we have a weak definition, we must endeavor to create only one
5593 instance of the variable at link-time. */
5596 maybe_commonize_var (tree decl
)
5598 /* Don't mess with __FUNCTION__ and similar. */
5599 if (DECL_ARTIFICIAL (decl
))
5602 /* Static data in a function with comdat linkage also has comdat
5604 if ((TREE_STATIC (decl
)
5605 && DECL_FUNCTION_SCOPE_P (decl
)
5606 && vague_linkage_p (DECL_CONTEXT (decl
)))
5607 || (TREE_PUBLIC (decl
) && DECL_INLINE_VAR_P (decl
)))
5611 /* With weak symbols, we simply make the variable COMDAT;
5612 that will cause copies in multiple translations units to
5614 comdat_linkage (decl
);
5618 if (DECL_INITIAL (decl
) == NULL_TREE
5619 || DECL_INITIAL (decl
) == error_mark_node
)
5621 /* Without weak symbols, we can use COMMON to merge
5622 uninitialized variables. */
5623 TREE_PUBLIC (decl
) = 1;
5624 DECL_COMMON (decl
) = 1;
5628 /* While for initialized variables, we must use internal
5629 linkage -- which means that multiple copies will not
5631 TREE_PUBLIC (decl
) = 0;
5632 DECL_COMMON (decl
) = 0;
5634 if (DECL_INLINE_VAR_P (decl
))
5635 msg
= G_("sorry: semantics of inline variable "
5636 "%q#D are wrong (you%'ll wind up with "
5637 "multiple copies)");
5639 msg
= G_("sorry: semantics of inline function "
5640 "static data %q#D are wrong (you%'ll wind "
5641 "up with multiple copies)");
5642 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5644 inform (DECL_SOURCE_LOCATION (decl
),
5645 "you can work around this by removing the initializer");
5651 /* Issue an error message if DECL is an uninitialized const variable.
5652 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
5653 context from potential_constant_expression. Returns true if all is well,
5657 check_for_uninitialized_const_var (tree decl
, bool constexpr_context_p
,
5658 tsubst_flags_t complain
)
5660 tree type
= strip_array_types (TREE_TYPE (decl
));
5662 /* ``Unless explicitly declared extern, a const object does not have
5663 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5666 && !TYPE_REF_P (type
)
5667 && (constexpr_context_p
5668 || CP_TYPE_CONST_P (type
) || var_in_constexpr_fn (decl
))
5669 && !DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
5671 tree field
= default_init_uninitialized_part (type
);
5675 if (!constexpr_context_p
)
5677 if (CP_TYPE_CONST_P (type
))
5679 if (complain
& tf_error
)
5680 permerror (DECL_SOURCE_LOCATION (decl
),
5681 "uninitialized const %qD", decl
);
5685 if (!is_instantiation_of_constexpr (current_function_decl
)
5686 && (complain
& tf_error
))
5687 error_at (DECL_SOURCE_LOCATION (decl
),
5688 "uninitialized variable %qD in %<constexpr%> "
5690 cp_function_chain
->invalid_constexpr
= true;
5693 else if (complain
& tf_error
)
5694 error_at (DECL_SOURCE_LOCATION (decl
),
5695 "uninitialized variable %qD in %<constexpr%> context",
5698 if (CLASS_TYPE_P (type
) && (complain
& tf_error
))
5700 tree defaulted_ctor
;
5702 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5703 "%q#T has no user-provided default constructor", type
);
5704 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5706 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5707 "constructor is not user-provided because it is "
5708 "explicitly defaulted in the class body");
5709 inform (DECL_SOURCE_LOCATION (field
),
5710 "and the implicitly-defined constructor does not "
5711 "initialize %q#D", field
);
5720 /* Structure holding the current initializer being processed by reshape_init.
5721 CUR is a pointer to the current element being processed, END is a pointer
5722 after the last element present in the initializer. */
5725 constructor_elt
*cur
;
5726 constructor_elt
*end
;
5729 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5731 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5732 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5733 initialized. If there are no more such fields, the return value
5737 next_initializable_field (tree field
)
5740 && (TREE_CODE (field
) != FIELD_DECL
5741 || DECL_UNNAMED_BIT_FIELD (field
)
5742 || (DECL_ARTIFICIAL (field
)
5743 && !(cxx_dialect
>= cxx17
&& DECL_FIELD_IS_BASE (field
)))))
5744 field
= DECL_CHAIN (field
);
5749 /* Return true for [dcl.init.list] direct-list-initialization from
5750 single element of enumeration with a fixed underlying type. */
5753 is_direct_enum_init (tree type
, tree init
)
5755 if (cxx_dialect
>= cxx17
5756 && TREE_CODE (type
) == ENUMERAL_TYPE
5757 && ENUM_FIXED_UNDERLYING_TYPE_P (type
)
5758 && TREE_CODE (init
) == CONSTRUCTOR
5759 && CONSTRUCTOR_IS_DIRECT_INIT (init
)
5760 && CONSTRUCTOR_NELTS (init
) == 1)
5765 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5766 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5767 INTEGER_CST representing the size of the array minus one (the maximum index),
5768 or NULL_TREE if the array was declared without specifying the size. D is
5769 the iterator within the constructor. */
5772 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5773 tsubst_flags_t complain
)
5776 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5777 unsigned HOST_WIDE_INT max_index_cst
= 0;
5778 unsigned HOST_WIDE_INT index
;
5780 /* The initializer for an array is always a CONSTRUCTOR. */
5781 new_init
= build_constructor (init_list_type_node
, NULL
);
5785 /* Minus 1 is used for zero sized arrays. */
5786 if (integer_all_onesp (max_index
))
5789 if (tree_fits_uhwi_p (max_index
))
5790 max_index_cst
= tree_to_uhwi (max_index
);
5791 /* sizetype is sign extended, not zero extended. */
5793 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5796 /* Loop until there are no more initializers. */
5798 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5802 constructor_elt
*old_cur
= d
->cur
;
5804 check_array_designated_initializer (d
->cur
, index
);
5805 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5807 if (elt_init
== error_mark_node
)
5808 return error_mark_node
;
5809 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5810 size_int (index
), elt_init
);
5811 if (!TREE_CONSTANT (elt_init
))
5812 TREE_CONSTANT (new_init
) = false;
5814 /* This can happen with an invalid initializer (c++/54501). */
5815 if (d
->cur
== old_cur
&& !sized_array_p
)
5822 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5823 Parameters are the same of reshape_init_r. */
5826 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5828 tree max_index
= NULL_TREE
;
5830 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5832 if (TYPE_DOMAIN (type
))
5833 max_index
= array_type_nelts (type
);
5835 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5838 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5839 Parameters are the same of reshape_init_r. */
5842 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5844 tree max_index
= NULL_TREE
;
5846 gcc_assert (VECTOR_TYPE_P (type
));
5848 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5850 tree value
= d
->cur
->value
;
5851 if (!same_type_p (TREE_TYPE (value
), type
))
5853 if (complain
& tf_error
)
5854 error ("invalid type %qT as initializer for a vector of type %qT",
5855 TREE_TYPE (d
->cur
->value
), type
);
5856 value
= error_mark_node
;
5862 /* For a vector, we initialize it as an array of the appropriate size. */
5863 if (VECTOR_TYPE_P (type
))
5864 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5866 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5869 /* Subroutine of reshape_init_r, processes the initializers for classes
5870 or union. Parameters are the same of reshape_init_r. */
5873 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5874 tsubst_flags_t complain
)
5879 gcc_assert (CLASS_TYPE_P (type
));
5881 /* The initializer for a class is always a CONSTRUCTOR. */
5882 new_init
= build_constructor (init_list_type_node
, NULL
);
5883 field
= next_initializable_field (TYPE_FIELDS (type
));
5889 An initializer for an aggregate member that is an
5890 empty class shall have the form of an empty
5891 initializer-list {}. */
5892 if (!first_initializer_p
)
5894 if (complain
& tf_error
)
5895 error ("initializer for %qT must be brace-enclosed", type
);
5896 return error_mark_node
;
5901 /* Loop through the initializable fields, gathering initializers. */
5902 while (d
->cur
!= d
->end
)
5905 constructor_elt
*old_cur
= d
->cur
;
5907 /* Handle designated initializers, as an extension. */
5910 if (d
->cur
->index
== error_mark_node
)
5911 return error_mark_node
;
5913 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5915 /* We already reshaped this. */
5916 if (field
!= d
->cur
->index
)
5918 tree id
= DECL_NAME (d
->cur
->index
);
5920 gcc_checking_assert (d
->cur
->index
5921 == get_class_binding (type
, id
, false));
5922 field
= d
->cur
->index
;
5925 else if (TREE_CODE (d
->cur
->index
) == IDENTIFIER_NODE
)
5926 field
= get_class_binding (type
, d
->cur
->index
, false);
5929 if (complain
& tf_error
)
5930 error ("%<[%E] =%> used in a GNU-style designated initializer"
5931 " for class %qT", d
->cur
->index
, type
);
5932 return error_mark_node
;
5935 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5937 if (complain
& tf_error
)
5938 error ("%qT has no non-static data member named %qD", type
,
5940 return error_mark_node
;
5944 /* If we processed all the member of the class, we are done. */
5948 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5949 /*first_initializer_p=*/false, complain
);
5950 if (field_init
== error_mark_node
)
5951 return error_mark_node
;
5953 if (d
->cur
== old_cur
&& d
->cur
->index
)
5955 /* This can happen with an invalid initializer for a flexible
5956 array member (c++/54441). */
5957 if (complain
& tf_error
)
5958 error ("invalid initializer for %q#D", field
);
5959 return error_mark_node
;
5962 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5966 When a union is initialized with a brace-enclosed
5967 initializer, the braces shall only contain an
5968 initializer for the first member of the union. */
5969 if (TREE_CODE (type
) == UNION_TYPE
)
5972 field
= next_initializable_field (DECL_CHAIN (field
));
5978 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5979 designators are not valid; either complain or return true to indicate
5980 that reshape_init_r should return error_mark_node. */
5983 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5987 if (complain
& tf_error
)
5988 error ("C99 designator %qE outside aggregate initializer",
5996 /* Subroutine of reshape_init, which processes a single initializer (part of
5997 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5998 iterator within the CONSTRUCTOR which points to the initializer to process.
5999 FIRST_INITIALIZER_P is true if this is the first initializer of the
6000 outermost CONSTRUCTOR node. */
6003 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
6004 tsubst_flags_t complain
)
6006 tree init
= d
->cur
->value
;
6008 if (error_operand_p (init
))
6009 return error_mark_node
;
6011 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
6012 && has_designator_problem (d
, complain
))
6013 return error_mark_node
;
6015 tree stripped_init
= tree_strip_any_location_wrapper (init
);
6017 if (TREE_CODE (type
) == COMPLEX_TYPE
)
6019 /* A complex type can be initialized from one or two initializers,
6020 but braces are not elided. */
6022 if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init
))
6024 if (CONSTRUCTOR_NELTS (stripped_init
) > 2)
6026 if (complain
& tf_error
)
6027 error ("too many initializers for %qT", type
);
6029 return error_mark_node
;
6032 else if (first_initializer_p
&& d
->cur
!= d
->end
)
6034 vec
<constructor_elt
, va_gc
> *v
= 0;
6035 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
6036 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
6037 if (has_designator_problem (d
, complain
))
6038 return error_mark_node
;
6040 init
= build_constructor (init_list_type_node
, v
);
6045 /* A non-aggregate type is always initialized with a single
6047 if (!CP_AGGREGATE_TYPE_P (type
))
6049 /* It is invalid to initialize a non-aggregate type with a
6050 brace-enclosed initializer before C++0x.
6051 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
6052 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
6053 a CONSTRUCTOR (with a record type). */
6054 if (TREE_CODE (stripped_init
) == CONSTRUCTOR
6055 /* Don't complain about a capture-init. */
6056 && !CONSTRUCTOR_IS_DIRECT_INIT (stripped_init
)
6057 && BRACE_ENCLOSED_INITIALIZER_P (stripped_init
)) /* p7626.C */
6059 if (SCALAR_TYPE_P (type
))
6061 if (cxx_dialect
< cxx11
6062 /* Isn't value-initialization. */
6063 || CONSTRUCTOR_NELTS (stripped_init
) > 0)
6065 if (complain
& tf_error
)
6066 error ("braces around scalar initializer for type %qT",
6068 init
= error_mark_node
;
6072 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6079 /* "If T is a class type and the initializer list has a single element of
6080 type cv U, where U is T or a class derived from T, the object is
6081 initialized from that element." Even if T is an aggregate. */
6082 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
6083 && first_initializer_p
6084 && d
->end
- d
->cur
== 1
6085 && reference_related_p (type
, TREE_TYPE (init
)))
6093 All implicit type conversions (clause _conv_) are considered when
6094 initializing the aggregate member with an initializer from an
6095 initializer-list. If the initializer can initialize a member,
6096 the member is initialized. Otherwise, if the member is itself a
6097 non-empty subaggregate, brace elision is assumed and the
6098 initializer is considered for the initialization of the first
6099 member of the subaggregate. */
6100 if (TREE_CODE (init
) != CONSTRUCTOR
6101 /* But don't try this for the first initializer, since that would be
6102 looking through the outermost braces; A a2 = { a1 }; is not a
6103 valid aggregate initialization. */
6104 && !first_initializer_p
6105 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
6106 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
6113 /* [dcl.init.string]
6115 A char array (whether plain char, signed char, or unsigned char)
6116 can be initialized by a string-literal (optionally enclosed in
6117 braces); a wchar_t array can be initialized by a wide
6118 string-literal (optionally enclosed in braces). */
6119 if (TREE_CODE (type
) == ARRAY_TYPE
6120 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
6122 tree str_init
= init
;
6123 tree stripped_str_init
= stripped_init
;
6125 /* Strip one level of braces if and only if they enclose a single
6126 element (as allowed by [dcl.init.string]). */
6127 if (!first_initializer_p
6128 && TREE_CODE (stripped_str_init
) == CONSTRUCTOR
6129 && CONSTRUCTOR_NELTS (stripped_str_init
) == 1)
6131 str_init
= (*CONSTRUCTOR_ELTS (stripped_str_init
))[0].value
;
6132 stripped_str_init
= tree_strip_any_location_wrapper (str_init
);
6135 /* If it's a string literal, then it's the initializer for the array
6136 as a whole. Otherwise, continue with normal initialization for
6137 array types (one value per array element). */
6138 if (TREE_CODE (stripped_str_init
) == STRING_CST
)
6140 if (has_designator_problem (d
, complain
))
6141 return error_mark_node
;
6147 /* The following cases are about aggregates. If we are not within a full
6148 initializer already, and there is not a CONSTRUCTOR, it means that there
6149 is a missing set of braces (that is, we are processing the case for
6150 which reshape_init exists). */
6151 if (!first_initializer_p
)
6153 if (TREE_CODE (stripped_init
) == CONSTRUCTOR
)
6155 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
6156 /* There is no need to reshape pointer-to-member function
6157 initializers, as they are always constructed correctly
6158 by the front end. */
6160 else if (COMPOUND_LITERAL_P (stripped_init
))
6161 /* For a nested compound literal, there is no need to reshape since
6162 brace elision is not allowed. Even if we decided to allow it,
6163 we should add a call to reshape_init in finish_compound_literal,
6164 before calling digest_init, so changing this code would still
6165 not be necessary. */
6166 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (stripped_init
));
6170 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (stripped_init
));
6171 return reshape_init (type
, init
, complain
);
6175 if (complain
& tf_warning
)
6176 warning (OPT_Wmissing_braces
,
6177 "missing braces around initializer for %qT",
6181 /* Dispatch to specialized routines. */
6182 if (CLASS_TYPE_P (type
))
6183 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
6184 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6185 return reshape_init_array (type
, d
, complain
);
6186 else if (VECTOR_TYPE_P (type
))
6187 return reshape_init_vector (type
, d
, complain
);
6192 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
6193 brace-enclosed aggregate initializer.
6195 INIT is the CONSTRUCTOR containing the list of initializers describing
6196 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
6197 It may not presently match the shape of the TYPE; for example:
6199 struct S { int a; int b; };
6200 struct S a[] = { 1, 2, 3, 4 };
6202 Here INIT will hold a vector of four elements, rather than a
6203 vector of two elements, each itself a vector of two elements. This
6204 routine transforms INIT from the former form into the latter. The
6205 revised CONSTRUCTOR node is returned. */
6208 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
6210 vec
<constructor_elt
, va_gc
> *v
;
6214 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
6216 v
= CONSTRUCTOR_ELTS (init
);
6218 /* An empty constructor does not need reshaping, and it is always a valid
6220 if (vec_safe_is_empty (v
))
6223 /* Handle [dcl.init.list] direct-list-initialization from
6224 single element of enumeration with a fixed underlying type. */
6225 if (is_direct_enum_init (type
, init
))
6227 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
6228 type
= cv_unqualified (type
);
6229 if (check_narrowing (ENUM_UNDERLYING_TYPE (type
), elt
, complain
))
6231 warning_sentinel
w (warn_useless_cast
);
6232 warning_sentinel
w2 (warn_ignored_qualifiers
);
6233 return cp_build_c_cast (type
, elt
, tf_warning_or_error
);
6236 return error_mark_node
;
6239 /* Recurse on this CONSTRUCTOR. */
6241 d
.end
= d
.cur
+ v
->length ();
6243 new_init
= reshape_init_r (type
, &d
, true, complain
);
6244 if (new_init
== error_mark_node
)
6245 return error_mark_node
;
6247 /* Make sure all the element of the constructor were used. Otherwise,
6248 issue an error about exceeding initializers. */
6251 if (complain
& tf_error
)
6252 error ("too many initializers for %qT", type
);
6253 return error_mark_node
;
6256 if (CONSTRUCTOR_IS_DIRECT_INIT (init
)
6257 && BRACE_ENCLOSED_INITIALIZER_P (new_init
))
6258 CONSTRUCTOR_IS_DIRECT_INIT (new_init
) = true;
6263 /* Verify array initializer. Returns true if errors have been reported. */
6266 check_array_initializer (tree decl
, tree type
, tree init
)
6268 tree element_type
= TREE_TYPE (type
);
6270 /* The array type itself need not be complete, because the
6271 initializer may tell us how many elements are in the array.
6272 But, the elements of the array must be complete. */
6273 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
6276 error_at (DECL_SOURCE_LOCATION (decl
),
6277 "elements of array %q#D have incomplete type", decl
);
6279 error ("elements of array %q#T have incomplete type", type
);
6282 /* A compound literal can't have variable size. */
6284 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
6285 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
6287 error ("variable-sized compound literal");
6293 /* Subroutine of check_initializer; args are passed down from that function.
6294 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
6297 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
6300 gcc_assert (stmts_are_full_exprs_p ());
6301 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
6304 /* Verify INIT (the initializer for DECL), and record the
6305 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
6306 grok_reference_init.
6308 If the return value is non-NULL, it is an expression that must be
6309 evaluated dynamically to initialize DECL. */
6312 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
6314 tree type
= TREE_TYPE (decl
);
6315 tree init_code
= NULL
;
6318 /* Things that are going to be initialized need to have complete
6320 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
6322 if (DECL_HAS_VALUE_EXPR_P (decl
))
6324 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
6325 it doesn't have storage to be initialized. */
6326 gcc_assert (init
== NULL_TREE
);
6330 if (type
== error_mark_node
)
6331 /* We will have already complained. */
6334 if (TREE_CODE (type
) == ARRAY_TYPE
)
6336 if (check_array_initializer (decl
, type
, init
))
6339 else if (!COMPLETE_TYPE_P (type
))
6341 error_at (DECL_SOURCE_LOCATION (decl
),
6342 "%q#D has incomplete type", decl
);
6343 TREE_TYPE (decl
) = error_mark_node
;
6347 /* There is no way to make a variable-sized class type in GNU C++. */
6348 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
6350 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
6352 int init_len
= CONSTRUCTOR_NELTS (init
);
6353 if (SCALAR_TYPE_P (type
))
6357 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6358 init
= build_zero_init (type
, NULL_TREE
, false);
6360 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
6362 error_at (cp_expr_loc_or_loc (init
, DECL_SOURCE_LOCATION (decl
)),
6363 "scalar object %qD requires one element in "
6364 "initializer", decl
);
6365 TREE_TYPE (decl
) = error_mark_node
;
6371 if (TREE_CODE (decl
) == CONST_DECL
)
6373 gcc_assert (!TYPE_REF_P (type
));
6375 DECL_INITIAL (decl
) = init
;
6377 gcc_assert (init
!= NULL_TREE
);
6380 else if (!init
&& DECL_REALLY_EXTERN (decl
))
6382 else if (init
|| type_build_ctor_call (type
)
6383 || TYPE_REF_P (type
))
6385 if (TYPE_REF_P (type
))
6387 init
= grok_reference_init (decl
, type
, init
, flags
);
6388 flags
|= LOOKUP_ALREADY_DIGESTED
;
6391 check_for_uninitialized_const_var (decl
, /*constexpr_context_p=*/false,
6392 tf_warning_or_error
);
6393 /* Do not reshape constructors of vectors (they don't need to be
6395 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
6397 if (is_std_init_list (type
))
6399 init
= perform_implicit_conversion (type
, init
,
6400 tf_warning_or_error
);
6401 flags
|= LOOKUP_ALREADY_DIGESTED
;
6403 else if (TYPE_NON_AGGREGATE_CLASS (type
))
6405 /* Don't reshape if the class has constructors. */
6406 if (cxx_dialect
== cxx98
)
6407 error_at (cp_expr_loc_or_loc (init
, DECL_SOURCE_LOCATION (decl
)),
6408 "in C++98 %qD must be initialized by "
6409 "constructor, not by %<{...}%>",
6412 else if (VECTOR_TYPE_P (type
) && TYPE_VECTOR_OPAQUE (type
))
6414 error ("opaque vector types cannot be initialized");
6415 init
= error_mark_node
;
6419 init
= reshape_init (type
, init
, tf_warning_or_error
);
6420 flags
|= LOOKUP_NO_NARROWING
;
6423 else if (TREE_CODE (init
) == TREE_LIST
6424 && TREE_TYPE (init
) != unknown_type_node
6425 && !MAYBE_CLASS_TYPE_P (type
))
6427 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6429 /* We get here with code like `int a (2);' */
6430 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6431 tf_warning_or_error
);
6434 /* If DECL has an array type without a specific bound, deduce the
6435 array size from the initializer. */
6436 maybe_deduce_size_from_array_init (decl
, init
);
6437 type
= TREE_TYPE (decl
);
6438 if (type
== error_mark_node
)
6441 if (((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
6442 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
6443 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
6444 && CP_AGGREGATE_TYPE_P (type
)
6445 && (CLASS_TYPE_P (type
)
6446 || !TYPE_NEEDS_CONSTRUCTING (type
)
6447 || type_has_extended_temps (type
))))
6448 || (DECL_DECOMPOSITION_P (decl
) && TREE_CODE (type
) == ARRAY_TYPE
))
6450 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
6452 /* A constructor call is a non-trivial initializer even if
6453 it isn't explicitly written. */
6454 if (TREE_SIDE_EFFECTS (init_code
))
6455 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
6457 /* If this is a constexpr initializer, expand_default_init will
6458 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6459 case, pull the initializer back out and pass it down into
6460 store_init_value. */
6461 while (TREE_CODE (init_code
) == EXPR_STMT
6462 || TREE_CODE (init_code
) == CONVERT_EXPR
)
6463 init_code
= TREE_OPERAND (init_code
, 0);
6464 if (TREE_CODE (init_code
) == INIT_EXPR
)
6466 init
= TREE_OPERAND (init_code
, 1);
6467 init_code
= NULL_TREE
;
6468 /* Don't call digest_init; it's unnecessary and will complain
6469 about aggregate initialization of non-aggregate classes. */
6470 flags
|= LOOKUP_ALREADY_DIGESTED
;
6472 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
6474 /* Declared constexpr, but no suitable initializer; massage
6475 init appropriately so we can pass it into store_init_value
6477 if (CLASS_TYPE_P (type
)
6478 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
6480 init
= build_functional_cast (type
, init
, tf_none
);
6481 if (TREE_CODE (init
) == TARGET_EXPR
)
6482 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
6484 init_code
= NULL_TREE
;
6490 if (init
&& TREE_CODE (init
) != TREE_VEC
)
6492 /* In aggregate initialization of a variable, each element
6493 initialization is a full-expression because there is no
6494 enclosing expression. */
6495 gcc_assert (stmts_are_full_exprs_p ());
6497 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
6499 if (DECL_INITIAL (decl
)
6500 && TREE_CODE (DECL_INITIAL (decl
)) == CONSTRUCTOR
6501 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (DECL_INITIAL (decl
))))
6503 tree elt
= CONSTRUCTOR_ELTS (DECL_INITIAL (decl
))->last ().value
;
6504 if (TREE_CODE (TREE_TYPE (elt
)) == ARRAY_TYPE
6505 && TYPE_SIZE (TREE_TYPE (elt
)) == NULL_TREE
)
6506 cp_complete_array_type (&TREE_TYPE (elt
), elt
, false);
6509 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
6510 && DECL_INITIAL (decl
)
6511 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
6512 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
6513 warning_at (cp_expr_loc_or_loc (DECL_INITIAL (decl
),
6514 DECL_SOURCE_LOCATION (decl
)),
6515 0, "array %qD initialized by parenthesized "
6516 "string literal %qE",
6517 decl
, DECL_INITIAL (decl
));
6523 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
6524 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
6525 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
6526 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
6529 check_for_uninitialized_const_var (decl
, /*constexpr_context_p=*/false,
6530 tf_warning_or_error
);
6533 if (init
&& init
!= error_mark_node
)
6534 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
6538 /* We might have set these in cp_finish_decl. */
6539 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
6540 TREE_CONSTANT (decl
) = false;
6544 && (DECL_IN_AGGR_P (decl
)
6545 && DECL_INITIALIZED_IN_CLASS_P (decl
)
6546 && !DECL_VAR_DECLARED_INLINE_P (decl
)))
6548 static int explained
= 0;
6550 if (cxx_dialect
< cxx11
)
6551 error ("initializer invalid for static member with constructor");
6552 else if (cxx_dialect
< cxx17
)
6553 error ("non-constant in-class initialization invalid for static "
6554 "member %qD", decl
);
6556 error ("non-constant in-class initialization invalid for non-inline "
6557 "static member %qD", decl
);
6560 inform (input_location
,
6561 "(an out of class initialization is required)");
6570 /* If DECL is not a local variable, give it RTL. */
6573 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6575 int toplev
= toplevel_bindings_p ();
6578 /* Set the DECL_ASSEMBLER_NAME for the object. */
6581 /* The `register' keyword, when used together with an
6582 asm-specification, indicates that the variable should be
6583 placed in a particular register. */
6584 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6586 set_user_assembler_name (decl
, asmspec
);
6587 DECL_HARD_REGISTER (decl
) = 1;
6591 if (TREE_CODE (decl
) == FUNCTION_DECL
6592 && fndecl_built_in_p (decl
, BUILT_IN_NORMAL
))
6593 set_builtin_user_assembler_name (decl
, asmspec
);
6594 set_user_assembler_name (decl
, asmspec
);
6598 /* Handle non-variables up front. */
6601 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6605 /* If we see a class member here, it should be a static data
6607 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6609 gcc_assert (TREE_STATIC (decl
));
6610 /* An in-class declaration of a static data member should be
6611 external; it is only a declaration, and not a definition. */
6612 if (init
== NULL_TREE
)
6613 gcc_assert (DECL_EXTERNAL (decl
)
6614 || !TREE_PUBLIC (decl
)
6615 || DECL_INLINE_VAR_P (decl
));
6618 /* We don't create any RTL for local variables. */
6619 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6622 /* We defer emission of local statics until the corresponding
6623 DECL_EXPR is expanded. But with constexpr its function might never
6624 be expanded, so go ahead and tell cgraph about the variable now. */
6625 defer_p
= ((DECL_FUNCTION_SCOPE_P (decl
)
6626 && !var_in_maybe_constexpr_fn (decl
))
6627 || DECL_VIRTUAL_P (decl
));
6629 /* Defer template instantiations. */
6630 if (DECL_LANG_SPECIFIC (decl
)
6631 && DECL_IMPLICIT_INSTANTIATION (decl
))
6634 /* If we're not deferring, go ahead and assemble the variable. */
6636 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6639 /* walk_tree helper for wrap_temporary_cleanups, below. */
6642 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6644 /* Stop at types or full-expression boundaries. */
6645 if (TYPE_P (*stmt_p
)
6646 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6652 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6654 tree guard
= (tree
)data
;
6655 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6657 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6658 /* Tell honor_protect_cleanup_actions to handle this as a separate
6660 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6662 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6668 /* We're initializing a local variable which has a cleanup GUARD. If there
6669 are any temporaries used in the initializer INIT of this variable, we
6670 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6671 variable will be cleaned up properly if one of them throws.
6673 Unfortunately, there's no way to express this properly in terms of
6674 nesting, as the regions for the temporaries overlap the region for the
6675 variable itself; if there are two temporaries, the variable needs to be
6676 the first thing destroyed if either of them throws. However, we only
6677 want to run the variable's cleanup if it actually got constructed. So
6678 we need to guard the temporary cleanups with the variable's cleanup if
6679 they are run on the normal path, but not if they are run on the
6680 exceptional path. We implement this by telling
6681 honor_protect_cleanup_actions to strip the variable cleanup from the
6682 exceptional path. */
6685 wrap_temporary_cleanups (tree init
, tree guard
)
6687 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6690 /* Generate code to initialize DECL (a local variable). */
6693 initialize_local_var (tree decl
, tree init
)
6695 tree type
= TREE_TYPE (decl
);
6699 gcc_assert (VAR_P (decl
)
6700 || TREE_CODE (decl
) == RESULT_DECL
);
6701 gcc_assert (!TREE_STATIC (decl
));
6703 if (DECL_SIZE (decl
) == NULL_TREE
)
6705 /* If we used it already as memory, it must stay in memory. */
6706 DECL_INITIAL (decl
) = NULL_TREE
;
6707 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6711 if (type
== error_mark_node
)
6714 /* Compute and store the initial value. */
6715 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6716 if (TREE_USED (type
))
6717 DECL_READ_P (decl
) = 1;
6719 /* Generate a cleanup, if necessary. */
6720 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6722 /* Perform the initialization. */
6725 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6726 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6727 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6729 /* Stick simple initializers in DECL_INITIAL so that
6730 -Wno-init-self works (c++/34772). */
6731 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6732 DECL_INITIAL (decl
) = rinit
;
6734 if (warn_init_self
&& TYPE_REF_P (type
))
6738 warning_at (DECL_SOURCE_LOCATION (decl
),
6740 "reference %qD is initialized with itself", decl
);
6745 int saved_stmts_are_full_exprs_p
;
6747 /* If we're only initializing a single object, guard the
6748 destructors of any temporaries used in its initializer with
6749 its destructor. This isn't right for arrays because each
6750 element initialization is a full-expression. */
6751 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6752 wrap_temporary_cleanups (init
, cleanup
);
6754 gcc_assert (building_stmt_list_p ());
6755 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6756 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6757 finish_expr_stmt (init
);
6758 current_stmt_tree ()->stmts_are_full_exprs_p
=
6759 saved_stmts_are_full_exprs_p
;
6763 /* Set this to 0 so we can tell whether an aggregate which was
6764 initialized was ever used. Don't do this if it has a
6765 destructor, so we don't complain about the 'resource
6766 allocation is initialization' idiom. Now set
6767 attribute((unused)) on types so decls of that type will be
6768 marked used. (see TREE_USED, above.) */
6769 if (TYPE_NEEDS_CONSTRUCTING (type
)
6771 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6772 && DECL_NAME (decl
))
6773 TREE_USED (decl
) = 0;
6774 else if (already_used
)
6775 TREE_USED (decl
) = 1;
6778 finish_decl_cleanup (decl
, cleanup
);
6781 /* DECL is a VAR_DECL for a compiler-generated variable with static
6782 storage duration (like a virtual table) whose initializer is a
6783 compile-time constant. Initialize the variable and provide it to the
6787 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6790 gcc_assert (DECL_ARTIFICIAL (decl
));
6791 init
= build_constructor (TREE_TYPE (decl
), v
);
6792 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6793 DECL_INITIAL (decl
) = init
;
6794 DECL_INITIALIZED_P (decl
) = 1;
6795 /* Mark the decl as constexpr so that we can access its content
6797 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
6798 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
6799 determine_visibility (decl
);
6800 layout_var_decl (decl
);
6801 maybe_commonize_var (decl
);
6802 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6805 /* INIT is the initializer for a variable, as represented by the
6806 parser. Returns true iff INIT is value-dependent. */
6809 value_dependent_init_p (tree init
)
6811 if (TREE_CODE (init
) == TREE_LIST
)
6812 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6813 return any_value_dependent_elements_p (init
);
6814 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6815 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6817 if (dependent_type_p (TREE_TYPE (init
)))
6820 vec
<constructor_elt
, va_gc
> *elts
;
6824 elts
= CONSTRUCTOR_ELTS (init
);
6825 nelts
= vec_safe_length (elts
);
6826 for (i
= 0; i
< nelts
; ++i
)
6827 if (value_dependent_init_p ((*elts
)[i
].value
))
6831 /* It must be a simple expression, e.g., int i = 3; */
6832 return value_dependent_expression_p (init
);
6837 // Returns true if a DECL is VAR_DECL with the concept specifier.
6839 is_concept_var (tree decl
)
6841 return (VAR_P (decl
)
6842 // Not all variables have DECL_LANG_SPECIFIC.
6843 && DECL_LANG_SPECIFIC (decl
)
6844 && DECL_DECLARED_CONCEPT_P (decl
));
6847 /* A helper function to be called via walk_tree. If any label exists
6848 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
6851 notice_forced_label_r (tree
*tp
, int *walk_subtrees
, void *)
6855 if (TREE_CODE (*tp
) == LABEL_DECL
)
6856 cfun
->has_forced_label_in_static
= 1;
6860 /* Finish processing of a declaration;
6861 install its line number and initial value.
6862 If the length of an array type is not known before,
6863 it must be determined now, from the initial value, or it is an error.
6865 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6866 true, then INIT is an integral constant expression.
6868 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6869 if the (init) syntax was used. */
6872 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6873 tree asmspec_tree
, int flags
)
6876 vec
<tree
, va_gc
> *cleanups
= NULL
;
6877 const char *asmspec
= NULL
;
6878 int was_readonly
= 0;
6879 bool var_definition_p
= false;
6882 if (decl
== error_mark_node
)
6887 error ("assignment (not initialization) in declaration");
6891 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6892 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6893 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6895 type
= TREE_TYPE (decl
);
6896 if (type
== error_mark_node
)
6899 /* Warn about register storage specifiers except when in GNU global
6900 or local register variable extension. */
6901 if (VAR_P (decl
) && DECL_REGISTER (decl
) && asmspec_tree
== NULL_TREE
)
6903 if (cxx_dialect
>= cxx17
)
6904 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
6905 "ISO C++17 does not allow %<register%> storage "
6908 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
6909 "%<register%> storage class specifier used");
6912 /* If a name was specified, get the string. */
6913 if (at_namespace_scope_p ())
6914 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6915 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6916 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6918 if (current_class_type
6919 && CP_DECL_CONTEXT (decl
) == current_class_type
6920 && TYPE_BEING_DEFINED (current_class_type
)
6921 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6922 && (DECL_INITIAL (decl
) || init
))
6923 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6925 /* Do auto deduction unless decl is a function or an uninstantiated
6926 template specialization. */
6927 if (TREE_CODE (decl
) != FUNCTION_DECL
6928 && !(init
== NULL_TREE
6929 && DECL_LANG_SPECIFIC (decl
)
6930 && DECL_TEMPLATE_INSTANTIATION (decl
)
6931 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6932 && (auto_node
= type_uses_auto (type
)))
6935 if (init
== NULL_TREE
)
6936 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (auto_node
));
6940 if (TREE_CODE (d_init
) == TREE_LIST
6941 && !CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
6942 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6943 tf_warning_or_error
);
6944 d_init
= resolve_nondeduced_context (d_init
, tf_warning_or_error
);
6946 enum auto_deduction_context adc
= adc_variable_type
;
6947 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
6948 adc
= adc_decomp_type
;
6949 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
, auto_node
,
6950 tf_warning_or_error
, adc
,
6952 if (type
== error_mark_node
)
6954 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6956 error ("initializer for %<decltype(auto) %D%> has function type "
6957 "(did you forget the %<()%> ?)", decl
);
6958 TREE_TYPE (decl
) = error_mark_node
;
6961 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6964 if (ensure_literal_type_for_constexpr_object (decl
) == error_mark_node
)
6966 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6967 if (VAR_P (decl
) && DECL_CLASS_SCOPE_P (decl
))
6970 DECL_EXTERNAL (decl
) = 1;
6975 && DECL_CLASS_SCOPE_P (decl
)
6976 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6977 check_static_variable_definition (decl
, type
);
6979 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6982 if (init
== ridpointers
[(int)RID_DELETE
])
6984 /* FIXME check this is 1st decl. */
6985 DECL_DELETED_FN (decl
) = 1;
6986 DECL_DECLARED_INLINE_P (decl
) = 1;
6987 DECL_INITIAL (decl
) = error_mark_node
;
6988 FOR_EACH_CLONE (clone
, decl
)
6990 DECL_DELETED_FN (clone
) = 1;
6991 DECL_DECLARED_INLINE_P (clone
) = 1;
6992 DECL_INITIAL (clone
) = error_mark_node
;
6996 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6998 if (defaultable_fn_check (decl
))
6999 DECL_DEFAULTED_FN (decl
) = 1;
7001 DECL_INITIAL (decl
) = NULL_TREE
;
7005 if (init
&& VAR_P (decl
))
7007 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
7008 /* If DECL is a reference, then we want to know whether init is a
7009 reference constant; init_const_expr_p as passed tells us whether
7010 it's an rvalue constant. */
7011 if (TYPE_REF_P (type
))
7012 init_const_expr_p
= potential_constant_expression (init
);
7013 if (init_const_expr_p
)
7015 /* Set these flags now for templates. We'll update the flags in
7016 store_init_value for instantiations. */
7017 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
7018 if (decl_maybe_constant_var_p (decl
)
7019 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
7020 && !TYPE_REF_P (type
))
7021 TREE_CONSTANT (decl
) = 1;
7025 if (processing_template_decl
)
7027 bool type_dependent_p
;
7029 /* Add this declaration to the statement-tree. */
7030 if (at_function_scope_p ())
7031 add_decl_expr (decl
);
7033 type_dependent_p
= dependent_type_p (type
);
7035 if (check_for_bare_parameter_packs (init
))
7038 DECL_INITIAL (decl
) = NULL_TREE
;
7041 /* Generally, initializers in templates are expanded when the
7042 template is instantiated. But, if DECL is a variable constant
7043 then it can be used in future constant expressions, so its value
7044 must be available. */
7046 bool dep_init
= false;
7048 if (!VAR_P (decl
) || type_dependent_p
)
7049 /* We can't do anything if the decl has dependent type. */;
7050 else if (!init
&& is_concept_var (decl
))
7052 error ("variable concept has no initializer");
7053 init
= boolean_true_node
;
7056 && init_const_expr_p
7057 && !TYPE_REF_P (type
)
7058 && decl_maybe_constant_var_p (decl
)
7059 && !(dep_init
= value_dependent_init_p (init
)))
7061 /* This variable seems to be a non-dependent constant, so process
7062 its initializer. If check_initializer returns non-null the
7063 initialization wasn't constant after all. */
7065 cleanups
= make_tree_vector ();
7066 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
7067 if (init_code
== NULL_TREE
)
7069 release_tree_vector (cleanups
);
7073 gcc_assert (!DECL_PRETTY_FUNCTION_P (decl
));
7074 /* Deduce array size even if the initializer is dependent. */
7075 maybe_deduce_size_from_array_init (decl
, init
);
7076 /* And complain about multiple initializers. */
7077 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
7078 && !MAYBE_CLASS_TYPE_P (type
))
7079 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
7080 tf_warning_or_error
);
7084 DECL_INITIAL (decl
) = init
;
7088 retrofit_lang_decl (decl
);
7089 SET_DECL_DEPENDENT_INIT_P (decl
, true);
7094 /* Just store non-static data member initializers for later. */
7095 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
7096 DECL_INITIAL (decl
) = init
;
7098 /* Take care of TYPE_DECLs up front. */
7099 if (TREE_CODE (decl
) == TYPE_DECL
)
7101 if (type
!= error_mark_node
7102 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
7104 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7105 warning (0, "shadowing previous type declaration of %q#D", decl
);
7106 set_identifier_type_value (DECL_NAME (decl
), decl
);
7109 /* If we have installed this as the canonical typedef for this
7110 type, and that type has not been defined yet, delay emitting
7111 the debug information for it, as we will emit it later. */
7112 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7113 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
7114 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
7116 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
7121 /* A reference will be modified here, as it is initialized. */
7122 if (! DECL_EXTERNAL (decl
)
7123 && TREE_READONLY (decl
)
7124 && TYPE_REF_P (type
))
7127 TREE_READONLY (decl
) = 0;
7132 /* If this is a local variable that will need a mangled name,
7133 register it now. We must do this before processing the
7134 initializer for the variable, since the initialization might
7135 require a guard variable, and since the mangled name of the
7136 guard variable will depend on the mangled name of this
7138 if (DECL_FUNCTION_SCOPE_P (decl
)
7139 && TREE_STATIC (decl
)
7140 && !DECL_ARTIFICIAL (decl
))
7142 /* The variable holding an anonymous union will have had its
7143 discriminator set in finish_anon_union, after which it's
7144 NAME will have been cleared. */
7145 if (DECL_NAME (decl
))
7146 determine_local_discriminator (decl
);
7147 /* Normally has_forced_label_in_static is set during GIMPLE
7148 lowering, but [cd]tors are never actually compiled directly.
7149 We need to set this early so we can deal with the label
7150 address extension. */
7151 if ((DECL_CONSTRUCTOR_P (current_function_decl
)
7152 || DECL_DESTRUCTOR_P (current_function_decl
))
7155 walk_tree (&init
, notice_forced_label_r
, NULL
, NULL
);
7156 add_local_decl (cfun
, decl
);
7158 /* And make sure it's in the symbol table for
7159 c_parse_final_cleanups to find. */
7160 varpool_node::get_create (decl
);
7163 /* Convert the initializer to the type of DECL, if we have not
7164 already initialized DECL. */
7165 if (!DECL_INITIALIZED_P (decl
)
7166 /* If !DECL_EXTERNAL then DECL is being defined. In the
7167 case of a static data member initialized inside the
7168 class-specifier, there can be an initializer even if DECL
7169 is *not* defined. */
7170 && (!DECL_EXTERNAL (decl
) || init
))
7172 cleanups
= make_tree_vector ();
7173 init
= check_initializer (decl
, init
, flags
, &cleanups
);
7179 The memory occupied by any object of static storage
7180 duration is zero-initialized at program startup before
7181 any other initialization takes place.
7183 We cannot create an appropriate initializer until after
7184 the type of DECL is finalized. If DECL_INITIAL is set,
7185 then the DECL is statically initialized, and any
7186 necessary zero-initialization has already been performed. */
7187 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
7188 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
7189 /*nelts=*/NULL_TREE
,
7190 /*static_storage_p=*/true);
7191 /* Remember that the initialization for this variable has
7193 DECL_INITIALIZED_P (decl
) = 1;
7194 /* This declaration is the definition of this variable,
7195 unless we are initializing a static data member within
7196 the class specifier. */
7197 if (!DECL_EXTERNAL (decl
))
7198 var_definition_p
= true;
7200 /* If the variable has an array type, lay out the type, even if
7201 there is no initializer. It is valid to index through the
7202 array, and we must get TYPE_ALIGN set correctly on the array
7204 else if (TREE_CODE (type
) == ARRAY_TYPE
)
7207 if (TREE_STATIC (decl
)
7208 && !at_function_scope_p ()
7209 && current_function_decl
== NULL
)
7210 /* So decl is a global variable or a static member of a
7211 non local class. Record the types it uses
7212 so that we can decide later to emit debug info for them. */
7213 record_types_used_by_current_var_decl (decl
);
7216 /* Add this declaration to the statement-tree. This needs to happen
7217 after the call to check_initializer so that the DECL_EXPR for a
7218 reference temp is added before the DECL_EXPR for the reference itself. */
7219 if (DECL_FUNCTION_SCOPE_P (decl
))
7221 /* If we're building a variable sized type, and we might be
7222 reachable other than via the top of the current binding
7223 level, then create a new BIND_EXPR so that we deallocate
7224 the object at the right time. */
7227 && !TREE_CONSTANT (DECL_SIZE (decl
))
7228 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
7231 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
7232 TREE_SIDE_EFFECTS (bind
) = 1;
7234 BIND_EXPR_BODY (bind
) = push_stmt_list ();
7236 add_decl_expr (decl
);
7239 /* Let the middle end know about variables and functions -- but not
7240 static data members in uninstantiated class templates. */
7241 if (VAR_OR_FUNCTION_DECL_P (decl
))
7245 layout_var_decl (decl
);
7246 maybe_commonize_var (decl
);
7249 /* This needs to happen after the linkage is set. */
7250 determine_visibility (decl
);
7252 if (var_definition_p
&& TREE_STATIC (decl
))
7254 /* If a TREE_READONLY variable needs initialization
7255 at runtime, it is no longer readonly and we need to
7256 avoid MEM_READONLY_P being set on RTL created for it. */
7259 if (TREE_READONLY (decl
))
7260 TREE_READONLY (decl
) = 0;
7263 else if (was_readonly
)
7264 TREE_READONLY (decl
) = 1;
7266 /* Likewise if it needs destruction. */
7267 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
7268 TREE_READONLY (decl
) = 0;
7271 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
7273 /* Check for abstractness of the type. Notice that there is no
7274 need to strip array types here since the check for those types
7275 is already done within create_array_type_for_decl. */
7276 abstract_virtuals_error (decl
, type
);
7278 if (TREE_TYPE (decl
) == error_mark_node
)
7279 /* No initialization required. */
7281 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
7285 if (init
== ridpointers
[(int)RID_DEFAULT
])
7287 /* An out-of-class default definition is defined at
7288 the point where it is explicitly defaulted. */
7289 if (DECL_DELETED_FN (decl
))
7290 maybe_explain_implicit_delete (decl
);
7291 else if (DECL_INITIAL (decl
) == error_mark_node
)
7292 synthesize_method (decl
);
7295 error ("function %q#D is initialized like a variable", decl
);
7297 /* else no initialization required. */
7299 else if (DECL_EXTERNAL (decl
)
7300 && ! (DECL_LANG_SPECIFIC (decl
)
7301 && DECL_NOT_REALLY_EXTERN (decl
)))
7304 DECL_INITIAL (decl
) = init
;
7306 /* A variable definition. */
7307 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
7308 /* Initialize the local variable. */
7309 initialize_local_var (decl
, init
);
7311 /* If a variable is defined, and then a subsequent
7312 definition with external linkage is encountered, we will
7313 get here twice for the same variable. We want to avoid
7314 calling expand_static_init more than once. For variables
7315 that are not static data members, we can call
7316 expand_static_init only when we actually process the
7317 initializer. It is not legal to redeclare a static data
7318 member, so this issue does not arise in that case. */
7319 else if (var_definition_p
&& TREE_STATIC (decl
))
7320 expand_static_init (decl
, init
);
7323 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
7324 reference, insert it in the statement-tree now. */
7328 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
7329 push_cleanup (decl
, t
, false);
7330 release_tree_vector (cleanups
);
7334 TREE_READONLY (decl
) = 1;
7338 && lookup_attribute ("omp declare target implicit",
7339 DECL_ATTRIBUTES (decl
)))
7341 DECL_ATTRIBUTES (decl
)
7342 = remove_attribute ("omp declare target implicit",
7343 DECL_ATTRIBUTES (decl
));
7344 complete_type (TREE_TYPE (decl
));
7345 if (!cp_omp_mappable_type (TREE_TYPE (decl
)))
7346 error ("%q+D in declare target directive does not have mappable type",
7348 else if (!lookup_attribute ("omp declare target",
7349 DECL_ATTRIBUTES (decl
))
7350 && !lookup_attribute ("omp declare target link",
7351 DECL_ATTRIBUTES (decl
)))
7352 DECL_ATTRIBUTES (decl
)
7353 = tree_cons (get_identifier ("omp declare target"),
7354 NULL_TREE
, DECL_ATTRIBUTES (decl
));
7357 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
7360 /* For class TYPE return itself or some its bases that contain
7361 any direct non-static data members. Return error_mark_node if an
7362 error has been diagnosed. */
7365 find_decomp_class_base (location_t loc
, tree type
, tree ret
)
7367 bool member_seen
= false;
7368 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
7369 if (TREE_CODE (field
) != FIELD_DECL
7370 || DECL_ARTIFICIAL (field
)
7371 || DECL_UNNAMED_BIT_FIELD (field
))
7375 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
7377 if (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
)
7378 error_at (loc
, "cannot decompose class type %qT because it has an "
7379 "anonymous struct member", type
);
7381 error_at (loc
, "cannot decompose class type %qT because it has an "
7382 "anonymous union member", type
);
7383 inform (DECL_SOURCE_LOCATION (field
), "declared here");
7384 return error_mark_node
;
7386 else if (!accessible_p (type
, field
, true))
7388 error_at (loc
, "cannot decompose inaccessible member %qD of %qT",
7390 inform (DECL_SOURCE_LOCATION (field
),
7391 TREE_PRIVATE (field
)
7392 ? G_("declared private here")
7393 : G_("declared protected here"));
7394 return error_mark_node
;
7399 tree base_binfo
, binfo
;
7400 tree orig_ret
= ret
;
7404 for (binfo
= TYPE_BINFO (type
), i
= 0;
7405 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
7407 tree t
= find_decomp_class_base (loc
, TREE_TYPE (base_binfo
), ret
);
7408 if (t
== error_mark_node
)
7409 return error_mark_node
;
7410 if (t
!= NULL_TREE
&& t
!= ret
)
7414 error_at (loc
, "cannot decompose class type %qT: both it and "
7415 "its base class %qT have non-static data members",
7417 return error_mark_node
;
7419 else if (orig_ret
!= NULL_TREE
)
7421 else if (ret
!= NULL_TREE
)
7423 error_at (loc
, "cannot decompose class type %qT: its base "
7424 "classes %qT and %qT have non-static data "
7425 "members", type
, ret
, t
);
7426 return error_mark_node
;
7435 /* Return std::tuple_size<TYPE>::value. */
7438 get_tuple_size (tree type
)
7440 tree args
= make_tree_vec (1);
7441 TREE_VEC_ELT (args
, 0) = type
;
7442 tree inst
= lookup_template_class (tuple_size_identifier
, args
,
7443 /*in_decl*/NULL_TREE
,
7444 /*context*/std_node
,
7445 /*entering_scope*/false, tf_none
);
7446 inst
= complete_type (inst
);
7447 if (inst
== error_mark_node
|| !COMPLETE_TYPE_P (inst
))
7449 tree val
= lookup_qualified_name (inst
, value_identifier
,
7450 /*type*/false, /*complain*/false);
7451 if (TREE_CODE (val
) == VAR_DECL
|| TREE_CODE (val
) == CONST_DECL
)
7452 val
= maybe_constant_value (val
);
7453 if (TREE_CODE (val
) == INTEGER_CST
)
7456 return error_mark_node
;
7459 /* Return std::tuple_element<I,TYPE>::type. */
7462 get_tuple_element_type (tree type
, unsigned i
)
7464 tree args
= make_tree_vec (2);
7465 TREE_VEC_ELT (args
, 0) = build_int_cst (integer_type_node
, i
);
7466 TREE_VEC_ELT (args
, 1) = type
;
7467 tree inst
= lookup_template_class (tuple_element_identifier
, args
,
7468 /*in_decl*/NULL_TREE
,
7469 /*context*/std_node
,
7470 /*entering_scope*/false,
7471 tf_warning_or_error
);
7472 return make_typename_type (inst
, type_identifier
,
7473 none_type
, tf_warning_or_error
);
7476 /* Return e.get<i>() or get<i>(e). */
7479 get_tuple_decomp_init (tree decl
, unsigned i
)
7481 tree targs
= make_tree_vec (1);
7482 TREE_VEC_ELT (targs
, 0) = build_int_cst (integer_type_node
, i
);
7484 tree etype
= TREE_TYPE (decl
);
7485 tree e
= convert_from_reference (decl
);
7487 /* [The id-expression] e is an lvalue if the type of the entity e is an
7488 lvalue reference and an xvalue otherwise. */
7489 if (!TYPE_REF_P (etype
)
7490 || TYPE_REF_IS_RVALUE (etype
))
7493 tree fns
= lookup_qualified_name (TREE_TYPE (e
), get__identifier
,
7494 /*type*/false, /*complain*/false);
7495 bool use_member_get
= false;
7497 /* To use a member get, member lookup must find at least one
7498 declaration that is a function template
7499 whose first template parameter is a non-type parameter. */
7500 for (lkp_iterator
iter (MAYBE_BASELINK_FUNCTIONS (fns
)); iter
; ++iter
)
7503 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
7505 tree tparms
= DECL_TEMPLATE_PARMS (fn
);
7506 tree parm
= TREE_VEC_ELT (INNERMOST_TEMPLATE_PARMS (tparms
), 0);
7507 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
7509 use_member_get
= true;
7517 fns
= lookup_template_function (fns
, targs
);
7518 return build_new_method_call (e
, fns
, /*args*/NULL
,
7519 /*path*/NULL_TREE
, LOOKUP_NORMAL
,
7520 /*fn_p*/NULL
, tf_warning_or_error
);
7524 vec
<tree
,va_gc
> *args
= make_tree_vector_single (e
);
7525 fns
= lookup_template_function (get__identifier
, targs
);
7526 fns
= perform_koenig_lookup (fns
, args
, tf_warning_or_error
);
7527 return finish_call_expr (fns
, &args
, /*novirt*/false,
7528 /*koenig*/true, tf_warning_or_error
);
7532 /* It's impossible to recover the decltype of a tuple decomposition variable
7533 based on the actual type of the variable, so store it in a hash table. */
7535 static GTY((cache
)) tree_cache_map
*decomp_type_table
;
7537 store_decomp_type (tree v
, tree t
)
7539 if (!decomp_type_table
)
7540 decomp_type_table
= tree_cache_map::create_ggc (13);
7541 decomp_type_table
->put (v
, t
);
7545 lookup_decomp_type (tree v
)
7547 return *decomp_type_table
->get (v
);
7550 /* Mangle a decomposition declaration if needed. Arguments like
7551 in cp_finish_decomp. */
7554 cp_maybe_mangle_decomp (tree decl
, tree first
, unsigned int count
)
7556 if (!processing_template_decl
7557 && !error_operand_p (decl
)
7558 && DECL_NAMESPACE_SCOPE_P (decl
))
7560 auto_vec
<tree
, 16> v
;
7561 v
.safe_grow (count
);
7563 for (unsigned int i
= 0; i
< count
; i
++, d
= DECL_CHAIN (d
))
7564 v
[count
- i
- 1] = d
;
7565 SET_DECL_ASSEMBLER_NAME (decl
, mangle_decomp (decl
, v
));
7566 maybe_apply_pragma_weak (decl
);
7570 /* Finish a decomposition declaration. DECL is the underlying declaration
7571 "e", FIRST is the head of a chain of decls for the individual identifiers
7572 chained through DECL_CHAIN in reverse order and COUNT is the number of
7576 cp_finish_decomp (tree decl
, tree first
, unsigned int count
)
7578 if (error_operand_p (decl
))
7583 TREE_TYPE (first
) = error_mark_node
;
7584 if (DECL_HAS_VALUE_EXPR_P (first
))
7586 SET_DECL_VALUE_EXPR (first
, NULL_TREE
);
7587 DECL_HAS_VALUE_EXPR_P (first
) = 0;
7589 first
= DECL_CHAIN (first
);
7591 if (DECL_P (decl
) && DECL_NAMESPACE_SCOPE_P (decl
))
7592 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier ("<decomp>"));
7596 location_t loc
= DECL_SOURCE_LOCATION (decl
);
7597 if (type_dependent_expression_p (decl
)
7598 /* This happens for range for when not in templates.
7599 Still add the DECL_VALUE_EXPRs for later processing. */
7600 || (!processing_template_decl
7601 && type_uses_auto (TREE_TYPE (decl
))))
7603 for (unsigned int i
= 0; i
< count
; i
++)
7605 if (!DECL_HAS_VALUE_EXPR_P (first
))
7607 tree v
= build_nt (ARRAY_REF
, decl
,
7608 size_int (count
- i
- 1),
7609 NULL_TREE
, NULL_TREE
);
7610 SET_DECL_VALUE_EXPR (first
, v
);
7611 DECL_HAS_VALUE_EXPR_P (first
) = 1;
7613 if (processing_template_decl
)
7614 fit_decomposition_lang_decl (first
, decl
);
7615 first
= DECL_CHAIN (first
);
7620 auto_vec
<tree
, 16> v
;
7621 v
.safe_grow (count
);
7623 for (unsigned int i
= 0; i
< count
; i
++, d
= DECL_CHAIN (d
))
7625 v
[count
- i
- 1] = d
;
7626 fit_decomposition_lang_decl (d
, decl
);
7629 tree type
= TREE_TYPE (decl
);
7632 if (TYPE_REF_P (type
))
7634 dexp
= convert_from_reference (dexp
);
7635 type
= complete_type (TREE_TYPE (type
));
7636 if (type
== error_mark_node
)
7638 if (!COMPLETE_TYPE_P (type
))
7640 error_at (loc
, "structured binding refers to incomplete type %qT",
7646 tree eltype
= NULL_TREE
;
7647 unsigned HOST_WIDE_INT eltscnt
= 0;
7648 if (TREE_CODE (type
) == ARRAY_TYPE
)
7651 nelts
= array_type_nelts_top (type
);
7652 if (nelts
== error_mark_node
)
7654 if (!tree_fits_uhwi_p (nelts
))
7656 error_at (loc
, "cannot decompose variable length array %qT", type
);
7659 eltscnt
= tree_to_uhwi (nelts
);
7660 if (count
!= eltscnt
)
7663 if (count
> eltscnt
)
7664 error_n (loc
, count
,
7665 "%u name provided for structured binding",
7666 "%u names provided for structured binding", count
);
7668 error_n (loc
, count
,
7669 "only %u name provided for structured binding",
7670 "only %u names provided for structured binding", count
);
7671 inform_n (loc
, eltscnt
,
7672 "while %qT decomposes into %wu element",
7673 "while %qT decomposes into %wu elements",
7677 eltype
= TREE_TYPE (type
);
7678 for (unsigned int i
= 0; i
< count
; i
++)
7680 TREE_TYPE (v
[i
]) = eltype
;
7681 layout_decl (v
[i
], 0);
7682 if (processing_template_decl
)
7684 tree t
= unshare_expr (dexp
);
7685 t
= build4_loc (DECL_SOURCE_LOCATION (v
[i
]), ARRAY_REF
,
7686 eltype
, t
, size_int (i
), NULL_TREE
,
7688 SET_DECL_VALUE_EXPR (v
[i
], t
);
7689 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7692 /* 2 GNU extensions. */
7693 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
7696 if (count
!= eltscnt
)
7698 eltype
= cp_build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
7699 for (unsigned int i
= 0; i
< count
; i
++)
7701 TREE_TYPE (v
[i
]) = eltype
;
7702 layout_decl (v
[i
], 0);
7703 if (processing_template_decl
)
7705 tree t
= unshare_expr (dexp
);
7706 t
= build1_loc (DECL_SOURCE_LOCATION (v
[i
]),
7707 i
? IMAGPART_EXPR
: REALPART_EXPR
, eltype
,
7709 SET_DECL_VALUE_EXPR (v
[i
], t
);
7710 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7713 else if (TREE_CODE (type
) == VECTOR_TYPE
)
7715 if (!TYPE_VECTOR_SUBPARTS (type
).is_constant (&eltscnt
))
7717 error_at (loc
, "cannot decompose variable length vector %qT", type
);
7720 if (count
!= eltscnt
)
7722 eltype
= cp_build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
7723 for (unsigned int i
= 0; i
< count
; i
++)
7725 TREE_TYPE (v
[i
]) = eltype
;
7726 layout_decl (v
[i
], 0);
7727 if (processing_template_decl
)
7729 tree t
= unshare_expr (dexp
);
7730 convert_vector_to_array_for_subscript (DECL_SOURCE_LOCATION (v
[i
]),
7732 t
= build4_loc (DECL_SOURCE_LOCATION (v
[i
]), ARRAY_REF
,
7733 eltype
, t
, size_int (i
), NULL_TREE
,
7735 SET_DECL_VALUE_EXPR (v
[i
], t
);
7736 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7739 else if (tree tsize
= get_tuple_size (type
))
7741 if (tsize
== error_mark_node
)
7743 error_at (loc
, "%<std::tuple_size<%T>::value%> is not an integral "
7744 "constant expression", type
);
7747 if (!tree_fits_uhwi_p (tsize
))
7749 error_n (loc
, count
,
7750 "%u name provided for structured binding",
7751 "%u names provided for structured binding", count
);
7752 inform (loc
, "while %qT decomposes into %E elements",
7756 eltscnt
= tree_to_uhwi (tsize
);
7757 if (count
!= eltscnt
)
7759 int save_read
= DECL_READ_P (decl
);
7760 for (unsigned i
= 0; i
< count
; ++i
)
7762 location_t sloc
= input_location
;
7763 location_t dloc
= DECL_SOURCE_LOCATION (v
[i
]);
7765 input_location
= dloc
;
7766 tree init
= get_tuple_decomp_init (decl
, i
);
7767 tree eltype
= (init
== error_mark_node
? error_mark_node
7768 : get_tuple_element_type (type
, i
));
7769 input_location
= sloc
;
7771 if (init
== error_mark_node
|| eltype
== error_mark_node
)
7773 inform (dloc
, "in initialization of structured binding "
7774 "variable %qD", v
[i
]);
7777 /* Save the decltype away before reference collapse. */
7778 store_decomp_type (v
[i
], eltype
);
7779 eltype
= cp_build_reference_type (eltype
, !lvalue_p (init
));
7780 TREE_TYPE (v
[i
]) = eltype
;
7781 layout_decl (v
[i
], 0);
7782 if (DECL_HAS_VALUE_EXPR_P (v
[i
]))
7784 /* In this case the names are variables, not just proxies. */
7785 SET_DECL_VALUE_EXPR (v
[i
], NULL_TREE
);
7786 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 0;
7788 if (!processing_template_decl
)
7789 cp_finish_decl (v
[i
], init
, /*constexpr*/false,
7790 /*asm*/NULL_TREE
, LOOKUP_NORMAL
);
7792 /* Ignore reads from the underlying decl performed during initialization
7793 of the individual variables. If those will be read, we'll mark
7794 the underlying decl as read at that point. */
7795 DECL_READ_P (decl
) = save_read
;
7797 else if (TREE_CODE (type
) == UNION_TYPE
)
7799 error_at (loc
, "cannot decompose union type %qT", type
);
7802 else if (!CLASS_TYPE_P (type
))
7804 error_at (loc
, "cannot decompose non-array non-class type %qT", type
);
7807 else if (LAMBDA_TYPE_P (type
))
7809 error_at (loc
, "cannot decompose lambda closure type %qT", type
);
7812 else if (processing_template_decl
&& !COMPLETE_TYPE_P (type
))
7813 pedwarn (loc
, 0, "structured binding refers to incomplete class type %qT",
7817 tree btype
= find_decomp_class_base (loc
, type
, NULL_TREE
);
7818 if (btype
== error_mark_node
)
7820 else if (btype
== NULL_TREE
)
7822 error_at (loc
, "cannot decompose class type %qT without non-static "
7823 "data members", type
);
7826 for (tree field
= TYPE_FIELDS (btype
); field
; field
= TREE_CHAIN (field
))
7827 if (TREE_CODE (field
) != FIELD_DECL
7828 || DECL_ARTIFICIAL (field
)
7829 || DECL_UNNAMED_BIT_FIELD (field
))
7833 if (count
!= eltscnt
)
7838 t
= convert_to_base (t
, btype
, /*check_access*/true,
7839 /*nonnull*/false, tf_warning_or_error
);
7843 for (tree field
= TYPE_FIELDS (btype
); field
; field
= TREE_CHAIN (field
))
7844 if (TREE_CODE (field
) != FIELD_DECL
7845 || DECL_ARTIFICIAL (field
)
7846 || DECL_UNNAMED_BIT_FIELD (field
))
7850 tree tt
= finish_non_static_data_member (field
, unshare_expr (t
),
7852 if (REFERENCE_REF_P (tt
))
7853 tt
= TREE_OPERAND (tt
, 0);
7854 TREE_TYPE (v
[i
]) = TREE_TYPE (tt
);
7855 layout_decl (v
[i
], 0);
7856 if (!processing_template_decl
)
7858 SET_DECL_VALUE_EXPR (v
[i
], tt
);
7859 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7864 if (processing_template_decl
)
7866 for (unsigned int i
= 0; i
< count
; i
++)
7867 if (!DECL_HAS_VALUE_EXPR_P (v
[i
]))
7869 tree a
= build_nt (ARRAY_REF
, decl
, size_int (i
),
7870 NULL_TREE
, NULL_TREE
);
7871 SET_DECL_VALUE_EXPR (v
[i
], a
);
7872 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7877 /* Returns a declaration for a VAR_DECL as if:
7879 extern "C" TYPE NAME;
7881 had been seen. Used to create compiler-generated global
7885 declare_global_var (tree name
, tree type
)
7889 push_to_top_level ();
7890 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7891 TREE_PUBLIC (decl
) = 1;
7892 DECL_EXTERNAL (decl
) = 1;
7893 DECL_ARTIFICIAL (decl
) = 1;
7894 DECL_CONTEXT (decl
) = FROB_CONTEXT (global_namespace
);
7895 /* If the user has explicitly declared this variable (perhaps
7896 because the code we are compiling is part of a low-level runtime
7897 library), then it is possible that our declaration will be merged
7898 with theirs by pushdecl. */
7899 decl
= pushdecl (decl
);
7900 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
7901 pop_from_top_level ();
7906 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
7907 if "__cxa_atexit" is not being used) corresponding to the function
7908 to be called when the program exits. */
7911 get_atexit_fn_ptr_type (void)
7915 if (!atexit_fn_ptr_type_node
)
7918 if (flag_use_cxa_atexit
7919 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7920 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
7921 arg_type
= ptr_type_node
;
7923 /* The parameter to "atexit" is "void (*)(void)". */
7924 arg_type
= NULL_TREE
;
7926 fn_type
= build_function_type_list (void_type_node
,
7927 arg_type
, NULL_TREE
);
7928 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
7931 return atexit_fn_ptr_type_node
;
7934 /* Returns a pointer to the `atexit' function. Note that if
7935 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
7936 `__cxa_atexit' function specified in the IA64 C++ ABI. */
7939 get_atexit_node (void)
7945 bool use_aeabi_atexit
;
7950 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7952 /* The declaration for `__cxa_atexit' is:
7954 int __cxa_atexit (void (*)(void *), void *, void *)
7956 We build up the argument types and then the function type
7958 tree argtype0
, argtype1
, argtype2
;
7960 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
7961 /* First, build the pointer-to-function type for the first
7963 fn_ptr_type
= get_atexit_fn_ptr_type ();
7964 /* Then, build the rest of the argument types. */
7965 argtype2
= ptr_type_node
;
7966 if (use_aeabi_atexit
)
7968 argtype1
= fn_ptr_type
;
7969 argtype0
= ptr_type_node
;
7973 argtype1
= ptr_type_node
;
7974 argtype0
= fn_ptr_type
;
7976 /* And the final __cxa_atexit type. */
7977 fn_type
= build_function_type_list (integer_type_node
,
7978 argtype0
, argtype1
, argtype2
,
7980 if (use_aeabi_atexit
)
7981 name
= "__aeabi_atexit";
7983 name
= "__cxa_atexit";
7987 /* The declaration for `atexit' is:
7989 int atexit (void (*)());
7991 We build up the argument types and then the function type
7993 fn_ptr_type
= get_atexit_fn_ptr_type ();
7994 /* Build the final atexit type. */
7995 fn_type
= build_function_type_list (integer_type_node
,
7996 fn_ptr_type
, NULL_TREE
);
8000 /* Now, build the function declaration. */
8001 push_lang_context (lang_name_c
);
8002 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
8003 mark_used (atexit_fndecl
);
8004 pop_lang_context ();
8005 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
8010 /* Like get_atexit_node, but for thread-local cleanups. */
8013 get_thread_atexit_node (void)
8015 /* The declaration for `__cxa_thread_atexit' is:
8017 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
8018 tree fn_type
= build_function_type_list (integer_type_node
,
8019 get_atexit_fn_ptr_type (),
8020 ptr_type_node
, ptr_type_node
,
8023 /* Now, build the function declaration. */
8024 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
8025 ECF_LEAF
| ECF_NOTHROW
);
8026 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
8029 /* Returns the __dso_handle VAR_DECL. */
8032 get_dso_handle_node (void)
8034 if (dso_handle_node
)
8035 return dso_handle_node
;
8037 /* Declare the variable. */
8038 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
8041 #ifdef HAVE_GAS_HIDDEN
8042 if (dso_handle_node
!= error_mark_node
)
8044 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
8045 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
8049 return dso_handle_node
;
8052 /* Begin a new function with internal linkage whose job will be simply
8053 to destroy some particular variable. */
8055 static GTY(()) int start_cleanup_cnt
;
8058 start_cleanup_fn (void)
8063 bool use_cxa_atexit
= flag_use_cxa_atexit
8064 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
8066 push_to_top_level ();
8068 /* No need to mangle this. */
8069 push_lang_context (lang_name_c
);
8071 /* Build the name of the function. */
8072 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
8073 /* Build the function declaration. */
8074 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
8075 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
8076 /* It's a function with internal linkage, generated by the
8078 TREE_PUBLIC (fndecl
) = 0;
8079 DECL_ARTIFICIAL (fndecl
) = 1;
8080 /* Make the function `inline' so that it is only emitted if it is
8081 actually needed. It is unlikely that it will be inlined, since
8082 it is only called via a function pointer, but we avoid unnecessary
8083 emissions this way. */
8084 DECL_DECLARED_INLINE_P (fndecl
) = 1;
8085 DECL_INTERFACE_KNOWN (fndecl
) = 1;
8086 /* Build the parameter. */
8089 tree parmdecl
= cp_build_parm_decl (fndecl
, NULL_TREE
, ptr_type_node
);
8090 TREE_USED (parmdecl
) = 1;
8091 DECL_READ_P (parmdecl
) = 1;
8092 DECL_ARGUMENTS (fndecl
) = parmdecl
;
8096 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
8098 pop_lang_context ();
8100 return current_function_decl
;
8103 /* Finish the cleanup function begun by start_cleanup_fn. */
8106 end_cleanup_fn (void)
8108 expand_or_defer_fn (finish_function (/*inline_p=*/false));
8110 pop_from_top_level ();
8113 /* Generate code to handle the destruction of DECL, an object with
8114 static storage duration. */
8117 register_dtor_fn (tree decl
)
8124 bool ob_parm
, dso_parm
, use_dtor
;
8125 tree arg0
, arg1
, arg2
;
8128 type
= TREE_TYPE (decl
);
8129 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
8132 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
8133 "__aeabi_atexit"), and DECL is a class object, we can just pass the
8134 destructor to "__cxa_atexit"; we don't have to build a temporary
8135 function to do the cleanup. */
8136 dso_parm
= (flag_use_cxa_atexit
8137 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
8138 ob_parm
= (CP_DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
8139 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
8142 cleanup
= get_class_binding (type
, complete_dtor_identifier
);
8144 /* Make sure it is accessible. */
8145 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
8146 tf_warning_or_error
);
8150 /* Call build_cleanup before we enter the anonymous function so
8151 that any access checks will be done relative to the current
8152 scope, rather than the scope of the anonymous function. */
8153 build_cleanup (decl
);
8155 /* Now start the function. */
8156 cleanup
= start_cleanup_fn ();
8158 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8159 to the original function, rather than the anonymous one. That
8160 will make the back end think that nested functions are in use,
8161 which causes confusion. */
8162 push_deferring_access_checks (dk_no_check
);
8163 fcall
= build_cleanup (decl
);
8164 pop_deferring_access_checks ();
8166 /* Create the body of the anonymous function. */
8167 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
8168 finish_expr_stmt (fcall
);
8169 finish_compound_stmt (compound_stmt
);
8173 /* Call atexit with the cleanup function. */
8174 mark_used (cleanup
);
8175 cleanup
= build_address (cleanup
);
8177 if (CP_DECL_THREAD_LOCAL_P (decl
))
8178 atex_node
= get_thread_atexit_node ();
8180 atex_node
= get_atexit_node ();
8184 /* We must convert CLEANUP to the type that "__cxa_atexit"
8186 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
8187 /* "__cxa_atexit" will pass the address of DECL to the
8188 cleanup function. */
8190 addr
= build_address (decl
);
8191 /* The declared type of the parameter to "__cxa_atexit" is
8192 "void *". For plain "T*", we could just let the
8193 machinery in cp_build_function_call convert it -- but if the
8194 type is "cv-qualified T *", then we need to convert it
8195 before passing it in, to avoid spurious errors. */
8196 addr
= build_nop (ptr_type_node
, addr
);
8199 /* Since the cleanup functions we build ignore the address
8200 they're given, there's no reason to pass the actual address
8201 in, and, in general, it's cheaper to pass NULL than any
8203 addr
= null_pointer_node
;
8206 arg2
= cp_build_addr_expr (get_dso_handle_node (),
8207 tf_warning_or_error
);
8209 /* Just pass NULL to the dso handle parm if we don't actually
8210 have a DSO handle on this target. */
8211 arg2
= null_pointer_node
;
8217 if (!CP_DECL_THREAD_LOCAL_P (decl
)
8218 && targetm
.cxx
.use_aeabi_atexit ())
8234 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
8235 arg0
, arg1
, arg2
, NULL_TREE
);
8238 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
8239 is its initializer. Generate code to handle the construction
8240 and destruction of DECL. */
8243 expand_static_init (tree decl
, tree init
)
8245 gcc_assert (VAR_P (decl
));
8246 gcc_assert (TREE_STATIC (decl
));
8248 /* Some variables require no dynamic initialization. */
8249 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
8251 /* Make sure the destructor is callable. */
8252 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
8257 if (CP_DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
8258 && !DECL_FUNCTION_SCOPE_P (decl
))
8260 location_t dloc
= DECL_SOURCE_LOCATION (decl
);
8262 error_at (dloc
, "non-local variable %qD declared %<__thread%> "
8263 "needs dynamic initialization", decl
);
8265 error_at (dloc
, "non-local variable %qD declared %<__thread%> "
8266 "has a non-trivial destructor", decl
);
8267 static bool informed
;
8270 inform (dloc
, "C++11 %<thread_local%> allows dynamic "
8271 "initialization and destruction");
8277 if (DECL_FUNCTION_SCOPE_P (decl
))
8279 /* Emit code to perform this initialization but once. */
8280 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
8281 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
8282 tree guard
, guard_addr
;
8284 /* We don't need thread-safety code for thread-local vars. */
8285 bool thread_guard
= (flag_threadsafe_statics
8286 && !CP_DECL_THREAD_LOCAL_P (decl
));
8288 /* Emit code to perform this initialization but once. This code
8291 static <type> guard;
8292 if (!__atomic_load (guard.first_byte)) {
8293 if (__cxa_guard_acquire (&guard)) {
8296 // Do initialization.
8297 flag = true; __cxa_guard_release (&guard);
8298 // Register variable for destruction at end of program.
8300 if (!flag) __cxa_guard_abort (&guard);
8305 Note that the `flag' variable is only set to 1 *after* the
8306 initialization is complete. This ensures that an exception,
8307 thrown during the construction, will cause the variable to
8308 reinitialized when we pass through this code again, as per:
8312 If the initialization exits by throwing an exception, the
8313 initialization is not complete, so it will be tried again
8314 the next time control enters the declaration.
8316 This process should be thread-safe, too; multiple threads
8317 should not be able to initialize the variable more than
8320 /* Create the guard variable. */
8321 guard
= get_guard (decl
);
8323 /* Begin the conditional initialization. */
8324 if_stmt
= begin_if_stmt ();
8326 finish_if_stmt_cond (get_guard_cond (guard
, thread_guard
), if_stmt
);
8327 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
8331 tree vfntype
= NULL_TREE
;
8332 tree acquire_name
, release_name
, abort_name
;
8333 tree acquire_fn
, release_fn
, abort_fn
;
8334 guard_addr
= build_address (guard
);
8336 acquire_name
= get_identifier ("__cxa_guard_acquire");
8337 release_name
= get_identifier ("__cxa_guard_release");
8338 abort_name
= get_identifier ("__cxa_guard_abort");
8339 acquire_fn
= get_global_binding (acquire_name
);
8340 release_fn
= get_global_binding (release_name
);
8341 abort_fn
= get_global_binding (abort_name
);
8343 acquire_fn
= push_library_fn
8344 (acquire_name
, build_function_type_list (integer_type_node
,
8345 TREE_TYPE (guard_addr
),
8347 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
8348 if (!release_fn
|| !abort_fn
)
8349 vfntype
= build_function_type_list (void_type_node
,
8350 TREE_TYPE (guard_addr
),
8353 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
8354 ECF_NOTHROW
| ECF_LEAF
);
8356 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
8357 ECF_NOTHROW
| ECF_LEAF
);
8359 inner_if_stmt
= begin_if_stmt ();
8360 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
8363 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
8364 begin
= get_target_expr (boolean_false_node
);
8365 flag
= TARGET_EXPR_SLOT (begin
);
8367 TARGET_EXPR_CLEANUP (begin
)
8368 = build3 (COND_EXPR
, void_type_node
, flag
,
8370 build_call_n (abort_fn
, 1, guard_addr
));
8371 CLEANUP_EH_ONLY (begin
) = 1;
8373 /* Do the initialization itself. */
8374 init
= add_stmt_to_compound (begin
, init
);
8375 init
= add_stmt_to_compound
8376 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
8377 init
= add_stmt_to_compound
8378 (init
, build_call_n (release_fn
, 1, guard_addr
));
8381 init
= add_stmt_to_compound (init
, set_guard (guard
));
8383 /* Use atexit to register a function for destroying this static
8385 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
8387 finish_expr_stmt (init
);
8391 finish_compound_stmt (inner_then_clause
);
8392 finish_then_clause (inner_if_stmt
);
8393 finish_if_stmt (inner_if_stmt
);
8396 finish_compound_stmt (then_clause
);
8397 finish_then_clause (if_stmt
);
8398 finish_if_stmt (if_stmt
);
8400 else if (CP_DECL_THREAD_LOCAL_P (decl
))
8401 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
8403 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
8407 /* Make TYPE a complete type based on INITIAL_VALUE.
8408 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8409 2 if there was no information (in which case assume 0 if DO_DEFAULT),
8410 3 if the initializer list is empty (in pedantic mode). */
8413 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
8416 tree type
, elt_type
;
8418 /* Don't get confused by a CONSTRUCTOR for some other type. */
8419 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
8420 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
)
8421 && TREE_CODE (TREE_TYPE (initial_value
)) != ARRAY_TYPE
)
8426 unsigned HOST_WIDE_INT i
;
8429 /* An array of character type can be initialized from a
8430 brace-enclosed string constant.
8432 FIXME: this code is duplicated from reshape_init. Probably
8433 we should just call reshape_init here? */
8434 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
8435 && TREE_CODE (initial_value
) == CONSTRUCTOR
8436 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
8438 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
8439 tree value
= (*v
)[0].value
;
8440 STRIP_ANY_LOCATION_WRAPPER (value
);
8442 if (TREE_CODE (value
) == STRING_CST
8443 && v
->length () == 1)
8444 initial_value
= value
;
8447 /* If any of the elements are parameter packs, we can't actually
8448 complete this type now because the array size is dependent. */
8449 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8451 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
8454 if (PACK_EXPANSION_P (value
))
8460 failure
= complete_array_type (ptype
, initial_value
, do_default
);
8462 /* We can create the array before the element type is complete, which
8463 means that we didn't have these two bits set in the original type
8464 either. In completing the type, we are expected to propagate these
8465 bits. See also complete_type which does the same thing for arrays
8468 if (type
!= error_mark_node
&& TYPE_DOMAIN (type
))
8470 elt_type
= TREE_TYPE (type
);
8471 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
8472 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
8473 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
8479 /* As above, but either give an error or reject zero-size arrays, depending
8483 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
8484 bool do_default
, tsubst_flags_t complain
)
8487 bool sfinae
= !(complain
& tf_error
);
8488 /* In SFINAE context we can't be lenient about zero-size arrays. */
8491 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
8497 /* Not an error. */;
8498 else if (failure
== 1)
8499 error ("initializer fails to determine size of %qT", *ptype
);
8500 else if (failure
== 2)
8503 error ("array size missing in %qT", *ptype
);
8505 else if (failure
== 3)
8506 error ("zero-size array %qT", *ptype
);
8507 *ptype
= error_mark_node
;
8512 /* Return zero if something is declared to be a member of type
8513 CTYPE when in the context of CUR_TYPE. STRING is the error
8514 message to print in that case. Otherwise, quietly return 1. */
8517 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
8519 if (ctype
&& ctype
!= cur_type
)
8521 if (flags
== DTOR_FLAG
)
8522 error ("destructor for alien class %qT cannot be a member", ctype
);
8524 error ("constructor for alien class %qT cannot be a member", ctype
);
8530 /* Subroutine of `grokdeclarator'. */
8532 /* Generate errors possibly applicable for a given set of specifiers.
8533 This is for ARM $7.1.2. */
8536 bad_specifiers (tree object
,
8537 enum bad_spec_place type
,
8543 const location_t
* locations
)
8549 error_at (locations
[ds_virtual
],
8550 "%qD declared as a %<virtual%> variable", object
);
8552 error ("%<const%> and %<volatile%> function specifiers on "
8553 "%qD invalid in variable declaration", object
);
8557 error_at (locations
[ds_virtual
],
8558 "%qD declared as a %<virtual%> parameter", object
);
8560 error_at (locations
[ds_inline
],
8561 "%qD declared as an %<inline%> parameter", object
);
8563 error ("%<const%> and %<volatile%> function specifiers on "
8564 "%qD invalid in parameter declaration", object
);
8568 error_at (locations
[ds_virtual
],
8569 "%qD declared as a %<virtual%> type", object
);
8571 error_at (locations
[ds_inline
],
8572 "%qD declared as an %<inline%> type", object
);
8574 error ("%<const%> and %<volatile%> function specifiers on "
8575 "%qD invalid in type declaration", object
);
8579 error_at (locations
[ds_virtual
],
8580 "%qD declared as a %<virtual%> field", object
);
8582 error_at (locations
[ds_inline
],
8583 "%qD declared as an %<inline%> field", object
);
8585 error ("%<const%> and %<volatile%> function specifiers on "
8586 "%qD invalid in field declaration", object
);
8592 error ("%q+D declared as a friend", object
);
8594 && !flag_noexcept_type
8595 && (TREE_CODE (object
) == TYPE_DECL
8596 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
8597 && !TYPE_REFFN_P (TREE_TYPE (object
))
8598 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
8599 error ("%q+D declared with an exception specification", object
);
8602 /* DECL is a member function or static data member and is presently
8603 being defined. Check that the definition is taking place in a
8607 check_class_member_definition_namespace (tree decl
)
8609 /* These checks only apply to member functions and static data
8611 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
8612 /* We check for problems with specializations in pt.c in
8613 check_specialization_namespace, where we can issue better
8615 if (processing_specialization
)
8617 /* We check this in check_explicit_instantiation_namespace. */
8618 if (processing_explicit_instantiation
)
8622 A member function definition that appears outside of the
8623 class definition shall appear in a namespace scope enclosing
8624 the class definition.
8628 The definition for a static data member shall appear in a
8629 namespace scope enclosing the member's class definition. */
8630 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
8631 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
8632 decl
, DECL_CONTEXT (decl
));
8635 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
8636 METHOD_TYPE for a non-static member function; QUALS are the
8637 cv-qualifiers that apply to the function. */
8640 build_this_parm (tree fn
, tree type
, cp_cv_quals quals
)
8645 cp_cv_quals this_quals
;
8647 if (CLASS_TYPE_P (type
))
8650 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
8651 this_type
= build_pointer_type (this_type
);
8654 this_type
= type_of_this_parm (type
);
8655 /* The `this' parameter is implicitly `const'; it cannot be
8657 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
8658 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
8659 parm
= build_artificial_parm (fn
, this_identifier
, qual_type
);
8660 cp_apply_type_quals_to_decl (this_quals
, parm
);
8664 /* DECL is a static member function. Complain if it was declared
8665 with function-cv-quals. */
8668 check_static_quals (tree decl
, cp_cv_quals quals
)
8670 if (quals
!= TYPE_UNQUALIFIED
)
8671 error ("static member function %q#D declared with type qualifiers",
8675 // Check that FN takes no arguments and returns bool.
8677 check_concept_fn (tree fn
)
8679 // A constraint is nullary.
8680 if (DECL_ARGUMENTS (fn
))
8681 error_at (DECL_SOURCE_LOCATION (fn
),
8682 "concept %q#D declared with function parameters", fn
);
8684 // The declared return type of the concept shall be bool, and
8685 // it shall not be deduced from it definition.
8686 tree type
= TREE_TYPE (TREE_TYPE (fn
));
8688 error_at (DECL_SOURCE_LOCATION (fn
),
8689 "concept %q#D declared with a deduced return type", fn
);
8690 else if (type
!= boolean_type_node
)
8691 error_at (DECL_SOURCE_LOCATION (fn
),
8692 "concept %q#D with non-%<bool%> return type %qT", fn
, type
);
8695 /* Helper function. Replace the temporary this parameter injected
8696 during cp_finish_omp_declare_simd with the real this parameter. */
8699 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
8701 tree this_parm
= (tree
) data
;
8702 if (TREE_CODE (*tp
) == PARM_DECL
8703 && DECL_NAME (*tp
) == this_identifier
8704 && *tp
!= this_parm
)
8706 else if (TYPE_P (*tp
))
8711 /* CTYPE is class type, or null if non-class.
8712 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8714 DECLARATOR is the function's name.
8715 PARMS is a chain of PARM_DECLs for the function.
8716 VIRTUALP is truthvalue of whether the function is virtual or not.
8717 FLAGS are to be passed through to `grokclassfn'.
8718 QUALS are qualifiers indicating whether the function is `const'
8720 RAISES is a list of exceptions that this function can raise.
8721 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8722 not look, and -1 if we should not call `grokclassfn' at all.
8724 SFK is the kind of special function (if any) for the new function.
8726 Returns `NULL_TREE' if something goes wrong, after issuing
8727 applicable error messages. */
8730 grokfndecl (tree ctype
,
8734 tree orig_declarator
,
8735 const cp_decl_specifier_seq
*declspecs
,
8738 enum overload_flags flags
,
8740 cp_ref_qualifier rqual
,
8747 special_function_kind sfk
,
8749 bool late_return_type_p
,
8753 location_t location
)
8756 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8759 if (location
== UNKNOWN_LOCATION
)
8760 location
= input_location
;
8762 // Was the concept specifier present?
8763 bool concept_p
= inlinep
& 4;
8765 // Concept declarations must have a corresponding definition.
8766 if (concept_p
&& !funcdef_flag
)
8768 error_at (location
, "concept %qD has no definition", declarator
);
8772 type
= build_cp_fntype_variant (type
, rqual
, raises
, late_return_type_p
);
8774 decl
= build_lang_decl_loc (location
, FUNCTION_DECL
, declarator
, type
);
8776 /* Set the constraints on the declaration. */
8779 tree tmpl_reqs
= NULL_TREE
;
8780 if (processing_template_decl
> template_class_depth (ctype
))
8781 tmpl_reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
8783 /* Adjust the required expression into a constraint. */
8785 decl_reqs
= normalize_expression (decl_reqs
);
8787 tree ci
= build_constraints (tmpl_reqs
, decl_reqs
);
8788 set_constraints (decl
, ci
);
8791 if (TREE_CODE (type
) == METHOD_TYPE
)
8793 tree parm
= build_this_parm (decl
, type
, quals
);
8794 DECL_CHAIN (parm
) = parms
;
8797 /* Allocate space to hold the vptr bit if needed. */
8798 SET_DECL_ALIGN (decl
, MINIMUM_METHOD_BOUNDARY
);
8801 DECL_ARGUMENTS (decl
) = parms
;
8802 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
8803 DECL_CONTEXT (t
) = decl
;
8805 /* Propagate volatile out from type to decl. */
8806 if (TYPE_VOLATILE (type
))
8807 TREE_THIS_VOLATILE (decl
) = 1;
8809 /* Setup decl according to sfk. */
8812 case sfk_constructor
:
8813 case sfk_copy_constructor
:
8814 case sfk_move_constructor
:
8815 DECL_CXX_CONSTRUCTOR_P (decl
) = 1;
8816 DECL_NAME (decl
) = ctor_identifier
;
8818 case sfk_destructor
:
8819 DECL_CXX_DESTRUCTOR_P (decl
) = 1;
8820 DECL_NAME (decl
) = dtor_identifier
;
8826 if (friendp
&& TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8830 "defining explicit specialization %qD in friend declaration",
8834 tree fns
= TREE_OPERAND (orig_declarator
, 0);
8835 tree args
= TREE_OPERAND (orig_declarator
, 1);
8837 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8839 /* Something like `template <class T> friend void f<T>()'. */
8841 "invalid use of template-id %qD in declaration "
8842 "of primary template",
8848 /* A friend declaration of the form friend void f<>(). Record
8849 the information in the TEMPLATE_ID_EXPR. */
8850 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8852 gcc_assert (identifier_p (fns
)
8853 || TREE_CODE (fns
) == OVERLOAD
8854 || TREE_CODE (fns
) == FUNCTION_DECL
);
8855 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
8857 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8858 if (TREE_PURPOSE (t
)
8859 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8861 error_at (defarg_location (TREE_PURPOSE (t
)),
8862 "default arguments are not allowed in declaration "
8863 "of friend template specialization %qD",
8870 error_at (declspecs
->locations
[ds_inline
],
8871 "%<inline%> is not allowed in declaration of friend "
8872 "template specialization %qD",
8879 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
8880 expression, that declaration shall be a definition..." */
8881 if (friendp
&& !funcdef_flag
)
8883 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
8884 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
8885 if (TREE_PURPOSE (t
))
8887 permerror (DECL_SOURCE_LOCATION (decl
),
8888 "friend declaration of %qD specifies default "
8889 "arguments and isn't a definition", decl
);
8894 /* If this decl has namespace scope, set that up. */
8896 set_decl_namespace (decl
, in_namespace
, friendp
);
8898 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
8900 /* `main' and builtins have implicit 'C' linkage. */
8901 if (ctype
== NULL_TREE
8902 && DECL_FILE_SCOPE_P (decl
)
8903 && current_lang_name
== lang_name_cplusplus
8904 && (MAIN_NAME_P (declarator
)
8905 || (IDENTIFIER_LENGTH (declarator
) > 10
8906 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8907 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8908 && strncmp (IDENTIFIER_POINTER (declarator
)+2,
8909 "builtin_", 8) == 0)
8910 || (targetcm
.cxx_implicit_extern_c
8911 && (targetcm
.cxx_implicit_extern_c
8912 (IDENTIFIER_POINTER (declarator
))))))
8913 SET_DECL_LANGUAGE (decl
, lang_c
);
8915 /* Should probably propagate const out from type to decl I bet (mrs). */
8918 DECL_STATIC_FUNCTION_P (decl
) = 1;
8919 DECL_CONTEXT (decl
) = ctype
;
8923 DECL_DELETED_FN (decl
) = 1;
8927 DECL_CONTEXT (decl
) = ctype
;
8929 check_class_member_definition_namespace (decl
);
8932 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8934 if (PROCESSING_REAL_TEMPLATE_DECL_P())
8935 error_at (location
, "cannot declare %<::main%> to be a template");
8937 error_at (declspecs
->locations
[ds_inline
],
8938 "cannot declare %<::main%> to be inline");
8940 error_at (declspecs
->locations
[ds_constexpr
],
8941 "cannot declare %<::main%> to be %<constexpr%>");
8943 error_at (location
, "cannot declare %<::main%> to be static");
8948 /* Members of anonymous types and local classes have no linkage; make
8949 them internal. If a typedef is made later, this will be changed. */
8950 if (ctype
&& (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype
))
8951 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
8954 if (publicp
&& cxx_dialect
== cxx98
)
8956 /* [basic.link]: A name with no linkage (notably, the name of a class
8957 or enumeration declared in a local scope) shall not be used to
8958 declare an entity with linkage.
8960 DR 757 relaxes this restriction for C++0x. */
8961 no_linkage_error (decl
);
8964 TREE_PUBLIC (decl
) = publicp
;
8967 DECL_INTERFACE_KNOWN (decl
) = 1;
8968 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8971 /* If the declaration was declared inline, mark it as such. */
8974 DECL_DECLARED_INLINE_P (decl
) = 1;
8976 DECL_COMDAT (decl
) = 1;
8979 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
8981 // If the concept declaration specifier was found, check
8982 // that the declaration satisfies the necessary requirements.
8985 DECL_DECLARED_CONCEPT_P (decl
) = true;
8986 check_concept_fn (decl
);
8989 DECL_EXTERNAL (decl
) = 1;
8990 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8993 TREE_TYPE (decl
) = apply_memfn_quals (TREE_TYPE (decl
),
9000 ? G_("static member function %qD cannot have cv-qualifier")
9001 : G_("non-member function %qD cannot have cv-qualifier"),
9003 quals
= TYPE_UNQUALIFIED
;
9009 ? G_("static member function %qD cannot have ref-qualifier")
9010 : G_("non-member function %qD cannot have ref-qualifier"),
9012 rqual
= REF_QUAL_NONE
;
9016 if (deduction_guide_p (decl
))
9018 if (!DECL_NAMESPACE_SCOPE_P (decl
))
9020 error_at (location
, "deduction guide %qD must be declared at "
9021 "namespace scope", decl
);
9026 "deduction guide %qD must not have a function body", decl
);
9028 else if (IDENTIFIER_ANY_OP_P (DECL_NAME (decl
))
9029 && !grok_op_properties (decl
, /*complain=*/true))
9031 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
9033 bool long_long_unsigned_p
;
9035 const char *suffix
= NULL
;
9036 /* [over.literal]/6: Literal operators shall not have C linkage. */
9037 if (DECL_LANGUAGE (decl
) == lang_c
)
9039 error_at (location
, "literal operator with C linkage");
9040 maybe_show_extern_c_location ();
9044 if (DECL_NAMESPACE_SCOPE_P (decl
))
9046 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
9049 error_at (location
, "%qD has invalid argument list", decl
);
9053 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
9054 if (long_long_unsigned_p
)
9056 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
9057 warning_at (location
, 0, "integer suffix %qs"
9058 " shadowed by implementation", suffix
);
9060 else if (long_double_p
)
9062 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
9063 warning_at (location
, 0, "floating point suffix %qs"
9064 " shadowed by implementation", suffix
);
9067 if (suffix
[0] != '_'
9068 && !in_system_header_at (location
)
9069 && !current_function_decl
&& !(friendp
&& !funcdef_flag
))
9070 warning_at (location
, OPT_Wliteral_suffix
,
9071 "literal operator suffixes not preceded by %<_%>"
9072 " are reserved for future standardization");
9076 error_at (location
, "%qD must be a non-member function", decl
);
9082 /* Make the init_value nonzero so pushdecl knows this is not
9083 tentative. error_mark_node is replaced later with the BLOCK. */
9084 DECL_INITIAL (decl
) = error_mark_node
;
9086 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
9087 TREE_NOTHROW (decl
) = 1;
9089 if (flag_openmp
|| flag_openmp_simd
)
9091 /* Adjust "omp declare simd" attributes. */
9092 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
9096 for (attr
= ods
; attr
;
9097 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
9099 if (TREE_CODE (type
) == METHOD_TYPE
)
9100 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
9101 DECL_ARGUMENTS (decl
), NULL
);
9102 if (TREE_VALUE (attr
) != NULL_TREE
)
9104 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
9105 cl
= c_omp_declare_simd_clauses_to_numbers
9106 (DECL_ARGUMENTS (decl
), cl
);
9108 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
9110 TREE_VALUE (attr
) = NULL_TREE
;
9116 /* Caller will do the rest of this. */
9120 if (ctype
!= NULL_TREE
)
9121 grokclassfn (ctype
, decl
, flags
);
9124 if (cxx_dialect
>= cxx11
9125 && DECL_DESTRUCTOR_P (decl
)
9126 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
9127 && !processing_template_decl
)
9128 deduce_noexcept_on_destructor (decl
);
9130 decl
= check_explicit_specialization (orig_declarator
, decl
,
9133 4 * (friendp
!= 0) +
9136 if (decl
== error_mark_node
)
9139 if (DECL_STATIC_FUNCTION_P (decl
))
9140 check_static_quals (decl
, quals
);
9144 cplus_decl_attributes (&decl
, *attrlist
, 0);
9145 *attrlist
= NULL_TREE
;
9148 /* Check main's type after attributes have been applied. */
9149 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
9151 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
9154 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
9156 error_at (declspecs
->locations
[ds_type_spec
],
9157 "%<::main%> must return %<int%>");
9158 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
9159 TREE_TYPE (decl
) = newtype
;
9162 check_main_parameter_types (decl
);
9165 if (ctype
!= NULL_TREE
&& check
)
9167 tree old_decl
= check_classfn (ctype
, decl
,
9168 (processing_template_decl
9169 > template_class_depth (ctype
))
9170 ? current_template_parms
9173 if (old_decl
== error_mark_node
)
9181 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
9182 /* Because grokfndecl is always supposed to return a
9183 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9184 here. We depend on our callers to figure out that its
9185 really a template that's being returned. */
9186 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
9188 if (DECL_STATIC_FUNCTION_P (old_decl
)
9189 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
9191 /* Remove the `this' parm added by grokclassfn. */
9192 revert_static_member_fn (decl
);
9193 check_static_quals (decl
, quals
);
9195 if (DECL_ARTIFICIAL (old_decl
))
9197 error ("definition of implicitly-declared %qD", old_decl
);
9200 else if (DECL_DEFAULTED_FN (old_decl
))
9202 error ("definition of explicitly-defaulted %q+D", decl
);
9203 inform (DECL_SOURCE_LOCATION (old_decl
),
9204 "%q#D explicitly defaulted here", old_decl
);
9208 /* Since we've smashed OLD_DECL to its
9209 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
9210 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9211 decl
= DECL_TEMPLATE_RESULT (decl
);
9213 /* Attempt to merge the declarations. This can fail, in
9214 the case of some invalid specialization declarations. */
9215 pushed_scope
= push_scope (ctype
);
9216 ok
= duplicate_decls (decl
, old_decl
, friendp
);
9218 pop_scope (pushed_scope
);
9221 error ("no %q#D member function declared in class %qT",
9225 if (ok
== error_mark_node
)
9231 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
9234 if (ctype
== NULL_TREE
|| check
)
9238 DECL_VIRTUAL_P (decl
) = 1;
9243 /* decl is a FUNCTION_DECL.
9244 specifiers are the parsed virt-specifiers.
9246 Set flags to reflect the virt-specifiers.
9251 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
9253 if (decl
== NULL_TREE
)
9255 if (specifiers
& VIRT_SPEC_OVERRIDE
)
9256 DECL_OVERRIDE_P (decl
) = 1;
9257 if (specifiers
& VIRT_SPEC_FINAL
)
9258 DECL_FINAL_P (decl
) = 1;
9262 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
9263 the linkage that DECL will receive in the object file. */
9266 set_linkage_for_static_data_member (tree decl
)
9268 /* A static data member always has static storage duration and
9269 external linkage. Note that static data members are forbidden in
9270 local classes -- the only situation in which a class has
9271 non-external linkage. */
9272 TREE_PUBLIC (decl
) = 1;
9273 TREE_STATIC (decl
) = 1;
9274 /* For non-template classes, static data members are always put
9275 out in exactly those files where they are defined, just as
9276 with ordinary namespace-scope variables. */
9277 if (!processing_template_decl
)
9278 DECL_INTERFACE_KNOWN (decl
) = 1;
9281 /* Create a VAR_DECL named NAME with the indicated TYPE.
9283 If SCOPE is non-NULL, it is the class type or namespace containing
9284 the variable. If SCOPE is NULL, the variable should is created in
9285 the innermost enclosing scope. */
9288 grokvardecl (tree type
,
9290 tree orig_declarator
,
9291 const cp_decl_specifier_seq
*declspecs
,
9298 location_t location
)
9301 tree explicit_scope
;
9303 gcc_assert (!name
|| identifier_p (name
));
9305 bool constp
= (type_quals
& TYPE_QUAL_CONST
) != 0;
9306 bool volatilep
= (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
9308 /* Compute the scope in which to place the variable, but remember
9309 whether or not that scope was explicitly specified by the user. */
9310 explicit_scope
= scope
;
9313 /* An explicit "extern" specifier indicates a namespace-scope
9315 if (declspecs
->storage_class
== sc_extern
)
9316 scope
= current_decl_namespace ();
9317 else if (!at_function_scope_p ())
9318 scope
= current_scope ();
9322 && (/* If the variable is a namespace-scope variable declared in a
9323 template, we need DECL_LANG_SPECIFIC. */
9324 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
9325 /* Similarly for namespace-scope variables with language linkage
9327 || (TREE_CODE (scope
) == NAMESPACE_DECL
9328 && current_lang_name
!= lang_name_cplusplus
)
9329 /* Similarly for static data members. */
9331 /* Similarly for explicit specializations. */
9333 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
9334 decl
= build_lang_decl_loc (location
, VAR_DECL
, name
, type
);
9336 decl
= build_decl (location
, VAR_DECL
, name
, type
);
9338 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
9339 set_decl_namespace (decl
, explicit_scope
, 0);
9341 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
9343 if (declspecs
->storage_class
== sc_extern
)
9345 DECL_THIS_EXTERN (decl
) = 1;
9346 DECL_EXTERNAL (decl
) = !initialized
;
9349 if (DECL_CLASS_SCOPE_P (decl
))
9351 set_linkage_for_static_data_member (decl
);
9352 /* This function is only called with out-of-class definitions. */
9353 DECL_EXTERNAL (decl
) = 0;
9354 check_class_member_definition_namespace (decl
);
9356 /* At top level, either `static' or no s.c. makes a definition
9357 (perhaps tentative), and absence of `static' makes it public. */
9358 else if (toplevel_bindings_p ())
9360 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
9361 && (DECL_THIS_EXTERN (decl
)
9365 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
9367 /* Not at top level, only `static' makes a static definition. */
9370 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
9371 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
9374 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
9376 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
9378 CP_DECL_THREAD_LOCAL_P (decl
) = true;
9379 if (!processing_template_decl
)
9380 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
9382 if (declspecs
->gnu_thread_keyword_p
)
9383 SET_DECL_GNU_TLS_P (decl
);
9386 /* If the type of the decl has no linkage, make sure that we'll
9387 notice that in mark_used. */
9388 if (cxx_dialect
> cxx98
9389 && decl_linkage (decl
) != lk_none
9390 && DECL_LANG_SPECIFIC (decl
) == NULL
9391 && !DECL_EXTERN_C_P (decl
)
9392 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
9393 retrofit_lang_decl (decl
);
9395 if (TREE_PUBLIC (decl
))
9397 /* [basic.link]: A name with no linkage (notably, the name of a class
9398 or enumeration declared in a local scope) shall not be used to
9399 declare an entity with linkage.
9401 DR 757 relaxes this restriction for C++0x. */
9402 if (cxx_dialect
< cxx11
)
9403 no_linkage_error (decl
);
9406 DECL_INTERFACE_KNOWN (decl
) = 1;
9408 if (DECL_NAME (decl
)
9409 && MAIN_NAME_P (DECL_NAME (decl
))
9410 && scope
== global_namespace
)
9411 error ("cannot declare %<::main%> to be a global variable");
9413 /* Check that the variable can be safely declared as a concept.
9414 Note that this also forbids explicit specializations. */
9417 if (!processing_template_decl
)
9419 error_at (declspecs
->locations
[ds_concept
],
9420 "a non-template variable cannot be %<concept%>");
9424 DECL_DECLARED_CONCEPT_P (decl
) = true;
9425 if (!same_type_ignoring_top_level_qualifiers_p (type
, boolean_type_node
))
9426 error_at (declspecs
->locations
[ds_type_spec
],
9427 "concept must have type %<bool%>");
9429 else if (flag_concepts
9430 && processing_template_decl
> template_class_depth (scope
))
9432 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
9433 tree ci
= build_constraints (reqs
, NULL_TREE
);
9434 set_constraints (decl
, ci
);
9437 // Handle explicit specializations and instantiations of variable templates.
9438 if (orig_declarator
)
9439 decl
= check_explicit_specialization (orig_declarator
, decl
,
9440 template_count
, conceptp
* 8);
9442 return decl
!= error_mark_node
? decl
: NULL_TREE
;
9445 /* Create and return a canonical pointer to member function type, for
9446 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9449 build_ptrmemfunc_type (tree type
)
9454 if (type
== error_mark_node
)
9457 /* Make sure that we always have the unqualified pointer-to-member
9459 if (cp_cv_quals quals
= cp_type_quals (type
))
9461 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
9462 return cp_build_qualified_type (unqual
, quals
);
9465 /* If a canonical type already exists for this type, use it. We use
9466 this method instead of type_hash_canon, because it only does a
9467 simple equality check on the list of field members. */
9469 t
= TYPE_PTRMEMFUNC_TYPE (type
);
9473 t
= make_node (RECORD_TYPE
);
9475 /* Let the front end know this is a pointer to member function. */
9476 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
9478 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
9481 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
9483 DECL_CHAIN (field
) = fields
;
9486 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
9488 /* Zap out the name so that the back end will give us the debugging
9489 information for this anonymous RECORD_TYPE. */
9490 TYPE_NAME (t
) = NULL_TREE
;
9492 /* Cache this pointer-to-member type so that we can find it again
9494 TYPE_PTRMEMFUNC_TYPE (type
) = t
;
9496 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
9497 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9498 else if (TYPE_CANONICAL (type
) != type
)
9499 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
9504 /* Create and return a pointer to data member type. */
9507 build_ptrmem_type (tree class_type
, tree member_type
)
9509 if (TREE_CODE (member_type
) == METHOD_TYPE
)
9511 cp_cv_quals quals
= type_memfn_quals (member_type
);
9512 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
9513 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
9514 return build_ptrmemfunc_type (build_pointer_type (member_type
));
9518 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
9519 return build_offset_type (class_type
, member_type
);
9523 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9524 Check to see that the definition is valid. Issue appropriate error
9528 check_static_variable_definition (tree decl
, tree type
)
9530 /* Avoid redundant diagnostics on out-of-class definitions. */
9531 if (!current_class_type
|| !TYPE_BEING_DEFINED (current_class_type
))
9533 /* Can't check yet if we don't know the type. */
9534 else if (dependent_type_p (type
))
9536 /* If DECL is declared constexpr, we'll do the appropriate checks
9537 in check_initializer. Similarly for inline static data members. */
9538 else if (DECL_P (decl
)
9539 && (DECL_DECLARED_CONSTEXPR_P (decl
)
9540 || undeduced_auto_decl (decl
)
9541 || DECL_VAR_DECLARED_INLINE_P (decl
)))
9543 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
9545 if (!COMPLETE_TYPE_P (type
))
9546 error_at (DECL_SOURCE_LOCATION (decl
),
9547 "in-class initialization of static data member %q#D of "
9548 "incomplete type", decl
);
9549 else if (literal_type_p (type
))
9550 permerror (DECL_SOURCE_LOCATION (decl
),
9551 "%<constexpr%> needed for in-class initialization of "
9552 "static data member %q#D of non-integral type", decl
);
9554 error_at (DECL_SOURCE_LOCATION (decl
),
9555 "in-class initialization of static data member %q#D of "
9556 "non-literal type", decl
);
9558 /* Motion 10 at San Diego: If a static const integral data member is
9559 initialized with an integral constant expression, the initializer
9560 may appear either in the declaration (within the class), or in
9561 the definition, but not both. If it appears in the class, the
9562 member is a member constant. The file-scope definition is always
9564 else if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
9565 error_at (DECL_SOURCE_LOCATION (decl
),
9566 "invalid in-class initialization of static data member "
9567 "of non-integral type %qT",
9569 else if (!CP_TYPE_CONST_P (type
))
9570 error_at (DECL_SOURCE_LOCATION (decl
),
9571 "ISO C++ forbids in-class initialization of non-const "
9572 "static member %qD",
9574 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
9575 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
9576 "ISO C++ forbids initialization of member constant "
9577 "%qD of non-integral type %qT", decl
, type
);
9580 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
9581 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
9582 expressions out into temporary variables so that walk_tree doesn't
9583 step into them (c++/15764). */
9586 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
9588 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
9589 tree expr
= *expr_p
;
9590 if (TREE_CODE (expr
) == SAVE_EXPR
)
9592 tree op
= TREE_OPERAND (expr
, 0);
9593 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
9594 if (TREE_SIDE_EFFECTS (op
))
9595 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
9598 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
9603 /* Entry point for the above. */
9606 stabilize_vla_size (tree size
)
9608 hash_set
<tree
> pset
;
9609 /* Break out any function calls into temporary variables. */
9610 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
9613 /* Reduce a SIZEOF_EXPR to its value. */
9616 fold_sizeof_expr (tree t
)
9619 if (SIZEOF_EXPR_TYPE_P (t
))
9620 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
9621 SIZEOF_EXPR
, false, false);
9622 else if (TYPE_P (TREE_OPERAND (t
, 0)))
9623 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
9626 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
9628 if (r
== error_mark_node
)
9633 /* Given the SIZE (i.e., number of elements) in an array, compute
9634 an appropriate index type for the array. If non-NULL, NAME is
9635 the name of the entity being declared. */
9638 compute_array_index_type_loc (location_t name_loc
, tree name
, tree size
,
9639 tsubst_flags_t complain
)
9644 if (error_operand_p (size
))
9645 return error_mark_node
;
9647 location_t loc
= cp_expr_loc_or_loc (size
, name
? name_loc
: input_location
);
9649 if (!type_dependent_expression_p (size
))
9651 osize
= size
= mark_rvalue_use (size
);
9653 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
9654 && TREE_SIDE_EFFECTS (size
))
9655 /* In C++98, we mark a non-constant array bound with a magic
9656 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
9659 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
9660 size
= build_converted_constant_expr (size_type_node
, size
, complain
);
9661 /* Pedantically a constant expression is required here and so
9662 __builtin_is_constant_evaluated () should fold to true if it
9663 is successfully folded into a constant. */
9664 size
= maybe_constant_value (size
, NULL_TREE
,
9665 /*manifestly_const_eval=*/true);
9667 if (!TREE_CONSTANT (size
))
9671 if (error_operand_p (size
))
9672 return error_mark_node
;
9674 /* The array bound must be an integer type. */
9675 tree type
= TREE_TYPE (size
);
9676 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
9678 if (!(complain
& tf_error
))
9679 return error_mark_node
;
9681 error_at (loc
, "size of array %qD has non-integral type %qT",
9684 error_at (loc
, "size of array has non-integral type %qT", type
);
9685 size
= integer_one_node
;
9689 /* A type is dependent if it is...an array type constructed from any
9690 dependent type or whose size is specified by a constant expression
9691 that is value-dependent. */
9692 /* We can only call value_dependent_expression_p on integral constant
9693 expressions; treat non-constant expressions as dependent, too. */
9694 if (processing_template_decl
9695 && (type_dependent_expression_p (size
)
9696 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
9698 /* We cannot do any checking for a SIZE that isn't known to be
9699 constant. Just build the index type and mark that it requires
9700 structural equality checks. */
9701 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
9702 size
, size_one_node
));
9703 TYPE_DEPENDENT_P (itype
) = 1;
9704 TYPE_DEPENDENT_P_VALID (itype
) = 1;
9705 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
9709 if (TREE_CODE (size
) != INTEGER_CST
)
9711 tree folded
= cp_fully_fold (size
);
9712 if (TREE_CODE (folded
) == INTEGER_CST
)
9715 pedwarn (loc
, OPT_Wpedantic
, "size of array %qD is not an "
9716 "integral constant-expression", name
);
9718 pedwarn (loc
, OPT_Wpedantic
,
9719 "size of array is not an integral constant-expression");
9721 /* Use the folded result for VLAs, too; it will have resolved
9726 /* Normally, the array-bound will be a constant. */
9727 if (TREE_CODE (size
) == INTEGER_CST
)
9729 /* An array must have a positive number of elements. */
9730 if (!valid_constant_size_p (size
))
9732 if (!(complain
& tf_error
))
9733 return error_mark_node
;
9736 error_at (loc
, "size of array %qD is negative", name
);
9738 error_at (loc
, "size of array is negative");
9739 size
= integer_one_node
;
9741 /* As an extension we allow zero-sized arrays. */
9742 else if (integer_zerop (size
))
9744 if (!(complain
& tf_error
))
9745 /* We must fail if performing argument deduction (as
9746 indicated by the state of complain), so that
9747 another substitution can be found. */
9748 return error_mark_node
;
9749 else if (in_system_header_at (input_location
))
9750 /* Allow them in system headers because glibc uses them. */;
9752 pedwarn (loc
, OPT_Wpedantic
,
9753 "ISO C++ forbids zero-size array %qD", name
);
9755 pedwarn (loc
, OPT_Wpedantic
,
9756 "ISO C++ forbids zero-size array");
9759 else if (TREE_CONSTANT (size
)
9760 /* We don't allow VLAs at non-function scopes, or during
9761 tentative template substitution. */
9762 || !at_function_scope_p ()
9763 || !(complain
& tf_error
))
9765 if (!(complain
& tf_error
))
9766 return error_mark_node
;
9767 /* `(int) &fn' is not a valid array bound. */
9770 "size of array %qD is not an integral constant-expression",
9773 error_at (loc
, "size of array is not an integral constant-expression");
9774 size
= integer_one_node
;
9776 else if (pedantic
&& warn_vla
!= 0)
9779 pedwarn (name_loc
, OPT_Wvla
,
9780 "ISO C++ forbids variable length array %qD", name
);
9782 pedwarn (input_location
, OPT_Wvla
,
9783 "ISO C++ forbids variable length array");
9785 else if (warn_vla
> 0)
9788 warning_at (name_loc
, OPT_Wvla
,
9789 "variable length array %qD is used", name
);
9792 "variable length array is used");
9795 if (processing_template_decl
&& !TREE_CONSTANT (size
))
9796 /* A variable sized array. */
9797 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
9800 /* Compute the index of the largest element in the array. It is
9801 one less than the number of elements in the array. We save
9802 and restore PROCESSING_TEMPLATE_DECL so that computations in
9803 cp_build_binary_op will be appropriately folded. */
9805 processing_template_decl_sentinel s
;
9806 itype
= cp_build_binary_op (input_location
,
9808 cp_convert (ssizetype
, size
, complain
),
9809 cp_convert (ssizetype
, integer_one_node
,
9812 itype
= maybe_constant_value (itype
);
9815 if (!TREE_CONSTANT (itype
))
9817 /* A variable sized array. */
9818 itype
= variable_size (itype
);
9820 stabilize_vla_size (itype
);
9822 if (sanitize_flags_p (SANITIZE_VLA
)
9823 && current_function_decl
!= NULL_TREE
)
9825 /* We have to add 1 -- in the ubsan routine we generate
9826 LE_EXPR rather than LT_EXPR. */
9827 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
9828 build_one_cst (TREE_TYPE (itype
)));
9829 t
= ubsan_instrument_vla (input_location
, t
);
9830 finish_expr_stmt (t
);
9833 /* Make sure that there was no overflow when creating to a signed
9834 index type. (For example, on a 32-bit machine, an array with
9835 size 2^32 - 1 is too big.) */
9836 else if (TREE_CODE (itype
) == INTEGER_CST
9837 && TREE_OVERFLOW (itype
))
9839 if (!(complain
& tf_error
))
9840 return error_mark_node
;
9841 error ("overflow in array dimension");
9842 TREE_OVERFLOW (itype
) = 0;
9846 /* Create and return the appropriate index type. */
9847 itype
= build_index_type (itype
);
9849 /* If the index type were dependent, we would have returned early, so
9850 remember that it isn't. */
9851 TYPE_DEPENDENT_P (itype
) = 0;
9852 TYPE_DEPENDENT_P_VALID (itype
) = 1;
9857 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
9859 return compute_array_index_type_loc (input_location
, name
, size
, complain
);
9862 /* Returns the scope (if any) in which the entity declared by
9863 DECLARATOR will be located. If the entity was declared with an
9864 unqualified name, NULL_TREE is returned. */
9867 get_scope_of_declarator (const cp_declarator
*declarator
)
9869 while (declarator
&& declarator
->kind
!= cdk_id
)
9870 declarator
= declarator
->declarator
;
9872 /* If the declarator-id is a SCOPE_REF, the scope in which the
9873 declaration occurs is the first operand. */
9875 && declarator
->u
.id
.qualifying_scope
)
9876 return declarator
->u
.id
.qualifying_scope
;
9878 /* Otherwise, the declarator is not a qualified name; the entity will
9879 be declared in the current scope. */
9883 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9884 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9888 create_array_type_for_decl (tree name
, tree type
, tree size
, location_t loc
)
9890 tree itype
= NULL_TREE
;
9892 /* If things have already gone awry, bail now. */
9893 if (type
== error_mark_node
|| size
== error_mark_node
)
9894 return error_mark_node
;
9896 /* 8.3.4/1: If the type of the identifier of D contains the auto
9897 type-specifier, the program is ill-formed. */
9898 if (type_uses_auto (type
))
9901 error_at (loc
, "%qD declared as array of %qT", name
, type
);
9903 error ("creating array of %qT", type
);
9904 return error_mark_node
;
9907 /* If there are some types which cannot be array elements,
9908 issue an error-message and return. */
9909 switch (TREE_CODE (type
))
9913 error_at (loc
, "declaration of %qD as array of void", name
);
9915 error ("creating array of void");
9916 return error_mark_node
;
9920 error_at (loc
, "declaration of %qD as array of functions", name
);
9922 error ("creating array of functions");
9923 return error_mark_node
;
9925 case REFERENCE_TYPE
:
9927 error_at (loc
, "declaration of %qD as array of references", name
);
9929 error ("creating array of references");
9930 return error_mark_node
;
9934 error_at (loc
, "declaration of %qD as array of function members",
9937 error ("creating array of function members");
9938 return error_mark_node
;
9946 The constant expressions that specify the bounds of the arrays
9947 can be omitted only for the first member of the sequence. */
9948 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9951 error_at (loc
, "declaration of %qD as multidimensional array must "
9952 "have bounds for all dimensions except the first",
9955 error ("multidimensional array must have bounds for all "
9956 "dimensions except the first");
9958 return error_mark_node
;
9961 /* Figure out the index type for the array. */
9963 itype
= compute_array_index_type_loc (loc
, name
, size
,
9964 tf_warning_or_error
);
9967 T is called the array element type; this type shall not be [...] an
9968 abstract class type. */
9969 abstract_virtuals_error (name
, type
);
9971 return build_cplus_array_type (type
, itype
);
9974 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
9977 min_location (location_t loca
, location_t locb
)
9979 if (loca
== UNKNOWN_LOCATION
9980 || (locb
!= UNKNOWN_LOCATION
9981 && linemap_location_before_p (line_table
, locb
, loca
)))
9986 /* Returns the smallest location != UNKNOWN_LOCATION among the
9987 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
9988 and LOCATIONS[ds_restrict]. */
9991 smallest_type_quals_location (int type_quals
, const location_t
* locations
)
9993 location_t loc
= UNKNOWN_LOCATION
;
9995 if (type_quals
& TYPE_QUAL_CONST
)
9996 loc
= locations
[ds_const
];
9998 if (type_quals
& TYPE_QUAL_VOLATILE
)
9999 loc
= min_location (loc
, locations
[ds_volatile
]);
10001 if (type_quals
& TYPE_QUAL_RESTRICT
)
10002 loc
= min_location (loc
, locations
[ds_restrict
]);
10007 /* Check that it's OK to declare a function with the indicated TYPE
10008 and TYPE_QUALS. SFK indicates the kind of special function (if any)
10009 that this function is. OPTYPE is the type given in a conversion
10010 operator declaration, or the class type for a constructor/destructor.
10011 Returns the actual return type of the function; that may be different
10012 than TYPE if an error occurs, or for certain special functions. */
10015 check_special_function_return_type (special_function_kind sfk
,
10019 const location_t
* locations
)
10023 case sfk_constructor
:
10025 error ("return type specification for constructor invalid");
10026 else if (type_quals
!= TYPE_UNQUALIFIED
)
10027 error_at (smallest_type_quals_location (type_quals
, locations
),
10028 "qualifiers are not allowed on constructor declaration");
10030 if (targetm
.cxx
.cdtor_returns_this ())
10031 type
= build_pointer_type (optype
);
10033 type
= void_type_node
;
10036 case sfk_destructor
:
10038 error ("return type specification for destructor invalid");
10039 else if (type_quals
!= TYPE_UNQUALIFIED
)
10040 error_at (smallest_type_quals_location (type_quals
, locations
),
10041 "qualifiers are not allowed on destructor declaration");
10043 /* We can't use the proper return type here because we run into
10044 problems with ambiguous bases and covariant returns. */
10045 if (targetm
.cxx
.cdtor_returns_this ())
10046 type
= build_pointer_type (void_type_node
);
10048 type
= void_type_node
;
10051 case sfk_conversion
:
10053 error ("return type specified for %<operator %T%>", optype
);
10054 else if (type_quals
!= TYPE_UNQUALIFIED
)
10055 error_at (smallest_type_quals_location (type_quals
, locations
),
10056 "qualifiers are not allowed on declaration of "
10057 "%<operator %T%>", optype
);
10062 case sfk_deduction_guide
:
10064 error ("return type specified for deduction guide");
10065 else if (type_quals
!= TYPE_UNQUALIFIED
)
10066 error_at (smallest_type_quals_location (type_quals
, locations
),
10067 "qualifiers are not allowed on declaration of "
10068 "deduction guide");
10069 if (TREE_CODE (optype
) == TEMPLATE_TEMPLATE_PARM
)
10071 error ("template template parameter %qT in declaration of "
10072 "deduction guide", optype
);
10073 type
= error_mark_node
;
10076 type
= make_template_placeholder (CLASSTYPE_TI_TEMPLATE (optype
));
10077 for (int i
= 0; i
< ds_last
; ++i
)
10078 if (i
!= ds_explicit
&& locations
[i
])
10079 error_at (locations
[i
],
10080 "decl-specifier in declaration of deduction guide");
10084 gcc_unreachable ();
10090 /* A variable or data member (whose unqualified name is IDENTIFIER)
10091 has been declared with the indicated TYPE. If the TYPE is not
10092 acceptable, issue an error message and return a type to use for
10093 error-recovery purposes. */
10096 check_var_type (tree identifier
, tree type
)
10098 if (VOID_TYPE_P (type
))
10101 error ("unnamed variable or field declared void");
10102 else if (identifier_p (identifier
))
10104 gcc_assert (!IDENTIFIER_ANY_OP_P (identifier
));
10105 error ("variable or field %qE declared void", identifier
);
10108 error ("variable or field declared void");
10109 type
= error_mark_node
;
10115 /* Handle declaring DECL as an inline variable. */
10118 mark_inline_variable (tree decl
, location_t loc
)
10120 bool inlinep
= true;
10121 if (! toplevel_bindings_p ())
10123 error_at (loc
, "%<inline%> specifier invalid for variable "
10124 "%qD declared at block scope", decl
);
10127 else if (cxx_dialect
< cxx17
)
10128 pedwarn (loc
, 0, "inline variables are only available "
10129 "with -std=c++17 or -std=gnu++17");
10132 retrofit_lang_decl (decl
);
10133 SET_DECL_VAR_DECLARED_INLINE_P (decl
);
10138 /* Assign a typedef-given name to a class or enumeration type declared
10139 as anonymous at first. This was split out of grokdeclarator
10140 because it is also used in libcc1. */
10143 name_unnamed_type (tree type
, tree decl
)
10145 gcc_assert (TYPE_UNNAMED_P (type
));
10147 /* Replace the anonymous name with the real name everywhere. */
10148 for (tree t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10150 if (anon_aggrname_p (TYPE_IDENTIFIER (t
)))
10151 /* We do not rename the debug info representing the
10152 unnamed tagged type because the standard says in
10153 [dcl.typedef] that the naming applies only for
10154 linkage purposes. */
10155 /*debug_hooks->set_name (t, decl);*/
10156 TYPE_NAME (t
) = decl
;
10159 if (TYPE_LANG_SPECIFIC (type
))
10160 TYPE_WAS_UNNAMED (type
) = 1;
10162 /* If this is a typedef within a template class, the nested
10163 type is a (non-primary) template. The name for the
10164 template needs updating as well. */
10165 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10166 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10167 = TYPE_IDENTIFIER (type
);
10169 /* Adjust linkage now that we aren't unnamed anymore. */
10170 reset_type_linkage (type
);
10172 /* FIXME remangle member functions; member functions of a
10173 type with external linkage have external linkage. */
10175 /* Check that our job is done, and that it would fail if we
10176 attempted to do it again. */
10177 gcc_assert (!TYPE_UNNAMED_P (type
));
10180 /* Given declspecs and a declarator (abstract or otherwise), determine
10181 the name and type of the object declared and construct a DECL node
10184 DECLSPECS points to the representation of declaration-specifier
10185 sequence that precedes declarator.
10187 DECL_CONTEXT says which syntactic context this declaration is in:
10188 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
10189 FUNCDEF for a function definition. Like NORMAL but a few different
10190 error messages in each case. Return value may be zero meaning
10191 this definition is too screwy to try to parse.
10192 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
10193 handle member functions (which have FIELD context).
10194 Return value may be zero meaning this definition is too screwy to
10196 PARM for a parameter declaration (either within a function prototype
10197 or before a function body). Make a PARM_DECL, or return void_type_node.
10198 TPARM for a template parameter declaration.
10199 CATCHPARM for a parameter declaration before a catch clause.
10200 TYPENAME if for a typename (in a cast or sizeof).
10201 Don't make a DECL node; just return the ..._TYPE node.
10202 FIELD for a struct or union field; make a FIELD_DECL.
10203 BITFIELD for a field with specified width.
10205 INITIALIZED is as for start_decl.
10207 ATTRLIST is a pointer to the list of attributes, which may be NULL
10208 if there are none; *ATTRLIST may be modified if attributes from inside
10209 the declarator should be applied to the declaration.
10211 When this function is called, scoping variables (such as
10212 CURRENT_CLASS_TYPE) should reflect the scope in which the
10213 declaration occurs, not the scope in which the new declaration will
10214 be placed. For example, on:
10216 void S::f() { ... }
10218 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
10221 Returns a DECL (if a declarator is present), a TYPE (if there is no
10222 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
10226 grokdeclarator (const cp_declarator
*declarator
,
10227 cp_decl_specifier_seq
*declspecs
,
10228 enum decl_context decl_context
,
10232 tree type
= NULL_TREE
;
10234 int explicit_intN
= 0;
10235 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
10236 int explicit_int
= 0;
10237 int explicit_char
= 0;
10238 int defaulted_int
= 0;
10240 tree typedef_decl
= NULL_TREE
;
10241 const char *name
= NULL
;
10242 tree typedef_type
= NULL_TREE
;
10243 /* True if this declarator is a function definition. */
10244 bool funcdef_flag
= false;
10245 cp_declarator_kind innermost_code
= cdk_error
;
10248 /* See the code below that used this. */
10249 tree decl_attr
= NULL_TREE
;
10252 /* Keep track of what sort of function is being processed
10253 so that we can warn about default return values, or explicit
10254 return values which do not match prescribed defaults. */
10255 special_function_kind sfk
= sfk_none
;
10257 tree dname
= NULL_TREE
;
10258 tree ctor_return_type
= NULL_TREE
;
10259 enum overload_flags flags
= NO_SPECIAL
;
10260 /* cv-qualifiers that apply to the declarator, for a declaration of
10261 a member function. */
10262 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
10263 /* virt-specifiers that apply to the declarator, for a declaration of
10264 a member function. */
10265 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
10266 /* ref-qualifier that applies to the declarator, for a declaration of
10267 a member function. */
10268 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
10269 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
10270 int type_quals
= TYPE_UNQUALIFIED
;
10271 tree raises
= NULL_TREE
;
10272 int template_count
= 0;
10273 tree returned_attrs
= NULL_TREE
;
10274 tree parms
= NULL_TREE
;
10275 const cp_declarator
*id_declarator
;
10276 /* The unqualified name of the declarator; either an
10277 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
10278 tree unqualified_id
;
10279 /* The class type, if any, in which this entity is located,
10280 or NULL_TREE if none. Note that this value may be different from
10281 the current class type; for example if an attempt is made to declare
10282 "A::f" inside "B", this value will be "A". */
10283 tree ctype
= current_class_type
;
10284 /* The NAMESPACE_DECL for the namespace in which this entity is
10285 located. If an unqualified name is used to declare the entity,
10286 this value will be NULL_TREE, even if the entity is located at
10287 namespace scope. */
10288 tree in_namespace
= NULL_TREE
;
10289 cp_storage_class storage_class
;
10290 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
10291 bool type_was_error_mark_node
= false;
10292 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
10293 bool template_type_arg
= false;
10294 bool template_parm_flag
= false;
10295 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
10296 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
10297 bool late_return_type_p
= false;
10298 bool array_parameter_p
= false;
10299 location_t saved_loc
= input_location
;
10300 tree reqs
= NULL_TREE
;
10302 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
10303 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
10304 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
10305 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
10306 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
10307 explicit_intN
= declspecs
->explicit_intN_p
;
10308 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
10310 // Was concept_p specified? Note that ds_concept
10311 // implies ds_constexpr!
10312 bool concept_p
= decl_spec_seq_has_spec_p (declspecs
, ds_concept
);
10314 constexpr_p
= true;
10316 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
10317 type_quals
|= TYPE_QUAL_CONST
;
10318 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
10319 type_quals
|= TYPE_QUAL_VOLATILE
;
10320 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
10321 type_quals
|= TYPE_QUAL_RESTRICT
;
10323 if (decl_context
== FUNCDEF
)
10324 funcdef_flag
= true, decl_context
= NORMAL
;
10325 else if (decl_context
== MEMFUNCDEF
)
10326 funcdef_flag
= true, decl_context
= FIELD
;
10327 else if (decl_context
== BITFIELD
)
10328 bitfield
= 1, decl_context
= FIELD
;
10329 else if (decl_context
== TEMPLATE_TYPE_ARG
)
10330 template_type_arg
= true, decl_context
= TYPENAME
;
10331 else if (decl_context
== TPARM
)
10332 template_parm_flag
= true, decl_context
= PARM
;
10334 if (initialized
> 1)
10335 funcdef_flag
= true;
10337 location_t typespec_loc
= smallest_type_quals_location (type_quals
,
10338 declspecs
->locations
);
10339 if (typespec_loc
== UNKNOWN_LOCATION
)
10340 typespec_loc
= declspecs
->locations
[ds_type_spec
];
10341 if (typespec_loc
== UNKNOWN_LOCATION
)
10342 typespec_loc
= input_location
;
10344 /* Look inside a declarator for the name being declared
10345 and get it as a string, for an error message. */
10346 for (id_declarator
= declarator
;
10348 id_declarator
= id_declarator
->declarator
)
10350 if (id_declarator
->kind
!= cdk_id
)
10351 innermost_code
= id_declarator
->kind
;
10353 switch (id_declarator
->kind
)
10356 if (id_declarator
->declarator
10357 && id_declarator
->declarator
->kind
== cdk_id
)
10359 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
10360 if (sfk
== sfk_destructor
)
10367 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
10368 tree decl
= id_declarator
->u
.id
.unqualified_name
;
10371 if (qualifying_scope
)
10373 if (check_for_bare_parameter_packs (qualifying_scope
,
10374 id_declarator
->id_loc
))
10375 return error_mark_node
;
10376 if (at_function_scope_p ())
10380 A declarator-id shall not be qualified except
10383 None of the cases are permitted in block
10385 if (qualifying_scope
== global_namespace
)
10386 error ("invalid use of qualified-name %<::%D%>",
10388 else if (TYPE_P (qualifying_scope
))
10389 error ("invalid use of qualified-name %<%T::%D%>",
10390 qualifying_scope
, decl
);
10392 error ("invalid use of qualified-name %<%D::%D%>",
10393 qualifying_scope
, decl
);
10394 return error_mark_node
;
10396 else if (TYPE_P (qualifying_scope
))
10398 ctype
= qualifying_scope
;
10399 if (!MAYBE_CLASS_TYPE_P (ctype
))
10401 error ("%q#T is not a class or a namespace", ctype
);
10404 else if (innermost_code
!= cdk_function
10405 && current_class_type
10406 && !uniquely_derived_from_p (ctype
,
10407 current_class_type
))
10409 error ("invalid use of qualified-name %<%T::%D%>",
10410 qualifying_scope
, decl
);
10411 return error_mark_node
;
10414 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
10415 in_namespace
= qualifying_scope
;
10417 switch (TREE_CODE (decl
))
10421 if (innermost_code
!= cdk_function
)
10423 error ("declaration of %qD as non-function", decl
);
10424 return error_mark_node
;
10426 else if (!qualifying_scope
10427 && !(current_class_type
&& at_class_scope_p ()))
10429 error ("declaration of %qD as non-member", decl
);
10430 return error_mark_node
;
10433 tree type
= TREE_OPERAND (decl
, 0);
10435 type
= constructor_name (type
);
10436 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
10441 case TEMPLATE_ID_EXPR
:
10443 tree fns
= TREE_OPERAND (decl
, 0);
10446 if (!identifier_p (dname
))
10447 dname
= OVL_NAME (dname
);
10449 /* Fall through. */
10451 case IDENTIFIER_NODE
:
10452 if (identifier_p (decl
))
10455 if (IDENTIFIER_KEYWORD_P (dname
))
10457 error ("declarator-id missing; using reserved word %qD",
10459 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10461 else if (!IDENTIFIER_CONV_OP_P (dname
))
10462 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10465 gcc_assert (flags
== NO_SPECIAL
);
10466 flags
= TYPENAME_FLAG
;
10467 sfk
= sfk_conversion
;
10468 tree glob
= get_global_binding (dname
);
10469 if (glob
&& TREE_CODE (glob
) == TYPE_DECL
)
10470 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10472 name
= "<invalid operator>";
10477 gcc_unreachable ();
10484 case cdk_reference
:
10489 name
= "structured binding";
10493 return error_mark_node
;
10496 gcc_unreachable ();
10498 if (id_declarator
->kind
== cdk_id
)
10504 The declarator in a function-definition shall have the form
10505 D1 ( parameter-declaration-clause) ... */
10506 if (funcdef_flag
&& innermost_code
!= cdk_function
)
10508 error ("function definition does not declare parameters");
10509 return error_mark_node
;
10512 if (flags
== TYPENAME_FLAG
10513 && innermost_code
!= cdk_function
10514 && ! (ctype
&& !declspecs
->any_specifiers_p
))
10516 error ("declaration of %qD as non-function", dname
);
10517 return error_mark_node
;
10520 if (dname
&& identifier_p (dname
))
10522 if (UDLIT_OPER_P (dname
)
10523 && innermost_code
!= cdk_function
)
10525 error ("declaration of %qD as non-function", dname
);
10526 return error_mark_node
;
10529 if (IDENTIFIER_ANY_OP_P (dname
))
10533 error ("declaration of %qD as %<typedef%>", dname
);
10534 return error_mark_node
;
10536 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10538 error ("declaration of %qD as parameter", dname
);
10539 return error_mark_node
;
10544 /* Anything declared one level down from the top level
10545 must be one of the parameters of a function
10546 (because the body is at least two levels down). */
10548 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10549 by not allowing C++ class definitions to specify their parameters
10550 with xdecls (must be spec.d in the parmlist).
10552 Since we now wait to push a class scope until we are sure that
10553 we are in a legitimate method context, we must set oldcname
10554 explicitly (since current_class_name is not yet alive).
10556 We also want to avoid calling this a PARM if it is in a namespace. */
10558 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
10560 cp_binding_level
*b
= current_binding_level
;
10561 current_binding_level
= b
->level_chain
;
10562 if (current_binding_level
!= 0 && toplevel_bindings_p ())
10563 decl_context
= PARM
;
10564 current_binding_level
= b
;
10568 name
= decl_context
== PARM
? "parameter" : "type name";
10570 if (concept_p
&& typedef_p
)
10572 error_at (declspecs
->locations
[ds_concept
],
10573 "%<concept%> cannot appear in a typedef declaration");
10574 return error_mark_node
;
10577 if (constexpr_p
&& typedef_p
)
10579 error_at (declspecs
->locations
[ds_constexpr
],
10580 "%<constexpr%> cannot appear in a typedef declaration");
10581 return error_mark_node
;
10584 /* If there were multiple types specified in the decl-specifier-seq,
10585 issue an error message. */
10586 if (declspecs
->multiple_types_p
)
10588 error ("two or more data types in declaration of %qs", name
);
10589 return error_mark_node
;
10592 if (declspecs
->conflicting_specifiers_p
)
10594 error ("conflicting specifiers in declaration of %qs", name
);
10595 return error_mark_node
;
10598 /* Extract the basic type from the decl-specifier-seq. */
10599 type
= declspecs
->type
;
10600 if (type
== error_mark_node
)
10603 type_was_error_mark_node
= true;
10605 cp_warn_deprecated_use (type
);
10606 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
10608 typedef_decl
= type
;
10609 type
= TREE_TYPE (typedef_decl
);
10610 if (DECL_ARTIFICIAL (typedef_decl
))
10611 cp_warn_deprecated_use (type
);
10613 /* No type at all: default to `int', and set DEFAULTED_INT
10614 because it was not a user-defined typedef. */
10615 if (type
== NULL_TREE
)
10617 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
10619 /* These imply 'int'. */
10620 type
= integer_type_node
;
10623 /* If we just have "complex", it is equivalent to "complex double". */
10624 else if (!longlong
&& !explicit_intN
10625 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
10627 type
= double_type_node
;
10628 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
10629 "ISO C++ does not support plain %<complex%> meaning "
10630 "%<double complex%>");
10633 /* Gather flags. */
10634 explicit_int
= declspecs
->explicit_int_p
;
10635 explicit_char
= declspecs
->explicit_char_p
;
10638 /* See the code below that used this. */
10640 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
10642 typedef_type
= type
;
10644 if (sfk
== sfk_conversion
|| sfk
== sfk_deduction_guide
)
10645 ctor_return_type
= TREE_TYPE (dname
);
10647 ctor_return_type
= ctype
;
10649 if (sfk
!= sfk_none
)
10651 type
= check_special_function_return_type (sfk
, type
,
10654 declspecs
->locations
);
10655 type_quals
= TYPE_UNQUALIFIED
;
10657 else if (type
== NULL_TREE
)
10663 /* We handle `main' specially here, because 'main () { }' is so
10664 common. With no options, it is allowed. With -Wreturn-type,
10665 it is a warning. It is only an error with -pedantic-errors. */
10666 is_main
= (funcdef_flag
10667 && dname
&& identifier_p (dname
)
10668 && MAIN_NAME_P (dname
)
10669 && ctype
== NULL_TREE
10670 && in_namespace
== NULL_TREE
10671 && current_namespace
== global_namespace
);
10673 if (type_was_error_mark_node
)
10674 /* We've already issued an error, don't complain more. */;
10675 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
10676 /* Allow it, sigh. */;
10677 else if (! is_main
)
10678 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
10680 pedwarn (input_location
, OPT_Wpedantic
,
10681 "ISO C++ forbids declaration of %qs with no type", name
);
10683 warning (OPT_Wreturn_type
,
10684 "ISO C++ forbids declaration of %qs with no type", name
);
10686 if (type_was_error_mark_node
&& template_parm_flag
)
10687 /* FIXME we should be able to propagate the error_mark_node as is
10688 for other contexts too. */
10689 type
= error_mark_node
;
10691 type
= integer_type_node
;
10698 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
10700 error ("%<__int%d%> is not supported by this target",
10701 int_n_data
[declspecs
->int_n_idx
].bitsize
);
10702 explicit_intN
= false;
10704 else if (pedantic
&& ! in_system_header_at (input_location
))
10705 pedwarn (input_location
, OPT_Wpedantic
,
10706 "ISO C++ does not support %<__int%d%> for %qs",
10707 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
10710 /* Now process the modifiers that were specified
10711 and check for invalid combinations. */
10713 /* Long double is a special combination. */
10714 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
10717 type
= cp_build_qualified_type (long_double_type_node
,
10718 cp_type_quals (type
));
10721 /* Check all other uses of type modifiers. */
10723 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
10730 loc
= declspecs
->locations
[ds_unsigned
];
10735 loc
= declspecs
->locations
[ds_signed
];
10740 loc
= declspecs
->locations
[ds_long_long
];
10745 loc
= declspecs
->locations
[ds_long
];
10747 else /* if (short_p) */
10750 loc
= declspecs
->locations
[ds_short
];
10755 if (signed_p
&& unsigned_p
)
10757 gcc_rich_location
richloc (declspecs
->locations
[ds_signed
]);
10758 richloc
.add_range (declspecs
->locations
[ds_unsigned
]);
10759 error_at (&richloc
,
10760 "%<signed%> and %<unsigned%> specified together");
10762 else if (long_p
&& short_p
)
10764 gcc_rich_location
richloc (declspecs
->locations
[ds_long
]);
10765 richloc
.add_range (declspecs
->locations
[ds_short
]);
10766 error_at (&richloc
, "%<long%> and %<short%> specified together");
10768 else if (TREE_CODE (type
) != INTEGER_TYPE
10769 || type
== char16_type_node
|| type
== char32_type_node
10770 || ((long_p
|| short_p
)
10771 && (explicit_char
|| explicit_intN
)))
10772 error_at (loc
, "%qs specified with %qT", key
, type
);
10773 else if (!explicit_int
&& !defaulted_int
10774 && !explicit_char
&& !explicit_intN
)
10778 pedwarn (loc
, OPT_Wpedantic
, "%qs specified with %qT",
10780 ok
= !flag_pedantic_errors
;
10782 else if (declspecs
->decltype_p
)
10783 error_at (loc
, "%qs specified with %<decltype%>", key
);
10785 error_at (loc
, "%qs specified with %<typeof%>", key
);
10790 /* Discard the type modifiers if they are invalid. */
10793 unsigned_p
= false;
10801 /* Decide whether an integer type is signed or not.
10802 Optionally treat bitfields as signed by default. */
10806 It is implementation-defined whether a plain (neither
10807 explicitly signed or unsigned) char, short, int, or long
10808 bit-field is signed or unsigned.
10810 Naturally, we extend this to long long as well. Note that
10811 this does not include wchar_t. */
10812 || (bitfield
&& !flag_signed_bitfields
10814 /* A typedef for plain `int' without `signed' can be
10815 controlled just like plain `int', but a typedef for
10816 `signed int' cannot be so controlled. */
10818 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
10819 && TREE_CODE (type
) == INTEGER_TYPE
10820 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
10823 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
10825 type
= long_long_unsigned_type_node
;
10827 type
= long_unsigned_type_node
;
10829 type
= short_unsigned_type_node
;
10830 else if (type
== char_type_node
)
10831 type
= unsigned_char_type_node
;
10832 else if (typedef_decl
)
10833 type
= unsigned_type_for (type
);
10835 type
= unsigned_type_node
;
10837 else if (signed_p
&& type
== char_type_node
)
10838 type
= signed_char_type_node
;
10839 else if (explicit_intN
)
10840 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
10842 type
= long_long_integer_type_node
;
10844 type
= long_integer_type_node
;
10846 type
= short_integer_type_node
;
10848 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
10850 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
10851 error ("complex invalid for %qs", name
);
10852 /* If a modifier is specified, the resulting complex is the complex
10853 form of TYPE. E.g, "complex short" is "complex short int". */
10854 else if (type
== integer_type_node
)
10855 type
= complex_integer_type_node
;
10856 else if (type
== float_type_node
)
10857 type
= complex_float_type_node
;
10858 else if (type
== double_type_node
)
10859 type
= complex_double_type_node
;
10860 else if (type
== long_double_type_node
)
10861 type
= complex_long_double_type_node
;
10863 type
= build_complex_type (type
);
10866 /* If we're using the injected-class-name to form a compound type or a
10867 declaration, replace it with the underlying class so we don't get
10868 redundant typedefs in the debug output. But if we are returning the
10869 type unchanged, leave it alone so that it's available to
10870 maybe_get_template_decl_from_type_decl. */
10871 if (CLASS_TYPE_P (type
)
10872 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
10873 && type
== TREE_TYPE (TYPE_NAME (type
))
10874 && (declarator
|| type_quals
))
10875 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
10877 type_quals
|= cp_type_quals (type
);
10878 type
= cp_build_qualified_type_real
10879 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
10880 || declspecs
->decltype_p
)
10881 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
10882 /* We might have ignored or rejected some of the qualifiers. */
10883 type_quals
= cp_type_quals (type
);
10885 if (cxx_dialect
>= cxx17
&& type
&& is_auto (type
)
10886 && innermost_code
!= cdk_function
10887 && id_declarator
&& declarator
!= id_declarator
)
10888 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (type
))
10890 error_at (typespec_loc
, "template placeholder type %qT must be followed "
10891 "by a simple declarator-id", type
);
10892 inform (DECL_SOURCE_LOCATION (tmpl
), "%qD declared here", tmpl
);
10896 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
10897 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
10898 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
10900 storage_class
= declspecs
->storage_class
;
10901 if (storage_class
== sc_static
)
10902 staticp
= 1 + (decl_context
== FIELD
);
10908 gcc_rich_location
richloc (declspecs
->locations
[ds_virtual
]);
10909 richloc
.add_range (declspecs
->locations
[ds_storage_class
]);
10910 error_at (&richloc
, "member %qD cannot be declared both %<virtual%> "
10911 "and %<static%>", dname
);
10912 storage_class
= sc_none
;
10915 if (constexpr_p
&& cxx_dialect
< cxx2a
)
10917 gcc_rich_location
richloc (declspecs
->locations
[ds_virtual
]);
10918 richloc
.add_range (declspecs
->locations
[ds_constexpr
]);
10919 pedwarn (&richloc
, OPT_Wpedantic
, "member %qD can be declared both "
10920 "%<virtual%> and %<constexpr%> only in -std=c++2a or "
10921 "-std=gnu++2a", dname
);
10924 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
10926 /* Issue errors about use of storage classes for parameters. */
10927 if (decl_context
== PARM
)
10931 error_at (declspecs
->locations
[ds_typedef
],
10932 "typedef declaration invalid in parameter declaration");
10933 return error_mark_node
;
10935 else if (template_parm_flag
&& storage_class
!= sc_none
)
10937 error_at (min_location (declspecs
->locations
[ds_thread
],
10938 declspecs
->locations
[ds_storage_class
]),
10939 "storage class specified for template parameter %qs",
10941 return error_mark_node
;
10943 else if (storage_class
== sc_static
10944 || storage_class
== sc_extern
10947 error_at (min_location (declspecs
->locations
[ds_thread
],
10948 declspecs
->locations
[ds_storage_class
]),
10949 "storage class specified for parameter %qs", name
);
10950 return error_mark_node
;
10953 /* Function parameters cannot be concept. */
10955 error_at (declspecs
->locations
[ds_concept
],
10956 "a parameter cannot be declared %<concept%>");
10957 /* Function parameters cannot be constexpr. If we saw one, moan
10958 and pretend it wasn't there. */
10959 else if (constexpr_p
)
10961 error_at (declspecs
->locations
[ds_constexpr
],
10962 "a parameter cannot be declared %<constexpr%>");
10967 /* Give error if `virtual' is used outside of class declaration. */
10969 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
10971 error_at (declspecs
->locations
[ds_virtual
],
10972 "%<virtual%> outside class declaration");
10976 if (innermost_code
== cdk_decomp
)
10978 location_t loc
= (declarator
->kind
== cdk_reference
10979 ? declarator
->declarator
->id_loc
: declarator
->id_loc
);
10981 error_at (declspecs
->locations
[ds_inline
],
10982 "structured binding declaration cannot be %<inline%>");
10984 error_at (declspecs
->locations
[ds_typedef
],
10985 "structured binding declaration cannot be %<typedef%>");
10987 error_at (declspecs
->locations
[ds_constexpr
], "structured "
10988 "binding declaration cannot be %<constexpr%>");
10990 error_at (declspecs
->locations
[ds_thread
],
10991 "structured binding declaration cannot be %qs",
10992 declspecs
->gnu_thread_keyword_p
10993 ? "__thread" : "thread_local");
10995 error_at (declspecs
->locations
[ds_concept
],
10996 "structured binding declaration cannot be %<concept%>");
10997 switch (storage_class
)
11002 error_at (loc
, "structured binding declaration cannot be "
11006 error_at (loc
, "structured binding declaration cannot be "
11010 error_at (loc
, "structured binding declaration cannot be "
11014 error_at (loc
, "structured binding declaration cannot be "
11018 error_at (loc
, "structured binding declaration cannot be "
11022 gcc_unreachable ();
11024 if (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
11025 || TYPE_IDENTIFIER (type
) != auto_identifier
)
11027 if (type
!= error_mark_node
)
11029 error_at (loc
, "structured binding declaration cannot have "
11032 "type must be cv-qualified %<auto%> or reference to "
11033 "cv-qualified %<auto%>");
11035 type
= build_qualified_type (make_auto (), type_quals
);
11036 declspecs
->type
= type
;
11043 storage_class
= sc_none
;
11045 declspecs
->storage_class
= sc_none
;
11046 declspecs
->locations
[ds_thread
] = UNKNOWN_LOCATION
;
11049 /* Static anonymous unions are dealt with here. */
11050 if (staticp
&& decl_context
== TYPENAME
11052 && ANON_AGGR_TYPE_P (declspecs
->type
))
11053 decl_context
= FIELD
;
11055 /* Warn about storage classes that are invalid for certain
11056 kinds of declarations (parameters, typenames, etc.). */
11059 && storage_class
!= sc_extern
11060 && storage_class
!= sc_static
)
11063 error ("multiple storage classes in declaration of %qs", name
);
11066 if (decl_context
!= NORMAL
11067 && ((storage_class
!= sc_none
11068 && storage_class
!= sc_mutable
)
11071 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
11072 && (storage_class
== sc_register
11073 || storage_class
== sc_auto
))
11075 else if (typedef_p
)
11077 else if (decl_context
== FIELD
11078 /* C++ allows static class elements. */
11079 && storage_class
== sc_static
)
11080 /* C++ also allows inlines and signed and unsigned elements,
11081 but in those cases we don't come in here. */
11086 = min_location (declspecs
->locations
[ds_thread
],
11087 declspecs
->locations
[ds_storage_class
]);
11088 if (decl_context
== FIELD
)
11089 error_at (loc
, "storage class specified for %qs", name
);
11090 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
11091 error_at (loc
, "storage class specified for parameter %qs", name
);
11093 error_at (loc
, "storage class specified for typename");
11094 if (storage_class
== sc_register
11095 || storage_class
== sc_auto
11096 || storage_class
== sc_extern
11098 storage_class
= sc_none
;
11101 else if (storage_class
== sc_extern
&& funcdef_flag
11102 && ! toplevel_bindings_p ())
11103 error ("nested function %qs declared %<extern%>", name
);
11104 else if (toplevel_bindings_p ())
11106 if (storage_class
== sc_auto
)
11107 error ("top-level declaration of %qs specifies %<auto%>", name
);
11110 && storage_class
!= sc_extern
11111 && storage_class
!= sc_static
)
11113 if (declspecs
->gnu_thread_keyword_p
)
11114 pedwarn (declspecs
->locations
[ds_thread
],
11115 0, "function-scope %qs implicitly auto and "
11116 "declared %<__thread%>", name
);
11118 /* When thread_local is applied to a variable of block scope the
11119 storage-class-specifier static is implied if it does not appear
11121 storage_class
= declspecs
->storage_class
= sc_static
;
11125 if (storage_class
&& friendp
)
11127 error_at (min_location (declspecs
->locations
[ds_thread
],
11128 declspecs
->locations
[ds_storage_class
]),
11129 "storage class specifiers invalid in friend function "
11131 storage_class
= sc_none
;
11135 if (!id_declarator
)
11136 unqualified_id
= NULL_TREE
;
11139 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
11140 switch (TREE_CODE (unqualified_id
))
11143 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
11144 if (TYPE_P (unqualified_id
))
11145 unqualified_id
= constructor_name (unqualified_id
);
11148 case IDENTIFIER_NODE
:
11149 case TEMPLATE_ID_EXPR
:
11153 gcc_unreachable ();
11157 if (declspecs
->std_attributes
)
11159 location_t attr_loc
= declspecs
->locations
[ds_std_attribute
];
11160 if (warning_at (attr_loc
, OPT_Wattributes
, "attribute ignored"))
11161 inform (attr_loc
, "an attribute that appertains to a type-specifier "
11165 /* Determine the type of the entity declared by recurring on the
11167 for (; declarator
; declarator
= declarator
->declarator
)
11169 const cp_declarator
*inner_declarator
;
11172 if (type
== error_mark_node
)
11173 return error_mark_node
;
11175 attrs
= declarator
->attributes
;
11181 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
11182 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
11183 if (declarator
->kind
== cdk_function
)
11184 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
11185 if (declarator
->kind
== cdk_array
)
11186 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
11187 returned_attrs
= decl_attributes (&type
,
11188 chainon (returned_attrs
, attrs
),
11192 inner_declarator
= declarator
->declarator
;
11194 /* We don't want to warn in parameter context because we don't
11195 yet know if the parse will succeed, and this might turn out
11196 to be a constructor call. */
11197 if (decl_context
!= PARM
11198 && decl_context
!= TYPENAME
11200 && declarator
->parenthesized
!= UNKNOWN_LOCATION
11201 /* If the type is class-like and the inner name used a
11202 global namespace qualifier, we need the parens.
11203 Unfortunately all we can tell is whether a qualified name
11204 was used or not. */
11205 && !(inner_declarator
11206 && inner_declarator
->kind
== cdk_id
11207 && inner_declarator
->u
.id
.qualifying_scope
11208 && (MAYBE_CLASS_TYPE_P (type
)
11209 || TREE_CODE (type
) == ENUMERAL_TYPE
)))
11210 warning_at (declarator
->parenthesized
, OPT_Wparentheses
,
11211 "unnecessary parentheses in declaration of %qs", name
);
11212 if (declarator
->kind
== cdk_id
|| declarator
->kind
== cdk_decomp
)
11215 switch (declarator
->kind
)
11218 type
= create_array_type_for_decl (dname
, type
,
11219 declarator
->u
.array
.bounds
,
11220 declarator
->id_loc
);
11221 if (!valid_array_size_p (input_location
, type
, dname
))
11222 type
= error_mark_node
;
11224 if (declarator
->std_attributes
)
11227 The optional attribute-specifier-seq appertains to the
11229 returned_attrs
= chainon (returned_attrs
,
11230 declarator
->std_attributes
);
11238 /* Declaring a function type. */
11240 input_location
= declspecs
->locations
[ds_type_spec
];
11241 abstract_virtuals_error (ACU_RETURN
, type
);
11242 input_location
= saved_loc
;
11244 /* Pick up type qualifiers which should be applied to `this'. */
11245 memfn_quals
= declarator
->u
.function
.qualifiers
;
11246 /* Pick up virt-specifiers. */
11247 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
11248 /* And ref-qualifier, too */
11249 rqual
= declarator
->u
.function
.ref_qualifier
;
11250 /* And tx-qualifier. */
11251 tree tx_qual
= declarator
->u
.function
.tx_qualifier
;
11252 /* Pick up the exception specifications. */
11253 raises
= declarator
->u
.function
.exception_specification
;
11254 /* If the exception-specification is ill-formed, let's pretend
11255 there wasn't one. */
11256 if (raises
== error_mark_node
)
11257 raises
= NULL_TREE
;
11260 error_at (location_of (reqs
), "requires-clause on return type");
11261 reqs
= declarator
->u
.function
.requires_clause
;
11263 /* Say it's a definition only for the CALL_EXPR
11264 closest to the identifier. */
11265 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
11267 /* Handle a late-specified return type. */
11268 tree late_return_type
= declarator
->u
.function
.late_return_type
;
11270 /* This is the case e.g. for
11271 using T = auto () -> int. */
11272 || inner_declarator
== NULL
)
11274 if (tree auto_node
= type_uses_auto (type
))
11276 if (!late_return_type
)
11278 if (current_class_type
11279 && LAMBDA_TYPE_P (current_class_type
))
11280 /* OK for C++11 lambdas. */;
11281 else if (cxx_dialect
< cxx14
)
11283 error ("%qs function uses "
11284 "%<auto%> type specifier without trailing "
11285 "return type", name
);
11286 inform (input_location
, "deduced return type "
11287 "only available with -std=c++14 or "
11292 error ("virtual function cannot "
11293 "have deduced return type");
11297 else if (!is_auto (type
) && sfk
!= sfk_conversion
)
11299 error ("%qs function with trailing return type has"
11300 " %qT as its type rather than plain %<auto%>",
11302 return error_mark_node
;
11304 else if (is_auto (type
) && AUTO_IS_DECLTYPE (type
))
11307 error ("%qs function with trailing return type has "
11308 "%<decltype(auto)%> as its type rather than "
11309 "plain %<auto%>", name
);
11311 error ("invalid use of %<decltype(auto)%>");
11312 return error_mark_node
;
11314 tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
);
11316 if (tree late_auto
= type_uses_auto (late_return_type
))
11317 tmpl
= CLASS_PLACEHOLDER_TEMPLATE (late_auto
);
11318 if (tmpl
&& funcdecl_p
)
11320 if (!dguide_name_p (unqualified_id
))
11322 error_at (declarator
->id_loc
, "deduced class "
11323 "type %qD in function return type",
11325 inform (DECL_SOURCE_LOCATION (tmpl
),
11326 "%qD declared here", tmpl
);
11327 return error_mark_node
;
11329 else if (!late_return_type
)
11331 error_at (declarator
->id_loc
, "deduction guide "
11332 "for %qT must have trailing return "
11333 "type", TREE_TYPE (tmpl
));
11334 inform (DECL_SOURCE_LOCATION (tmpl
),
11335 "%qD declared here", tmpl
);
11336 return error_mark_node
;
11338 else if (CLASS_TYPE_P (late_return_type
)
11339 && CLASSTYPE_TEMPLATE_INFO (late_return_type
)
11340 && (CLASSTYPE_TI_TEMPLATE (late_return_type
)
11344 error ("trailing return type %qT of deduction guide "
11345 "is not a specialization of %qT",
11346 late_return_type
, TREE_TYPE (tmpl
));
11349 else if (late_return_type
11350 && sfk
!= sfk_conversion
)
11352 if (cxx_dialect
< cxx11
)
11353 /* Not using maybe_warn_cpp0x because this should
11354 always be an error. */
11355 error ("trailing return type only available with "
11356 "-std=c++11 or -std=gnu++11");
11358 error ("%qs function with trailing return type not "
11359 "declared with %<auto%> type specifier", name
);
11360 return error_mark_node
;
11363 type
= splice_late_return_type (type
, late_return_type
);
11364 if (type
== error_mark_node
)
11365 return error_mark_node
;
11367 if (late_return_type
)
11369 late_return_type_p
= true;
11370 type_quals
= cp_type_quals (type
);
11373 if (type_quals
!= TYPE_UNQUALIFIED
)
11375 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
11376 warning_at (typespec_loc
, OPT_Wignored_qualifiers
, "type "
11377 "qualifiers ignored on function return type");
11378 /* We now know that the TYPE_QUALS don't apply to the
11379 decl, but to its return type. */
11380 type_quals
= TYPE_UNQUALIFIED
;
11383 /* Error about some types functions can't return. */
11385 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11387 error_at (typespec_loc
, "%qs declared as function returning "
11388 "a function", name
);
11389 return error_mark_node
;
11391 if (TREE_CODE (type
) == ARRAY_TYPE
)
11393 error_at (typespec_loc
, "%qs declared as function returning "
11395 return error_mark_node
;
11398 if (ctype
== NULL_TREE
11399 && decl_context
== FIELD
11402 ctype
= current_class_type
;
11404 if (ctype
&& (sfk
== sfk_constructor
11405 || sfk
== sfk_destructor
))
11407 /* We are within a class's scope. If our declarator name
11408 is the same as the class name, and we are defining
11409 a function, then it is a constructor/destructor, and
11410 therefore returns a void type. */
11412 /* ISO C++ 12.4/2. A destructor may not be declared
11413 const or volatile. A destructor may not be static.
11414 A destructor may not be declared with ref-qualifier.
11416 ISO C++ 12.1. A constructor may not be declared
11417 const or volatile. A constructor may not be
11418 virtual. A constructor may not be static.
11419 A constructor may not be declared with ref-qualifier. */
11421 error ((flags
== DTOR_FLAG
)
11422 ? G_("destructor cannot be static member function")
11423 : G_("constructor cannot be static member function"));
11426 error ((flags
== DTOR_FLAG
)
11427 ? G_("destructors may not be cv-qualified")
11428 : G_("constructors may not be cv-qualified"));
11429 memfn_quals
= TYPE_UNQUALIFIED
;
11434 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
11435 error ((flags
== DTOR_FLAG
)
11436 ? G_("destructors may not be ref-qualified")
11437 : G_("constructors may not be ref-qualified"));
11438 rqual
= REF_QUAL_NONE
;
11441 if (decl_context
== FIELD
11442 && !member_function_or_else (ctype
,
11443 current_class_type
,
11445 return error_mark_node
;
11447 if (flags
!= DTOR_FLAG
)
11449 /* It's a constructor. */
11450 if (explicitp
== 1)
11454 permerror (declspecs
->locations
[ds_virtual
],
11455 "constructors cannot be declared %<virtual%>");
11458 if (decl_context
== FIELD
11459 && sfk
!= sfk_constructor
)
11460 return error_mark_node
;
11462 if (decl_context
== FIELD
)
11469 /* Cannot be both friend and virtual. */
11470 gcc_rich_location
richloc (declspecs
->locations
[ds_virtual
]);
11471 richloc
.add_range (declspecs
->locations
[ds_friend
]);
11472 error_at (&richloc
, "virtual functions cannot be friends");
11475 if (decl_context
== NORMAL
)
11476 error ("friend declaration not in class definition");
11477 if (current_function_decl
&& funcdef_flag
)
11479 error ("can%'t define friend function %qs in a local "
11480 "class definition", name
);
11484 else if (ctype
&& sfk
== sfk_conversion
)
11486 if (explicitp
== 1)
11488 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
11491 if (late_return_type_p
)
11492 error ("a conversion function cannot have a trailing return type");
11494 else if (sfk
== sfk_deduction_guide
)
11496 if (explicitp
== 1)
11500 tree pushed_scope
= NULL_TREE
;
11502 && decl_context
!= FIELD
11503 && inner_declarator
->u
.id
.qualifying_scope
11504 && CLASS_TYPE_P (inner_declarator
->u
.id
.qualifying_scope
))
11506 = push_scope (inner_declarator
->u
.id
.qualifying_scope
);
11508 arg_types
= grokparms (declarator
->u
.function
.parameters
, &parms
);
11511 pop_scope (pushed_scope
);
11513 if (inner_declarator
11514 && inner_declarator
->kind
== cdk_id
11515 && inner_declarator
->u
.id
.sfk
== sfk_destructor
11516 && arg_types
!= void_list_node
)
11518 error ("destructors may not have parameters");
11519 arg_types
= void_list_node
;
11523 type
= build_function_type (type
, arg_types
);
11525 tree attrs
= declarator
->std_attributes
;
11528 tree att
= build_tree_list (tx_qual
, NULL_TREE
);
11529 /* transaction_safe applies to the type, but
11530 transaction_safe_dynamic applies to the function. */
11531 if (is_attribute_p ("transaction_safe", tx_qual
))
11532 attrs
= chainon (attrs
, att
);
11534 returned_attrs
= chainon (returned_attrs
, att
);
11539 The optional attribute-specifier-seq appertains to
11540 the function type. */
11541 decl_attributes (&type
, attrs
, 0);
11544 type
= build_exception_variant (type
, raises
);
11549 case cdk_reference
:
11551 /* Filter out pointers-to-references and references-to-references.
11552 We can get these if a TYPE_DECL is used. */
11554 if (TYPE_REF_P (type
))
11556 if (declarator
->kind
!= cdk_reference
)
11558 error ("cannot declare pointer to %q#T", type
);
11559 type
= TREE_TYPE (type
);
11562 /* In C++0x, we allow reference to reference declarations
11563 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
11564 and template type arguments [14.3.1/4 temp.arg.type]. The
11565 check for direct reference to reference declarations, which
11566 are still forbidden, occurs below. Reasoning behind the change
11567 can be found in DR106, DR540, and the rvalue reference
11569 else if (cxx_dialect
== cxx98
)
11571 error ("cannot declare reference to %q#T", type
);
11572 type
= TREE_TYPE (type
);
11575 else if (VOID_TYPE_P (type
))
11577 if (declarator
->kind
== cdk_reference
)
11578 error ("cannot declare reference to %q#T", type
);
11579 else if (declarator
->kind
== cdk_ptrmem
)
11580 error ("cannot declare pointer to %q#T member", type
);
11583 /* We now know that the TYPE_QUALS don't apply to the decl,
11584 but to the target of the pointer. */
11585 type_quals
= TYPE_UNQUALIFIED
;
11587 /* This code used to handle METHOD_TYPE, but I don't think it's
11588 possible to get it here anymore. */
11589 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
11590 if (declarator
->kind
== cdk_ptrmem
11591 && TREE_CODE (type
) == FUNCTION_TYPE
)
11593 memfn_quals
|= type_memfn_quals (type
);
11594 type
= build_memfn_type (type
,
11595 declarator
->u
.pointer
.class_type
,
11598 if (type
== error_mark_node
)
11599 return error_mark_node
;
11601 rqual
= REF_QUAL_NONE
;
11602 memfn_quals
= TYPE_UNQUALIFIED
;
11605 if (TREE_CODE (type
) == FUNCTION_TYPE
11606 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
11607 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
11608 error (declarator
->kind
== cdk_reference
11609 ? G_("cannot declare reference to qualified function type %qT")
11610 : G_("cannot declare pointer to qualified function type %qT"),
11613 /* When the pointed-to type involves components of variable size,
11614 care must be taken to ensure that the size evaluation code is
11615 emitted early enough to dominate all the possible later uses
11616 and late enough for the variables on which it depends to have
11619 This is expected to happen automatically when the pointed-to
11620 type has a name/declaration of it's own, but special attention
11621 is required if the type is anonymous.
11623 We handle the NORMAL and FIELD contexts here by inserting a
11624 dummy statement that just evaluates the size at a safe point
11625 and ensures it is not deferred until e.g. within a deeper
11626 conditional context (c++/43555).
11628 We expect nothing to be needed here for PARM or TYPENAME.
11629 Evaluating the size at this point for TYPENAME would
11630 actually be incorrect, as we might be in the middle of an
11631 expression with side effects on the pointed-to type size
11632 "arguments" prior to the pointer declaration point and the
11633 size evaluation could end up prior to the side effects. */
11635 if (!TYPE_NAME (type
)
11636 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
11637 && at_function_scope_p ()
11638 && variably_modified_type_p (type
, NULL_TREE
))
11640 TYPE_NAME (type
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
11642 add_decl_expr (TYPE_NAME (type
));
11645 if (declarator
->kind
== cdk_reference
)
11647 /* In C++0x, the type we are creating a reference to might be
11648 a typedef which is itself a reference type. In that case,
11649 we follow the reference collapsing rules in
11650 [7.1.3/8 dcl.typedef] to create the final reference type:
11652 "If a typedef TD names a type that is a reference to a type
11653 T, an attempt to create the type 'lvalue reference to cv TD'
11654 creates the type 'lvalue reference to T,' while an attempt
11655 to create the type "rvalue reference to cv TD' creates the
11658 if (VOID_TYPE_P (type
))
11659 /* We already gave an error. */;
11660 else if (TYPE_REF_P (type
))
11662 if (declarator
->u
.reference
.rvalue_ref
)
11663 /* Leave type alone. */;
11665 type
= cp_build_reference_type (TREE_TYPE (type
), false);
11668 type
= cp_build_reference_type
11669 (type
, declarator
->u
.reference
.rvalue_ref
);
11671 /* In C++0x, we need this check for direct reference to
11672 reference declarations, which are forbidden by
11673 [8.3.2/5 dcl.ref]. Reference to reference declarations
11674 are only allowed indirectly through typedefs and template
11675 type arguments. Example:
11677 void foo(int & &); // invalid ref-to-ref decl
11679 typedef int & int_ref;
11680 void foo(int_ref &); // valid ref-to-ref decl
11682 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
11683 error ("cannot declare reference to %q#T, which is not "
11684 "a typedef or a template type argument", type
);
11686 else if (TREE_CODE (type
) == METHOD_TYPE
)
11687 type
= build_ptrmemfunc_type (build_pointer_type (type
));
11688 else if (declarator
->kind
== cdk_ptrmem
)
11690 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
11691 != NAMESPACE_DECL
);
11692 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
11693 /* We will already have complained. */
11694 type
= error_mark_node
;
11696 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
11700 type
= build_pointer_type (type
);
11702 /* Process a list of type modifier keywords (such as
11703 const or volatile) that were given inside the `*' or `&'. */
11705 if (declarator
->u
.pointer
.qualifiers
)
11708 = cp_build_qualified_type (type
,
11709 declarator
->u
.pointer
.qualifiers
);
11710 type_quals
= cp_type_quals (type
);
11713 /* Apply C++11 attributes to the pointer, and not to the
11714 type pointed to. This is unlike what is done for GNU
11715 attributes above. It is to comply with [dcl.ptr]/1:
11717 [the optional attribute-specifier-seq (7.6.1) appertains
11718 to the pointer and not to the object pointed to]. */
11719 if (declarator
->std_attributes
)
11720 decl_attributes (&type
, declarator
->std_attributes
,
11730 gcc_unreachable ();
11734 /* A `constexpr' specifier used in an object declaration declares
11735 the object as `const'. */
11736 if (constexpr_p
&& innermost_code
!= cdk_function
)
11738 /* DR1688 says that a `constexpr' specifier in combination with
11739 `volatile' is valid. */
11741 if (!TYPE_REF_P (type
))
11743 type_quals
|= TYPE_QUAL_CONST
;
11744 type
= cp_build_qualified_type (type
, type_quals
);
11748 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
11749 && TREE_CODE (type
) != FUNCTION_TYPE
11750 && TREE_CODE (type
) != METHOD_TYPE
11751 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
11753 error ("template-id %qD used as a declarator",
11755 unqualified_id
= dname
;
11758 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
11759 qualified with a class-name, turn it into a METHOD_TYPE, unless
11760 we know that the function is static. We take advantage of this
11761 opportunity to do other processing that pertains to entities
11762 explicitly declared to be class members. Note that if DECLARATOR
11763 is non-NULL, we know it is a cdk_id declarator; otherwise, we
11764 would not have exited the loop above. */
11766 && declarator
->kind
== cdk_id
11767 && declarator
->u
.id
.qualifying_scope
11768 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
11770 ctype
= declarator
->u
.id
.qualifying_scope
;
11771 ctype
= TYPE_MAIN_VARIANT (ctype
);
11772 template_count
= num_template_headers_for_class (ctype
);
11774 if (ctype
== current_class_type
)
11778 permerror (input_location
, "member functions are implicitly "
11779 "friends of their class");
11783 permerror (declarator
->id_loc
,
11784 "extra qualification %<%T::%> on member %qs",
11787 else if (/* If the qualifying type is already complete, then we
11788 can skip the following checks. */
11789 !COMPLETE_TYPE_P (ctype
)
11790 && (/* If the function is being defined, then
11791 qualifying type must certainly be complete. */
11793 /* A friend declaration of "T::f" is OK, even if
11794 "T" is a template parameter. But, if this
11795 function is not a friend, the qualifying type
11796 must be a class. */
11797 || (!friendp
&& !CLASS_TYPE_P (ctype
))
11798 /* For a declaration, the type need not be
11799 complete, if either it is dependent (since there
11800 is no meaningful definition of complete in that
11801 case) or the qualifying class is currently being
11803 || !(dependent_type_p (ctype
)
11804 || currently_open_class (ctype
)))
11805 /* Check that the qualifying type is complete. */
11806 && !complete_type_or_else (ctype
, NULL_TREE
))
11807 return error_mark_node
;
11808 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11810 if (current_class_type
11811 && (!friendp
|| funcdef_flag
|| initialized
))
11813 error (funcdef_flag
|| initialized
11814 ? G_("cannot define member function %<%T::%s%> "
11816 : G_("cannot declare member function %<%T::%s%> "
11818 ctype
, name
, current_class_type
);
11819 return error_mark_node
;
11822 else if (typedef_p
&& current_class_type
)
11824 error ("cannot declare member %<%T::%s%> within %qT",
11825 ctype
, name
, current_class_type
);
11826 return error_mark_node
;
11830 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
11831 ctype
= current_class_type
;
11833 /* Now TYPE has the actual type. */
11835 if (returned_attrs
)
11838 *attrlist
= chainon (returned_attrs
, *attrlist
);
11840 attrlist
= &returned_attrs
;
11844 && declarator
->kind
== cdk_id
11845 && declarator
->std_attributes
11846 && attrlist
!= NULL
)
11848 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
11849 a declarator-id appertains to the entity that is declared. */
11850 if (declarator
->std_attributes
!= error_mark_node
)
11851 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
11853 /* We should have already diagnosed the issue (c++/78344). */
11854 gcc_assert (seen_error ());
11857 /* Handle parameter packs. */
11858 if (parameter_pack_p
)
11860 if (decl_context
== PARM
)
11861 /* Turn the type into a pack expansion.*/
11862 type
= make_pack_expansion (type
);
11864 error ("non-parameter %qs cannot be a parameter pack", name
);
11867 if ((decl_context
== FIELD
|| decl_context
== PARM
)
11868 && !processing_template_decl
11869 && variably_modified_type_p (type
, NULL_TREE
))
11871 if (decl_context
== FIELD
)
11872 error ("data member may not have variably modified type %qT", type
);
11874 error ("parameter may not have variably modified type %qT", type
);
11875 type
= error_mark_node
;
11878 if (explicitp
== 1 || (explicitp
&& friendp
))
11880 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
11881 in the declaration of a constructor or conversion function within
11882 a class definition. */
11883 if (!current_class_type
)
11884 error_at (declspecs
->locations
[ds_explicit
],
11885 "%<explicit%> outside class declaration");
11887 error_at (declspecs
->locations
[ds_explicit
],
11888 "%<explicit%> in friend declaration");
11890 error_at (declspecs
->locations
[ds_explicit
],
11891 "only declarations of constructors and conversion operators "
11892 "can be %<explicit%>");
11896 if (storage_class
== sc_mutable
)
11898 if (decl_context
!= FIELD
|| friendp
)
11900 error ("non-member %qs cannot be declared %<mutable%>", name
);
11901 storage_class
= sc_none
;
11903 else if (decl_context
== TYPENAME
|| typedef_p
)
11905 error ("non-object member %qs cannot be declared %<mutable%>", name
);
11906 storage_class
= sc_none
;
11908 else if (TREE_CODE (type
) == FUNCTION_TYPE
11909 || TREE_CODE (type
) == METHOD_TYPE
)
11911 error ("function %qs cannot be declared %<mutable%>", name
);
11912 storage_class
= sc_none
;
11916 error ("static %qs cannot be declared %<mutable%>", name
);
11917 storage_class
= sc_none
;
11919 else if (type_quals
& TYPE_QUAL_CONST
)
11921 error ("const %qs cannot be declared %<mutable%>", name
);
11922 storage_class
= sc_none
;
11924 else if (TYPE_REF_P (type
))
11926 permerror (input_location
, "reference %qs cannot be declared "
11927 "%<mutable%>", name
);
11928 storage_class
= sc_none
;
11932 /* If this is declaring a typedef name, return a TYPE_DECL. */
11933 if (typedef_p
&& decl_context
!= TYPENAME
)
11935 bool alias_p
= decl_spec_seq_has_spec_p (declspecs
, ds_alias
);
11938 /* This declaration:
11940 typedef void f(int) const;
11942 declares a function type which is not a member of any
11943 particular class, but which is cv-qualified; for
11944 example "f S::*" declares a pointer to a const-qualified
11945 member function of S. We record the cv-qualification in the
11947 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
11949 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
11951 /* We have now dealt with these qualifiers. */
11952 memfn_quals
= TYPE_UNQUALIFIED
;
11953 rqual
= REF_QUAL_NONE
;
11956 if (type_uses_auto (type
))
11959 error_at (declspecs
->locations
[ds_type_spec
],
11960 "%<auto%> not allowed in alias declaration");
11962 error_at (declspecs
->locations
[ds_type_spec
],
11963 "typedef declared %<auto%>");
11964 type
= error_mark_node
;
11968 error_at (location_of (reqs
), "requires-clause on typedef");
11970 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
)
11972 error ("typedef name may not be a nested-name-specifier");
11973 type
= error_mark_node
;
11976 if (decl_context
== FIELD
)
11977 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
11979 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
11981 if (decl_context
!= FIELD
)
11983 if (!current_function_decl
)
11984 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
11985 else if (DECL_MAYBE_IN_CHARGE_CDTOR_P (current_function_decl
))
11986 /* The TYPE_DECL is "abstract" because there will be
11987 clones of this constructor/destructor, and there will
11988 be copies of this TYPE_DECL generated in those
11989 clones. The decloning optimization (for space) may
11990 revert this subsequently if it determines that
11991 the clones should share a common implementation. */
11992 DECL_ABSTRACT_P (decl
) = true;
11994 else if (current_class_type
11995 && constructor_name_p (unqualified_id
, current_class_type
))
11996 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
11997 "as enclosing class",
12000 /* If the user declares "typedef struct {...} foo" then the
12001 struct will have an anonymous name. Fill that name in now.
12002 Nothing can refer to it, so nothing needs know about the name
12004 if (type
!= error_mark_node
12006 && TYPE_NAME (type
)
12007 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12008 && TYPE_UNNAMED_P (type
)
12009 && declspecs
->type_definition_p
12010 && attributes_naming_typedef_ok (*attrlist
)
12011 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
12012 name_unnamed_type (type
, decl
);
12015 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
12016 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
12018 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
12019 memfn_quals
!= TYPE_UNQUALIFIED
,
12020 inlinep
, friendp
, raises
!= NULL_TREE
,
12021 declspecs
->locations
);
12024 /* Acknowledge that this was written:
12025 `using analias = atype;'. */
12026 TYPE_DECL_ALIAS_P (decl
) = 1;
12031 /* Detect the case of an array type of unspecified size
12032 which came, as such, direct from a typedef name.
12033 We must copy the type, so that the array's domain can be
12034 individually set by the object's initializer. */
12036 if (type
&& typedef_type
12037 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
12038 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
12039 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
12041 /* Detect where we're using a typedef of function type to declare a
12042 function. PARMS will not be set, so we must create it now. */
12044 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
12046 tree decls
= NULL_TREE
;
12049 for (args
= TYPE_ARG_TYPES (type
);
12050 args
&& args
!= void_list_node
;
12051 args
= TREE_CHAIN (args
))
12053 tree decl
= cp_build_parm_decl (NULL_TREE
, NULL_TREE
,
12054 TREE_VALUE (args
));
12056 DECL_CHAIN (decl
) = decls
;
12060 parms
= nreverse (decls
);
12062 if (decl_context
!= TYPENAME
)
12064 /* The qualifiers on the function type become the qualifiers on
12065 the non-static member function. */
12066 memfn_quals
|= type_memfn_quals (type
);
12067 rqual
= type_memfn_rqual (type
);
12068 type_quals
= TYPE_UNQUALIFIED
;
12072 /* If this is a type name (such as, in a cast or sizeof),
12073 compute the type and return it now. */
12075 if (decl_context
== TYPENAME
)
12077 /* Note that here we don't care about type_quals. */
12079 /* Special case: "friend class foo" looks like a TYPENAME context. */
12084 error ("%<inline%> specified for friend class declaration");
12090 /* Don't allow friend declaration without a class-key. */
12091 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
12092 permerror (input_location
, "template parameters cannot be friends");
12093 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
12094 permerror (input_location
, "friend declaration requires class-key, "
12095 "i.e. %<friend class %T::%D%>",
12096 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
12098 permerror (input_location
, "friend declaration requires class-key, "
12099 "i.e. %<friend %#T%>",
12103 /* Only try to do this stuff if we didn't already give up. */
12104 if (type
!= integer_type_node
)
12106 /* A friendly class? */
12107 if (current_class_type
)
12108 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
12109 /*complain=*/true);
12111 error ("trying to make class %qT a friend of global scope",
12114 type
= void_type_node
;
12117 else if (memfn_quals
|| rqual
)
12119 if (ctype
== NULL_TREE
12120 && TREE_CODE (type
) == METHOD_TYPE
)
12121 ctype
= TYPE_METHOD_BASETYPE (type
);
12124 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
12125 /* Core issue #547: need to allow this in template type args.
12126 Allow it in general in C++11 for alias-declarations. */
12127 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
12128 && TREE_CODE (type
) == FUNCTION_TYPE
)
12129 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
12131 error ("invalid qualifiers on non-member function type");
12135 error_at (location_of (reqs
), "requires-clause on type-id");
12139 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
12140 && decl_context
!= CATCHPARM
12141 && TREE_CODE (type
) != UNION_TYPE
12143 && innermost_code
!= cdk_decomp
)
12145 error ("abstract declarator %qT used as declaration", type
);
12146 return error_mark_node
;
12149 if (!FUNC_OR_METHOD_TYPE_P (type
))
12151 /* Only functions may be declared using an operator-function-id. */
12152 if (dname
&& IDENTIFIER_ANY_OP_P (dname
))
12154 error ("declaration of %qD as non-function", dname
);
12155 return error_mark_node
;
12159 error_at (location_of (reqs
),
12160 "requires-clause on declaration of non-function type %qT",
12164 /* We don't check parameter types here because we can emit a better
12165 error message later. */
12166 if (decl_context
!= PARM
)
12168 type
= check_var_type (unqualified_id
, type
);
12169 if (type
== error_mark_node
)
12170 return error_mark_node
;
12173 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
12174 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
12176 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
12178 if (ctype
|| in_namespace
)
12179 error ("cannot use %<::%> in parameter declaration");
12181 if (type_uses_auto (type
)
12182 && !(cxx_dialect
>= cxx17
&& template_parm_flag
))
12184 if (cxx_dialect
>= cxx14
)
12185 error ("%<auto%> parameter not permitted in this context");
12187 error ("parameter declared %<auto%>");
12188 type
= error_mark_node
;
12191 /* A parameter declared as an array of T is really a pointer to T.
12192 One declared as a function is really a pointer to a function.
12193 One declared as a member is really a pointer to member. */
12195 if (TREE_CODE (type
) == ARRAY_TYPE
)
12197 /* Transfer const-ness of array into that of type pointed to. */
12198 type
= build_pointer_type (TREE_TYPE (type
));
12199 type_quals
= TYPE_UNQUALIFIED
;
12200 array_parameter_p
= true;
12202 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
12203 type
= build_pointer_type (type
);
12206 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
12207 && !(unqualified_id
12208 && identifier_p (unqualified_id
)
12209 && IDENTIFIER_NEWDEL_OP_P (unqualified_id
)))
12211 cp_cv_quals real_quals
= memfn_quals
;
12212 if (cxx_dialect
< cxx14
&& constexpr_p
12213 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
12214 real_quals
|= TYPE_QUAL_CONST
;
12215 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
12219 tree decl
= NULL_TREE
;
12220 location_t loc
= declarator
? declarator
->id_loc
: input_location
;
12222 if (decl_context
== PARM
)
12224 decl
= cp_build_parm_decl (NULL_TREE
, unqualified_id
, type
);
12225 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
12227 bad_specifiers (decl
, BSP_PARM
, virtualp
,
12228 memfn_quals
!= TYPE_UNQUALIFIED
,
12229 inlinep
, friendp
, raises
!= NULL_TREE
,
12230 declspecs
->locations
);
12232 else if (decl_context
== FIELD
)
12234 if (!staticp
&& !friendp
&& TREE_CODE (type
) != METHOD_TYPE
)
12235 if (tree auto_node
= type_uses_auto (type
))
12237 location_t tloc
= declspecs
->locations
[ds_type_spec
];
12238 if (CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
12239 error_at (tloc
, "invalid use of template-name %qE without an "
12241 CLASS_PLACEHOLDER_TEMPLATE (auto_node
));
12243 error_at (tloc
, "non-static data member declared with "
12244 "placeholder %qT", auto_node
);
12245 type
= error_mark_node
;
12248 /* The C99 flexible array extension. */
12249 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
12250 && TYPE_DOMAIN (type
) == NULL_TREE
)
12253 && (TREE_CODE (ctype
) == UNION_TYPE
12254 || TREE_CODE (ctype
) == QUAL_UNION_TYPE
))
12256 error ("flexible array member in union");
12257 type
= error_mark_node
;
12261 /* Array is a flexible member. */
12262 if (in_system_header_at (input_location
))
12263 /* Do not warn on flexible array members in system
12264 headers because glibc uses them. */;
12265 else if (name
&& declarator
)
12266 pedwarn (declarator
->id_loc
, OPT_Wpedantic
,
12267 "ISO C++ forbids flexible array member %qs", name
);
12269 pedwarn (input_location
, OPT_Wpedantic
,
12270 "ISO C++ forbids flexible array members");
12272 /* Flexible array member has a null domain. */
12273 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
12277 if (type
== error_mark_node
)
12279 /* Happens when declaring arrays of sizes which
12280 are error_mark_node, for example. */
12283 else if (in_namespace
&& !friendp
)
12285 /* Something like struct S { int N::j; }; */
12286 error ("invalid use of %<::%>");
12287 return error_mark_node
;
12289 else if (FUNC_OR_METHOD_TYPE_P (type
) && unqualified_id
)
12292 tree function_context
;
12296 /* This should never happen in pure C++ (the check
12297 could be an assert). It could happen in
12298 Objective-C++ if someone writes invalid code that
12299 uses a function declaration for an instance
12300 variable or property (instance variables and
12301 properties are parsed as FIELD_DECLs, but they are
12302 part of an Objective-C class, not a C++ class).
12303 That code is invalid and is caught by this
12307 error ("declaration of function %qD in invalid context",
12309 return error_mark_node
;
12312 /* ``A union may [ ... ] not [ have ] virtual functions.''
12314 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
12316 error_at (declspecs
->locations
[ds_virtual
],
12317 "function %qD declared %<virtual%> inside a union",
12319 return error_mark_node
;
12323 && identifier_p (unqualified_id
)
12324 && IDENTIFIER_NEWDEL_OP_P (unqualified_id
))
12326 error_at (declspecs
->locations
[ds_virtual
],
12327 "%qD cannot be declared %<virtual%>, since it "
12328 "is always static", unqualified_id
);
12333 /* Check that the name used for a destructor makes sense. */
12334 if (sfk
== sfk_destructor
)
12336 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
12340 gcc_assert (friendp
);
12341 error ("expected qualified name in friend declaration "
12342 "for destructor %qD", uqname
);
12343 return error_mark_node
;
12346 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
12348 error ("declaration of %qD as member of %qT",
12350 return error_mark_node
;
12354 error_at (declspecs
->locations
[ds_concept
],
12355 "a destructor cannot be %<concept%>");
12356 return error_mark_node
;
12360 error_at (declspecs
->locations
[ds_constexpr
],
12361 "a destructor cannot be %<constexpr%>");
12362 return error_mark_node
;
12365 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
12367 error ("expected qualified name in friend declaration "
12368 "for constructor %qD",
12369 id_declarator
->u
.id
.unqualified_name
);
12370 return error_mark_node
;
12372 if (sfk
== sfk_constructor
)
12375 error_at (declspecs
->locations
[ds_concept
],
12376 "a constructor cannot be %<concept%>");
12377 return error_mark_node
;
12381 error_at (declspecs
->locations
[ds_concept
],
12382 "a concept cannot be a member function");
12386 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
12388 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
12389 if (variable_template_p (tmpl
))
12391 error ("specialization of variable template %qD "
12392 "declared as function", tmpl
);
12393 inform (DECL_SOURCE_LOCATION (tmpl
),
12394 "variable template declared here");
12395 return error_mark_node
;
12399 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
12400 function_context
= (ctype
!= NULL_TREE
) ?
12401 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
12402 publicp
= (! friendp
|| ! staticp
)
12403 && function_context
== NULL_TREE
;
12405 decl
= grokfndecl (ctype
, type
,
12406 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
12407 ? unqualified_id
: dname
,
12412 virtualp
, flags
, memfn_quals
, rqual
, raises
,
12413 friendp
? -1 : 0, friendp
, publicp
,
12414 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
12415 initialized
== SD_DELETED
, sfk
,
12416 funcdef_flag
, late_return_type_p
,
12417 template_count
, in_namespace
,
12418 attrlist
, declarator
->id_loc
);
12419 decl
= set_virt_specifiers (decl
, virt_specifiers
);
12420 if (decl
== NULL_TREE
)
12421 return error_mark_node
;
12423 /* This clobbers the attrs stored in `decl' from `attrlist'. */
12424 /* The decl and setting of decl_attr is also turned off. */
12425 decl
= build_decl_attribute_variant (decl
, decl_attr
);
12428 /* [class.conv.ctor]
12430 A constructor declared without the function-specifier
12431 explicit that can be called with a single parameter
12432 specifies a conversion from the type of its first
12433 parameter to the type of its class. Such a constructor
12434 is called a converting constructor. */
12435 if (explicitp
== 2)
12436 DECL_NONCONVERTING_P (decl
) = 1;
12438 if (declspecs
->explicit_specifier
)
12439 store_explicit_specifier (decl
, declspecs
->explicit_specifier
);
12441 else if (!staticp
&& !dependent_type_p (type
)
12442 && !COMPLETE_TYPE_P (complete_type (type
))
12443 && (!complete_or_array_type_p (type
)
12444 || initialized
== 0))
12446 if (TREE_CODE (type
) != ARRAY_TYPE
12447 || !COMPLETE_TYPE_P (TREE_TYPE (type
)))
12449 if (unqualified_id
)
12451 error_at (declarator
->id_loc
,
12452 "field %qD has incomplete type %qT",
12453 unqualified_id
, type
);
12454 cxx_incomplete_type_inform (strip_array_types (type
));
12457 error ("name %qT has incomplete type", type
);
12459 type
= error_mark_node
;
12467 if (unqualified_id
&& declarator
)
12468 error_at (declarator
->id_loc
,
12469 "%qE is neither function nor member function; "
12470 "cannot be declared friend", unqualified_id
);
12472 error ("unnamed field is neither function nor member "
12473 "function; cannot be declared friend");
12474 return error_mark_node
;
12481 /* Friends are treated specially. */
12482 if (ctype
== current_class_type
)
12483 ; /* We already issued a permerror. */
12484 else if (decl
&& DECL_NAME (decl
))
12486 if (template_class_depth (current_class_type
) == 0)
12488 decl
= check_explicit_specialization
12489 (unqualified_id
, decl
, template_count
,
12490 2 * funcdef_flag
+ 4);
12491 if (decl
== error_mark_node
)
12492 return error_mark_node
;
12495 decl
= do_friend (ctype
, unqualified_id
, decl
,
12501 return error_mark_node
;
12504 /* Structure field. It may not be a function, except for C++. */
12506 if (decl
== NULL_TREE
)
12510 /* C++ allows static class members. All other work
12511 for this is done by grokfield. */
12512 decl
= build_lang_decl_loc (loc
, VAR_DECL
,
12513 unqualified_id
, type
);
12514 set_linkage_for_static_data_member (decl
);
12516 error_at (declspecs
->locations
[ds_concept
],
12517 "static data member %qE declared %<concept%>",
12519 else if (constexpr_p
&& !initialized
)
12521 error_at (DECL_SOURCE_LOCATION (decl
),
12522 "%<constexpr%> static data member %qD must "
12523 "have an initializer", decl
);
12524 constexpr_p
= false;
12528 mark_inline_variable (decl
, declspecs
->locations
[ds_inline
]);
12530 if (!DECL_VAR_DECLARED_INLINE_P (decl
)
12531 && !(cxx_dialect
>= cxx17
&& constexpr_p
))
12532 /* Even if there is an in-class initialization, DECL
12533 is considered undefined until an out-of-class
12534 definition is provided, unless this is an inline
12536 DECL_EXTERNAL (decl
) = 1;
12540 CP_DECL_THREAD_LOCAL_P (decl
) = true;
12541 if (!processing_template_decl
)
12542 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
12543 if (declspecs
->gnu_thread_keyword_p
)
12544 SET_DECL_GNU_TLS_P (decl
);
12550 error_at (declspecs
->locations
[ds_concept
],
12551 "non-static data member %qE declared %<concept%>",
12553 else if (constexpr_p
)
12555 error_at (declspecs
->locations
[ds_constexpr
],
12556 "non-static data member %qE declared %<constexpr%>",
12558 constexpr_p
= false;
12560 decl
= build_decl (loc
, FIELD_DECL
, unqualified_id
, type
);
12561 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
12562 if (bitfield
&& !unqualified_id
)
12564 TREE_NO_WARNING (decl
) = 1;
12565 DECL_PADDING_P (decl
) = 1;
12568 if (storage_class
== sc_mutable
)
12570 DECL_MUTABLE_P (decl
) = 1;
12571 storage_class
= sc_none
;
12576 /* An attempt is being made to initialize a non-static
12577 member. This is new in C++11. */
12578 maybe_warn_cpp0x (CPP0X_NSDMI
);
12580 /* If this has been parsed with static storage class, but
12581 errors forced staticp to be cleared, ensure NSDMI is
12583 if (declspecs
->storage_class
== sc_static
)
12584 DECL_INITIAL (decl
) = error_mark_node
;
12588 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
12589 memfn_quals
!= TYPE_UNQUALIFIED
,
12590 staticp
? false : inlinep
, friendp
,
12591 raises
!= NULL_TREE
,
12592 declspecs
->locations
);
12595 else if (TREE_CODE (type
) == FUNCTION_TYPE
12596 || TREE_CODE (type
) == METHOD_TYPE
)
12598 tree original_name
;
12601 if (!unqualified_id
)
12602 return error_mark_node
;
12604 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
12605 original_name
= dname
;
12607 original_name
= unqualified_id
;
12608 // FIXME:gcc_assert (original_name == dname);
12610 if (storage_class
== sc_auto
)
12611 error ("storage class %<auto%> invalid for function %qs", name
);
12612 else if (storage_class
== sc_register
)
12613 error ("storage class %<register%> invalid for function %qs", name
);
12616 if (declspecs
->gnu_thread_keyword_p
)
12617 error_at (declspecs
->locations
[ds_thread
],
12618 "storage class %<__thread%> invalid for function %qs",
12621 error_at (declspecs
->locations
[ds_thread
],
12622 "storage class %<thread_local%> invalid for "
12623 "function %qs", name
);
12626 if (virt_specifiers
)
12627 error ("virt-specifiers in %qs not allowed outside a class "
12628 "definition", name
);
12629 /* Function declaration not at top level.
12630 Storage classes other than `extern' are not allowed
12631 and `extern' makes no difference. */
12632 if (! toplevel_bindings_p ()
12633 && (storage_class
== sc_static
12634 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
12637 if (storage_class
== sc_static
)
12638 pedwarn (declspecs
->locations
[ds_storage_class
], OPT_Wpedantic
,
12639 "%<static%> specifier invalid for function %qs "
12640 "declared out of global scope", name
);
12642 pedwarn (declspecs
->locations
[ds_inline
], OPT_Wpedantic
,
12643 "%<inline%> specifier invalid for function %qs "
12644 "declared out of global scope", name
);
12647 if (ctype
== NULL_TREE
)
12651 error ("virtual non-class function %qs", name
);
12654 else if (sfk
== sfk_constructor
12655 || sfk
== sfk_destructor
)
12657 error (funcdef_flag
12658 ? G_("%qs defined in a non-class scope")
12659 : G_("%qs declared in a non-class scope"), name
);
12664 /* Record whether the function is public. */
12665 publicp
= (ctype
!= NULL_TREE
12666 || storage_class
!= sc_static
);
12668 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
12670 reqs
, virtualp
, flags
, memfn_quals
, rqual
, raises
,
12673 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
12674 initialized
== SD_DELETED
,
12677 late_return_type_p
,
12678 template_count
, in_namespace
, attrlist
,
12679 declarator
->id_loc
);
12680 if (decl
== NULL_TREE
)
12681 return error_mark_node
;
12683 if (explicitp
== 2)
12684 DECL_NONCONVERTING_P (decl
) = 1;
12687 int invalid_static
= 0;
12689 /* Don't allow a static member function in a class, and forbid
12690 declaring main to be static. */
12691 if (TREE_CODE (type
) == METHOD_TYPE
)
12693 permerror (input_location
, "cannot declare member function %qD to have "
12694 "static linkage", decl
);
12695 invalid_static
= 1;
12697 else if (current_function_decl
)
12699 /* 7.1.1: There can be no static function declarations within a
12701 error_at (declspecs
->locations
[ds_storage_class
],
12702 "cannot declare static function inside another function");
12703 invalid_static
= 1;
12706 if (invalid_static
)
12709 storage_class
= sc_none
;
12715 /* It's a variable. */
12717 /* An uninitialized decl with `extern' is a reference. */
12718 decl
= grokvardecl (type
, dname
, unqualified_id
,
12725 ctype
? ctype
: in_namespace
,
12727 if (decl
== NULL_TREE
)
12728 return error_mark_node
;
12730 bad_specifiers (decl
, BSP_VAR
, virtualp
,
12731 memfn_quals
!= TYPE_UNQUALIFIED
,
12732 inlinep
, friendp
, raises
!= NULL_TREE
,
12733 declspecs
->locations
);
12737 DECL_CONTEXT (decl
) = ctype
;
12740 permerror (declspecs
->locations
[ds_storage_class
],
12741 "%<static%> may not be used when defining "
12742 "(as opposed to declaring) a static data member");
12744 storage_class
= sc_none
;
12746 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
12748 error ("static member %qD declared %<register%>", decl
);
12749 storage_class
= sc_none
;
12751 if (storage_class
== sc_extern
&& pedantic
)
12753 pedwarn (input_location
, OPT_Wpedantic
,
12754 "cannot explicitly declare member %q#D to have "
12755 "extern linkage", decl
);
12756 storage_class
= sc_none
;
12759 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
12761 error_at (DECL_SOURCE_LOCATION (decl
),
12762 "declaration of %<constexpr%> variable %qD "
12763 "is not a definition", decl
);
12764 constexpr_p
= false;
12768 mark_inline_variable (decl
, declspecs
->locations
[ds_inline
]);
12769 if (innermost_code
== cdk_decomp
)
12771 gcc_assert (declarator
&& declarator
->kind
== cdk_decomp
);
12772 DECL_SOURCE_LOCATION (decl
) = declarator
->id_loc
;
12773 DECL_ARTIFICIAL (decl
) = 1;
12774 fit_decomposition_lang_decl (decl
, NULL_TREE
);
12778 if (VAR_P (decl
) && !initialized
)
12779 if (tree auto_node
= type_uses_auto (type
))
12780 if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
12782 location_t loc
= declspecs
->locations
[ds_type_spec
];
12783 error_at (loc
, "declaration of %q#D has no initializer", decl
);
12784 TREE_TYPE (decl
) = error_mark_node
;
12787 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
12789 if (toplevel_bindings_p ())
12791 /* It's common practice (and completely valid) to have a const
12792 be initialized and declared extern. */
12793 if (!(type_quals
& TYPE_QUAL_CONST
))
12794 warning (0, "%qs initialized and declared %<extern%>", name
);
12798 error ("%qs has both %<extern%> and initializer", name
);
12799 return error_mark_node
;
12803 /* Record `register' declaration for warnings on &
12804 and in case doing stupid register allocation. */
12806 if (storage_class
== sc_register
)
12808 DECL_REGISTER (decl
) = 1;
12809 /* Warn about register storage specifiers on PARM_DECLs. */
12810 if (TREE_CODE (decl
) == PARM_DECL
)
12812 if (cxx_dialect
>= cxx17
)
12813 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
12814 "ISO C++17 does not allow %<register%> storage "
12815 "class specifier");
12817 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
12818 "%<register%> storage class specifier used");
12821 else if (storage_class
== sc_extern
)
12822 DECL_THIS_EXTERN (decl
) = 1;
12823 else if (storage_class
== sc_static
)
12824 DECL_THIS_STATIC (decl
) = 1;
12826 /* Set constexpr flag on vars (functions got it in grokfndecl). */
12827 if (constexpr_p
&& VAR_P (decl
))
12828 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
12830 /* Record constancy and volatility on the DECL itself . There's
12831 no need to do this when processing a template; we'll do this
12832 for the instantiated declaration based on the type of DECL. */
12833 if (!processing_template_decl
)
12834 cp_apply_type_quals_to_decl (type_quals
, decl
);
12840 /* Subroutine of start_function. Ensure that each of the parameter
12841 types (as listed in PARMS) is complete, as is required for a
12842 function definition. */
12845 require_complete_types_for_parms (tree parms
)
12847 for (; parms
; parms
= DECL_CHAIN (parms
))
12849 if (dependent_type_p (TREE_TYPE (parms
)))
12851 if (!VOID_TYPE_P (TREE_TYPE (parms
))
12852 && complete_type_or_else (TREE_TYPE (parms
), parms
))
12854 relayout_decl (parms
);
12855 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
12857 maybe_warn_parm_abi (TREE_TYPE (parms
),
12858 DECL_SOURCE_LOCATION (parms
));
12861 /* grokparms or complete_type_or_else will have already issued
12863 TREE_TYPE (parms
) = error_mark_node
;
12867 /* Returns nonzero if T is a local variable. */
12870 local_variable_p (const_tree t
)
12873 /* A VAR_DECL with a context that is a _TYPE is a static data
12875 && !TYPE_P (CP_DECL_CONTEXT (t
))
12876 /* Any other non-local variable must be at namespace scope. */
12877 && !DECL_NAMESPACE_SCOPE_P (t
))
12878 || (TREE_CODE (t
) == PARM_DECL
))
12884 /* Like local_variable_p, but suitable for use as a tree-walking
12888 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
12891 if (local_variable_p (*tp
)
12892 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
12894 else if (TYPE_P (*tp
))
12895 *walk_subtrees
= 0;
12900 /* Check that ARG, which is a default-argument expression for a
12901 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
12902 something goes wrong. DECL may also be a _TYPE node, rather than a
12903 DECL, if there is no DECL available. */
12906 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
12911 if (TREE_CODE (arg
) == DEFAULT_ARG
)
12912 /* We get a DEFAULT_ARG when looking at an in-class declaration
12913 with a default argument. Ignore the argument for now; we'll
12914 deal with it after the class is complete. */
12923 decl_type
= TREE_TYPE (decl
);
12925 if (arg
== error_mark_node
12926 || decl
== error_mark_node
12927 || TREE_TYPE (arg
) == error_mark_node
12928 || decl_type
== error_mark_node
)
12929 /* Something already went wrong. There's no need to check
12931 return error_mark_node
;
12933 /* [dcl.fct.default]
12935 A default argument expression is implicitly converted to the
12937 ++cp_unevaluated_operand
;
12938 /* Avoid digest_init clobbering the initializer. */
12939 tree carg
= BRACE_ENCLOSED_INITIALIZER_P (arg
) ? unshare_expr (arg
): arg
;
12940 perform_implicit_conversion_flags (decl_type
, carg
, complain
,
12942 --cp_unevaluated_operand
;
12944 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
12946 if (TYPE_PTR_OR_PTRMEM_P (decl_type
)
12947 && null_ptr_cst_p (arg
))
12948 return nullptr_node
;
12950 /* [dcl.fct.default]
12952 Local variables shall not be used in default argument
12955 The keyword `this' shall not be used in a default argument of a
12956 member function. */
12957 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
12960 if (complain
& tf_warning_or_error
)
12962 if (DECL_NAME (var
) == this_identifier
)
12963 permerror (input_location
, "default argument %qE uses %qD",
12966 error ("default argument %qE uses local variable %qD", arg
, var
);
12968 return error_mark_node
;
12975 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
12978 type_is_deprecated (tree type
)
12980 enum tree_code code
;
12981 if (TREE_DEPRECATED (type
))
12983 if (TYPE_NAME (type
))
12985 if (TREE_DEPRECATED (TYPE_NAME (type
)))
12991 /* Do warn about using typedefs to a deprecated class. */
12992 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
12993 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
12995 code
= TREE_CODE (type
);
12997 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
12998 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
12999 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
13000 return type_is_deprecated (TREE_TYPE (type
));
13002 if (TYPE_PTRMEMFUNC_P (type
))
13003 return type_is_deprecated
13004 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
13009 /* Decode the list of parameter types for a function type.
13010 Given the list of things declared inside the parens,
13011 return a list of types.
13013 If this parameter does not end with an ellipsis, we append
13016 *PARMS is set to the chain of PARM_DECLs created. */
13019 grokparms (tree parmlist
, tree
*parms
)
13021 tree result
= NULL_TREE
;
13022 tree decls
= NULL_TREE
;
13026 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
13028 tree type
= NULL_TREE
;
13029 tree init
= TREE_PURPOSE (parm
);
13030 tree decl
= TREE_VALUE (parm
);
13032 if (parm
== void_list_node
)
13035 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
13038 type
= TREE_TYPE (decl
);
13039 if (VOID_TYPE_P (type
))
13041 if (same_type_p (type
, void_type_node
)
13043 && !DECL_NAME (decl
) && !result
13044 && TREE_CHAIN (parm
) == void_list_node
)
13045 /* DR 577: A parameter list consisting of a single
13046 unnamed parameter of non-dependent type 'void'. */
13048 else if (cv_qualified_p (type
))
13049 error_at (DECL_SOURCE_LOCATION (decl
),
13050 "invalid use of cv-qualified type %qT in "
13051 "parameter declaration", type
);
13053 error_at (DECL_SOURCE_LOCATION (decl
),
13054 "invalid use of type %<void%> in parameter "
13056 /* It's not a good idea to actually create parameters of
13057 type `void'; other parts of the compiler assume that a
13058 void type terminates the parameter list. */
13059 type
= error_mark_node
;
13060 TREE_TYPE (decl
) = error_mark_node
;
13063 if (type
!= error_mark_node
)
13065 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
13067 tree deptype
= type_is_deprecated (type
);
13069 cp_warn_deprecated_use (deptype
);
13072 /* Top-level qualifiers on the parameters are
13073 ignored for function types. */
13074 type
= cp_build_qualified_type (type
, 0);
13075 if (TREE_CODE (type
) == METHOD_TYPE
)
13077 error ("parameter %qD invalidly declared method type", decl
);
13078 type
= build_pointer_type (type
);
13079 TREE_TYPE (decl
) = type
;
13081 else if (abstract_virtuals_error (decl
, type
))
13082 any_error
= 1; /* Seems like a good idea. */
13083 else if (cxx_dialect
< cxx17
&& INDIRECT_TYPE_P (type
))
13085 /* Before C++17 DR 393:
13086 [dcl.fct]/6, parameter types cannot contain pointers
13087 (references) to arrays of unknown bound. */
13088 tree t
= TREE_TYPE (type
);
13089 int ptr
= TYPE_PTR_P (type
);
13093 if (TYPE_PTR_P (t
))
13095 else if (TREE_CODE (t
) != ARRAY_TYPE
)
13097 else if (!TYPE_DOMAIN (t
))
13101 if (TREE_CODE (t
) == ARRAY_TYPE
)
13102 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
13104 ? G_("parameter %qD includes pointer to array of "
13105 "unknown bound %qT")
13106 : G_("parameter %qD includes reference to array of "
13107 "unknown bound %qT"),
13113 else if (init
&& !processing_template_decl
)
13114 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
13117 DECL_CHAIN (decl
) = decls
;
13119 result
= tree_cons (init
, type
, result
);
13121 decls
= nreverse (decls
);
13122 result
= nreverse (result
);
13124 result
= chainon (result
, void_list_node
);
13131 /* D is a constructor or overloaded `operator='.
13133 Let T be the class in which D is declared. Then, this function
13136 -1 if D's is an ill-formed constructor or copy assignment operator
13137 whose first parameter is of type `T'.
13138 0 if D is not a copy constructor or copy assignment
13140 1 if D is a copy constructor or copy assignment operator whose
13141 first parameter is a reference to non-const qualified T.
13142 2 if D is a copy constructor or copy assignment operator whose
13143 first parameter is a reference to const qualified T.
13145 This function can be used as a predicate. Positive values indicate
13146 a copy constructor and nonzero values indicate a copy assignment
13150 copy_fn_p (const_tree d
)
13156 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
13158 if (TREE_CODE (d
) == TEMPLATE_DECL
13159 || (DECL_TEMPLATE_INFO (d
)
13160 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
13161 /* Instantiations of template member functions are never copy
13162 functions. Note that member functions of templated classes are
13163 represented as template functions internally, and we must
13164 accept those as copy functions. */
13167 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
13171 arg_type
= TREE_VALUE (args
);
13172 if (arg_type
== error_mark_node
)
13175 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
13177 /* Pass by value copy assignment operator. */
13180 else if (TYPE_REF_P (arg_type
)
13181 && !TYPE_REF_IS_RVALUE (arg_type
)
13182 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
13184 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
13190 args
= TREE_CHAIN (args
);
13192 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
13193 /* There are more non-optional args. */
13199 /* D is a constructor or overloaded `operator='.
13201 Let T be the class in which D is declared. Then, this function
13202 returns true when D is a move constructor or move assignment
13203 operator, false otherwise. */
13206 move_fn_p (const_tree d
)
13208 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
13210 if (cxx_dialect
== cxx98
)
13211 /* There are no move constructors if we are in C++98 mode. */
13214 if (TREE_CODE (d
) == TEMPLATE_DECL
13215 || (DECL_TEMPLATE_INFO (d
)
13216 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
13217 /* Instantiations of template member functions are never move
13218 functions. Note that member functions of templated classes are
13219 represented as template functions internally, and we must
13220 accept those as move functions. */
13223 return move_signature_fn_p (d
);
13226 /* D is a constructor or overloaded `operator='.
13228 Then, this function returns true when D has the same signature as a move
13229 constructor or move assignment operator (because either it is such a
13230 ctor/op= or it is a template specialization with the same signature),
13231 false otherwise. */
13234 move_signature_fn_p (const_tree d
)
13238 bool result
= false;
13240 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
13244 arg_type
= TREE_VALUE (args
);
13245 if (arg_type
== error_mark_node
)
13248 if (TYPE_REF_P (arg_type
)
13249 && TYPE_REF_IS_RVALUE (arg_type
)
13250 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
13254 args
= TREE_CHAIN (args
);
13256 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
13257 /* There are more non-optional args. */
13263 /* Remember any special properties of member function DECL. */
13266 grok_special_member_properties (tree decl
)
13270 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
13273 class_type
= DECL_CONTEXT (decl
);
13274 if (IDENTIFIER_CTOR_P (DECL_NAME (decl
)))
13276 int ctor
= copy_fn_p (decl
);
13278 if (!DECL_ARTIFICIAL (decl
))
13279 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
13285 A non-template constructor for class X is a copy
13286 constructor if its first parameter is of type X&, const
13287 X&, volatile X& or const volatile X&, and either there
13288 are no other parameters or else all other parameters have
13289 default arguments. */
13290 TYPE_HAS_COPY_CTOR (class_type
) = 1;
13291 if (user_provided_p (decl
))
13292 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
13294 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
13296 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
13297 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
13298 else if (move_fn_p (decl
) && user_provided_p (decl
))
13299 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
13300 else if (is_list_ctor (decl
))
13301 TYPE_HAS_LIST_CTOR (class_type
) = 1;
13303 if (DECL_DECLARED_CONSTEXPR_P (decl
)
13304 && !ctor
&& !move_fn_p (decl
))
13305 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
13307 else if (DECL_NAME (decl
) == assign_op_identifier
)
13311 A non-template assignment operator for class X is a copy
13312 assignment operator if its parameter is of type X, X&, const
13313 X&, volatile X& or const volatile X&. */
13315 int assop
= copy_fn_p (decl
);
13319 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
13320 if (user_provided_p (decl
))
13321 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
13323 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
13325 else if (move_fn_p (decl
) && user_provided_p (decl
))
13326 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
13328 else if (IDENTIFIER_CONV_OP_P (DECL_NAME (decl
)))
13329 TYPE_HAS_CONVERSION (class_type
) = true;
13331 /* Destructors are handled in check_methods. */
13334 /* Check a constructor DECL has the correct form. Complains
13335 if the class has a constructor of the form X(X). */
13338 grok_ctor_properties (const_tree ctype
, const_tree decl
)
13340 int ctor_parm
= copy_fn_p (decl
);
13346 A declaration of a constructor for a class X is ill-formed if
13347 its first parameter is of type (optionally cv-qualified) X
13348 and either there are no other parameters or else all other
13349 parameters have default arguments.
13351 We *don't* complain about member template instantiations that
13352 have this form, though; they can occur as we try to decide
13353 what constructor to use during overload resolution. Since
13354 overload resolution will never prefer such a constructor to
13355 the non-template copy constructor (which is either explicitly
13356 or implicitly defined), there's no need to worry about their
13357 existence. Theoretically, they should never even be
13358 instantiated, but that's hard to forestall. */
13359 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
13367 /* DECL is a declaration for an overloaded or conversion operator. If
13368 COMPLAIN is true, errors are issued for invalid declarations. */
13371 grok_op_properties (tree decl
, bool complain
)
13373 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
13374 bool methodp
= TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
;
13375 tree name
= DECL_NAME (decl
);
13376 location_t loc
= DECL_SOURCE_LOCATION (decl
);
13378 tree class_type
= DECL_CONTEXT (decl
);
13379 if (class_type
&& !CLASS_TYPE_P (class_type
))
13380 class_type
= NULL_TREE
;
13382 tree_code operator_code
;
13384 if (IDENTIFIER_CONV_OP_P (name
))
13386 /* Conversion operators are TYPE_EXPR for the purposes of this
13388 operator_code
= TYPE_EXPR
;
13389 op_flags
= OVL_OP_FLAG_UNARY
;
13393 const ovl_op_info_t
*ovl_op
= IDENTIFIER_OVL_OP_INFO (name
);
13395 operator_code
= ovl_op
->tree_code
;
13396 op_flags
= ovl_op
->flags
;
13397 gcc_checking_assert (operator_code
!= ERROR_MARK
);
13398 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op
->ovl_op_code
;
13401 if (op_flags
& OVL_OP_FLAG_ALLOC
)
13403 /* operator new and operator delete are quite special. */
13407 case OVL_OP_FLAG_ALLOC
:
13408 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
13411 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_DELETE
:
13412 TYPE_GETS_DELETE (class_type
) |= 1;
13415 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_VEC
:
13416 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
13419 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_DELETE
| OVL_OP_FLAG_VEC
:
13420 TYPE_GETS_DELETE (class_type
) |= 2;
13424 gcc_unreachable ();
13427 /* [basic.std.dynamic.allocation]/1:
13429 A program is ill-formed if an allocation function is declared
13430 in a namespace scope other than global scope or declared
13431 static in global scope.
13433 The same also holds true for deallocation functions. */
13434 if (DECL_NAMESPACE_SCOPE_P (decl
))
13436 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
13438 error_at (loc
, "%qD may not be declared within a namespace",
13443 if (!TREE_PUBLIC (decl
))
13445 error_at (loc
, "%qD may not be declared as static", decl
);
13450 if (op_flags
& OVL_OP_FLAG_DELETE
)
13451 coerce_delete_type (decl
, loc
);
13454 DECL_IS_OPERATOR_NEW (decl
) = 1;
13455 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
), loc
);
13461 /* An operator function must either be a non-static member function
13462 or have at least one parameter of a class, a reference to a class,
13463 an enumeration, or a reference to an enumeration. 13.4.0.6 */
13464 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
13466 if (operator_code
== TYPE_EXPR
13467 || operator_code
== CALL_EXPR
13468 || operator_code
== COMPONENT_REF
13469 || operator_code
== ARRAY_REF
13470 || operator_code
== NOP_EXPR
)
13472 error_at (loc
, "%qD must be a nonstatic member function", decl
);
13476 if (DECL_STATIC_FUNCTION_P (decl
))
13478 error_at (loc
, "%qD must be either a non-static member "
13479 "function or a non-member function", decl
);
13483 for (tree arg
= argtypes
; ; arg
= TREE_CHAIN (arg
))
13485 if (!arg
|| arg
== void_list_node
)
13488 error_at(loc
, "%qD must have an argument of class or "
13489 "enumerated type", decl
);
13493 tree type
= non_reference (TREE_VALUE (arg
));
13494 if (type
== error_mark_node
)
13497 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
13498 because these checks are performed even on template
13500 if (MAYBE_CLASS_TYPE_P (type
)
13501 || TREE_CODE (type
) == ENUMERAL_TYPE
)
13506 if (operator_code
== CALL_EXPR
)
13507 /* There are no further restrictions on the arguments to an overloaded
13511 if (operator_code
== COND_EXPR
)
13514 error_at (loc
, "ISO C++ prohibits overloading operator ?:");
13518 /* Count the number of arguments and check for ellipsis. */
13520 for (tree arg
= argtypes
; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
13525 error_at (loc
, "%qD must not have variable number of arguments",
13532 /* Verify correct number of arguments. */
13535 case OVL_OP_FLAG_AMBIARY
:
13538 /* We have a unary instance of an ambi-ary op. Remap to the
13540 unsigned alt
= ovl_op_alternate
[ovl_op_mapping
[operator_code
]];
13541 const ovl_op_info_t
*ovl_op
= &ovl_op_info
[false][alt
];
13542 gcc_checking_assert (ovl_op
->flags
== OVL_OP_FLAG_UNARY
);
13543 operator_code
= ovl_op
->tree_code
;
13544 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op
->ovl_op_code
;
13546 else if (arity
!= 2)
13548 /* This was an ambiguous operator but is invalid. */
13551 ? G_("%qD must have either zero or one argument")
13552 : G_("%qD must have either one or two arguments"), decl
);
13555 else if ((operator_code
== POSTINCREMENT_EXPR
13556 || operator_code
== POSTDECREMENT_EXPR
)
13557 && ! processing_template_decl
13558 /* x++ and x--'s second argument must be an int. */
13559 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)),
13560 integer_type_node
))
13564 ? G_("postfix %qD must have %<int%> as its argument")
13565 : G_("postfix %qD must have %<int%> as its second argument"),
13571 case OVL_OP_FLAG_UNARY
:
13576 ? G_("%qD must have no arguments")
13577 : G_("%qD must have exactly one argument"), decl
);
13582 case OVL_OP_FLAG_BINARY
:
13587 ? G_("%qD must have exactly one argument")
13588 : G_("%qD must have exactly two arguments"), decl
);
13594 gcc_unreachable ();
13597 /* There can be no default arguments. */
13598 for (tree arg
= argtypes
; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
13599 if (TREE_PURPOSE (arg
))
13601 TREE_PURPOSE (arg
) = NULL_TREE
;
13602 error_at (loc
, "%qD cannot have default arguments", decl
);
13606 /* At this point the declaration is well-formed. It may not be
13607 sensible though. */
13609 /* Check member function warnings only on the in-class declaration.
13610 There's no point warning on an out-of-class definition. */
13611 if (class_type
&& class_type
!= current_class_type
)
13614 /* Warn about conversion operators that will never be used. */
13615 if (IDENTIFIER_CONV_OP_P (name
)
13616 && ! DECL_TEMPLATE_INFO (decl
)
13617 && warn_class_conversion
)
13619 tree t
= TREE_TYPE (name
);
13620 int ref
= TYPE_REF_P (t
);
13623 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
13625 if (VOID_TYPE_P (t
))
13626 warning_at (loc
, OPT_Wclass_conversion
, "converting %qT to %<void%> "
13627 "will never use a type conversion operator", class_type
);
13628 else if (class_type
)
13630 if (same_type_ignoring_top_level_qualifiers_p (t
, class_type
))
13631 warning_at (loc
, OPT_Wclass_conversion
,
13633 ? G_("converting %qT to a reference to the same type "
13634 "will never use a type conversion operator")
13635 : G_("converting %qT to the same type "
13636 "will never use a type conversion operator"),
13638 /* Don't force t to be complete here. */
13639 else if (MAYBE_CLASS_TYPE_P (t
)
13640 && COMPLETE_TYPE_P (t
)
13641 && DERIVED_FROM_P (t
, class_type
))
13642 warning_at (loc
, OPT_Wclass_conversion
,
13644 ? G_("converting %qT to a reference to a base class "
13645 "%qT will never use a type conversion operator")
13646 : G_("converting %qT to a base class %qT "
13647 "will never use a type conversion operator"),
13655 /* Effective C++ rules below. */
13657 /* More Effective C++ rule 7. */
13658 if (operator_code
== TRUTH_ANDIF_EXPR
13659 || operator_code
== TRUTH_ORIF_EXPR
13660 || operator_code
== COMPOUND_EXPR
)
13661 warning_at (loc
, OPT_Weffc__
,
13662 "user-defined %qD always evaluates both arguments", decl
);
13664 /* More Effective C++ rule 6. */
13665 if (operator_code
== POSTINCREMENT_EXPR
13666 || operator_code
== POSTDECREMENT_EXPR
13667 || operator_code
== PREINCREMENT_EXPR
13668 || operator_code
== PREDECREMENT_EXPR
)
13670 tree arg
= TREE_VALUE (argtypes
);
13671 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
13672 if (methodp
|| TYPE_REF_P (arg
))
13673 arg
= TREE_TYPE (arg
);
13674 arg
= TYPE_MAIN_VARIANT (arg
);
13676 if (operator_code
== PREINCREMENT_EXPR
13677 || operator_code
== PREDECREMENT_EXPR
)
13679 if (!TYPE_REF_P (ret
)
13680 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)), arg
))
13681 warning_at (loc
, OPT_Weffc__
, "prefix %qD should return %qT", decl
,
13682 build_reference_type (arg
));
13686 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
13687 warning_at (loc
, OPT_Weffc__
,
13688 "postfix %qD should return %qT", decl
, arg
);
13692 /* Effective C++ rule 23. */
13693 if (!DECL_ASSIGNMENT_OPERATOR_P (decl
)
13694 && (operator_code
== PLUS_EXPR
13695 || operator_code
== MINUS_EXPR
13696 || operator_code
== TRUNC_DIV_EXPR
13697 || operator_code
== MULT_EXPR
13698 || operator_code
== TRUNC_MOD_EXPR
)
13699 && TYPE_REF_P (TREE_TYPE (TREE_TYPE (decl
))))
13700 warning_at (loc
, OPT_Weffc__
, "%qD should return by value", decl
);
13705 /* Return a string giving the keyword associate with CODE. */
13707 static const char *
13708 tag_name (enum tag_types code
)
13720 case typename_type
:
13723 gcc_unreachable ();
13727 /* Name lookup in an elaborated-type-specifier (after the keyword
13728 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
13729 elaborated-type-specifier is invalid, issue a diagnostic and return
13730 error_mark_node; otherwise, return the *_TYPE to which it referred.
13731 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
13734 check_elaborated_type_specifier (enum tag_types tag_code
,
13736 bool allow_template_p
)
13742 struct S { struct S *p; };
13744 name lookup will find the TYPE_DECL for the implicit "S::S"
13745 typedef. Adjust for that here. */
13746 if (DECL_SELF_REFERENCE_P (decl
))
13747 decl
= TYPE_NAME (TREE_TYPE (decl
));
13749 type
= TREE_TYPE (decl
);
13751 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
13752 is false for this case as well. */
13753 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
13755 error ("using template type parameter %qT after %qs",
13756 type
, tag_name (tag_code
));
13757 return error_mark_node
;
13759 /* Accept template template parameters. */
13760 else if (allow_template_p
13761 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
13762 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
13766 If the identifier resolves to a typedef-name or the
13767 simple-template-id resolves to an alias template
13768 specialization, the elaborated-type-specifier is ill-formed.
13770 In other words, the only legitimate declaration to use in the
13771 elaborated type specifier is the implicit typedef created when
13772 the type is declared. */
13773 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
13774 && !DECL_SELF_REFERENCE_P (decl
)
13775 && tag_code
!= typename_type
)
13777 if (alias_template_specialization_p (type
))
13778 error ("using alias template specialization %qT after %qs",
13779 type
, tag_name (tag_code
));
13781 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
13782 inform (DECL_SOURCE_LOCATION (decl
),
13783 "%qD has a previous declaration here", decl
);
13784 return error_mark_node
;
13786 else if (TREE_CODE (type
) != RECORD_TYPE
13787 && TREE_CODE (type
) != UNION_TYPE
13788 && tag_code
!= enum_type
13789 && tag_code
!= typename_type
)
13791 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
13792 inform (location_of (type
), "%qT has a previous declaration here", type
);
13793 return error_mark_node
;
13795 else if (TREE_CODE (type
) != ENUMERAL_TYPE
13796 && tag_code
== enum_type
)
13798 error ("%qT referred to as enum", type
);
13799 inform (location_of (type
), "%qT has a previous declaration here", type
);
13800 return error_mark_node
;
13802 else if (!allow_template_p
13803 && TREE_CODE (type
) == RECORD_TYPE
13804 && CLASSTYPE_IS_TEMPLATE (type
))
13806 /* If a class template appears as elaborated type specifier
13807 without a template header such as:
13809 template <class T> class C {};
13810 void f(class C); // No template header here
13812 then the required template argument is missing. */
13813 error ("template argument required for %<%s %T%>",
13814 tag_name (tag_code
),
13815 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
13816 return error_mark_node
;
13822 /* Lookup NAME in elaborate type specifier in scope according to
13823 SCOPE and issue diagnostics if necessary.
13824 Return *_TYPE node upon success, NULL_TREE when the NAME is not
13825 found, and ERROR_MARK_NODE for type error. */
13828 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
13829 tag_scope scope
, bool template_header_p
)
13833 if (scope
== ts_global
)
13835 /* First try ordinary name lookup, ignoring hidden class name
13836 injected via friend declaration. */
13837 decl
= lookup_name_prefer_type (name
, 2);
13838 decl
= strip_using_decl (decl
);
13839 /* If that fails, the name will be placed in the smallest
13840 non-class, non-function-prototype scope according to 3.3.1/5.
13841 We may already have a hidden name declared as friend in this
13842 scope. So lookup again but not ignoring hidden names.
13843 If we find one, that name will be made visible rather than
13844 creating a new tag. */
13846 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
13849 decl
= lookup_type_scope (name
, scope
);
13852 && (DECL_CLASS_TEMPLATE_P (decl
)
13853 /* If scope is ts_current we're defining a class, so ignore a
13854 template template parameter. */
13855 || (scope
!= ts_current
13856 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
13857 decl
= DECL_TEMPLATE_RESULT (decl
);
13859 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
13861 /* Look for invalid nested type:
13865 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
13867 error ("%qD has the same name as the class in which it is "
13870 return error_mark_node
;
13873 /* Two cases we need to consider when deciding if a class
13874 template is allowed as an elaborated type specifier:
13875 1. It is a self reference to its own class.
13876 2. It comes with a template header.
13880 template <class T> class C {
13881 class C *c1; // DECL_SELF_REFERENCE_P is true
13884 template <class U> class C; // template_header_p is true
13885 template <class T> class C<T>::D {
13886 class C *c2; // DECL_SELF_REFERENCE_P is true
13889 t
= check_elaborated_type_specifier (tag_code
,
13892 | DECL_SELF_REFERENCE_P (decl
));
13893 if (template_header_p
&& t
&& CLASS_TYPE_P (t
)
13894 && (!CLASSTYPE_TEMPLATE_INFO (t
)
13895 || (!PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))))
13897 error ("%qT is not a template", t
);
13898 inform (location_of (t
), "previous declaration here");
13899 if (TYPE_CLASS_SCOPE_P (t
)
13900 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (t
)))
13901 inform (input_location
,
13902 "perhaps you want to explicitly add %<%T::%>",
13904 t
= error_mark_node
;
13909 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
13911 error ("reference to %qD is ambiguous", name
);
13912 print_candidates (decl
);
13913 return error_mark_node
;
13919 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
13920 Define the tag as a forward-reference if it is not defined.
13922 If a declaration is given, process it here, and report an error if
13923 multiple declarations are not identical.
13925 SCOPE is TS_CURRENT when this is also a definition. Only look in
13926 the current frame for the name (since C++ allows new names in any
13927 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
13928 declaration. Only look beginning from the current scope outward up
13929 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
13931 TEMPLATE_HEADER_P is true when this declaration is preceded by
13932 a set of template parameters. */
13935 xref_tag_1 (enum tag_types tag_code
, tree name
,
13936 tag_scope scope
, bool template_header_p
)
13938 enum tree_code code
;
13939 tree context
= NULL_TREE
;
13941 gcc_assert (identifier_p (name
));
13947 code
= RECORD_TYPE
;
13953 code
= ENUMERAL_TYPE
;
13956 gcc_unreachable ();
13959 /* In case of anonymous name, xref_tag is only called to
13960 make type node and push name. Name lookup is not required. */
13961 tree t
= NULL_TREE
;
13962 if (scope
!= ts_lambda
&& !anon_aggrname_p (name
))
13963 t
= lookup_and_check_tag (tag_code
, name
, scope
, template_header_p
);
13965 if (t
== error_mark_node
)
13966 return error_mark_node
;
13968 if (scope
!= ts_current
&& t
&& current_class_type
13969 && template_class_depth (current_class_type
)
13970 && template_header_p
)
13972 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
13975 /* Since SCOPE is not TS_CURRENT, we are not looking at a
13976 definition of this tag. Since, in addition, we are currently
13977 processing a (member) template declaration of a template
13978 class, we must be very careful; consider:
13980 template <class X> struct S1
13982 template <class U> struct S2
13984 template <class V> friend struct S1;
13987 Here, the S2::S1 declaration should not be confused with the
13988 outer declaration. In particular, the inner version should
13989 have a template parameter of level 2, not level 1.
13991 On the other hand, when presented with:
13993 template <class T> struct S1
13995 template <class U> struct S2 {};
13996 template <class U> friend struct S2;
13999 the friend must find S1::S2 eventually. We accomplish this
14000 by making sure that the new type we create to represent this
14001 declaration has the right TYPE_CONTEXT. */
14002 context
= TYPE_CONTEXT (t
);
14008 /* If no such tag is yet defined, create a forward-reference node
14009 and record it as the "definition".
14010 When a real declaration of this type is found,
14011 the forward-reference will be altered into a real type. */
14012 if (code
== ENUMERAL_TYPE
)
14014 error ("use of enum %q#D without previous declaration", name
);
14015 return error_mark_node
;
14019 t
= make_class_type (code
);
14020 TYPE_CONTEXT (t
) = context
;
14021 if (scope
== ts_lambda
)
14023 /* Mark it as a lambda type. */
14024 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
14025 /* And push it into current scope. */
14026 scope
= ts_current
;
14028 t
= pushtag (name
, t
, scope
);
14033 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
14035 /* Check that we aren't trying to overload a class with different
14037 tree constr
= NULL_TREE
;
14038 if (current_template_parms
)
14040 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
14041 constr
= build_constraints (reqs
, NULL_TREE
);
14043 if (!redeclare_class_template (t
, current_template_parms
, constr
))
14044 return error_mark_node
;
14046 else if (!processing_template_decl
14047 && CLASS_TYPE_P (t
)
14048 && CLASSTYPE_IS_TEMPLATE (t
))
14050 error ("redeclaration of %qT as a non-template", t
);
14051 inform (location_of (t
), "previous declaration %qD", t
);
14052 return error_mark_node
;
14055 if (scope
!= ts_within_enclosing_non_class
&& TYPE_HIDDEN_P (t
))
14057 /* This is no longer an invisible friend. Make it
14059 tree decl
= TYPE_NAME (t
);
14061 DECL_ANTICIPATED (decl
) = false;
14062 DECL_FRIEND_P (decl
) = false;
14064 if (TYPE_TEMPLATE_INFO (t
))
14066 tree tmpl
= TYPE_TI_TEMPLATE (t
);
14067 DECL_ANTICIPATED (tmpl
) = false;
14068 DECL_FRIEND_P (tmpl
) = false;
14076 /* Wrapper for xref_tag_1. */
14079 xref_tag (enum tag_types tag_code
, tree name
,
14080 tag_scope scope
, bool template_header_p
)
14084 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
14085 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
14086 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
14092 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
14094 enum tag_types tag_kind
;
14096 if (TREE_CODE (old
) == RECORD_TYPE
)
14097 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
14099 tag_kind
= union_type
;
14101 if (id
== NULL_TREE
)
14102 id
= TYPE_IDENTIFIER (old
);
14104 return xref_tag (tag_kind
, id
, scope
, false);
14107 /* Create the binfo hierarchy for REF with (possibly NULL) base list
14108 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
14109 access_* node, and the TREE_VALUE is the type of the base-class.
14110 Non-NULL TREE_TYPE indicates virtual inheritance. */
14113 xref_basetypes (tree ref
, tree base_list
)
14116 tree binfo
, base_binfo
;
14117 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
14118 unsigned max_bases
= 0; /* Maximum direct bases. */
14119 unsigned max_dvbases
= 0; /* Maximum direct virtual bases. */
14121 tree default_access
;
14122 tree igo_prev
; /* Track Inheritance Graph Order. */
14124 if (ref
== error_mark_node
)
14127 /* The base of a derived class is private by default, all others are
14129 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
14130 && CLASSTYPE_DECLARED_CLASS (ref
)
14131 ? access_private_node
: access_public_node
);
14133 /* First, make sure that any templates in base-classes are
14134 instantiated. This ensures that if we call ourselves recursively
14135 we do not get confused about which classes are marked and which
14137 basep
= &base_list
;
14140 tree basetype
= TREE_VALUE (*basep
);
14142 /* The dependent_type_p call below should really be dependent_scope_p
14143 so that we give a hard error about using an incomplete type as a
14144 base, but we allow it with a pedwarn for backward
14146 if (processing_template_decl
14147 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
14148 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
14149 if (!dependent_type_p (basetype
)
14150 && !complete_type_or_else (basetype
, NULL
))
14151 /* An incomplete type. Remove it from the list. */
14152 *basep
= TREE_CHAIN (*basep
);
14156 if (TREE_TYPE (*basep
))
14158 if (CLASS_TYPE_P (basetype
))
14159 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
14160 basep
= &TREE_CHAIN (*basep
);
14163 max_vbases
+= max_dvbases
;
14165 TYPE_MARKED_P (ref
) = 1;
14167 /* The binfo slot should be empty, unless this is an (ill-formed)
14169 gcc_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
));
14171 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
14173 binfo
= make_tree_binfo (max_bases
);
14175 TYPE_BINFO (ref
) = binfo
;
14176 BINFO_OFFSET (binfo
) = size_zero_node
;
14177 BINFO_TYPE (binfo
) = ref
;
14179 /* Apply base-class info set up to the variants of this type. */
14180 fixup_type_variants (ref
);
14184 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
14185 /* A C++98 POD cannot have base classes. */
14186 CLASSTYPE_NON_LAYOUT_POD_P (ref
) = true;
14188 if (TREE_CODE (ref
) == UNION_TYPE
)
14190 error ("derived union %qT invalid", ref
);
14196 warning (OPT_Wmultiple_inheritance
,
14197 "%qT defined with multiple direct bases", ref
);
14201 /* An aggregate can't have virtual base classes. */
14202 CLASSTYPE_NON_AGGREGATE (ref
) = true;
14204 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
14207 warning (OPT_Wvirtual_inheritance
,
14208 "%qT defined with direct virtual base", ref
);
14211 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
14213 tree access
= TREE_PURPOSE (base_list
);
14214 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
14215 tree basetype
= TREE_VALUE (base_list
);
14217 if (access
== access_default_node
)
14218 access
= default_access
;
14220 /* Before C++17, an aggregate cannot have base classes. In C++17, an
14221 aggregate can't have virtual, private, or protected base classes. */
14222 if (cxx_dialect
< cxx17
14223 || access
!= access_public_node
14225 CLASSTYPE_NON_AGGREGATE (ref
) = true;
14227 if (PACK_EXPANSION_P (basetype
))
14228 basetype
= PACK_EXPANSION_PATTERN (basetype
);
14229 if (TREE_CODE (basetype
) == TYPE_DECL
)
14230 basetype
= TREE_TYPE (basetype
);
14231 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
14233 error ("base type %qT fails to be a struct or class type",
14238 base_binfo
= NULL_TREE
;
14239 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
14241 base_binfo
= TYPE_BINFO (basetype
);
14242 /* The original basetype could have been a typedef'd type. */
14243 basetype
= BINFO_TYPE (base_binfo
);
14245 /* Inherit flags from the base. */
14246 TYPE_HAS_NEW_OPERATOR (ref
)
14247 |= TYPE_HAS_NEW_OPERATOR (basetype
);
14248 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
14249 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
14250 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
14251 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
14252 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
14253 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
14254 CLASSTYPE_REPEATED_BASE_P (ref
)
14255 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
14258 /* We must do this test after we've seen through a typedef
14260 if (TYPE_MARKED_P (basetype
))
14262 if (basetype
== ref
)
14263 error ("recursive type %qT undefined", basetype
);
14265 error ("duplicate base type %qT invalid", basetype
);
14269 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
14270 /* Regenerate the pack expansion for the bases. */
14271 basetype
= make_pack_expansion (basetype
);
14273 TYPE_MARKED_P (basetype
) = 1;
14275 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
14276 &igo_prev
, via_virtual
);
14277 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
14278 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
14280 BINFO_BASE_APPEND (binfo
, base_binfo
);
14281 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
14285 /* Update max_vbases to reflect the reality that we are dropping
14286 this base: if it reaches zero we want to undo the vec_alloc
14287 above to avoid inconsistencies during error-recovery: eg, in
14288 build_special_member_call, CLASSTYPE_VBASECLASSES non null
14289 and vtt null (c++/27952). */
14292 if (CLASS_TYPE_P (basetype
))
14294 -= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
14297 if (CLASSTYPE_VBASECLASSES (ref
)
14298 && max_vbases
== 0)
14299 vec_free (CLASSTYPE_VBASECLASSES (ref
));
14301 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
14302 /* If we didn't get max_vbases vbases, we must have shared at
14303 least one of them, and are therefore diamond shaped. */
14304 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
14306 /* Unmark all the types. */
14307 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
14308 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
14309 TYPE_MARKED_P (ref
) = 0;
14311 /* Now see if we have a repeated base type. */
14312 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
14314 for (base_binfo
= binfo
; base_binfo
;
14315 base_binfo
= TREE_CHAIN (base_binfo
))
14317 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
14319 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
14322 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
14324 for (base_binfo
= binfo
; base_binfo
;
14325 base_binfo
= TREE_CHAIN (base_binfo
))
14326 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
14327 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
14334 /* Copies the enum-related properties from type SRC to type DST.
14335 Used with the underlying type of an enum and the enum itself. */
14337 copy_type_enum (tree dst
, tree src
)
14340 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
14342 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
14343 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
14344 TYPE_SIZE (t
) = TYPE_SIZE (src
);
14345 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
14346 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
14347 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
14348 unsigned valign
= TYPE_ALIGN (src
);
14349 if (TYPE_USER_ALIGN (t
))
14350 valign
= MAX (valign
, TYPE_ALIGN (t
));
14352 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
14353 SET_TYPE_ALIGN (t
, valign
);
14354 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
14358 /* Begin compiling the definition of an enumeration type.
14361 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
14363 UNDERLYING_TYPE is the type that will be used as the storage for
14364 the enumeration type. This should be NULL_TREE if no storage type
14367 ATTRIBUTES are any attributes specified after the enum-key.
14369 SCOPED_ENUM_P is true if this is a scoped enumeration type.
14371 if IS_NEW is not NULL, gets TRUE iff a new type is created.
14373 Returns the type object, as yet incomplete.
14374 Also records info about it so that build_enumerator
14375 may be used to declare the individual values as they are read. */
14378 start_enum (tree name
, tree enumtype
, tree underlying_type
,
14379 tree attributes
, bool scoped_enum_p
, bool *is_new
)
14381 tree prevtype
= NULL_TREE
;
14382 gcc_assert (identifier_p (name
));
14386 /* [C++0x dcl.enum]p5:
14388 If not explicitly specified, the underlying type of a scoped
14389 enumeration type is int. */
14390 if (!underlying_type
&& scoped_enum_p
)
14391 underlying_type
= integer_type_node
;
14393 if (underlying_type
)
14394 underlying_type
= cv_unqualified (underlying_type
);
14396 /* If this is the real definition for a previous forward reference,
14397 fill in the contents in the same object that used to be the
14398 forward reference. */
14400 enumtype
= lookup_and_check_tag (enum_type
, name
,
14401 /*tag_scope=*/ts_current
,
14402 /*template_header_p=*/false);
14404 /* In case of a template_decl, the only check that should be deferred
14405 to instantiation time is the comparison of underlying types. */
14406 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
14408 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
14410 error_at (input_location
, "scoped/unscoped mismatch "
14411 "in enum %q#T", enumtype
);
14412 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
14413 "previous definition here");
14414 enumtype
= error_mark_node
;
14416 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
14418 error_at (input_location
, "underlying type mismatch "
14419 "in enum %q#T", enumtype
);
14420 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
14421 "previous definition here");
14422 enumtype
= error_mark_node
;
14424 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
14425 && !same_type_p (underlying_type
,
14426 ENUM_UNDERLYING_TYPE (enumtype
)))
14428 error_at (input_location
, "different underlying type "
14429 "in enum %q#T", enumtype
);
14430 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
14431 "previous definition here");
14432 underlying_type
= NULL_TREE
;
14436 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
14437 || processing_template_decl
)
14439 /* In case of error, make a dummy enum to allow parsing to
14441 if (enumtype
== error_mark_node
)
14443 name
= make_anon_name ();
14444 enumtype
= NULL_TREE
;
14447 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
14448 of an opaque enum, or an opaque enum of an already defined
14449 enumeration (C++11).
14450 In any other case, it'll be NULL_TREE. */
14456 prevtype
= enumtype
;
14458 /* Do not push the decl more than once. */
14460 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
14462 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
14463 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
14465 /* std::byte aliases anything. */
14466 if (enumtype
!= error_mark_node
14467 && TYPE_CONTEXT (enumtype
) == std_node
14468 && !strcmp ("byte", TYPE_NAME_STRING (enumtype
)))
14469 TYPE_ALIAS_SET (enumtype
) = 0;
14472 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
14475 if (enumtype
== error_mark_node
)
14476 return error_mark_node
;
14478 /* The enum is considered opaque until the opening '{' of the
14479 enumerator list. */
14480 SET_OPAQUE_ENUM_P (enumtype
, true);
14481 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
14484 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
14486 cplus_decl_attributes (&enumtype
, attributes
, (int)ATTR_FLAG_TYPE_IN_PLACE
);
14488 if (underlying_type
)
14490 if (ENUM_UNDERLYING_TYPE (enumtype
))
14491 /* We already checked that it matches, don't change it to a different
14492 typedef variant. */;
14493 else if (CP_INTEGRAL_TYPE_P (underlying_type
))
14495 copy_type_enum (enumtype
, underlying_type
);
14496 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
14498 else if (dependent_type_p (underlying_type
))
14499 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
14501 error ("underlying type %qT of %qT must be an integral type",
14502 underlying_type
, enumtype
);
14505 /* If into a template class, the returned enum is always the first
14506 declaration (opaque or not) seen. This way all the references to
14507 this type will be to the same declaration. The following ones are used
14508 only to check for definition errors. */
14509 if (prevtype
&& processing_template_decl
)
14515 /* After processing and defining all the values of an enumeration type,
14516 install their decls in the enumeration type.
14517 ENUMTYPE is the type object. */
14520 finish_enum_value_list (tree enumtype
)
14523 tree underlying_type
;
14526 tree minnode
, maxnode
;
14529 bool fixed_underlying_type_p
14530 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
14532 /* We built up the VALUES in reverse order. */
14533 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
14535 /* For an enum defined in a template, just set the type of the values;
14536 all further processing is postponed until the template is
14537 instantiated. We need to set the type so that tsubst of a CONST_DECL
14539 if (processing_template_decl
)
14541 for (values
= TYPE_VALUES (enumtype
);
14543 values
= TREE_CHAIN (values
))
14544 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
14548 /* Determine the minimum and maximum values of the enumerators. */
14549 if (TYPE_VALUES (enumtype
))
14551 minnode
= maxnode
= NULL_TREE
;
14553 for (values
= TYPE_VALUES (enumtype
);
14555 values
= TREE_CHAIN (values
))
14557 decl
= TREE_VALUE (values
);
14559 /* [dcl.enum]: Following the closing brace of an enum-specifier,
14560 each enumerator has the type of its enumeration. Prior to the
14561 closing brace, the type of each enumerator is the type of its
14562 initializing value. */
14563 TREE_TYPE (decl
) = enumtype
;
14565 /* Update the minimum and maximum values, if appropriate. */
14566 value
= DECL_INITIAL (decl
);
14567 if (value
== error_mark_node
)
14568 value
= integer_zero_node
;
14569 /* Figure out what the minimum and maximum values of the
14570 enumerators are. */
14572 minnode
= maxnode
= value
;
14573 else if (tree_int_cst_lt (maxnode
, value
))
14575 else if (tree_int_cst_lt (value
, minnode
))
14582 If the enumerator-list is empty, the underlying type is as if
14583 the enumeration had a single enumerator with value 0. */
14584 minnode
= maxnode
= integer_zero_node
;
14586 if (!fixed_underlying_type_p
)
14588 /* Compute the number of bits require to represent all values of the
14589 enumeration. We must do this before the type of MINNODE and
14590 MAXNODE are transformed, since tree_int_cst_min_precision relies
14591 on the TREE_TYPE of the value it is passed. */
14592 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
14593 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
14594 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
14595 int precision
= MAX (lowprec
, highprec
);
14597 bool use_short_enum
;
14599 /* Determine the underlying type of the enumeration.
14603 The underlying type of an enumeration is an integral type that
14604 can represent all the enumerator values defined in the
14605 enumeration. It is implementation-defined which integral type is
14606 used as the underlying type for an enumeration except that the
14607 underlying type shall not be larger than int unless the value of
14608 an enumerator cannot fit in an int or unsigned int.
14610 We use "int" or an "unsigned int" as the underlying type, even if
14611 a smaller integral type would work, unless the user has
14612 explicitly requested that we use the smallest possible type. The
14613 user can request that for all enumerations with a command line
14614 flag, or for just one enumeration with an attribute. */
14616 use_short_enum
= flag_short_enums
14617 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
14619 /* If the precision of the type was specified with an attribute and it
14620 was too small, give an error. Otherwise, use it. */
14621 if (TYPE_PRECISION (enumtype
))
14623 if (precision
> TYPE_PRECISION (enumtype
))
14624 error ("specified mode too small for enumeral values");
14627 use_short_enum
= true;
14628 precision
= TYPE_PRECISION (enumtype
);
14632 for (itk
= (use_short_enum
? itk_char
: itk_int
);
14636 underlying_type
= integer_types
[itk
];
14637 if (underlying_type
!= NULL_TREE
14638 && TYPE_PRECISION (underlying_type
) >= precision
14639 && TYPE_SIGN (underlying_type
) == sgn
)
14642 if (itk
== itk_none
)
14646 IF no integral type can represent all the enumerator values, the
14647 enumeration is ill-formed. */
14648 error ("no integral type can represent all of the enumerator values "
14649 "for %qT", enumtype
);
14650 precision
= TYPE_PRECISION (long_long_integer_type_node
);
14651 underlying_type
= integer_types
[itk_unsigned_long_long
];
14656 The value of sizeof() applied to an enumeration type, an object
14657 of an enumeration type, or an enumerator, is the value of sizeof()
14658 applied to the underlying type. */
14659 copy_type_enum (enumtype
, underlying_type
);
14661 /* Compute the minimum and maximum values for the type.
14665 For an enumeration where emin is the smallest enumerator and emax
14666 is the largest, the values of the enumeration are the values of the
14667 underlying type in the range bmin to bmax, where bmin and bmax are,
14668 respectively, the smallest and largest values of the smallest bit-
14669 field that can store emin and emax. */
14671 /* The middle-end currently assumes that types with TYPE_PRECISION
14672 narrower than their underlying type are suitably zero or sign
14673 extended to fill their mode. Similarly, it assumes that the front
14674 end assures that a value of a particular type must be within
14675 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
14677 We used to set these fields based on bmin and bmax, but that led
14678 to invalid assumptions like optimizing away bounds checking. So
14679 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
14680 TYPE_MAX_VALUE to the values for the mode above and only restrict
14681 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
14682 ENUM_UNDERLYING_TYPE (enumtype
)
14683 = build_distinct_type_copy (underlying_type
);
14684 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
14685 set_min_and_max_values_for_integral_type
14686 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
14688 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
14689 if (flag_strict_enums
)
14690 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
14693 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
14695 /* Convert each of the enumerators to the type of the underlying
14696 type of the enumeration. */
14697 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
14699 location_t saved_location
;
14701 decl
= TREE_VALUE (values
);
14702 saved_location
= input_location
;
14703 input_location
= DECL_SOURCE_LOCATION (decl
);
14704 if (fixed_underlying_type_p
)
14705 /* If the enumeration type has a fixed underlying type, we
14706 already checked all of the enumerator values. */
14707 value
= DECL_INITIAL (decl
);
14709 value
= perform_implicit_conversion (underlying_type
,
14710 DECL_INITIAL (decl
),
14711 tf_warning_or_error
);
14712 input_location
= saved_location
;
14714 /* Do not clobber shared ints. */
14715 if (value
!= error_mark_node
)
14717 value
= copy_node (value
);
14719 TREE_TYPE (value
) = enumtype
;
14721 DECL_INITIAL (decl
) = value
;
14724 /* Fix up all variant types of this enum type. */
14725 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
14726 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
14728 if (at_class_scope_p ()
14729 && COMPLETE_TYPE_P (current_class_type
)
14730 && UNSCOPED_ENUM_P (enumtype
))
14732 insert_late_enum_def_bindings (current_class_type
, enumtype
);
14733 /* TYPE_FIELDS needs fixup. */
14734 fixup_type_variants (current_class_type
);
14737 /* Finish debugging output for this type. */
14738 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
14740 /* Each enumerator now has the type of its enumeration. Clear the cache
14741 so that this change in types doesn't confuse us later on. */
14742 clear_cv_and_fold_caches ();
14745 /* Finishes the enum type. This is called only the first time an
14746 enumeration is seen, be it opaque or odinary.
14747 ENUMTYPE is the type object. */
14750 finish_enum (tree enumtype
)
14752 if (processing_template_decl
)
14754 if (at_function_scope_p ())
14755 add_stmt (build_min (TAG_DEFN
, enumtype
));
14759 /* If this is a forward declaration, there should not be any variants,
14760 though we can get a variant in the middle of an enum-specifier with
14761 wacky code like 'enum E { e = sizeof(const E*) };' */
14762 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
14763 && (TYPE_VALUES (enumtype
)
14764 || !TYPE_NEXT_VARIANT (enumtype
)));
14767 /* Build and install a CONST_DECL for an enumeration constant of the
14768 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
14769 Apply ATTRIBUTES if available. LOC is the location of NAME.
14770 Assignment of sequential values by default is handled here. */
14773 build_enumerator (tree name
, tree value
, tree enumtype
, tree attributes
,
14780 /* scalar_constant_value will pull out this expression, so make sure
14781 it's folded as appropriate. */
14782 if (processing_template_decl
)
14783 value
= fold_non_dependent_expr (value
);
14785 /* If the VALUE was erroneous, pretend it wasn't there; that will
14786 result in the enum being assigned the next value in sequence. */
14787 if (value
== error_mark_node
)
14790 /* Remove no-op casts from the value. */
14792 STRIP_TYPE_NOPS (value
);
14794 if (! processing_template_decl
)
14796 /* Validate and default VALUE. */
14797 if (value
!= NULL_TREE
)
14799 if (!ENUM_UNDERLYING_TYPE (enumtype
))
14801 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
14806 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14807 (TREE_TYPE (value
)))
14808 value
= perform_implicit_conversion_flags
14809 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
14810 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
14812 if (value
== error_mark_node
)
14815 if (value
!= NULL_TREE
)
14817 if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14818 (TREE_TYPE (value
)))
14820 error ("enumerator value for %qD must have integral or "
14821 "unscoped enumeration type", name
);
14826 value
= cxx_constant_value (value
);
14828 if (TREE_CODE (value
) != INTEGER_CST
)
14830 error ("enumerator value for %qD is not an integer "
14838 /* Default based on previous value. */
14839 if (value
== NULL_TREE
)
14841 if (TYPE_VALUES (enumtype
))
14845 /* C++03 7.2/4: If no initializer is specified for the first
14846 enumerator, the type is an unspecified integral
14847 type. Otherwise the type is the same as the type of the
14848 initializing value of the preceding enumerator unless the
14849 incremented value is not representable in that type, in
14850 which case the type is an unspecified integral type
14851 sufficient to contain the incremented value. */
14852 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
14853 if (error_operand_p (prev_value
))
14854 value
= error_mark_node
;
14857 wi::overflow_type overflowed
;
14858 tree type
= TREE_TYPE (prev_value
);
14859 signop sgn
= TYPE_SIGN (type
);
14860 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
14864 bool pos
= !wi::neg_p (wi
, sgn
);
14865 if (!wi::fits_to_tree_p (wi
, type
))
14868 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
14870 type
= integer_types
[itk
];
14871 if (type
!= NULL_TREE
14872 && (pos
|| !TYPE_UNSIGNED (type
))
14873 && wi::fits_to_tree_p (wi
, type
))
14876 if (type
&& cxx_dialect
< cxx11
14877 && itk
> itk_unsigned_long
)
14878 pedwarn (input_location
, OPT_Wlong_long
,
14880 incremented enumerator value is too large for %<unsigned long%>") : G_("\
14881 incremented enumerator value is too large for %<long%>"));
14883 if (type
== NULL_TREE
)
14884 overflowed
= wi::OVF_UNKNOWN
;
14886 value
= wide_int_to_tree (type
, wi
);
14891 error ("overflow in enumeration values at %qD", name
);
14892 value
= error_mark_node
;
14897 value
= integer_zero_node
;
14900 /* Remove no-op casts from the value. */
14901 STRIP_TYPE_NOPS (value
);
14903 /* If the underlying type of the enum is fixed, check whether
14904 the enumerator values fits in the underlying type. If it
14905 does not fit, the program is ill-formed [C++0x dcl.enum]. */
14906 if (ENUM_UNDERLYING_TYPE (enumtype
)
14908 && TREE_CODE (value
) == INTEGER_CST
)
14910 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
14911 error ("enumerator value %qE is outside the range of underlying "
14912 "type %qT", value
, ENUM_UNDERLYING_TYPE (enumtype
));
14914 /* Convert the value to the appropriate type. */
14915 value
= fold_convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
14919 /* C++ associates enums with global, function, or class declarations. */
14920 context
= current_scope ();
14922 /* Build the actual enumeration constant. Note that the enumeration
14923 constants have the underlying type of the enum (if it is fixed)
14924 or the type of their initializer (if the underlying type of the
14925 enum is not fixed):
14929 If the underlying type is fixed, the type of each enumerator
14930 prior to the closing brace is the underlying type; if the
14931 initializing value of an enumerator cannot be represented by
14932 the underlying type, the program is ill-formed. If the
14933 underlying type is not fixed, the type of each enumerator is
14934 the type of its initializing value.
14936 If the underlying type is not fixed, it will be computed by
14937 finish_enum and we will reset the type of this enumerator. Of
14938 course, if we're processing a template, there may be no value. */
14939 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
14941 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
14943 DECL_CONTEXT (decl
) = enumtype
;
14944 TREE_CONSTANT (decl
) = 1;
14945 TREE_READONLY (decl
) = 1;
14946 DECL_INITIAL (decl
) = value
;
14949 cplus_decl_attributes (&decl
, attributes
, 0);
14951 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
14953 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
14954 on the TYPE_FIELDS list for `S'. (That's so that you can say
14955 things like `S::i' later.) */
14957 /* The enumerator may be getting declared outside of its enclosing
14960 class S { public: enum E : int; }; enum S::E : int { i = 7; };
14962 For which case we need to make sure that the access of `S::i'
14963 matches the access of `S::E'. */
14964 tree saved_cas
= current_access_specifier
;
14965 if (TREE_PRIVATE (TYPE_NAME (enumtype
)))
14966 current_access_specifier
= access_private_node
;
14967 else if (TREE_PROTECTED (TYPE_NAME (enumtype
)))
14968 current_access_specifier
= access_protected_node
;
14970 current_access_specifier
= access_public_node
;
14972 finish_member_declaration (decl
);
14974 current_access_specifier
= saved_cas
;
14979 /* Add this enumeration constant to the list for this type. */
14980 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
14983 /* Look for an enumerator with the given NAME within the enumeration
14984 type ENUMTYPE. This routine is used primarily for qualified name
14985 lookup into an enumerator in C++0x, e.g.,
14987 enum class Color { Red, Green, Blue };
14989 Color color = Color::Red;
14991 Returns the value corresponding to the enumerator, or
14992 NULL_TREE if no such enumerator was found. */
14994 lookup_enumerator (tree enumtype
, tree name
)
14997 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
14999 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
15000 return e
? TREE_VALUE (e
) : NULL_TREE
;
15004 /* We're defining DECL. Make sure that its type is OK. */
15007 check_function_type (tree decl
, tree current_function_parms
)
15009 tree fntype
= TREE_TYPE (decl
);
15010 tree return_type
= complete_type (TREE_TYPE (fntype
));
15012 /* In a function definition, arg types must be complete. */
15013 require_complete_types_for_parms (current_function_parms
);
15015 if (dependent_type_p (return_type
)
15016 || type_uses_auto (return_type
))
15018 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
15020 tree args
= TYPE_ARG_TYPES (fntype
);
15022 error ("return type %q#T is incomplete", return_type
);
15024 /* Make it return void instead. */
15025 if (TREE_CODE (fntype
) == METHOD_TYPE
)
15026 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
15028 TREE_CHAIN (args
));
15030 fntype
= build_function_type (void_type_node
, args
);
15031 fntype
= (cp_build_type_attribute_variant
15032 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
15033 fntype
= cxx_copy_lang_qualifiers (fntype
, TREE_TYPE (decl
));
15034 TREE_TYPE (decl
) = fntype
;
15038 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
15039 maybe_warn_parm_abi (TREE_TYPE (fntype
),
15040 DECL_SOURCE_LOCATION (decl
));
15044 /* True iff FN is an implicitly-defined default constructor. */
15047 implicit_default_ctor_p (tree fn
)
15049 return (DECL_CONSTRUCTOR_P (fn
)
15050 && !user_provided_p (fn
)
15051 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)));
15054 /* Clobber the contents of *this to let the back end know that the object
15055 storage is dead when we enter the constructor or leave the destructor. */
15058 build_clobber_this ()
15060 /* Clobbering an empty base is pointless, and harmful if its one byte
15061 TYPE_SIZE overlays real data. */
15062 if (is_empty_class (current_class_type
))
15065 /* If we have virtual bases, clobber the whole object, but only if we're in
15066 charge. If we don't have virtual bases, clobber the as-base type so we
15067 don't mess with tail padding. */
15068 bool vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
15070 tree ctype
= current_class_type
;
15072 ctype
= CLASSTYPE_AS_BASE (ctype
);
15074 tree clobber
= build_clobber (ctype
);
15076 tree thisref
= current_class_ref
;
15077 if (ctype
!= current_class_type
)
15079 thisref
= build_nop (build_reference_type (ctype
), current_class_ptr
);
15080 thisref
= convert_from_reference (thisref
);
15083 tree exprstmt
= build2 (MODIFY_EXPR
, void_type_node
, thisref
, clobber
);
15085 exprstmt
= build_if_in_charge (exprstmt
);
15090 /* Create the FUNCTION_DECL for a function definition.
15091 DECLSPECS and DECLARATOR are the parts of the declaration;
15092 they describe the function's name and the type it returns,
15093 but twisted together in a fashion that parallels the syntax of C.
15095 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
15096 DECLARATOR is really the DECL for the function we are about to
15097 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
15098 indicating that the function is an inline defined in-class.
15100 This function creates a binding context for the function body
15101 as well as setting up the FUNCTION_DECL in current_function_decl.
15103 For C++, we must first check whether that datum makes any sense.
15104 For example, "class A local_a(1,2);" means that variable local_a
15105 is an aggregate of type A, which should have a constructor
15106 applied to it with the argument list [1, 2].
15108 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
15109 or may be a BLOCK if the function has been defined previously
15110 in this translation unit. On exit, DECL_INITIAL (decl1) will be
15111 error_mark_node if the function has never been defined, or
15112 a BLOCK if the function has been defined somewhere. */
15115 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
15117 tree ctype
= NULL_TREE
;
15120 int doing_friend
= 0;
15121 cp_binding_level
*bl
;
15122 tree current_function_parms
;
15123 struct c_fileinfo
*finfo
15124 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
15125 bool honor_interface
;
15127 /* Sanity check. */
15128 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
15129 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
15131 fntype
= TREE_TYPE (decl1
);
15132 if (TREE_CODE (fntype
) == METHOD_TYPE
)
15133 ctype
= TYPE_METHOD_BASETYPE (fntype
);
15135 /* ISO C++ 11.4/5. A friend function defined in a class is in
15136 the (lexical) scope of the class in which it is defined. */
15137 if (!ctype
&& DECL_FRIEND_P (decl1
))
15139 ctype
= DECL_FRIEND_CONTEXT (decl1
);
15141 /* CTYPE could be null here if we're dealing with a template;
15142 for example, `inline friend float foo()' inside a template
15143 will have no CTYPE set. */
15144 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
15150 if (DECL_DECLARED_INLINE_P (decl1
)
15151 && lookup_attribute ("noinline", attrs
))
15152 warning_at (DECL_SOURCE_LOCATION (decl1
), 0,
15153 "inline function %qD given attribute noinline", decl1
);
15155 /* Handle gnu_inline attribute. */
15156 if (GNU_INLINE_P (decl1
))
15158 DECL_EXTERNAL (decl1
) = 1;
15159 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
15160 DECL_INTERFACE_KNOWN (decl1
) = 1;
15161 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
15164 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
15165 /* This is a constructor, we must ensure that any default args
15166 introduced by this definition are propagated to the clones
15167 now. The clones are used directly in overload resolution. */
15168 adjust_clone_args (decl1
);
15170 /* Sometimes we don't notice that a function is a static member, and
15171 build a METHOD_TYPE for it. Fix that up now. */
15172 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
15173 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
15175 /* Set up current_class_type, and enter the scope of the class, if
15178 push_nested_class (ctype
);
15179 else if (DECL_STATIC_FUNCTION_P (decl1
))
15180 push_nested_class (DECL_CONTEXT (decl1
));
15182 /* Now that we have entered the scope of the class, we must restore
15183 the bindings for any template parameters surrounding DECL1, if it
15184 is an inline member template. (Order is important; consider the
15185 case where a template parameter has the same name as a field of
15186 the class.) It is not until after this point that
15187 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
15188 if (flags
& SF_INCLASS_INLINE
)
15189 maybe_begin_member_template_processing (decl1
);
15191 /* Effective C++ rule 15. */
15193 && DECL_ASSIGNMENT_OPERATOR_P (decl1
)
15194 && DECL_OVERLOADED_OPERATOR_IS (decl1
, NOP_EXPR
)
15195 && VOID_TYPE_P (TREE_TYPE (fntype
)))
15196 warning (OPT_Weffc__
,
15197 "%<operator=%> should return a reference to %<*this%>");
15199 /* Make the init_value nonzero so pushdecl knows this is not tentative.
15200 error_mark_node is replaced below (in poplevel) with the BLOCK. */
15201 if (!DECL_INITIAL (decl1
))
15202 DECL_INITIAL (decl1
) = error_mark_node
;
15204 /* This function exists in static storage.
15205 (This does not mean `static' in the C sense!) */
15206 TREE_STATIC (decl1
) = 1;
15208 /* We must call push_template_decl after current_class_type is set
15209 up. (If we are processing inline definitions after exiting a
15210 class scope, current_class_type will be NULL_TREE until set above
15211 by push_nested_class.) */
15212 if (processing_template_decl
)
15214 tree newdecl1
= push_template_decl (decl1
);
15215 if (newdecl1
== error_mark_node
)
15217 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
15218 pop_nested_class ();
15224 /* Make sure the parameter and return types are reasonable. When
15225 you declare a function, these types can be incomplete, but they
15226 must be complete when you define the function. */
15227 check_function_type (decl1
, DECL_ARGUMENTS (decl1
));
15229 /* Build the return declaration for the function. */
15230 restype
= TREE_TYPE (fntype
);
15232 if (DECL_RESULT (decl1
) == NULL_TREE
)
15236 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
15237 DECL_ARTIFICIAL (resdecl
) = 1;
15238 DECL_IGNORED_P (resdecl
) = 1;
15239 DECL_RESULT (decl1
) = resdecl
;
15241 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
15244 /* Record the decl so that the function name is defined.
15245 If we already have a decl for this name, and it is a FUNCTION_DECL,
15246 use the old decl. */
15247 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
15249 /* A specialization is not used to guide overload resolution. */
15250 if (!DECL_FUNCTION_MEMBER_P (decl1
)
15251 && !(DECL_USE_TEMPLATE (decl1
) &&
15252 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
15254 tree olddecl
= pushdecl (decl1
);
15256 if (olddecl
== error_mark_node
)
15257 /* If something went wrong when registering the declaration,
15258 use DECL1; we have to have a FUNCTION_DECL to use when
15259 parsing the body of the function. */
15263 /* Otherwise, OLDDECL is either a previous declaration
15264 of the same function or DECL1 itself. */
15266 if (warn_missing_declarations
15267 && olddecl
== decl1
15268 && !DECL_MAIN_P (decl1
)
15269 && TREE_PUBLIC (decl1
)
15270 && !DECL_DECLARED_INLINE_P (decl1
))
15274 /* Check whether DECL1 is in an anonymous
15276 for (context
= DECL_CONTEXT (decl1
);
15278 context
= DECL_CONTEXT (context
))
15280 if (TREE_CODE (context
) == NAMESPACE_DECL
15281 && DECL_NAME (context
) == NULL_TREE
)
15285 if (context
== NULL
)
15286 warning_at (DECL_SOURCE_LOCATION (decl1
),
15287 OPT_Wmissing_declarations
,
15288 "no previous declaration for %qD", decl1
);
15296 /* We need to set the DECL_CONTEXT. */
15297 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
15298 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
15300 fntype
= TREE_TYPE (decl1
);
15301 restype
= TREE_TYPE (fntype
);
15303 /* If #pragma weak applies, mark the decl appropriately now.
15304 The pragma only applies to global functions. Because
15305 determining whether or not the #pragma applies involves
15306 computing the mangled name for the declaration, we cannot
15307 apply the pragma until after we have merged this declaration
15308 with any previous declarations; if the original declaration
15309 has a linkage specification, that specification applies to
15310 the definition as well, and may affect the mangled name. */
15311 if (DECL_FILE_SCOPE_P (decl1
))
15312 maybe_apply_pragma_weak (decl1
);
15315 /* We are now in the scope of the function being defined. */
15316 current_function_decl
= decl1
;
15318 /* Save the parm names or decls from this function's declarator
15319 where store_parm_decls will find them. */
15320 current_function_parms
= DECL_ARGUMENTS (decl1
);
15322 /* Let the user know we're compiling this function. */
15323 announce_function (decl1
);
15325 gcc_assert (DECL_INITIAL (decl1
));
15327 /* This function may already have been parsed, in which case just
15328 return; our caller will skip over the body without parsing. */
15329 if (DECL_INITIAL (decl1
) != error_mark_node
)
15332 /* Initialize RTL machinery. We cannot do this until
15333 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
15334 even when processing a template; this is how we get
15335 CFUN set up, and our per-function variables initialized.
15336 FIXME factor out the non-RTL stuff. */
15337 bl
= current_binding_level
;
15338 allocate_struct_function (decl1
, processing_template_decl
);
15340 /* Initialize the language data structures. Whenever we start
15341 a new function, we destroy temporaries in the usual way. */
15342 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
15343 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
15344 current_binding_level
= bl
;
15346 if (!processing_template_decl
&& type_uses_auto (restype
))
15348 FNDECL_USED_AUTO (decl1
) = true;
15349 current_function_auto_return_pattern
= restype
;
15352 /* Start the statement-tree, start the tree now. */
15353 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
15355 /* If we are (erroneously) defining a function that we have already
15356 defined before, wipe out what we knew before. */
15357 if (!DECL_PENDING_INLINE_P (decl1
))
15358 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
15360 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
15362 /* We know that this was set up by `grokclassfn'. We do not
15363 wait until `store_parm_decls', since evil parse errors may
15364 never get us to that point. Here we keep the consistency
15365 between `current_class_type' and `current_class_ptr'. */
15366 tree t
= DECL_ARGUMENTS (decl1
);
15368 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
15369 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
15371 cp_function_chain
->x_current_class_ref
15372 = cp_build_fold_indirect_ref (t
);
15373 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
15374 cp_function_chain
->x_current_class_ptr
= t
;
15376 /* Constructors and destructors need to know whether they're "in
15377 charge" of initializing virtual base classes. */
15378 t
= DECL_CHAIN (t
);
15379 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
15381 current_in_charge_parm
= t
;
15382 t
= DECL_CHAIN (t
);
15384 if (DECL_HAS_VTT_PARM_P (decl1
))
15386 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
15387 current_vtt_parm
= t
;
15391 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
15392 /* Implicitly-defined methods (like the
15393 destructor for a class in which no destructor
15394 is explicitly declared) must not be defined
15395 until their definition is needed. So, we
15396 ignore interface specifications for
15397 compiler-generated functions. */
15398 && !DECL_ARTIFICIAL (decl1
));
15400 if (processing_template_decl
)
15401 /* Don't mess with interface flags. */;
15402 else if (DECL_INTERFACE_KNOWN (decl1
))
15404 tree ctx
= decl_function_context (decl1
);
15406 if (DECL_NOT_REALLY_EXTERN (decl1
))
15407 DECL_EXTERNAL (decl1
) = 0;
15409 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
15410 /* This is a function in a local class in an extern inline
15411 or template function. */
15412 comdat_linkage (decl1
);
15414 /* If this function belongs to an interface, it is public.
15415 If it belongs to someone else's interface, it is also external.
15416 This only affects inlines and template instantiations. */
15417 else if (!finfo
->interface_unknown
&& honor_interface
)
15419 if (DECL_DECLARED_INLINE_P (decl1
)
15420 || DECL_TEMPLATE_INSTANTIATION (decl1
))
15422 DECL_EXTERNAL (decl1
)
15423 = (finfo
->interface_only
15424 || (DECL_DECLARED_INLINE_P (decl1
)
15425 && ! flag_implement_inlines
15426 && !DECL_VINDEX (decl1
)));
15428 /* For WIN32 we also want to put these in linkonce sections. */
15429 maybe_make_one_only (decl1
);
15432 DECL_EXTERNAL (decl1
) = 0;
15433 DECL_INTERFACE_KNOWN (decl1
) = 1;
15434 /* If this function is in an interface implemented in this file,
15435 make sure that the back end knows to emit this function
15437 if (!DECL_EXTERNAL (decl1
))
15438 mark_needed (decl1
);
15440 else if (finfo
->interface_unknown
&& finfo
->interface_only
15441 && honor_interface
)
15443 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
15444 interface, we will have both finfo->interface_unknown and
15445 finfo->interface_only set. In that case, we don't want to
15446 use the normal heuristics because someone will supply a
15447 #pragma implementation elsewhere, and deducing it here would
15448 produce a conflict. */
15449 comdat_linkage (decl1
);
15450 DECL_EXTERNAL (decl1
) = 0;
15451 DECL_INTERFACE_KNOWN (decl1
) = 1;
15452 DECL_DEFER_OUTPUT (decl1
) = 1;
15456 /* This is a definition, not a reference.
15457 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
15458 if (!GNU_INLINE_P (decl1
))
15459 DECL_EXTERNAL (decl1
) = 0;
15461 if ((DECL_DECLARED_INLINE_P (decl1
)
15462 || DECL_TEMPLATE_INSTANTIATION (decl1
))
15463 && ! DECL_INTERFACE_KNOWN (decl1
))
15464 DECL_DEFER_OUTPUT (decl1
) = 1;
15466 DECL_INTERFACE_KNOWN (decl1
) = 1;
15469 /* Determine the ELF visibility attribute for the function. We must not
15470 do this before calling "pushdecl", as we must allow "duplicate_decls"
15471 to merge any attributes appropriately. We also need to wait until
15473 if (!DECL_CLONED_FUNCTION_P (decl1
))
15474 determine_visibility (decl1
);
15476 if (!processing_template_decl
)
15477 maybe_instantiate_noexcept (decl1
);
15479 begin_scope (sk_function_parms
, decl1
);
15483 if (DECL_DESTRUCTOR_P (decl1
)
15484 || (DECL_CONSTRUCTOR_P (decl1
)
15485 && targetm
.cxx
.cdtor_returns_this ()))
15487 cdtor_label
= create_artificial_label (input_location
);
15488 LABEL_DECL_CDTOR (cdtor_label
) = true;
15491 start_fname_decls ();
15493 store_parm_decls (current_function_parms
);
15495 if (!processing_template_decl
15496 && (flag_lifetime_dse
> 1)
15497 && DECL_CONSTRUCTOR_P (decl1
)
15498 && !DECL_CLONED_FUNCTION_P (decl1
)
15499 /* Clobbering an empty base is harmful if it overlays real data. */
15500 && !is_empty_class (current_class_type
)
15501 /* We can't clobber safely for an implicitly-defined default constructor
15502 because part of the initialization might happen before we enter the
15503 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
15504 && !implicit_default_ctor_p (decl1
))
15505 finish_expr_stmt (build_clobber_this ());
15507 if (!processing_template_decl
15508 && DECL_CONSTRUCTOR_P (decl1
)
15509 && sanitize_flags_p (SANITIZE_VPTR
)
15510 && !DECL_CLONED_FUNCTION_P (decl1
)
15511 && !implicit_default_ctor_p (decl1
))
15512 cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr
);
15514 start_lambda_scope (decl1
);
15520 /* Like start_preparsed_function, except that instead of a
15521 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
15523 Returns true on success. If the DECLARATOR is not suitable
15524 for a function, we return false, which tells the parser to
15525 skip the entire function. */
15528 start_function (cp_decl_specifier_seq
*declspecs
,
15529 const cp_declarator
*declarator
,
15534 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
15535 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
15536 if (decl1
== error_mark_node
)
15538 /* If the declarator is not suitable for a function definition,
15539 cause a syntax error. */
15540 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
15542 error ("invalid function declaration");
15546 if (DECL_MAIN_P (decl1
))
15547 /* main must return int. grokfndecl should have corrected it
15548 (and issued a diagnostic) if the user got it wrong. */
15549 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
15550 integer_type_node
));
15552 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
15555 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
15559 use_eh_spec_block (tree fn
)
15561 return (flag_exceptions
&& flag_enforce_eh_specs
15562 && !processing_template_decl
15563 && !type_throw_all_p (TREE_TYPE (fn
))
15564 /* We insert the EH_SPEC_BLOCK only in the original
15565 function; then, it is copied automatically to the
15567 && !DECL_CLONED_FUNCTION_P (fn
)
15568 /* Implicitly-generated constructors and destructors have
15569 exception specifications. However, those specifications
15570 are the union of the possible exceptions specified by the
15571 constructors/destructors for bases and members, so no
15572 unallowed exception will ever reach this function. By
15573 not creating the EH_SPEC_BLOCK we save a little memory,
15574 and we avoid spurious warnings about unreachable
15576 && !DECL_DEFAULTED_FN (fn
));
15579 /* Store the parameter declarations into the current function declaration.
15580 This is called after parsing the parameter declarations, before
15581 digesting the body of the function.
15583 Also install to binding contour return value identifier, if any. */
15586 store_parm_decls (tree current_function_parms
)
15588 tree fndecl
= current_function_decl
;
15591 /* This is a chain of any other decls that came in among the parm
15592 declarations. If a parm is declared with enum {foo, bar} x;
15593 then CONST_DECLs for foo and bar are put here. */
15594 tree nonparms
= NULL_TREE
;
15596 if (current_function_parms
)
15598 /* This case is when the function was defined with an ANSI prototype.
15599 The parms already have decls, so we need not do anything here
15600 except record them as in effect
15601 and complain if any redundant old-style parm decls were written. */
15603 tree specparms
= current_function_parms
;
15606 /* Must clear this because it might contain TYPE_DECLs declared
15608 current_binding_level
->names
= NULL
;
15610 /* If we're doing semantic analysis, then we'll call pushdecl
15611 for each of these. We must do them in reverse order so that
15612 they end in the correct forward order. */
15613 specparms
= nreverse (specparms
);
15615 for (parm
= specparms
; parm
; parm
= next
)
15617 next
= DECL_CHAIN (parm
);
15618 if (TREE_CODE (parm
) == PARM_DECL
)
15622 /* If we find an enum constant or a type tag,
15623 put it aside for the moment. */
15624 TREE_CHAIN (parm
) = NULL_TREE
;
15625 nonparms
= chainon (nonparms
, parm
);
15629 /* Get the decls in their original chain order and record in the
15630 function. This is all and only the PARM_DECLs that were
15631 pushed into scope by the loop above. */
15632 DECL_ARGUMENTS (fndecl
) = get_local_decls ();
15635 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
15637 /* Now store the final chain of decls for the arguments
15638 as the decl-chain of the current lexical scope.
15639 Put the enumerators in as well, at the front so that
15640 DECL_ARGUMENTS is not modified. */
15641 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
15643 if (use_eh_spec_block (current_function_decl
))
15644 current_eh_spec_block
= begin_eh_spec_block ();
15648 /* We have finished doing semantic analysis on DECL, but have not yet
15649 generated RTL for its body. Save away our current state, so that
15650 when we want to generate RTL later we know what to do. */
15653 save_function_data (tree decl
)
15655 struct language_function
*f
;
15657 /* Save the language-specific per-function data so that we can
15658 get it back when we really expand this function. */
15659 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
15662 f
= ggc_alloc
<language_function
> ();
15663 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
15664 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
15666 /* Clear out the bits we don't need. */
15667 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
15668 f
->bindings
= NULL
;
15669 f
->base
.local_typedefs
= NULL
;
15673 /* Set the return value of the constructor (if present). */
15676 finish_constructor_body (void)
15681 if (targetm
.cxx
.cdtor_returns_this ())
15683 /* Any return from a constructor will end up here. */
15684 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
15686 val
= DECL_ARGUMENTS (current_function_decl
);
15687 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
15688 DECL_RESULT (current_function_decl
), val
);
15689 /* Return the address of the object. */
15690 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
15691 add_stmt (exprstmt
);
15695 /* Do all the processing for the beginning of a destructor; set up the
15696 vtable pointers and cleanups for bases and members. */
15699 begin_destructor_body (void)
15701 tree compound_stmt
;
15703 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
15704 issued an error message. We still want to try to process the
15705 body of the function, but initialize_vtbl_ptrs will crash if
15706 TYPE_BINFO is NULL. */
15707 if (COMPLETE_TYPE_P (current_class_type
))
15709 compound_stmt
= begin_compound_stmt (0);
15710 /* Make all virtual function table pointers in non-virtual base
15711 classes point to CURRENT_CLASS_TYPE's virtual function
15713 initialize_vtbl_ptrs (current_class_ptr
);
15714 finish_compound_stmt (compound_stmt
);
15716 if (flag_lifetime_dse
15717 /* Clobbering an empty base is harmful if it overlays real data. */
15718 && !is_empty_class (current_class_type
))
15720 if (sanitize_flags_p (SANITIZE_VPTR
)
15721 && (flag_sanitize_recover
& SANITIZE_VPTR
) == 0
15722 && TYPE_CONTAINS_VPTR_P (current_class_type
))
15724 tree binfo
= TYPE_BINFO (current_class_type
);
15726 = cp_build_fold_indirect_ref (current_class_ptr
);
15728 tree vtbl_ptr
= build_vfield_ref (ref
, TREE_TYPE (binfo
));
15729 tree vtbl
= build_zero_cst (TREE_TYPE (vtbl_ptr
));
15730 tree stmt
= cp_build_modify_expr (input_location
, vtbl_ptr
,
15732 tf_warning_or_error
);
15733 /* If the vptr is shared with some virtual nearly empty base,
15734 don't clear it if not in charge, the dtor of the virtual
15735 nearly empty base will do that later. */
15736 if (CLASSTYPE_VBASECLASSES (current_class_type
)
15737 && CLASSTYPE_PRIMARY_BINFO (current_class_type
)
15739 (CLASSTYPE_PRIMARY_BINFO (current_class_type
)))
15741 stmt
= convert_to_void (stmt
, ICV_STATEMENT
,
15742 tf_warning_or_error
);
15743 stmt
= build_if_in_charge (stmt
);
15745 finish_decl_cleanup (NULL_TREE
, stmt
);
15748 finish_decl_cleanup (NULL_TREE
, build_clobber_this ());
15751 /* And insert cleanups for our bases and members so that they
15752 will be properly destroyed if we throw. */
15753 push_base_cleanups ();
15757 /* At the end of every destructor we generate code to delete the object if
15758 necessary. Do that now. */
15761 finish_destructor_body (void)
15765 /* Any return from a destructor will end up here; that way all base
15766 and member cleanups will be run when the function returns. */
15767 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
15769 if (targetm
.cxx
.cdtor_returns_this ())
15773 val
= DECL_ARGUMENTS (current_function_decl
);
15774 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
15775 DECL_RESULT (current_function_decl
), val
);
15776 /* Return the address of the object. */
15777 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
15778 add_stmt (exprstmt
);
15782 /* Do the necessary processing for the beginning of a function body, which
15783 in this case includes member-initializers, but not the catch clauses of
15784 a function-try-block. Currently, this means opening a binding level
15785 for the member-initializers (in a ctor), member cleanups (in a dtor),
15786 and capture proxies (in a lambda operator()). */
15789 begin_function_body (void)
15793 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
15796 if (processing_template_decl
)
15797 /* Do nothing now. */;
15799 /* Always keep the BLOCK node associated with the outermost pair of
15800 curly braces of a function. These are needed for correct
15801 operation of dwarfout.c. */
15802 keep_next_level (true);
15804 stmt
= begin_compound_stmt (BCS_FN_BODY
);
15806 if (processing_template_decl
)
15807 /* Do nothing now. */;
15808 else if (DECL_DESTRUCTOR_P (current_function_decl
))
15809 begin_destructor_body ();
15814 /* Do the processing for the end of a function body. Currently, this means
15815 closing out the cleanups for fully-constructed bases and members, and in
15816 the case of the destructor, deleting the object if desired. Again, this
15817 is only meaningful for [cd]tors, since they are the only functions where
15818 there is a significant distinction between the main body and any
15819 function catch clauses. Handling, say, main() return semantics here
15820 would be wrong, as flowing off the end of a function catch clause for
15821 main() would also need to return 0. */
15824 finish_function_body (tree compstmt
)
15826 if (compstmt
== NULL_TREE
)
15829 /* Close the block. */
15830 finish_compound_stmt (compstmt
);
15832 if (processing_template_decl
)
15833 /* Do nothing now. */;
15834 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
15835 finish_constructor_body ();
15836 else if (DECL_DESTRUCTOR_P (current_function_decl
))
15837 finish_destructor_body ();
15840 /* Given a function, returns the BLOCK corresponding to the outermost level
15841 of curly braces, skipping the artificial block created for constructor
15845 outer_curly_brace_block (tree fndecl
)
15847 tree block
= DECL_INITIAL (fndecl
);
15848 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
15850 block
= BLOCK_SUBBLOCKS (block
);
15851 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
15853 block
= BLOCK_SUBBLOCKS (block
);
15854 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block
));
15858 /* If FNDECL is a class's key method, add the class to the list of
15859 keyed classes that should be emitted. */
15862 record_key_method_defined (tree fndecl
)
15864 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
15865 && DECL_VIRTUAL_P (fndecl
)
15866 && !processing_template_decl
)
15868 tree fnclass
= DECL_CONTEXT (fndecl
);
15869 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
15870 vec_safe_push (keyed_classes
, fnclass
);
15874 /* Subroutine of finish_function.
15875 Save the body of constexpr functions for possible
15876 future compile time evaluation. */
15879 maybe_save_function_definition (tree fun
)
15881 if (!processing_template_decl
15882 && DECL_DECLARED_CONSTEXPR_P (fun
)
15883 && !cp_function_chain
->invalid_constexpr
15884 && !DECL_CLONED_FUNCTION_P (fun
))
15885 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
15888 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
15889 of "return *this;" immediately before its location, using FNDECL's
15890 first statement (if any) to give the indentation, if appropriate. */
15893 add_return_star_this_fixit (gcc_rich_location
*richloc
, tree fndecl
)
15895 location_t indent
= UNKNOWN_LOCATION
;
15896 tree stmts
= expr_first (DECL_SAVED_TREE (fndecl
));
15898 indent
= EXPR_LOCATION (stmts
);
15899 richloc
->add_fixit_insert_formatted ("return *this;",
15900 richloc
->get_loc (),
15904 /* Finish up a function declaration and compile that function
15905 all the way to assembler language output. The free the storage
15906 for the function definition. INLINE_P is TRUE if we just
15907 finished processing the body of an in-class inline function
15908 definition. (This processing will have taken place after the
15909 class definition is complete.) */
15912 finish_function (bool inline_p
)
15914 tree fndecl
= current_function_decl
;
15915 tree fntype
, ctype
= NULL_TREE
;
15917 /* When we get some parse errors, we can end up without a
15918 current_function_decl, so cope. */
15919 if (fndecl
== NULL_TREE
)
15920 return error_mark_node
;
15922 finish_lambda_scope ();
15924 if (c_dialect_objc ())
15925 objc_finish_function ();
15927 record_key_method_defined (fndecl
);
15929 fntype
= TREE_TYPE (fndecl
);
15931 /* TREE_READONLY (fndecl) = 1;
15932 This caused &foo to be of type ptr-to-const-function
15933 which then got a warning when stored in a ptr-to-function variable. */
15935 gcc_assert (building_stmt_list_p ());
15936 /* The current function is being defined, so its DECL_INITIAL should
15937 be set, and unless there's a multiple definition, it should be
15938 error_mark_node. */
15939 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
15941 /* For a cloned function, we've already got all the code we need;
15942 there's no need to add any extra bits. */
15943 if (!DECL_CLONED_FUNCTION_P (fndecl
))
15945 /* Make it so that `main' always returns 0 by default. */
15946 if (DECL_MAIN_P (current_function_decl
))
15947 finish_return_stmt (integer_zero_node
);
15949 if (use_eh_spec_block (current_function_decl
))
15950 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
15951 (TREE_TYPE (current_function_decl
)),
15952 current_eh_spec_block
);
15955 /* If we're saving up tree structure, tie off the function now. */
15956 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
15958 finish_fname_decls ();
15960 /* If this function can't throw any exceptions, remember that. */
15961 if (!processing_template_decl
15962 && !cp_function_chain
->can_throw
15963 && !flag_non_call_exceptions
15964 && !decl_replaceable_p (fndecl
))
15965 TREE_NOTHROW (fndecl
) = 1;
15967 /* This must come after expand_function_end because cleanups might
15968 have declarations (from inline functions) that need to go into
15969 this function's blocks. */
15971 /* If the current binding level isn't the outermost binding level
15972 for this function, either there is a bug, or we have experienced
15973 syntax errors and the statement tree is malformed. */
15974 if (current_binding_level
->kind
!= sk_function_parms
)
15976 /* Make sure we have already experienced errors. */
15977 gcc_assert (errorcount
);
15979 /* Throw away the broken statement tree and extra binding
15981 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
15983 while (current_binding_level
->kind
!= sk_function_parms
)
15985 if (current_binding_level
->kind
== sk_class
)
15986 pop_nested_class ();
15988 poplevel (0, 0, 0);
15991 poplevel (1, 0, 1);
15993 /* Statements should always be full-expressions at the outermost set
15994 of curly braces for a function. */
15995 gcc_assert (stmts_are_full_exprs_p ());
15997 /* If there are no return statements in a function with auto return type,
15998 the return type is void. But if the declared type is something like
15999 auto*, this is an error. */
16000 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
16001 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
16003 if (is_auto (current_function_auto_return_pattern
))
16005 apply_deduced_return_type (fndecl
, void_type_node
);
16006 fntype
= TREE_TYPE (fndecl
);
16008 else if (!current_function_returns_value
16009 && !current_function_returns_null
)
16011 error ("no return statements in function returning %qT",
16012 current_function_auto_return_pattern
);
16013 inform (input_location
, "only plain %<auto%> return type can be "
16014 "deduced to %<void%>");
16018 // If this is a concept, check that the definition is reasonable.
16019 if (DECL_DECLARED_CONCEPT_P (fndecl
))
16020 check_function_concept (fndecl
);
16022 /* Lambda closure members are implicitly constexpr if possible. */
16023 if (cxx_dialect
>= cxx17
16024 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fndecl
)))
16025 DECL_DECLARED_CONSTEXPR_P (fndecl
)
16026 = ((processing_template_decl
16027 || is_valid_constexpr_fn (fndecl
, /*complain*/false))
16028 && potential_constant_expression (DECL_SAVED_TREE (fndecl
)));
16030 /* Save constexpr function body before it gets munged by
16031 the NRV transformation. */
16032 maybe_save_function_definition (fndecl
);
16034 /* Invoke the pre-genericize plugin before we start munging things. */
16035 if (!processing_template_decl
)
16036 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
16038 /* Perform delayed folding before NRV transformation. */
16039 if (!processing_template_decl
)
16040 cp_fold_function (fndecl
);
16042 /* Set up the named return value optimization, if we can. Candidate
16043 variables are selected in check_return_expr. */
16044 if (current_function_return_value
)
16046 tree r
= current_function_return_value
;
16049 if (r
!= error_mark_node
16050 /* This is only worth doing for fns that return in memory--and
16051 simpler, since we don't have to worry about promoted modes. */
16052 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
16053 /* Only allow this for variables declared in the outer scope of
16054 the function so we know that their lifetime always ends with a
16055 return; see g++.dg/opt/nrv6.C. We could be more flexible if
16056 we were to do this optimization in tree-ssa. */
16057 && (outer
= outer_curly_brace_block (fndecl
))
16058 && chain_member (r
, BLOCK_VARS (outer
)))
16059 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
16061 current_function_return_value
= NULL_TREE
;
16064 /* Remember that we were in class scope. */
16065 if (current_class_name
)
16066 ctype
= current_class_type
;
16068 /* Must mark the RESULT_DECL as being in this function. */
16069 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
16071 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
16072 to the FUNCTION_DECL node itself. */
16073 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
16075 /* Save away current state, if appropriate. */
16076 if (!processing_template_decl
)
16077 save_function_data (fndecl
);
16079 /* Complain if there's just no return statement. */
16080 if (warn_return_type
16081 && !VOID_TYPE_P (TREE_TYPE (fntype
))
16082 && !dependent_type_p (TREE_TYPE (fntype
))
16083 && !current_function_returns_value
&& !current_function_returns_null
16084 /* Don't complain if we abort or throw. */
16085 && !current_function_returns_abnormally
16086 /* Don't complain if there's an infinite loop. */
16087 && !current_function_infinite_loop
16088 /* Don't complain if we are declared noreturn. */
16089 && !TREE_THIS_VOLATILE (fndecl
)
16090 && !DECL_NAME (DECL_RESULT (fndecl
))
16091 && !TREE_NO_WARNING (fndecl
)
16092 /* Structor return values (if any) are set by the compiler. */
16093 && !DECL_CONSTRUCTOR_P (fndecl
)
16094 && !DECL_DESTRUCTOR_P (fndecl
)
16095 && targetm
.warn_func_return (fndecl
))
16097 gcc_rich_location
richloc (input_location
);
16098 /* Potentially add a "return *this;" fix-it hint for
16099 assignment operators. */
16100 if (IDENTIFIER_ASSIGN_OP_P (DECL_NAME (fndecl
)))
16102 tree valtype
= TREE_TYPE (DECL_RESULT (fndecl
));
16103 if (TREE_CODE (valtype
) == REFERENCE_TYPE
16104 && current_class_ref
16105 && same_type_ignoring_top_level_qualifiers_p
16106 (TREE_TYPE (valtype
), TREE_TYPE (current_class_ref
))
16107 && global_dc
->option_enabled (OPT_Wreturn_type
,
16108 global_dc
->option_state
))
16109 add_return_star_this_fixit (&richloc
, fndecl
);
16111 warning_at (&richloc
, OPT_Wreturn_type
,
16112 "no return statement in function returning non-void");
16113 TREE_NO_WARNING (fndecl
) = 1;
16116 /* Store the end of the function, so that we get good line number
16117 info for the epilogue. */
16118 cfun
->function_end_locus
= input_location
;
16120 /* Complain about parameters that are only set, but never otherwise used. */
16121 if (warn_unused_but_set_parameter
16122 && !processing_template_decl
16123 && errorcount
== unused_but_set_errorcount
16124 && !DECL_CLONED_FUNCTION_P (fndecl
))
16128 for (decl
= DECL_ARGUMENTS (fndecl
);
16130 decl
= DECL_CHAIN (decl
))
16131 if (TREE_USED (decl
)
16132 && TREE_CODE (decl
) == PARM_DECL
16133 && !DECL_READ_P (decl
)
16134 && DECL_NAME (decl
)
16135 && !DECL_ARTIFICIAL (decl
)
16136 && !TREE_NO_WARNING (decl
)
16137 && !DECL_IN_SYSTEM_HEADER (decl
)
16138 && TREE_TYPE (decl
) != error_mark_node
16139 && !TYPE_REF_P (TREE_TYPE (decl
))
16140 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
16141 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
16142 warning_at (DECL_SOURCE_LOCATION (decl
),
16143 OPT_Wunused_but_set_parameter
,
16144 "parameter %qD set but not used", decl
);
16145 unused_but_set_errorcount
= errorcount
;
16148 /* Complain about locally defined typedefs that are not used in this
16150 maybe_warn_unused_local_typedefs ();
16152 /* Possibly warn about unused parameters. */
16153 if (warn_unused_parameter
16154 && !processing_template_decl
16155 && !DECL_CLONED_FUNCTION_P (fndecl
))
16156 do_warn_unused_parameter (fndecl
);
16158 /* Genericize before inlining. */
16159 if (!processing_template_decl
)
16161 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
16162 cp_genericize (fndecl
);
16163 /* Clear out the bits we don't need. */
16164 f
->x_current_class_ptr
= NULL
;
16165 f
->x_current_class_ref
= NULL
;
16166 f
->x_eh_spec_block
= NULL
;
16167 f
->x_in_charge_parm
= NULL
;
16168 f
->x_vtt_parm
= NULL
;
16169 f
->x_return_value
= NULL
;
16170 f
->bindings
= NULL
;
16171 f
->extern_decl_map
= NULL
;
16172 f
->infinite_loops
= NULL
;
16175 /* We're leaving the context of this function, so zap cfun. It's still in
16176 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
16178 current_function_decl
= NULL
;
16180 /* If this is an in-class inline definition, we may have to pop the
16181 bindings for the template parameters that we added in
16182 maybe_begin_member_template_processing when start_function was
16185 maybe_end_member_template_processing ();
16187 /* Leave the scope of the class. */
16189 pop_nested_class ();
16194 current_function_decl
= NULL_TREE
;
16196 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, fndecl
);
16200 /* Create the FUNCTION_DECL for a function definition.
16201 DECLSPECS and DECLARATOR are the parts of the declaration;
16202 they describe the return type and the name of the function,
16203 but twisted together in a fashion that parallels the syntax of C.
16205 This function creates a binding context for the function body
16206 as well as setting up the FUNCTION_DECL in current_function_decl.
16208 Returns a FUNCTION_DECL on success.
16210 If the DECLARATOR is not suitable for a function (it defines a datum
16211 instead), we return 0, which tells yyparse to report a parse error.
16213 May return void_type_node indicating that this method is actually
16214 a friend. See grokfield for more details.
16216 Came here with a `.pushlevel' .
16218 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
16219 CHANGES TO CODE IN `grokfield'. */
16222 grokmethod (cp_decl_specifier_seq
*declspecs
,
16223 const cp_declarator
*declarator
, tree attrlist
)
16225 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
16228 if (fndecl
== error_mark_node
)
16229 return error_mark_node
;
16231 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
16233 error ("invalid member function declaration");
16234 return error_mark_node
;
16238 cplus_decl_attributes (&fndecl
, attrlist
, 0);
16240 /* Pass friends other than inline friend functions back. */
16241 if (fndecl
== void_type_node
)
16244 if (DECL_IN_AGGR_P (fndecl
))
16246 if (DECL_CLASS_SCOPE_P (fndecl
))
16247 error ("%qD is already defined in class %qT", fndecl
,
16248 DECL_CONTEXT (fndecl
));
16249 return error_mark_node
;
16252 check_template_shadow (fndecl
);
16254 if (TREE_PUBLIC (fndecl
))
16255 DECL_COMDAT (fndecl
) = 1;
16256 DECL_DECLARED_INLINE_P (fndecl
) = 1;
16257 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
16259 /* We process method specializations in finish_struct_1. */
16260 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
16262 fndecl
= push_template_decl (fndecl
);
16263 if (fndecl
== error_mark_node
)
16267 if (! DECL_FRIEND_P (fndecl
))
16269 if (DECL_CHAIN (fndecl
))
16271 fndecl
= copy_node (fndecl
);
16272 TREE_CHAIN (fndecl
) = NULL_TREE
;
16276 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
16278 DECL_IN_AGGR_P (fndecl
) = 1;
16283 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
16284 we can lay it out later, when and if its type becomes complete.
16286 Also handle constexpr variables where the initializer involves
16287 an unlowered PTRMEM_CST because the class isn't complete yet. */
16290 maybe_register_incomplete_var (tree var
)
16292 gcc_assert (VAR_P (var
));
16294 /* Keep track of variables with incomplete types. */
16295 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
16296 && DECL_EXTERNAL (var
))
16298 tree inner_type
= TREE_TYPE (var
);
16300 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
16301 inner_type
= TREE_TYPE (inner_type
);
16302 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
16304 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
16305 /* RTTI TD entries are created while defining the type_info. */
16306 || (TYPE_LANG_SPECIFIC (inner_type
)
16307 && TYPE_BEING_DEFINED (inner_type
)))
16309 incomplete_var iv
= {var
, inner_type
};
16310 vec_safe_push (incomplete_vars
, iv
);
16312 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
16313 && decl_constant_var_p (var
)
16314 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
16316 /* When the outermost open class is complete we can resolve any
16317 pointers-to-members. */
16318 tree context
= outermost_open_class ();
16319 incomplete_var iv
= {var
, context
};
16320 vec_safe_push (incomplete_vars
, iv
);
16325 /* Called when a class type (given by TYPE) is defined. If there are
16326 any existing VAR_DECLs whose type has been completed by this
16327 declaration, update them now. */
16330 complete_vars (tree type
)
16333 incomplete_var
*iv
;
16335 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
16337 if (same_type_p (type
, iv
->incomplete_type
))
16339 tree var
= iv
->decl
;
16340 tree type
= TREE_TYPE (var
);
16342 if (type
!= error_mark_node
16343 && (TYPE_MAIN_VARIANT (strip_array_types (type
))
16344 == iv
->incomplete_type
))
16346 /* Complete the type of the variable. The VAR_DECL itself
16347 will be laid out in expand_expr. */
16348 complete_type (type
);
16349 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
16352 /* Remove this entry from the list. */
16353 incomplete_vars
->unordered_remove (ix
);
16359 /* Check for pending declarations which may have abstract type. */
16360 complete_type_check_abstract (type
);
16363 /* If DECL is of a type which needs a cleanup, build and return an
16364 expression to perform that cleanup here. Return NULL_TREE if no
16365 cleanup need be done. DECL can also be a _REF when called from
16366 split_nonconstant_init_1. */
16369 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
16375 /* Assume no cleanup is required. */
16376 cleanup
= NULL_TREE
;
16378 if (error_operand_p (decl
))
16381 /* Handle "__attribute__((cleanup))". We run the cleanup function
16382 before the destructor since the destructor is what actually
16383 terminates the lifetime of the object. */
16385 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
16394 /* Get the name specified by the user for the cleanup function. */
16395 id
= TREE_VALUE (TREE_VALUE (attr
));
16396 /* Look up the name to find the cleanup function to call. It is
16397 important to use lookup_name here because that is what is
16398 used in c-common.c:handle_cleanup_attribute when performing
16399 initial checks on the attribute. Note that those checks
16400 include ensuring that the function found is not an overloaded
16401 function, or an object with an overloaded call operator,
16402 etc.; we can rely on the fact that the function found is an
16403 ordinary FUNCTION_DECL. */
16404 fn
= lookup_name (id
);
16405 arg
= build_address (decl
);
16406 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
16407 return error_mark_node
;
16408 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
16409 if (cleanup
== error_mark_node
)
16410 return error_mark_node
;
16412 /* Handle ordinary C++ destructors. */
16413 type
= TREE_TYPE (decl
);
16414 if (type_build_dtor_call (type
))
16416 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
16420 if (TREE_CODE (type
) == ARRAY_TYPE
)
16423 addr
= build_address (decl
);
16425 call
= build_delete (TREE_TYPE (addr
), addr
,
16426 sfk_complete_destructor
, flags
, 0, complain
);
16427 if (call
== error_mark_node
)
16428 cleanup
= error_mark_node
;
16429 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
16430 /* Discard the call. */;
16432 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
16437 /* build_delete sets the location of the destructor call to the
16438 current location, even though the destructor is going to be
16439 called later, at the end of the current scope. This can lead to
16440 a "jumpy" behavior for users of debuggers when they step around
16441 the end of the block. So let's unset the location of the
16442 destructor call instead. */
16443 protected_set_expr_location (cleanup
, UNKNOWN_LOCATION
);
16447 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
)))
16448 /* Treat objects with destructors as used; the destructor may do
16449 something substantive. */
16450 && !mark_used (decl
, complain
) && !(complain
& tf_error
))
16451 return error_mark_node
;
16457 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
16458 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
16459 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
16462 static_fn_type (tree memfntype
)
16467 if (TYPE_PTRMEMFUNC_P (memfntype
))
16468 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
16469 if (INDIRECT_TYPE_P (memfntype
)
16470 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
16471 memfntype
= TREE_TYPE (memfntype
);
16472 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
16474 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
16475 args
= TYPE_ARG_TYPES (memfntype
);
16476 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
16477 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
));
16478 fntype
= (cp_build_type_attribute_variant
16479 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
16480 fntype
= cxx_copy_lang_qualifiers (fntype
, memfntype
);
16484 /* DECL was originally constructed as a non-static member function,
16485 but turned out to be static. Update it accordingly. */
16488 revert_static_member_fn (tree decl
)
16490 tree stype
= static_fn_type (decl
);
16491 cp_cv_quals quals
= type_memfn_quals (stype
);
16492 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
16494 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
16495 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
16497 TREE_TYPE (decl
) = stype
;
16499 if (DECL_ARGUMENTS (decl
))
16500 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
16501 DECL_STATIC_FUNCTION_P (decl
) = 1;
16504 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
16505 one of the language-independent trees. */
16507 enum cp_tree_node_structure_enum
16508 cp_tree_node_structure (union lang_tree_node
* t
)
16510 switch (TREE_CODE (&t
->generic
))
16512 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
16513 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
16514 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
16515 case OVERLOAD
: return TS_CP_OVERLOAD
;
16516 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
16517 case PTRMEM_CST
: return TS_CP_PTRMEM
;
16518 case BASELINK
: return TS_CP_BASELINK
;
16519 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
16520 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
16521 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
16522 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
16523 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
16524 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
16525 case CONSTRAINT_INFO
: return TS_CP_CONSTRAINT_INFO
;
16526 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
16527 default: return TS_CP_GENERIC
;
16531 /* Build the void_list_node (void_type_node having been created). */
16533 build_void_list_node (void)
16535 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
16540 cp_missing_noreturn_ok_p (tree decl
)
16542 /* A missing noreturn is ok for the `main' function. */
16543 return DECL_MAIN_P (decl
);
16546 /* Return the decl used to identify the COMDAT group into which DECL should
16550 cxx_comdat_group (tree decl
)
16552 /* Virtual tables, construction virtual tables, and virtual table
16553 tables all go in a single COMDAT group, named after the primary
16555 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
16556 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
16557 /* For all other DECLs, the COMDAT group is the mangled name of the
16558 declaration itself. */
16561 while (DECL_THUNK_P (decl
))
16563 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
16564 into the same section as the target function. In that case
16565 we must return target's name. */
16566 tree target
= THUNK_TARGET (decl
);
16567 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
16568 && DECL_SECTION_NAME (target
) != NULL
16569 && DECL_ONE_ONLY (target
))
16579 /* Returns the return type for FN as written by the user, which may include
16580 a placeholder for a deduced return type. */
16583 fndecl_declared_return_type (tree fn
)
16585 fn
= STRIP_TEMPLATE (fn
);
16586 if (FNDECL_USED_AUTO (fn
))
16588 struct language_function
*f
= NULL
;
16589 if (DECL_STRUCT_FUNCTION (fn
))
16590 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
16592 f
= DECL_SAVED_FUNCTION_DATA (fn
);
16593 return f
->x_auto_return_pattern
;
16595 return TREE_TYPE (TREE_TYPE (fn
));
16598 /* Returns true iff DECL is a variable or function declared with an auto type
16599 that has not yet been deduced to a real type. */
16602 undeduced_auto_decl (tree decl
)
16604 if (cxx_dialect
< cxx11
)
16606 STRIP_ANY_LOCATION_WRAPPER (decl
);
16607 return ((VAR_OR_FUNCTION_DECL_P (decl
)
16608 || TREE_CODE (decl
) == TEMPLATE_DECL
)
16609 && type_uses_auto (TREE_TYPE (decl
)));
16612 /* Complain if DECL has an undeduced return type. */
16615 require_deduced_type (tree decl
, tsubst_flags_t complain
)
16617 if (undeduced_auto_decl (decl
))
16619 if (complain
& tf_error
)
16620 error ("use of %qD before deduction of %<auto%>", decl
);
16626 /* Create a representation of the explicit-specifier with
16627 constant-expression of EXPR. COMPLAIN is as for tsubst. */
16630 build_explicit_specifier (tree expr
, tsubst_flags_t complain
)
16632 if (processing_template_decl
&& value_dependent_expression_p (expr
))
16633 /* Wait for instantiation, tsubst_function_decl will handle it. */
16636 expr
= build_converted_constant_expr (boolean_type_node
, expr
, complain
);
16637 expr
= instantiate_non_dependent_expr (expr
);
16638 expr
= cxx_constant_value (expr
);
16642 #include "gt-cp-decl.h"