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 if (TYPE_MAIN_VARIANT (remove
) == remove
)
2136 gcc_assert (TYPE_NEXT_VARIANT (remove
) == NULL_TREE
);
2138 for (tree t
= TYPE_MAIN_VARIANT (remove
); ;
2139 t
= TYPE_NEXT_VARIANT (t
))
2140 if (TYPE_NEXT_VARIANT (t
) == remove
)
2142 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (remove
);
2147 else if (merge_attr
)
2148 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
2150 newtype
= TREE_TYPE (newdecl
);
2152 if (VAR_P (newdecl
))
2154 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
2155 /* For already initialized vars, TREE_READONLY could have been
2156 cleared in cp_finish_decl, because the var needs runtime
2157 initialization or destruction. Make sure not to set
2158 TREE_READONLY on it again. */
2159 if (DECL_INITIALIZED_P (olddecl
)
2160 && !DECL_EXTERNAL (olddecl
)
2161 && !TREE_READONLY (olddecl
))
2162 TREE_READONLY (newdecl
) = 0;
2163 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
2164 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
2165 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
2166 if (DECL_DEPENDENT_INIT_P (olddecl
))
2167 SET_DECL_DEPENDENT_INIT_P (newdecl
, true);
2168 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
2169 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
2170 if (DECL_CLASS_SCOPE_P (olddecl
))
2171 DECL_DECLARED_CONSTEXPR_P (newdecl
)
2172 |= DECL_DECLARED_CONSTEXPR_P (olddecl
);
2174 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2175 if (DECL_LANG_SPECIFIC (olddecl
)
2176 && CP_DECL_THREADPRIVATE_P (olddecl
))
2178 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2179 retrofit_lang_decl (newdecl
);
2180 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
2184 /* An explicit specialization of a function template or of a member
2185 function of a class template can be declared transaction_safe
2186 independently of whether the corresponding template entity is declared
2187 transaction_safe. */
2188 if (flag_tm
&& TREE_CODE (newdecl
) == FUNCTION_DECL
2189 && DECL_TEMPLATE_INSTANTIATION (olddecl
)
2190 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2191 && tx_safe_fn_type_p (newtype
)
2192 && !tx_safe_fn_type_p (TREE_TYPE (newdecl
)))
2193 newtype
= tx_unsafe_fn_variant (newtype
);
2195 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
2197 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2198 check_default_args (newdecl
);
2200 /* Lay the type out, unless already done. */
2201 if (! same_type_p (newtype
, oldtype
)
2202 && TREE_TYPE (newdecl
) != error_mark_node
2203 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2204 layout_type (TREE_TYPE (newdecl
));
2206 if ((VAR_P (newdecl
)
2207 || TREE_CODE (newdecl
) == PARM_DECL
2208 || TREE_CODE (newdecl
) == RESULT_DECL
2209 || TREE_CODE (newdecl
) == FIELD_DECL
2210 || TREE_CODE (newdecl
) == TYPE_DECL
)
2211 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2212 layout_decl (newdecl
, 0);
2214 /* Merge deprecatedness. */
2215 if (TREE_DEPRECATED (newdecl
))
2216 TREE_DEPRECATED (olddecl
) = 1;
2218 /* Preserve function specific target and optimization options */
2219 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2221 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2222 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2223 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2224 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2226 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2227 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2228 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2229 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2233 /* Merge the const type qualifier. */
2234 if (TREE_READONLY (newdecl
))
2235 TREE_READONLY (olddecl
) = 1;
2236 /* Merge the volatile type qualifier. */
2237 if (TREE_THIS_VOLATILE (newdecl
))
2238 TREE_THIS_VOLATILE (olddecl
) = 1;
2241 /* Merge the initialization information. */
2242 if (DECL_INITIAL (newdecl
) == NULL_TREE
2243 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2245 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2246 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2247 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2249 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2250 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2254 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2256 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2257 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2258 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2259 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2260 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2261 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2264 merge_attribute_bits (newdecl
, olddecl
);
2267 /* Merge the noreturn bit. */
2268 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2269 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2270 TREE_NOTHROW (olddecl
) = TREE_NOTHROW (newdecl
);
2271 DECL_IS_MALLOC (olddecl
) = DECL_IS_MALLOC (newdecl
);
2272 DECL_PURE_P (olddecl
) = DECL_PURE_P (newdecl
);
2274 /* Keep the old RTL. */
2275 COPY_DECL_RTL (olddecl
, newdecl
);
2277 else if (VAR_P (newdecl
)
2278 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2280 /* Keep the old RTL. We cannot keep the old RTL if the old
2281 declaration was for an incomplete object and the new
2282 declaration is not since many attributes of the RTL will
2284 COPY_DECL_RTL (olddecl
, newdecl
);
2287 /* If cannot merge, then use the new type and qualifiers,
2288 and don't preserve the old rtl. */
2291 /* Clean out any memory we had of the old declaration. */
2292 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2294 TREE_VALUE (oldstatic
) = error_mark_node
;
2296 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2297 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2298 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2299 TREE_NOTHROW (olddecl
) = TREE_NOTHROW (newdecl
);
2300 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2303 /* Merge the storage class information. */
2304 merge_weak (newdecl
, olddecl
);
2306 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2307 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2308 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2309 if (! DECL_EXTERNAL (olddecl
))
2310 DECL_EXTERNAL (newdecl
) = 0;
2311 if (! DECL_COMDAT (olddecl
))
2312 DECL_COMDAT (newdecl
) = 0;
2314 new_template_info
= NULL_TREE
;
2315 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2317 bool new_redefines_gnu_inline
= false;
2319 if (new_defines_function
2320 && ((DECL_INTERFACE_KNOWN (olddecl
)
2321 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2322 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2323 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2324 == FUNCTION_DECL
))))
2328 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2329 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2331 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2334 if (!new_redefines_gnu_inline
)
2336 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2337 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2338 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2340 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2341 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2342 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2344 /* If the OLDDECL is an instantiation and/or specialization,
2345 then the NEWDECL must be too. But, it may not yet be marked
2346 as such if the caller has created NEWDECL, but has not yet
2347 figured out that it is a redeclaration. */
2348 if (!DECL_USE_TEMPLATE (newdecl
))
2349 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2351 /* Don't really know how much of the language-specific
2352 values we should copy from old to new. */
2353 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2354 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2355 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2356 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2358 if (LANG_DECL_HAS_MIN (newdecl
))
2360 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
2361 if (DECL_TEMPLATE_INFO (newdecl
))
2363 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2364 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2365 && DECL_TEMPLATE_SPECIALIZATION (newdecl
))
2366 /* Remember the presence of explicit specialization args. */
2367 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl
))
2368 = TINFO_USED_TEMPLATE_ID (new_template_info
);
2370 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2372 /* Only functions have these fields. */
2373 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2375 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2376 DECL_BEFRIENDING_CLASSES (newdecl
)
2377 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2378 DECL_BEFRIENDING_CLASSES (olddecl
));
2379 /* DECL_THUNKS is only valid for virtual functions,
2380 otherwise it is a DECL_FRIEND_CONTEXT. */
2381 if (DECL_VIRTUAL_P (newdecl
))
2382 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2384 /* Only variables have this field. */
2385 else if (VAR_P (newdecl
)
2386 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2387 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2390 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2394 /* Merge parameter attributes. */
2395 tree oldarg
, newarg
;
2396 for (oldarg
= DECL_ARGUMENTS(olddecl
), newarg
= DECL_ARGUMENTS(newdecl
);
2398 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
))
2400 DECL_ATTRIBUTES (newarg
)
2401 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2402 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2405 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2406 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2408 /* If newdecl is not a specialization, then it is not a
2409 template-related function at all. And that means that we
2410 should have exited above, returning 0. */
2411 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2413 if (DECL_ODR_USED (olddecl
))
2414 /* From [temp.expl.spec]:
2416 If a template, a member template or the member of a class
2417 template is explicitly specialized then that
2418 specialization shall be declared before the first use of
2419 that specialization that would cause an implicit
2420 instantiation to take place, in every translation unit in
2421 which such a use occurs. */
2422 error ("explicit specialization of %qD after first use",
2425 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2426 DECL_COMDAT (newdecl
) = (TREE_PUBLIC (newdecl
)
2427 && DECL_DECLARED_INLINE_P (newdecl
));
2429 /* Don't propagate visibility from the template to the
2430 specialization here. We'll do that in determine_visibility if
2432 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2434 /* [temp.expl.spec/14] We don't inline explicit specialization
2435 just because the primary template says so. */
2436 gcc_assert (!merge_attr
);
2438 DECL_DECLARED_INLINE_P (olddecl
)
2439 = DECL_DECLARED_INLINE_P (newdecl
);
2441 DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2442 = DECL_DISREGARD_INLINE_LIMITS (newdecl
);
2444 DECL_UNINLINABLE (olddecl
) = DECL_UNINLINABLE (newdecl
);
2446 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2448 /* Never inline re-defined extern inline functions.
2449 FIXME: this could be better handled by keeping both
2450 function as separate declarations. */
2451 DECL_UNINLINABLE (newdecl
) = 1;
2455 if (DECL_PENDING_INLINE_P (olddecl
))
2457 DECL_PENDING_INLINE_P (newdecl
) = 1;
2458 DECL_PENDING_INLINE_INFO (newdecl
)
2459 = DECL_PENDING_INLINE_INFO (olddecl
);
2461 else if (DECL_PENDING_INLINE_P (newdecl
))
2463 else if (DECL_SAVED_FUNCTION_DATA (newdecl
) == NULL
)
2464 DECL_SAVED_FUNCTION_DATA (newdecl
)
2465 = DECL_SAVED_FUNCTION_DATA (olddecl
);
2467 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2469 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2470 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2472 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2473 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2474 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2475 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2478 /* Preserve abstractness on cloned [cd]tors. */
2479 DECL_ABSTRACT_P (newdecl
) = DECL_ABSTRACT_P (olddecl
);
2481 /* Update newdecl's parms to point at olddecl. */
2482 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2483 parm
= DECL_CHAIN (parm
))
2484 DECL_CONTEXT (parm
) = olddecl
;
2488 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2489 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2490 COPY_DECL_RTL (newdecl
, olddecl
);
2492 if (! types_match
|| new_defines_function
)
2494 /* These need to be copied so that the names are available.
2495 Note that if the types do match, we'll preserve inline
2496 info and other bits, but if not, we won't. */
2497 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2498 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2500 /* If redeclaring a builtin function, it stays built in
2501 if newdecl is a gnu_inline definition, or if newdecl is just
2503 if (fndecl_built_in_p (olddecl
)
2504 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2506 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2507 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2508 /* If we're keeping the built-in definition, keep the rtl,
2509 regardless of declaration matches. */
2510 COPY_DECL_RTL (olddecl
, newdecl
);
2511 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2513 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2516 /* If a compatible prototype of these builtin functions
2517 is seen, assume the runtime implements it with the
2518 expected semantics. */
2519 case BUILT_IN_STPCPY
:
2520 if (builtin_decl_explicit_p (fncode
))
2521 set_builtin_decl_implicit_p (fncode
, true);
2524 if (builtin_decl_explicit_p (fncode
))
2525 set_builtin_decl_declared_p (fncode
, true);
2530 copy_attributes_to_builtin (newdecl
);
2532 if (new_defines_function
)
2533 /* If defining a function declared with other language
2534 linkage, use the previously declared language linkage. */
2535 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2536 else if (types_match
)
2538 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2539 /* Don't clear out the arguments if we're just redeclaring a
2541 if (DECL_ARGUMENTS (olddecl
))
2542 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2545 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2546 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2548 /* Now preserve various other info from the definition. */
2549 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2550 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2551 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2552 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2554 /* Warn about conflicting visibility specifications. */
2555 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2556 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2557 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2559 auto_diagnostic_group d
;
2560 if (warning_at (newdecl_loc
, OPT_Wattributes
,
2561 "%qD: visibility attribute ignored because it "
2562 "conflicts with previous declaration", newdecl
))
2563 inform (olddecl_loc
,
2564 "previous declaration of %qD", olddecl
);
2566 /* Choose the declaration which specified visibility. */
2567 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2569 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2570 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2572 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2573 so keep this behavior. */
2574 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2576 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2577 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2579 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2580 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2582 SET_DECL_ALIGN (newdecl
, DECL_ALIGN (olddecl
));
2583 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2585 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2586 if (DECL_WARN_IF_NOT_ALIGN (olddecl
)
2587 > DECL_WARN_IF_NOT_ALIGN (newdecl
))
2588 SET_DECL_WARN_IF_NOT_ALIGN (newdecl
,
2589 DECL_WARN_IF_NOT_ALIGN (olddecl
));
2590 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2591 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2593 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2594 with that from NEWDECL below. */
2595 if (DECL_LANG_SPECIFIC (olddecl
))
2597 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2598 != DECL_LANG_SPECIFIC (newdecl
));
2599 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2602 /* Merge the USED information. */
2603 if (TREE_USED (olddecl
))
2604 TREE_USED (newdecl
) = 1;
2605 else if (TREE_USED (newdecl
))
2606 TREE_USED (olddecl
) = 1;
2607 if (VAR_P (newdecl
))
2609 if (DECL_READ_P (olddecl
))
2610 DECL_READ_P (newdecl
) = 1;
2611 else if (DECL_READ_P (newdecl
))
2612 DECL_READ_P (olddecl
) = 1;
2614 if (DECL_PRESERVE_P (olddecl
))
2615 DECL_PRESERVE_P (newdecl
) = 1;
2616 else if (DECL_PRESERVE_P (newdecl
))
2617 DECL_PRESERVE_P (olddecl
) = 1;
2619 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2620 to olddecl and deleted. */
2621 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2622 && DECL_FUNCTION_VERSIONED (olddecl
))
2624 /* Set the flag for newdecl so that it gets copied to olddecl. */
2625 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2626 /* newdecl will be purged after copying to olddecl and is no longer
2628 cgraph_node::delete_function_version_by_decl (newdecl
);
2631 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2634 struct symtab_node
*snode
= symtab_node::get (olddecl
);
2636 function_size
= sizeof (struct tree_decl_common
);
2638 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2639 (char *) newdecl
+ sizeof (struct tree_common
),
2640 function_size
- sizeof (struct tree_common
));
2642 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2643 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2644 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2646 /* Preserve symtab node mapping. */
2647 olddecl
->decl_with_vis
.symtab_node
= snode
;
2649 if (new_template_info
)
2650 /* If newdecl is a template instantiation, it is possible that
2651 the following sequence of events has occurred:
2653 o A friend function was declared in a class template. The
2654 class template was instantiated.
2656 o The instantiation of the friend declaration was
2657 recorded on the instantiation list, and is newdecl.
2659 o Later, however, instantiate_class_template called pushdecl
2660 on the newdecl to perform name injection. But, pushdecl in
2661 turn called duplicate_decls when it discovered that another
2662 declaration of a global function with the same name already
2665 o Here, in duplicate_decls, we decided to clobber newdecl.
2667 If we're going to do that, we'd better make sure that
2668 olddecl, and not newdecl, is on the list of
2669 instantiations so that if we try to do the instantiation
2670 again we won't get the clobbered declaration. */
2671 reregister_specialization (newdecl
,
2677 size_t size
= tree_code_size (TREE_CODE (newdecl
));
2679 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2680 (char *) newdecl
+ sizeof (struct tree_common
),
2681 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2682 switch (TREE_CODE (newdecl
))
2692 struct symtab_node
*snode
= NULL
;
2695 && (TREE_STATIC (olddecl
) || TREE_PUBLIC (olddecl
)
2696 || DECL_EXTERNAL (olddecl
)))
2697 snode
= symtab_node::get (olddecl
);
2698 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2699 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2700 size
- sizeof (struct tree_decl_common
)
2701 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2702 if (VAR_P (newdecl
))
2703 olddecl
->decl_with_vis
.symtab_node
= snode
;
2707 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2708 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2709 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2710 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2715 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2717 if (DECL_EXTERNAL (olddecl
)
2718 || TREE_PUBLIC (olddecl
)
2719 || TREE_STATIC (olddecl
))
2721 /* Merge the section attribute.
2722 We want to issue an error if the sections conflict but that must be
2723 done later in decl_attributes since we are called before attributes
2725 if (DECL_SECTION_NAME (newdecl
) != NULL
)
2726 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2728 if (DECL_ONE_ONLY (newdecl
))
2730 struct symtab_node
*oldsym
, *newsym
;
2731 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2732 oldsym
= cgraph_node::get_create (olddecl
);
2734 oldsym
= varpool_node::get_create (olddecl
);
2735 newsym
= symtab_node::get (newdecl
);
2736 oldsym
->set_comdat_group (newsym
->get_comdat_group ());
2741 && CP_DECL_THREAD_LOCAL_P (newdecl
))
2743 CP_DECL_THREAD_LOCAL_P (olddecl
) = true;
2744 if (!processing_template_decl
)
2745 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2749 DECL_UID (olddecl
) = olddecl_uid
;
2751 DECL_FRIEND_P (olddecl
) = 1;
2754 DECL_ANTICIPATED (olddecl
) = 1;
2755 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2758 /* NEWDECL contains the merged attribute lists.
2759 Update OLDDECL to be the same. */
2760 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2762 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2763 so that encode_section_info has a chance to look at the new decl
2764 flags and attributes. */
2765 if (DECL_RTL_SET_P (olddecl
)
2766 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2768 && TREE_STATIC (olddecl
))))
2769 make_decl_rtl (olddecl
);
2771 /* The NEWDECL will no longer be needed. Because every out-of-class
2772 declaration of a member results in a call to duplicate_decls,
2773 freeing these nodes represents in a significant savings.
2775 Before releasing the node, be sore to remove function from symbol
2776 table that might have been inserted there to record comdat group.
2777 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2778 structure is shared in between newdecl and oldecl. */
2779 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2780 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2781 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2783 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2788 /* Remove the associated constraints for newdecl, if any, before
2789 reclaiming memory. */
2791 remove_constraints (newdecl
);
2798 /* Return zero if the declaration NEWDECL is valid
2799 when the declaration OLDDECL (assumed to be for the same name)
2800 has already been seen.
2801 Otherwise return an error message format string with a %s
2802 where the identifier should go. */
2805 redeclaration_error_message (tree newdecl
, tree olddecl
)
2807 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2809 /* Because C++ can put things into name space for free,
2810 constructs like "typedef struct foo { ... } foo"
2811 would look like an erroneous redeclaration. */
2812 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2815 return G_("redefinition of %q#D");
2817 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2819 /* If this is a pure function, its olddecl will actually be
2820 the original initialization to `0' (which we force to call
2821 abort()). Don't complain about redefinition in this case. */
2822 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2823 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2826 /* If both functions come from different namespaces, this is not
2827 a redeclaration - this is a conflict with a used function. */
2828 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2829 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2830 && ! decls_match (olddecl
, newdecl
))
2831 return G_("%qD conflicts with used function");
2833 /* We'll complain about linkage mismatches in
2834 warn_extern_redeclared_static. */
2836 /* Defining the same name twice is no good. */
2837 if (decl_defined_p (olddecl
)
2838 && decl_defined_p (newdecl
))
2840 if (DECL_NAME (olddecl
) == NULL_TREE
)
2841 return G_("%q#D not declared in class");
2842 else if (!GNU_INLINE_P (olddecl
)
2843 || GNU_INLINE_P (newdecl
))
2844 return G_("redefinition of %q#D");
2847 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2849 bool olda
= GNU_INLINE_P (olddecl
);
2850 bool newa
= GNU_INLINE_P (newdecl
);
2855 return G_("%q+D redeclared inline with "
2856 "%<gnu_inline%> attribute");
2858 return G_("%q+D redeclared inline without "
2859 "%<gnu_inline%> attribute");
2863 check_abi_tag_redeclaration
2864 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2865 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2869 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2873 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2875 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2876 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2877 return G_("redefinition of %q#D");
2881 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2882 || (DECL_TEMPLATE_RESULT (newdecl
)
2883 == DECL_TEMPLATE_RESULT (olddecl
)))
2886 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2887 if (DECL_TEMPLATE_INFO (nt
))
2888 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2889 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2890 if (DECL_TEMPLATE_INFO (ot
))
2891 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2892 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2893 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2894 return G_("redefinition of %q#D");
2896 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2898 bool olda
= GNU_INLINE_P (ot
);
2899 bool newa
= GNU_INLINE_P (nt
);
2904 return G_("%q+D redeclared inline with "
2905 "%<gnu_inline%> attribute");
2907 return G_("%q+D redeclared inline without "
2908 "%<gnu_inline%> attribute");
2912 /* Core issue #226 (C++0x):
2914 If a friend function template declaration specifies a
2915 default template-argument, that declaration shall be a
2916 definition and shall be the only declaration of the
2917 function template in the translation unit. */
2918 if ((cxx_dialect
!= cxx98
)
2919 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2920 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2921 /*is_primary=*/true,
2922 /*is_partial=*/false,
2923 /*is_friend_decl=*/2))
2924 return G_("redeclaration of friend %q#D "
2925 "may not have default template arguments");
2929 else if (VAR_P (newdecl
)
2930 && CP_DECL_THREAD_LOCAL_P (newdecl
) != CP_DECL_THREAD_LOCAL_P (olddecl
)
2931 && (! DECL_LANG_SPECIFIC (olddecl
)
2932 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2933 || CP_DECL_THREAD_LOCAL_P (newdecl
)))
2935 /* Only variables can be thread-local, and all declarations must
2936 agree on this property. */
2937 if (CP_DECL_THREAD_LOCAL_P (newdecl
))
2938 return G_("thread-local declaration of %q#D follows "
2939 "non-thread-local declaration");
2941 return G_("non-thread-local declaration of %q#D follows "
2942 "thread-local declaration");
2944 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2946 /* The objects have been declared at namespace scope. If either
2947 is a member of an anonymous union, then this is an invalid
2948 redeclaration. For example:
2954 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2955 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2956 return G_("redeclaration of %q#D");
2957 /* If at least one declaration is a reference, there is no
2958 conflict. For example:
2964 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2967 /* Static data member declared outside a class definition
2968 if the variable is defined within the class with constexpr
2969 specifier is declaration rather than definition (and
2971 if (cxx_dialect
>= cxx17
2973 && DECL_CLASS_SCOPE_P (olddecl
)
2974 && DECL_DECLARED_CONSTEXPR_P (olddecl
)
2975 && !DECL_INITIAL (newdecl
))
2977 DECL_EXTERNAL (newdecl
) = 1;
2978 /* For now, only warn with explicit -Wdeprecated. */
2979 if (global_options_set
.x_warn_deprecated
)
2981 auto_diagnostic_group d
;
2982 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wdeprecated
,
2983 "redundant redeclaration of %<constexpr%> "
2984 "static data member %qD", newdecl
))
2985 inform (DECL_SOURCE_LOCATION (olddecl
),
2986 "previous declaration of %qD", olddecl
);
2991 /* Reject two definitions. */
2992 return G_("redefinition of %q#D");
2996 /* Objects declared with block scope: */
2997 /* Reject two definitions, and reject a definition
2998 together with an external reference. */
2999 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
3000 return G_("redeclaration of %q#D");
3006 /* Hash and equality functions for the named_label table. */
3009 named_label_hash::hash (const value_type entry
)
3011 return IDENTIFIER_HASH_VALUE (entry
->name
);
3015 named_label_hash::equal (const value_type entry
, compare_type name
)
3017 return name
== entry
->name
;
3020 /* Look for a label named ID in the current function. If one cannot
3021 be found, create one. Return the named_label_entry, or NULL on
3024 static named_label_entry
*
3025 lookup_label_1 (tree id
, bool making_local_p
)
3027 /* You can't use labels at global scope. */
3028 if (current_function_decl
== NULL_TREE
)
3030 error ("label %qE referenced outside of any function", id
);
3035 named_labels
= hash_table
<named_label_hash
>::create_ggc (13);
3037 hashval_t hash
= IDENTIFIER_HASH_VALUE (id
);
3038 named_label_entry
**slot
3039 = named_labels
->find_slot_with_hash (id
, hash
, INSERT
);
3040 named_label_entry
*old
= *slot
;
3042 if (old
&& old
->label_decl
)
3044 if (!making_local_p
)
3047 if (old
->binding_level
== current_binding_level
)
3049 error ("local label %qE conflicts with existing label", id
);
3050 inform (DECL_SOURCE_LOCATION (old
->label_decl
), "previous label");
3055 /* We are making a new decl, create or reuse the named_label_entry */
3056 named_label_entry
*ent
= NULL
;
3057 if (old
&& !old
->label_decl
)
3061 ent
= ggc_cleared_alloc
<named_label_entry
> ();
3067 /* Now create the LABEL_DECL. */
3068 tree decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
3070 DECL_CONTEXT (decl
) = current_function_decl
;
3071 SET_DECL_MODE (decl
, VOIDmode
);
3074 C_DECLARED_LABEL_FLAG (decl
) = true;
3075 DECL_CHAIN (decl
) = current_binding_level
->names
;
3076 current_binding_level
->names
= decl
;
3079 ent
->label_decl
= decl
;
3084 /* Wrapper for lookup_label_1. */
3087 lookup_label (tree id
)
3089 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3090 named_label_entry
*ent
= lookup_label_1 (id
, false);
3091 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3092 return ent
? ent
->label_decl
: NULL_TREE
;
3096 declare_local_label (tree id
)
3098 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3099 named_label_entry
*ent
= lookup_label_1 (id
, true);
3100 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3101 return ent
? ent
->label_decl
: NULL_TREE
;
3104 /* Returns nonzero if it is ill-formed to jump past the declaration of
3105 DECL. Returns 2 if it's also a real problem. */
3108 decl_jump_unsafe (tree decl
)
3110 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3111 with automatic storage duration is not in scope to a point where it is
3112 in scope is ill-formed unless the variable has scalar type, class type
3113 with a trivial default constructor and a trivial destructor, a
3114 cv-qualified version of one of these types, or an array of one of the
3115 preceding types and is declared without an initializer (8.5). */
3116 tree type
= TREE_TYPE (decl
);
3118 if (!VAR_P (decl
) || TREE_STATIC (decl
)
3119 || type
== error_mark_node
)
3122 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
3123 || variably_modified_type_p (type
, NULL_TREE
))
3126 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3132 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3136 identify_goto (tree decl
, location_t loc
, const location_t
*locus
,
3137 diagnostic_t diag_kind
)
3140 = emit_diagnostic (diag_kind
, loc
, 0,
3141 decl
? N_("jump to label %qD")
3142 : N_("jump to case label"), decl
);
3143 if (complained
&& locus
)
3144 inform (*locus
, " from here");
3148 /* Check that a single previously seen jump to a newly defined label
3149 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3150 the jump context; NAMES are the names in scope in LEVEL at the jump
3151 context; LOCUS is the source position of the jump or 0. Returns
3152 true if all is well. */
3155 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
3156 bool exited_omp
, const location_t
*locus
)
3158 cp_binding_level
*b
;
3159 bool complained
= false;
3161 bool saw_eh
= false, saw_omp
= false, saw_tm
= false, saw_cxif
= false;
3165 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3167 inform (input_location
, " exits OpenMP structured block");
3172 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3174 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
3176 for (new_decls
= b
->names
; new_decls
!= old_decls
;
3177 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
3178 : TREE_CHAIN (new_decls
)))
3180 int problem
= decl_jump_unsafe (new_decls
);
3186 complained
= identify_goto (decl
, input_location
, locus
,
3188 ? DK_ERROR
: DK_PERMERROR
);
3194 inform (DECL_SOURCE_LOCATION (new_decls
),
3195 " crosses initialization of %q#D", new_decls
);
3197 inform (DECL_SOURCE_LOCATION (new_decls
),
3198 " enters scope of %q#D, which has "
3199 "non-trivial destructor", new_decls
);
3206 const char *inf
= NULL
;
3207 location_t loc
= input_location
;
3212 inf
= N_("enters try block");
3218 inf
= N_("enters catch block");
3224 inf
= N_("enters OpenMP structured block");
3228 case sk_transaction
:
3230 inf
= N_("enters synchronized or atomic statement");
3235 if (!saw_cxif
&& level_for_constexpr_if (b
->level_chain
))
3237 inf
= N_("enters constexpr if statement");
3238 loc
= EXPR_LOCATION (b
->level_chain
->this_entity
);
3250 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3253 inform (loc
, " %s", inf
);
3261 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
3263 check_previous_goto_1 (decl
, use
->binding_level
,
3264 use
->names_in_scope
, use
->in_omp_scope
,
3265 &use
->o_goto_locus
);
3269 check_switch_goto (cp_binding_level
* level
)
3271 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
3274 /* Check that a new jump to a label DECL is OK. Called by
3275 finish_goto_stmt. */
3278 check_goto (tree decl
)
3280 /* We can't know where a computed goto is jumping.
3281 So we assume that it's OK. */
3282 if (TREE_CODE (decl
) != LABEL_DECL
)
3285 /* We didn't record any information about this label when we created it,
3286 and there's not much point since it's trivial to analyze as a return. */
3287 if (decl
== cdtor_label
)
3290 hashval_t hash
= IDENTIFIER_HASH_VALUE (DECL_NAME (decl
));
3291 named_label_entry
**slot
3292 = named_labels
->find_slot_with_hash (DECL_NAME (decl
), hash
, NO_INSERT
);
3293 named_label_entry
*ent
= *slot
;
3295 /* If the label hasn't been defined yet, defer checking. */
3296 if (! DECL_INITIAL (decl
))
3298 /* Don't bother creating another use if the last goto had the
3299 same data, and will therefore create the same set of errors. */
3301 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
3304 named_label_use_entry
*new_use
3305 = ggc_alloc
<named_label_use_entry
> ();
3306 new_use
->binding_level
= current_binding_level
;
3307 new_use
->names_in_scope
= current_binding_level
->names
;
3308 new_use
->o_goto_locus
= input_location
;
3309 new_use
->in_omp_scope
= false;
3311 new_use
->next
= ent
->uses
;
3312 ent
->uses
= new_use
;
3316 bool saw_catch
= false, complained
= false;
3321 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_transaction_scope
3322 || ent
->in_constexpr_if
3323 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
3325 diagnostic_t diag_kind
= DK_PERMERROR
;
3326 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_constexpr_if
3327 || ent
->in_transaction_scope
|| ent
->in_omp_scope
)
3328 diag_kind
= DK_ERROR
;
3329 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3330 &input_location
, diag_kind
);
3331 identified
= 1 + (diag_kind
== DK_ERROR
);
3334 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
3336 int u
= decl_jump_unsafe (bad
);
3338 if (u
> 1 && DECL_ARTIFICIAL (bad
))
3340 /* Can't skip init of __exception_info. */
3341 if (identified
== 1)
3343 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3344 &input_location
, DK_ERROR
);
3348 inform (DECL_SOURCE_LOCATION (bad
), " enters catch block");
3351 else if (complained
)
3354 inform (DECL_SOURCE_LOCATION (bad
),
3355 " skips initialization of %q#D", bad
);
3357 inform (DECL_SOURCE_LOCATION (bad
),
3358 " enters scope of %q#D which has "
3359 "non-trivial destructor", bad
);
3365 if (ent
->in_try_scope
)
3366 inform (input_location
, " enters try block");
3367 else if (ent
->in_catch_scope
&& !saw_catch
)
3368 inform (input_location
, " enters catch block");
3369 else if (ent
->in_transaction_scope
)
3370 inform (input_location
, " enters synchronized or atomic statement");
3371 else if (ent
->in_constexpr_if
)
3372 inform (input_location
, " enters %<constexpr%> if statement");
3375 if (ent
->in_omp_scope
)
3378 inform (input_location
, " enters OpenMP structured block");
3380 else if (flag_openmp
)
3381 for (cp_binding_level
*b
= current_binding_level
; b
; b
= b
->level_chain
)
3383 if (b
== ent
->binding_level
)
3385 if (b
->kind
== sk_omp
)
3389 complained
= identify_goto (decl
,
3390 DECL_SOURCE_LOCATION (decl
),
3391 &input_location
, DK_ERROR
);
3395 inform (input_location
, " exits OpenMP structured block");
3401 /* Check that a return is ok wrt OpenMP structured blocks.
3402 Called by finish_return_stmt. Returns true if all is well. */
3405 check_omp_return (void)
3407 for (cp_binding_level
*b
= current_binding_level
; b
; b
= b
->level_chain
)
3408 if (b
->kind
== sk_omp
)
3410 error ("invalid exit from OpenMP structured block");
3413 else if (b
->kind
== sk_function_parms
)
3418 /* Define a label, specifying the location in the source file.
3419 Return the LABEL_DECL node for the label. */
3422 define_label_1 (location_t location
, tree name
)
3424 /* After labels, make any new cleanups in the function go into their
3425 own new (temporary) binding contour. */
3426 for (cp_binding_level
*p
= current_binding_level
;
3427 p
->kind
!= sk_function_parms
;
3429 p
->more_cleanups_ok
= 0;
3431 named_label_entry
*ent
= lookup_label_1 (name
, false);
3432 tree decl
= ent
->label_decl
;
3434 if (DECL_INITIAL (decl
) != NULL_TREE
)
3436 error ("duplicate label %qD", decl
);
3437 return error_mark_node
;
3441 /* Mark label as having been defined. */
3442 DECL_INITIAL (decl
) = error_mark_node
;
3443 /* Say where in the source. */
3444 DECL_SOURCE_LOCATION (decl
) = location
;
3446 ent
->binding_level
= current_binding_level
;
3447 ent
->names_in_scope
= current_binding_level
->names
;
3449 for (named_label_use_entry
*use
= ent
->uses
; use
; use
= use
->next
)
3450 check_previous_goto (decl
, use
);
3457 /* Wrapper for define_label_1. */
3460 define_label (location_t location
, tree name
)
3462 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3463 tree ret
= define_label_1 (location
, name
);
3464 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3471 cp_binding_level
*level
;
3472 struct cp_switch
*next
;
3473 /* The SWITCH_STMT being built. */
3475 /* A splay-tree mapping the low element of a case range to the high
3476 element, or NULL_TREE if there is no high element. Used to
3477 determine whether or not a new case label duplicates an old case
3478 label. We need a tree, rather than simply a hash table, because
3479 of the GNU case range extension. */
3481 /* Remember whether there was a case value that is outside the
3482 range of the original type of the controlling expression. */
3483 bool outside_range_p
;
3484 /* Remember whether a default: case label has been seen. */
3486 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
3487 bool break_stmt_seen_p
;
3488 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
3489 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
3490 bool in_loop_body_p
;
3493 /* A stack of the currently active switch statements. The innermost
3494 switch statement is on the top of the stack. There is no need to
3495 mark the stack for garbage collection because it is only active
3496 during the processing of the body of a function, and we never
3497 collect at that point. */
3499 static struct cp_switch
*switch_stack
;
3501 /* Called right after a switch-statement condition is parsed.
3502 SWITCH_STMT is the switch statement being parsed. */
3505 push_switch (tree switch_stmt
)
3507 struct cp_switch
*p
= XNEW (struct cp_switch
);
3508 p
->level
= current_binding_level
;
3509 p
->next
= switch_stack
;
3510 p
->switch_stmt
= switch_stmt
;
3511 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3512 p
->outside_range_p
= false;
3513 p
->has_default_p
= false;
3514 p
->break_stmt_seen_p
= false;
3515 p
->in_loop_body_p
= false;
3522 struct cp_switch
*cs
= switch_stack
;
3523 location_t switch_location
;
3525 /* Emit warnings as needed. */
3526 switch_location
= cp_expr_loc_or_loc (cs
->switch_stmt
, input_location
);
3527 const bool bool_cond_p
3528 = (SWITCH_STMT_TYPE (cs
->switch_stmt
)
3529 && TREE_CODE (SWITCH_STMT_TYPE (cs
->switch_stmt
)) == BOOLEAN_TYPE
);
3530 if (!processing_template_decl
)
3531 c_do_switch_warnings (cs
->cases
, switch_location
,
3532 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3533 SWITCH_STMT_COND (cs
->switch_stmt
),
3534 bool_cond_p
, cs
->outside_range_p
);
3536 /* For the benefit of block_may_fallthru remember if the switch body
3537 case labels cover all possible values and if there are break; stmts. */
3538 if (cs
->has_default_p
3539 || (!processing_template_decl
3540 && c_switch_covers_all_cases_p (cs
->cases
,
3541 SWITCH_STMT_TYPE (cs
->switch_stmt
))))
3542 SWITCH_STMT_ALL_CASES_P (cs
->switch_stmt
) = 1;
3543 if (!cs
->break_stmt_seen_p
)
3544 SWITCH_STMT_NO_BREAK_P (cs
->switch_stmt
) = 1;
3545 gcc_assert (!cs
->in_loop_body_p
);
3546 splay_tree_delete (cs
->cases
);
3547 switch_stack
= switch_stack
->next
;
3551 /* Note that a BREAK_STMT is about to be added. If it is inside of
3552 a SWITCH_STMT and not inside of a loop body inside of it, note
3553 in switch_stack we've seen a BREAK_STMT. */
3556 note_break_stmt (void)
3558 if (switch_stack
&& !switch_stack
->in_loop_body_p
)
3559 switch_stack
->break_stmt_seen_p
= true;
3562 /* Note the start of processing of an iteration statement's body.
3563 The note_break_stmt function will do nothing while processing it.
3564 Return a flag that should be passed to note_iteration_stmt_body_end. */
3567 note_iteration_stmt_body_start (void)
3571 bool ret
= switch_stack
->in_loop_body_p
;
3572 switch_stack
->in_loop_body_p
= true;
3576 /* Note the end of processing of an iteration statement's body. */
3579 note_iteration_stmt_body_end (bool prev
)
3582 switch_stack
->in_loop_body_p
= prev
;
3585 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3586 condition. Note that if TYPE and VALUE are already integral we don't
3587 really do the conversion because the language-independent
3588 warning/optimization code will work better that way. */
3591 case_conversion (tree type
, tree value
)
3593 if (value
== NULL_TREE
)
3596 value
= mark_rvalue_use (value
);
3598 if (cxx_dialect
>= cxx11
3599 && (SCOPED_ENUM_P (type
)
3600 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3602 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3603 type
= type_promotes_to (type
);
3604 value
= (perform_implicit_conversion_flags
3605 (type
, value
, tf_warning_or_error
,
3606 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3608 return cxx_constant_value (value
);
3611 /* Note that we've seen a definition of a case label, and complain if this
3612 is a bad place for one. */
3615 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3618 cp_binding_level
*p
;
3621 if (low_value
== NULL_TREE
&& high_value
== NULL_TREE
)
3622 switch_stack
->has_default_p
= true;
3624 if (processing_template_decl
)
3628 /* For templates, just add the case label; we'll do semantic
3629 analysis at instantiation-time. */
3630 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, void_type_node
);
3631 return add_stmt (build_case_label (low_value
, high_value
, label
));
3634 /* Find the condition on which this switch statement depends. */
3635 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3636 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3637 cond
= TREE_VALUE (cond
);
3639 if (!check_switch_goto (switch_stack
->level
))
3640 return error_mark_node
;
3642 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3643 if (type
== error_mark_node
)
3644 return error_mark_node
;
3646 low_value
= case_conversion (type
, low_value
);
3647 high_value
= case_conversion (type
, high_value
);
3649 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3650 low_value
, high_value
,
3651 &switch_stack
->outside_range_p
);
3653 /* After labels, make any new cleanups in the function go into their
3654 own new (temporary) binding contour. */
3655 for (p
= current_binding_level
;
3656 p
->kind
!= sk_function_parms
;
3658 p
->more_cleanups_ok
= 0;
3663 struct typename_info
{
3671 struct typename_hasher
: ggc_ptr_hash
<tree_node
>
3673 typedef typename_info
*compare_type
;
3675 /* Hash a TYPENAME_TYPE. */
3682 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3683 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3688 /* Compare two TYPENAME_TYPEs. */
3691 equal (tree t1
, const typename_info
*t2
)
3693 return (TYPE_IDENTIFIER (t1
) == t2
->name
3694 && TYPE_CONTEXT (t1
) == t2
->scope
3695 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3696 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3697 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3701 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3702 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3704 Returns the new TYPENAME_TYPE. */
3706 static GTY (()) hash_table
<typename_hasher
> *typename_htab
;
3709 build_typename_type (tree context
, tree name
, tree fullname
,
3710 enum tag_types tag_type
)
3718 if (typename_htab
== NULL
)
3719 typename_htab
= hash_table
<typename_hasher
>::create_ggc (61);
3721 ti
.scope
= FROB_CONTEXT (context
);
3723 ti
.template_id
= fullname
;
3724 ti
.enum_p
= tag_type
== enum_type
;
3725 ti
.class_p
= (tag_type
== class_type
3726 || tag_type
== record_type
3727 || tag_type
== union_type
);
3728 hash
= (htab_hash_pointer (ti
.scope
)
3729 ^ htab_hash_pointer (ti
.name
));
3731 /* See if we already have this type. */
3732 e
= typename_htab
->find_slot_with_hash (&ti
, hash
, INSERT
);
3737 /* Build the TYPENAME_TYPE. */
3738 t
= cxx_make_type (TYPENAME_TYPE
);
3739 TYPE_CONTEXT (t
) = ti
.scope
;
3740 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3741 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3742 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3744 /* Build the corresponding TYPE_DECL. */
3745 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3746 TYPE_NAME (TREE_TYPE (d
)) = d
;
3747 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3748 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3749 DECL_ARTIFICIAL (d
) = 1;
3751 /* Store it in the hash table. */
3754 /* TYPENAME_TYPEs must always be compared structurally, because
3755 they may or may not resolve down to another type depending on
3756 the currently open classes. */
3757 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3763 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3764 provided to name the type. Returns an appropriate type, unless an
3765 error occurs, in which case error_mark_node is returned. If we
3766 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3767 return that, rather than the _TYPE it corresponds to, in other
3768 cases we look through the type decl. If TF_ERROR is set, complain
3769 about errors, otherwise be quiet. */
3772 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3773 tsubst_flags_t complain
)
3779 if (name
== error_mark_node
3780 || context
== NULL_TREE
3781 || context
== error_mark_node
)
3782 return error_mark_node
;
3786 if (!(TYPE_LANG_SPECIFIC (name
)
3787 && (CLASSTYPE_IS_TEMPLATE (name
)
3788 || CLASSTYPE_USE_TEMPLATE (name
))))
3789 name
= TYPE_IDENTIFIER (name
);
3791 /* Create a TEMPLATE_ID_EXPR for the type. */
3792 name
= build_nt (TEMPLATE_ID_EXPR
,
3793 CLASSTYPE_TI_TEMPLATE (name
),
3794 CLASSTYPE_TI_ARGS (name
));
3796 else if (TREE_CODE (name
) == TYPE_DECL
)
3797 name
= DECL_NAME (name
);
3801 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3803 name
= TREE_OPERAND (name
, 0);
3804 if (DECL_TYPE_TEMPLATE_P (name
))
3805 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3806 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
3808 if (complain
& tf_error
)
3809 error ("%qD is not a type", name
);
3810 return error_mark_node
;
3813 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3815 if (complain
& tf_error
)
3816 error ("%qD used without template arguments", name
);
3817 return error_mark_node
;
3819 gcc_assert (identifier_p (name
));
3820 gcc_assert (TYPE_P (context
));
3822 if (TREE_CODE (context
) == TYPE_PACK_EXPANSION
)
3823 /* This can happen for C++17 variadic using (c++/88986). */;
3824 else if (!MAYBE_CLASS_TYPE_P (context
))
3826 if (complain
& tf_error
)
3827 error ("%q#T is not a class", context
);
3828 return error_mark_node
;
3831 /* When the CONTEXT is a dependent type, NAME could refer to a
3832 dependent base class of CONTEXT. But look inside it anyway
3833 if CONTEXT is a currently open scope, in case it refers to a
3834 member of the current instantiation or a non-dependent base;
3835 lookup will stop when we hit a dependent base. */
3836 if (!dependent_scope_p (context
))
3837 /* We should only set WANT_TYPE when we're a nested typename type.
3838 Then we can give better diagnostics if we find a non-type. */
3839 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3843 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3844 return build_typename_type (context
, name
, fullname
, tag_type
);
3846 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3850 if (complain
& tf_error
)
3852 if (!COMPLETE_TYPE_P (context
))
3853 cxx_incomplete_type_error (NULL_TREE
, context
);
3855 error (want_template
? G_("no class template named %q#T in %q#T")
3856 : G_("no type named %q#T in %q#T"), name
, context
);
3858 return error_mark_node
;
3861 /* Pull out the template from an injected-class-name (or multiple). */
3863 t
= maybe_get_template_decl_from_type_decl (t
);
3865 if (TREE_CODE (t
) == TREE_LIST
)
3867 if (complain
& tf_error
)
3869 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3870 print_candidates (t
);
3872 return error_mark_node
;
3875 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3877 if (complain
& tf_error
)
3878 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3880 return error_mark_node
;
3882 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3884 if (complain
& tf_error
)
3885 error ("%<typename %T::%D%> names %q#T, which is not a type",
3887 return error_mark_node
;
3890 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3891 return error_mark_node
;
3893 /* If we are currently parsing a template and if T is a typedef accessed
3894 through CONTEXT then we need to remember and check access of T at
3895 template instantiation time. */
3896 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3899 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3901 /*entering_scope=*/0,
3902 complain
| tf_user
);
3904 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3907 maybe_record_typedef_use (t
);
3912 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3913 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3914 in which case error_mark_node is returned.
3916 If PARM_LIST is non-NULL, also make sure that the template parameter
3917 list of TEMPLATE_DECL matches.
3919 If COMPLAIN zero, don't complain about any errors that occur. */
3922 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3923 tsubst_flags_t complain
)
3929 name
= TYPE_IDENTIFIER (name
);
3930 else if (DECL_P (name
))
3931 name
= DECL_NAME (name
);
3932 gcc_assert (identifier_p (name
));
3934 if (!dependent_type_p (context
)
3935 || currently_open_class (context
))
3937 tree tmpl
= NULL_TREE
;
3939 if (MAYBE_CLASS_TYPE_P (context
))
3940 tmpl
= lookup_field (context
, name
, 0, false);
3942 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3943 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3945 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3947 if (complain
& tf_error
)
3948 error ("no class template named %q#T in %q#T", name
, context
);
3949 return error_mark_node
;
3953 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3955 if (complain
& tf_error
)
3957 error ("template parameters do not match template %qD", tmpl
);
3958 inform (DECL_SOURCE_LOCATION (tmpl
),
3959 "%qD declared here", tmpl
);
3961 return error_mark_node
;
3964 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3966 return error_mark_node
;
3971 /* Build the UNBOUND_CLASS_TEMPLATE. */
3972 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3973 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3974 TREE_TYPE (t
) = NULL_TREE
;
3975 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3977 /* Build the corresponding TEMPLATE_DECL. */
3978 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3979 TYPE_NAME (TREE_TYPE (d
)) = d
;
3980 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3981 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3982 DECL_ARTIFICIAL (d
) = 1;
3983 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3990 /* Push the declarations of builtin types into the global namespace.
3991 RID_INDEX is the index of the builtin type in the array
3992 RID_POINTERS. NAME is the name used when looking up the builtin
3993 type. TYPE is the _TYPE node for the builtin type.
3995 The calls to set_global_binding below should be
3996 eliminated. Built-in types should not be looked up name; their
3997 names are keywords that the parser can recognize. However, there
3998 is code in c-common.c that uses identifier_global_value to look up
3999 built-in types by name. */
4002 record_builtin_type (enum rid rid_index
,
4006 tree decl
= NULL_TREE
;
4010 tree tname
= get_identifier (name
);
4011 tree tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
4012 DECL_ARTIFICIAL (tdecl
) = 1;
4013 set_global_binding (tdecl
);
4017 if ((int) rid_index
< (int) RID_MAX
)
4018 if (tree rname
= ridpointers
[(int) rid_index
])
4019 if (!decl
|| DECL_NAME (decl
) != rname
)
4021 tree rdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
4022 DECL_ARTIFICIAL (rdecl
) = 1;
4023 set_global_binding (rdecl
);
4030 if (!TYPE_NAME (type
))
4031 TYPE_NAME (type
) = decl
;
4032 debug_hooks
->type_decl (decl
, 0);
4036 /* Push a type into the namespace so that the back ends ignore it. */
4039 record_unknown_type (tree type
, const char* name
)
4041 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
4042 TYPE_DECL
, get_identifier (name
), type
));
4043 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4044 DECL_IGNORED_P (decl
) = 1;
4045 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
4046 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
4047 SET_TYPE_ALIGN (type
, 1);
4048 TYPE_USER_ALIGN (type
) = 0;
4049 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
4052 /* Create all the predefined identifiers. */
4055 initialize_predefined_identifiers (void)
4057 struct predefined_identifier
4059 const char *name
; /* Name. */
4060 tree
*node
; /* Node to store it in. */
4061 cp_identifier_kind kind
; /* Kind of identifier. */
4064 /* A table of identifiers to create at startup. */
4065 static const predefined_identifier predefined_identifiers
[] = {
4066 {"C++", &lang_name_cplusplus
, cik_normal
},
4067 {"C", &lang_name_c
, cik_normal
},
4068 /* Some of these names have a trailing space so that it is
4069 impossible for them to conflict with names written by users. */
4070 {"__ct ", &ctor_identifier
, cik_ctor
},
4071 {"__ct_base ", &base_ctor_identifier
, cik_ctor
},
4072 {"__ct_comp ", &complete_ctor_identifier
, cik_ctor
},
4073 {"__dt ", &dtor_identifier
, cik_dtor
},
4074 {"__dt_base ", &base_dtor_identifier
, cik_dtor
},
4075 {"__dt_comp ", &complete_dtor_identifier
, cik_dtor
},
4076 {"__dt_del ", &deleting_dtor_identifier
, cik_dtor
},
4077 {"__conv_op ", &conv_op_identifier
, cik_conv_op
},
4078 {"__in_chrg", &in_charge_identifier
, cik_normal
},
4079 {"this", &this_identifier
, cik_normal
},
4080 {"__delta", &delta_identifier
, cik_normal
},
4081 {"__pfn", &pfn_identifier
, cik_normal
},
4082 {"_vptr", &vptr_identifier
, cik_normal
},
4083 {"__vtt_parm", &vtt_parm_identifier
, cik_normal
},
4084 {"::", &global_identifier
, cik_normal
},
4085 {"std", &std_identifier
, cik_normal
},
4086 /* The demangler expects anonymous namespaces to be called
4087 something starting with '_GLOBAL__N_'. It no longer needs
4088 to be unique to the TU. */
4089 {"_GLOBAL__N_1", &anon_identifier
, cik_normal
},
4090 {"auto", &auto_identifier
, cik_normal
},
4091 {"decltype(auto)", &decltype_auto_identifier
, cik_normal
},
4092 {"initializer_list", &init_list_identifier
, cik_normal
},
4093 {"__for_range ", &for_range__identifier
, cik_normal
},
4094 {"__for_begin ", &for_begin__identifier
, cik_normal
},
4095 {"__for_end ", &for_end__identifier
, cik_normal
},
4096 {"__for_range", &for_range_identifier
, cik_normal
},
4097 {"__for_begin", &for_begin_identifier
, cik_normal
},
4098 {"__for_end", &for_end_identifier
, cik_normal
},
4099 {"abi_tag", &abi_tag_identifier
, cik_normal
},
4100 {"aligned", &aligned_identifier
, cik_normal
},
4101 {"begin", &begin_identifier
, cik_normal
},
4102 {"end", &end_identifier
, cik_normal
},
4103 {"get", &get__identifier
, cik_normal
},
4104 {"gnu", &gnu_identifier
, cik_normal
},
4105 {"tuple_element", &tuple_element_identifier
, cik_normal
},
4106 {"tuple_size", &tuple_size_identifier
, cik_normal
},
4107 {"type", &type_identifier
, cik_normal
},
4108 {"value", &value_identifier
, cik_normal
},
4109 {"_FUN", &fun_identifier
, cik_normal
},
4110 {"__closure", &closure_identifier
, cik_normal
},
4111 {NULL
, NULL
, cik_normal
}
4114 for (const predefined_identifier
*pid
= predefined_identifiers
;
4117 *pid
->node
= get_identifier (pid
->name
);
4118 /* Some of these identifiers already have a special kind. */
4119 if (pid
->kind
!= cik_normal
)
4120 set_identifier_kind (*pid
->node
, pid
->kind
);
4124 /* Create the predefined scalar types of C,
4125 and some nodes representing standard constants (0, 1, (void *)0).
4126 Initialize the global binding level.
4127 Make definitions for built-in primitive functions. */
4130 cxx_init_decl_processing (void)
4133 tree void_ftype_ptr
;
4135 /* Create all the identifiers we need. */
4136 initialize_predefined_identifiers ();
4138 /* Create the global variables. */
4139 push_to_top_level ();
4141 current_function_decl
= NULL_TREE
;
4142 current_binding_level
= NULL
;
4143 /* Enter the global namespace. */
4144 gcc_assert (global_namespace
== NULL_TREE
);
4145 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_identifier
,
4147 TREE_PUBLIC (global_namespace
) = 1;
4148 DECL_CONTEXT (global_namespace
)
4149 = build_translation_unit_decl (get_identifier (main_input_filename
));
4150 /* Remember whether we want the empty class passing ABI change warning
4152 TRANSLATION_UNIT_WARN_EMPTY_P (DECL_CONTEXT (global_namespace
))
4153 = warn_abi
&& abi_version_crosses (12);
4154 debug_hooks
->register_main_translation_unit
4155 (DECL_CONTEXT (global_namespace
));
4156 begin_scope (sk_namespace
, global_namespace
);
4157 current_namespace
= global_namespace
;
4159 if (flag_visibility_ms_compat
)
4160 default_visibility
= VISIBILITY_HIDDEN
;
4163 current_lang_name
= lang_name_c
;
4165 /* Create the `std' namespace. */
4166 push_namespace (std_identifier
);
4167 std_node
= current_namespace
;
4170 flag_noexcept_type
= (cxx_dialect
>= cxx17
);
4172 c_common_nodes_and_builtins ();
4174 tree bool_ftype
= build_function_type_list (boolean_type_node
, NULL_TREE
);
4176 = add_builtin_function ("__builtin_is_constant_evaluated",
4177 bool_ftype
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
4178 BUILT_IN_FRONTEND
, NULL
, NULL_TREE
);
4179 set_call_expr_flags (decl
, ECF_CONST
| ECF_NOTHROW
| ECF_LEAF
);
4181 integer_two_node
= build_int_cst (NULL_TREE
, 2);
4183 /* Guess at the initial static decls size. */
4184 vec_alloc (static_decls
, 500);
4186 /* ... and keyed classes. */
4187 vec_alloc (keyed_classes
, 100);
4189 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
4190 truthvalue_type_node
= boolean_type_node
;
4191 truthvalue_false_node
= boolean_false_node
;
4192 truthvalue_true_node
= boolean_true_node
;
4194 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
4195 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
4196 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
4197 noexcept_deferred_spec
= build_tree_list (make_node (DEFERRED_NOEXCEPT
),
4201 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
4204 delta_type_node
= ptrdiff_type_node
;
4205 vtable_index_type
= ptrdiff_type_node
;
4207 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
4208 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
4209 void_ftype_ptr
= build_function_type_list (void_type_node
,
4210 ptr_type_node
, NULL_TREE
);
4212 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
4214 /* Create the conversion operator marker. This operator's DECL_NAME
4215 is in the identifier table, so we can use identifier equality to
4217 conv_op_marker
= build_lang_decl (FUNCTION_DECL
, conv_op_identifier
,
4220 /* C++ extensions */
4222 unknown_type_node
= make_node (LANG_TYPE
);
4223 record_unknown_type (unknown_type_node
, "unknown type");
4225 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4226 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
4228 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4230 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
4231 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
4233 init_list_type_node
= make_node (LANG_TYPE
);
4234 record_unknown_type (init_list_type_node
, "init list");
4237 /* Make sure we get a unique function type, so we can give
4238 its pointer type a name. (This wins for gdb.) */
4239 tree vfunc_type
= make_node (FUNCTION_TYPE
);
4240 TREE_TYPE (vfunc_type
) = integer_type_node
;
4241 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
4242 layout_type (vfunc_type
);
4244 vtable_entry_type
= build_pointer_type (vfunc_type
);
4246 record_builtin_type (RID_MAX
, "__vtbl_ptr_type", vtable_entry_type
);
4249 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
4250 layout_type (vtbl_type_node
);
4251 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
4252 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
4253 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
4254 layout_type (vtbl_ptr_type_node
);
4255 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
4257 push_namespace (get_identifier ("__cxxabiv1"));
4258 abi_node
= current_namespace
;
4261 global_type_node
= make_node (LANG_TYPE
);
4262 record_unknown_type (global_type_node
, "global type");
4264 any_targ_node
= make_node (LANG_TYPE
);
4265 record_unknown_type (any_targ_node
, "any type");
4268 current_lang_name
= lang_name_cplusplus
;
4270 if (aligned_new_threshold
> 1
4271 && !pow2p_hwi (aligned_new_threshold
))
4273 error ("%<-faligned-new=%d%> is not a power of two",
4274 aligned_new_threshold
);
4275 aligned_new_threshold
= 1;
4277 if (aligned_new_threshold
== -1)
4278 aligned_new_threshold
= (cxx_dialect
>= cxx17
) ? 1 : 0;
4279 if (aligned_new_threshold
== 1)
4280 aligned_new_threshold
= malloc_alignment () / BITS_PER_UNIT
;
4283 tree newattrs
, extvisattr
;
4284 tree newtype
, deltype
;
4285 tree ptr_ftype_sizetype
;
4289 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
4290 if (cxx_dialect
== cxx98
)
4293 tree bad_alloc_type_node
;
4294 tree bad_alloc_decl
;
4296 push_namespace (std_identifier
);
4297 bad_alloc_id
= get_identifier ("bad_alloc");
4298 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
4299 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
4301 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
4302 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
4306 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
4309 new_eh_spec
= noexcept_false_spec
;
4311 /* Ensure attribs.c is initialized. */
4314 /* Ensure constraint.cc is initialized. */
4315 init_constraint_processing ();
4317 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
4319 newattrs
= tree_cons (get_identifier ("alloc_size"),
4320 build_tree_list (NULL_TREE
, integer_one_node
),
4322 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
4323 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4324 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
4325 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4326 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4327 DECL_IS_MALLOC (opnew
) = 1;
4328 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4329 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4330 DECL_IS_MALLOC (opnew
) = 1;
4331 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4332 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4333 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4334 if (flag_sized_deallocation
)
4336 /* Also push the sized deallocation variants:
4337 void operator delete(void*, std::size_t) throw();
4338 void operator delete[](void*, std::size_t) throw(); */
4339 tree void_ftype_ptr_size
4340 = build_function_type_list (void_type_node
, ptr_type_node
,
4341 size_type_node
, NULL_TREE
);
4342 deltype
= cp_build_type_attribute_variant (void_ftype_ptr_size
,
4344 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4345 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4346 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4349 if (aligned_new_threshold
)
4351 push_namespace (std_identifier
);
4352 tree align_id
= get_identifier ("align_val_t");
4353 align_type_node
= start_enum (align_id
, NULL_TREE
, size_type_node
,
4354 NULL_TREE
, /*scoped*/true, NULL
);
4357 /* operator new (size_t, align_val_t); */
4358 newtype
= build_function_type_list (ptr_type_node
, size_type_node
,
4359 align_type_node
, NULL_TREE
);
4360 newtype
= cp_build_type_attribute_variant (newtype
, newattrs
);
4361 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4362 opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4363 DECL_IS_MALLOC (opnew
) = 1;
4364 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4365 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4366 DECL_IS_MALLOC (opnew
) = 1;
4367 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4369 /* operator delete (void *, align_val_t); */
4370 deltype
= build_function_type_list (void_type_node
, ptr_type_node
,
4371 align_type_node
, NULL_TREE
);
4372 deltype
= cp_build_type_attribute_variant (deltype
, extvisattr
);
4373 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4374 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4375 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4377 if (flag_sized_deallocation
)
4379 /* operator delete (void *, size_t, align_val_t); */
4380 deltype
= build_function_type_list (void_type_node
, ptr_type_node
,
4381 size_type_node
, align_type_node
,
4383 deltype
= cp_build_type_attribute_variant (deltype
, extvisattr
);
4384 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4385 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4386 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4390 nullptr_type_node
= make_node (NULLPTR_TYPE
);
4391 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
4392 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
4393 TYPE_UNSIGNED (nullptr_type_node
) = 1;
4394 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
4395 if (abi_version_at_least (9))
4396 SET_TYPE_ALIGN (nullptr_type_node
, GET_MODE_ALIGNMENT (ptr_mode
));
4397 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
4398 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
4399 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
4403 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
4404 ECF_NORETURN
| ECF_NOTHROW
| ECF_COLD
);
4406 /* Perform other language dependent initializations. */
4407 init_class_processing ();
4408 init_rtti_processing ();
4409 init_template_processing ();
4411 if (flag_exceptions
)
4412 init_exception_processing ();
4414 if (! supports_one_only ())
4417 make_fname_decl
= cp_make_fname_decl
;
4418 start_fname_decls ();
4420 /* Show we use EH for cleanups. */
4421 if (flag_exceptions
)
4422 using_eh_for_cleanups ();
4425 /* Generate an initializer for a function naming variable from
4426 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4427 filled in with the type of the init. */
4430 cp_fname_init (const char* name
, tree
*type_p
)
4432 tree domain
= NULL_TREE
;
4434 tree init
= NULL_TREE
;
4439 length
= strlen (name
);
4440 domain
= build_index_type (size_int (length
));
4441 init
= build_string (length
+ 1, name
);
4444 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
4445 type
= build_cplus_array_type (type
, domain
);
4450 TREE_TYPE (init
) = type
;
4452 init
= error_mark_node
;
4457 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4458 the decl, LOC is the location to give the decl, NAME is the
4459 initialization string and TYPE_DEP indicates whether NAME depended
4460 on the type of the function. We make use of that to detect
4461 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4462 at the point of first use, so we mustn't push the decl now. */
4465 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4467 const char *const name
= (type_dep
&& in_template_function ()
4468 ? NULL
: fname_as_string (type_dep
));
4470 tree init
= cp_fname_init (name
, &type
);
4471 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4474 free (CONST_CAST (char *, name
));
4476 /* As we're using pushdecl_with_scope, we must set the context. */
4477 DECL_CONTEXT (decl
) = current_function_decl
;
4479 TREE_READONLY (decl
) = 1;
4480 DECL_ARTIFICIAL (decl
) = 1;
4481 DECL_DECLARED_CONSTEXPR_P (decl
) = 1;
4482 TREE_STATIC (decl
) = 1;
4484 TREE_USED (decl
) = 1;
4488 SET_DECL_VALUE_EXPR (decl
, init
);
4489 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
4490 /* For decl_constant_var_p. */
4491 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
4494 if (current_function_decl
)
4496 DECL_CONTEXT (decl
) = current_function_decl
;
4497 decl
= pushdecl_outermost_localscope (decl
);
4498 if (decl
!= error_mark_node
)
4499 add_decl_expr (decl
);
4503 DECL_THIS_STATIC (decl
) = true;
4504 pushdecl_top_level_and_finish (decl
, NULL_TREE
);
4511 builtin_function_1 (tree decl
, tree context
, bool is_global
)
4513 tree id
= DECL_NAME (decl
);
4514 const char *name
= IDENTIFIER_POINTER (id
);
4516 retrofit_lang_decl (decl
);
4518 DECL_ARTIFICIAL (decl
) = 1;
4519 SET_DECL_LANGUAGE (decl
, lang_c
);
4520 /* Runtime library routines are, by definition, available in an
4521 external shared object. */
4522 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4523 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4525 DECL_CONTEXT (decl
) = context
;
4527 /* A function in the user's namespace should have an explicit
4528 declaration before it is used. Mark the built-in function as
4529 anticipated but not actually declared. */
4530 if (name
[0] != '_' || name
[1] != '_')
4531 DECL_ANTICIPATED (decl
) = 1;
4532 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4534 size_t len
= strlen (name
);
4536 /* Treat __*_chk fortification functions as anticipated as well,
4537 unless they are __builtin_*. */
4538 if (len
> strlen ("___chk")
4539 && memcmp (name
+ len
- strlen ("_chk"),
4540 "_chk", strlen ("_chk") + 1) == 0)
4541 DECL_ANTICIPATED (decl
) = 1;
4545 return pushdecl_top_level (decl
);
4547 return pushdecl (decl
);
4551 cxx_builtin_function (tree decl
)
4553 tree id
= DECL_NAME (decl
);
4554 const char *name
= IDENTIFIER_POINTER (id
);
4555 /* All builtins that don't begin with an '_' should additionally
4556 go in the 'std' namespace. */
4559 tree decl2
= copy_node(decl
);
4560 push_namespace (std_identifier
);
4561 builtin_function_1 (decl2
, std_node
, false);
4565 return builtin_function_1 (decl
, NULL_TREE
, false);
4568 /* Like cxx_builtin_function, but guarantee the function is added to the global
4569 scope. This is to allow function specific options to add new machine
4570 dependent builtins when the target ISA changes via attribute((target(...)))
4571 which saves space on program startup if the program does not use non-generic
4575 cxx_builtin_function_ext_scope (tree decl
)
4578 tree id
= DECL_NAME (decl
);
4579 const char *name
= IDENTIFIER_POINTER (id
);
4580 /* All builtins that don't begin with an '_' should additionally
4581 go in the 'std' namespace. */
4584 tree decl2
= copy_node(decl
);
4585 push_namespace (std_identifier
);
4586 builtin_function_1 (decl2
, std_node
, true);
4590 return builtin_function_1 (decl
, NULL_TREE
, true);
4593 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4594 function. Not called directly. */
4597 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4600 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4601 DECL_EXTERNAL (fn
) = 1;
4602 TREE_PUBLIC (fn
) = 1;
4603 DECL_ARTIFICIAL (fn
) = 1;
4604 DECL_OVERLOADED_OPERATOR_CODE_RAW (fn
)
4605 = OVL_OP_INFO (false, operator_code
)->ovl_op_code
;
4606 SET_DECL_LANGUAGE (fn
, lang_c
);
4607 /* Runtime library routines are, by definition, available in an
4608 external shared object. */
4609 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4610 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4611 set_call_expr_flags (fn
, ecf_flags
);
4615 /* Returns the _DECL for a library function with C++ linkage. */
4618 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4621 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4622 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4623 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4627 /* Like build_library_fn, but takes a C string instead of an
4631 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4633 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4636 /* Like build_cp_library_fn, but takes a C string instead of an
4640 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4642 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4646 /* Like build_library_fn, but also pushes the function so that we will
4647 be able to find it via get_global_binding. Also, the function
4648 may throw exceptions listed in RAISES. */
4651 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4656 type
= build_exception_variant (type
, raises
);
4658 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4659 pushdecl_top_level (fn
);
4663 /* Like build_cp_library_fn, but also pushes the function so that it
4664 will be found by normal lookup. */
4667 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4670 tree fn
= build_cp_library_fn (ovl_op_identifier (false, operator_code
),
4671 operator_code
, type
, ecf_flags
);
4674 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4678 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4682 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4684 tree type
= build_function_type (void_type_node
, parmtypes
);
4685 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4688 /* Like push_library_fn, but also note that this function throws
4689 and does not return. Used for __throw_foo and the like. */
4692 push_throw_library_fn (tree name
, tree type
)
4694 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
| ECF_COLD
);
4698 /* When we call finish_struct for an anonymous union, we create
4699 default copy constructors and such. But, an anonymous union
4700 shouldn't have such things; this function undoes the damage to the
4701 anonymous union type T.
4703 (The reason that we create the synthesized methods is that we don't
4704 distinguish `union { int i; }' from `typedef union { int i; } U'.
4705 The first is an anonymous union; the second is just an ordinary
4709 fixup_anonymous_aggr (tree t
)
4711 /* Wipe out memory of synthesized methods. */
4712 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4713 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4714 TYPE_HAS_COPY_CTOR (t
) = 0;
4715 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4716 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4717 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4719 /* Splice the implicitly generated functions out of TYPE_FIELDS. */
4720 for (tree probe
, *prev_p
= &TYPE_FIELDS (t
); (probe
= *prev_p
);)
4721 if (TREE_CODE (probe
) == FUNCTION_DECL
&& DECL_ARTIFICIAL (probe
))
4722 *prev_p
= DECL_CHAIN (probe
);
4724 prev_p
= &DECL_CHAIN (probe
);
4726 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4727 assignment operators (because they cannot have these methods themselves).
4728 For anonymous unions this is already checked because they are not allowed
4729 in any union, otherwise we have to check it. */
4730 if (TREE_CODE (t
) != UNION_TYPE
)
4734 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4735 if (TREE_CODE (field
) == FIELD_DECL
)
4737 type
= TREE_TYPE (field
);
4738 if (CLASS_TYPE_P (type
))
4740 if (TYPE_NEEDS_CONSTRUCTING (type
))
4741 error ("member %q+#D with constructor not allowed "
4742 "in anonymous aggregate", field
);
4743 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4744 error ("member %q+#D with destructor not allowed "
4745 "in anonymous aggregate", field
);
4746 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4747 error ("member %q+#D with copy assignment operator "
4748 "not allowed in anonymous aggregate", field
);
4754 /* Warn for an attribute located at LOCATION that appertains to the
4755 class type CLASS_TYPE that has not been properly placed after its
4756 class-key, in it class-specifier. */
4759 warn_misplaced_attr_for_class_type (location_t location
,
4762 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4764 auto_diagnostic_group d
;
4765 if (warning_at (location
, OPT_Wattributes
,
4766 "attribute ignored in declaration "
4767 "of %q#T", class_type
))
4769 "attribute for %q#T must follow the %qs keyword",
4770 class_type
, class_key_or_enum_as_string (class_type
));
4773 /* Make sure that a declaration with no declarator is well-formed, i.e.
4774 just declares a tagged type or anonymous union.
4776 Returns the type declared; or NULL_TREE if none. */
4779 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4780 bool explicit_type_instantiation_p
)
4782 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4783 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4784 /* If a class, struct, or enum type is declared by the DECLSPECS
4785 (i.e, if a class-specifier, enum-specifier, or non-typename
4786 elaborated-type-specifier appears in the DECLSPECS),
4787 DECLARED_TYPE is set to the corresponding type. */
4788 tree declared_type
= NULL_TREE
;
4789 bool error_p
= false;
4791 if (declspecs
->multiple_types_p
)
4792 error ("multiple types in one declaration");
4793 else if (declspecs
->redefined_builtin_type
)
4795 if (!in_system_header_at (input_location
))
4796 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4797 "redeclaration of C++ built-in type %qT",
4798 declspecs
->redefined_builtin_type
);
4803 && TYPE_P (declspecs
->type
)
4804 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4805 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4806 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4807 declared_type
= declspecs
->type
;
4808 else if (declspecs
->type
== error_mark_node
)
4811 if (type_uses_auto (declared_type
))
4813 error_at (declspecs
->locations
[ds_type_spec
],
4814 "%<auto%> can only be specified for variables "
4815 "or function declarations");
4816 return error_mark_node
;
4819 if (declared_type
&& !OVERLOAD_TYPE_P (declared_type
))
4820 declared_type
= NULL_TREE
;
4822 if (!declared_type
&& !saw_friend
&& !error_p
)
4823 permerror (input_location
, "declaration does not declare anything");
4824 /* Check for an anonymous union. */
4825 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4826 && TYPE_UNNAMED_P (declared_type
))
4828 /* 7/3 In a simple-declaration, the optional init-declarator-list
4829 can be omitted only when declaring a class (clause 9) or
4830 enumeration (7.2), that is, when the decl-specifier-seq contains
4831 either a class-specifier, an elaborated-type-specifier with
4832 a class-key (9.1), or an enum-specifier. In these cases and
4833 whenever a class-specifier or enum-specifier is present in the
4834 decl-specifier-seq, the identifiers in these specifiers are among
4835 the names being declared by the declaration (as class-name,
4836 enum-names, or enumerators, depending on the syntax). In such
4837 cases, and except for the declaration of an unnamed bit-field (9.6),
4838 the decl-specifier-seq shall introduce one or more names into the
4839 program, or shall redeclare a name introduced by a previous
4840 declaration. [Example:
4841 enum { }; // ill-formed
4842 typedef class { }; // ill-formed
4846 error ("missing type-name in typedef-declaration");
4849 /* Anonymous unions are objects, so they can have specifiers. */;
4850 SET_ANON_AGGR_TYPE_P (declared_type
);
4852 if (TREE_CODE (declared_type
) != UNION_TYPE
4853 && !in_system_header_at (input_location
))
4854 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4859 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
4860 error_at (declspecs
->locations
[ds_inline
],
4861 "%<inline%> can only be specified for functions");
4862 else if (decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4863 error_at (declspecs
->locations
[ds_virtual
],
4864 "%<virtual%> can only be specified for functions");
4866 && (!current_class_type
4867 || current_scope () != current_class_type
))
4868 error_at (declspecs
->locations
[ds_friend
],
4869 "%<friend%> can only be specified inside a class");
4870 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4871 error_at (declspecs
->locations
[ds_explicit
],
4872 "%<explicit%> can only be specified for constructors");
4873 else if (declspecs
->storage_class
)
4874 error_at (declspecs
->locations
[ds_storage_class
],
4875 "a storage class can only be specified for objects "
4877 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
4878 error_at (declspecs
->locations
[ds_const
],
4879 "%<const%> can only be specified for objects and "
4881 else if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
4882 error_at (declspecs
->locations
[ds_volatile
],
4883 "%<volatile%> can only be specified for objects and "
4885 else if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
4886 error_at (declspecs
->locations
[ds_restrict
],
4887 "%<__restrict%> can only be specified for objects and "
4889 else if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4890 error_at (declspecs
->locations
[ds_thread
],
4891 "%<__thread%> can only be specified for objects "
4893 else if (saw_typedef
)
4894 warning_at (declspecs
->locations
[ds_typedef
], 0,
4895 "%<typedef%> was ignored in this declaration");
4896 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4897 error_at (declspecs
->locations
[ds_constexpr
],
4898 "%<constexpr%> cannot be used for type declarations");
4901 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4904 if (!CLASS_TYPE_P (declared_type
)
4905 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4906 /* For a non-template class, use the name location. */
4907 loc
= location_of (declared_type
);
4909 /* For a template class (an explicit instantiation), use the
4910 current location. */
4911 loc
= input_location
;
4913 if (explicit_type_instantiation_p
)
4914 /* [dcl.attr.grammar]/4:
4916 No attribute-specifier-seq shall appertain to an explicit
4919 if (warning_at (loc
, OPT_Wattributes
,
4920 "attribute ignored in explicit instantiation %q#T",
4923 "no attribute can be applied to "
4924 "an explicit instantiation");
4927 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4930 return declared_type
;
4933 /* Called when a declaration is seen that contains no names to declare.
4934 If its type is a reference to a structure, union or enum inherited
4935 from a containing scope, shadow that tag name for the current scope
4936 with a forward reference.
4937 If its type defines a new named structure or union
4938 or defines an enum, it is valid but we need not do anything here.
4939 Otherwise, it is an error.
4941 C++: may have to grok the declspecs to learn about static,
4942 complain for anonymous unions.
4944 Returns the TYPE declared -- or NULL_TREE if none. */
4947 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4949 tree t
= check_tag_decl (declspecs
,
4950 /*explicit_type_instantiation_p=*/false);
4955 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4958 /* This is where the variables in an anonymous union are
4959 declared. An anonymous union declaration looks like:
4961 because there is no declarator after the union, the parser
4962 sends that declaration here. */
4963 if (ANON_AGGR_TYPE_P (t
))
4965 fixup_anonymous_aggr (t
);
4967 if (TYPE_FIELDS (t
))
4969 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4970 declspecs
, NORMAL
, 0, NULL
);
4971 finish_anon_union (decl
);
4978 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4981 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4982 const cp_declarator
*declarator
,
4983 bool is_template_arg
)
4987 enum decl_context context
4988 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4989 attrs
= type_specifiers
->attributes
;
4990 type_specifiers
->attributes
= NULL_TREE
;
4991 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4992 if (attrs
&& type
!= error_mark_node
)
4994 if (CLASS_TYPE_P (type
))
4995 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4996 "outside of definition", type
);
4997 else if (MAYBE_CLASS_TYPE_P (type
))
4998 /* A template type parameter or other dependent type. */
4999 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
5000 "type %qT without an associated declaration", type
);
5002 cplus_decl_attributes (&type
, attrs
, 0);
5007 /* Process a DECLARATOR for a function-scope variable declaration,
5008 namespace-scope variable declaration, or function declaration.
5009 (Function definitions go through start_function; class member
5010 declarations appearing in the body of the class go through
5011 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5012 If an error occurs, the error_mark_node is returned instead.
5014 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5015 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5016 for an explicitly defaulted function, or SD_DELETED for an explicitly
5017 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5018 implicitly initialized via a default constructor. ATTRIBUTES and
5019 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
5021 The scope represented by the context of the returned DECL is pushed
5022 (if it is not the global namespace) and is assigned to
5023 *PUSHED_SCOPE_P. The caller is then responsible for calling
5024 pop_scope on *PUSHED_SCOPE_P if it is set. */
5027 start_decl (const cp_declarator
*declarator
,
5028 cp_decl_specifier_seq
*declspecs
,
5031 tree prefix_attributes
,
5032 tree
*pushed_scope_p
)
5040 *pushed_scope_p
= NULL_TREE
;
5042 /* An object declared as __attribute__((deprecated)) suppresses
5043 warnings of uses of other deprecated items. */
5044 if (lookup_attribute ("deprecated", attributes
))
5045 deprecated_state
= DEPRECATED_SUPPRESS
;
5047 attributes
= chainon (attributes
, prefix_attributes
);
5049 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
5052 deprecated_state
= DEPRECATED_NORMAL
;
5054 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
5055 || decl
== error_mark_node
)
5056 return error_mark_node
;
5058 context
= CP_DECL_CONTEXT (decl
);
5059 if (context
!= global_namespace
)
5060 *pushed_scope_p
= push_scope (context
);
5062 /* Is it valid for this decl to have an initializer at all?
5063 If not, set INITIALIZED to zero, which will indirectly
5064 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
5066 && TREE_CODE (decl
) == TYPE_DECL
)
5068 error_at (DECL_SOURCE_LOCATION (decl
),
5069 "typedef %qD is initialized (use decltype instead)", decl
);
5070 return error_mark_node
;
5075 if (! toplevel_bindings_p ()
5076 && DECL_EXTERNAL (decl
))
5077 warning (0, "declaration of %q#D has %<extern%> and is initialized",
5079 DECL_EXTERNAL (decl
) = 0;
5080 if (toplevel_bindings_p ())
5081 TREE_STATIC (decl
) = 1;
5083 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
5085 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
5086 record_key_method_defined (decl
);
5088 /* If this is a typedef that names the class for linkage purposes
5089 (7.1.3p8), apply any attributes directly to the type. */
5090 if (TREE_CODE (decl
) == TYPE_DECL
5091 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
5092 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
5093 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
5097 /* Set attributes here so if duplicate decl, will have proper attributes. */
5098 cplus_decl_attributes (&decl
, attributes
, flags
);
5100 /* Dllimported symbols cannot be defined. Static data members (which
5101 can be initialized in-class and dllimported) go through grokfield,
5102 not here, so we don't need to exclude those decls when checking for
5104 if (initialized
&& DECL_DLLIMPORT_P (decl
))
5106 error_at (DECL_SOURCE_LOCATION (decl
),
5107 "definition of %q#D is marked %<dllimport%>", decl
);
5108 DECL_DLLIMPORT_P (decl
) = 0;
5111 /* If #pragma weak was used, mark the decl weak now. */
5112 if (!processing_template_decl
&& !DECL_DECOMPOSITION_P (decl
))
5113 maybe_apply_pragma_weak (decl
);
5115 if (TREE_CODE (decl
) == FUNCTION_DECL
5116 && DECL_DECLARED_INLINE_P (decl
)
5117 && DECL_UNINLINABLE (decl
)
5118 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
5119 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5120 "inline function %qD given attribute noinline", decl
);
5122 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
5124 bool this_tmpl
= (processing_template_decl
5125 > template_class_depth (context
));
5128 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
5129 if (field
== NULL_TREE
5130 || !(VAR_P (field
) || variable_template_p (field
)))
5131 error ("%q+#D is not a static data member of %q#T", decl
, context
);
5132 else if (variable_template_p (field
)
5133 && (DECL_LANG_SPECIFIC (decl
)
5134 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
5135 /* OK, specialization was already checked. */;
5136 else if (variable_template_p (field
) && !this_tmpl
)
5138 error_at (DECL_SOURCE_LOCATION (decl
),
5139 "non-member-template declaration of %qD", decl
);
5140 inform (DECL_SOURCE_LOCATION (field
), "does not match "
5141 "member template declaration here");
5142 return error_mark_node
;
5146 if (variable_template_p (field
))
5147 field
= DECL_TEMPLATE_RESULT (field
);
5149 if (DECL_CONTEXT (field
) != context
)
5151 if (!same_type_p (DECL_CONTEXT (field
), context
))
5152 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
5153 "to be defined as %<%T::%D%>",
5154 DECL_CONTEXT (field
), DECL_NAME (decl
),
5155 context
, DECL_NAME (decl
));
5156 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
5158 /* Static data member are tricky; an in-class initialization
5159 still doesn't provide a definition, so the in-class
5160 declaration will have DECL_EXTERNAL set, but will have an
5161 initialization. Thus, duplicate_decls won't warn
5162 about this situation, and so we check here. */
5163 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
5164 error ("duplicate initialization of %qD", decl
);
5165 field
= duplicate_decls (decl
, field
,
5166 /*newdecl_is_friend=*/false);
5167 if (field
== error_mark_node
)
5168 return error_mark_node
;
5175 tree field
= check_classfn (context
, decl
,
5177 ? current_template_parms
5179 if (field
&& field
!= error_mark_node
5180 && duplicate_decls (decl
, field
,
5181 /*newdecl_is_friend=*/false))
5185 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5186 DECL_IN_AGGR_P (decl
) = 0;
5187 /* Do not mark DECL as an explicit specialization if it was not
5188 already marked as an instantiation; a declaration should
5189 never be marked as a specialization unless we know what
5190 template is being specialized. */
5191 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
5193 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
5194 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5195 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
5196 && DECL_DECLARED_INLINE_P (decl
));
5198 DECL_COMDAT (decl
) = false;
5200 /* [temp.expl.spec] An explicit specialization of a static data
5201 member of a template is a definition if the declaration
5202 includes an initializer; otherwise, it is a declaration.
5204 We check for processing_specialization so this only applies
5205 to the new specialization syntax. */
5206 if (!initialized
&& processing_specialization
)
5207 DECL_EXTERNAL (decl
) = 1;
5210 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
5211 /* Aliases are definitions. */
5213 permerror (declarator
->id_loc
,
5214 "declaration of %q#D outside of class is not definition",
5218 was_public
= TREE_PUBLIC (decl
);
5220 /* Enter this declaration into the symbol table. Don't push the plain
5221 VAR_DECL for a variable template. */
5222 if (!template_parm_scope_p ()
5224 decl
= maybe_push_decl (decl
);
5226 if (processing_template_decl
)
5227 decl
= push_template_decl (decl
);
5228 if (decl
== error_mark_node
)
5229 return error_mark_node
;
5232 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
5233 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
5235 /* This is a const variable with implicit 'static'. Set
5236 DECL_THIS_STATIC so we can tell it from variables that are
5237 !TREE_PUBLIC because of the anonymous namespace. */
5238 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
5239 DECL_THIS_STATIC (decl
) = 1;
5242 if (current_function_decl
&& VAR_P (decl
)
5243 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
5246 if (CP_DECL_THREAD_LOCAL_P (decl
))
5247 error_at (DECL_SOURCE_LOCATION (decl
),
5248 "%qD declared %<thread_local%> in %<constexpr%> function",
5250 else if (TREE_STATIC (decl
))
5251 error_at (DECL_SOURCE_LOCATION (decl
),
5252 "%qD declared %<static%> in %<constexpr%> function", decl
);
5256 cp_function_chain
->invalid_constexpr
= true;
5259 if (!processing_template_decl
&& VAR_P (decl
))
5260 start_decl_1 (decl
, initialized
);
5265 /* Process the declaration of a variable DECL. INITIALIZED is true
5266 iff DECL is explicitly initialized. (INITIALIZED is false if the
5267 variable is initialized via an implicitly-called constructor.)
5268 This function must be called for ordinary variables (including, for
5269 example, implicit instantiations of templates), but must not be
5270 called for template declarations. */
5273 start_decl_1 (tree decl
, bool initialized
)
5277 bool aggregate_definition_p
;
5279 gcc_assert (!processing_template_decl
);
5281 if (error_operand_p (decl
))
5284 gcc_assert (VAR_P (decl
));
5286 type
= TREE_TYPE (decl
);
5287 complete_p
= COMPLETE_TYPE_P (type
);
5288 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
5290 /* If an explicit initializer is present, or if this is a definition
5291 of an aggregate, then we need a complete type at this point.
5292 (Scalars are always complete types, so there is nothing to
5293 check.) This code just sets COMPLETE_P; errors (if necessary)
5294 are issued below. */
5295 if ((initialized
|| aggregate_definition_p
)
5297 && COMPLETE_TYPE_P (complete_type (type
)))
5300 /* We will not yet have set TREE_READONLY on DECL if the type
5301 was "const", but incomplete, before this point. But, now, we
5302 have a complete type, so we can try again. */
5303 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
5307 /* Is it valid for this decl to have an initializer at all? */
5309 /* Don't allow initializations for incomplete types except for
5310 arrays which might be completed by the initialization. */
5312 ; /* A complete type is ok. */
5313 else if (type_uses_auto (type
))
5314 ; /* An auto type is ok. */
5315 else if (TREE_CODE (type
) != ARRAY_TYPE
)
5317 error ("variable %q#D has initializer but incomplete type", decl
);
5318 type
= TREE_TYPE (decl
) = error_mark_node
;
5320 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
5322 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
5323 error ("elements of array %q#D have incomplete type", decl
);
5324 /* else we already gave an error in start_decl. */
5327 else if (aggregate_definition_p
&& !complete_p
)
5329 if (type_uses_auto (type
))
5330 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (type
));
5333 error ("aggregate %q#D has incomplete type and cannot be defined",
5335 /* Change the type so that assemble_variable will give
5336 DECL an rtl we can live with: (mem (const_int 0)). */
5337 type
= TREE_TYPE (decl
) = error_mark_node
;
5341 /* Create a new scope to hold this declaration if necessary.
5342 Whether or not a new scope is necessary cannot be determined
5343 until after the type has been completed; if the type is a
5344 specialization of a class template it is not until after
5345 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5346 will be set correctly. */
5347 maybe_push_cleanup_level (type
);
5350 /* Handle initialization of references. DECL, TYPE, and INIT have the
5351 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5352 but will be set to a new CLEANUP_STMT if a temporary is created
5353 that must be destroyed subsequently.
5355 Returns an initializer expression to use to initialize DECL, or
5356 NULL if the initialization can be performed statically.
5358 Quotes on semantics can be found in ARM 8.4.3. */
5361 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
5363 if (init
== NULL_TREE
)
5365 if ((DECL_LANG_SPECIFIC (decl
) == 0
5366 || DECL_IN_AGGR_P (decl
) == 0)
5367 && ! DECL_THIS_EXTERN (decl
))
5368 error_at (DECL_SOURCE_LOCATION (decl
),
5369 "%qD declared as reference but not initialized", decl
);
5373 if (TREE_CODE (init
) == TREE_LIST
)
5374 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5375 tf_warning_or_error
);
5377 tree ttype
= TREE_TYPE (type
);
5378 if (TREE_CODE (ttype
) != ARRAY_TYPE
5379 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
5380 /* Note: default conversion is only called in very special cases. */
5381 init
= decay_conversion (init
, tf_warning_or_error
);
5383 /* check_initializer handles this for non-reference variables, but for
5384 references we need to do it here or the initializer will get the
5385 incomplete array type and confuse later calls to
5386 cp_complete_array_type. */
5387 if (TREE_CODE (ttype
) == ARRAY_TYPE
5388 && TYPE_DOMAIN (ttype
) == NULL_TREE
5389 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
5390 || TREE_CODE (init
) == STRING_CST
))
5392 cp_complete_array_type (&ttype
, init
, false);
5393 if (ttype
!= TREE_TYPE (type
))
5394 type
= cp_build_reference_type (ttype
, TYPE_REF_IS_RVALUE (type
));
5397 /* Convert INIT to the reference type TYPE. This may involve the
5398 creation of a temporary, whose lifetime must be the same as that
5399 of the reference. If so, a DECL_EXPR for the temporary will be
5400 added just after the DECL_EXPR for DECL. That's why we don't set
5401 DECL_INITIAL for local references (instead assigning to them
5402 explicitly); we need to allow the temporary to be initialized
5404 return initialize_reference (type
, init
, flags
,
5405 tf_warning_or_error
);
5408 /* Designated initializers in arrays are not supported in GNU C++.
5409 The parser cannot detect this error since it does not know whether
5410 a given brace-enclosed initializer is for a class type or for an
5411 array. This function checks that CE does not use a designated
5412 initializer. If it does, an error is issued. Returns true if CE
5413 is valid, i.e., does not have a designated initializer. */
5416 check_array_designated_initializer (constructor_elt
*ce
,
5417 unsigned HOST_WIDE_INT index
)
5419 /* Designated initializers for array elements are not supported. */
5422 /* The parser only allows identifiers as designated
5424 if (ce
->index
== error_mark_node
)
5426 error ("name used in a GNU-style designated "
5427 "initializer for an array");
5430 else if (identifier_p (ce
->index
))
5432 error ("name %qD used in a GNU-style designated "
5433 "initializer for an array", ce
->index
);
5437 tree ce_index
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
5440 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index
))
5441 && (TREE_CODE (ce_index
= fold_non_dependent_expr (ce_index
))
5444 /* A C99 designator is OK if it matches the current index. */
5445 if (wi::to_wide (ce_index
) == index
)
5447 ce
->index
= ce_index
;
5451 sorry ("non-trivial designated initializers not supported");
5454 error ("C99 designator %qE is not an integral constant-expression",
5463 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5464 array until we finish parsing the initializer. If that's the
5465 situation we're in, update DECL accordingly. */
5468 maybe_deduce_size_from_array_init (tree decl
, tree init
)
5470 tree type
= TREE_TYPE (decl
);
5472 if (TREE_CODE (type
) == ARRAY_TYPE
5473 && TYPE_DOMAIN (type
) == NULL_TREE
5474 && TREE_CODE (decl
) != TYPE_DECL
)
5476 /* do_default is really a C-ism to deal with tentative definitions.
5477 But let's leave it here to ease the eventual merge. */
5478 int do_default
= !DECL_EXTERNAL (decl
);
5479 tree initializer
= init
? init
: DECL_INITIAL (decl
);
5482 /* Check that there are no designated initializers in INIT, as
5483 those are not supported in GNU C++, and as the middle-end
5484 will crash if presented with a non-numeric designated
5486 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
5488 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
5489 constructor_elt
*ce
;
5491 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
5493 if (instantiation_dependent_expression_p (ce
->index
))
5495 if (!check_array_designated_initializer (ce
, i
))
5501 TREE_TYPE (decl
) = error_mark_node
;
5504 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
5508 error_at (cp_expr_loc_or_loc (initializer
,
5509 DECL_SOURCE_LOCATION (decl
)),
5510 "initializer fails to determine size of %qD", decl
);
5512 else if (failure
== 2)
5516 error_at (DECL_SOURCE_LOCATION (decl
),
5517 "array size missing in %qD", decl
);
5519 /* If a `static' var's size isn't known, make it extern as
5520 well as static, so it does not get allocated. If it's not
5521 `static', then don't mark it extern; finish_incomplete_decl
5522 will give it a default size and it will get allocated. */
5523 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
5524 DECL_EXTERNAL (decl
) = 1;
5526 else if (failure
== 3)
5528 error_at (DECL_SOURCE_LOCATION (decl
),
5529 "zero-size array %qD", decl
);
5533 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
5535 relayout_decl (decl
);
5539 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5540 any appropriate error messages regarding the layout. */
5543 layout_var_decl (tree decl
)
5547 type
= TREE_TYPE (decl
);
5548 if (type
== error_mark_node
)
5551 /* If we haven't already laid out this declaration, do so now.
5552 Note that we must not call complete type for an external object
5553 because it's type might involve templates that we are not
5554 supposed to instantiate yet. (And it's perfectly valid to say
5555 `extern X x' for some incomplete type `X'.) */
5556 if (!DECL_EXTERNAL (decl
))
5557 complete_type (type
);
5558 if (!DECL_SIZE (decl
)
5559 && TREE_TYPE (decl
) != error_mark_node
5560 && complete_or_array_type_p (type
))
5561 layout_decl (decl
, 0);
5563 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
5565 /* An automatic variable with an incomplete type: that is an error.
5566 Don't talk about array types here, since we took care of that
5567 message in grokdeclarator. */
5568 error_at (DECL_SOURCE_LOCATION (decl
),
5569 "storage size of %qD isn%'t known", decl
);
5570 TREE_TYPE (decl
) = error_mark_node
;
5573 /* Keep this code around in case we later want to control debug info
5574 based on whether a type is "used". (jason 1999-11-11) */
5576 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
5577 /* Let debugger know it should output info for this type. */
5578 note_debug_info_needed (ttype
);
5580 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
5581 note_debug_info_needed (DECL_CONTEXT (decl
));
5584 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
5585 && DECL_SIZE (decl
) != NULL_TREE
5586 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
5588 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
5589 constant_expression_warning (DECL_SIZE (decl
));
5592 error_at (DECL_SOURCE_LOCATION (decl
),
5593 "storage size of %qD isn%'t constant", decl
);
5594 TREE_TYPE (decl
) = error_mark_node
;
5599 /* If a local static variable is declared in an inline function, or if
5600 we have a weak definition, we must endeavor to create only one
5601 instance of the variable at link-time. */
5604 maybe_commonize_var (tree decl
)
5606 /* Don't mess with __FUNCTION__ and similar. */
5607 if (DECL_ARTIFICIAL (decl
))
5610 /* Static data in a function with comdat linkage also has comdat
5612 if ((TREE_STATIC (decl
)
5613 && DECL_FUNCTION_SCOPE_P (decl
)
5614 && vague_linkage_p (DECL_CONTEXT (decl
)))
5615 || (TREE_PUBLIC (decl
) && DECL_INLINE_VAR_P (decl
)))
5619 /* With weak symbols, we simply make the variable COMDAT;
5620 that will cause copies in multiple translations units to
5622 comdat_linkage (decl
);
5626 if (DECL_INITIAL (decl
) == NULL_TREE
5627 || DECL_INITIAL (decl
) == error_mark_node
)
5629 /* Without weak symbols, we can use COMMON to merge
5630 uninitialized variables. */
5631 TREE_PUBLIC (decl
) = 1;
5632 DECL_COMMON (decl
) = 1;
5636 /* While for initialized variables, we must use internal
5637 linkage -- which means that multiple copies will not
5639 TREE_PUBLIC (decl
) = 0;
5640 DECL_COMMON (decl
) = 0;
5641 DECL_INTERFACE_KNOWN (decl
) = 1;
5643 if (DECL_INLINE_VAR_P (decl
))
5644 msg
= G_("sorry: semantics of inline variable "
5645 "%q#D are wrong (you%'ll wind up with "
5646 "multiple copies)");
5648 msg
= G_("sorry: semantics of inline function "
5649 "static data %q#D are wrong (you%'ll wind "
5650 "up with multiple copies)");
5651 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5653 inform (DECL_SOURCE_LOCATION (decl
),
5654 "you can work around this by removing the initializer");
5660 /* Issue an error message if DECL is an uninitialized const variable.
5661 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
5662 context from potential_constant_expression. Returns true if all is well,
5666 check_for_uninitialized_const_var (tree decl
, bool constexpr_context_p
,
5667 tsubst_flags_t complain
)
5669 tree type
= strip_array_types (TREE_TYPE (decl
));
5671 /* ``Unless explicitly declared extern, a const object does not have
5672 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5675 && !TYPE_REF_P (type
)
5676 && (constexpr_context_p
5677 || CP_TYPE_CONST_P (type
) || var_in_constexpr_fn (decl
))
5678 && !DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
5680 tree field
= default_init_uninitialized_part (type
);
5684 if (!constexpr_context_p
)
5686 if (CP_TYPE_CONST_P (type
))
5688 if (complain
& tf_error
)
5689 permerror (DECL_SOURCE_LOCATION (decl
),
5690 "uninitialized const %qD", decl
);
5694 if (!is_instantiation_of_constexpr (current_function_decl
)
5695 && (complain
& tf_error
))
5696 error_at (DECL_SOURCE_LOCATION (decl
),
5697 "uninitialized variable %qD in %<constexpr%> "
5699 cp_function_chain
->invalid_constexpr
= true;
5702 else if (complain
& tf_error
)
5703 error_at (DECL_SOURCE_LOCATION (decl
),
5704 "uninitialized variable %qD in %<constexpr%> context",
5707 if (CLASS_TYPE_P (type
) && (complain
& tf_error
))
5709 tree defaulted_ctor
;
5711 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5712 "%q#T has no user-provided default constructor", type
);
5713 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5715 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5716 "constructor is not user-provided because it is "
5717 "explicitly defaulted in the class body");
5718 inform (DECL_SOURCE_LOCATION (field
),
5719 "and the implicitly-defined constructor does not "
5720 "initialize %q#D", field
);
5729 /* Structure holding the current initializer being processed by reshape_init.
5730 CUR is a pointer to the current element being processed, END is a pointer
5731 after the last element present in the initializer. */
5734 constructor_elt
*cur
;
5735 constructor_elt
*end
;
5738 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5740 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5741 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5742 initialized. If there are no more such fields, the return value
5746 next_initializable_field (tree field
)
5749 && (TREE_CODE (field
) != FIELD_DECL
5750 || DECL_UNNAMED_BIT_FIELD (field
)
5751 || (DECL_ARTIFICIAL (field
)
5752 && !(cxx_dialect
>= cxx17
&& DECL_FIELD_IS_BASE (field
)))))
5753 field
= DECL_CHAIN (field
);
5758 /* Return true for [dcl.init.list] direct-list-initialization from
5759 single element of enumeration with a fixed underlying type. */
5762 is_direct_enum_init (tree type
, tree init
)
5764 if (cxx_dialect
>= cxx17
5765 && TREE_CODE (type
) == ENUMERAL_TYPE
5766 && ENUM_FIXED_UNDERLYING_TYPE_P (type
)
5767 && TREE_CODE (init
) == CONSTRUCTOR
5768 && CONSTRUCTOR_IS_DIRECT_INIT (init
)
5769 && CONSTRUCTOR_NELTS (init
) == 1)
5774 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5775 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5776 INTEGER_CST representing the size of the array minus one (the maximum index),
5777 or NULL_TREE if the array was declared without specifying the size. D is
5778 the iterator within the constructor. */
5781 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5782 tsubst_flags_t complain
)
5785 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5786 unsigned HOST_WIDE_INT max_index_cst
= 0;
5787 unsigned HOST_WIDE_INT index
;
5789 /* The initializer for an array is always a CONSTRUCTOR. */
5790 new_init
= build_constructor (init_list_type_node
, NULL
);
5794 /* Minus 1 is used for zero sized arrays. */
5795 if (integer_all_onesp (max_index
))
5798 if (tree_fits_uhwi_p (max_index
))
5799 max_index_cst
= tree_to_uhwi (max_index
);
5800 /* sizetype is sign extended, not zero extended. */
5802 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5805 /* Set to the index of the last element with a non-zero initializer.
5806 Zero initializers for elements past this one can be dropped. */
5807 unsigned HOST_WIDE_INT last_nonzero
= -1;
5808 /* Loop until there are no more initializers. */
5810 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5814 constructor_elt
*old_cur
= d
->cur
;
5816 check_array_designated_initializer (d
->cur
, index
);
5817 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5819 if (elt_init
== error_mark_node
)
5820 return error_mark_node
;
5821 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5822 size_int (index
), elt_init
);
5823 if (!TREE_CONSTANT (elt_init
))
5824 TREE_CONSTANT (new_init
) = false;
5826 /* Pointers initialized to strings must be treated as non-zero
5827 even if the string is empty. */
5828 tree init_type
= TREE_TYPE (elt_init
);
5829 if ((POINTER_TYPE_P (elt_type
) != POINTER_TYPE_P (init_type
))
5830 || !initializer_zerop (elt_init
))
5831 last_nonzero
= index
;
5833 /* This can happen with an invalid initializer (c++/54501). */
5834 if (d
->cur
== old_cur
&& !sized_array_p
)
5838 if (sized_array_p
&& trivial_type_p (elt_type
))
5840 /* Strip trailing zero-initializers from an array of a trivial
5841 type of known size. They are redundant and get in the way
5842 of telling them apart from those with implicit zero value. */
5843 unsigned HOST_WIDE_INT nelts
= CONSTRUCTOR_NELTS (new_init
);
5844 if (last_nonzero
> nelts
)
5846 else if (last_nonzero
< nelts
- 1)
5847 nelts
= last_nonzero
+ 1;
5849 vec_safe_truncate (CONSTRUCTOR_ELTS (new_init
), nelts
);
5855 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5856 Parameters are the same of reshape_init_r. */
5859 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5861 tree max_index
= NULL_TREE
;
5863 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5865 if (TYPE_DOMAIN (type
))
5866 max_index
= array_type_nelts (type
);
5868 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5871 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5872 Parameters are the same of reshape_init_r. */
5875 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5877 tree max_index
= NULL_TREE
;
5879 gcc_assert (VECTOR_TYPE_P (type
));
5881 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5883 tree value
= d
->cur
->value
;
5884 if (!same_type_p (TREE_TYPE (value
), type
))
5886 if (complain
& tf_error
)
5887 error ("invalid type %qT as initializer for a vector of type %qT",
5888 TREE_TYPE (d
->cur
->value
), type
);
5889 value
= error_mark_node
;
5895 /* For a vector, we initialize it as an array of the appropriate size. */
5896 if (VECTOR_TYPE_P (type
))
5897 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5899 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5902 /* Subroutine of reshape_init_r, processes the initializers for classes
5903 or union. Parameters are the same of reshape_init_r. */
5906 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5907 tsubst_flags_t complain
)
5912 gcc_assert (CLASS_TYPE_P (type
));
5914 /* The initializer for a class is always a CONSTRUCTOR. */
5915 new_init
= build_constructor (init_list_type_node
, NULL
);
5916 field
= next_initializable_field (TYPE_FIELDS (type
));
5922 An initializer for an aggregate member that is an
5923 empty class shall have the form of an empty
5924 initializer-list {}. */
5925 if (!first_initializer_p
)
5927 if (complain
& tf_error
)
5928 error ("initializer for %qT must be brace-enclosed", type
);
5929 return error_mark_node
;
5934 /* Loop through the initializable fields, gathering initializers. */
5935 while (d
->cur
!= d
->end
)
5938 constructor_elt
*old_cur
= d
->cur
;
5940 /* Handle designated initializers, as an extension. */
5943 if (d
->cur
->index
== error_mark_node
)
5944 return error_mark_node
;
5946 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5948 /* We already reshaped this. */
5949 if (field
!= d
->cur
->index
)
5951 tree id
= DECL_NAME (d
->cur
->index
);
5953 gcc_checking_assert (d
->cur
->index
5954 == get_class_binding (type
, id
, false));
5955 field
= d
->cur
->index
;
5958 else if (TREE_CODE (d
->cur
->index
) == IDENTIFIER_NODE
)
5959 field
= get_class_binding (type
, d
->cur
->index
, false);
5962 if (complain
& tf_error
)
5963 error ("%<[%E] =%> used in a GNU-style designated initializer"
5964 " for class %qT", d
->cur
->index
, type
);
5965 return error_mark_node
;
5968 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5970 if (complain
& tf_error
)
5971 error ("%qT has no non-static data member named %qD", type
,
5973 return error_mark_node
;
5977 /* If we processed all the member of the class, we are done. */
5981 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5982 /*first_initializer_p=*/false, complain
);
5983 if (field_init
== error_mark_node
)
5984 return error_mark_node
;
5986 if (d
->cur
== old_cur
&& d
->cur
->index
)
5988 /* This can happen with an invalid initializer for a flexible
5989 array member (c++/54441). */
5990 if (complain
& tf_error
)
5991 error ("invalid initializer for %q#D", field
);
5992 return error_mark_node
;
5995 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5999 When a union is initialized with a brace-enclosed
6000 initializer, the braces shall only contain an
6001 initializer for the first member of the union. */
6002 if (TREE_CODE (type
) == UNION_TYPE
)
6005 field
= next_initializable_field (DECL_CHAIN (field
));
6011 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
6012 designators are not valid; either complain or return true to indicate
6013 that reshape_init_r should return error_mark_node. */
6016 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
6020 if (complain
& tf_error
)
6021 error ("C99 designator %qE outside aggregate initializer",
6029 /* Subroutine of reshape_init, which processes a single initializer (part of
6030 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
6031 iterator within the CONSTRUCTOR which points to the initializer to process.
6032 FIRST_INITIALIZER_P is true if this is the first initializer of the
6033 outermost CONSTRUCTOR node. */
6036 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
6037 tsubst_flags_t complain
)
6039 tree init
= d
->cur
->value
;
6041 if (error_operand_p (init
))
6042 return error_mark_node
;
6044 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
6045 && has_designator_problem (d
, complain
))
6046 return error_mark_node
;
6048 tree stripped_init
= tree_strip_any_location_wrapper (init
);
6050 if (TREE_CODE (type
) == COMPLEX_TYPE
)
6052 /* A complex type can be initialized from one or two initializers,
6053 but braces are not elided. */
6055 if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init
))
6057 if (CONSTRUCTOR_NELTS (stripped_init
) > 2)
6059 if (complain
& tf_error
)
6060 error ("too many initializers for %qT", type
);
6062 return error_mark_node
;
6065 else if (first_initializer_p
&& d
->cur
!= d
->end
)
6067 vec
<constructor_elt
, va_gc
> *v
= 0;
6068 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
6069 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
6070 if (has_designator_problem (d
, complain
))
6071 return error_mark_node
;
6073 init
= build_constructor (init_list_type_node
, v
);
6078 /* A non-aggregate type is always initialized with a single
6080 if (!CP_AGGREGATE_TYPE_P (type
))
6082 /* It is invalid to initialize a non-aggregate type with a
6083 brace-enclosed initializer before C++0x.
6084 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
6085 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
6086 a CONSTRUCTOR (with a record type). */
6087 if (TREE_CODE (stripped_init
) == CONSTRUCTOR
6088 /* Don't complain about a capture-init. */
6089 && !CONSTRUCTOR_IS_DIRECT_INIT (stripped_init
)
6090 && BRACE_ENCLOSED_INITIALIZER_P (stripped_init
)) /* p7626.C */
6092 if (SCALAR_TYPE_P (type
))
6094 if (cxx_dialect
< cxx11
)
6096 if (complain
& tf_error
)
6097 error ("braces around scalar initializer for type %qT",
6099 init
= error_mark_node
;
6101 else if (first_initializer_p
6102 || (CONSTRUCTOR_NELTS (stripped_init
) > 0
6103 && (BRACE_ENCLOSED_INITIALIZER_P
6104 (CONSTRUCTOR_ELT (stripped_init
,0)->value
))))
6106 if (complain
& tf_error
)
6107 error ("too many braces around scalar initializer"
6108 "for type %qT", type
);
6109 init
= error_mark_node
;
6113 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6120 /* "If T is a class type and the initializer list has a single element of
6121 type cv U, where U is T or a class derived from T, the object is
6122 initialized from that element." Even if T is an aggregate. */
6123 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
6124 && first_initializer_p
6125 && d
->end
- d
->cur
== 1
6126 && reference_related_p (type
, TREE_TYPE (init
)))
6134 All implicit type conversions (clause _conv_) are considered when
6135 initializing the aggregate member with an initializer from an
6136 initializer-list. If the initializer can initialize a member,
6137 the member is initialized. Otherwise, if the member is itself a
6138 non-empty subaggregate, brace elision is assumed and the
6139 initializer is considered for the initialization of the first
6140 member of the subaggregate. */
6141 if (TREE_CODE (init
) != CONSTRUCTOR
6142 /* But don't try this for the first initializer, since that would be
6143 looking through the outermost braces; A a2 = { a1 }; is not a
6144 valid aggregate initialization. */
6145 && !first_initializer_p
6146 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
6147 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
6154 /* [dcl.init.string]
6156 A char array (whether plain char, signed char, or unsigned char)
6157 can be initialized by a string-literal (optionally enclosed in
6158 braces); a wchar_t array can be initialized by a wide
6159 string-literal (optionally enclosed in braces). */
6160 if (TREE_CODE (type
) == ARRAY_TYPE
6161 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
6163 tree str_init
= init
;
6164 tree stripped_str_init
= stripped_init
;
6166 /* Strip one level of braces if and only if they enclose a single
6167 element (as allowed by [dcl.init.string]). */
6168 if (!first_initializer_p
6169 && TREE_CODE (stripped_str_init
) == CONSTRUCTOR
6170 && CONSTRUCTOR_NELTS (stripped_str_init
) == 1)
6172 str_init
= (*CONSTRUCTOR_ELTS (stripped_str_init
))[0].value
;
6173 stripped_str_init
= tree_strip_any_location_wrapper (str_init
);
6176 /* If it's a string literal, then it's the initializer for the array
6177 as a whole. Otherwise, continue with normal initialization for
6178 array types (one value per array element). */
6179 if (TREE_CODE (stripped_str_init
) == STRING_CST
)
6181 if (has_designator_problem (d
, complain
))
6182 return error_mark_node
;
6188 /* The following cases are about aggregates. If we are not within a full
6189 initializer already, and there is not a CONSTRUCTOR, it means that there
6190 is a missing set of braces (that is, we are processing the case for
6191 which reshape_init exists). */
6192 if (!first_initializer_p
)
6194 if (TREE_CODE (stripped_init
) == CONSTRUCTOR
)
6196 tree init_type
= TREE_TYPE (init
);
6197 if (init_type
&& TYPE_PTRMEMFUNC_P (init_type
))
6198 /* There is no need to call reshape_init for pointer-to-member
6199 function initializers, as they are always constructed correctly
6200 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
6201 which is missing outermost braces. We should warn below, and
6202 one of the routines below will wrap it in additional { }. */;
6203 /* For a nested compound literal, there is no need to reshape since
6204 we called reshape_init in finish_compound_literal, before calling
6206 else if (COMPOUND_LITERAL_P (stripped_init
)
6207 /* Similarly, a CONSTRUCTOR of the target's type is a
6208 previously digested initializer. */
6209 || same_type_ignoring_top_level_qualifiers_p (type
,
6213 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (stripped_init
));
6218 /* Something that hasn't been reshaped yet. */
6220 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (stripped_init
));
6221 return reshape_init (type
, init
, complain
);
6225 if (complain
& tf_warning
)
6226 warning (OPT_Wmissing_braces
,
6227 "missing braces around initializer for %qT",
6231 /* Dispatch to specialized routines. */
6232 if (CLASS_TYPE_P (type
))
6233 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
6234 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6235 return reshape_init_array (type
, d
, complain
);
6236 else if (VECTOR_TYPE_P (type
))
6237 return reshape_init_vector (type
, d
, complain
);
6242 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
6243 brace-enclosed aggregate initializer.
6245 INIT is the CONSTRUCTOR containing the list of initializers describing
6246 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
6247 It may not presently match the shape of the TYPE; for example:
6249 struct S { int a; int b; };
6250 struct S a[] = { 1, 2, 3, 4 };
6252 Here INIT will hold a vector of four elements, rather than a
6253 vector of two elements, each itself a vector of two elements. This
6254 routine transforms INIT from the former form into the latter. The
6255 revised CONSTRUCTOR node is returned. */
6258 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
6260 vec
<constructor_elt
, va_gc
> *v
;
6264 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
6266 v
= CONSTRUCTOR_ELTS (init
);
6268 /* An empty constructor does not need reshaping, and it is always a valid
6270 if (vec_safe_is_empty (v
))
6273 /* Handle [dcl.init.list] direct-list-initialization from
6274 single element of enumeration with a fixed underlying type. */
6275 if (is_direct_enum_init (type
, init
))
6277 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
6278 type
= cv_unqualified (type
);
6279 if (check_narrowing (ENUM_UNDERLYING_TYPE (type
), elt
, complain
))
6281 warning_sentinel
w (warn_useless_cast
);
6282 warning_sentinel
w2 (warn_ignored_qualifiers
);
6283 return cp_build_c_cast (type
, elt
, tf_warning_or_error
);
6286 return error_mark_node
;
6289 /* Recurse on this CONSTRUCTOR. */
6291 d
.end
= d
.cur
+ v
->length ();
6293 new_init
= reshape_init_r (type
, &d
, true, complain
);
6294 if (new_init
== error_mark_node
)
6295 return error_mark_node
;
6297 /* Make sure all the element of the constructor were used. Otherwise,
6298 issue an error about exceeding initializers. */
6301 if (complain
& tf_error
)
6302 error ("too many initializers for %qT", type
);
6303 return error_mark_node
;
6306 if (CONSTRUCTOR_IS_DIRECT_INIT (init
)
6307 && BRACE_ENCLOSED_INITIALIZER_P (new_init
))
6308 CONSTRUCTOR_IS_DIRECT_INIT (new_init
) = true;
6309 if (CONSTRUCTOR_IS_DESIGNATED_INIT (init
)
6310 && BRACE_ENCLOSED_INITIALIZER_P (new_init
))
6311 CONSTRUCTOR_IS_DESIGNATED_INIT (new_init
) = true;
6316 /* Verify array initializer. Returns true if errors have been reported. */
6319 check_array_initializer (tree decl
, tree type
, tree init
)
6321 tree element_type
= TREE_TYPE (type
);
6323 /* The array type itself need not be complete, because the
6324 initializer may tell us how many elements are in the array.
6325 But, the elements of the array must be complete. */
6326 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
6329 error_at (DECL_SOURCE_LOCATION (decl
),
6330 "elements of array %q#D have incomplete type", decl
);
6332 error ("elements of array %q#T have incomplete type", type
);
6335 /* A compound literal can't have variable size. */
6337 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
6338 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
6340 error ("variable-sized compound literal");
6346 /* Subroutine of check_initializer; args are passed down from that function.
6347 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
6350 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
6353 gcc_assert (stmts_are_full_exprs_p ());
6354 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
6357 /* Verify INIT (the initializer for DECL), and record the
6358 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
6359 grok_reference_init.
6361 If the return value is non-NULL, it is an expression that must be
6362 evaluated dynamically to initialize DECL. */
6365 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
6367 tree type
= TREE_TYPE (decl
);
6368 tree init_code
= NULL
;
6371 /* Things that are going to be initialized need to have complete
6373 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
6375 if (DECL_HAS_VALUE_EXPR_P (decl
))
6377 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
6378 it doesn't have storage to be initialized. */
6379 gcc_assert (init
== NULL_TREE
);
6383 if (type
== error_mark_node
)
6384 /* We will have already complained. */
6387 if (TREE_CODE (type
) == ARRAY_TYPE
)
6389 if (check_array_initializer (decl
, type
, init
))
6392 else if (!COMPLETE_TYPE_P (type
))
6394 error_at (DECL_SOURCE_LOCATION (decl
),
6395 "%q#D has incomplete type", decl
);
6396 TREE_TYPE (decl
) = error_mark_node
;
6400 /* There is no way to make a variable-sized class type in GNU C++. */
6401 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
6403 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
6405 int init_len
= CONSTRUCTOR_NELTS (init
);
6406 if (SCALAR_TYPE_P (type
))
6410 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6411 init
= build_zero_init (type
, NULL_TREE
, false);
6413 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
6415 error_at (cp_expr_loc_or_loc (init
, DECL_SOURCE_LOCATION (decl
)),
6416 "scalar object %qD requires one element in "
6417 "initializer", decl
);
6418 TREE_TYPE (decl
) = error_mark_node
;
6424 if (TREE_CODE (decl
) == CONST_DECL
)
6426 gcc_assert (!TYPE_REF_P (type
));
6428 DECL_INITIAL (decl
) = init
;
6430 gcc_assert (init
!= NULL_TREE
);
6433 else if (!init
&& DECL_REALLY_EXTERN (decl
))
6435 else if (init
|| type_build_ctor_call (type
)
6436 || TYPE_REF_P (type
))
6438 if (TYPE_REF_P (type
))
6440 init
= grok_reference_init (decl
, type
, init
, flags
);
6441 flags
|= LOOKUP_ALREADY_DIGESTED
;
6444 check_for_uninitialized_const_var (decl
, /*constexpr_context_p=*/false,
6445 tf_warning_or_error
);
6446 /* Do not reshape constructors of vectors (they don't need to be
6448 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
6450 if (is_std_init_list (type
))
6452 init
= perform_implicit_conversion (type
, init
,
6453 tf_warning_or_error
);
6454 flags
|= LOOKUP_ALREADY_DIGESTED
;
6456 else if (TYPE_NON_AGGREGATE_CLASS (type
))
6458 /* Don't reshape if the class has constructors. */
6459 if (cxx_dialect
== cxx98
)
6460 error_at (cp_expr_loc_or_loc (init
, DECL_SOURCE_LOCATION (decl
)),
6461 "in C++98 %qD must be initialized by "
6462 "constructor, not by %<{...}%>",
6465 else if (VECTOR_TYPE_P (type
) && TYPE_VECTOR_OPAQUE (type
))
6467 error ("opaque vector types cannot be initialized");
6468 init
= error_mark_node
;
6472 init
= reshape_init (type
, init
, tf_warning_or_error
);
6473 flags
|= LOOKUP_NO_NARROWING
;
6476 else if (TREE_CODE (init
) == TREE_LIST
6477 && TREE_TYPE (init
) != unknown_type_node
6478 && !MAYBE_CLASS_TYPE_P (type
))
6480 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6482 /* We get here with code like `int a (2);' */
6483 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6484 tf_warning_or_error
);
6487 /* If DECL has an array type without a specific bound, deduce the
6488 array size from the initializer. */
6489 maybe_deduce_size_from_array_init (decl
, init
);
6490 type
= TREE_TYPE (decl
);
6491 if (type
== error_mark_node
)
6494 if (((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
6495 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
6496 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
6497 && CP_AGGREGATE_TYPE_P (type
)
6498 && (CLASS_TYPE_P (type
)
6499 || !TYPE_NEEDS_CONSTRUCTING (type
)
6500 || type_has_extended_temps (type
))))
6501 || (DECL_DECOMPOSITION_P (decl
) && TREE_CODE (type
) == ARRAY_TYPE
))
6503 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
6505 /* A constructor call is a non-trivial initializer even if
6506 it isn't explicitly written. */
6507 if (TREE_SIDE_EFFECTS (init_code
))
6508 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
6510 /* If this is a constexpr initializer, expand_default_init will
6511 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6512 case, pull the initializer back out and pass it down into
6513 store_init_value. */
6514 while (TREE_CODE (init_code
) == EXPR_STMT
6515 || TREE_CODE (init_code
) == CONVERT_EXPR
)
6516 init_code
= TREE_OPERAND (init_code
, 0);
6517 if (TREE_CODE (init_code
) == INIT_EXPR
)
6519 init
= TREE_OPERAND (init_code
, 1);
6520 init_code
= NULL_TREE
;
6521 /* Don't call digest_init; it's unnecessary and will complain
6522 about aggregate initialization of non-aggregate classes. */
6523 flags
|= LOOKUP_ALREADY_DIGESTED
;
6525 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
6527 /* Declared constexpr, but no suitable initializer; massage
6528 init appropriately so we can pass it into store_init_value
6530 if (CLASS_TYPE_P (type
)
6531 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
6533 init
= build_functional_cast (type
, init
, tf_none
);
6534 if (TREE_CODE (init
) == TARGET_EXPR
)
6535 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
6537 init_code
= NULL_TREE
;
6543 if (init
&& TREE_CODE (init
) != TREE_VEC
)
6545 /* In aggregate initialization of a variable, each element
6546 initialization is a full-expression because there is no
6547 enclosing expression. */
6548 gcc_assert (stmts_are_full_exprs_p ());
6550 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
6552 if (DECL_INITIAL (decl
)
6553 && TREE_CODE (DECL_INITIAL (decl
)) == CONSTRUCTOR
6554 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (DECL_INITIAL (decl
))))
6556 tree elt
= CONSTRUCTOR_ELTS (DECL_INITIAL (decl
))->last ().value
;
6557 if (TREE_CODE (TREE_TYPE (elt
)) == ARRAY_TYPE
6558 && TYPE_SIZE (TREE_TYPE (elt
)) == NULL_TREE
)
6559 cp_complete_array_type (&TREE_TYPE (elt
), elt
, false);
6562 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
6563 && DECL_INITIAL (decl
)
6564 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
6565 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
6566 warning_at (cp_expr_loc_or_loc (DECL_INITIAL (decl
),
6567 DECL_SOURCE_LOCATION (decl
)),
6568 0, "array %qD initialized by parenthesized "
6569 "string literal %qE",
6570 decl
, DECL_INITIAL (decl
));
6576 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
6577 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
6578 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
6579 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
6582 check_for_uninitialized_const_var (decl
, /*constexpr_context_p=*/false,
6583 tf_warning_or_error
);
6586 if (init
&& init
!= error_mark_node
)
6587 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
6591 /* We might have set these in cp_finish_decl. */
6592 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
6593 TREE_CONSTANT (decl
) = false;
6597 && DECL_IN_AGGR_P (decl
)
6598 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6600 static int explained
= 0;
6602 if (cxx_dialect
< cxx11
)
6603 error ("initializer invalid for static member with constructor");
6604 else if (cxx_dialect
< cxx17
)
6605 error ("non-constant in-class initialization invalid for static "
6606 "member %qD", decl
);
6608 error ("non-constant in-class initialization invalid for non-inline "
6609 "static member %qD", decl
);
6612 inform (input_location
,
6613 "(an out of class initialization is required)");
6622 /* If DECL is not a local variable, give it RTL. */
6625 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6627 int toplev
= toplevel_bindings_p ();
6630 /* Set the DECL_ASSEMBLER_NAME for the object. */
6633 /* The `register' keyword, when used together with an
6634 asm-specification, indicates that the variable should be
6635 placed in a particular register. */
6636 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6638 set_user_assembler_name (decl
, asmspec
);
6639 DECL_HARD_REGISTER (decl
) = 1;
6643 if (TREE_CODE (decl
) == FUNCTION_DECL
6644 && fndecl_built_in_p (decl
, BUILT_IN_NORMAL
))
6645 set_builtin_user_assembler_name (decl
, asmspec
);
6646 set_user_assembler_name (decl
, asmspec
);
6650 /* Handle non-variables up front. */
6653 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6657 /* If we see a class member here, it should be a static data
6659 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6661 gcc_assert (TREE_STATIC (decl
));
6662 /* An in-class declaration of a static data member should be
6663 external; it is only a declaration, and not a definition. */
6664 if (init
== NULL_TREE
)
6665 gcc_assert (DECL_EXTERNAL (decl
)
6666 || !TREE_PUBLIC (decl
));
6669 /* We don't create any RTL for local variables. */
6670 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6673 /* We defer emission of local statics until the corresponding
6674 DECL_EXPR is expanded. But with constexpr its function might never
6675 be expanded, so go ahead and tell cgraph about the variable now. */
6676 defer_p
= ((DECL_FUNCTION_SCOPE_P (decl
)
6677 && !var_in_maybe_constexpr_fn (decl
))
6678 || DECL_VIRTUAL_P (decl
));
6680 /* Defer template instantiations. */
6681 if (DECL_LANG_SPECIFIC (decl
)
6682 && DECL_IMPLICIT_INSTANTIATION (decl
))
6685 /* If we're not deferring, go ahead and assemble the variable. */
6687 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6690 /* walk_tree helper for wrap_temporary_cleanups, below. */
6693 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6695 /* Stop at types or full-expression boundaries. */
6696 if (TYPE_P (*stmt_p
)
6697 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6703 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6705 tree guard
= (tree
)data
;
6706 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6708 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6709 /* Tell honor_protect_cleanup_actions to handle this as a separate
6711 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6713 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6719 /* We're initializing a local variable which has a cleanup GUARD. If there
6720 are any temporaries used in the initializer INIT of this variable, we
6721 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6722 variable will be cleaned up properly if one of them throws.
6724 Unfortunately, there's no way to express this properly in terms of
6725 nesting, as the regions for the temporaries overlap the region for the
6726 variable itself; if there are two temporaries, the variable needs to be
6727 the first thing destroyed if either of them throws. However, we only
6728 want to run the variable's cleanup if it actually got constructed. So
6729 we need to guard the temporary cleanups with the variable's cleanup if
6730 they are run on the normal path, but not if they are run on the
6731 exceptional path. We implement this by telling
6732 honor_protect_cleanup_actions to strip the variable cleanup from the
6733 exceptional path. */
6736 wrap_temporary_cleanups (tree init
, tree guard
)
6738 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6741 /* Generate code to initialize DECL (a local variable). */
6744 initialize_local_var (tree decl
, tree init
)
6746 tree type
= TREE_TYPE (decl
);
6750 gcc_assert (VAR_P (decl
)
6751 || TREE_CODE (decl
) == RESULT_DECL
);
6752 gcc_assert (!TREE_STATIC (decl
));
6754 if (DECL_SIZE (decl
) == NULL_TREE
)
6756 /* If we used it already as memory, it must stay in memory. */
6757 DECL_INITIAL (decl
) = NULL_TREE
;
6758 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6762 if (type
== error_mark_node
)
6765 /* Compute and store the initial value. */
6766 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6767 if (TREE_USED (type
))
6768 DECL_READ_P (decl
) = 1;
6770 /* Generate a cleanup, if necessary. */
6771 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6773 /* Perform the initialization. */
6776 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6777 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6778 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6780 /* Stick simple initializers in DECL_INITIAL so that
6781 -Wno-init-self works (c++/34772). */
6782 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6783 DECL_INITIAL (decl
) = rinit
;
6785 if (warn_init_self
&& TYPE_REF_P (type
))
6789 warning_at (DECL_SOURCE_LOCATION (decl
),
6791 "reference %qD is initialized with itself", decl
);
6796 int saved_stmts_are_full_exprs_p
;
6798 /* If we're only initializing a single object, guard the
6799 destructors of any temporaries used in its initializer with
6800 its destructor. This isn't right for arrays because each
6801 element initialization is a full-expression. */
6802 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6803 wrap_temporary_cleanups (init
, cleanup
);
6805 gcc_assert (building_stmt_list_p ());
6806 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6807 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6808 finish_expr_stmt (init
);
6809 current_stmt_tree ()->stmts_are_full_exprs_p
=
6810 saved_stmts_are_full_exprs_p
;
6814 /* Set this to 0 so we can tell whether an aggregate which was
6815 initialized was ever used. Don't do this if it has a
6816 destructor, so we don't complain about the 'resource
6817 allocation is initialization' idiom. Now set
6818 attribute((unused)) on types so decls of that type will be
6819 marked used. (see TREE_USED, above.) */
6820 if (TYPE_NEEDS_CONSTRUCTING (type
)
6822 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6823 && DECL_NAME (decl
))
6824 TREE_USED (decl
) = 0;
6825 else if (already_used
)
6826 TREE_USED (decl
) = 1;
6829 finish_decl_cleanup (decl
, cleanup
);
6832 /* DECL is a VAR_DECL for a compiler-generated variable with static
6833 storage duration (like a virtual table) whose initializer is a
6834 compile-time constant. Initialize the variable and provide it to the
6838 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6841 gcc_assert (DECL_ARTIFICIAL (decl
));
6842 init
= build_constructor (TREE_TYPE (decl
), v
);
6843 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6844 DECL_INITIAL (decl
) = init
;
6845 DECL_INITIALIZED_P (decl
) = 1;
6846 /* Mark the decl as constexpr so that we can access its content
6848 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
6849 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
6850 determine_visibility (decl
);
6851 layout_var_decl (decl
);
6852 maybe_commonize_var (decl
);
6853 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6856 /* INIT is the initializer for a variable, as represented by the
6857 parser. Returns true iff INIT is value-dependent. */
6860 value_dependent_init_p (tree init
)
6862 if (TREE_CODE (init
) == TREE_LIST
)
6863 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6864 return any_value_dependent_elements_p (init
);
6865 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6866 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6868 if (dependent_type_p (TREE_TYPE (init
)))
6871 vec
<constructor_elt
, va_gc
> *elts
;
6875 elts
= CONSTRUCTOR_ELTS (init
);
6876 nelts
= vec_safe_length (elts
);
6877 for (i
= 0; i
< nelts
; ++i
)
6878 if (value_dependent_init_p ((*elts
)[i
].value
))
6882 /* It must be a simple expression, e.g., int i = 3; */
6883 return value_dependent_expression_p (init
);
6888 // Returns true if a DECL is VAR_DECL with the concept specifier.
6890 is_concept_var (tree decl
)
6892 return (VAR_P (decl
)
6893 // Not all variables have DECL_LANG_SPECIFIC.
6894 && DECL_LANG_SPECIFIC (decl
)
6895 && DECL_DECLARED_CONCEPT_P (decl
));
6898 /* A helper function to be called via walk_tree. If any label exists
6899 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
6902 notice_forced_label_r (tree
*tp
, int *walk_subtrees
, void *)
6906 if (TREE_CODE (*tp
) == LABEL_DECL
)
6907 cfun
->has_forced_label_in_static
= 1;
6911 /* Finish processing of a declaration;
6912 install its line number and initial value.
6913 If the length of an array type is not known before,
6914 it must be determined now, from the initial value, or it is an error.
6916 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6917 true, then INIT is an integral constant expression.
6919 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6920 if the (init) syntax was used. */
6923 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6924 tree asmspec_tree
, int flags
)
6927 vec
<tree
, va_gc
> *cleanups
= NULL
;
6928 const char *asmspec
= NULL
;
6929 int was_readonly
= 0;
6930 bool var_definition_p
= false;
6933 if (decl
== error_mark_node
)
6938 error ("assignment (not initialization) in declaration");
6942 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6943 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6944 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6946 type
= TREE_TYPE (decl
);
6947 if (type
== error_mark_node
)
6950 /* Warn about register storage specifiers except when in GNU global
6951 or local register variable extension. */
6952 if (VAR_P (decl
) && DECL_REGISTER (decl
) && asmspec_tree
== NULL_TREE
)
6954 if (cxx_dialect
>= cxx17
)
6955 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
6956 "ISO C++17 does not allow %<register%> storage "
6959 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
6960 "%<register%> storage class specifier used");
6963 /* If a name was specified, get the string. */
6964 if (at_namespace_scope_p ())
6965 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6966 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6967 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6969 if (current_class_type
6970 && CP_DECL_CONTEXT (decl
) == current_class_type
6971 && TYPE_BEING_DEFINED (current_class_type
)
6972 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6973 && (DECL_INITIAL (decl
) || init
))
6974 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6976 /* Do auto deduction unless decl is a function or an uninstantiated
6977 template specialization. */
6978 if (TREE_CODE (decl
) != FUNCTION_DECL
6979 && !(init
== NULL_TREE
6980 && DECL_LANG_SPECIFIC (decl
)
6981 && DECL_TEMPLATE_INSTANTIATION (decl
)
6982 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6983 && (auto_node
= type_uses_auto (type
)))
6986 if (init
== NULL_TREE
)
6987 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (auto_node
));
6991 if (TREE_CODE (d_init
) == TREE_LIST
6992 && !CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
6993 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6994 tf_warning_or_error
);
6995 d_init
= resolve_nondeduced_context (d_init
, tf_warning_or_error
);
6997 enum auto_deduction_context adc
= adc_variable_type
;
6998 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
6999 adc
= adc_decomp_type
;
7000 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
, auto_node
,
7001 tf_warning_or_error
, adc
,
7003 if (type
== error_mark_node
)
7005 if (TREE_CODE (type
) == FUNCTION_TYPE
)
7007 error ("initializer for %<decltype(auto) %D%> has function type "
7008 "(did you forget the %<()%> ?)", decl
);
7009 TREE_TYPE (decl
) = error_mark_node
;
7012 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
7015 if (ensure_literal_type_for_constexpr_object (decl
) == error_mark_node
)
7017 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
7018 if (VAR_P (decl
) && DECL_CLASS_SCOPE_P (decl
))
7021 DECL_EXTERNAL (decl
) = 1;
7026 && DECL_CLASS_SCOPE_P (decl
)
7027 && DECL_INITIALIZED_IN_CLASS_P (decl
))
7028 check_static_variable_definition (decl
, type
);
7030 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
7033 if (init
== ridpointers
[(int)RID_DELETE
])
7035 /* FIXME check this is 1st decl. */
7036 DECL_DELETED_FN (decl
) = 1;
7037 DECL_DECLARED_INLINE_P (decl
) = 1;
7038 DECL_INITIAL (decl
) = error_mark_node
;
7039 FOR_EACH_CLONE (clone
, decl
)
7041 DECL_DELETED_FN (clone
) = 1;
7042 DECL_DECLARED_INLINE_P (clone
) = 1;
7043 DECL_INITIAL (clone
) = error_mark_node
;
7047 else if (init
== ridpointers
[(int)RID_DEFAULT
])
7049 if (defaultable_fn_check (decl
))
7050 DECL_DEFAULTED_FN (decl
) = 1;
7052 DECL_INITIAL (decl
) = NULL_TREE
;
7056 if (init
&& VAR_P (decl
))
7058 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
7059 /* If DECL is a reference, then we want to know whether init is a
7060 reference constant; init_const_expr_p as passed tells us whether
7061 it's an rvalue constant. */
7062 if (TYPE_REF_P (type
))
7063 init_const_expr_p
= potential_constant_expression (init
);
7064 if (init_const_expr_p
)
7066 /* Set these flags now for templates. We'll update the flags in
7067 store_init_value for instantiations. */
7068 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
7069 if (decl_maybe_constant_var_p (decl
)
7070 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
7071 && !TYPE_REF_P (type
))
7072 TREE_CONSTANT (decl
) = 1;
7076 if (processing_template_decl
)
7078 bool type_dependent_p
;
7080 /* Add this declaration to the statement-tree. */
7081 if (at_function_scope_p ())
7082 add_decl_expr (decl
);
7084 type_dependent_p
= dependent_type_p (type
);
7086 if (check_for_bare_parameter_packs (init
))
7089 DECL_INITIAL (decl
) = NULL_TREE
;
7092 /* Generally, initializers in templates are expanded when the
7093 template is instantiated. But, if DECL is a variable constant
7094 then it can be used in future constant expressions, so its value
7095 must be available. */
7097 bool dep_init
= false;
7099 if (!VAR_P (decl
) || type_dependent_p
)
7100 /* We can't do anything if the decl has dependent type. */;
7101 else if (!init
&& is_concept_var (decl
))
7103 error ("variable concept has no initializer");
7104 init
= boolean_true_node
;
7107 && init_const_expr_p
7108 && !TYPE_REF_P (type
)
7109 && decl_maybe_constant_var_p (decl
)
7110 && !(dep_init
= value_dependent_init_p (init
)))
7112 /* This variable seems to be a non-dependent constant, so process
7113 its initializer. If check_initializer returns non-null the
7114 initialization wasn't constant after all. */
7116 cleanups
= make_tree_vector ();
7117 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
7118 if (init_code
== NULL_TREE
)
7120 release_tree_vector (cleanups
);
7124 gcc_assert (!DECL_PRETTY_FUNCTION_P (decl
));
7125 /* Deduce array size even if the initializer is dependent. */
7126 maybe_deduce_size_from_array_init (decl
, init
);
7127 /* And complain about multiple initializers. */
7128 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
7129 && !MAYBE_CLASS_TYPE_P (type
))
7130 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
7131 tf_warning_or_error
);
7135 DECL_INITIAL (decl
) = init
;
7139 retrofit_lang_decl (decl
);
7140 SET_DECL_DEPENDENT_INIT_P (decl
, true);
7145 /* Just store non-static data member initializers for later. */
7146 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
7147 DECL_INITIAL (decl
) = init
;
7149 /* Take care of TYPE_DECLs up front. */
7150 if (TREE_CODE (decl
) == TYPE_DECL
)
7152 if (type
!= error_mark_node
7153 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
7155 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7156 warning (0, "shadowing previous type declaration of %q#D", decl
);
7157 set_identifier_type_value (DECL_NAME (decl
), decl
);
7160 /* If we have installed this as the canonical typedef for this
7161 type, and that type has not been defined yet, delay emitting
7162 the debug information for it, as we will emit it later. */
7163 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7164 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
7165 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
7167 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
7172 /* A reference will be modified here, as it is initialized. */
7173 if (! DECL_EXTERNAL (decl
)
7174 && TREE_READONLY (decl
)
7175 && TYPE_REF_P (type
))
7178 TREE_READONLY (decl
) = 0;
7183 /* If this is a local variable that will need a mangled name,
7184 register it now. We must do this before processing the
7185 initializer for the variable, since the initialization might
7186 require a guard variable, and since the mangled name of the
7187 guard variable will depend on the mangled name of this
7189 if (DECL_FUNCTION_SCOPE_P (decl
)
7190 && TREE_STATIC (decl
)
7191 && !DECL_ARTIFICIAL (decl
))
7193 /* The variable holding an anonymous union will have had its
7194 discriminator set in finish_anon_union, after which it's
7195 NAME will have been cleared. */
7196 if (DECL_NAME (decl
))
7197 determine_local_discriminator (decl
);
7198 /* Normally has_forced_label_in_static is set during GIMPLE
7199 lowering, but [cd]tors are never actually compiled directly.
7200 We need to set this early so we can deal with the label
7201 address extension. */
7202 if ((DECL_CONSTRUCTOR_P (current_function_decl
)
7203 || DECL_DESTRUCTOR_P (current_function_decl
))
7206 walk_tree (&init
, notice_forced_label_r
, NULL
, NULL
);
7207 add_local_decl (cfun
, decl
);
7209 /* And make sure it's in the symbol table for
7210 c_parse_final_cleanups to find. */
7211 varpool_node::get_create (decl
);
7214 /* Convert the initializer to the type of DECL, if we have not
7215 already initialized DECL. */
7216 if (!DECL_INITIALIZED_P (decl
)
7217 /* If !DECL_EXTERNAL then DECL is being defined. In the
7218 case of a static data member initialized inside the
7219 class-specifier, there can be an initializer even if DECL
7220 is *not* defined. */
7221 && (!DECL_EXTERNAL (decl
) || init
))
7223 cleanups
= make_tree_vector ();
7224 init
= check_initializer (decl
, init
, flags
, &cleanups
);
7230 The memory occupied by any object of static storage
7231 duration is zero-initialized at program startup before
7232 any other initialization takes place.
7234 We cannot create an appropriate initializer until after
7235 the type of DECL is finalized. If DECL_INITIAL is set,
7236 then the DECL is statically initialized, and any
7237 necessary zero-initialization has already been performed. */
7238 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
7239 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
7240 /*nelts=*/NULL_TREE
,
7241 /*static_storage_p=*/true);
7242 /* Remember that the initialization for this variable has
7244 DECL_INITIALIZED_P (decl
) = 1;
7245 /* This declaration is the definition of this variable,
7246 unless we are initializing a static data member within
7247 the class specifier. */
7248 if (!DECL_EXTERNAL (decl
))
7249 var_definition_p
= true;
7251 /* If the variable has an array type, lay out the type, even if
7252 there is no initializer. It is valid to index through the
7253 array, and we must get TYPE_ALIGN set correctly on the array
7255 else if (TREE_CODE (type
) == ARRAY_TYPE
)
7258 if (TREE_STATIC (decl
)
7259 && !at_function_scope_p ()
7260 && current_function_decl
== NULL
)
7261 /* So decl is a global variable or a static member of a
7262 non local class. Record the types it uses
7263 so that we can decide later to emit debug info for them. */
7264 record_types_used_by_current_var_decl (decl
);
7267 /* Add this declaration to the statement-tree. This needs to happen
7268 after the call to check_initializer so that the DECL_EXPR for a
7269 reference temp is added before the DECL_EXPR for the reference itself. */
7270 if (DECL_FUNCTION_SCOPE_P (decl
))
7272 /* If we're building a variable sized type, and we might be
7273 reachable other than via the top of the current binding
7274 level, then create a new BIND_EXPR so that we deallocate
7275 the object at the right time. */
7278 && !TREE_CONSTANT (DECL_SIZE (decl
))
7279 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
7282 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
7283 TREE_SIDE_EFFECTS (bind
) = 1;
7285 BIND_EXPR_BODY (bind
) = push_stmt_list ();
7287 add_decl_expr (decl
);
7290 /* Let the middle end know about variables and functions -- but not
7291 static data members in uninstantiated class templates. */
7292 if (VAR_OR_FUNCTION_DECL_P (decl
))
7296 layout_var_decl (decl
);
7297 maybe_commonize_var (decl
);
7300 /* This needs to happen after the linkage is set. */
7301 determine_visibility (decl
);
7303 if (var_definition_p
&& TREE_STATIC (decl
))
7305 /* If a TREE_READONLY variable needs initialization
7306 at runtime, it is no longer readonly and we need to
7307 avoid MEM_READONLY_P being set on RTL created for it. */
7310 if (TREE_READONLY (decl
))
7311 TREE_READONLY (decl
) = 0;
7314 else if (was_readonly
)
7315 TREE_READONLY (decl
) = 1;
7317 /* Likewise if it needs destruction. */
7318 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
7319 TREE_READONLY (decl
) = 0;
7322 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
7324 /* Check for abstractness of the type. Notice that there is no
7325 need to strip array types here since the check for those types
7326 is already done within create_array_type_for_decl. */
7327 abstract_virtuals_error (decl
, type
);
7329 if (TREE_TYPE (decl
) == error_mark_node
)
7330 /* No initialization required. */
7332 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
7336 if (init
== ridpointers
[(int)RID_DEFAULT
])
7338 /* An out-of-class default definition is defined at
7339 the point where it is explicitly defaulted. */
7340 if (DECL_DELETED_FN (decl
))
7341 maybe_explain_implicit_delete (decl
);
7342 else if (DECL_INITIAL (decl
) == error_mark_node
)
7343 synthesize_method (decl
);
7346 error_at (cp_expr_loc_or_loc (init
,
7347 DECL_SOURCE_LOCATION (decl
)),
7348 "function %q#D is initialized like a variable",
7351 /* else no initialization required. */
7353 else if (DECL_EXTERNAL (decl
)
7354 && ! (DECL_LANG_SPECIFIC (decl
)
7355 && DECL_NOT_REALLY_EXTERN (decl
)))
7358 DECL_INITIAL (decl
) = init
;
7360 /* A variable definition. */
7361 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
7362 /* Initialize the local variable. */
7363 initialize_local_var (decl
, init
);
7365 /* If a variable is defined, and then a subsequent
7366 definition with external linkage is encountered, we will
7367 get here twice for the same variable. We want to avoid
7368 calling expand_static_init more than once. For variables
7369 that are not static data members, we can call
7370 expand_static_init only when we actually process the
7371 initializer. It is not legal to redeclare a static data
7372 member, so this issue does not arise in that case. */
7373 else if (var_definition_p
&& TREE_STATIC (decl
))
7374 expand_static_init (decl
, init
);
7377 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
7378 reference, insert it in the statement-tree now. */
7382 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
7383 push_cleanup (decl
, t
, false);
7384 release_tree_vector (cleanups
);
7388 TREE_READONLY (decl
) = 1;
7392 && lookup_attribute ("omp declare target implicit",
7393 DECL_ATTRIBUTES (decl
)))
7395 DECL_ATTRIBUTES (decl
)
7396 = remove_attribute ("omp declare target implicit",
7397 DECL_ATTRIBUTES (decl
));
7398 complete_type (TREE_TYPE (decl
));
7399 if (!cp_omp_mappable_type (TREE_TYPE (decl
)))
7400 error ("%q+D in declare target directive does not have mappable type",
7402 else if (!lookup_attribute ("omp declare target",
7403 DECL_ATTRIBUTES (decl
))
7404 && !lookup_attribute ("omp declare target link",
7405 DECL_ATTRIBUTES (decl
)))
7406 DECL_ATTRIBUTES (decl
)
7407 = tree_cons (get_identifier ("omp declare target"),
7408 NULL_TREE
, DECL_ATTRIBUTES (decl
));
7411 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
7414 /* For class TYPE return itself or some its bases that contain
7415 any direct non-static data members. Return error_mark_node if an
7416 error has been diagnosed. */
7419 find_decomp_class_base (location_t loc
, tree type
, tree ret
)
7421 bool member_seen
= false;
7422 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
7423 if (TREE_CODE (field
) != FIELD_DECL
7424 || DECL_ARTIFICIAL (field
)
7425 || DECL_UNNAMED_BIT_FIELD (field
))
7429 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
7431 if (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
)
7432 error_at (loc
, "cannot decompose class type %qT because it has an "
7433 "anonymous struct member", type
);
7435 error_at (loc
, "cannot decompose class type %qT because it has an "
7436 "anonymous union member", type
);
7437 inform (DECL_SOURCE_LOCATION (field
), "declared here");
7438 return error_mark_node
;
7440 else if (!accessible_p (type
, field
, true))
7442 error_at (loc
, "cannot decompose inaccessible member %qD of %qT",
7444 inform (DECL_SOURCE_LOCATION (field
),
7445 TREE_PRIVATE (field
)
7446 ? G_("declared private here")
7447 : G_("declared protected here"));
7448 return error_mark_node
;
7453 tree base_binfo
, binfo
;
7454 tree orig_ret
= ret
;
7458 for (binfo
= TYPE_BINFO (type
), i
= 0;
7459 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
7461 tree t
= find_decomp_class_base (loc
, TREE_TYPE (base_binfo
), ret
);
7462 if (t
== error_mark_node
)
7463 return error_mark_node
;
7464 if (t
!= NULL_TREE
&& t
!= ret
)
7468 error_at (loc
, "cannot decompose class type %qT: both it and "
7469 "its base class %qT have non-static data members",
7471 return error_mark_node
;
7473 else if (orig_ret
!= NULL_TREE
)
7475 else if (ret
!= NULL_TREE
)
7477 error_at (loc
, "cannot decompose class type %qT: its base "
7478 "classes %qT and %qT have non-static data "
7479 "members", type
, ret
, t
);
7480 return error_mark_node
;
7489 /* Return std::tuple_size<TYPE>::value. */
7492 get_tuple_size (tree type
)
7494 tree args
= make_tree_vec (1);
7495 TREE_VEC_ELT (args
, 0) = type
;
7496 tree inst
= lookup_template_class (tuple_size_identifier
, args
,
7497 /*in_decl*/NULL_TREE
,
7498 /*context*/std_node
,
7499 /*entering_scope*/false, tf_none
);
7500 inst
= complete_type (inst
);
7501 if (inst
== error_mark_node
|| !COMPLETE_TYPE_P (inst
))
7503 tree val
= lookup_qualified_name (inst
, value_identifier
,
7504 /*type*/false, /*complain*/false);
7505 if (TREE_CODE (val
) == VAR_DECL
|| TREE_CODE (val
) == CONST_DECL
)
7506 val
= maybe_constant_value (val
);
7507 if (TREE_CODE (val
) == INTEGER_CST
)
7510 return error_mark_node
;
7513 /* Return std::tuple_element<I,TYPE>::type. */
7516 get_tuple_element_type (tree type
, unsigned i
)
7518 tree args
= make_tree_vec (2);
7519 TREE_VEC_ELT (args
, 0) = build_int_cst (integer_type_node
, i
);
7520 TREE_VEC_ELT (args
, 1) = type
;
7521 tree inst
= lookup_template_class (tuple_element_identifier
, args
,
7522 /*in_decl*/NULL_TREE
,
7523 /*context*/std_node
,
7524 /*entering_scope*/false,
7525 tf_warning_or_error
);
7526 return make_typename_type (inst
, type_identifier
,
7527 none_type
, tf_warning_or_error
);
7530 /* Return e.get<i>() or get<i>(e). */
7533 get_tuple_decomp_init (tree decl
, unsigned i
)
7535 tree targs
= make_tree_vec (1);
7536 TREE_VEC_ELT (targs
, 0) = build_int_cst (integer_type_node
, i
);
7538 tree etype
= TREE_TYPE (decl
);
7539 tree e
= convert_from_reference (decl
);
7541 /* [The id-expression] e is an lvalue if the type of the entity e is an
7542 lvalue reference and an xvalue otherwise. */
7543 if (!TYPE_REF_P (etype
)
7544 || TYPE_REF_IS_RVALUE (etype
))
7547 tree fns
= lookup_qualified_name (TREE_TYPE (e
), get__identifier
,
7548 /*type*/false, /*complain*/false);
7549 bool use_member_get
= false;
7551 /* To use a member get, member lookup must find at least one
7552 declaration that is a function template
7553 whose first template parameter is a non-type parameter. */
7554 for (lkp_iterator
iter (MAYBE_BASELINK_FUNCTIONS (fns
)); iter
; ++iter
)
7557 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
7559 tree tparms
= DECL_TEMPLATE_PARMS (fn
);
7560 tree parm
= TREE_VEC_ELT (INNERMOST_TEMPLATE_PARMS (tparms
), 0);
7561 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
7563 use_member_get
= true;
7571 fns
= lookup_template_function (fns
, targs
);
7572 return build_new_method_call (e
, fns
, /*args*/NULL
,
7573 /*path*/NULL_TREE
, LOOKUP_NORMAL
,
7574 /*fn_p*/NULL
, tf_warning_or_error
);
7578 vec
<tree
,va_gc
> *args
= make_tree_vector_single (e
);
7579 fns
= lookup_template_function (get__identifier
, targs
);
7580 fns
= perform_koenig_lookup (fns
, args
, tf_warning_or_error
);
7581 return finish_call_expr (fns
, &args
, /*novirt*/false,
7582 /*koenig*/true, tf_warning_or_error
);
7586 /* It's impossible to recover the decltype of a tuple decomposition variable
7587 based on the actual type of the variable, so store it in a hash table. */
7589 static GTY((cache
)) tree_cache_map
*decomp_type_table
;
7591 store_decomp_type (tree v
, tree t
)
7593 if (!decomp_type_table
)
7594 decomp_type_table
= tree_cache_map::create_ggc (13);
7595 decomp_type_table
->put (v
, t
);
7599 lookup_decomp_type (tree v
)
7601 return *decomp_type_table
->get (v
);
7604 /* Mangle a decomposition declaration if needed. Arguments like
7605 in cp_finish_decomp. */
7608 cp_maybe_mangle_decomp (tree decl
, tree first
, unsigned int count
)
7610 if (!processing_template_decl
7611 && !error_operand_p (decl
)
7612 && DECL_NAMESPACE_SCOPE_P (decl
))
7614 auto_vec
<tree
, 16> v
;
7615 v
.safe_grow (count
);
7617 for (unsigned int i
= 0; i
< count
; i
++, d
= DECL_CHAIN (d
))
7618 v
[count
- i
- 1] = d
;
7619 SET_DECL_ASSEMBLER_NAME (decl
, mangle_decomp (decl
, v
));
7620 maybe_apply_pragma_weak (decl
);
7624 /* Finish a decomposition declaration. DECL is the underlying declaration
7625 "e", FIRST is the head of a chain of decls for the individual identifiers
7626 chained through DECL_CHAIN in reverse order and COUNT is the number of
7630 cp_finish_decomp (tree decl
, tree first
, unsigned int count
)
7632 if (error_operand_p (decl
))
7637 TREE_TYPE (first
) = error_mark_node
;
7638 if (DECL_HAS_VALUE_EXPR_P (first
))
7640 SET_DECL_VALUE_EXPR (first
, NULL_TREE
);
7641 DECL_HAS_VALUE_EXPR_P (first
) = 0;
7643 first
= DECL_CHAIN (first
);
7645 if (DECL_P (decl
) && DECL_NAMESPACE_SCOPE_P (decl
))
7646 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier ("<decomp>"));
7650 location_t loc
= DECL_SOURCE_LOCATION (decl
);
7651 if (type_dependent_expression_p (decl
)
7652 /* This happens for range for when not in templates.
7653 Still add the DECL_VALUE_EXPRs for later processing. */
7654 || (!processing_template_decl
7655 && type_uses_auto (TREE_TYPE (decl
))))
7657 for (unsigned int i
= 0; i
< count
; i
++)
7659 if (!DECL_HAS_VALUE_EXPR_P (first
))
7661 tree v
= build_nt (ARRAY_REF
, decl
,
7662 size_int (count
- i
- 1),
7663 NULL_TREE
, NULL_TREE
);
7664 SET_DECL_VALUE_EXPR (first
, v
);
7665 DECL_HAS_VALUE_EXPR_P (first
) = 1;
7667 if (processing_template_decl
)
7668 fit_decomposition_lang_decl (first
, decl
);
7669 first
= DECL_CHAIN (first
);
7674 auto_vec
<tree
, 16> v
;
7675 v
.safe_grow (count
);
7677 for (unsigned int i
= 0; i
< count
; i
++, d
= DECL_CHAIN (d
))
7679 v
[count
- i
- 1] = d
;
7680 fit_decomposition_lang_decl (d
, decl
);
7683 tree type
= TREE_TYPE (decl
);
7686 if (TYPE_REF_P (type
))
7688 dexp
= convert_from_reference (dexp
);
7689 type
= complete_type (TREE_TYPE (type
));
7690 if (type
== error_mark_node
)
7692 if (!COMPLETE_TYPE_P (type
))
7694 error_at (loc
, "structured binding refers to incomplete type %qT",
7700 tree eltype
= NULL_TREE
;
7701 unsigned HOST_WIDE_INT eltscnt
= 0;
7702 if (TREE_CODE (type
) == ARRAY_TYPE
)
7705 nelts
= array_type_nelts_top (type
);
7706 if (nelts
== error_mark_node
)
7708 if (!tree_fits_uhwi_p (nelts
))
7710 error_at (loc
, "cannot decompose variable length array %qT", type
);
7713 eltscnt
= tree_to_uhwi (nelts
);
7714 if (count
!= eltscnt
)
7717 if (count
> eltscnt
)
7718 error_n (loc
, count
,
7719 "%u name provided for structured binding",
7720 "%u names provided for structured binding", count
);
7722 error_n (loc
, count
,
7723 "only %u name provided for structured binding",
7724 "only %u names provided for structured binding", count
);
7725 inform_n (loc
, eltscnt
,
7726 "while %qT decomposes into %wu element",
7727 "while %qT decomposes into %wu elements",
7731 eltype
= TREE_TYPE (type
);
7732 for (unsigned int i
= 0; i
< count
; i
++)
7734 TREE_TYPE (v
[i
]) = eltype
;
7735 layout_decl (v
[i
], 0);
7736 if (processing_template_decl
)
7738 tree t
= unshare_expr (dexp
);
7739 t
= build4_loc (DECL_SOURCE_LOCATION (v
[i
]), ARRAY_REF
,
7740 eltype
, t
, size_int (i
), NULL_TREE
,
7742 SET_DECL_VALUE_EXPR (v
[i
], t
);
7743 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7746 /* 2 GNU extensions. */
7747 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
7750 if (count
!= eltscnt
)
7752 eltype
= cp_build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
7753 for (unsigned int i
= 0; i
< count
; i
++)
7755 TREE_TYPE (v
[i
]) = eltype
;
7756 layout_decl (v
[i
], 0);
7757 if (processing_template_decl
)
7759 tree t
= unshare_expr (dexp
);
7760 t
= build1_loc (DECL_SOURCE_LOCATION (v
[i
]),
7761 i
? IMAGPART_EXPR
: REALPART_EXPR
, eltype
,
7763 SET_DECL_VALUE_EXPR (v
[i
], t
);
7764 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7767 else if (TREE_CODE (type
) == VECTOR_TYPE
)
7769 if (!TYPE_VECTOR_SUBPARTS (type
).is_constant (&eltscnt
))
7771 error_at (loc
, "cannot decompose variable length vector %qT", type
);
7774 if (count
!= eltscnt
)
7776 eltype
= cp_build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
7777 for (unsigned int i
= 0; i
< count
; i
++)
7779 TREE_TYPE (v
[i
]) = eltype
;
7780 layout_decl (v
[i
], 0);
7781 if (processing_template_decl
)
7783 tree t
= unshare_expr (dexp
);
7784 convert_vector_to_array_for_subscript (DECL_SOURCE_LOCATION (v
[i
]),
7786 t
= build4_loc (DECL_SOURCE_LOCATION (v
[i
]), ARRAY_REF
,
7787 eltype
, t
, size_int (i
), NULL_TREE
,
7789 SET_DECL_VALUE_EXPR (v
[i
], t
);
7790 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7793 else if (tree tsize
= get_tuple_size (type
))
7795 if (tsize
== error_mark_node
)
7797 error_at (loc
, "%<std::tuple_size<%T>::value%> is not an integral "
7798 "constant expression", type
);
7801 if (!tree_fits_uhwi_p (tsize
))
7803 error_n (loc
, count
,
7804 "%u name provided for structured binding",
7805 "%u names provided for structured binding", count
);
7806 inform (loc
, "while %qT decomposes into %E elements",
7810 eltscnt
= tree_to_uhwi (tsize
);
7811 if (count
!= eltscnt
)
7813 int save_read
= DECL_READ_P (decl
);
7814 for (unsigned i
= 0; i
< count
; ++i
)
7816 location_t sloc
= input_location
;
7817 location_t dloc
= DECL_SOURCE_LOCATION (v
[i
]);
7819 input_location
= dloc
;
7820 tree init
= get_tuple_decomp_init (decl
, i
);
7821 tree eltype
= (init
== error_mark_node
? error_mark_node
7822 : get_tuple_element_type (type
, i
));
7823 input_location
= sloc
;
7825 if (init
== error_mark_node
|| eltype
== error_mark_node
)
7827 inform (dloc
, "in initialization of structured binding "
7828 "variable %qD", v
[i
]);
7831 /* Save the decltype away before reference collapse. */
7832 store_decomp_type (v
[i
], eltype
);
7833 eltype
= cp_build_reference_type (eltype
, !lvalue_p (init
));
7834 TREE_TYPE (v
[i
]) = eltype
;
7835 layout_decl (v
[i
], 0);
7836 if (DECL_HAS_VALUE_EXPR_P (v
[i
]))
7838 /* In this case the names are variables, not just proxies. */
7839 SET_DECL_VALUE_EXPR (v
[i
], NULL_TREE
);
7840 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 0;
7842 if (!processing_template_decl
)
7843 cp_finish_decl (v
[i
], init
, /*constexpr*/false,
7844 /*asm*/NULL_TREE
, LOOKUP_NORMAL
);
7846 /* Ignore reads from the underlying decl performed during initialization
7847 of the individual variables. If those will be read, we'll mark
7848 the underlying decl as read at that point. */
7849 DECL_READ_P (decl
) = save_read
;
7851 else if (TREE_CODE (type
) == UNION_TYPE
)
7853 error_at (loc
, "cannot decompose union type %qT", type
);
7856 else if (!CLASS_TYPE_P (type
))
7858 error_at (loc
, "cannot decompose non-array non-class type %qT", type
);
7861 else if (LAMBDA_TYPE_P (type
))
7863 error_at (loc
, "cannot decompose lambda closure type %qT", type
);
7866 else if (processing_template_decl
&& !COMPLETE_TYPE_P (type
))
7867 pedwarn (loc
, 0, "structured binding refers to incomplete class type %qT",
7871 tree btype
= find_decomp_class_base (loc
, type
, NULL_TREE
);
7872 if (btype
== error_mark_node
)
7874 else if (btype
== NULL_TREE
)
7876 error_at (loc
, "cannot decompose class type %qT without non-static "
7877 "data members", type
);
7880 for (tree field
= TYPE_FIELDS (btype
); field
; field
= TREE_CHAIN (field
))
7881 if (TREE_CODE (field
) != FIELD_DECL
7882 || DECL_ARTIFICIAL (field
)
7883 || DECL_UNNAMED_BIT_FIELD (field
))
7887 if (count
!= eltscnt
)
7892 t
= convert_to_base (t
, btype
, /*check_access*/true,
7893 /*nonnull*/false, tf_warning_or_error
);
7897 for (tree field
= TYPE_FIELDS (btype
); field
; field
= TREE_CHAIN (field
))
7898 if (TREE_CODE (field
) != FIELD_DECL
7899 || DECL_ARTIFICIAL (field
)
7900 || DECL_UNNAMED_BIT_FIELD (field
))
7904 tree tt
= finish_non_static_data_member (field
, unshare_expr (t
),
7906 if (REFERENCE_REF_P (tt
))
7907 tt
= TREE_OPERAND (tt
, 0);
7908 TREE_TYPE (v
[i
]) = TREE_TYPE (tt
);
7909 layout_decl (v
[i
], 0);
7910 if (!processing_template_decl
)
7912 SET_DECL_VALUE_EXPR (v
[i
], tt
);
7913 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7918 if (processing_template_decl
)
7920 for (unsigned int i
= 0; i
< count
; i
++)
7921 if (!DECL_HAS_VALUE_EXPR_P (v
[i
]))
7923 tree a
= build_nt (ARRAY_REF
, decl
, size_int (i
),
7924 NULL_TREE
, NULL_TREE
);
7925 SET_DECL_VALUE_EXPR (v
[i
], a
);
7926 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7931 /* Returns a declaration for a VAR_DECL as if:
7933 extern "C" TYPE NAME;
7935 had been seen. Used to create compiler-generated global
7939 declare_global_var (tree name
, tree type
)
7943 push_to_top_level ();
7944 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7945 TREE_PUBLIC (decl
) = 1;
7946 DECL_EXTERNAL (decl
) = 1;
7947 DECL_ARTIFICIAL (decl
) = 1;
7948 DECL_CONTEXT (decl
) = FROB_CONTEXT (global_namespace
);
7949 /* If the user has explicitly declared this variable (perhaps
7950 because the code we are compiling is part of a low-level runtime
7951 library), then it is possible that our declaration will be merged
7952 with theirs by pushdecl. */
7953 decl
= pushdecl (decl
);
7954 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
7955 pop_from_top_level ();
7960 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
7961 if "__cxa_atexit" is not being used) corresponding to the function
7962 to be called when the program exits. */
7965 get_atexit_fn_ptr_type (void)
7969 if (!atexit_fn_ptr_type_node
)
7972 if (flag_use_cxa_atexit
7973 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7974 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
7975 arg_type
= ptr_type_node
;
7977 /* The parameter to "atexit" is "void (*)(void)". */
7978 arg_type
= NULL_TREE
;
7980 fn_type
= build_function_type_list (void_type_node
,
7981 arg_type
, NULL_TREE
);
7982 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
7985 return atexit_fn_ptr_type_node
;
7988 /* Returns a pointer to the `atexit' function. Note that if
7989 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
7990 `__cxa_atexit' function specified in the IA64 C++ ABI. */
7993 get_atexit_node (void)
7999 bool use_aeabi_atexit
;
8004 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
8006 /* The declaration for `__cxa_atexit' is:
8008 int __cxa_atexit (void (*)(void *), void *, void *)
8010 We build up the argument types and then the function type
8012 tree argtype0
, argtype1
, argtype2
;
8014 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
8015 /* First, build the pointer-to-function type for the first
8017 fn_ptr_type
= get_atexit_fn_ptr_type ();
8018 /* Then, build the rest of the argument types. */
8019 argtype2
= ptr_type_node
;
8020 if (use_aeabi_atexit
)
8022 argtype1
= fn_ptr_type
;
8023 argtype0
= ptr_type_node
;
8027 argtype1
= ptr_type_node
;
8028 argtype0
= fn_ptr_type
;
8030 /* And the final __cxa_atexit type. */
8031 fn_type
= build_function_type_list (integer_type_node
,
8032 argtype0
, argtype1
, argtype2
,
8034 if (use_aeabi_atexit
)
8035 name
= "__aeabi_atexit";
8037 name
= "__cxa_atexit";
8041 /* The declaration for `atexit' is:
8043 int atexit (void (*)());
8045 We build up the argument types and then the function type
8047 fn_ptr_type
= get_atexit_fn_ptr_type ();
8048 /* Build the final atexit type. */
8049 fn_type
= build_function_type_list (integer_type_node
,
8050 fn_ptr_type
, NULL_TREE
);
8054 /* Now, build the function declaration. */
8055 push_lang_context (lang_name_c
);
8056 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
8057 mark_used (atexit_fndecl
);
8058 pop_lang_context ();
8059 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
8064 /* Like get_atexit_node, but for thread-local cleanups. */
8067 get_thread_atexit_node (void)
8069 /* The declaration for `__cxa_thread_atexit' is:
8071 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
8072 tree fn_type
= build_function_type_list (integer_type_node
,
8073 get_atexit_fn_ptr_type (),
8074 ptr_type_node
, ptr_type_node
,
8077 /* Now, build the function declaration. */
8078 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
8079 ECF_LEAF
| ECF_NOTHROW
);
8080 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
8083 /* Returns the __dso_handle VAR_DECL. */
8086 get_dso_handle_node (void)
8088 if (dso_handle_node
)
8089 return dso_handle_node
;
8091 /* Declare the variable. */
8092 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
8095 #ifdef HAVE_GAS_HIDDEN
8096 if (dso_handle_node
!= error_mark_node
)
8098 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
8099 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
8103 return dso_handle_node
;
8106 /* Begin a new function with internal linkage whose job will be simply
8107 to destroy some particular variable. */
8109 static GTY(()) int start_cleanup_cnt
;
8112 start_cleanup_fn (void)
8117 bool use_cxa_atexit
= flag_use_cxa_atexit
8118 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
8120 push_to_top_level ();
8122 /* No need to mangle this. */
8123 push_lang_context (lang_name_c
);
8125 /* Build the name of the function. */
8126 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
8127 /* Build the function declaration. */
8128 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
8129 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
8130 /* It's a function with internal linkage, generated by the
8132 TREE_PUBLIC (fndecl
) = 0;
8133 DECL_ARTIFICIAL (fndecl
) = 1;
8134 /* Make the function `inline' so that it is only emitted if it is
8135 actually needed. It is unlikely that it will be inlined, since
8136 it is only called via a function pointer, but we avoid unnecessary
8137 emissions this way. */
8138 DECL_DECLARED_INLINE_P (fndecl
) = 1;
8139 DECL_INTERFACE_KNOWN (fndecl
) = 1;
8140 /* Build the parameter. */
8143 tree parmdecl
= cp_build_parm_decl (fndecl
, NULL_TREE
, ptr_type_node
);
8144 TREE_USED (parmdecl
) = 1;
8145 DECL_READ_P (parmdecl
) = 1;
8146 DECL_ARGUMENTS (fndecl
) = parmdecl
;
8150 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
8152 pop_lang_context ();
8154 return current_function_decl
;
8157 /* Finish the cleanup function begun by start_cleanup_fn. */
8160 end_cleanup_fn (void)
8162 expand_or_defer_fn (finish_function (/*inline_p=*/false));
8164 pop_from_top_level ();
8167 /* Generate code to handle the destruction of DECL, an object with
8168 static storage duration. */
8171 register_dtor_fn (tree decl
)
8178 bool ob_parm
, dso_parm
, use_dtor
;
8179 tree arg0
, arg1
, arg2
;
8182 type
= TREE_TYPE (decl
);
8183 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
8186 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
8187 "__aeabi_atexit"), and DECL is a class object, we can just pass the
8188 destructor to "__cxa_atexit"; we don't have to build a temporary
8189 function to do the cleanup. */
8190 dso_parm
= (flag_use_cxa_atexit
8191 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
8192 ob_parm
= (CP_DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
8193 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
8196 cleanup
= get_class_binding (type
, complete_dtor_identifier
);
8198 /* Make sure it is accessible. */
8199 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
8200 tf_warning_or_error
);
8204 /* Call build_cleanup before we enter the anonymous function so
8205 that any access checks will be done relative to the current
8206 scope, rather than the scope of the anonymous function. */
8207 build_cleanup (decl
);
8209 /* Now start the function. */
8210 cleanup
= start_cleanup_fn ();
8212 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8213 to the original function, rather than the anonymous one. That
8214 will make the back end think that nested functions are in use,
8215 which causes confusion. */
8216 push_deferring_access_checks (dk_no_check
);
8217 fcall
= build_cleanup (decl
);
8218 pop_deferring_access_checks ();
8220 /* Create the body of the anonymous function. */
8221 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
8222 finish_expr_stmt (fcall
);
8223 finish_compound_stmt (compound_stmt
);
8227 /* Call atexit with the cleanup function. */
8228 mark_used (cleanup
);
8229 cleanup
= build_address (cleanup
);
8231 if (CP_DECL_THREAD_LOCAL_P (decl
))
8232 atex_node
= get_thread_atexit_node ();
8234 atex_node
= get_atexit_node ();
8238 /* We must convert CLEANUP to the type that "__cxa_atexit"
8240 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
8241 /* "__cxa_atexit" will pass the address of DECL to the
8242 cleanup function. */
8244 addr
= build_address (decl
);
8245 /* The declared type of the parameter to "__cxa_atexit" is
8246 "void *". For plain "T*", we could just let the
8247 machinery in cp_build_function_call convert it -- but if the
8248 type is "cv-qualified T *", then we need to convert it
8249 before passing it in, to avoid spurious errors. */
8250 addr
= build_nop (ptr_type_node
, addr
);
8253 /* Since the cleanup functions we build ignore the address
8254 they're given, there's no reason to pass the actual address
8255 in, and, in general, it's cheaper to pass NULL than any
8257 addr
= null_pointer_node
;
8260 arg2
= cp_build_addr_expr (get_dso_handle_node (),
8261 tf_warning_or_error
);
8263 /* Just pass NULL to the dso handle parm if we don't actually
8264 have a DSO handle on this target. */
8265 arg2
= null_pointer_node
;
8271 if (!CP_DECL_THREAD_LOCAL_P (decl
)
8272 && targetm
.cxx
.use_aeabi_atexit ())
8288 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
8289 arg0
, arg1
, arg2
, NULL_TREE
);
8292 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
8293 is its initializer. Generate code to handle the construction
8294 and destruction of DECL. */
8297 expand_static_init (tree decl
, tree init
)
8299 gcc_assert (VAR_P (decl
));
8300 gcc_assert (TREE_STATIC (decl
));
8302 /* Some variables require no dynamic initialization. */
8303 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
8305 /* Make sure the destructor is callable. */
8306 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
8311 if (CP_DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
8312 && !DECL_FUNCTION_SCOPE_P (decl
))
8314 location_t dloc
= DECL_SOURCE_LOCATION (decl
);
8316 error_at (dloc
, "non-local variable %qD declared %<__thread%> "
8317 "needs dynamic initialization", decl
);
8319 error_at (dloc
, "non-local variable %qD declared %<__thread%> "
8320 "has a non-trivial destructor", decl
);
8321 static bool informed
;
8324 inform (dloc
, "C++11 %<thread_local%> allows dynamic "
8325 "initialization and destruction");
8331 if (DECL_FUNCTION_SCOPE_P (decl
))
8333 /* Emit code to perform this initialization but once. */
8334 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
8335 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
8336 tree guard
, guard_addr
;
8338 /* We don't need thread-safety code for thread-local vars. */
8339 bool thread_guard
= (flag_threadsafe_statics
8340 && !CP_DECL_THREAD_LOCAL_P (decl
));
8342 /* Emit code to perform this initialization but once. This code
8345 static <type> guard;
8346 if (!__atomic_load (guard.first_byte)) {
8347 if (__cxa_guard_acquire (&guard)) {
8350 // Do initialization.
8351 flag = true; __cxa_guard_release (&guard);
8352 // Register variable for destruction at end of program.
8354 if (!flag) __cxa_guard_abort (&guard);
8359 Note that the `flag' variable is only set to 1 *after* the
8360 initialization is complete. This ensures that an exception,
8361 thrown during the construction, will cause the variable to
8362 reinitialized when we pass through this code again, as per:
8366 If the initialization exits by throwing an exception, the
8367 initialization is not complete, so it will be tried again
8368 the next time control enters the declaration.
8370 This process should be thread-safe, too; multiple threads
8371 should not be able to initialize the variable more than
8374 /* Create the guard variable. */
8375 guard
= get_guard (decl
);
8377 /* Begin the conditional initialization. */
8378 if_stmt
= begin_if_stmt ();
8380 finish_if_stmt_cond (get_guard_cond (guard
, thread_guard
), if_stmt
);
8381 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
8385 tree vfntype
= NULL_TREE
;
8386 tree acquire_name
, release_name
, abort_name
;
8387 tree acquire_fn
, release_fn
, abort_fn
;
8388 guard_addr
= build_address (guard
);
8390 acquire_name
= get_identifier ("__cxa_guard_acquire");
8391 release_name
= get_identifier ("__cxa_guard_release");
8392 abort_name
= get_identifier ("__cxa_guard_abort");
8393 acquire_fn
= get_global_binding (acquire_name
);
8394 release_fn
= get_global_binding (release_name
);
8395 abort_fn
= get_global_binding (abort_name
);
8397 acquire_fn
= push_library_fn
8398 (acquire_name
, build_function_type_list (integer_type_node
,
8399 TREE_TYPE (guard_addr
),
8401 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
8402 if (!release_fn
|| !abort_fn
)
8403 vfntype
= build_function_type_list (void_type_node
,
8404 TREE_TYPE (guard_addr
),
8407 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
8408 ECF_NOTHROW
| ECF_LEAF
);
8410 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
8411 ECF_NOTHROW
| ECF_LEAF
);
8413 inner_if_stmt
= begin_if_stmt ();
8414 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
8417 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
8418 begin
= get_target_expr (boolean_false_node
);
8419 flag
= TARGET_EXPR_SLOT (begin
);
8421 TARGET_EXPR_CLEANUP (begin
)
8422 = build3 (COND_EXPR
, void_type_node
, flag
,
8424 build_call_n (abort_fn
, 1, guard_addr
));
8425 CLEANUP_EH_ONLY (begin
) = 1;
8427 /* Do the initialization itself. */
8428 init
= add_stmt_to_compound (begin
, init
);
8429 init
= add_stmt_to_compound
8430 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
8431 init
= add_stmt_to_compound
8432 (init
, build_call_n (release_fn
, 1, guard_addr
));
8435 init
= add_stmt_to_compound (init
, set_guard (guard
));
8437 /* Use atexit to register a function for destroying this static
8439 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
8441 finish_expr_stmt (init
);
8445 finish_compound_stmt (inner_then_clause
);
8446 finish_then_clause (inner_if_stmt
);
8447 finish_if_stmt (inner_if_stmt
);
8450 finish_compound_stmt (then_clause
);
8451 finish_then_clause (if_stmt
);
8452 finish_if_stmt (if_stmt
);
8454 else if (CP_DECL_THREAD_LOCAL_P (decl
))
8455 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
8457 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
8461 /* Make TYPE a complete type based on INITIAL_VALUE.
8462 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8463 2 if there was no information (in which case assume 0 if DO_DEFAULT),
8464 3 if the initializer list is empty (in pedantic mode). */
8467 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
8470 tree type
, elt_type
;
8472 /* Don't get confused by a CONSTRUCTOR for some other type. */
8473 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
8474 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
)
8475 && TREE_CODE (TREE_TYPE (initial_value
)) != ARRAY_TYPE
)
8480 unsigned HOST_WIDE_INT i
;
8483 /* An array of character type can be initialized from a
8484 brace-enclosed string constant.
8486 FIXME: this code is duplicated from reshape_init. Probably
8487 we should just call reshape_init here? */
8488 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
8489 && TREE_CODE (initial_value
) == CONSTRUCTOR
8490 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
8492 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
8493 tree value
= (*v
)[0].value
;
8494 STRIP_ANY_LOCATION_WRAPPER (value
);
8496 if (TREE_CODE (value
) == STRING_CST
8497 && v
->length () == 1)
8498 initial_value
= value
;
8501 /* If any of the elements are parameter packs, we can't actually
8502 complete this type now because the array size is dependent. */
8503 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8505 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
8508 if (PACK_EXPANSION_P (value
))
8514 failure
= complete_array_type (ptype
, initial_value
, do_default
);
8516 /* We can create the array before the element type is complete, which
8517 means that we didn't have these two bits set in the original type
8518 either. In completing the type, we are expected to propagate these
8519 bits. See also complete_type which does the same thing for arrays
8522 if (type
!= error_mark_node
&& TYPE_DOMAIN (type
))
8524 elt_type
= TREE_TYPE (type
);
8525 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
8526 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
8527 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
8533 /* As above, but either give an error or reject zero-size arrays, depending
8537 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
8538 bool do_default
, tsubst_flags_t complain
)
8541 bool sfinae
= !(complain
& tf_error
);
8542 /* In SFINAE context we can't be lenient about zero-size arrays. */
8545 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
8551 /* Not an error. */;
8552 else if (failure
== 1)
8553 error ("initializer fails to determine size of %qT", *ptype
);
8554 else if (failure
== 2)
8557 error ("array size missing in %qT", *ptype
);
8559 else if (failure
== 3)
8560 error ("zero-size array %qT", *ptype
);
8561 *ptype
= error_mark_node
;
8566 /* Return zero if something is declared to be a member of type
8567 CTYPE when in the context of CUR_TYPE. STRING is the error
8568 message to print in that case. Otherwise, quietly return 1. */
8571 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
8573 if (ctype
&& ctype
!= cur_type
)
8575 if (flags
== DTOR_FLAG
)
8576 error ("destructor for alien class %qT cannot be a member", ctype
);
8578 error ("constructor for alien class %qT cannot be a member", ctype
);
8584 /* Subroutine of `grokdeclarator'. */
8586 /* Generate errors possibly applicable for a given set of specifiers.
8587 This is for ARM $7.1.2. */
8590 bad_specifiers (tree object
,
8591 enum bad_spec_place type
,
8597 const location_t
* locations
)
8603 error_at (locations
[ds_virtual
],
8604 "%qD declared as a %<virtual%> variable", object
);
8606 error ("%<const%> and %<volatile%> function specifiers on "
8607 "%qD invalid in variable declaration", object
);
8611 error_at (locations
[ds_virtual
],
8612 "%qD declared as a %<virtual%> parameter", object
);
8614 error_at (locations
[ds_inline
],
8615 "%qD declared as an %<inline%> parameter", object
);
8617 error ("%<const%> and %<volatile%> function specifiers on "
8618 "%qD invalid in parameter declaration", object
);
8622 error_at (locations
[ds_virtual
],
8623 "%qD declared as a %<virtual%> type", object
);
8625 error_at (locations
[ds_inline
],
8626 "%qD declared as an %<inline%> type", object
);
8628 error ("%<const%> and %<volatile%> function specifiers on "
8629 "%qD invalid in type declaration", object
);
8633 error_at (locations
[ds_virtual
],
8634 "%qD declared as a %<virtual%> field", object
);
8636 error_at (locations
[ds_inline
],
8637 "%qD declared as an %<inline%> field", object
);
8639 error ("%<const%> and %<volatile%> function specifiers on "
8640 "%qD invalid in field declaration", object
);
8646 error ("%q+D declared as a friend", object
);
8648 && !flag_noexcept_type
8649 && (TREE_CODE (object
) == TYPE_DECL
8650 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
8651 && !TYPE_REFFN_P (TREE_TYPE (object
))
8652 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
8653 error ("%q+D declared with an exception specification", object
);
8656 /* DECL is a member function or static data member and is presently
8657 being defined. Check that the definition is taking place in a
8661 check_class_member_definition_namespace (tree decl
)
8663 /* These checks only apply to member functions and static data
8665 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
8666 /* We check for problems with specializations in pt.c in
8667 check_specialization_namespace, where we can issue better
8669 if (processing_specialization
)
8671 /* We check this in check_explicit_instantiation_namespace. */
8672 if (processing_explicit_instantiation
)
8676 A member function definition that appears outside of the
8677 class definition shall appear in a namespace scope enclosing
8678 the class definition.
8682 The definition for a static data member shall appear in a
8683 namespace scope enclosing the member's class definition. */
8684 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
8685 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
8686 decl
, DECL_CONTEXT (decl
));
8689 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
8690 METHOD_TYPE for a non-static member function; QUALS are the
8691 cv-qualifiers that apply to the function. */
8694 build_this_parm (tree fn
, tree type
, cp_cv_quals quals
)
8699 cp_cv_quals this_quals
;
8701 if (CLASS_TYPE_P (type
))
8704 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
8705 this_type
= build_pointer_type (this_type
);
8708 this_type
= type_of_this_parm (type
);
8709 /* The `this' parameter is implicitly `const'; it cannot be
8711 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
8712 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
8713 parm
= build_artificial_parm (fn
, this_identifier
, qual_type
);
8714 cp_apply_type_quals_to_decl (this_quals
, parm
);
8718 /* DECL is a static member function. Complain if it was declared
8719 with function-cv-quals. */
8722 check_static_quals (tree decl
, cp_cv_quals quals
)
8724 if (quals
!= TYPE_UNQUALIFIED
)
8725 error ("static member function %q#D declared with type qualifiers",
8729 // Check that FN takes no arguments and returns bool.
8731 check_concept_fn (tree fn
)
8733 // A constraint is nullary.
8734 if (DECL_ARGUMENTS (fn
))
8735 error_at (DECL_SOURCE_LOCATION (fn
),
8736 "concept %q#D declared with function parameters", fn
);
8738 // The declared return type of the concept shall be bool, and
8739 // it shall not be deduced from it definition.
8740 tree type
= TREE_TYPE (TREE_TYPE (fn
));
8742 error_at (DECL_SOURCE_LOCATION (fn
),
8743 "concept %q#D declared with a deduced return type", fn
);
8744 else if (type
!= boolean_type_node
)
8745 error_at (DECL_SOURCE_LOCATION (fn
),
8746 "concept %q#D with non-%<bool%> return type %qT", fn
, type
);
8749 /* Helper function. Replace the temporary this parameter injected
8750 during cp_finish_omp_declare_simd with the real this parameter. */
8753 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
8755 tree this_parm
= (tree
) data
;
8756 if (TREE_CODE (*tp
) == PARM_DECL
8757 && DECL_NAME (*tp
) == this_identifier
8758 && *tp
!= this_parm
)
8760 else if (TYPE_P (*tp
))
8765 /* CTYPE is class type, or null if non-class.
8766 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8768 DECLARATOR is the function's name.
8769 PARMS is a chain of PARM_DECLs for the function.
8770 VIRTUALP is truthvalue of whether the function is virtual or not.
8771 FLAGS are to be passed through to `grokclassfn'.
8772 QUALS are qualifiers indicating whether the function is `const'
8774 RAISES is a list of exceptions that this function can raise.
8775 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8776 not look, and -1 if we should not call `grokclassfn' at all.
8778 SFK is the kind of special function (if any) for the new function.
8780 Returns `NULL_TREE' if something goes wrong, after issuing
8781 applicable error messages. */
8784 grokfndecl (tree ctype
,
8788 tree orig_declarator
,
8789 const cp_decl_specifier_seq
*declspecs
,
8792 enum overload_flags flags
,
8794 cp_ref_qualifier rqual
,
8801 special_function_kind sfk
,
8803 bool late_return_type_p
,
8807 location_t location
)
8810 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8813 if (location
== UNKNOWN_LOCATION
)
8814 location
= input_location
;
8816 // Was the concept specifier present?
8817 bool concept_p
= inlinep
& 4;
8819 // Concept declarations must have a corresponding definition.
8820 if (concept_p
&& !funcdef_flag
)
8822 error_at (location
, "concept %qD has no definition", declarator
);
8826 type
= build_cp_fntype_variant (type
, rqual
, raises
, late_return_type_p
);
8828 decl
= build_lang_decl_loc (location
, FUNCTION_DECL
, declarator
, type
);
8830 /* Set the constraints on the declaration. */
8833 tree tmpl_reqs
= NULL_TREE
;
8834 if (processing_template_decl
> template_class_depth (ctype
))
8835 tmpl_reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
8837 /* Adjust the required expression into a constraint. */
8839 decl_reqs
= normalize_expression (decl_reqs
);
8841 tree ci
= build_constraints (tmpl_reqs
, decl_reqs
);
8842 set_constraints (decl
, ci
);
8845 if (TREE_CODE (type
) == METHOD_TYPE
)
8847 tree parm
= build_this_parm (decl
, type
, quals
);
8848 DECL_CHAIN (parm
) = parms
;
8851 /* Allocate space to hold the vptr bit if needed. */
8852 SET_DECL_ALIGN (decl
, MINIMUM_METHOD_BOUNDARY
);
8855 DECL_ARGUMENTS (decl
) = parms
;
8856 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
8857 DECL_CONTEXT (t
) = decl
;
8859 /* Propagate volatile out from type to decl. */
8860 if (TYPE_VOLATILE (type
))
8861 TREE_THIS_VOLATILE (decl
) = 1;
8863 /* Setup decl according to sfk. */
8866 case sfk_constructor
:
8867 case sfk_copy_constructor
:
8868 case sfk_move_constructor
:
8869 DECL_CXX_CONSTRUCTOR_P (decl
) = 1;
8870 DECL_NAME (decl
) = ctor_identifier
;
8872 case sfk_destructor
:
8873 DECL_CXX_DESTRUCTOR_P (decl
) = 1;
8874 DECL_NAME (decl
) = dtor_identifier
;
8880 if (friendp
&& TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8884 "defining explicit specialization %qD in friend declaration",
8888 tree fns
= TREE_OPERAND (orig_declarator
, 0);
8889 tree args
= TREE_OPERAND (orig_declarator
, 1);
8891 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8893 /* Something like `template <class T> friend void f<T>()'. */
8895 "invalid use of template-id %qD in declaration "
8896 "of primary template",
8902 /* A friend declaration of the form friend void f<>(). Record
8903 the information in the TEMPLATE_ID_EXPR. */
8904 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8906 gcc_assert (identifier_p (fns
)
8907 || TREE_CODE (fns
) == OVERLOAD
8908 || TREE_CODE (fns
) == FUNCTION_DECL
);
8909 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
8911 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8912 if (TREE_PURPOSE (t
)
8913 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8915 error_at (defarg_location (TREE_PURPOSE (t
)),
8916 "default arguments are not allowed in declaration "
8917 "of friend template specialization %qD",
8924 error_at (declspecs
->locations
[ds_inline
],
8925 "%<inline%> is not allowed in declaration of friend "
8926 "template specialization %qD",
8933 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
8934 expression, that declaration shall be a definition..." */
8935 if (friendp
&& !funcdef_flag
)
8937 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
8938 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
8939 if (TREE_PURPOSE (t
))
8941 permerror (DECL_SOURCE_LOCATION (decl
),
8942 "friend declaration of %qD specifies default "
8943 "arguments and isn%'t a definition", decl
);
8948 /* If this decl has namespace scope, set that up. */
8950 set_decl_namespace (decl
, in_namespace
, friendp
);
8952 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
8954 /* `main' and builtins have implicit 'C' linkage. */
8955 if (ctype
== NULL_TREE
8956 && DECL_FILE_SCOPE_P (decl
)
8957 && current_lang_name
== lang_name_cplusplus
8958 && (MAIN_NAME_P (declarator
)
8959 || (IDENTIFIER_LENGTH (declarator
) > 10
8960 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8961 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8962 && strncmp (IDENTIFIER_POINTER (declarator
)+2,
8963 "builtin_", 8) == 0)
8964 || (targetcm
.cxx_implicit_extern_c
8965 && (targetcm
.cxx_implicit_extern_c
8966 (IDENTIFIER_POINTER (declarator
))))))
8967 SET_DECL_LANGUAGE (decl
, lang_c
);
8969 /* Should probably propagate const out from type to decl I bet (mrs). */
8972 DECL_STATIC_FUNCTION_P (decl
) = 1;
8973 DECL_CONTEXT (decl
) = ctype
;
8977 DECL_DELETED_FN (decl
) = 1;
8981 DECL_CONTEXT (decl
) = ctype
;
8983 check_class_member_definition_namespace (decl
);
8986 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8988 if (PROCESSING_REAL_TEMPLATE_DECL_P())
8989 error_at (location
, "cannot declare %<::main%> to be a template");
8991 error_at (declspecs
->locations
[ds_inline
],
8992 "cannot declare %<::main%> to be inline");
8994 error_at (declspecs
->locations
[ds_constexpr
],
8995 "cannot declare %<::main%> to be %<constexpr%>");
8997 error_at (location
, "cannot declare %<::main%> to be static");
9002 /* Members of anonymous types and local classes have no linkage; make
9003 them internal. If a typedef is made later, this will be changed. */
9004 if (ctype
&& (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype
))
9005 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
9008 if (publicp
&& cxx_dialect
== cxx98
)
9010 /* [basic.link]: A name with no linkage (notably, the name of a class
9011 or enumeration declared in a local scope) shall not be used to
9012 declare an entity with linkage.
9014 DR 757 relaxes this restriction for C++0x. */
9015 no_linkage_error (decl
);
9018 TREE_PUBLIC (decl
) = publicp
;
9021 DECL_INTERFACE_KNOWN (decl
) = 1;
9022 DECL_NOT_REALLY_EXTERN (decl
) = 1;
9025 /* If the declaration was declared inline, mark it as such. */
9028 DECL_DECLARED_INLINE_P (decl
) = 1;
9030 DECL_COMDAT (decl
) = 1;
9033 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
9035 // If the concept declaration specifier was found, check
9036 // that the declaration satisfies the necessary requirements.
9039 DECL_DECLARED_CONCEPT_P (decl
) = true;
9040 check_concept_fn (decl
);
9043 DECL_EXTERNAL (decl
) = 1;
9044 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9047 TREE_TYPE (decl
) = apply_memfn_quals (TREE_TYPE (decl
),
9054 ? G_("static member function %qD cannot have cv-qualifier")
9055 : G_("non-member function %qD cannot have cv-qualifier"),
9057 quals
= TYPE_UNQUALIFIED
;
9063 ? G_("static member function %qD cannot have ref-qualifier")
9064 : G_("non-member function %qD cannot have ref-qualifier"),
9066 rqual
= REF_QUAL_NONE
;
9070 if (deduction_guide_p (decl
))
9072 if (!DECL_NAMESPACE_SCOPE_P (decl
))
9074 error_at (location
, "deduction guide %qD must be declared at "
9075 "namespace scope", decl
);
9080 "deduction guide %qD must not have a function body", decl
);
9082 else if (IDENTIFIER_ANY_OP_P (DECL_NAME (decl
))
9083 && !grok_op_properties (decl
, /*complain=*/true))
9085 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
9087 bool long_long_unsigned_p
;
9089 const char *suffix
= NULL
;
9090 /* [over.literal]/6: Literal operators shall not have C linkage. */
9091 if (DECL_LANGUAGE (decl
) == lang_c
)
9093 error_at (location
, "literal operator with C linkage");
9094 maybe_show_extern_c_location ();
9098 if (DECL_NAMESPACE_SCOPE_P (decl
))
9100 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
9103 error_at (location
, "%qD has invalid argument list", decl
);
9107 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
9108 if (long_long_unsigned_p
)
9110 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
9111 warning_at (location
, 0, "integer suffix %qs"
9112 " shadowed by implementation", suffix
);
9114 else if (long_double_p
)
9116 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
9117 warning_at (location
, 0, "floating point suffix %qs"
9118 " shadowed by implementation", suffix
);
9121 if (suffix
[0] != '_'
9122 && !in_system_header_at (location
)
9123 && !current_function_decl
&& !(friendp
&& !funcdef_flag
))
9124 warning_at (location
, OPT_Wliteral_suffix
,
9125 "literal operator suffixes not preceded by %<_%>"
9126 " are reserved for future standardization");
9130 error_at (location
, "%qD must be a non-member function", decl
);
9136 /* Make the init_value nonzero so pushdecl knows this is not
9137 tentative. error_mark_node is replaced later with the BLOCK. */
9138 DECL_INITIAL (decl
) = error_mark_node
;
9140 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
9141 TREE_NOTHROW (decl
) = 1;
9143 if (flag_openmp
|| flag_openmp_simd
)
9145 /* Adjust "omp declare simd" attributes. */
9146 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
9150 for (attr
= ods
; attr
;
9151 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
9153 if (TREE_CODE (type
) == METHOD_TYPE
)
9154 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
9155 DECL_ARGUMENTS (decl
), NULL
);
9156 if (TREE_VALUE (attr
) != NULL_TREE
)
9158 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
9159 cl
= c_omp_declare_simd_clauses_to_numbers
9160 (DECL_ARGUMENTS (decl
), cl
);
9162 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
9164 TREE_VALUE (attr
) = NULL_TREE
;
9170 /* Caller will do the rest of this. */
9174 if (ctype
!= NULL_TREE
)
9175 grokclassfn (ctype
, decl
, flags
);
9178 if (cxx_dialect
>= cxx11
9179 && DECL_DESTRUCTOR_P (decl
)
9180 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
9181 && !processing_template_decl
)
9182 deduce_noexcept_on_destructor (decl
);
9184 decl
= check_explicit_specialization (orig_declarator
, decl
,
9187 4 * (friendp
!= 0) +
9190 if (decl
== error_mark_node
)
9193 if (DECL_STATIC_FUNCTION_P (decl
))
9194 check_static_quals (decl
, quals
);
9198 cplus_decl_attributes (&decl
, *attrlist
, 0);
9199 *attrlist
= NULL_TREE
;
9202 /* Check main's type after attributes have been applied. */
9203 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
9205 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
9208 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
9210 error_at (declspecs
->locations
[ds_type_spec
],
9211 "%<::main%> must return %<int%>");
9212 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
9213 TREE_TYPE (decl
) = newtype
;
9216 check_main_parameter_types (decl
);
9219 if (ctype
!= NULL_TREE
&& check
)
9221 tree old_decl
= check_classfn (ctype
, decl
,
9222 (processing_template_decl
9223 > template_class_depth (ctype
))
9224 ? current_template_parms
9227 if (old_decl
== error_mark_node
)
9235 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
9236 /* Because grokfndecl is always supposed to return a
9237 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9238 here. We depend on our callers to figure out that its
9239 really a template that's being returned. */
9240 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
9242 if (DECL_STATIC_FUNCTION_P (old_decl
)
9243 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
9245 /* Remove the `this' parm added by grokclassfn. */
9246 revert_static_member_fn (decl
);
9247 check_static_quals (decl
, quals
);
9249 if (DECL_ARTIFICIAL (old_decl
))
9251 error ("definition of implicitly-declared %qD", old_decl
);
9254 else if (DECL_DEFAULTED_FN (old_decl
))
9256 error ("definition of explicitly-defaulted %q+D", decl
);
9257 inform (DECL_SOURCE_LOCATION (old_decl
),
9258 "%q#D explicitly defaulted here", old_decl
);
9262 /* Since we've smashed OLD_DECL to its
9263 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
9264 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9265 decl
= DECL_TEMPLATE_RESULT (decl
);
9267 /* Attempt to merge the declarations. This can fail, in
9268 the case of some invalid specialization declarations. */
9269 pushed_scope
= push_scope (ctype
);
9270 ok
= duplicate_decls (decl
, old_decl
, friendp
);
9272 pop_scope (pushed_scope
);
9275 error ("no %q#D member function declared in class %qT",
9279 if (ok
== error_mark_node
)
9285 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
9288 if (ctype
== NULL_TREE
|| check
)
9292 DECL_VIRTUAL_P (decl
) = 1;
9297 /* decl is a FUNCTION_DECL.
9298 specifiers are the parsed virt-specifiers.
9300 Set flags to reflect the virt-specifiers.
9305 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
9307 if (decl
== NULL_TREE
)
9309 if (specifiers
& VIRT_SPEC_OVERRIDE
)
9310 DECL_OVERRIDE_P (decl
) = 1;
9311 if (specifiers
& VIRT_SPEC_FINAL
)
9312 DECL_FINAL_P (decl
) = 1;
9316 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
9317 the linkage that DECL will receive in the object file. */
9320 set_linkage_for_static_data_member (tree decl
)
9322 /* A static data member always has static storage duration and
9323 external linkage. Note that static data members are forbidden in
9324 local classes -- the only situation in which a class has
9325 non-external linkage. */
9326 TREE_PUBLIC (decl
) = 1;
9327 TREE_STATIC (decl
) = 1;
9328 /* For non-template classes, static data members are always put
9329 out in exactly those files where they are defined, just as
9330 with ordinary namespace-scope variables. */
9331 if (!processing_template_decl
)
9332 DECL_INTERFACE_KNOWN (decl
) = 1;
9335 /* Create a VAR_DECL named NAME with the indicated TYPE.
9337 If SCOPE is non-NULL, it is the class type or namespace containing
9338 the variable. If SCOPE is NULL, the variable should is created in
9339 the innermost enclosing scope. */
9342 grokvardecl (tree type
,
9344 tree orig_declarator
,
9345 const cp_decl_specifier_seq
*declspecs
,
9352 location_t location
)
9355 tree explicit_scope
;
9357 gcc_assert (!name
|| identifier_p (name
));
9359 bool constp
= (type_quals
& TYPE_QUAL_CONST
) != 0;
9360 bool volatilep
= (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
9362 /* Compute the scope in which to place the variable, but remember
9363 whether or not that scope was explicitly specified by the user. */
9364 explicit_scope
= scope
;
9367 /* An explicit "extern" specifier indicates a namespace-scope
9369 if (declspecs
->storage_class
== sc_extern
)
9370 scope
= current_decl_namespace ();
9371 else if (!at_function_scope_p ())
9372 scope
= current_scope ();
9376 && (/* If the variable is a namespace-scope variable declared in a
9377 template, we need DECL_LANG_SPECIFIC. */
9378 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
9379 /* Similarly for namespace-scope variables with language linkage
9381 || (TREE_CODE (scope
) == NAMESPACE_DECL
9382 && current_lang_name
!= lang_name_cplusplus
)
9383 /* Similarly for static data members. */
9385 /* Similarly for explicit specializations. */
9387 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
9388 decl
= build_lang_decl_loc (location
, VAR_DECL
, name
, type
);
9390 decl
= build_decl (location
, VAR_DECL
, name
, type
);
9392 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
9393 set_decl_namespace (decl
, explicit_scope
, 0);
9395 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
9397 if (declspecs
->storage_class
== sc_extern
)
9399 DECL_THIS_EXTERN (decl
) = 1;
9400 DECL_EXTERNAL (decl
) = !initialized
;
9403 if (DECL_CLASS_SCOPE_P (decl
))
9405 set_linkage_for_static_data_member (decl
);
9406 /* This function is only called with out-of-class definitions. */
9407 DECL_EXTERNAL (decl
) = 0;
9408 check_class_member_definition_namespace (decl
);
9410 /* At top level, either `static' or no s.c. makes a definition
9411 (perhaps tentative), and absence of `static' makes it public. */
9412 else if (toplevel_bindings_p ())
9414 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
9415 && (DECL_THIS_EXTERN (decl
)
9419 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
9421 /* Not at top level, only `static' makes a static definition. */
9424 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
9425 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
9428 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
9430 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
9432 CP_DECL_THREAD_LOCAL_P (decl
) = true;
9433 if (!processing_template_decl
)
9434 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
9436 if (declspecs
->gnu_thread_keyword_p
)
9437 SET_DECL_GNU_TLS_P (decl
);
9440 /* If the type of the decl has no linkage, make sure that we'll
9441 notice that in mark_used. */
9442 if (cxx_dialect
> cxx98
9443 && decl_linkage (decl
) != lk_none
9444 && DECL_LANG_SPECIFIC (decl
) == NULL
9445 && !DECL_EXTERN_C_P (decl
)
9446 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
9447 retrofit_lang_decl (decl
);
9449 if (TREE_PUBLIC (decl
))
9451 /* [basic.link]: A name with no linkage (notably, the name of a class
9452 or enumeration declared in a local scope) shall not be used to
9453 declare an entity with linkage.
9455 DR 757 relaxes this restriction for C++0x. */
9456 if (cxx_dialect
< cxx11
)
9457 no_linkage_error (decl
);
9460 DECL_INTERFACE_KNOWN (decl
) = 1;
9462 if (DECL_NAME (decl
)
9463 && MAIN_NAME_P (DECL_NAME (decl
))
9464 && scope
== global_namespace
)
9465 error ("cannot declare %<::main%> to be a global variable");
9467 /* Check that the variable can be safely declared as a concept.
9468 Note that this also forbids explicit specializations. */
9471 if (!processing_template_decl
)
9473 error_at (declspecs
->locations
[ds_concept
],
9474 "a non-template variable cannot be %<concept%>");
9478 DECL_DECLARED_CONCEPT_P (decl
) = true;
9479 if (!same_type_ignoring_top_level_qualifiers_p (type
, boolean_type_node
))
9480 error_at (declspecs
->locations
[ds_type_spec
],
9481 "concept must have type %<bool%>");
9483 else if (flag_concepts
9484 && processing_template_decl
> template_class_depth (scope
))
9486 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
9487 tree ci
= build_constraints (reqs
, NULL_TREE
);
9488 set_constraints (decl
, ci
);
9491 // Handle explicit specializations and instantiations of variable templates.
9492 if (orig_declarator
)
9493 decl
= check_explicit_specialization (orig_declarator
, decl
,
9494 template_count
, conceptp
* 8);
9496 return decl
!= error_mark_node
? decl
: NULL_TREE
;
9499 /* Create and return a canonical pointer to member function type, for
9500 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9503 build_ptrmemfunc_type (tree type
)
9508 if (type
== error_mark_node
)
9511 /* Make sure that we always have the unqualified pointer-to-member
9513 if (cp_cv_quals quals
= cp_type_quals (type
))
9515 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
9516 return cp_build_qualified_type (unqual
, quals
);
9519 /* If a canonical type already exists for this type, use it. We use
9520 this method instead of type_hash_canon, because it only does a
9521 simple equality check on the list of field members. */
9523 t
= TYPE_PTRMEMFUNC_TYPE (type
);
9527 t
= make_node (RECORD_TYPE
);
9529 /* Let the front end know this is a pointer to member function. */
9530 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
9532 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
9535 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
9537 DECL_CHAIN (field
) = fields
;
9540 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
9542 /* Zap out the name so that the back end will give us the debugging
9543 information for this anonymous RECORD_TYPE. */
9544 TYPE_NAME (t
) = NULL_TREE
;
9546 /* Cache this pointer-to-member type so that we can find it again
9548 TYPE_PTRMEMFUNC_TYPE (type
) = t
;
9550 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
9551 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9552 else if (TYPE_CANONICAL (type
) != type
)
9553 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
9558 /* Create and return a pointer to data member type. */
9561 build_ptrmem_type (tree class_type
, tree member_type
)
9563 if (TREE_CODE (member_type
) == METHOD_TYPE
)
9565 cp_cv_quals quals
= type_memfn_quals (member_type
);
9566 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
9567 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
9568 return build_ptrmemfunc_type (build_pointer_type (member_type
));
9572 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
9573 return build_offset_type (class_type
, member_type
);
9577 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9578 Check to see that the definition is valid. Issue appropriate error
9582 check_static_variable_definition (tree decl
, tree type
)
9584 /* Avoid redundant diagnostics on out-of-class definitions. */
9585 if (!current_class_type
|| !TYPE_BEING_DEFINED (current_class_type
))
9587 /* Can't check yet if we don't know the type. */
9588 else if (dependent_type_p (type
))
9590 /* If DECL is declared constexpr, we'll do the appropriate checks
9591 in check_initializer. Similarly for inline static data members. */
9592 else if (DECL_P (decl
)
9593 && (DECL_DECLARED_CONSTEXPR_P (decl
)
9594 || undeduced_auto_decl (decl
)
9595 || DECL_VAR_DECLARED_INLINE_P (decl
)))
9597 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
9599 if (!COMPLETE_TYPE_P (type
))
9600 error_at (DECL_SOURCE_LOCATION (decl
),
9601 "in-class initialization of static data member %q#D of "
9602 "incomplete type", decl
);
9603 else if (literal_type_p (type
))
9604 permerror (DECL_SOURCE_LOCATION (decl
),
9605 "%<constexpr%> needed for in-class initialization of "
9606 "static data member %q#D of non-integral type", decl
);
9608 error_at (DECL_SOURCE_LOCATION (decl
),
9609 "in-class initialization of static data member %q#D of "
9610 "non-literal type", decl
);
9612 /* Motion 10 at San Diego: If a static const integral data member is
9613 initialized with an integral constant expression, the initializer
9614 may appear either in the declaration (within the class), or in
9615 the definition, but not both. If it appears in the class, the
9616 member is a member constant. The file-scope definition is always
9618 else if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
9619 error_at (DECL_SOURCE_LOCATION (decl
),
9620 "invalid in-class initialization of static data member "
9621 "of non-integral type %qT",
9623 else if (!CP_TYPE_CONST_P (type
))
9624 error_at (DECL_SOURCE_LOCATION (decl
),
9625 "ISO C++ forbids in-class initialization of non-const "
9626 "static member %qD",
9628 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
9629 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
9630 "ISO C++ forbids initialization of member constant "
9631 "%qD of non-integral type %qT", decl
, type
);
9634 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
9635 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
9636 expressions out into temporary variables so that walk_tree doesn't
9637 step into them (c++/15764). */
9640 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
9642 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
9643 tree expr
= *expr_p
;
9644 if (TREE_CODE (expr
) == SAVE_EXPR
)
9646 tree op
= TREE_OPERAND (expr
, 0);
9647 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
9648 if (TREE_SIDE_EFFECTS (op
))
9649 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
9652 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
9657 /* Entry point for the above. */
9660 stabilize_vla_size (tree size
)
9662 hash_set
<tree
> pset
;
9663 /* Break out any function calls into temporary variables. */
9664 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
9667 /* Reduce a SIZEOF_EXPR to its value. */
9670 fold_sizeof_expr (tree t
)
9673 if (SIZEOF_EXPR_TYPE_P (t
))
9674 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
9675 SIZEOF_EXPR
, false, false);
9676 else if (TYPE_P (TREE_OPERAND (t
, 0)))
9677 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
9680 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
9682 if (r
== error_mark_node
)
9687 /* Given the SIZE (i.e., number of elements) in an array, compute
9688 an appropriate index type for the array. If non-NULL, NAME is
9689 the name of the entity being declared. */
9692 compute_array_index_type_loc (location_t name_loc
, tree name
, tree size
,
9693 tsubst_flags_t complain
)
9695 if (error_operand_p (size
))
9696 return error_mark_node
;
9698 /* The type of the index being computed. */
9701 /* The original numeric size as seen in the source code before
9702 conversion to size_t. */
9703 tree origsize
= size
;
9705 location_t loc
= cp_expr_loc_or_loc (size
, name
? name_loc
: input_location
);
9707 if (!type_dependent_expression_p (size
))
9709 origsize
= size
= mark_rvalue_use (size
);
9711 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
9712 && TREE_SIDE_EFFECTS (size
))
9713 /* In C++98, we mark a non-constant array bound with a magic
9714 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
9717 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
9718 size
= build_converted_constant_expr (size_type_node
, size
, complain
);
9719 /* Pedantically a constant expression is required here and so
9720 __builtin_is_constant_evaluated () should fold to true if it
9721 is successfully folded into a constant. */
9722 size
= maybe_constant_value (size
, NULL_TREE
,
9723 /*manifestly_const_eval=*/true);
9725 if (!TREE_CONSTANT (size
))
9729 if (error_operand_p (size
))
9730 return error_mark_node
;
9732 /* The array bound must be an integer type. */
9733 tree type
= TREE_TYPE (size
);
9734 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
9736 if (!(complain
& tf_error
))
9737 return error_mark_node
;
9739 error_at (loc
, "size of array %qD has non-integral type %qT",
9742 error_at (loc
, "size of array has non-integral type %qT", type
);
9743 size
= integer_one_node
;
9747 /* A type is dependent if it is...an array type constructed from any
9748 dependent type or whose size is specified by a constant expression
9749 that is value-dependent. */
9750 /* We can only call value_dependent_expression_p on integral constant
9751 expressions; treat non-constant expressions as dependent, too. */
9752 if (processing_template_decl
9753 && (type_dependent_expression_p (size
)
9754 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
9756 /* We cannot do any checking for a SIZE that isn't known to be
9757 constant. Just build the index type and mark that it requires
9758 structural equality checks. */
9759 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
9760 size
, size_one_node
));
9761 TYPE_DEPENDENT_P (itype
) = 1;
9762 TYPE_DEPENDENT_P_VALID (itype
) = 1;
9763 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
9767 if (TREE_CODE (size
) != INTEGER_CST
)
9769 tree folded
= cp_fully_fold (size
);
9770 if (TREE_CODE (folded
) == INTEGER_CST
)
9773 pedwarn (loc
, OPT_Wpedantic
, "size of array %qD is not an "
9774 "integral constant-expression", name
);
9776 pedwarn (loc
, OPT_Wpedantic
,
9777 "size of array is not an integral constant-expression");
9779 /* Use the folded result for VLAs, too; it will have resolved
9784 /* Normally, the array-bound will be a constant. */
9785 if (TREE_CODE (size
) == INTEGER_CST
)
9787 /* The size to use in diagnostics that reflects the constant
9788 size used in the source, rather than SIZE massaged above. */
9789 tree diagsize
= size
;
9791 /* If the original size before conversion to size_t was signed
9792 and negative, convert it to ssizetype to restore the sign. */
9793 if (!TYPE_UNSIGNED (TREE_TYPE (origsize
))
9794 && TREE_CODE (size
) == INTEGER_CST
9795 && tree_int_cst_sign_bit (size
))
9797 diagsize
= fold_convert (ssizetype
, size
);
9799 /* Clear the overflow bit that may have been set as a result
9800 of the conversion from the sizetype of the new size to
9802 TREE_OVERFLOW (diagsize
) = false;
9805 /* Verify that the array has a positive number of elements
9806 and issue the appropriate diagnostic if it doesn't. */
9807 if (!valid_array_size_p (loc
, diagsize
, name
, (complain
& tf_error
)))
9809 if (!(complain
& tf_error
))
9810 return error_mark_node
;
9811 size
= integer_one_node
;
9813 /* As an extension we allow zero-sized arrays. */
9814 else if (integer_zerop (size
))
9816 if (!(complain
& tf_error
))
9817 /* We must fail if performing argument deduction (as
9818 indicated by the state of complain), so that
9819 another substitution can be found. */
9820 return error_mark_node
;
9821 else if (in_system_header_at (input_location
))
9822 /* Allow them in system headers because glibc uses them. */;
9824 pedwarn (loc
, OPT_Wpedantic
,
9825 "ISO C++ forbids zero-size array %qD", name
);
9827 pedwarn (loc
, OPT_Wpedantic
,
9828 "ISO C++ forbids zero-size array");
9831 else if (TREE_CONSTANT (size
)
9832 /* We don't allow VLAs at non-function scopes, or during
9833 tentative template substitution. */
9834 || !at_function_scope_p ()
9835 || !(complain
& tf_error
))
9837 if (!(complain
& tf_error
))
9838 return error_mark_node
;
9839 /* `(int) &fn' is not a valid array bound. */
9842 "size of array %qD is not an integral constant-expression",
9845 error_at (loc
, "size of array is not an integral constant-expression");
9846 size
= integer_one_node
;
9848 else if (pedantic
&& warn_vla
!= 0)
9851 pedwarn (name_loc
, OPT_Wvla
,
9852 "ISO C++ forbids variable length array %qD", name
);
9854 pedwarn (input_location
, OPT_Wvla
,
9855 "ISO C++ forbids variable length array");
9857 else if (warn_vla
> 0)
9860 warning_at (name_loc
, OPT_Wvla
,
9861 "variable length array %qD is used", name
);
9864 "variable length array is used");
9867 if (processing_template_decl
&& !TREE_CONSTANT (size
))
9868 /* A variable sized array. */
9869 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
9872 /* Compute the index of the largest element in the array. It is
9873 one less than the number of elements in the array. We save
9874 and restore PROCESSING_TEMPLATE_DECL so that computations in
9875 cp_build_binary_op will be appropriately folded. */
9877 processing_template_decl_sentinel s
;
9878 itype
= cp_build_binary_op (input_location
,
9880 cp_convert (ssizetype
, size
, complain
),
9881 cp_convert (ssizetype
, integer_one_node
,
9884 itype
= maybe_constant_value (itype
);
9887 if (!TREE_CONSTANT (itype
))
9889 /* A variable sized array. */
9890 itype
= variable_size (itype
);
9892 stabilize_vla_size (itype
);
9894 if (sanitize_flags_p (SANITIZE_VLA
)
9895 && current_function_decl
!= NULL_TREE
)
9897 /* We have to add 1 -- in the ubsan routine we generate
9898 LE_EXPR rather than LT_EXPR. */
9899 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
9900 build_one_cst (TREE_TYPE (itype
)));
9901 t
= ubsan_instrument_vla (input_location
, t
);
9902 finish_expr_stmt (t
);
9905 /* Make sure that there was no overflow when creating to a signed
9906 index type. (For example, on a 32-bit machine, an array with
9907 size 2^32 - 1 is too big.) */
9908 else if (TREE_CODE (itype
) == INTEGER_CST
9909 && TREE_OVERFLOW (itype
))
9911 if (!(complain
& tf_error
))
9912 return error_mark_node
;
9913 error ("overflow in array dimension");
9914 TREE_OVERFLOW (itype
) = 0;
9918 /* Create and return the appropriate index type. */
9919 itype
= build_index_type (itype
);
9921 /* If the index type were dependent, we would have returned early, so
9922 remember that it isn't. */
9923 TYPE_DEPENDENT_P (itype
) = 0;
9924 TYPE_DEPENDENT_P_VALID (itype
) = 1;
9929 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
9931 return compute_array_index_type_loc (input_location
, name
, size
, complain
);
9934 /* Returns the scope (if any) in which the entity declared by
9935 DECLARATOR will be located. If the entity was declared with an
9936 unqualified name, NULL_TREE is returned. */
9939 get_scope_of_declarator (const cp_declarator
*declarator
)
9941 while (declarator
&& declarator
->kind
!= cdk_id
)
9942 declarator
= declarator
->declarator
;
9944 /* If the declarator-id is a SCOPE_REF, the scope in which the
9945 declaration occurs is the first operand. */
9947 && declarator
->u
.id
.qualifying_scope
)
9948 return declarator
->u
.id
.qualifying_scope
;
9950 /* Otherwise, the declarator is not a qualified name; the entity will
9951 be declared in the current scope. */
9955 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9956 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9960 create_array_type_for_decl (tree name
, tree type
, tree size
, location_t loc
)
9962 tree itype
= NULL_TREE
;
9964 /* If things have already gone awry, bail now. */
9965 if (type
== error_mark_node
|| size
== error_mark_node
)
9966 return error_mark_node
;
9968 /* 8.3.4/1: If the type of the identifier of D contains the auto
9969 type-specifier, the program is ill-formed. */
9970 if (type_uses_auto (type
))
9973 error_at (loc
, "%qD declared as array of %qT", name
, type
);
9975 error ("creating array of %qT", type
);
9976 return error_mark_node
;
9979 /* If there are some types which cannot be array elements,
9980 issue an error-message and return. */
9981 switch (TREE_CODE (type
))
9985 error_at (loc
, "declaration of %qD as array of void", name
);
9987 error ("creating array of void");
9988 return error_mark_node
;
9992 error_at (loc
, "declaration of %qD as array of functions", name
);
9994 error ("creating array of functions");
9995 return error_mark_node
;
9997 case REFERENCE_TYPE
:
9999 error_at (loc
, "declaration of %qD as array of references", name
);
10001 error ("creating array of references");
10002 return error_mark_node
;
10006 error_at (loc
, "declaration of %qD as array of function members",
10009 error ("creating array of function members");
10010 return error_mark_node
;
10018 The constant expressions that specify the bounds of the arrays
10019 can be omitted only for the first member of the sequence. */
10020 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
10023 error_at (loc
, "declaration of %qD as multidimensional array must "
10024 "have bounds for all dimensions except the first",
10027 error ("multidimensional array must have bounds for all "
10028 "dimensions except the first");
10030 return error_mark_node
;
10033 /* Figure out the index type for the array. */
10035 itype
= compute_array_index_type_loc (loc
, name
, size
,
10036 tf_warning_or_error
);
10039 T is called the array element type; this type shall not be [...] an
10040 abstract class type. */
10041 abstract_virtuals_error (name
, type
);
10043 return build_cplus_array_type (type
, itype
);
10046 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
10049 min_location (location_t loca
, location_t locb
)
10051 if (loca
== UNKNOWN_LOCATION
10052 || (locb
!= UNKNOWN_LOCATION
10053 && linemap_location_before_p (line_table
, locb
, loca
)))
10058 /* Returns the smallest location != UNKNOWN_LOCATION among the
10059 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
10060 and LOCATIONS[ds_restrict]. */
10063 smallest_type_quals_location (int type_quals
, const location_t
* locations
)
10065 location_t loc
= UNKNOWN_LOCATION
;
10067 if (type_quals
& TYPE_QUAL_CONST
)
10068 loc
= locations
[ds_const
];
10070 if (type_quals
& TYPE_QUAL_VOLATILE
)
10071 loc
= min_location (loc
, locations
[ds_volatile
]);
10073 if (type_quals
& TYPE_QUAL_RESTRICT
)
10074 loc
= min_location (loc
, locations
[ds_restrict
]);
10079 /* Check that it's OK to declare a function with the indicated TYPE
10080 and TYPE_QUALS. SFK indicates the kind of special function (if any)
10081 that this function is. OPTYPE is the type given in a conversion
10082 operator declaration, or the class type for a constructor/destructor.
10083 Returns the actual return type of the function; that may be different
10084 than TYPE if an error occurs, or for certain special functions. */
10087 check_special_function_return_type (special_function_kind sfk
,
10091 const location_t
* locations
)
10095 case sfk_constructor
:
10097 error ("return type specification for constructor invalid");
10098 else if (type_quals
!= TYPE_UNQUALIFIED
)
10099 error_at (smallest_type_quals_location (type_quals
, locations
),
10100 "qualifiers are not allowed on constructor declaration");
10102 if (targetm
.cxx
.cdtor_returns_this ())
10103 type
= build_pointer_type (optype
);
10105 type
= void_type_node
;
10108 case sfk_destructor
:
10110 error ("return type specification for destructor invalid");
10111 else if (type_quals
!= TYPE_UNQUALIFIED
)
10112 error_at (smallest_type_quals_location (type_quals
, locations
),
10113 "qualifiers are not allowed on destructor declaration");
10115 /* We can't use the proper return type here because we run into
10116 problems with ambiguous bases and covariant returns. */
10117 if (targetm
.cxx
.cdtor_returns_this ())
10118 type
= build_pointer_type (void_type_node
);
10120 type
= void_type_node
;
10123 case sfk_conversion
:
10125 error ("return type specified for %<operator %T%>", optype
);
10126 else if (type_quals
!= TYPE_UNQUALIFIED
)
10127 error_at (smallest_type_quals_location (type_quals
, locations
),
10128 "qualifiers are not allowed on declaration of "
10129 "%<operator %T%>", optype
);
10134 case sfk_deduction_guide
:
10136 error ("return type specified for deduction guide");
10137 else if (type_quals
!= TYPE_UNQUALIFIED
)
10138 error_at (smallest_type_quals_location (type_quals
, locations
),
10139 "qualifiers are not allowed on declaration of "
10140 "deduction guide");
10141 if (TREE_CODE (optype
) == TEMPLATE_TEMPLATE_PARM
)
10143 error ("template template parameter %qT in declaration of "
10144 "deduction guide", optype
);
10145 type
= error_mark_node
;
10148 type
= make_template_placeholder (CLASSTYPE_TI_TEMPLATE (optype
));
10149 for (int i
= 0; i
< ds_last
; ++i
)
10150 if (i
!= ds_explicit
&& locations
[i
])
10151 error_at (locations
[i
],
10152 "decl-specifier in declaration of deduction guide");
10156 gcc_unreachable ();
10162 /* A variable or data member (whose unqualified name is IDENTIFIER)
10163 has been declared with the indicated TYPE. If the TYPE is not
10164 acceptable, issue an error message and return a type to use for
10165 error-recovery purposes. */
10168 check_var_type (tree identifier
, tree type
)
10170 if (VOID_TYPE_P (type
))
10173 error ("unnamed variable or field declared void");
10174 else if (identifier_p (identifier
))
10176 gcc_assert (!IDENTIFIER_ANY_OP_P (identifier
));
10177 error ("variable or field %qE declared void", identifier
);
10180 error ("variable or field declared void");
10181 type
= error_mark_node
;
10187 /* Handle declaring DECL as an inline variable. */
10190 mark_inline_variable (tree decl
, location_t loc
)
10192 bool inlinep
= true;
10193 if (! toplevel_bindings_p ())
10195 error_at (loc
, "%<inline%> specifier invalid for variable "
10196 "%qD declared at block scope", decl
);
10199 else if (cxx_dialect
< cxx17
)
10200 pedwarn (loc
, 0, "inline variables are only available "
10201 "with %<-std=c++17%> or %<-std=gnu++17%>");
10204 retrofit_lang_decl (decl
);
10205 SET_DECL_VAR_DECLARED_INLINE_P (decl
);
10210 /* Assign a typedef-given name to a class or enumeration type declared
10211 as anonymous at first. This was split out of grokdeclarator
10212 because it is also used in libcc1. */
10215 name_unnamed_type (tree type
, tree decl
)
10217 gcc_assert (TYPE_UNNAMED_P (type
));
10219 /* Replace the anonymous name with the real name everywhere. */
10220 for (tree t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10222 if (anon_aggrname_p (TYPE_IDENTIFIER (t
)))
10223 /* We do not rename the debug info representing the
10224 unnamed tagged type because the standard says in
10225 [dcl.typedef] that the naming applies only for
10226 linkage purposes. */
10227 /*debug_hooks->set_name (t, decl);*/
10228 TYPE_NAME (t
) = decl
;
10231 if (TYPE_LANG_SPECIFIC (type
))
10232 TYPE_WAS_UNNAMED (type
) = 1;
10234 /* If this is a typedef within a template class, the nested
10235 type is a (non-primary) template. The name for the
10236 template needs updating as well. */
10237 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10238 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10239 = TYPE_IDENTIFIER (type
);
10241 /* Adjust linkage now that we aren't unnamed anymore. */
10242 reset_type_linkage (type
);
10244 /* FIXME remangle member functions; member functions of a
10245 type with external linkage have external linkage. */
10247 /* Check that our job is done, and that it would fail if we
10248 attempted to do it again. */
10249 gcc_assert (!TYPE_UNNAMED_P (type
));
10252 /* Given declspecs and a declarator (abstract or otherwise), determine
10253 the name and type of the object declared and construct a DECL node
10256 DECLSPECS points to the representation of declaration-specifier
10257 sequence that precedes declarator.
10259 DECL_CONTEXT says which syntactic context this declaration is in:
10260 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
10261 FUNCDEF for a function definition. Like NORMAL but a few different
10262 error messages in each case. Return value may be zero meaning
10263 this definition is too screwy to try to parse.
10264 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
10265 handle member functions (which have FIELD context).
10266 Return value may be zero meaning this definition is too screwy to
10268 PARM for a parameter declaration (either within a function prototype
10269 or before a function body). Make a PARM_DECL, or return void_type_node.
10270 TPARM for a template parameter declaration.
10271 CATCHPARM for a parameter declaration before a catch clause.
10272 TYPENAME if for a typename (in a cast or sizeof).
10273 Don't make a DECL node; just return the ..._TYPE node.
10274 FIELD for a struct or union field; make a FIELD_DECL.
10275 BITFIELD for a field with specified width.
10277 INITIALIZED is as for start_decl.
10279 ATTRLIST is a pointer to the list of attributes, which may be NULL
10280 if there are none; *ATTRLIST may be modified if attributes from inside
10281 the declarator should be applied to the declaration.
10283 When this function is called, scoping variables (such as
10284 CURRENT_CLASS_TYPE) should reflect the scope in which the
10285 declaration occurs, not the scope in which the new declaration will
10286 be placed. For example, on:
10288 void S::f() { ... }
10290 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
10293 Returns a DECL (if a declarator is present), a TYPE (if there is no
10294 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
10298 grokdeclarator (const cp_declarator
*declarator
,
10299 cp_decl_specifier_seq
*declspecs
,
10300 enum decl_context decl_context
,
10304 tree type
= NULL_TREE
;
10306 int explicit_intN
= 0;
10307 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
10308 int explicit_int
= 0;
10309 int explicit_char
= 0;
10310 int defaulted_int
= 0;
10312 tree typedef_decl
= NULL_TREE
;
10313 const char *name
= NULL
;
10314 tree typedef_type
= NULL_TREE
;
10315 /* True if this declarator is a function definition. */
10316 bool funcdef_flag
= false;
10317 cp_declarator_kind innermost_code
= cdk_error
;
10320 /* See the code below that used this. */
10321 tree decl_attr
= NULL_TREE
;
10324 /* Keep track of what sort of function is being processed
10325 so that we can warn about default return values, or explicit
10326 return values which do not match prescribed defaults. */
10327 special_function_kind sfk
= sfk_none
;
10329 tree dname
= NULL_TREE
;
10330 tree ctor_return_type
= NULL_TREE
;
10331 enum overload_flags flags
= NO_SPECIAL
;
10332 /* cv-qualifiers that apply to the declarator, for a declaration of
10333 a member function. */
10334 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
10335 /* virt-specifiers that apply to the declarator, for a declaration of
10336 a member function. */
10337 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
10338 /* ref-qualifier that applies to the declarator, for a declaration of
10339 a member function. */
10340 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
10341 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
10342 int type_quals
= TYPE_UNQUALIFIED
;
10343 tree raises
= NULL_TREE
;
10344 int template_count
= 0;
10345 tree returned_attrs
= NULL_TREE
;
10346 tree parms
= NULL_TREE
;
10347 const cp_declarator
*id_declarator
;
10348 /* The unqualified name of the declarator; either an
10349 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
10350 tree unqualified_id
;
10351 /* The class type, if any, in which this entity is located,
10352 or NULL_TREE if none. Note that this value may be different from
10353 the current class type; for example if an attempt is made to declare
10354 "A::f" inside "B", this value will be "A". */
10355 tree ctype
= current_class_type
;
10356 /* The NAMESPACE_DECL for the namespace in which this entity is
10357 located. If an unqualified name is used to declare the entity,
10358 this value will be NULL_TREE, even if the entity is located at
10359 namespace scope. */
10360 tree in_namespace
= NULL_TREE
;
10361 cp_storage_class storage_class
;
10362 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
10363 bool type_was_error_mark_node
= false;
10364 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
10365 bool template_type_arg
= false;
10366 bool template_parm_flag
= false;
10367 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
10368 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
10369 bool late_return_type_p
= false;
10370 bool array_parameter_p
= false;
10371 location_t saved_loc
= input_location
;
10372 tree reqs
= NULL_TREE
;
10374 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
10375 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
10376 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
10377 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
10378 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
10379 explicit_intN
= declspecs
->explicit_intN_p
;
10380 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
10382 // Was concept_p specified? Note that ds_concept
10383 // implies ds_constexpr!
10384 bool concept_p
= decl_spec_seq_has_spec_p (declspecs
, ds_concept
);
10386 constexpr_p
= true;
10388 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
10389 type_quals
|= TYPE_QUAL_CONST
;
10390 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
10391 type_quals
|= TYPE_QUAL_VOLATILE
;
10392 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
10393 type_quals
|= TYPE_QUAL_RESTRICT
;
10395 if (decl_context
== FUNCDEF
)
10396 funcdef_flag
= true, decl_context
= NORMAL
;
10397 else if (decl_context
== MEMFUNCDEF
)
10398 funcdef_flag
= true, decl_context
= FIELD
;
10399 else if (decl_context
== BITFIELD
)
10400 bitfield
= 1, decl_context
= FIELD
;
10401 else if (decl_context
== TEMPLATE_TYPE_ARG
)
10402 template_type_arg
= true, decl_context
= TYPENAME
;
10403 else if (decl_context
== TPARM
)
10404 template_parm_flag
= true, decl_context
= PARM
;
10406 if (initialized
> 1)
10407 funcdef_flag
= true;
10409 location_t typespec_loc
= smallest_type_quals_location (type_quals
,
10410 declspecs
->locations
);
10411 if (typespec_loc
== UNKNOWN_LOCATION
)
10412 typespec_loc
= declspecs
->locations
[ds_type_spec
];
10413 if (typespec_loc
== UNKNOWN_LOCATION
)
10414 typespec_loc
= input_location
;
10416 /* Look inside a declarator for the name being declared
10417 and get it as a string, for an error message. */
10418 for (id_declarator
= declarator
;
10420 id_declarator
= id_declarator
->declarator
)
10422 if (id_declarator
->kind
!= cdk_id
)
10423 innermost_code
= id_declarator
->kind
;
10425 switch (id_declarator
->kind
)
10428 if (id_declarator
->declarator
10429 && id_declarator
->declarator
->kind
== cdk_id
)
10431 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
10432 if (sfk
== sfk_destructor
)
10439 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
10440 tree decl
= id_declarator
->u
.id
.unqualified_name
;
10443 if (qualifying_scope
)
10445 if (check_for_bare_parameter_packs (qualifying_scope
,
10446 id_declarator
->id_loc
))
10447 return error_mark_node
;
10448 if (at_function_scope_p ())
10452 A declarator-id shall not be qualified except
10455 None of the cases are permitted in block
10457 if (qualifying_scope
== global_namespace
)
10458 error ("invalid use of qualified-name %<::%D%>",
10460 else if (TYPE_P (qualifying_scope
))
10461 error ("invalid use of qualified-name %<%T::%D%>",
10462 qualifying_scope
, decl
);
10464 error ("invalid use of qualified-name %<%D::%D%>",
10465 qualifying_scope
, decl
);
10466 return error_mark_node
;
10468 else if (TYPE_P (qualifying_scope
))
10470 ctype
= qualifying_scope
;
10471 if (!MAYBE_CLASS_TYPE_P (ctype
))
10473 error ("%q#T is not a class or a namespace", ctype
);
10476 else if (innermost_code
!= cdk_function
10477 && current_class_type
10478 && !uniquely_derived_from_p (ctype
,
10479 current_class_type
))
10481 error ("invalid use of qualified-name %<%T::%D%>",
10482 qualifying_scope
, decl
);
10483 return error_mark_node
;
10486 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
10487 in_namespace
= qualifying_scope
;
10489 switch (TREE_CODE (decl
))
10493 if (innermost_code
!= cdk_function
)
10495 error ("declaration of %qD as non-function", decl
);
10496 return error_mark_node
;
10498 else if (!qualifying_scope
10499 && !(current_class_type
&& at_class_scope_p ()))
10501 error ("declaration of %qD as non-member", decl
);
10502 return error_mark_node
;
10505 tree type
= TREE_OPERAND (decl
, 0);
10507 type
= constructor_name (type
);
10508 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
10513 case TEMPLATE_ID_EXPR
:
10515 tree fns
= TREE_OPERAND (decl
, 0);
10518 if (!identifier_p (dname
))
10519 dname
= OVL_NAME (dname
);
10521 /* Fall through. */
10523 case IDENTIFIER_NODE
:
10524 if (identifier_p (decl
))
10527 if (IDENTIFIER_KEYWORD_P (dname
))
10529 error ("declarator-id missing; using reserved word %qD",
10531 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10533 else if (!IDENTIFIER_CONV_OP_P (dname
))
10534 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10537 gcc_assert (flags
== NO_SPECIAL
);
10538 flags
= TYPENAME_FLAG
;
10539 sfk
= sfk_conversion
;
10540 tree glob
= get_global_binding (dname
);
10541 if (glob
&& TREE_CODE (glob
) == TYPE_DECL
)
10542 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10544 name
= "<invalid operator>";
10549 gcc_unreachable ();
10556 case cdk_reference
:
10561 name
= "structured binding";
10565 return error_mark_node
;
10568 gcc_unreachable ();
10570 if (id_declarator
->kind
== cdk_id
)
10576 The declarator in a function-definition shall have the form
10577 D1 ( parameter-declaration-clause) ... */
10578 if (funcdef_flag
&& innermost_code
!= cdk_function
)
10580 error ("function definition does not declare parameters");
10581 return error_mark_node
;
10584 if (flags
== TYPENAME_FLAG
10585 && innermost_code
!= cdk_function
10586 && ! (ctype
&& !declspecs
->any_specifiers_p
))
10588 error ("declaration of %qD as non-function", dname
);
10589 return error_mark_node
;
10592 if (dname
&& identifier_p (dname
))
10594 if (UDLIT_OPER_P (dname
)
10595 && innermost_code
!= cdk_function
)
10597 error ("declaration of %qD as non-function", dname
);
10598 return error_mark_node
;
10601 if (IDENTIFIER_ANY_OP_P (dname
))
10605 error ("declaration of %qD as %<typedef%>", dname
);
10606 return error_mark_node
;
10608 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10610 error ("declaration of %qD as parameter", dname
);
10611 return error_mark_node
;
10616 /* Anything declared one level down from the top level
10617 must be one of the parameters of a function
10618 (because the body is at least two levels down). */
10620 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10621 by not allowing C++ class definitions to specify their parameters
10622 with xdecls (must be spec.d in the parmlist).
10624 Since we now wait to push a class scope until we are sure that
10625 we are in a legitimate method context, we must set oldcname
10626 explicitly (since current_class_name is not yet alive).
10628 We also want to avoid calling this a PARM if it is in a namespace. */
10630 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
10632 cp_binding_level
*b
= current_binding_level
;
10633 current_binding_level
= b
->level_chain
;
10634 if (current_binding_level
!= 0 && toplevel_bindings_p ())
10635 decl_context
= PARM
;
10636 current_binding_level
= b
;
10640 name
= decl_context
== PARM
? "parameter" : "type name";
10642 if (concept_p
&& typedef_p
)
10644 error_at (declspecs
->locations
[ds_concept
],
10645 "%<concept%> cannot appear in a typedef declaration");
10646 return error_mark_node
;
10649 if (constexpr_p
&& typedef_p
)
10651 error_at (declspecs
->locations
[ds_constexpr
],
10652 "%<constexpr%> cannot appear in a typedef declaration");
10653 return error_mark_node
;
10656 /* If there were multiple types specified in the decl-specifier-seq,
10657 issue an error message. */
10658 if (declspecs
->multiple_types_p
)
10660 error ("two or more data types in declaration of %qs", name
);
10661 return error_mark_node
;
10664 if (declspecs
->conflicting_specifiers_p
)
10666 error ("conflicting specifiers in declaration of %qs", name
);
10667 return error_mark_node
;
10670 /* Extract the basic type from the decl-specifier-seq. */
10671 type
= declspecs
->type
;
10672 if (type
== error_mark_node
)
10675 type_was_error_mark_node
= true;
10677 cp_warn_deprecated_use (type
);
10678 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
10680 typedef_decl
= type
;
10681 type
= TREE_TYPE (typedef_decl
);
10682 if (DECL_ARTIFICIAL (typedef_decl
))
10683 cp_warn_deprecated_use (type
);
10685 /* No type at all: default to `int', and set DEFAULTED_INT
10686 because it was not a user-defined typedef. */
10687 if (type
== NULL_TREE
)
10689 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
10691 /* These imply 'int'. */
10692 type
= integer_type_node
;
10695 /* If we just have "complex", it is equivalent to "complex double". */
10696 else if (!longlong
&& !explicit_intN
10697 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
10699 type
= double_type_node
;
10700 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
10701 "ISO C++ does not support plain %<complex%> meaning "
10702 "%<double complex%>");
10705 /* Gather flags. */
10706 explicit_int
= declspecs
->explicit_int_p
;
10707 explicit_char
= declspecs
->explicit_char_p
;
10710 /* See the code below that used this. */
10712 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
10714 typedef_type
= type
;
10716 if (sfk
== sfk_conversion
|| sfk
== sfk_deduction_guide
)
10717 ctor_return_type
= TREE_TYPE (dname
);
10719 ctor_return_type
= ctype
;
10721 if (sfk
!= sfk_none
)
10723 type
= check_special_function_return_type (sfk
, type
,
10726 declspecs
->locations
);
10727 type_quals
= TYPE_UNQUALIFIED
;
10729 else if (type
== NULL_TREE
)
10735 /* We handle `main' specially here, because 'main () { }' is so
10736 common. With no options, it is allowed. With -Wreturn-type,
10737 it is a warning. It is only an error with -pedantic-errors. */
10738 is_main
= (funcdef_flag
10739 && dname
&& identifier_p (dname
)
10740 && MAIN_NAME_P (dname
)
10741 && ctype
== NULL_TREE
10742 && in_namespace
== NULL_TREE
10743 && current_namespace
== global_namespace
);
10745 if (type_was_error_mark_node
)
10746 /* We've already issued an error, don't complain more. */;
10747 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
10748 /* Allow it, sigh. */;
10749 else if (! is_main
)
10750 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
10752 pedwarn (input_location
, OPT_Wpedantic
,
10753 "ISO C++ forbids declaration of %qs with no type", name
);
10755 warning (OPT_Wreturn_type
,
10756 "ISO C++ forbids declaration of %qs with no type", name
);
10758 if (type_was_error_mark_node
&& template_parm_flag
)
10759 /* FIXME we should be able to propagate the error_mark_node as is
10760 for other contexts too. */
10761 type
= error_mark_node
;
10763 type
= integer_type_node
;
10770 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
10772 error ("%<__int%d%> is not supported by this target",
10773 int_n_data
[declspecs
->int_n_idx
].bitsize
);
10774 explicit_intN
= false;
10776 else if (pedantic
&& ! in_system_header_at (input_location
))
10777 pedwarn (input_location
, OPT_Wpedantic
,
10778 "ISO C++ does not support %<__int%d%> for %qs",
10779 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
10782 /* Now process the modifiers that were specified
10783 and check for invalid combinations. */
10785 /* Long double is a special combination. */
10786 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
10789 type
= cp_build_qualified_type (long_double_type_node
,
10790 cp_type_quals (type
));
10793 /* Check all other uses of type modifiers. */
10795 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
10802 loc
= declspecs
->locations
[ds_unsigned
];
10807 loc
= declspecs
->locations
[ds_signed
];
10812 loc
= declspecs
->locations
[ds_long_long
];
10817 loc
= declspecs
->locations
[ds_long
];
10819 else /* if (short_p) */
10822 loc
= declspecs
->locations
[ds_short
];
10827 if (signed_p
&& unsigned_p
)
10829 gcc_rich_location
richloc (declspecs
->locations
[ds_signed
]);
10830 richloc
.add_range (declspecs
->locations
[ds_unsigned
]);
10831 error_at (&richloc
,
10832 "%<signed%> and %<unsigned%> specified together");
10834 else if (long_p
&& short_p
)
10836 gcc_rich_location
richloc (declspecs
->locations
[ds_long
]);
10837 richloc
.add_range (declspecs
->locations
[ds_short
]);
10838 error_at (&richloc
, "%<long%> and %<short%> specified together");
10840 else if (TREE_CODE (type
) != INTEGER_TYPE
10841 || type
== char8_type_node
10842 || type
== char16_type_node
10843 || type
== char32_type_node
10844 || ((long_p
|| short_p
)
10845 && (explicit_char
|| explicit_intN
)))
10846 error_at (loc
, "%qs specified with %qT", key
, type
);
10847 else if (!explicit_int
&& !defaulted_int
10848 && !explicit_char
&& !explicit_intN
)
10852 pedwarn (loc
, OPT_Wpedantic
, "%qs specified with %qT",
10854 ok
= !flag_pedantic_errors
;
10856 else if (declspecs
->decltype_p
)
10857 error_at (loc
, "%qs specified with %<decltype%>", key
);
10859 error_at (loc
, "%qs specified with %<typeof%>", key
);
10864 /* Discard the type modifiers if they are invalid. */
10867 unsigned_p
= false;
10875 /* Decide whether an integer type is signed or not.
10876 Optionally treat bitfields as signed by default. */
10880 It is implementation-defined whether a plain (neither
10881 explicitly signed or unsigned) char, short, int, or long
10882 bit-field is signed or unsigned.
10884 Naturally, we extend this to long long as well. Note that
10885 this does not include wchar_t. */
10886 || (bitfield
&& !flag_signed_bitfields
10888 /* A typedef for plain `int' without `signed' can be
10889 controlled just like plain `int', but a typedef for
10890 `signed int' cannot be so controlled. */
10892 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
10893 && TREE_CODE (type
) == INTEGER_TYPE
10894 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
10897 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
10899 type
= long_long_unsigned_type_node
;
10901 type
= long_unsigned_type_node
;
10903 type
= short_unsigned_type_node
;
10904 else if (type
== char_type_node
)
10905 type
= unsigned_char_type_node
;
10906 else if (typedef_decl
)
10907 type
= unsigned_type_for (type
);
10909 type
= unsigned_type_node
;
10911 else if (signed_p
&& type
== char_type_node
)
10912 type
= signed_char_type_node
;
10913 else if (explicit_intN
)
10914 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
10916 type
= long_long_integer_type_node
;
10918 type
= long_integer_type_node
;
10920 type
= short_integer_type_node
;
10922 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
10924 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
10925 error ("complex invalid for %qs", name
);
10926 /* If a modifier is specified, the resulting complex is the complex
10927 form of TYPE. E.g, "complex short" is "complex short int". */
10928 else if (type
== integer_type_node
)
10929 type
= complex_integer_type_node
;
10930 else if (type
== float_type_node
)
10931 type
= complex_float_type_node
;
10932 else if (type
== double_type_node
)
10933 type
= complex_double_type_node
;
10934 else if (type
== long_double_type_node
)
10935 type
= complex_long_double_type_node
;
10937 type
= build_complex_type (type
);
10940 /* If we're using the injected-class-name to form a compound type or a
10941 declaration, replace it with the underlying class so we don't get
10942 redundant typedefs in the debug output. But if we are returning the
10943 type unchanged, leave it alone so that it's available to
10944 maybe_get_template_decl_from_type_decl. */
10945 if (CLASS_TYPE_P (type
)
10946 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
10947 && type
== TREE_TYPE (TYPE_NAME (type
))
10948 && (declarator
|| type_quals
))
10949 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
10951 type_quals
|= cp_type_quals (type
);
10952 type
= cp_build_qualified_type_real
10953 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
10954 || declspecs
->decltype_p
)
10955 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
10956 /* We might have ignored or rejected some of the qualifiers. */
10957 type_quals
= cp_type_quals (type
);
10959 if (cxx_dialect
>= cxx17
&& type
&& is_auto (type
)
10960 && innermost_code
!= cdk_function
10961 && id_declarator
&& declarator
!= id_declarator
)
10962 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (type
))
10964 error_at (typespec_loc
, "template placeholder type %qT must be followed "
10965 "by a simple declarator-id", type
);
10966 inform (DECL_SOURCE_LOCATION (tmpl
), "%qD declared here", tmpl
);
10970 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
10971 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
10972 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
10974 storage_class
= declspecs
->storage_class
;
10975 if (storage_class
== sc_static
)
10976 staticp
= 1 + (decl_context
== FIELD
);
10982 gcc_rich_location
richloc (declspecs
->locations
[ds_virtual
]);
10983 richloc
.add_range (declspecs
->locations
[ds_storage_class
]);
10984 error_at (&richloc
, "member %qD cannot be declared both %<virtual%> "
10985 "and %<static%>", dname
);
10986 storage_class
= sc_none
;
10989 if (constexpr_p
&& cxx_dialect
< cxx2a
)
10991 gcc_rich_location
richloc (declspecs
->locations
[ds_virtual
]);
10992 richloc
.add_range (declspecs
->locations
[ds_constexpr
]);
10993 pedwarn (&richloc
, OPT_Wpedantic
, "member %qD can be declared both "
10994 "%<virtual%> and %<constexpr%> only in %<-std=c++2a%> or "
10995 "%<-std=gnu++2a%>", dname
);
10998 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
11000 /* Issue errors about use of storage classes for parameters. */
11001 if (decl_context
== PARM
)
11005 error_at (declspecs
->locations
[ds_typedef
],
11006 "typedef declaration invalid in parameter declaration");
11007 return error_mark_node
;
11009 else if (template_parm_flag
&& storage_class
!= sc_none
)
11011 error_at (min_location (declspecs
->locations
[ds_thread
],
11012 declspecs
->locations
[ds_storage_class
]),
11013 "storage class specified for template parameter %qs",
11015 return error_mark_node
;
11017 else if (storage_class
== sc_static
11018 || storage_class
== sc_extern
11021 error_at (min_location (declspecs
->locations
[ds_thread
],
11022 declspecs
->locations
[ds_storage_class
]),
11023 "storage class specified for parameter %qs", name
);
11024 return error_mark_node
;
11027 /* Function parameters cannot be concept. */
11029 error_at (declspecs
->locations
[ds_concept
],
11030 "a parameter cannot be declared %<concept%>");
11031 /* Function parameters cannot be constexpr. If we saw one, moan
11032 and pretend it wasn't there. */
11033 else if (constexpr_p
)
11035 error_at (declspecs
->locations
[ds_constexpr
],
11036 "a parameter cannot be declared %<constexpr%>");
11041 /* Give error if `virtual' is used outside of class declaration. */
11043 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
11045 error_at (declspecs
->locations
[ds_virtual
],
11046 "%<virtual%> outside class declaration");
11050 if (innermost_code
== cdk_decomp
)
11052 location_t loc
= (declarator
->kind
== cdk_reference
11053 ? declarator
->declarator
->id_loc
: declarator
->id_loc
);
11055 error_at (declspecs
->locations
[ds_inline
],
11056 "structured binding declaration cannot be %<inline%>");
11058 error_at (declspecs
->locations
[ds_typedef
],
11059 "structured binding declaration cannot be %<typedef%>");
11061 error_at (declspecs
->locations
[ds_constexpr
], "structured "
11062 "binding declaration cannot be %<constexpr%>");
11064 error_at (declspecs
->locations
[ds_thread
],
11065 "structured binding declaration cannot be %qs",
11066 declspecs
->gnu_thread_keyword_p
11067 ? "__thread" : "thread_local");
11069 error_at (declspecs
->locations
[ds_concept
],
11070 "structured binding declaration cannot be %<concept%>");
11071 switch (storage_class
)
11076 error_at (loc
, "structured binding declaration cannot be "
11080 error_at (loc
, "structured binding declaration cannot be "
11084 error_at (loc
, "structured binding declaration cannot be "
11088 error_at (loc
, "structured binding declaration cannot be "
11092 error_at (loc
, "structured binding declaration cannot be "
11096 gcc_unreachable ();
11098 if (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
11099 || TYPE_IDENTIFIER (type
) != auto_identifier
)
11101 if (type
!= error_mark_node
)
11103 error_at (loc
, "structured binding declaration cannot have "
11106 "type must be cv-qualified %<auto%> or reference to "
11107 "cv-qualified %<auto%>");
11109 type
= build_qualified_type (make_auto (), type_quals
);
11110 declspecs
->type
= type
;
11117 storage_class
= sc_none
;
11119 declspecs
->storage_class
= sc_none
;
11120 declspecs
->locations
[ds_thread
] = UNKNOWN_LOCATION
;
11123 /* Static anonymous unions are dealt with here. */
11124 if (staticp
&& decl_context
== TYPENAME
11126 && ANON_AGGR_TYPE_P (declspecs
->type
))
11127 decl_context
= FIELD
;
11129 /* Warn about storage classes that are invalid for certain
11130 kinds of declarations (parameters, typenames, etc.). */
11133 && storage_class
!= sc_extern
11134 && storage_class
!= sc_static
)
11137 error ("multiple storage classes in declaration of %qs", name
);
11140 if (decl_context
!= NORMAL
11141 && ((storage_class
!= sc_none
11142 && storage_class
!= sc_mutable
)
11145 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
11146 && (storage_class
== sc_register
11147 || storage_class
== sc_auto
))
11149 else if (typedef_p
)
11151 else if (decl_context
== FIELD
11152 /* C++ allows static class elements. */
11153 && storage_class
== sc_static
)
11154 /* C++ also allows inlines and signed and unsigned elements,
11155 but in those cases we don't come in here. */
11160 = min_location (declspecs
->locations
[ds_thread
],
11161 declspecs
->locations
[ds_storage_class
]);
11162 if (decl_context
== FIELD
)
11163 error_at (loc
, "storage class specified for %qs", name
);
11164 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
11165 error_at (loc
, "storage class specified for parameter %qs", name
);
11167 error_at (loc
, "storage class specified for typename");
11168 if (storage_class
== sc_register
11169 || storage_class
== sc_auto
11170 || storage_class
== sc_extern
11172 storage_class
= sc_none
;
11175 else if (storage_class
== sc_extern
&& funcdef_flag
11176 && ! toplevel_bindings_p ())
11177 error ("nested function %qs declared %<extern%>", name
);
11178 else if (toplevel_bindings_p ())
11180 if (storage_class
== sc_auto
)
11181 error ("top-level declaration of %qs specifies %<auto%>", name
);
11184 && storage_class
!= sc_extern
11185 && storage_class
!= sc_static
)
11187 if (declspecs
->gnu_thread_keyword_p
)
11188 pedwarn (declspecs
->locations
[ds_thread
],
11189 0, "function-scope %qs implicitly auto and "
11190 "declared %<__thread%>", name
);
11192 /* When thread_local is applied to a variable of block scope the
11193 storage-class-specifier static is implied if it does not appear
11195 storage_class
= declspecs
->storage_class
= sc_static
;
11199 if (storage_class
&& friendp
)
11201 error_at (min_location (declspecs
->locations
[ds_thread
],
11202 declspecs
->locations
[ds_storage_class
]),
11203 "storage class specifiers invalid in friend function "
11205 storage_class
= sc_none
;
11209 if (!id_declarator
)
11210 unqualified_id
= NULL_TREE
;
11213 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
11214 switch (TREE_CODE (unqualified_id
))
11217 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
11218 if (TYPE_P (unqualified_id
))
11219 unqualified_id
= constructor_name (unqualified_id
);
11222 case IDENTIFIER_NODE
:
11223 case TEMPLATE_ID_EXPR
:
11227 gcc_unreachable ();
11231 if (declspecs
->std_attributes
)
11233 location_t attr_loc
= declspecs
->locations
[ds_std_attribute
];
11234 if (warning_at (attr_loc
, OPT_Wattributes
, "attribute ignored"))
11235 inform (attr_loc
, "an attribute that appertains to a type-specifier "
11239 /* Determine the type of the entity declared by recurring on the
11241 for (; declarator
; declarator
= declarator
->declarator
)
11243 const cp_declarator
*inner_declarator
;
11246 if (type
== error_mark_node
)
11247 return error_mark_node
;
11249 attrs
= declarator
->attributes
;
11255 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
11256 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
11257 if (declarator
->kind
== cdk_function
)
11258 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
11259 if (declarator
->kind
== cdk_array
)
11260 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
11261 returned_attrs
= decl_attributes (&type
,
11262 chainon (returned_attrs
, attrs
),
11266 inner_declarator
= declarator
->declarator
;
11268 /* We don't want to warn in parameter context because we don't
11269 yet know if the parse will succeed, and this might turn out
11270 to be a constructor call. */
11271 if (decl_context
!= PARM
11272 && decl_context
!= TYPENAME
11274 && declarator
->parenthesized
!= UNKNOWN_LOCATION
11275 /* If the type is class-like and the inner name used a
11276 global namespace qualifier, we need the parens.
11277 Unfortunately all we can tell is whether a qualified name
11278 was used or not. */
11279 && !(inner_declarator
11280 && inner_declarator
->kind
== cdk_id
11281 && inner_declarator
->u
.id
.qualifying_scope
11282 && (MAYBE_CLASS_TYPE_P (type
)
11283 || TREE_CODE (type
) == ENUMERAL_TYPE
)))
11284 warning_at (declarator
->parenthesized
, OPT_Wparentheses
,
11285 "unnecessary parentheses in declaration of %qs", name
);
11286 if (declarator
->kind
== cdk_id
|| declarator
->kind
== cdk_decomp
)
11289 switch (declarator
->kind
)
11292 type
= create_array_type_for_decl (dname
, type
,
11293 declarator
->u
.array
.bounds
,
11294 declarator
->id_loc
);
11295 if (!valid_array_size_p (input_location
, type
, dname
))
11296 type
= error_mark_node
;
11298 if (declarator
->std_attributes
)
11301 The optional attribute-specifier-seq appertains to the
11303 returned_attrs
= chainon (returned_attrs
,
11304 declarator
->std_attributes
);
11312 /* Declaring a function type. */
11314 input_location
= declspecs
->locations
[ds_type_spec
];
11315 abstract_virtuals_error (ACU_RETURN
, type
);
11316 input_location
= saved_loc
;
11318 /* Pick up type qualifiers which should be applied to `this'. */
11319 memfn_quals
= declarator
->u
.function
.qualifiers
;
11320 /* Pick up virt-specifiers. */
11321 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
11322 /* And ref-qualifier, too */
11323 rqual
= declarator
->u
.function
.ref_qualifier
;
11324 /* And tx-qualifier. */
11325 tree tx_qual
= declarator
->u
.function
.tx_qualifier
;
11326 /* Pick up the exception specifications. */
11327 raises
= declarator
->u
.function
.exception_specification
;
11328 /* If the exception-specification is ill-formed, let's pretend
11329 there wasn't one. */
11330 if (raises
== error_mark_node
)
11331 raises
= NULL_TREE
;
11334 error_at (location_of (reqs
), "requires-clause on return type");
11335 reqs
= declarator
->u
.function
.requires_clause
;
11337 /* Say it's a definition only for the CALL_EXPR
11338 closest to the identifier. */
11339 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
11341 /* Handle a late-specified return type. */
11342 tree late_return_type
= declarator
->u
.function
.late_return_type
;
11344 /* This is the case e.g. for
11345 using T = auto () -> int. */
11346 || inner_declarator
== NULL
)
11348 if (tree auto_node
= type_uses_auto (type
))
11350 if (!late_return_type
)
11352 if (current_class_type
11353 && LAMBDA_TYPE_P (current_class_type
))
11354 /* OK for C++11 lambdas. */;
11355 else if (cxx_dialect
< cxx14
)
11357 error_at (typespec_loc
, "%qs function uses "
11358 "%<auto%> type specifier without "
11359 "trailing return type", name
);
11360 inform (typespec_loc
,
11361 "deduced return type only available "
11362 "with %<-std=c++14%> or %<-std=gnu++14%>");
11366 error_at (typespec_loc
, "virtual function "
11367 "cannot have deduced return type");
11371 else if (!is_auto (type
) && sfk
!= sfk_conversion
)
11373 error_at (typespec_loc
, "%qs function with trailing "
11374 "return type has %qT as its type rather "
11375 "than plain %<auto%>", name
, type
);
11376 return error_mark_node
;
11378 else if (is_auto (type
) && AUTO_IS_DECLTYPE (type
))
11381 error_at (typespec_loc
,
11382 "%qs function with trailing return type "
11383 "has %<decltype(auto)%> as its type "
11384 "rather than plain %<auto%>", name
);
11386 error_at (typespec_loc
,
11387 "invalid use of %<decltype(auto)%>");
11388 return error_mark_node
;
11390 tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
);
11392 if (tree late_auto
= type_uses_auto (late_return_type
))
11393 tmpl
= CLASS_PLACEHOLDER_TEMPLATE (late_auto
);
11394 if (tmpl
&& funcdecl_p
)
11396 if (!dguide_name_p (unqualified_id
))
11398 error_at (declarator
->id_loc
, "deduced class "
11399 "type %qD in function return type",
11401 inform (DECL_SOURCE_LOCATION (tmpl
),
11402 "%qD declared here", tmpl
);
11403 return error_mark_node
;
11405 else if (!late_return_type
)
11407 error_at (declarator
->id_loc
, "deduction guide "
11408 "for %qT must have trailing return "
11409 "type", TREE_TYPE (tmpl
));
11410 inform (DECL_SOURCE_LOCATION (tmpl
),
11411 "%qD declared here", tmpl
);
11412 return error_mark_node
;
11414 else if (CLASS_TYPE_P (late_return_type
)
11415 && CLASSTYPE_TEMPLATE_INFO (late_return_type
)
11416 && (CLASSTYPE_TI_TEMPLATE (late_return_type
)
11420 error ("trailing return type %qT of deduction guide "
11421 "is not a specialization of %qT",
11422 late_return_type
, TREE_TYPE (tmpl
));
11425 else if (late_return_type
11426 && sfk
!= sfk_conversion
)
11428 if (cxx_dialect
< cxx11
)
11429 /* Not using maybe_warn_cpp0x because this should
11430 always be an error. */
11431 error_at (typespec_loc
,
11432 "trailing return type only available "
11433 "with %<-std=c++11%> or %<-std=gnu++11%>");
11435 error_at (typespec_loc
, "%qs function with trailing "
11436 "return type not declared with %<auto%> "
11437 "type specifier", name
);
11438 return error_mark_node
;
11441 type
= splice_late_return_type (type
, late_return_type
);
11442 if (type
== error_mark_node
)
11443 return error_mark_node
;
11445 if (late_return_type
)
11447 late_return_type_p
= true;
11448 type_quals
= cp_type_quals (type
);
11451 if (type_quals
!= TYPE_UNQUALIFIED
)
11453 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
11454 warning_at (typespec_loc
, OPT_Wignored_qualifiers
, "type "
11455 "qualifiers ignored on function return type");
11456 /* We now know that the TYPE_QUALS don't apply to the
11457 decl, but to its return type. */
11458 type_quals
= TYPE_UNQUALIFIED
;
11461 /* Error about some types functions can't return. */
11463 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11465 error_at (typespec_loc
, "%qs declared as function returning "
11466 "a function", name
);
11467 return error_mark_node
;
11469 if (TREE_CODE (type
) == ARRAY_TYPE
)
11471 error_at (typespec_loc
, "%qs declared as function returning "
11473 return error_mark_node
;
11476 if (ctype
== NULL_TREE
11477 && decl_context
== FIELD
11480 ctype
= current_class_type
;
11482 if (ctype
&& (sfk
== sfk_constructor
11483 || sfk
== sfk_destructor
))
11485 /* We are within a class's scope. If our declarator name
11486 is the same as the class name, and we are defining
11487 a function, then it is a constructor/destructor, and
11488 therefore returns a void type. */
11490 /* ISO C++ 12.4/2. A destructor may not be declared
11491 const or volatile. A destructor may not be static.
11492 A destructor may not be declared with ref-qualifier.
11494 ISO C++ 12.1. A constructor may not be declared
11495 const or volatile. A constructor may not be
11496 virtual. A constructor may not be static.
11497 A constructor may not be declared with ref-qualifier. */
11499 error ((flags
== DTOR_FLAG
)
11500 ? G_("destructor cannot be static member function")
11501 : G_("constructor cannot be static member function"));
11504 error ((flags
== DTOR_FLAG
)
11505 ? G_("destructors may not be cv-qualified")
11506 : G_("constructors may not be cv-qualified"));
11507 memfn_quals
= TYPE_UNQUALIFIED
;
11512 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
11513 error ((flags
== DTOR_FLAG
)
11514 ? G_("destructors may not be ref-qualified")
11515 : G_("constructors may not be ref-qualified"));
11516 rqual
= REF_QUAL_NONE
;
11519 if (decl_context
== FIELD
11520 && !member_function_or_else (ctype
,
11521 current_class_type
,
11523 return error_mark_node
;
11525 if (flags
!= DTOR_FLAG
)
11527 /* It's a constructor. */
11528 if (explicitp
== 1)
11532 permerror (declspecs
->locations
[ds_virtual
],
11533 "constructors cannot be declared %<virtual%>");
11536 if (decl_context
== FIELD
11537 && sfk
!= sfk_constructor
)
11538 return error_mark_node
;
11540 if (decl_context
== FIELD
)
11547 /* Cannot be both friend and virtual. */
11548 gcc_rich_location
richloc (declspecs
->locations
[ds_virtual
]);
11549 richloc
.add_range (declspecs
->locations
[ds_friend
]);
11550 error_at (&richloc
, "virtual functions cannot be friends");
11553 if (decl_context
== NORMAL
)
11554 error ("friend declaration not in class definition");
11555 if (current_function_decl
&& funcdef_flag
)
11557 error ("can%'t define friend function %qs in a local "
11558 "class definition", name
);
11562 else if (ctype
&& sfk
== sfk_conversion
)
11564 if (explicitp
== 1)
11566 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
11569 if (late_return_type_p
)
11570 error ("a conversion function cannot have a trailing return type");
11572 else if (sfk
== sfk_deduction_guide
)
11574 if (explicitp
== 1)
11578 tree pushed_scope
= NULL_TREE
;
11580 && decl_context
!= FIELD
11581 && inner_declarator
->u
.id
.qualifying_scope
11582 && CLASS_TYPE_P (inner_declarator
->u
.id
.qualifying_scope
))
11584 = push_scope (inner_declarator
->u
.id
.qualifying_scope
);
11586 arg_types
= grokparms (declarator
->u
.function
.parameters
, &parms
);
11589 pop_scope (pushed_scope
);
11591 if (inner_declarator
11592 && inner_declarator
->kind
== cdk_id
11593 && inner_declarator
->u
.id
.sfk
== sfk_destructor
11594 && arg_types
!= void_list_node
)
11596 error ("destructors may not have parameters");
11597 arg_types
= void_list_node
;
11601 type
= build_function_type (type
, arg_types
);
11603 tree attrs
= declarator
->std_attributes
;
11606 tree att
= build_tree_list (tx_qual
, NULL_TREE
);
11607 /* transaction_safe applies to the type, but
11608 transaction_safe_dynamic applies to the function. */
11609 if (is_attribute_p ("transaction_safe", tx_qual
))
11610 attrs
= chainon (attrs
, att
);
11612 returned_attrs
= chainon (returned_attrs
, att
);
11617 The optional attribute-specifier-seq appertains to
11618 the function type. */
11619 decl_attributes (&type
, attrs
, 0);
11622 type
= build_exception_variant (type
, raises
);
11627 case cdk_reference
:
11629 /* Filter out pointers-to-references and references-to-references.
11630 We can get these if a TYPE_DECL is used. */
11632 if (TYPE_REF_P (type
))
11634 if (declarator
->kind
!= cdk_reference
)
11636 error ("cannot declare pointer to %q#T", type
);
11637 type
= TREE_TYPE (type
);
11640 /* In C++0x, we allow reference to reference declarations
11641 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
11642 and template type arguments [14.3.1/4 temp.arg.type]. The
11643 check for direct reference to reference declarations, which
11644 are still forbidden, occurs below. Reasoning behind the change
11645 can be found in DR106, DR540, and the rvalue reference
11647 else if (cxx_dialect
== cxx98
)
11649 error ("cannot declare reference to %q#T", type
);
11650 type
= TREE_TYPE (type
);
11653 else if (VOID_TYPE_P (type
))
11655 if (declarator
->kind
== cdk_reference
)
11656 error ("cannot declare reference to %q#T", type
);
11657 else if (declarator
->kind
== cdk_ptrmem
)
11658 error ("cannot declare pointer to %q#T member", type
);
11661 /* We now know that the TYPE_QUALS don't apply to the decl,
11662 but to the target of the pointer. */
11663 type_quals
= TYPE_UNQUALIFIED
;
11665 /* This code used to handle METHOD_TYPE, but I don't think it's
11666 possible to get it here anymore. */
11667 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
11668 if (declarator
->kind
== cdk_ptrmem
11669 && TREE_CODE (type
) == FUNCTION_TYPE
)
11671 memfn_quals
|= type_memfn_quals (type
);
11672 type
= build_memfn_type (type
,
11673 declarator
->u
.pointer
.class_type
,
11676 if (type
== error_mark_node
)
11677 return error_mark_node
;
11679 rqual
= REF_QUAL_NONE
;
11680 memfn_quals
= TYPE_UNQUALIFIED
;
11683 if (TREE_CODE (type
) == FUNCTION_TYPE
11684 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
11685 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
11686 error (declarator
->kind
== cdk_reference
11687 ? G_("cannot declare reference to qualified function type %qT")
11688 : G_("cannot declare pointer to qualified function type %qT"),
11691 /* When the pointed-to type involves components of variable size,
11692 care must be taken to ensure that the size evaluation code is
11693 emitted early enough to dominate all the possible later uses
11694 and late enough for the variables on which it depends to have
11697 This is expected to happen automatically when the pointed-to
11698 type has a name/declaration of it's own, but special attention
11699 is required if the type is anonymous.
11701 We handle the NORMAL and FIELD contexts here by inserting a
11702 dummy statement that just evaluates the size at a safe point
11703 and ensures it is not deferred until e.g. within a deeper
11704 conditional context (c++/43555).
11706 We expect nothing to be needed here for PARM or TYPENAME.
11707 Evaluating the size at this point for TYPENAME would
11708 actually be incorrect, as we might be in the middle of an
11709 expression with side effects on the pointed-to type size
11710 "arguments" prior to the pointer declaration point and the
11711 size evaluation could end up prior to the side effects. */
11713 if (!TYPE_NAME (type
)
11714 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
11715 && at_function_scope_p ()
11716 && variably_modified_type_p (type
, NULL_TREE
))
11718 TYPE_NAME (type
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
11720 add_decl_expr (TYPE_NAME (type
));
11723 if (declarator
->kind
== cdk_reference
)
11725 /* In C++0x, the type we are creating a reference to might be
11726 a typedef which is itself a reference type. In that case,
11727 we follow the reference collapsing rules in
11728 [7.1.3/8 dcl.typedef] to create the final reference type:
11730 "If a typedef TD names a type that is a reference to a type
11731 T, an attempt to create the type 'lvalue reference to cv TD'
11732 creates the type 'lvalue reference to T,' while an attempt
11733 to create the type "rvalue reference to cv TD' creates the
11736 if (VOID_TYPE_P (type
))
11737 /* We already gave an error. */;
11738 else if (TYPE_REF_P (type
))
11740 if (declarator
->u
.reference
.rvalue_ref
)
11741 /* Leave type alone. */;
11743 type
= cp_build_reference_type (TREE_TYPE (type
), false);
11746 type
= cp_build_reference_type
11747 (type
, declarator
->u
.reference
.rvalue_ref
);
11749 /* In C++0x, we need this check for direct reference to
11750 reference declarations, which are forbidden by
11751 [8.3.2/5 dcl.ref]. Reference to reference declarations
11752 are only allowed indirectly through typedefs and template
11753 type arguments. Example:
11755 void foo(int & &); // invalid ref-to-ref decl
11757 typedef int & int_ref;
11758 void foo(int_ref &); // valid ref-to-ref decl
11760 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
11761 error ("cannot declare reference to %q#T, which is not "
11762 "a typedef or a template type argument", type
);
11764 else if (TREE_CODE (type
) == METHOD_TYPE
)
11765 type
= build_ptrmemfunc_type (build_pointer_type (type
));
11766 else if (declarator
->kind
== cdk_ptrmem
)
11768 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
11769 != NAMESPACE_DECL
);
11770 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
11771 /* We will already have complained. */
11772 type
= error_mark_node
;
11774 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
11778 type
= build_pointer_type (type
);
11780 /* Process a list of type modifier keywords (such as
11781 const or volatile) that were given inside the `*' or `&'. */
11783 if (declarator
->u
.pointer
.qualifiers
)
11786 = cp_build_qualified_type (type
,
11787 declarator
->u
.pointer
.qualifiers
);
11788 type_quals
= cp_type_quals (type
);
11791 /* Apply C++11 attributes to the pointer, and not to the
11792 type pointed to. This is unlike what is done for GNU
11793 attributes above. It is to comply with [dcl.ptr]/1:
11795 [the optional attribute-specifier-seq (7.6.1) appertains
11796 to the pointer and not to the object pointed to]. */
11797 if (declarator
->std_attributes
)
11798 decl_attributes (&type
, declarator
->std_attributes
,
11808 gcc_unreachable ();
11812 /* A `constexpr' specifier used in an object declaration declares
11813 the object as `const'. */
11814 if (constexpr_p
&& innermost_code
!= cdk_function
)
11816 /* DR1688 says that a `constexpr' specifier in combination with
11817 `volatile' is valid. */
11819 if (!TYPE_REF_P (type
))
11821 type_quals
|= TYPE_QUAL_CONST
;
11822 type
= cp_build_qualified_type (type
, type_quals
);
11826 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
11827 && TREE_CODE (type
) != FUNCTION_TYPE
11828 && TREE_CODE (type
) != METHOD_TYPE
11829 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
11831 error ("template-id %qD used as a declarator",
11833 unqualified_id
= dname
;
11836 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
11837 qualified with a class-name, turn it into a METHOD_TYPE, unless
11838 we know that the function is static. We take advantage of this
11839 opportunity to do other processing that pertains to entities
11840 explicitly declared to be class members. Note that if DECLARATOR
11841 is non-NULL, we know it is a cdk_id declarator; otherwise, we
11842 would not have exited the loop above. */
11844 && declarator
->kind
== cdk_id
11845 && declarator
->u
.id
.qualifying_scope
11846 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
11848 ctype
= declarator
->u
.id
.qualifying_scope
;
11849 ctype
= TYPE_MAIN_VARIANT (ctype
);
11850 template_count
= num_template_headers_for_class (ctype
);
11852 if (ctype
== current_class_type
)
11856 permerror (input_location
, "member functions are implicitly "
11857 "friends of their class");
11861 permerror (declarator
->id_loc
,
11862 "extra qualification %<%T::%> on member %qs",
11865 else if (/* If the qualifying type is already complete, then we
11866 can skip the following checks. */
11867 !COMPLETE_TYPE_P (ctype
)
11868 && (/* If the function is being defined, then
11869 qualifying type must certainly be complete. */
11871 /* A friend declaration of "T::f" is OK, even if
11872 "T" is a template parameter. But, if this
11873 function is not a friend, the qualifying type
11874 must be a class. */
11875 || (!friendp
&& !CLASS_TYPE_P (ctype
))
11876 /* For a declaration, the type need not be
11877 complete, if either it is dependent (since there
11878 is no meaningful definition of complete in that
11879 case) or the qualifying class is currently being
11881 || !(dependent_type_p (ctype
)
11882 || currently_open_class (ctype
)))
11883 /* Check that the qualifying type is complete. */
11884 && !complete_type_or_else (ctype
, NULL_TREE
))
11885 return error_mark_node
;
11886 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11888 if (current_class_type
11889 && (!friendp
|| funcdef_flag
|| initialized
))
11891 error (funcdef_flag
|| initialized
11892 ? G_("cannot define member function %<%T::%s%> "
11894 : G_("cannot declare member function %<%T::%s%> "
11896 ctype
, name
, current_class_type
);
11897 return error_mark_node
;
11900 else if (typedef_p
&& current_class_type
)
11902 error ("cannot declare member %<%T::%s%> within %qT",
11903 ctype
, name
, current_class_type
);
11904 return error_mark_node
;
11908 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
11909 ctype
= current_class_type
;
11911 /* Now TYPE has the actual type. */
11913 if (returned_attrs
)
11916 *attrlist
= chainon (returned_attrs
, *attrlist
);
11918 attrlist
= &returned_attrs
;
11922 && declarator
->kind
== cdk_id
11923 && declarator
->std_attributes
11924 && attrlist
!= NULL
)
11926 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
11927 a declarator-id appertains to the entity that is declared. */
11928 if (declarator
->std_attributes
!= error_mark_node
)
11929 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
11931 /* We should have already diagnosed the issue (c++/78344). */
11932 gcc_assert (seen_error ());
11935 /* Handle parameter packs. */
11936 if (parameter_pack_p
)
11938 if (decl_context
== PARM
)
11939 /* Turn the type into a pack expansion.*/
11940 type
= make_pack_expansion (type
);
11942 error ("non-parameter %qs cannot be a parameter pack", name
);
11945 if ((decl_context
== FIELD
|| decl_context
== PARM
)
11946 && !processing_template_decl
11947 && variably_modified_type_p (type
, NULL_TREE
))
11949 if (decl_context
== FIELD
)
11950 error ("data member may not have variably modified type %qT", type
);
11952 error ("parameter may not have variably modified type %qT", type
);
11953 type
= error_mark_node
;
11956 if (explicitp
== 1 || (explicitp
&& friendp
))
11958 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
11959 in the declaration of a constructor or conversion function within
11960 a class definition. */
11961 if (!current_class_type
)
11962 error_at (declspecs
->locations
[ds_explicit
],
11963 "%<explicit%> outside class declaration");
11965 error_at (declspecs
->locations
[ds_explicit
],
11966 "%<explicit%> in friend declaration");
11968 error_at (declspecs
->locations
[ds_explicit
],
11969 "only declarations of constructors and conversion operators "
11970 "can be %<explicit%>");
11974 if (storage_class
== sc_mutable
)
11976 location_t sloc
= declspecs
->locations
[ds_storage_class
];
11977 if (decl_context
!= FIELD
|| friendp
)
11979 error_at (sloc
, "non-member %qs cannot be declared %<mutable%>",
11981 storage_class
= sc_none
;
11983 else if (decl_context
== TYPENAME
|| typedef_p
)
11986 "non-object member %qs cannot be declared %<mutable%>",
11988 storage_class
= sc_none
;
11990 else if (TREE_CODE (type
) == FUNCTION_TYPE
11991 || TREE_CODE (type
) == METHOD_TYPE
)
11993 error_at (sloc
, "function %qs cannot be declared %<mutable%>",
11995 storage_class
= sc_none
;
11999 error_at (sloc
, "%<static%> %qs cannot be declared %<mutable%>",
12001 storage_class
= sc_none
;
12003 else if (type_quals
& TYPE_QUAL_CONST
)
12005 error_at (sloc
, "%<const%> %qs cannot be declared %<mutable%>",
12007 storage_class
= sc_none
;
12009 else if (TYPE_REF_P (type
))
12011 permerror (sloc
, "reference %qs cannot be declared %<mutable%>",
12013 storage_class
= sc_none
;
12017 location_t loc
= declarator
? declarator
->id_loc
: input_location
;
12019 /* If this is declaring a typedef name, return a TYPE_DECL. */
12020 if (typedef_p
&& decl_context
!= TYPENAME
)
12022 bool alias_p
= decl_spec_seq_has_spec_p (declspecs
, ds_alias
);
12025 /* This declaration:
12027 typedef void f(int) const;
12029 declares a function type which is not a member of any
12030 particular class, but which is cv-qualified; for
12031 example "f S::*" declares a pointer to a const-qualified
12032 member function of S. We record the cv-qualification in the
12034 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
12036 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
12038 /* We have now dealt with these qualifiers. */
12039 memfn_quals
= TYPE_UNQUALIFIED
;
12040 rqual
= REF_QUAL_NONE
;
12043 if (type_uses_auto (type
))
12046 error_at (declspecs
->locations
[ds_type_spec
],
12047 "%<auto%> not allowed in alias declaration");
12049 error_at (declspecs
->locations
[ds_type_spec
],
12050 "typedef declared %<auto%>");
12051 type
= error_mark_node
;
12055 error_at (location_of (reqs
), "requires-clause on typedef");
12057 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
)
12059 error ("typedef name may not be a nested-name-specifier");
12060 type
= error_mark_node
;
12063 if (decl_context
== FIELD
)
12064 decl
= build_lang_decl_loc (loc
, TYPE_DECL
, unqualified_id
, type
);
12066 decl
= build_decl (loc
, TYPE_DECL
, unqualified_id
, type
);
12068 if (decl_context
!= FIELD
)
12070 if (!current_function_decl
)
12071 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
12072 else if (DECL_MAYBE_IN_CHARGE_CDTOR_P (current_function_decl
))
12073 /* The TYPE_DECL is "abstract" because there will be
12074 clones of this constructor/destructor, and there will
12075 be copies of this TYPE_DECL generated in those
12076 clones. The decloning optimization (for space) may
12077 revert this subsequently if it determines that
12078 the clones should share a common implementation. */
12079 DECL_ABSTRACT_P (decl
) = true;
12081 else if (current_class_type
12082 && constructor_name_p (unqualified_id
, current_class_type
))
12083 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
12084 "as enclosing class",
12087 /* If the user declares "typedef struct {...} foo" then the
12088 struct will have an anonymous name. Fill that name in now.
12089 Nothing can refer to it, so nothing needs know about the name
12091 if (type
!= error_mark_node
12093 && TYPE_NAME (type
)
12094 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12095 && TYPE_UNNAMED_P (type
)
12096 && declspecs
->type_definition_p
12097 && attributes_naming_typedef_ok (*attrlist
)
12098 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
12099 name_unnamed_type (type
, decl
);
12102 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
12103 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
12105 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
12106 memfn_quals
!= TYPE_UNQUALIFIED
,
12107 inlinep
, friendp
, raises
!= NULL_TREE
,
12108 declspecs
->locations
);
12111 /* Acknowledge that this was written:
12112 `using analias = atype;'. */
12113 TYPE_DECL_ALIAS_P (decl
) = 1;
12118 /* Detect the case of an array type of unspecified size
12119 which came, as such, direct from a typedef name.
12120 We must copy the type, so that the array's domain can be
12121 individually set by the object's initializer. */
12123 if (type
&& typedef_type
12124 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
12125 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
12126 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
12128 /* Detect where we're using a typedef of function type to declare a
12129 function. PARMS will not be set, so we must create it now. */
12131 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
12133 tree decls
= NULL_TREE
;
12136 for (args
= TYPE_ARG_TYPES (type
);
12137 args
&& args
!= void_list_node
;
12138 args
= TREE_CHAIN (args
))
12140 tree decl
= cp_build_parm_decl (NULL_TREE
, NULL_TREE
,
12141 TREE_VALUE (args
));
12143 DECL_CHAIN (decl
) = decls
;
12147 parms
= nreverse (decls
);
12149 if (decl_context
!= TYPENAME
)
12151 /* The qualifiers on the function type become the qualifiers on
12152 the non-static member function. */
12153 memfn_quals
|= type_memfn_quals (type
);
12154 rqual
= type_memfn_rqual (type
);
12155 type_quals
= TYPE_UNQUALIFIED
;
12159 /* If this is a type name (such as, in a cast or sizeof),
12160 compute the type and return it now. */
12162 if (decl_context
== TYPENAME
)
12164 /* Note that here we don't care about type_quals. */
12166 /* Special case: "friend class foo" looks like a TYPENAME context. */
12171 error ("%<inline%> specified for friend class declaration");
12177 /* Don't allow friend declaration without a class-key. */
12178 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
12179 permerror (input_location
, "template parameters cannot be friends");
12180 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
12181 permerror (input_location
, "friend declaration requires class-key, "
12182 "i.e. %<friend class %T::%D%>",
12183 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
12185 permerror (input_location
, "friend declaration requires class-key, "
12186 "i.e. %<friend %#T%>",
12190 /* Only try to do this stuff if we didn't already give up. */
12191 if (type
!= integer_type_node
)
12193 /* A friendly class? */
12194 if (current_class_type
)
12195 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
12196 /*complain=*/true);
12198 error ("trying to make class %qT a friend of global scope",
12201 type
= void_type_node
;
12204 else if (memfn_quals
|| rqual
)
12206 if (ctype
== NULL_TREE
12207 && TREE_CODE (type
) == METHOD_TYPE
)
12208 ctype
= TYPE_METHOD_BASETYPE (type
);
12211 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
12212 /* Core issue #547: need to allow this in template type args.
12213 Allow it in general in C++11 for alias-declarations. */
12214 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
12215 && TREE_CODE (type
) == FUNCTION_TYPE
)
12216 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
12218 error ("invalid qualifiers on non-member function type");
12222 error_at (location_of (reqs
), "requires-clause on type-id");
12226 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
12227 && decl_context
!= CATCHPARM
12228 && TREE_CODE (type
) != UNION_TYPE
12230 && innermost_code
!= cdk_decomp
)
12232 error ("abstract declarator %qT used as declaration", type
);
12233 return error_mark_node
;
12236 if (!FUNC_OR_METHOD_TYPE_P (type
))
12238 /* Only functions may be declared using an operator-function-id. */
12239 if (dname
&& IDENTIFIER_ANY_OP_P (dname
))
12241 error ("declaration of %qD as non-function", dname
);
12242 return error_mark_node
;
12246 error_at (location_of (reqs
),
12247 "requires-clause on declaration of non-function type %qT",
12251 /* We don't check parameter types here because we can emit a better
12252 error message later. */
12253 if (decl_context
!= PARM
)
12255 type
= check_var_type (unqualified_id
, type
);
12256 if (type
== error_mark_node
)
12257 return error_mark_node
;
12260 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
12261 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
12263 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
12265 if (ctype
|| in_namespace
)
12266 error ("cannot use %<::%> in parameter declaration");
12268 if (type_uses_auto (type
)
12269 && !(cxx_dialect
>= cxx17
&& template_parm_flag
))
12271 if (cxx_dialect
>= cxx14
)
12272 error ("%<auto%> parameter not permitted in this context");
12274 error ("parameter declared %<auto%>");
12275 type
= error_mark_node
;
12278 /* A parameter declared as an array of T is really a pointer to T.
12279 One declared as a function is really a pointer to a function.
12280 One declared as a member is really a pointer to member. */
12282 if (TREE_CODE (type
) == ARRAY_TYPE
)
12284 /* Transfer const-ness of array into that of type pointed to. */
12285 type
= build_pointer_type (TREE_TYPE (type
));
12286 type_quals
= TYPE_UNQUALIFIED
;
12287 array_parameter_p
= true;
12289 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
12290 type
= build_pointer_type (type
);
12293 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
12294 && !(unqualified_id
12295 && identifier_p (unqualified_id
)
12296 && IDENTIFIER_NEWDEL_OP_P (unqualified_id
)))
12298 cp_cv_quals real_quals
= memfn_quals
;
12299 if (cxx_dialect
< cxx14
&& constexpr_p
12300 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
12301 real_quals
|= TYPE_QUAL_CONST
;
12302 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
12306 tree decl
= NULL_TREE
;
12308 if (decl_context
== PARM
)
12310 decl
= cp_build_parm_decl (NULL_TREE
, unqualified_id
, type
);
12311 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
12313 bad_specifiers (decl
, BSP_PARM
, virtualp
,
12314 memfn_quals
!= TYPE_UNQUALIFIED
,
12315 inlinep
, friendp
, raises
!= NULL_TREE
,
12316 declspecs
->locations
);
12318 else if (decl_context
== FIELD
)
12320 if (!staticp
&& !friendp
&& TREE_CODE (type
) != METHOD_TYPE
)
12321 if (tree auto_node
= type_uses_auto (type
))
12323 location_t tloc
= declspecs
->locations
[ds_type_spec
];
12324 if (CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
12325 error_at (tloc
, "invalid use of template-name %qE without an "
12327 CLASS_PLACEHOLDER_TEMPLATE (auto_node
));
12329 error_at (tloc
, "non-static data member declared with "
12330 "placeholder %qT", auto_node
);
12331 type
= error_mark_node
;
12334 /* The C99 flexible array extension. */
12335 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
12336 && TYPE_DOMAIN (type
) == NULL_TREE
)
12339 && (TREE_CODE (ctype
) == UNION_TYPE
12340 || TREE_CODE (ctype
) == QUAL_UNION_TYPE
))
12342 error ("flexible array member in union");
12343 type
= error_mark_node
;
12347 /* Array is a flexible member. */
12348 if (in_system_header_at (input_location
))
12349 /* Do not warn on flexible array members in system
12350 headers because glibc uses them. */;
12351 else if (name
&& declarator
)
12352 pedwarn (declarator
->id_loc
, OPT_Wpedantic
,
12353 "ISO C++ forbids flexible array member %qs", name
);
12355 pedwarn (input_location
, OPT_Wpedantic
,
12356 "ISO C++ forbids flexible array members");
12358 /* Flexible array member has a null domain. */
12359 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
12363 if (type
== error_mark_node
)
12365 /* Happens when declaring arrays of sizes which
12366 are error_mark_node, for example. */
12369 else if (in_namespace
&& !friendp
)
12371 /* Something like struct S { int N::j; }; */
12372 error ("invalid use of %<::%>");
12373 return error_mark_node
;
12375 else if (FUNC_OR_METHOD_TYPE_P (type
) && unqualified_id
)
12378 tree function_context
;
12382 /* This should never happen in pure C++ (the check
12383 could be an assert). It could happen in
12384 Objective-C++ if someone writes invalid code that
12385 uses a function declaration for an instance
12386 variable or property (instance variables and
12387 properties are parsed as FIELD_DECLs, but they are
12388 part of an Objective-C class, not a C++ class).
12389 That code is invalid and is caught by this
12393 error ("declaration of function %qD in invalid context",
12395 return error_mark_node
;
12398 /* ``A union may [ ... ] not [ have ] virtual functions.''
12400 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
12402 error_at (declspecs
->locations
[ds_virtual
],
12403 "function %qD declared %<virtual%> inside a union",
12405 return error_mark_node
;
12409 && identifier_p (unqualified_id
)
12410 && IDENTIFIER_NEWDEL_OP_P (unqualified_id
))
12412 error_at (declspecs
->locations
[ds_virtual
],
12413 "%qD cannot be declared %<virtual%>, since it "
12414 "is always static", unqualified_id
);
12419 /* Check that the name used for a destructor makes sense. */
12420 if (sfk
== sfk_destructor
)
12422 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
12426 gcc_assert (friendp
);
12427 error ("expected qualified name in friend declaration "
12428 "for destructor %qD", uqname
);
12429 return error_mark_node
;
12432 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
12434 error ("declaration of %qD as member of %qT",
12436 return error_mark_node
;
12440 error_at (declspecs
->locations
[ds_concept
],
12441 "a destructor cannot be %<concept%>");
12442 return error_mark_node
;
12446 error_at (declspecs
->locations
[ds_constexpr
],
12447 "a destructor cannot be %<constexpr%>");
12448 return error_mark_node
;
12451 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
12453 error ("expected qualified name in friend declaration "
12454 "for constructor %qD",
12455 id_declarator
->u
.id
.unqualified_name
);
12456 return error_mark_node
;
12458 if (sfk
== sfk_constructor
)
12461 error_at (declspecs
->locations
[ds_concept
],
12462 "a constructor cannot be %<concept%>");
12463 return error_mark_node
;
12467 error_at (declspecs
->locations
[ds_concept
],
12468 "a concept cannot be a member function");
12472 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
12474 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
12475 if (variable_template_p (tmpl
))
12477 error ("specialization of variable template %qD "
12478 "declared as function", tmpl
);
12479 inform (DECL_SOURCE_LOCATION (tmpl
),
12480 "variable template declared here");
12481 return error_mark_node
;
12485 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
12486 function_context
= (ctype
!= NULL_TREE
) ?
12487 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
12488 publicp
= (! friendp
|| ! staticp
)
12489 && function_context
== NULL_TREE
;
12491 decl
= grokfndecl (ctype
, type
,
12492 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
12493 ? unqualified_id
: dname
,
12498 virtualp
, flags
, memfn_quals
, rqual
, raises
,
12499 friendp
? -1 : 0, friendp
, publicp
,
12500 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
12501 initialized
== SD_DELETED
, sfk
,
12502 funcdef_flag
, late_return_type_p
,
12503 template_count
, in_namespace
,
12504 attrlist
, declarator
->id_loc
);
12505 decl
= set_virt_specifiers (decl
, virt_specifiers
);
12506 if (decl
== NULL_TREE
)
12507 return error_mark_node
;
12509 /* This clobbers the attrs stored in `decl' from `attrlist'. */
12510 /* The decl and setting of decl_attr is also turned off. */
12511 decl
= build_decl_attribute_variant (decl
, decl_attr
);
12514 /* [class.conv.ctor]
12516 A constructor declared without the function-specifier
12517 explicit that can be called with a single parameter
12518 specifies a conversion from the type of its first
12519 parameter to the type of its class. Such a constructor
12520 is called a converting constructor. */
12521 if (explicitp
== 2)
12522 DECL_NONCONVERTING_P (decl
) = 1;
12524 if (declspecs
->explicit_specifier
)
12525 store_explicit_specifier (decl
, declspecs
->explicit_specifier
);
12527 else if (!staticp
&& !dependent_type_p (type
)
12528 && !COMPLETE_TYPE_P (complete_type (type
))
12529 && (!complete_or_array_type_p (type
)
12530 || initialized
== 0))
12532 if (TREE_CODE (type
) != ARRAY_TYPE
12533 || !COMPLETE_TYPE_P (TREE_TYPE (type
)))
12535 if (unqualified_id
)
12537 error_at (declarator
->id_loc
,
12538 "field %qD has incomplete type %qT",
12539 unqualified_id
, type
);
12540 cxx_incomplete_type_inform (strip_array_types (type
));
12543 error ("name %qT has incomplete type", type
);
12545 type
= error_mark_node
;
12553 if (unqualified_id
&& declarator
)
12554 error_at (declarator
->id_loc
,
12555 "%qE is neither function nor member function; "
12556 "cannot be declared friend", unqualified_id
);
12558 error ("unnamed field is neither function nor member "
12559 "function; cannot be declared friend");
12560 return error_mark_node
;
12567 /* Friends are treated specially. */
12568 if (ctype
== current_class_type
)
12569 ; /* We already issued a permerror. */
12570 else if (decl
&& DECL_NAME (decl
))
12572 if (template_class_depth (current_class_type
) == 0)
12574 decl
= check_explicit_specialization
12575 (unqualified_id
, decl
, template_count
,
12576 2 * funcdef_flag
+ 4);
12577 if (decl
== error_mark_node
)
12578 return error_mark_node
;
12581 decl
= do_friend (ctype
, unqualified_id
, decl
,
12587 return error_mark_node
;
12590 /* Structure field. It may not be a function, except for C++. */
12592 if (decl
== NULL_TREE
)
12596 /* C++ allows static class members. All other work
12597 for this is done by grokfield. */
12598 decl
= build_lang_decl_loc (loc
, VAR_DECL
,
12599 unqualified_id
, type
);
12600 set_linkage_for_static_data_member (decl
);
12602 error_at (declspecs
->locations
[ds_concept
],
12603 "static data member %qE declared %<concept%>",
12605 else if (constexpr_p
&& !initialized
)
12607 error_at (DECL_SOURCE_LOCATION (decl
),
12608 "%<constexpr%> static data member %qD must "
12609 "have an initializer", decl
);
12610 constexpr_p
= false;
12614 mark_inline_variable (decl
, declspecs
->locations
[ds_inline
]);
12616 if (!DECL_VAR_DECLARED_INLINE_P (decl
)
12617 && !(cxx_dialect
>= cxx17
&& constexpr_p
))
12618 /* Even if there is an in-class initialization, DECL
12619 is considered undefined until an out-of-class
12620 definition is provided, unless this is an inline
12622 DECL_EXTERNAL (decl
) = 1;
12626 CP_DECL_THREAD_LOCAL_P (decl
) = true;
12627 if (!processing_template_decl
)
12628 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
12629 if (declspecs
->gnu_thread_keyword_p
)
12630 SET_DECL_GNU_TLS_P (decl
);
12636 error_at (declspecs
->locations
[ds_concept
],
12637 "non-static data member %qE declared %<concept%>",
12639 else if (constexpr_p
)
12641 error_at (declspecs
->locations
[ds_constexpr
],
12642 "non-static data member %qE declared %<constexpr%>",
12644 constexpr_p
= false;
12646 decl
= build_decl (loc
, FIELD_DECL
, unqualified_id
, type
);
12647 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
12648 if (bitfield
&& !unqualified_id
)
12650 TREE_NO_WARNING (decl
) = 1;
12651 DECL_PADDING_P (decl
) = 1;
12654 if (storage_class
== sc_mutable
)
12656 DECL_MUTABLE_P (decl
) = 1;
12657 storage_class
= sc_none
;
12662 /* An attempt is being made to initialize a non-static
12663 member. This is new in C++11. */
12664 maybe_warn_cpp0x (CPP0X_NSDMI
);
12666 /* If this has been parsed with static storage class, but
12667 errors forced staticp to be cleared, ensure NSDMI is
12669 if (declspecs
->storage_class
== sc_static
)
12670 DECL_INITIAL (decl
) = error_mark_node
;
12674 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
12675 memfn_quals
!= TYPE_UNQUALIFIED
,
12676 staticp
? false : inlinep
, friendp
,
12677 raises
!= NULL_TREE
,
12678 declspecs
->locations
);
12681 else if (TREE_CODE (type
) == FUNCTION_TYPE
12682 || TREE_CODE (type
) == METHOD_TYPE
)
12684 tree original_name
;
12687 if (!unqualified_id
)
12688 return error_mark_node
;
12690 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
12691 original_name
= dname
;
12693 original_name
= unqualified_id
;
12694 // FIXME:gcc_assert (original_name == dname);
12696 if (storage_class
== sc_auto
)
12697 error ("storage class %<auto%> invalid for function %qs", name
);
12698 else if (storage_class
== sc_register
)
12699 error ("storage class %<register%> invalid for function %qs", name
);
12702 if (declspecs
->gnu_thread_keyword_p
)
12703 error_at (declspecs
->locations
[ds_thread
],
12704 "storage class %<__thread%> invalid for function %qs",
12707 error_at (declspecs
->locations
[ds_thread
],
12708 "storage class %<thread_local%> invalid for "
12709 "function %qs", name
);
12712 if (virt_specifiers
)
12713 error ("virt-specifiers in %qs not allowed outside a class "
12714 "definition", name
);
12715 /* Function declaration not at top level.
12716 Storage classes other than `extern' are not allowed
12717 and `extern' makes no difference. */
12718 if (! toplevel_bindings_p ()
12719 && (storage_class
== sc_static
12720 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
12723 if (storage_class
== sc_static
)
12724 pedwarn (declspecs
->locations
[ds_storage_class
], OPT_Wpedantic
,
12725 "%<static%> specifier invalid for function %qs "
12726 "declared out of global scope", name
);
12728 pedwarn (declspecs
->locations
[ds_inline
], OPT_Wpedantic
,
12729 "%<inline%> specifier invalid for function %qs "
12730 "declared out of global scope", name
);
12733 if (ctype
== NULL_TREE
)
12737 error ("virtual non-class function %qs", name
);
12740 else if (sfk
== sfk_constructor
12741 || sfk
== sfk_destructor
)
12743 error (funcdef_flag
12744 ? G_("%qs defined in a non-class scope")
12745 : G_("%qs declared in a non-class scope"), name
);
12750 /* Record whether the function is public. */
12751 publicp
= (ctype
!= NULL_TREE
12752 || storage_class
!= sc_static
);
12754 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
12756 reqs
, virtualp
, flags
, memfn_quals
, rqual
, raises
,
12759 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
12760 initialized
== SD_DELETED
,
12763 late_return_type_p
,
12764 template_count
, in_namespace
, attrlist
,
12765 declarator
->id_loc
);
12766 if (decl
== NULL_TREE
)
12767 return error_mark_node
;
12769 if (explicitp
== 2)
12770 DECL_NONCONVERTING_P (decl
) = 1;
12773 int invalid_static
= 0;
12775 /* Don't allow a static member function in a class, and forbid
12776 declaring main to be static. */
12777 if (TREE_CODE (type
) == METHOD_TYPE
)
12779 permerror (input_location
, "cannot declare member function %qD to have "
12780 "static linkage", decl
);
12781 invalid_static
= 1;
12783 else if (current_function_decl
)
12785 /* 7.1.1: There can be no static function declarations within a
12787 error_at (declspecs
->locations
[ds_storage_class
],
12788 "cannot declare static function inside another function");
12789 invalid_static
= 1;
12792 if (invalid_static
)
12795 storage_class
= sc_none
;
12801 /* It's a variable. */
12803 /* An uninitialized decl with `extern' is a reference. */
12804 decl
= grokvardecl (type
, dname
, unqualified_id
,
12811 ctype
? ctype
: in_namespace
,
12813 if (decl
== NULL_TREE
)
12814 return error_mark_node
;
12816 bad_specifiers (decl
, BSP_VAR
, virtualp
,
12817 memfn_quals
!= TYPE_UNQUALIFIED
,
12818 inlinep
, friendp
, raises
!= NULL_TREE
,
12819 declspecs
->locations
);
12823 DECL_CONTEXT (decl
) = ctype
;
12826 permerror (declspecs
->locations
[ds_storage_class
],
12827 "%<static%> may not be used when defining "
12828 "(as opposed to declaring) a static data member");
12830 storage_class
= sc_none
;
12832 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
12834 error ("static member %qD declared %<register%>", decl
);
12835 storage_class
= sc_none
;
12837 if (storage_class
== sc_extern
&& pedantic
)
12839 pedwarn (input_location
, OPT_Wpedantic
,
12840 "cannot explicitly declare member %q#D to have "
12841 "extern linkage", decl
);
12842 storage_class
= sc_none
;
12845 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
12847 error_at (DECL_SOURCE_LOCATION (decl
),
12848 "declaration of %<constexpr%> variable %qD "
12849 "is not a definition", decl
);
12850 constexpr_p
= false;
12854 mark_inline_variable (decl
, declspecs
->locations
[ds_inline
]);
12855 if (innermost_code
== cdk_decomp
)
12857 gcc_assert (declarator
&& declarator
->kind
== cdk_decomp
);
12858 DECL_SOURCE_LOCATION (decl
) = declarator
->id_loc
;
12859 DECL_ARTIFICIAL (decl
) = 1;
12860 fit_decomposition_lang_decl (decl
, NULL_TREE
);
12864 if (VAR_P (decl
) && !initialized
)
12865 if (tree auto_node
= type_uses_auto (type
))
12866 if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
12868 location_t loc
= declspecs
->locations
[ds_type_spec
];
12869 error_at (loc
, "declaration of %q#D has no initializer", decl
);
12870 TREE_TYPE (decl
) = error_mark_node
;
12873 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
12875 if (toplevel_bindings_p ())
12877 /* It's common practice (and completely valid) to have a const
12878 be initialized and declared extern. */
12879 if (!(type_quals
& TYPE_QUAL_CONST
))
12880 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
12881 "%qs initialized and declared %<extern%>", name
);
12885 error_at (DECL_SOURCE_LOCATION (decl
),
12886 "%qs has both %<extern%> and initializer", name
);
12887 return error_mark_node
;
12891 /* Record `register' declaration for warnings on &
12892 and in case doing stupid register allocation. */
12894 if (storage_class
== sc_register
)
12896 DECL_REGISTER (decl
) = 1;
12897 /* Warn about register storage specifiers on PARM_DECLs. */
12898 if (TREE_CODE (decl
) == PARM_DECL
)
12900 if (cxx_dialect
>= cxx17
)
12901 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
12902 "ISO C++17 does not allow %<register%> storage "
12903 "class specifier");
12905 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
12906 "%<register%> storage class specifier used");
12909 else if (storage_class
== sc_extern
)
12910 DECL_THIS_EXTERN (decl
) = 1;
12911 else if (storage_class
== sc_static
)
12912 DECL_THIS_STATIC (decl
) = 1;
12914 /* Set constexpr flag on vars (functions got it in grokfndecl). */
12915 if (constexpr_p
&& VAR_P (decl
))
12916 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
12918 /* Record constancy and volatility on the DECL itself . There's
12919 no need to do this when processing a template; we'll do this
12920 for the instantiated declaration based on the type of DECL. */
12921 if (!processing_template_decl
)
12922 cp_apply_type_quals_to_decl (type_quals
, decl
);
12928 /* Subroutine of start_function. Ensure that each of the parameter
12929 types (as listed in PARMS) is complete, as is required for a
12930 function definition. */
12933 require_complete_types_for_parms (tree parms
)
12935 for (; parms
; parms
= DECL_CHAIN (parms
))
12937 if (dependent_type_p (TREE_TYPE (parms
)))
12939 if (!VOID_TYPE_P (TREE_TYPE (parms
))
12940 && complete_type_or_else (TREE_TYPE (parms
), parms
))
12942 relayout_decl (parms
);
12943 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
12945 maybe_warn_parm_abi (TREE_TYPE (parms
),
12946 DECL_SOURCE_LOCATION (parms
));
12949 /* grokparms or complete_type_or_else will have already issued
12951 TREE_TYPE (parms
) = error_mark_node
;
12955 /* Returns nonzero if T is a local variable. */
12958 local_variable_p (const_tree t
)
12961 /* A VAR_DECL with a context that is a _TYPE is a static data
12963 && !TYPE_P (CP_DECL_CONTEXT (t
))
12964 /* Any other non-local variable must be at namespace scope. */
12965 && !DECL_NAMESPACE_SCOPE_P (t
))
12966 || (TREE_CODE (t
) == PARM_DECL
))
12972 /* Like local_variable_p, but suitable for use as a tree-walking
12976 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
12979 if (local_variable_p (*tp
)
12980 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
12982 else if (TYPE_P (*tp
))
12983 *walk_subtrees
= 0;
12988 /* Check that ARG, which is a default-argument expression for a
12989 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
12990 something goes wrong. DECL may also be a _TYPE node, rather than a
12991 DECL, if there is no DECL available. */
12994 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
12999 if (TREE_CODE (arg
) == DEFAULT_ARG
)
13000 /* We get a DEFAULT_ARG when looking at an in-class declaration
13001 with a default argument. Ignore the argument for now; we'll
13002 deal with it after the class is complete. */
13011 decl_type
= TREE_TYPE (decl
);
13013 if (arg
== error_mark_node
13014 || decl
== error_mark_node
13015 || TREE_TYPE (arg
) == error_mark_node
13016 || decl_type
== error_mark_node
)
13017 /* Something already went wrong. There's no need to check
13019 return error_mark_node
;
13021 /* [dcl.fct.default]
13023 A default argument expression is implicitly converted to the
13025 ++cp_unevaluated_operand
;
13026 /* Avoid digest_init clobbering the initializer. */
13027 tree carg
= BRACE_ENCLOSED_INITIALIZER_P (arg
) ? unshare_expr (arg
): arg
;
13028 perform_implicit_conversion_flags (decl_type
, carg
, complain
,
13030 --cp_unevaluated_operand
;
13032 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
13034 if (TYPE_PTR_OR_PTRMEM_P (decl_type
)
13035 && null_ptr_cst_p (arg
))
13036 return nullptr_node
;
13038 /* [dcl.fct.default]
13040 Local variables shall not be used in default argument
13043 The keyword `this' shall not be used in a default argument of a
13044 member function. */
13045 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
13048 if (complain
& tf_warning_or_error
)
13050 if (DECL_NAME (var
) == this_identifier
)
13051 permerror (input_location
, "default argument %qE uses %qD",
13054 error ("default argument %qE uses local variable %qD", arg
, var
);
13056 return error_mark_node
;
13063 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
13066 type_is_deprecated (tree type
)
13068 enum tree_code code
;
13069 if (TREE_DEPRECATED (type
))
13071 if (TYPE_NAME (type
))
13073 if (TREE_DEPRECATED (TYPE_NAME (type
)))
13079 /* Do warn about using typedefs to a deprecated class. */
13080 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
13081 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
13083 code
= TREE_CODE (type
);
13085 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
13086 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
13087 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
13088 return type_is_deprecated (TREE_TYPE (type
));
13090 if (TYPE_PTRMEMFUNC_P (type
))
13091 return type_is_deprecated
13092 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
13097 /* Decode the list of parameter types for a function type.
13098 Given the list of things declared inside the parens,
13099 return a list of types.
13101 If this parameter does not end with an ellipsis, we append
13104 *PARMS is set to the chain of PARM_DECLs created. */
13107 grokparms (tree parmlist
, tree
*parms
)
13109 tree result
= NULL_TREE
;
13110 tree decls
= NULL_TREE
;
13114 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
13116 tree type
= NULL_TREE
;
13117 tree init
= TREE_PURPOSE (parm
);
13118 tree decl
= TREE_VALUE (parm
);
13120 if (parm
== void_list_node
)
13123 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
13126 type
= TREE_TYPE (decl
);
13127 if (VOID_TYPE_P (type
))
13129 if (same_type_p (type
, void_type_node
)
13131 && !DECL_NAME (decl
) && !result
13132 && TREE_CHAIN (parm
) == void_list_node
)
13133 /* DR 577: A parameter list consisting of a single
13134 unnamed parameter of non-dependent type 'void'. */
13136 else if (cv_qualified_p (type
))
13137 error_at (DECL_SOURCE_LOCATION (decl
),
13138 "invalid use of cv-qualified type %qT in "
13139 "parameter declaration", type
);
13141 error_at (DECL_SOURCE_LOCATION (decl
),
13142 "invalid use of type %<void%> in parameter "
13144 /* It's not a good idea to actually create parameters of
13145 type `void'; other parts of the compiler assume that a
13146 void type terminates the parameter list. */
13147 type
= error_mark_node
;
13148 TREE_TYPE (decl
) = error_mark_node
;
13151 if (type
!= error_mark_node
)
13153 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
13155 tree deptype
= type_is_deprecated (type
);
13157 cp_warn_deprecated_use (deptype
);
13160 /* Top-level qualifiers on the parameters are
13161 ignored for function types. */
13162 type
= cp_build_qualified_type (type
, 0);
13163 if (TREE_CODE (type
) == METHOD_TYPE
)
13165 error ("parameter %qD invalidly declared method type", decl
);
13166 type
= build_pointer_type (type
);
13167 TREE_TYPE (decl
) = type
;
13169 else if (abstract_virtuals_error (decl
, type
))
13170 any_error
= 1; /* Seems like a good idea. */
13171 else if (cxx_dialect
< cxx17
&& INDIRECT_TYPE_P (type
))
13173 /* Before C++17 DR 393:
13174 [dcl.fct]/6, parameter types cannot contain pointers
13175 (references) to arrays of unknown bound. */
13176 tree t
= TREE_TYPE (type
);
13177 int ptr
= TYPE_PTR_P (type
);
13181 if (TYPE_PTR_P (t
))
13183 else if (TREE_CODE (t
) != ARRAY_TYPE
)
13185 else if (!TYPE_DOMAIN (t
))
13189 if (TREE_CODE (t
) == ARRAY_TYPE
)
13190 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
13192 ? G_("parameter %qD includes pointer to array of "
13193 "unknown bound %qT")
13194 : G_("parameter %qD includes reference to array of "
13195 "unknown bound %qT"),
13201 else if (init
&& !processing_template_decl
)
13202 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
13205 DECL_CHAIN (decl
) = decls
;
13207 result
= tree_cons (init
, type
, result
);
13209 decls
= nreverse (decls
);
13210 result
= nreverse (result
);
13212 result
= chainon (result
, void_list_node
);
13219 /* D is a constructor or overloaded `operator='.
13221 Let T be the class in which D is declared. Then, this function
13224 -1 if D's is an ill-formed constructor or copy assignment operator
13225 whose first parameter is of type `T'.
13226 0 if D is not a copy constructor or copy assignment
13228 1 if D is a copy constructor or copy assignment operator whose
13229 first parameter is a reference to non-const qualified T.
13230 2 if D is a copy constructor or copy assignment operator whose
13231 first parameter is a reference to const qualified T.
13233 This function can be used as a predicate. Positive values indicate
13234 a copy constructor and nonzero values indicate a copy assignment
13238 copy_fn_p (const_tree d
)
13244 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
13246 if (TREE_CODE (d
) == TEMPLATE_DECL
13247 || (DECL_TEMPLATE_INFO (d
)
13248 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
13249 /* Instantiations of template member functions are never copy
13250 functions. Note that member functions of templated classes are
13251 represented as template functions internally, and we must
13252 accept those as copy functions. */
13255 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
13259 arg_type
= TREE_VALUE (args
);
13260 if (arg_type
== error_mark_node
)
13263 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
13265 /* Pass by value copy assignment operator. */
13268 else if (TYPE_REF_P (arg_type
)
13269 && !TYPE_REF_IS_RVALUE (arg_type
)
13270 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
13272 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
13278 args
= TREE_CHAIN (args
);
13280 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
13281 /* There are more non-optional args. */
13287 /* D is a constructor or overloaded `operator='.
13289 Let T be the class in which D is declared. Then, this function
13290 returns true when D is a move constructor or move assignment
13291 operator, false otherwise. */
13294 move_fn_p (const_tree d
)
13296 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
13298 if (cxx_dialect
== cxx98
)
13299 /* There are no move constructors if we are in C++98 mode. */
13302 if (TREE_CODE (d
) == TEMPLATE_DECL
13303 || (DECL_TEMPLATE_INFO (d
)
13304 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
13305 /* Instantiations of template member functions are never move
13306 functions. Note that member functions of templated classes are
13307 represented as template functions internally, and we must
13308 accept those as move functions. */
13311 return move_signature_fn_p (d
);
13314 /* D is a constructor or overloaded `operator='.
13316 Then, this function returns true when D has the same signature as a move
13317 constructor or move assignment operator (because either it is such a
13318 ctor/op= or it is a template specialization with the same signature),
13319 false otherwise. */
13322 move_signature_fn_p (const_tree d
)
13326 bool result
= false;
13328 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
13332 arg_type
= TREE_VALUE (args
);
13333 if (arg_type
== error_mark_node
)
13336 if (TYPE_REF_P (arg_type
)
13337 && TYPE_REF_IS_RVALUE (arg_type
)
13338 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
13342 args
= TREE_CHAIN (args
);
13344 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
13345 /* There are more non-optional args. */
13351 /* Remember any special properties of member function DECL. */
13354 grok_special_member_properties (tree decl
)
13358 if (TREE_CODE (decl
) == USING_DECL
13359 || !DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
13362 class_type
= DECL_CONTEXT (decl
);
13363 if (IDENTIFIER_CTOR_P (DECL_NAME (decl
)))
13365 int ctor
= copy_fn_p (decl
);
13367 if (!DECL_ARTIFICIAL (decl
))
13368 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
13374 A non-template constructor for class X is a copy
13375 constructor if its first parameter is of type X&, const
13376 X&, volatile X& or const volatile X&, and either there
13377 are no other parameters or else all other parameters have
13378 default arguments. */
13379 TYPE_HAS_COPY_CTOR (class_type
) = 1;
13380 if (user_provided_p (decl
))
13381 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
13383 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
13385 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
13386 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
13387 else if (move_fn_p (decl
) && user_provided_p (decl
))
13388 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
13389 else if (is_list_ctor (decl
))
13390 TYPE_HAS_LIST_CTOR (class_type
) = 1;
13392 if (DECL_DECLARED_CONSTEXPR_P (decl
)
13393 && !ctor
&& !move_fn_p (decl
))
13394 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
13396 else if (DECL_NAME (decl
) == assign_op_identifier
)
13400 A non-template assignment operator for class X is a copy
13401 assignment operator if its parameter is of type X, X&, const
13402 X&, volatile X& or const volatile X&. */
13404 int assop
= copy_fn_p (decl
);
13408 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
13409 if (user_provided_p (decl
))
13410 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
13412 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
13414 else if (move_fn_p (decl
) && user_provided_p (decl
))
13415 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
13417 else if (IDENTIFIER_CONV_OP_P (DECL_NAME (decl
)))
13418 TYPE_HAS_CONVERSION (class_type
) = true;
13420 /* Destructors are handled in check_methods. */
13423 /* Check a constructor DECL has the correct form. Complains
13424 if the class has a constructor of the form X(X). */
13427 grok_ctor_properties (const_tree ctype
, const_tree decl
)
13429 int ctor_parm
= copy_fn_p (decl
);
13435 A declaration of a constructor for a class X is ill-formed if
13436 its first parameter is of type (optionally cv-qualified) X
13437 and either there are no other parameters or else all other
13438 parameters have default arguments.
13440 We *don't* complain about member template instantiations that
13441 have this form, though; they can occur as we try to decide
13442 what constructor to use during overload resolution. Since
13443 overload resolution will never prefer such a constructor to
13444 the non-template copy constructor (which is either explicitly
13445 or implicitly defined), there's no need to worry about their
13446 existence. Theoretically, they should never even be
13447 instantiated, but that's hard to forestall. */
13448 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
13456 /* DECL is a declaration for an overloaded or conversion operator. If
13457 COMPLAIN is true, errors are issued for invalid declarations. */
13460 grok_op_properties (tree decl
, bool complain
)
13462 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
13463 bool methodp
= TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
;
13464 tree name
= DECL_NAME (decl
);
13465 location_t loc
= DECL_SOURCE_LOCATION (decl
);
13467 tree class_type
= DECL_CONTEXT (decl
);
13468 if (class_type
&& !CLASS_TYPE_P (class_type
))
13469 class_type
= NULL_TREE
;
13471 tree_code operator_code
;
13473 if (IDENTIFIER_CONV_OP_P (name
))
13475 /* Conversion operators are TYPE_EXPR for the purposes of this
13477 operator_code
= TYPE_EXPR
;
13478 op_flags
= OVL_OP_FLAG_UNARY
;
13482 const ovl_op_info_t
*ovl_op
= IDENTIFIER_OVL_OP_INFO (name
);
13484 operator_code
= ovl_op
->tree_code
;
13485 op_flags
= ovl_op
->flags
;
13486 gcc_checking_assert (operator_code
!= ERROR_MARK
);
13487 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op
->ovl_op_code
;
13490 if (op_flags
& OVL_OP_FLAG_ALLOC
)
13492 /* operator new and operator delete are quite special. */
13496 case OVL_OP_FLAG_ALLOC
:
13497 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
13500 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_DELETE
:
13501 TYPE_GETS_DELETE (class_type
) |= 1;
13504 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_VEC
:
13505 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
13508 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_DELETE
| OVL_OP_FLAG_VEC
:
13509 TYPE_GETS_DELETE (class_type
) |= 2;
13513 gcc_unreachable ();
13516 /* [basic.std.dynamic.allocation]/1:
13518 A program is ill-formed if an allocation function is declared
13519 in a namespace scope other than global scope or declared
13520 static in global scope.
13522 The same also holds true for deallocation functions. */
13523 if (DECL_NAMESPACE_SCOPE_P (decl
))
13525 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
13527 error_at (loc
, "%qD may not be declared within a namespace",
13532 if (!TREE_PUBLIC (decl
))
13534 error_at (loc
, "%qD may not be declared as static", decl
);
13539 if (op_flags
& OVL_OP_FLAG_DELETE
)
13540 coerce_delete_type (decl
, loc
);
13543 DECL_IS_OPERATOR_NEW (decl
) = 1;
13544 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
), loc
);
13550 /* An operator function must either be a non-static member function
13551 or have at least one parameter of a class, a reference to a class,
13552 an enumeration, or a reference to an enumeration. 13.4.0.6 */
13553 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
13555 if (operator_code
== TYPE_EXPR
13556 || operator_code
== CALL_EXPR
13557 || operator_code
== COMPONENT_REF
13558 || operator_code
== ARRAY_REF
13559 || operator_code
== NOP_EXPR
)
13561 error_at (loc
, "%qD must be a nonstatic member function", decl
);
13565 if (DECL_STATIC_FUNCTION_P (decl
))
13567 error_at (loc
, "%qD must be either a non-static member "
13568 "function or a non-member function", decl
);
13572 for (tree arg
= argtypes
; ; arg
= TREE_CHAIN (arg
))
13574 if (!arg
|| arg
== void_list_node
)
13577 error_at(loc
, "%qD must have an argument of class or "
13578 "enumerated type", decl
);
13582 tree type
= non_reference (TREE_VALUE (arg
));
13583 if (type
== error_mark_node
)
13586 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
13587 because these checks are performed even on template
13589 if (MAYBE_CLASS_TYPE_P (type
)
13590 || TREE_CODE (type
) == ENUMERAL_TYPE
)
13595 if (operator_code
== CALL_EXPR
)
13596 /* There are no further restrictions on the arguments to an overloaded
13600 if (operator_code
== COND_EXPR
)
13603 error_at (loc
, "ISO C++ prohibits overloading operator ?:");
13607 /* Count the number of arguments and check for ellipsis. */
13609 for (tree arg
= argtypes
; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
13614 error_at (loc
, "%qD must not have variable number of arguments",
13621 /* Verify correct number of arguments. */
13624 case OVL_OP_FLAG_AMBIARY
:
13627 /* We have a unary instance of an ambi-ary op. Remap to the
13629 unsigned alt
= ovl_op_alternate
[ovl_op_mapping
[operator_code
]];
13630 const ovl_op_info_t
*ovl_op
= &ovl_op_info
[false][alt
];
13631 gcc_checking_assert (ovl_op
->flags
== OVL_OP_FLAG_UNARY
);
13632 operator_code
= ovl_op
->tree_code
;
13633 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op
->ovl_op_code
;
13635 else if (arity
!= 2)
13637 /* This was an ambiguous operator but is invalid. */
13640 ? G_("%qD must have either zero or one argument")
13641 : G_("%qD must have either one or two arguments"), decl
);
13644 else if ((operator_code
== POSTINCREMENT_EXPR
13645 || operator_code
== POSTDECREMENT_EXPR
)
13646 && ! processing_template_decl
13647 /* x++ and x--'s second argument must be an int. */
13648 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)),
13649 integer_type_node
))
13653 ? G_("postfix %qD must have %<int%> as its argument")
13654 : G_("postfix %qD must have %<int%> as its second argument"),
13660 case OVL_OP_FLAG_UNARY
:
13665 ? G_("%qD must have no arguments")
13666 : G_("%qD must have exactly one argument"), decl
);
13671 case OVL_OP_FLAG_BINARY
:
13676 ? G_("%qD must have exactly one argument")
13677 : G_("%qD must have exactly two arguments"), decl
);
13683 gcc_unreachable ();
13686 /* There can be no default arguments. */
13687 for (tree arg
= argtypes
; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
13688 if (TREE_PURPOSE (arg
))
13690 TREE_PURPOSE (arg
) = NULL_TREE
;
13691 error_at (loc
, "%qD cannot have default arguments", decl
);
13695 /* At this point the declaration is well-formed. It may not be
13696 sensible though. */
13698 /* Check member function warnings only on the in-class declaration.
13699 There's no point warning on an out-of-class definition. */
13700 if (class_type
&& class_type
!= current_class_type
)
13703 /* Warn about conversion operators that will never be used. */
13704 if (IDENTIFIER_CONV_OP_P (name
)
13705 && ! DECL_TEMPLATE_INFO (decl
)
13706 && warn_class_conversion
)
13708 tree t
= TREE_TYPE (name
);
13709 int ref
= TYPE_REF_P (t
);
13712 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
13714 if (VOID_TYPE_P (t
))
13715 warning_at (loc
, OPT_Wclass_conversion
, "converting %qT to %<void%> "
13716 "will never use a type conversion operator", class_type
);
13717 else if (class_type
)
13719 if (same_type_ignoring_top_level_qualifiers_p (t
, class_type
))
13720 warning_at (loc
, OPT_Wclass_conversion
,
13722 ? G_("converting %qT to a reference to the same type "
13723 "will never use a type conversion operator")
13724 : G_("converting %qT to the same type "
13725 "will never use a type conversion operator"),
13727 /* Don't force t to be complete here. */
13728 else if (MAYBE_CLASS_TYPE_P (t
)
13729 && COMPLETE_TYPE_P (t
)
13730 && DERIVED_FROM_P (t
, class_type
))
13731 warning_at (loc
, OPT_Wclass_conversion
,
13733 ? G_("converting %qT to a reference to a base class "
13734 "%qT will never use a type conversion operator")
13735 : G_("converting %qT to a base class %qT "
13736 "will never use a type conversion operator"),
13744 /* Effective C++ rules below. */
13746 /* More Effective C++ rule 7. */
13747 if (operator_code
== TRUTH_ANDIF_EXPR
13748 || operator_code
== TRUTH_ORIF_EXPR
13749 || operator_code
== COMPOUND_EXPR
)
13750 warning_at (loc
, OPT_Weffc__
,
13751 "user-defined %qD always evaluates both arguments", decl
);
13753 /* More Effective C++ rule 6. */
13754 if (operator_code
== POSTINCREMENT_EXPR
13755 || operator_code
== POSTDECREMENT_EXPR
13756 || operator_code
== PREINCREMENT_EXPR
13757 || operator_code
== PREDECREMENT_EXPR
)
13759 tree arg
= TREE_VALUE (argtypes
);
13760 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
13761 if (methodp
|| TYPE_REF_P (arg
))
13762 arg
= TREE_TYPE (arg
);
13763 arg
= TYPE_MAIN_VARIANT (arg
);
13765 if (operator_code
== PREINCREMENT_EXPR
13766 || operator_code
== PREDECREMENT_EXPR
)
13768 if (!TYPE_REF_P (ret
)
13769 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)), arg
))
13770 warning_at (loc
, OPT_Weffc__
, "prefix %qD should return %qT", decl
,
13771 build_reference_type (arg
));
13775 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
13776 warning_at (loc
, OPT_Weffc__
,
13777 "postfix %qD should return %qT", decl
, arg
);
13781 /* Effective C++ rule 23. */
13782 if (!DECL_ASSIGNMENT_OPERATOR_P (decl
)
13783 && (operator_code
== PLUS_EXPR
13784 || operator_code
== MINUS_EXPR
13785 || operator_code
== TRUNC_DIV_EXPR
13786 || operator_code
== MULT_EXPR
13787 || operator_code
== TRUNC_MOD_EXPR
)
13788 && TYPE_REF_P (TREE_TYPE (TREE_TYPE (decl
))))
13789 warning_at (loc
, OPT_Weffc__
, "%qD should return by value", decl
);
13794 /* Return a string giving the keyword associate with CODE. */
13796 static const char *
13797 tag_name (enum tag_types code
)
13809 case typename_type
:
13812 gcc_unreachable ();
13816 /* Name lookup in an elaborated-type-specifier (after the keyword
13817 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
13818 elaborated-type-specifier is invalid, issue a diagnostic and return
13819 error_mark_node; otherwise, return the *_TYPE to which it referred.
13820 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
13823 check_elaborated_type_specifier (enum tag_types tag_code
,
13825 bool allow_template_p
)
13831 struct S { struct S *p; };
13833 name lookup will find the TYPE_DECL for the implicit "S::S"
13834 typedef. Adjust for that here. */
13835 if (DECL_SELF_REFERENCE_P (decl
))
13836 decl
= TYPE_NAME (TREE_TYPE (decl
));
13838 type
= TREE_TYPE (decl
);
13840 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
13841 is false for this case as well. */
13842 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
13844 error ("using template type parameter %qT after %qs",
13845 type
, tag_name (tag_code
));
13846 return error_mark_node
;
13848 /* Accept template template parameters. */
13849 else if (allow_template_p
13850 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
13851 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
13855 If the identifier resolves to a typedef-name or the
13856 simple-template-id resolves to an alias template
13857 specialization, the elaborated-type-specifier is ill-formed.
13859 In other words, the only legitimate declaration to use in the
13860 elaborated type specifier is the implicit typedef created when
13861 the type is declared. */
13862 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
13863 && !DECL_SELF_REFERENCE_P (decl
)
13864 && tag_code
!= typename_type
)
13866 if (alias_template_specialization_p (type
))
13867 error ("using alias template specialization %qT after %qs",
13868 type
, tag_name (tag_code
));
13870 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
13871 inform (DECL_SOURCE_LOCATION (decl
),
13872 "%qD has a previous declaration here", decl
);
13873 return error_mark_node
;
13875 else if (TREE_CODE (type
) != RECORD_TYPE
13876 && TREE_CODE (type
) != UNION_TYPE
13877 && tag_code
!= enum_type
13878 && tag_code
!= typename_type
)
13880 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
13881 inform (location_of (type
), "%qT has a previous declaration here", type
);
13882 return error_mark_node
;
13884 else if (TREE_CODE (type
) != ENUMERAL_TYPE
13885 && tag_code
== enum_type
)
13887 error ("%qT referred to as enum", type
);
13888 inform (location_of (type
), "%qT has a previous declaration here", type
);
13889 return error_mark_node
;
13891 else if (!allow_template_p
13892 && TREE_CODE (type
) == RECORD_TYPE
13893 && CLASSTYPE_IS_TEMPLATE (type
))
13895 /* If a class template appears as elaborated type specifier
13896 without a template header such as:
13898 template <class T> class C {};
13899 void f(class C); // No template header here
13901 then the required template argument is missing. */
13902 error ("template argument required for %<%s %T%>",
13903 tag_name (tag_code
),
13904 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
13905 return error_mark_node
;
13911 /* Lookup NAME in elaborate type specifier in scope according to
13912 SCOPE and issue diagnostics if necessary.
13913 Return *_TYPE node upon success, NULL_TREE when the NAME is not
13914 found, and ERROR_MARK_NODE for type error. */
13917 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
13918 tag_scope scope
, bool template_header_p
)
13922 if (scope
== ts_global
)
13924 /* First try ordinary name lookup, ignoring hidden class name
13925 injected via friend declaration. */
13926 decl
= lookup_name_prefer_type (name
, 2);
13927 decl
= strip_using_decl (decl
);
13928 /* If that fails, the name will be placed in the smallest
13929 non-class, non-function-prototype scope according to 3.3.1/5.
13930 We may already have a hidden name declared as friend in this
13931 scope. So lookup again but not ignoring hidden names.
13932 If we find one, that name will be made visible rather than
13933 creating a new tag. */
13935 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
13938 decl
= lookup_type_scope (name
, scope
);
13941 && (DECL_CLASS_TEMPLATE_P (decl
)
13942 /* If scope is ts_current we're defining a class, so ignore a
13943 template template parameter. */
13944 || (scope
!= ts_current
13945 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
13946 decl
= DECL_TEMPLATE_RESULT (decl
);
13948 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
13950 /* Look for invalid nested type:
13954 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
13956 error ("%qD has the same name as the class in which it is "
13959 return error_mark_node
;
13962 /* Two cases we need to consider when deciding if a class
13963 template is allowed as an elaborated type specifier:
13964 1. It is a self reference to its own class.
13965 2. It comes with a template header.
13969 template <class T> class C {
13970 class C *c1; // DECL_SELF_REFERENCE_P is true
13973 template <class U> class C; // template_header_p is true
13974 template <class T> class C<T>::D {
13975 class C *c2; // DECL_SELF_REFERENCE_P is true
13978 t
= check_elaborated_type_specifier (tag_code
,
13981 | DECL_SELF_REFERENCE_P (decl
));
13982 if (template_header_p
&& t
&& CLASS_TYPE_P (t
)
13983 && (!CLASSTYPE_TEMPLATE_INFO (t
)
13984 || (!PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))))
13986 error ("%qT is not a template", t
);
13987 inform (location_of (t
), "previous declaration here");
13988 if (TYPE_CLASS_SCOPE_P (t
)
13989 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (t
)))
13990 inform (input_location
,
13991 "perhaps you want to explicitly add %<%T::%>",
13993 t
= error_mark_node
;
13998 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
14000 error ("reference to %qD is ambiguous", name
);
14001 print_candidates (decl
);
14002 return error_mark_node
;
14008 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
14009 Define the tag as a forward-reference if it is not defined.
14011 If a declaration is given, process it here, and report an error if
14012 multiple declarations are not identical.
14014 SCOPE is TS_CURRENT when this is also a definition. Only look in
14015 the current frame for the name (since C++ allows new names in any
14016 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
14017 declaration. Only look beginning from the current scope outward up
14018 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
14020 TEMPLATE_HEADER_P is true when this declaration is preceded by
14021 a set of template parameters. */
14024 xref_tag_1 (enum tag_types tag_code
, tree name
,
14025 tag_scope scope
, bool template_header_p
)
14027 enum tree_code code
;
14028 tree context
= NULL_TREE
;
14030 gcc_assert (identifier_p (name
));
14036 code
= RECORD_TYPE
;
14042 code
= ENUMERAL_TYPE
;
14045 gcc_unreachable ();
14048 /* In case of anonymous name, xref_tag is only called to
14049 make type node and push name. Name lookup is not required. */
14050 tree t
= NULL_TREE
;
14051 if (scope
!= ts_lambda
&& !anon_aggrname_p (name
))
14052 t
= lookup_and_check_tag (tag_code
, name
, scope
, template_header_p
);
14054 if (t
== error_mark_node
)
14055 return error_mark_node
;
14057 if (scope
!= ts_current
&& t
&& current_class_type
14058 && template_class_depth (current_class_type
)
14059 && template_header_p
)
14061 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
14064 /* Since SCOPE is not TS_CURRENT, we are not looking at a
14065 definition of this tag. Since, in addition, we are currently
14066 processing a (member) template declaration of a template
14067 class, we must be very careful; consider:
14069 template <class X> struct S1
14071 template <class U> struct S2
14073 template <class V> friend struct S1;
14076 Here, the S2::S1 declaration should not be confused with the
14077 outer declaration. In particular, the inner version should
14078 have a template parameter of level 2, not level 1.
14080 On the other hand, when presented with:
14082 template <class T> struct S1
14084 template <class U> struct S2 {};
14085 template <class U> friend struct S2;
14088 the friend must find S1::S2 eventually. We accomplish this
14089 by making sure that the new type we create to represent this
14090 declaration has the right TYPE_CONTEXT. */
14091 context
= TYPE_CONTEXT (t
);
14097 /* If no such tag is yet defined, create a forward-reference node
14098 and record it as the "definition".
14099 When a real declaration of this type is found,
14100 the forward-reference will be altered into a real type. */
14101 if (code
== ENUMERAL_TYPE
)
14103 error ("use of enum %q#D without previous declaration", name
);
14104 return error_mark_node
;
14108 t
= make_class_type (code
);
14109 TYPE_CONTEXT (t
) = context
;
14110 if (scope
== ts_lambda
)
14112 /* Mark it as a lambda type. */
14113 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
14114 /* And push it into current scope. */
14115 scope
= ts_current
;
14117 t
= pushtag (name
, t
, scope
);
14122 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
14124 /* Check that we aren't trying to overload a class with different
14126 tree constr
= NULL_TREE
;
14127 if (current_template_parms
)
14129 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
14130 constr
= build_constraints (reqs
, NULL_TREE
);
14132 if (!redeclare_class_template (t
, current_template_parms
, constr
))
14133 return error_mark_node
;
14135 else if (!processing_template_decl
14136 && CLASS_TYPE_P (t
)
14137 && CLASSTYPE_IS_TEMPLATE (t
))
14139 error ("redeclaration of %qT as a non-template", t
);
14140 inform (location_of (t
), "previous declaration %qD", t
);
14141 return error_mark_node
;
14144 if (scope
!= ts_within_enclosing_non_class
&& TYPE_HIDDEN_P (t
))
14146 /* This is no longer an invisible friend. Make it
14148 tree decl
= TYPE_NAME (t
);
14150 DECL_ANTICIPATED (decl
) = false;
14151 DECL_FRIEND_P (decl
) = false;
14153 if (TYPE_TEMPLATE_INFO (t
))
14155 tree tmpl
= TYPE_TI_TEMPLATE (t
);
14156 DECL_ANTICIPATED (tmpl
) = false;
14157 DECL_FRIEND_P (tmpl
) = false;
14165 /* Wrapper for xref_tag_1. */
14168 xref_tag (enum tag_types tag_code
, tree name
,
14169 tag_scope scope
, bool template_header_p
)
14173 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
14174 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
14175 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
14181 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
14183 enum tag_types tag_kind
;
14185 if (TREE_CODE (old
) == RECORD_TYPE
)
14186 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
14188 tag_kind
= union_type
;
14190 if (id
== NULL_TREE
)
14191 id
= TYPE_IDENTIFIER (old
);
14193 return xref_tag (tag_kind
, id
, scope
, false);
14196 /* Create the binfo hierarchy for REF with (possibly NULL) base list
14197 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
14198 access_* node, and the TREE_VALUE is the type of the base-class.
14199 Non-NULL TREE_TYPE indicates virtual inheritance. */
14202 xref_basetypes (tree ref
, tree base_list
)
14205 tree binfo
, base_binfo
;
14206 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
14207 unsigned max_bases
= 0; /* Maximum direct bases. */
14208 unsigned max_dvbases
= 0; /* Maximum direct virtual bases. */
14210 tree default_access
;
14211 tree igo_prev
; /* Track Inheritance Graph Order. */
14213 if (ref
== error_mark_node
)
14216 /* The base of a derived class is private by default, all others are
14218 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
14219 && CLASSTYPE_DECLARED_CLASS (ref
)
14220 ? access_private_node
: access_public_node
);
14222 /* First, make sure that any templates in base-classes are
14223 instantiated. This ensures that if we call ourselves recursively
14224 we do not get confused about which classes are marked and which
14226 basep
= &base_list
;
14229 tree basetype
= TREE_VALUE (*basep
);
14231 /* The dependent_type_p call below should really be dependent_scope_p
14232 so that we give a hard error about using an incomplete type as a
14233 base, but we allow it with a pedwarn for backward
14235 if (processing_template_decl
14236 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
14237 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
14238 if (!dependent_type_p (basetype
)
14239 && !complete_type_or_else (basetype
, NULL
))
14240 /* An incomplete type. Remove it from the list. */
14241 *basep
= TREE_CHAIN (*basep
);
14245 if (TREE_TYPE (*basep
))
14247 if (CLASS_TYPE_P (basetype
))
14248 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
14249 basep
= &TREE_CHAIN (*basep
);
14252 max_vbases
+= max_dvbases
;
14254 TYPE_MARKED_P (ref
) = 1;
14256 /* The binfo slot should be empty, unless this is an (ill-formed)
14258 gcc_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
));
14260 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
14262 binfo
= make_tree_binfo (max_bases
);
14264 TYPE_BINFO (ref
) = binfo
;
14265 BINFO_OFFSET (binfo
) = size_zero_node
;
14266 BINFO_TYPE (binfo
) = ref
;
14268 /* Apply base-class info set up to the variants of this type. */
14269 fixup_type_variants (ref
);
14273 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
14274 /* A C++98 POD cannot have base classes. */
14275 CLASSTYPE_NON_LAYOUT_POD_P (ref
) = true;
14277 if (TREE_CODE (ref
) == UNION_TYPE
)
14279 error ("derived union %qT invalid", ref
);
14285 warning (OPT_Wmultiple_inheritance
,
14286 "%qT defined with multiple direct bases", ref
);
14290 /* An aggregate can't have virtual base classes. */
14291 CLASSTYPE_NON_AGGREGATE (ref
) = true;
14293 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
14296 warning (OPT_Wvirtual_inheritance
,
14297 "%qT defined with direct virtual base", ref
);
14300 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
14302 tree access
= TREE_PURPOSE (base_list
);
14303 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
14304 tree basetype
= TREE_VALUE (base_list
);
14306 if (access
== access_default_node
)
14307 access
= default_access
;
14309 /* Before C++17, an aggregate cannot have base classes. In C++17, an
14310 aggregate can't have virtual, private, or protected base classes. */
14311 if (cxx_dialect
< cxx17
14312 || access
!= access_public_node
14314 CLASSTYPE_NON_AGGREGATE (ref
) = true;
14316 if (PACK_EXPANSION_P (basetype
))
14317 basetype
= PACK_EXPANSION_PATTERN (basetype
);
14318 if (TREE_CODE (basetype
) == TYPE_DECL
)
14319 basetype
= TREE_TYPE (basetype
);
14320 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
14322 error ("base type %qT fails to be a struct or class type",
14327 base_binfo
= NULL_TREE
;
14328 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
14330 base_binfo
= TYPE_BINFO (basetype
);
14331 /* The original basetype could have been a typedef'd type. */
14332 basetype
= BINFO_TYPE (base_binfo
);
14334 /* Inherit flags from the base. */
14335 TYPE_HAS_NEW_OPERATOR (ref
)
14336 |= TYPE_HAS_NEW_OPERATOR (basetype
);
14337 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
14338 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
14339 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
14340 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
14341 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
14342 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
14343 CLASSTYPE_REPEATED_BASE_P (ref
)
14344 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
14347 /* We must do this test after we've seen through a typedef
14349 if (TYPE_MARKED_P (basetype
))
14351 if (basetype
== ref
)
14352 error ("recursive type %qT undefined", basetype
);
14354 error ("duplicate base type %qT invalid", basetype
);
14358 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
14359 /* Regenerate the pack expansion for the bases. */
14360 basetype
= make_pack_expansion (basetype
);
14362 TYPE_MARKED_P (basetype
) = 1;
14364 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
14365 &igo_prev
, via_virtual
);
14366 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
14367 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
14369 BINFO_BASE_APPEND (binfo
, base_binfo
);
14370 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
14374 /* Update max_vbases to reflect the reality that we are dropping
14375 this base: if it reaches zero we want to undo the vec_alloc
14376 above to avoid inconsistencies during error-recovery: eg, in
14377 build_special_member_call, CLASSTYPE_VBASECLASSES non null
14378 and vtt null (c++/27952). */
14381 if (CLASS_TYPE_P (basetype
))
14383 -= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
14386 if (CLASSTYPE_VBASECLASSES (ref
)
14387 && max_vbases
== 0)
14388 vec_free (CLASSTYPE_VBASECLASSES (ref
));
14390 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
14391 /* If we didn't get max_vbases vbases, we must have shared at
14392 least one of them, and are therefore diamond shaped. */
14393 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
14395 /* Unmark all the types. */
14396 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
14397 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
14398 TYPE_MARKED_P (ref
) = 0;
14400 /* Now see if we have a repeated base type. */
14401 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
14403 for (base_binfo
= binfo
; base_binfo
;
14404 base_binfo
= TREE_CHAIN (base_binfo
))
14406 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
14408 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
14411 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
14413 for (base_binfo
= binfo
; base_binfo
;
14414 base_binfo
= TREE_CHAIN (base_binfo
))
14415 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
14416 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
14423 /* Copies the enum-related properties from type SRC to type DST.
14424 Used with the underlying type of an enum and the enum itself. */
14426 copy_type_enum (tree dst
, tree src
)
14429 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
14431 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
14432 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
14433 TYPE_SIZE (t
) = TYPE_SIZE (src
);
14434 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
14435 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
14436 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
14437 unsigned valign
= TYPE_ALIGN (src
);
14438 if (TYPE_USER_ALIGN (t
))
14439 valign
= MAX (valign
, TYPE_ALIGN (t
));
14441 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
14442 SET_TYPE_ALIGN (t
, valign
);
14443 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
14447 /* Begin compiling the definition of an enumeration type.
14450 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
14452 UNDERLYING_TYPE is the type that will be used as the storage for
14453 the enumeration type. This should be NULL_TREE if no storage type
14456 ATTRIBUTES are any attributes specified after the enum-key.
14458 SCOPED_ENUM_P is true if this is a scoped enumeration type.
14460 if IS_NEW is not NULL, gets TRUE iff a new type is created.
14462 Returns the type object, as yet incomplete.
14463 Also records info about it so that build_enumerator
14464 may be used to declare the individual values as they are read. */
14467 start_enum (tree name
, tree enumtype
, tree underlying_type
,
14468 tree attributes
, bool scoped_enum_p
, bool *is_new
)
14470 tree prevtype
= NULL_TREE
;
14471 gcc_assert (identifier_p (name
));
14475 /* [C++0x dcl.enum]p5:
14477 If not explicitly specified, the underlying type of a scoped
14478 enumeration type is int. */
14479 if (!underlying_type
&& scoped_enum_p
)
14480 underlying_type
= integer_type_node
;
14482 if (underlying_type
)
14483 underlying_type
= cv_unqualified (underlying_type
);
14485 /* If this is the real definition for a previous forward reference,
14486 fill in the contents in the same object that used to be the
14487 forward reference. */
14489 enumtype
= lookup_and_check_tag (enum_type
, name
,
14490 /*tag_scope=*/ts_current
,
14491 /*template_header_p=*/false);
14493 /* In case of a template_decl, the only check that should be deferred
14494 to instantiation time is the comparison of underlying types. */
14495 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
14497 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
14499 error_at (input_location
, "scoped/unscoped mismatch "
14500 "in enum %q#T", enumtype
);
14501 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
14502 "previous definition here");
14503 enumtype
= error_mark_node
;
14505 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
14507 error_at (input_location
, "underlying type mismatch "
14508 "in enum %q#T", enumtype
);
14509 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
14510 "previous definition here");
14511 enumtype
= error_mark_node
;
14513 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
14514 && !same_type_p (underlying_type
,
14515 ENUM_UNDERLYING_TYPE (enumtype
)))
14517 error_at (input_location
, "different underlying type "
14518 "in enum %q#T", enumtype
);
14519 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
14520 "previous definition here");
14521 underlying_type
= NULL_TREE
;
14525 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
14526 || processing_template_decl
)
14528 /* In case of error, make a dummy enum to allow parsing to
14530 if (enumtype
== error_mark_node
)
14532 name
= make_anon_name ();
14533 enumtype
= NULL_TREE
;
14536 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
14537 of an opaque enum, or an opaque enum of an already defined
14538 enumeration (C++11).
14539 In any other case, it'll be NULL_TREE. */
14545 prevtype
= enumtype
;
14547 /* Do not push the decl more than once. */
14549 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
14551 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
14552 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
14554 /* std::byte aliases anything. */
14555 if (enumtype
!= error_mark_node
14556 && TYPE_CONTEXT (enumtype
) == std_node
14557 && !strcmp ("byte", TYPE_NAME_STRING (enumtype
)))
14558 TYPE_ALIAS_SET (enumtype
) = 0;
14561 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
14564 if (enumtype
== error_mark_node
)
14565 return error_mark_node
;
14567 /* The enum is considered opaque until the opening '{' of the
14568 enumerator list. */
14569 SET_OPAQUE_ENUM_P (enumtype
, true);
14570 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
14573 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
14575 cplus_decl_attributes (&enumtype
, attributes
, (int)ATTR_FLAG_TYPE_IN_PLACE
);
14577 if (underlying_type
)
14579 if (ENUM_UNDERLYING_TYPE (enumtype
))
14580 /* We already checked that it matches, don't change it to a different
14581 typedef variant. */;
14582 else if (CP_INTEGRAL_TYPE_P (underlying_type
))
14584 copy_type_enum (enumtype
, underlying_type
);
14585 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
14587 else if (dependent_type_p (underlying_type
))
14588 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
14590 error ("underlying type %qT of %qT must be an integral type",
14591 underlying_type
, enumtype
);
14594 /* If into a template class, the returned enum is always the first
14595 declaration (opaque or not) seen. This way all the references to
14596 this type will be to the same declaration. The following ones are used
14597 only to check for definition errors. */
14598 if (prevtype
&& processing_template_decl
)
14604 /* After processing and defining all the values of an enumeration type,
14605 install their decls in the enumeration type.
14606 ENUMTYPE is the type object. */
14609 finish_enum_value_list (tree enumtype
)
14612 tree underlying_type
;
14615 tree minnode
, maxnode
;
14618 bool fixed_underlying_type_p
14619 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
14621 /* We built up the VALUES in reverse order. */
14622 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
14624 /* For an enum defined in a template, just set the type of the values;
14625 all further processing is postponed until the template is
14626 instantiated. We need to set the type so that tsubst of a CONST_DECL
14628 if (processing_template_decl
)
14630 for (values
= TYPE_VALUES (enumtype
);
14632 values
= TREE_CHAIN (values
))
14633 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
14637 /* Determine the minimum and maximum values of the enumerators. */
14638 if (TYPE_VALUES (enumtype
))
14640 minnode
= maxnode
= NULL_TREE
;
14642 for (values
= TYPE_VALUES (enumtype
);
14644 values
= TREE_CHAIN (values
))
14646 decl
= TREE_VALUE (values
);
14648 /* [dcl.enum]: Following the closing brace of an enum-specifier,
14649 each enumerator has the type of its enumeration. Prior to the
14650 closing brace, the type of each enumerator is the type of its
14651 initializing value. */
14652 TREE_TYPE (decl
) = enumtype
;
14654 /* Update the minimum and maximum values, if appropriate. */
14655 value
= DECL_INITIAL (decl
);
14656 if (value
== error_mark_node
)
14657 value
= integer_zero_node
;
14658 /* Figure out what the minimum and maximum values of the
14659 enumerators are. */
14661 minnode
= maxnode
= value
;
14662 else if (tree_int_cst_lt (maxnode
, value
))
14664 else if (tree_int_cst_lt (value
, minnode
))
14671 If the enumerator-list is empty, the underlying type is as if
14672 the enumeration had a single enumerator with value 0. */
14673 minnode
= maxnode
= integer_zero_node
;
14675 if (!fixed_underlying_type_p
)
14677 /* Compute the number of bits require to represent all values of the
14678 enumeration. We must do this before the type of MINNODE and
14679 MAXNODE are transformed, since tree_int_cst_min_precision relies
14680 on the TREE_TYPE of the value it is passed. */
14681 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
14682 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
14683 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
14684 int precision
= MAX (lowprec
, highprec
);
14686 bool use_short_enum
;
14688 /* Determine the underlying type of the enumeration.
14692 The underlying type of an enumeration is an integral type that
14693 can represent all the enumerator values defined in the
14694 enumeration. It is implementation-defined which integral type is
14695 used as the underlying type for an enumeration except that the
14696 underlying type shall not be larger than int unless the value of
14697 an enumerator cannot fit in an int or unsigned int.
14699 We use "int" or an "unsigned int" as the underlying type, even if
14700 a smaller integral type would work, unless the user has
14701 explicitly requested that we use the smallest possible type. The
14702 user can request that for all enumerations with a command line
14703 flag, or for just one enumeration with an attribute. */
14705 use_short_enum
= flag_short_enums
14706 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
14708 /* If the precision of the type was specified with an attribute and it
14709 was too small, give an error. Otherwise, use it. */
14710 if (TYPE_PRECISION (enumtype
))
14712 if (precision
> TYPE_PRECISION (enumtype
))
14713 error ("specified mode too small for enumeral values");
14716 use_short_enum
= true;
14717 precision
= TYPE_PRECISION (enumtype
);
14721 for (itk
= (use_short_enum
? itk_char
: itk_int
);
14725 underlying_type
= integer_types
[itk
];
14726 if (underlying_type
!= NULL_TREE
14727 && TYPE_PRECISION (underlying_type
) >= precision
14728 && TYPE_SIGN (underlying_type
) == sgn
)
14731 if (itk
== itk_none
)
14735 IF no integral type can represent all the enumerator values, the
14736 enumeration is ill-formed. */
14737 error ("no integral type can represent all of the enumerator values "
14738 "for %qT", enumtype
);
14739 precision
= TYPE_PRECISION (long_long_integer_type_node
);
14740 underlying_type
= integer_types
[itk_unsigned_long_long
];
14745 The value of sizeof() applied to an enumeration type, an object
14746 of an enumeration type, or an enumerator, is the value of sizeof()
14747 applied to the underlying type. */
14748 copy_type_enum (enumtype
, underlying_type
);
14750 /* Compute the minimum and maximum values for the type.
14754 For an enumeration where emin is the smallest enumerator and emax
14755 is the largest, the values of the enumeration are the values of the
14756 underlying type in the range bmin to bmax, where bmin and bmax are,
14757 respectively, the smallest and largest values of the smallest bit-
14758 field that can store emin and emax. */
14760 /* The middle-end currently assumes that types with TYPE_PRECISION
14761 narrower than their underlying type are suitably zero or sign
14762 extended to fill their mode. Similarly, it assumes that the front
14763 end assures that a value of a particular type must be within
14764 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
14766 We used to set these fields based on bmin and bmax, but that led
14767 to invalid assumptions like optimizing away bounds checking. So
14768 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
14769 TYPE_MAX_VALUE to the values for the mode above and only restrict
14770 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
14771 ENUM_UNDERLYING_TYPE (enumtype
)
14772 = build_distinct_type_copy (underlying_type
);
14773 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
14774 set_min_and_max_values_for_integral_type
14775 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
14777 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
14778 if (flag_strict_enums
)
14779 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
14782 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
14784 /* Convert each of the enumerators to the type of the underlying
14785 type of the enumeration. */
14786 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
14788 location_t saved_location
;
14790 decl
= TREE_VALUE (values
);
14791 saved_location
= input_location
;
14792 input_location
= DECL_SOURCE_LOCATION (decl
);
14793 if (fixed_underlying_type_p
)
14794 /* If the enumeration type has a fixed underlying type, we
14795 already checked all of the enumerator values. */
14796 value
= DECL_INITIAL (decl
);
14798 value
= perform_implicit_conversion (underlying_type
,
14799 DECL_INITIAL (decl
),
14800 tf_warning_or_error
);
14801 input_location
= saved_location
;
14803 /* Do not clobber shared ints. */
14804 if (value
!= error_mark_node
)
14806 value
= copy_node (value
);
14808 TREE_TYPE (value
) = enumtype
;
14810 DECL_INITIAL (decl
) = value
;
14813 /* Fix up all variant types of this enum type. */
14814 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
14815 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
14817 if (at_class_scope_p ()
14818 && COMPLETE_TYPE_P (current_class_type
)
14819 && UNSCOPED_ENUM_P (enumtype
))
14821 insert_late_enum_def_bindings (current_class_type
, enumtype
);
14822 /* TYPE_FIELDS needs fixup. */
14823 fixup_type_variants (current_class_type
);
14826 /* Finish debugging output for this type. */
14827 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
14829 /* Each enumerator now has the type of its enumeration. Clear the cache
14830 so that this change in types doesn't confuse us later on. */
14831 clear_cv_and_fold_caches ();
14834 /* Finishes the enum type. This is called only the first time an
14835 enumeration is seen, be it opaque or odinary.
14836 ENUMTYPE is the type object. */
14839 finish_enum (tree enumtype
)
14841 if (processing_template_decl
)
14843 if (at_function_scope_p ())
14844 add_stmt (build_min (TAG_DEFN
, enumtype
));
14848 /* If this is a forward declaration, there should not be any variants,
14849 though we can get a variant in the middle of an enum-specifier with
14850 wacky code like 'enum E { e = sizeof(const E*) };' */
14851 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
14852 && (TYPE_VALUES (enumtype
)
14853 || !TYPE_NEXT_VARIANT (enumtype
)));
14856 /* Build and install a CONST_DECL for an enumeration constant of the
14857 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
14858 Apply ATTRIBUTES if available. LOC is the location of NAME.
14859 Assignment of sequential values by default is handled here. */
14862 build_enumerator (tree name
, tree value
, tree enumtype
, tree attributes
,
14869 /* scalar_constant_value will pull out this expression, so make sure
14870 it's folded as appropriate. */
14871 if (processing_template_decl
)
14872 value
= fold_non_dependent_expr (value
);
14874 /* If the VALUE was erroneous, pretend it wasn't there; that will
14875 result in the enum being assigned the next value in sequence. */
14876 if (value
== error_mark_node
)
14879 /* Remove no-op casts from the value. */
14881 STRIP_TYPE_NOPS (value
);
14883 if (! processing_template_decl
)
14885 /* Validate and default VALUE. */
14886 if (value
!= NULL_TREE
)
14888 if (!ENUM_UNDERLYING_TYPE (enumtype
))
14890 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
14895 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14896 (TREE_TYPE (value
)))
14897 value
= perform_implicit_conversion_flags
14898 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
14899 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
14901 if (value
== error_mark_node
)
14904 if (value
!= NULL_TREE
)
14906 if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14907 (TREE_TYPE (value
)))
14909 error ("enumerator value for %qD must have integral or "
14910 "unscoped enumeration type", name
);
14915 value
= cxx_constant_value (value
);
14917 if (TREE_CODE (value
) != INTEGER_CST
)
14919 error ("enumerator value for %qD is not an integer "
14927 /* Default based on previous value. */
14928 if (value
== NULL_TREE
)
14930 if (TYPE_VALUES (enumtype
))
14934 /* C++03 7.2/4: If no initializer is specified for the first
14935 enumerator, the type is an unspecified integral
14936 type. Otherwise the type is the same as the type of the
14937 initializing value of the preceding enumerator unless the
14938 incremented value is not representable in that type, in
14939 which case the type is an unspecified integral type
14940 sufficient to contain the incremented value. */
14941 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
14942 if (error_operand_p (prev_value
))
14943 value
= error_mark_node
;
14946 wi::overflow_type overflowed
;
14947 tree type
= TREE_TYPE (prev_value
);
14948 signop sgn
= TYPE_SIGN (type
);
14949 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
14953 bool pos
= !wi::neg_p (wi
, sgn
);
14954 if (!wi::fits_to_tree_p (wi
, type
))
14957 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
14959 type
= integer_types
[itk
];
14960 if (type
!= NULL_TREE
14961 && (pos
|| !TYPE_UNSIGNED (type
))
14962 && wi::fits_to_tree_p (wi
, type
))
14965 if (type
&& cxx_dialect
< cxx11
14966 && itk
> itk_unsigned_long
)
14967 pedwarn (input_location
, OPT_Wlong_long
,
14969 incremented enumerator value is too large for %<unsigned long%>") : G_("\
14970 incremented enumerator value is too large for %<long%>"));
14972 if (type
== NULL_TREE
)
14973 overflowed
= wi::OVF_UNKNOWN
;
14975 value
= wide_int_to_tree (type
, wi
);
14980 error ("overflow in enumeration values at %qD", name
);
14981 value
= error_mark_node
;
14986 value
= integer_zero_node
;
14989 /* Remove no-op casts from the value. */
14990 STRIP_TYPE_NOPS (value
);
14992 /* If the underlying type of the enum is fixed, check whether
14993 the enumerator values fits in the underlying type. If it
14994 does not fit, the program is ill-formed [C++0x dcl.enum]. */
14995 if (ENUM_UNDERLYING_TYPE (enumtype
)
14997 && TREE_CODE (value
) == INTEGER_CST
)
14999 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
15000 error ("enumerator value %qE is outside the range of underlying "
15001 "type %qT", value
, ENUM_UNDERLYING_TYPE (enumtype
));
15003 /* Convert the value to the appropriate type. */
15004 value
= fold_convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
15008 /* C++ associates enums with global, function, or class declarations. */
15009 context
= current_scope ();
15011 /* Build the actual enumeration constant. Note that the enumeration
15012 constants have the underlying type of the enum (if it is fixed)
15013 or the type of their initializer (if the underlying type of the
15014 enum is not fixed):
15018 If the underlying type is fixed, the type of each enumerator
15019 prior to the closing brace is the underlying type; if the
15020 initializing value of an enumerator cannot be represented by
15021 the underlying type, the program is ill-formed. If the
15022 underlying type is not fixed, the type of each enumerator is
15023 the type of its initializing value.
15025 If the underlying type is not fixed, it will be computed by
15026 finish_enum and we will reset the type of this enumerator. Of
15027 course, if we're processing a template, there may be no value. */
15028 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
15030 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
15032 DECL_CONTEXT (decl
) = enumtype
;
15033 TREE_CONSTANT (decl
) = 1;
15034 TREE_READONLY (decl
) = 1;
15035 DECL_INITIAL (decl
) = value
;
15038 cplus_decl_attributes (&decl
, attributes
, 0);
15040 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
15042 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
15043 on the TYPE_FIELDS list for `S'. (That's so that you can say
15044 things like `S::i' later.) */
15046 /* The enumerator may be getting declared outside of its enclosing
15049 class S { public: enum E : int; }; enum S::E : int { i = 7; };
15051 For which case we need to make sure that the access of `S::i'
15052 matches the access of `S::E'. */
15053 tree saved_cas
= current_access_specifier
;
15054 if (TREE_PRIVATE (TYPE_NAME (enumtype
)))
15055 current_access_specifier
= access_private_node
;
15056 else if (TREE_PROTECTED (TYPE_NAME (enumtype
)))
15057 current_access_specifier
= access_protected_node
;
15059 current_access_specifier
= access_public_node
;
15061 finish_member_declaration (decl
);
15063 current_access_specifier
= saved_cas
;
15068 /* Add this enumeration constant to the list for this type. */
15069 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
15072 /* Look for an enumerator with the given NAME within the enumeration
15073 type ENUMTYPE. This routine is used primarily for qualified name
15074 lookup into an enumerator in C++0x, e.g.,
15076 enum class Color { Red, Green, Blue };
15078 Color color = Color::Red;
15080 Returns the value corresponding to the enumerator, or
15081 NULL_TREE if no such enumerator was found. */
15083 lookup_enumerator (tree enumtype
, tree name
)
15086 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
15088 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
15089 return e
? TREE_VALUE (e
) : NULL_TREE
;
15093 /* We're defining DECL. Make sure that its type is OK. */
15096 check_function_type (tree decl
, tree current_function_parms
)
15098 tree fntype
= TREE_TYPE (decl
);
15099 tree return_type
= complete_type (TREE_TYPE (fntype
));
15101 /* In a function definition, arg types must be complete. */
15102 require_complete_types_for_parms (current_function_parms
);
15104 if (dependent_type_p (return_type
)
15105 || type_uses_auto (return_type
))
15107 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
15109 tree args
= TYPE_ARG_TYPES (fntype
);
15111 error ("return type %q#T is incomplete", return_type
);
15113 /* Make it return void instead. */
15114 if (TREE_CODE (fntype
) == METHOD_TYPE
)
15115 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
15117 TREE_CHAIN (args
));
15119 fntype
= build_function_type (void_type_node
, args
);
15120 fntype
= (cp_build_type_attribute_variant
15121 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
15122 fntype
= cxx_copy_lang_qualifiers (fntype
, TREE_TYPE (decl
));
15123 TREE_TYPE (decl
) = fntype
;
15127 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
15128 maybe_warn_parm_abi (TREE_TYPE (fntype
),
15129 DECL_SOURCE_LOCATION (decl
));
15133 /* True iff FN is an implicitly-defined default constructor. */
15136 implicit_default_ctor_p (tree fn
)
15138 return (DECL_CONSTRUCTOR_P (fn
)
15139 && !user_provided_p (fn
)
15140 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)));
15143 /* Clobber the contents of *this to let the back end know that the object
15144 storage is dead when we enter the constructor or leave the destructor. */
15147 build_clobber_this ()
15149 /* Clobbering an empty base is pointless, and harmful if its one byte
15150 TYPE_SIZE overlays real data. */
15151 if (is_empty_class (current_class_type
))
15154 /* If we have virtual bases, clobber the whole object, but only if we're in
15155 charge. If we don't have virtual bases, clobber the as-base type so we
15156 don't mess with tail padding. */
15157 bool vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
15159 tree ctype
= current_class_type
;
15161 ctype
= CLASSTYPE_AS_BASE (ctype
);
15163 tree clobber
= build_clobber (ctype
);
15165 tree thisref
= current_class_ref
;
15166 if (ctype
!= current_class_type
)
15168 thisref
= build_nop (build_reference_type (ctype
), current_class_ptr
);
15169 thisref
= convert_from_reference (thisref
);
15172 tree exprstmt
= build2 (MODIFY_EXPR
, void_type_node
, thisref
, clobber
);
15174 exprstmt
= build_if_in_charge (exprstmt
);
15179 /* Create the FUNCTION_DECL for a function definition.
15180 DECLSPECS and DECLARATOR are the parts of the declaration;
15181 they describe the function's name and the type it returns,
15182 but twisted together in a fashion that parallels the syntax of C.
15184 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
15185 DECLARATOR is really the DECL for the function we are about to
15186 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
15187 indicating that the function is an inline defined in-class.
15189 This function creates a binding context for the function body
15190 as well as setting up the FUNCTION_DECL in current_function_decl.
15192 For C++, we must first check whether that datum makes any sense.
15193 For example, "class A local_a(1,2);" means that variable local_a
15194 is an aggregate of type A, which should have a constructor
15195 applied to it with the argument list [1, 2].
15197 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
15198 or may be a BLOCK if the function has been defined previously
15199 in this translation unit. On exit, DECL_INITIAL (decl1) will be
15200 error_mark_node if the function has never been defined, or
15201 a BLOCK if the function has been defined somewhere. */
15204 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
15206 tree ctype
= NULL_TREE
;
15209 int doing_friend
= 0;
15210 cp_binding_level
*bl
;
15211 tree current_function_parms
;
15212 struct c_fileinfo
*finfo
15213 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
15214 bool honor_interface
;
15216 /* Sanity check. */
15217 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
15218 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
15220 fntype
= TREE_TYPE (decl1
);
15221 if (TREE_CODE (fntype
) == METHOD_TYPE
)
15222 ctype
= TYPE_METHOD_BASETYPE (fntype
);
15224 /* ISO C++ 11.4/5. A friend function defined in a class is in
15225 the (lexical) scope of the class in which it is defined. */
15226 if (!ctype
&& DECL_FRIEND_P (decl1
))
15228 ctype
= DECL_FRIEND_CONTEXT (decl1
);
15230 /* CTYPE could be null here if we're dealing with a template;
15231 for example, `inline friend float foo()' inside a template
15232 will have no CTYPE set. */
15233 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
15239 if (DECL_DECLARED_INLINE_P (decl1
)
15240 && lookup_attribute ("noinline", attrs
))
15241 warning_at (DECL_SOURCE_LOCATION (decl1
), 0,
15242 "inline function %qD given attribute noinline", decl1
);
15244 /* Handle gnu_inline attribute. */
15245 if (GNU_INLINE_P (decl1
))
15247 DECL_EXTERNAL (decl1
) = 1;
15248 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
15249 DECL_INTERFACE_KNOWN (decl1
) = 1;
15250 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
15253 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
15254 /* This is a constructor, we must ensure that any default args
15255 introduced by this definition are propagated to the clones
15256 now. The clones are used directly in overload resolution. */
15257 adjust_clone_args (decl1
);
15259 /* Sometimes we don't notice that a function is a static member, and
15260 build a METHOD_TYPE for it. Fix that up now. */
15261 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
15262 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
15264 /* Set up current_class_type, and enter the scope of the class, if
15267 push_nested_class (ctype
);
15268 else if (DECL_STATIC_FUNCTION_P (decl1
))
15269 push_nested_class (DECL_CONTEXT (decl1
));
15271 /* Now that we have entered the scope of the class, we must restore
15272 the bindings for any template parameters surrounding DECL1, if it
15273 is an inline member template. (Order is important; consider the
15274 case where a template parameter has the same name as a field of
15275 the class.) It is not until after this point that
15276 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
15277 if (flags
& SF_INCLASS_INLINE
)
15278 maybe_begin_member_template_processing (decl1
);
15280 /* Effective C++ rule 15. */
15282 && DECL_ASSIGNMENT_OPERATOR_P (decl1
)
15283 && DECL_OVERLOADED_OPERATOR_IS (decl1
, NOP_EXPR
)
15284 && VOID_TYPE_P (TREE_TYPE (fntype
)))
15285 warning (OPT_Weffc__
,
15286 "%<operator=%> should return a reference to %<*this%>");
15288 /* Make the init_value nonzero so pushdecl knows this is not tentative.
15289 error_mark_node is replaced below (in poplevel) with the BLOCK. */
15290 if (!DECL_INITIAL (decl1
))
15291 DECL_INITIAL (decl1
) = error_mark_node
;
15293 /* This function exists in static storage.
15294 (This does not mean `static' in the C sense!) */
15295 TREE_STATIC (decl1
) = 1;
15297 /* We must call push_template_decl after current_class_type is set
15298 up. (If we are processing inline definitions after exiting a
15299 class scope, current_class_type will be NULL_TREE until set above
15300 by push_nested_class.) */
15301 if (processing_template_decl
)
15303 tree newdecl1
= push_template_decl (decl1
);
15304 if (newdecl1
== error_mark_node
)
15306 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
15307 pop_nested_class ();
15313 /* Make sure the parameter and return types are reasonable. When
15314 you declare a function, these types can be incomplete, but they
15315 must be complete when you define the function. */
15316 check_function_type (decl1
, DECL_ARGUMENTS (decl1
));
15318 /* Build the return declaration for the function. */
15319 restype
= TREE_TYPE (fntype
);
15321 if (DECL_RESULT (decl1
) == NULL_TREE
)
15325 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
15326 DECL_ARTIFICIAL (resdecl
) = 1;
15327 DECL_IGNORED_P (resdecl
) = 1;
15328 DECL_RESULT (decl1
) = resdecl
;
15330 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
15333 /* Record the decl so that the function name is defined.
15334 If we already have a decl for this name, and it is a FUNCTION_DECL,
15335 use the old decl. */
15336 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
15338 /* A specialization is not used to guide overload resolution. */
15339 if (!DECL_FUNCTION_MEMBER_P (decl1
)
15340 && !(DECL_USE_TEMPLATE (decl1
) &&
15341 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
15343 tree olddecl
= pushdecl (decl1
);
15345 if (olddecl
== error_mark_node
)
15346 /* If something went wrong when registering the declaration,
15347 use DECL1; we have to have a FUNCTION_DECL to use when
15348 parsing the body of the function. */
15352 /* Otherwise, OLDDECL is either a previous declaration
15353 of the same function or DECL1 itself. */
15355 if (warn_missing_declarations
15356 && olddecl
== decl1
15357 && !DECL_MAIN_P (decl1
)
15358 && TREE_PUBLIC (decl1
)
15359 && !DECL_DECLARED_INLINE_P (decl1
))
15363 /* Check whether DECL1 is in an anonymous
15365 for (context
= DECL_CONTEXT (decl1
);
15367 context
= DECL_CONTEXT (context
))
15369 if (TREE_CODE (context
) == NAMESPACE_DECL
15370 && DECL_NAME (context
) == NULL_TREE
)
15374 if (context
== NULL
)
15375 warning_at (DECL_SOURCE_LOCATION (decl1
),
15376 OPT_Wmissing_declarations
,
15377 "no previous declaration for %qD", decl1
);
15385 /* We need to set the DECL_CONTEXT. */
15386 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
15387 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
15389 fntype
= TREE_TYPE (decl1
);
15390 restype
= TREE_TYPE (fntype
);
15392 /* If #pragma weak applies, mark the decl appropriately now.
15393 The pragma only applies to global functions. Because
15394 determining whether or not the #pragma applies involves
15395 computing the mangled name for the declaration, we cannot
15396 apply the pragma until after we have merged this declaration
15397 with any previous declarations; if the original declaration
15398 has a linkage specification, that specification applies to
15399 the definition as well, and may affect the mangled name. */
15400 if (DECL_FILE_SCOPE_P (decl1
))
15401 maybe_apply_pragma_weak (decl1
);
15404 /* We are now in the scope of the function being defined. */
15405 current_function_decl
= decl1
;
15407 /* Save the parm names or decls from this function's declarator
15408 where store_parm_decls will find them. */
15409 current_function_parms
= DECL_ARGUMENTS (decl1
);
15411 /* Let the user know we're compiling this function. */
15412 announce_function (decl1
);
15414 gcc_assert (DECL_INITIAL (decl1
));
15416 /* This function may already have been parsed, in which case just
15417 return; our caller will skip over the body without parsing. */
15418 if (DECL_INITIAL (decl1
) != error_mark_node
)
15421 /* Initialize RTL machinery. We cannot do this until
15422 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
15423 even when processing a template; this is how we get
15424 CFUN set up, and our per-function variables initialized.
15425 FIXME factor out the non-RTL stuff. */
15426 bl
= current_binding_level
;
15427 allocate_struct_function (decl1
, processing_template_decl
);
15429 /* Initialize the language data structures. Whenever we start
15430 a new function, we destroy temporaries in the usual way. */
15431 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
15432 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
15433 current_binding_level
= bl
;
15435 if (!processing_template_decl
&& type_uses_auto (restype
))
15437 FNDECL_USED_AUTO (decl1
) = true;
15438 current_function_auto_return_pattern
= restype
;
15441 /* Start the statement-tree, start the tree now. */
15442 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
15444 /* If we are (erroneously) defining a function that we have already
15445 defined before, wipe out what we knew before. */
15446 if (!DECL_PENDING_INLINE_P (decl1
))
15447 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
15449 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
15451 /* We know that this was set up by `grokclassfn'. We do not
15452 wait until `store_parm_decls', since evil parse errors may
15453 never get us to that point. Here we keep the consistency
15454 between `current_class_type' and `current_class_ptr'. */
15455 tree t
= DECL_ARGUMENTS (decl1
);
15457 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
15458 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
15460 cp_function_chain
->x_current_class_ref
15461 = cp_build_fold_indirect_ref (t
);
15462 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
15463 cp_function_chain
->x_current_class_ptr
= t
;
15465 /* Constructors and destructors need to know whether they're "in
15466 charge" of initializing virtual base classes. */
15467 t
= DECL_CHAIN (t
);
15468 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
15470 current_in_charge_parm
= t
;
15471 t
= DECL_CHAIN (t
);
15473 if (DECL_HAS_VTT_PARM_P (decl1
))
15475 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
15476 current_vtt_parm
= t
;
15480 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
15481 /* Implicitly-defined methods (like the
15482 destructor for a class in which no destructor
15483 is explicitly declared) must not be defined
15484 until their definition is needed. So, we
15485 ignore interface specifications for
15486 compiler-generated functions. */
15487 && !DECL_ARTIFICIAL (decl1
));
15489 if (processing_template_decl
)
15490 /* Don't mess with interface flags. */;
15491 else if (DECL_INTERFACE_KNOWN (decl1
))
15493 tree ctx
= decl_function_context (decl1
);
15495 if (DECL_NOT_REALLY_EXTERN (decl1
))
15496 DECL_EXTERNAL (decl1
) = 0;
15498 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
15499 /* This is a function in a local class in an extern inline
15500 or template function. */
15501 comdat_linkage (decl1
);
15503 /* If this function belongs to an interface, it is public.
15504 If it belongs to someone else's interface, it is also external.
15505 This only affects inlines and template instantiations. */
15506 else if (!finfo
->interface_unknown
&& honor_interface
)
15508 if (DECL_DECLARED_INLINE_P (decl1
)
15509 || DECL_TEMPLATE_INSTANTIATION (decl1
))
15511 DECL_EXTERNAL (decl1
)
15512 = (finfo
->interface_only
15513 || (DECL_DECLARED_INLINE_P (decl1
)
15514 && ! flag_implement_inlines
15515 && !DECL_VINDEX (decl1
)));
15517 /* For WIN32 we also want to put these in linkonce sections. */
15518 maybe_make_one_only (decl1
);
15521 DECL_EXTERNAL (decl1
) = 0;
15522 DECL_INTERFACE_KNOWN (decl1
) = 1;
15523 /* If this function is in an interface implemented in this file,
15524 make sure that the back end knows to emit this function
15526 if (!DECL_EXTERNAL (decl1
))
15527 mark_needed (decl1
);
15529 else if (finfo
->interface_unknown
&& finfo
->interface_only
15530 && honor_interface
)
15532 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
15533 interface, we will have both finfo->interface_unknown and
15534 finfo->interface_only set. In that case, we don't want to
15535 use the normal heuristics because someone will supply a
15536 #pragma implementation elsewhere, and deducing it here would
15537 produce a conflict. */
15538 comdat_linkage (decl1
);
15539 DECL_EXTERNAL (decl1
) = 0;
15540 DECL_INTERFACE_KNOWN (decl1
) = 1;
15541 DECL_DEFER_OUTPUT (decl1
) = 1;
15545 /* This is a definition, not a reference.
15546 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
15547 if (!GNU_INLINE_P (decl1
))
15548 DECL_EXTERNAL (decl1
) = 0;
15550 if ((DECL_DECLARED_INLINE_P (decl1
)
15551 || DECL_TEMPLATE_INSTANTIATION (decl1
))
15552 && ! DECL_INTERFACE_KNOWN (decl1
))
15553 DECL_DEFER_OUTPUT (decl1
) = 1;
15555 DECL_INTERFACE_KNOWN (decl1
) = 1;
15558 /* Determine the ELF visibility attribute for the function. We must not
15559 do this before calling "pushdecl", as we must allow "duplicate_decls"
15560 to merge any attributes appropriately. We also need to wait until
15562 if (!DECL_CLONED_FUNCTION_P (decl1
))
15563 determine_visibility (decl1
);
15565 if (!processing_template_decl
)
15566 maybe_instantiate_noexcept (decl1
);
15568 begin_scope (sk_function_parms
, decl1
);
15572 if (DECL_DESTRUCTOR_P (decl1
)
15573 || (DECL_CONSTRUCTOR_P (decl1
)
15574 && targetm
.cxx
.cdtor_returns_this ()))
15576 cdtor_label
= create_artificial_label (input_location
);
15577 LABEL_DECL_CDTOR (cdtor_label
) = true;
15580 start_fname_decls ();
15582 store_parm_decls (current_function_parms
);
15584 push_operator_bindings ();
15586 if (!processing_template_decl
15587 && (flag_lifetime_dse
> 1)
15588 && DECL_CONSTRUCTOR_P (decl1
)
15589 && !DECL_CLONED_FUNCTION_P (decl1
)
15590 /* Clobbering an empty base is harmful if it overlays real data. */
15591 && !is_empty_class (current_class_type
)
15592 /* We can't clobber safely for an implicitly-defined default constructor
15593 because part of the initialization might happen before we enter the
15594 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
15595 && !implicit_default_ctor_p (decl1
))
15596 finish_expr_stmt (build_clobber_this ());
15598 if (!processing_template_decl
15599 && DECL_CONSTRUCTOR_P (decl1
)
15600 && sanitize_flags_p (SANITIZE_VPTR
)
15601 && !DECL_CLONED_FUNCTION_P (decl1
)
15602 && !implicit_default_ctor_p (decl1
))
15603 cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr
);
15605 start_lambda_scope (decl1
);
15611 /* Like start_preparsed_function, except that instead of a
15612 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
15614 Returns true on success. If the DECLARATOR is not suitable
15615 for a function, we return false, which tells the parser to
15616 skip the entire function. */
15619 start_function (cp_decl_specifier_seq
*declspecs
,
15620 const cp_declarator
*declarator
,
15625 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
15626 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
15627 if (decl1
== error_mark_node
)
15629 /* If the declarator is not suitable for a function definition,
15630 cause a syntax error. */
15631 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
15633 error ("invalid function declaration");
15637 if (DECL_MAIN_P (decl1
))
15638 /* main must return int. grokfndecl should have corrected it
15639 (and issued a diagnostic) if the user got it wrong. */
15640 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
15641 integer_type_node
));
15643 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
15646 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
15650 use_eh_spec_block (tree fn
)
15652 return (flag_exceptions
&& flag_enforce_eh_specs
15653 && !processing_template_decl
15654 && !type_throw_all_p (TREE_TYPE (fn
))
15655 /* We insert the EH_SPEC_BLOCK only in the original
15656 function; then, it is copied automatically to the
15658 && !DECL_CLONED_FUNCTION_P (fn
)
15659 /* Implicitly-generated constructors and destructors have
15660 exception specifications. However, those specifications
15661 are the union of the possible exceptions specified by the
15662 constructors/destructors for bases and members, so no
15663 unallowed exception will ever reach this function. By
15664 not creating the EH_SPEC_BLOCK we save a little memory,
15665 and we avoid spurious warnings about unreachable
15667 && !DECL_DEFAULTED_FN (fn
));
15670 /* Store the parameter declarations into the current function declaration.
15671 This is called after parsing the parameter declarations, before
15672 digesting the body of the function.
15674 Also install to binding contour return value identifier, if any. */
15677 store_parm_decls (tree current_function_parms
)
15679 tree fndecl
= current_function_decl
;
15682 /* This is a chain of any other decls that came in among the parm
15683 declarations. If a parm is declared with enum {foo, bar} x;
15684 then CONST_DECLs for foo and bar are put here. */
15685 tree nonparms
= NULL_TREE
;
15687 if (current_function_parms
)
15689 /* This case is when the function was defined with an ANSI prototype.
15690 The parms already have decls, so we need not do anything here
15691 except record them as in effect
15692 and complain if any redundant old-style parm decls were written. */
15694 tree specparms
= current_function_parms
;
15697 /* Must clear this because it might contain TYPE_DECLs declared
15699 current_binding_level
->names
= NULL
;
15701 /* If we're doing semantic analysis, then we'll call pushdecl
15702 for each of these. We must do them in reverse order so that
15703 they end in the correct forward order. */
15704 specparms
= nreverse (specparms
);
15706 for (parm
= specparms
; parm
; parm
= next
)
15708 next
= DECL_CHAIN (parm
);
15709 if (TREE_CODE (parm
) == PARM_DECL
)
15713 /* If we find an enum constant or a type tag,
15714 put it aside for the moment. */
15715 TREE_CHAIN (parm
) = NULL_TREE
;
15716 nonparms
= chainon (nonparms
, parm
);
15720 /* Get the decls in their original chain order and record in the
15721 function. This is all and only the PARM_DECLs that were
15722 pushed into scope by the loop above. */
15723 DECL_ARGUMENTS (fndecl
) = get_local_decls ();
15726 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
15728 /* Now store the final chain of decls for the arguments
15729 as the decl-chain of the current lexical scope.
15730 Put the enumerators in as well, at the front so that
15731 DECL_ARGUMENTS is not modified. */
15732 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
15734 if (use_eh_spec_block (current_function_decl
))
15735 current_eh_spec_block
= begin_eh_spec_block ();
15739 /* We have finished doing semantic analysis on DECL, but have not yet
15740 generated RTL for its body. Save away our current state, so that
15741 when we want to generate RTL later we know what to do. */
15744 save_function_data (tree decl
)
15746 struct language_function
*f
;
15748 /* Save the language-specific per-function data so that we can
15749 get it back when we really expand this function. */
15750 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
15753 f
= ggc_alloc
<language_function
> ();
15754 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
15755 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
15757 /* Clear out the bits we don't need. */
15758 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
15759 f
->bindings
= NULL
;
15760 f
->base
.local_typedefs
= NULL
;
15764 /* Set the return value of the constructor (if present). */
15767 finish_constructor_body (void)
15772 if (targetm
.cxx
.cdtor_returns_this ())
15774 /* Any return from a constructor will end up here. */
15775 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
15777 val
= DECL_ARGUMENTS (current_function_decl
);
15778 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
15779 DECL_RESULT (current_function_decl
), val
);
15780 /* Return the address of the object. */
15781 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
15782 add_stmt (exprstmt
);
15786 /* Do all the processing for the beginning of a destructor; set up the
15787 vtable pointers and cleanups for bases and members. */
15790 begin_destructor_body (void)
15792 tree compound_stmt
;
15794 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
15795 issued an error message. We still want to try to process the
15796 body of the function, but initialize_vtbl_ptrs will crash if
15797 TYPE_BINFO is NULL. */
15798 if (COMPLETE_TYPE_P (current_class_type
))
15800 compound_stmt
= begin_compound_stmt (0);
15801 /* Make all virtual function table pointers in non-virtual base
15802 classes point to CURRENT_CLASS_TYPE's virtual function
15804 initialize_vtbl_ptrs (current_class_ptr
);
15805 finish_compound_stmt (compound_stmt
);
15807 if (flag_lifetime_dse
15808 /* Clobbering an empty base is harmful if it overlays real data. */
15809 && !is_empty_class (current_class_type
))
15811 if (sanitize_flags_p (SANITIZE_VPTR
)
15812 && (flag_sanitize_recover
& SANITIZE_VPTR
) == 0
15813 && TYPE_CONTAINS_VPTR_P (current_class_type
))
15815 tree binfo
= TYPE_BINFO (current_class_type
);
15817 = cp_build_fold_indirect_ref (current_class_ptr
);
15819 tree vtbl_ptr
= build_vfield_ref (ref
, TREE_TYPE (binfo
));
15820 tree vtbl
= build_zero_cst (TREE_TYPE (vtbl_ptr
));
15821 tree stmt
= cp_build_modify_expr (input_location
, vtbl_ptr
,
15823 tf_warning_or_error
);
15824 /* If the vptr is shared with some virtual nearly empty base,
15825 don't clear it if not in charge, the dtor of the virtual
15826 nearly empty base will do that later. */
15827 if (CLASSTYPE_VBASECLASSES (current_class_type
)
15828 && CLASSTYPE_PRIMARY_BINFO (current_class_type
)
15830 (CLASSTYPE_PRIMARY_BINFO (current_class_type
)))
15832 stmt
= convert_to_void (stmt
, ICV_STATEMENT
,
15833 tf_warning_or_error
);
15834 stmt
= build_if_in_charge (stmt
);
15836 finish_decl_cleanup (NULL_TREE
, stmt
);
15839 finish_decl_cleanup (NULL_TREE
, build_clobber_this ());
15842 /* And insert cleanups for our bases and members so that they
15843 will be properly destroyed if we throw. */
15844 push_base_cleanups ();
15848 /* At the end of every destructor we generate code to delete the object if
15849 necessary. Do that now. */
15852 finish_destructor_body (void)
15856 /* Any return from a destructor will end up here; that way all base
15857 and member cleanups will be run when the function returns. */
15858 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
15860 if (targetm
.cxx
.cdtor_returns_this ())
15864 val
= DECL_ARGUMENTS (current_function_decl
);
15865 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
15866 DECL_RESULT (current_function_decl
), val
);
15867 /* Return the address of the object. */
15868 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
15869 add_stmt (exprstmt
);
15873 /* Do the necessary processing for the beginning of a function body, which
15874 in this case includes member-initializers, but not the catch clauses of
15875 a function-try-block. Currently, this means opening a binding level
15876 for the member-initializers (in a ctor), member cleanups (in a dtor),
15877 and capture proxies (in a lambda operator()). */
15880 begin_function_body (void)
15884 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
15887 if (processing_template_decl
)
15888 /* Do nothing now. */;
15890 /* Always keep the BLOCK node associated with the outermost pair of
15891 curly braces of a function. These are needed for correct
15892 operation of dwarfout.c. */
15893 keep_next_level (true);
15895 stmt
= begin_compound_stmt (BCS_FN_BODY
);
15897 if (processing_template_decl
)
15898 /* Do nothing now. */;
15899 else if (DECL_DESTRUCTOR_P (current_function_decl
))
15900 begin_destructor_body ();
15905 /* Do the processing for the end of a function body. Currently, this means
15906 closing out the cleanups for fully-constructed bases and members, and in
15907 the case of the destructor, deleting the object if desired. Again, this
15908 is only meaningful for [cd]tors, since they are the only functions where
15909 there is a significant distinction between the main body and any
15910 function catch clauses. Handling, say, main() return semantics here
15911 would be wrong, as flowing off the end of a function catch clause for
15912 main() would also need to return 0. */
15915 finish_function_body (tree compstmt
)
15917 if (compstmt
== NULL_TREE
)
15920 /* Close the block. */
15921 finish_compound_stmt (compstmt
);
15923 if (processing_template_decl
)
15924 /* Do nothing now. */;
15925 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
15926 finish_constructor_body ();
15927 else if (DECL_DESTRUCTOR_P (current_function_decl
))
15928 finish_destructor_body ();
15931 /* Given a function, returns the BLOCK corresponding to the outermost level
15932 of curly braces, skipping the artificial block created for constructor
15936 outer_curly_brace_block (tree fndecl
)
15938 tree block
= DECL_INITIAL (fndecl
);
15939 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
15941 block
= BLOCK_SUBBLOCKS (block
);
15942 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
15944 block
= BLOCK_SUBBLOCKS (block
);
15945 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block
));
15949 /* If FNDECL is a class's key method, add the class to the list of
15950 keyed classes that should be emitted. */
15953 record_key_method_defined (tree fndecl
)
15955 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
15956 && DECL_VIRTUAL_P (fndecl
)
15957 && !processing_template_decl
)
15959 tree fnclass
= DECL_CONTEXT (fndecl
);
15960 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
15961 vec_safe_push (keyed_classes
, fnclass
);
15965 /* Subroutine of finish_function.
15966 Save the body of constexpr functions for possible
15967 future compile time evaluation. */
15970 maybe_save_function_definition (tree fun
)
15972 if (!processing_template_decl
15973 && DECL_DECLARED_CONSTEXPR_P (fun
)
15974 && !cp_function_chain
->invalid_constexpr
15975 && !DECL_CLONED_FUNCTION_P (fun
))
15976 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
15979 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
15980 of "return *this;" immediately before its location, using FNDECL's
15981 first statement (if any) to give the indentation, if appropriate. */
15984 add_return_star_this_fixit (gcc_rich_location
*richloc
, tree fndecl
)
15986 location_t indent
= UNKNOWN_LOCATION
;
15987 tree stmts
= expr_first (DECL_SAVED_TREE (fndecl
));
15989 indent
= EXPR_LOCATION (stmts
);
15990 richloc
->add_fixit_insert_formatted ("return *this;",
15991 richloc
->get_loc (),
15995 /* Finish up a function declaration and compile that function
15996 all the way to assembler language output. The free the storage
15997 for the function definition. INLINE_P is TRUE if we just
15998 finished processing the body of an in-class inline function
15999 definition. (This processing will have taken place after the
16000 class definition is complete.) */
16003 finish_function (bool inline_p
)
16005 tree fndecl
= current_function_decl
;
16006 tree fntype
, ctype
= NULL_TREE
;
16008 /* When we get some parse errors, we can end up without a
16009 current_function_decl, so cope. */
16010 if (fndecl
== NULL_TREE
)
16011 return error_mark_node
;
16013 finish_lambda_scope ();
16015 if (c_dialect_objc ())
16016 objc_finish_function ();
16018 record_key_method_defined (fndecl
);
16020 fntype
= TREE_TYPE (fndecl
);
16022 /* TREE_READONLY (fndecl) = 1;
16023 This caused &foo to be of type ptr-to-const-function
16024 which then got a warning when stored in a ptr-to-function variable. */
16026 gcc_assert (building_stmt_list_p ());
16027 /* The current function is being defined, so its DECL_INITIAL should
16028 be set, and unless there's a multiple definition, it should be
16029 error_mark_node. */
16030 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
16032 /* For a cloned function, we've already got all the code we need;
16033 there's no need to add any extra bits. */
16034 if (!DECL_CLONED_FUNCTION_P (fndecl
))
16036 /* Make it so that `main' always returns 0 by default. */
16037 if (DECL_MAIN_P (current_function_decl
))
16038 finish_return_stmt (integer_zero_node
);
16040 if (use_eh_spec_block (current_function_decl
))
16041 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
16042 (TREE_TYPE (current_function_decl
)),
16043 current_eh_spec_block
);
16046 /* If we're saving up tree structure, tie off the function now. */
16047 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
16049 finish_fname_decls ();
16051 /* If this function can't throw any exceptions, remember that. */
16052 if (!processing_template_decl
16053 && !cp_function_chain
->can_throw
16054 && !flag_non_call_exceptions
16055 && !decl_replaceable_p (fndecl
))
16056 TREE_NOTHROW (fndecl
) = 1;
16058 /* This must come after expand_function_end because cleanups might
16059 have declarations (from inline functions) that need to go into
16060 this function's blocks. */
16062 /* If the current binding level isn't the outermost binding level
16063 for this function, either there is a bug, or we have experienced
16064 syntax errors and the statement tree is malformed. */
16065 if (current_binding_level
->kind
!= sk_function_parms
)
16067 /* Make sure we have already experienced errors. */
16068 gcc_assert (errorcount
);
16070 /* Throw away the broken statement tree and extra binding
16072 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
16074 while (current_binding_level
->kind
!= sk_function_parms
)
16076 if (current_binding_level
->kind
== sk_class
)
16077 pop_nested_class ();
16079 poplevel (0, 0, 0);
16082 poplevel (1, 0, 1);
16084 /* Statements should always be full-expressions at the outermost set
16085 of curly braces for a function. */
16086 gcc_assert (stmts_are_full_exprs_p ());
16088 /* If there are no return statements in a function with auto return type,
16089 the return type is void. But if the declared type is something like
16090 auto*, this is an error. */
16091 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
16092 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
16094 if (is_auto (current_function_auto_return_pattern
))
16096 apply_deduced_return_type (fndecl
, void_type_node
);
16097 fntype
= TREE_TYPE (fndecl
);
16099 else if (!current_function_returns_value
16100 && !current_function_returns_null
)
16102 error ("no return statements in function returning %qT",
16103 current_function_auto_return_pattern
);
16104 inform (input_location
, "only plain %<auto%> return type can be "
16105 "deduced to %<void%>");
16109 // If this is a concept, check that the definition is reasonable.
16110 if (DECL_DECLARED_CONCEPT_P (fndecl
))
16111 check_function_concept (fndecl
);
16113 /* Lambda closure members are implicitly constexpr if possible. */
16114 if (cxx_dialect
>= cxx17
16115 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fndecl
)))
16116 DECL_DECLARED_CONSTEXPR_P (fndecl
)
16117 = ((processing_template_decl
16118 || is_valid_constexpr_fn (fndecl
, /*complain*/false))
16119 && potential_constant_expression (DECL_SAVED_TREE (fndecl
)));
16121 /* Save constexpr function body before it gets munged by
16122 the NRV transformation. */
16123 maybe_save_function_definition (fndecl
);
16125 /* Invoke the pre-genericize plugin before we start munging things. */
16126 if (!processing_template_decl
)
16127 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
16129 /* Perform delayed folding before NRV transformation. */
16130 if (!processing_template_decl
)
16131 cp_fold_function (fndecl
);
16133 /* Set up the named return value optimization, if we can. Candidate
16134 variables are selected in check_return_expr. */
16135 if (current_function_return_value
)
16137 tree r
= current_function_return_value
;
16140 if (r
!= error_mark_node
16141 /* This is only worth doing for fns that return in memory--and
16142 simpler, since we don't have to worry about promoted modes. */
16143 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
16144 /* Only allow this for variables declared in the outer scope of
16145 the function so we know that their lifetime always ends with a
16146 return; see g++.dg/opt/nrv6.C. We could be more flexible if
16147 we were to do this optimization in tree-ssa. */
16148 && (outer
= outer_curly_brace_block (fndecl
))
16149 && chain_member (r
, BLOCK_VARS (outer
)))
16150 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
16152 current_function_return_value
= NULL_TREE
;
16155 /* Remember that we were in class scope. */
16156 if (current_class_name
)
16157 ctype
= current_class_type
;
16159 /* Must mark the RESULT_DECL as being in this function. */
16160 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
16162 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
16163 to the FUNCTION_DECL node itself. */
16164 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
16166 /* Save away current state, if appropriate. */
16167 if (!processing_template_decl
)
16168 save_function_data (fndecl
);
16170 /* Complain if there's just no return statement. */
16171 if (warn_return_type
16172 && !VOID_TYPE_P (TREE_TYPE (fntype
))
16173 && !dependent_type_p (TREE_TYPE (fntype
))
16174 && !current_function_returns_value
&& !current_function_returns_null
16175 /* Don't complain if we abort or throw. */
16176 && !current_function_returns_abnormally
16177 /* Don't complain if there's an infinite loop. */
16178 && !current_function_infinite_loop
16179 /* Don't complain if we are declared noreturn. */
16180 && !TREE_THIS_VOLATILE (fndecl
)
16181 && !DECL_NAME (DECL_RESULT (fndecl
))
16182 && !TREE_NO_WARNING (fndecl
)
16183 /* Structor return values (if any) are set by the compiler. */
16184 && !DECL_CONSTRUCTOR_P (fndecl
)
16185 && !DECL_DESTRUCTOR_P (fndecl
)
16186 && targetm
.warn_func_return (fndecl
))
16188 gcc_rich_location
richloc (input_location
);
16189 /* Potentially add a "return *this;" fix-it hint for
16190 assignment operators. */
16191 if (IDENTIFIER_ASSIGN_OP_P (DECL_NAME (fndecl
)))
16193 tree valtype
= TREE_TYPE (DECL_RESULT (fndecl
));
16194 if (TREE_CODE (valtype
) == REFERENCE_TYPE
16195 && current_class_ref
16196 && same_type_ignoring_top_level_qualifiers_p
16197 (TREE_TYPE (valtype
), TREE_TYPE (current_class_ref
))
16198 && global_dc
->option_enabled (OPT_Wreturn_type
,
16199 global_dc
->option_state
))
16200 add_return_star_this_fixit (&richloc
, fndecl
);
16202 if (warning_at (&richloc
, OPT_Wreturn_type
,
16203 "no return statement in function returning non-void"))
16204 TREE_NO_WARNING (fndecl
) = 1;
16207 /* Store the end of the function, so that we get good line number
16208 info for the epilogue. */
16209 cfun
->function_end_locus
= input_location
;
16211 /* Complain about parameters that are only set, but never otherwise used. */
16212 if (warn_unused_but_set_parameter
16213 && !processing_template_decl
16214 && errorcount
== unused_but_set_errorcount
16215 && !DECL_CLONED_FUNCTION_P (fndecl
))
16219 for (decl
= DECL_ARGUMENTS (fndecl
);
16221 decl
= DECL_CHAIN (decl
))
16222 if (TREE_USED (decl
)
16223 && TREE_CODE (decl
) == PARM_DECL
16224 && !DECL_READ_P (decl
)
16225 && DECL_NAME (decl
)
16226 && !DECL_ARTIFICIAL (decl
)
16227 && !TREE_NO_WARNING (decl
)
16228 && !DECL_IN_SYSTEM_HEADER (decl
)
16229 && TREE_TYPE (decl
) != error_mark_node
16230 && !TYPE_REF_P (TREE_TYPE (decl
))
16231 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
16232 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
16233 warning_at (DECL_SOURCE_LOCATION (decl
),
16234 OPT_Wunused_but_set_parameter
,
16235 "parameter %qD set but not used", decl
);
16236 unused_but_set_errorcount
= errorcount
;
16239 /* Complain about locally defined typedefs that are not used in this
16241 maybe_warn_unused_local_typedefs ();
16243 /* Possibly warn about unused parameters. */
16244 if (warn_unused_parameter
16245 && !processing_template_decl
16246 && !DECL_CLONED_FUNCTION_P (fndecl
))
16247 do_warn_unused_parameter (fndecl
);
16249 /* Genericize before inlining. */
16250 if (!processing_template_decl
)
16252 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
16253 cp_genericize (fndecl
);
16254 /* Clear out the bits we don't need. */
16255 f
->x_current_class_ptr
= NULL
;
16256 f
->x_current_class_ref
= NULL
;
16257 f
->x_eh_spec_block
= NULL
;
16258 f
->x_in_charge_parm
= NULL
;
16259 f
->x_vtt_parm
= NULL
;
16260 f
->x_return_value
= NULL
;
16261 f
->bindings
= NULL
;
16262 f
->extern_decl_map
= NULL
;
16263 f
->infinite_loops
= NULL
;
16266 /* We're leaving the context of this function, so zap cfun. It's still in
16267 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
16269 current_function_decl
= NULL
;
16271 /* If this is an in-class inline definition, we may have to pop the
16272 bindings for the template parameters that we added in
16273 maybe_begin_member_template_processing when start_function was
16276 maybe_end_member_template_processing ();
16278 /* Leave the scope of the class. */
16280 pop_nested_class ();
16285 current_function_decl
= NULL_TREE
;
16287 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, fndecl
);
16291 /* Create the FUNCTION_DECL for a function definition.
16292 DECLSPECS and DECLARATOR are the parts of the declaration;
16293 they describe the return type and the name of the function,
16294 but twisted together in a fashion that parallels the syntax of C.
16296 This function creates a binding context for the function body
16297 as well as setting up the FUNCTION_DECL in current_function_decl.
16299 Returns a FUNCTION_DECL on success.
16301 If the DECLARATOR is not suitable for a function (it defines a datum
16302 instead), we return 0, which tells yyparse to report a parse error.
16304 May return void_type_node indicating that this method is actually
16305 a friend. See grokfield for more details.
16307 Came here with a `.pushlevel' .
16309 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
16310 CHANGES TO CODE IN `grokfield'. */
16313 grokmethod (cp_decl_specifier_seq
*declspecs
,
16314 const cp_declarator
*declarator
, tree attrlist
)
16316 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
16319 if (fndecl
== error_mark_node
)
16320 return error_mark_node
;
16322 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
16324 error ("invalid member function declaration");
16325 return error_mark_node
;
16329 cplus_decl_attributes (&fndecl
, attrlist
, 0);
16331 /* Pass friends other than inline friend functions back. */
16332 if (fndecl
== void_type_node
)
16335 if (DECL_IN_AGGR_P (fndecl
))
16337 if (DECL_CLASS_SCOPE_P (fndecl
))
16338 error ("%qD is already defined in class %qT", fndecl
,
16339 DECL_CONTEXT (fndecl
));
16340 return error_mark_node
;
16343 check_template_shadow (fndecl
);
16345 if (TREE_PUBLIC (fndecl
))
16346 DECL_COMDAT (fndecl
) = 1;
16347 DECL_DECLARED_INLINE_P (fndecl
) = 1;
16348 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
16350 /* We process method specializations in finish_struct_1. */
16351 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
16353 fndecl
= push_template_decl (fndecl
);
16354 if (fndecl
== error_mark_node
)
16358 if (! DECL_FRIEND_P (fndecl
))
16360 if (DECL_CHAIN (fndecl
))
16362 fndecl
= copy_node (fndecl
);
16363 TREE_CHAIN (fndecl
) = NULL_TREE
;
16367 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
16369 DECL_IN_AGGR_P (fndecl
) = 1;
16374 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
16375 we can lay it out later, when and if its type becomes complete.
16377 Also handle constexpr variables where the initializer involves
16378 an unlowered PTRMEM_CST because the class isn't complete yet. */
16381 maybe_register_incomplete_var (tree var
)
16383 gcc_assert (VAR_P (var
));
16385 /* Keep track of variables with incomplete types. */
16386 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
16387 && DECL_EXTERNAL (var
))
16389 tree inner_type
= TREE_TYPE (var
);
16391 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
16392 inner_type
= TREE_TYPE (inner_type
);
16393 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
16395 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
16396 /* RTTI TD entries are created while defining the type_info. */
16397 || (TYPE_LANG_SPECIFIC (inner_type
)
16398 && TYPE_BEING_DEFINED (inner_type
)))
16400 incomplete_var iv
= {var
, inner_type
};
16401 vec_safe_push (incomplete_vars
, iv
);
16403 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
16404 && decl_constant_var_p (var
)
16405 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
16407 /* When the outermost open class is complete we can resolve any
16408 pointers-to-members. */
16409 tree context
= outermost_open_class ();
16410 incomplete_var iv
= {var
, context
};
16411 vec_safe_push (incomplete_vars
, iv
);
16416 /* Called when a class type (given by TYPE) is defined. If there are
16417 any existing VAR_DECLs whose type has been completed by this
16418 declaration, update them now. */
16421 complete_vars (tree type
)
16424 incomplete_var
*iv
;
16426 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
16428 if (same_type_p (type
, iv
->incomplete_type
))
16430 tree var
= iv
->decl
;
16431 tree type
= TREE_TYPE (var
);
16433 if (type
!= error_mark_node
16434 && (TYPE_MAIN_VARIANT (strip_array_types (type
))
16435 == iv
->incomplete_type
))
16437 /* Complete the type of the variable. The VAR_DECL itself
16438 will be laid out in expand_expr. */
16439 complete_type (type
);
16440 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
16443 /* Remove this entry from the list. */
16444 incomplete_vars
->unordered_remove (ix
);
16450 /* Check for pending declarations which may have abstract type. */
16451 complete_type_check_abstract (type
);
16454 /* If DECL is of a type which needs a cleanup, build and return an
16455 expression to perform that cleanup here. Return NULL_TREE if no
16456 cleanup need be done. DECL can also be a _REF when called from
16457 split_nonconstant_init_1. */
16460 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
16466 /* Assume no cleanup is required. */
16467 cleanup
= NULL_TREE
;
16469 if (error_operand_p (decl
))
16472 /* Handle "__attribute__((cleanup))". We run the cleanup function
16473 before the destructor since the destructor is what actually
16474 terminates the lifetime of the object. */
16476 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
16485 /* Get the name specified by the user for the cleanup function. */
16486 id
= TREE_VALUE (TREE_VALUE (attr
));
16487 /* Look up the name to find the cleanup function to call. It is
16488 important to use lookup_name here because that is what is
16489 used in c-common.c:handle_cleanup_attribute when performing
16490 initial checks on the attribute. Note that those checks
16491 include ensuring that the function found is not an overloaded
16492 function, or an object with an overloaded call operator,
16493 etc.; we can rely on the fact that the function found is an
16494 ordinary FUNCTION_DECL. */
16495 fn
= lookup_name (id
);
16496 arg
= build_address (decl
);
16497 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
16498 return error_mark_node
;
16499 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
16500 if (cleanup
== error_mark_node
)
16501 return error_mark_node
;
16503 /* Handle ordinary C++ destructors. */
16504 type
= TREE_TYPE (decl
);
16505 if (type_build_dtor_call (type
))
16507 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
16511 if (TREE_CODE (type
) == ARRAY_TYPE
)
16514 addr
= build_address (decl
);
16516 call
= build_delete (TREE_TYPE (addr
), addr
,
16517 sfk_complete_destructor
, flags
, 0, complain
);
16518 if (call
== error_mark_node
)
16519 cleanup
= error_mark_node
;
16520 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
16521 /* Discard the call. */;
16523 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
16528 /* build_delete sets the location of the destructor call to the
16529 current location, even though the destructor is going to be
16530 called later, at the end of the current scope. This can lead to
16531 a "jumpy" behavior for users of debuggers when they step around
16532 the end of the block. So let's unset the location of the
16533 destructor call instead. */
16534 protected_set_expr_location (cleanup
, UNKNOWN_LOCATION
);
16538 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
)))
16539 /* Treat objects with destructors as used; the destructor may do
16540 something substantive. */
16541 && !mark_used (decl
, complain
) && !(complain
& tf_error
))
16542 return error_mark_node
;
16548 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
16549 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
16550 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
16553 static_fn_type (tree memfntype
)
16558 if (TYPE_PTRMEMFUNC_P (memfntype
))
16559 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
16560 if (INDIRECT_TYPE_P (memfntype
)
16561 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
16562 memfntype
= TREE_TYPE (memfntype
);
16563 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
16565 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
16566 args
= TYPE_ARG_TYPES (memfntype
);
16567 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
16568 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
));
16569 fntype
= (cp_build_type_attribute_variant
16570 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
16571 fntype
= cxx_copy_lang_qualifiers (fntype
, memfntype
);
16575 /* DECL was originally constructed as a non-static member function,
16576 but turned out to be static. Update it accordingly. */
16579 revert_static_member_fn (tree decl
)
16581 tree stype
= static_fn_type (decl
);
16582 cp_cv_quals quals
= type_memfn_quals (stype
);
16583 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
16585 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
16586 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
16588 TREE_TYPE (decl
) = stype
;
16590 if (DECL_ARGUMENTS (decl
))
16591 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
16592 DECL_STATIC_FUNCTION_P (decl
) = 1;
16595 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
16596 one of the language-independent trees. */
16598 enum cp_tree_node_structure_enum
16599 cp_tree_node_structure (union lang_tree_node
* t
)
16601 switch (TREE_CODE (&t
->generic
))
16603 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
16604 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
16605 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
16606 case OVERLOAD
: return TS_CP_OVERLOAD
;
16607 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
16608 case PTRMEM_CST
: return TS_CP_PTRMEM
;
16609 case BASELINK
: return TS_CP_BASELINK
;
16610 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
16611 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
16612 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
16613 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
16614 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
16615 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
16616 case CONSTRAINT_INFO
: return TS_CP_CONSTRAINT_INFO
;
16617 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
16618 default: return TS_CP_GENERIC
;
16622 /* Build the void_list_node (void_type_node having been created). */
16624 build_void_list_node (void)
16626 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
16631 cp_missing_noreturn_ok_p (tree decl
)
16633 /* A missing noreturn is ok for the `main' function. */
16634 return DECL_MAIN_P (decl
);
16637 /* Return the decl used to identify the COMDAT group into which DECL should
16641 cxx_comdat_group (tree decl
)
16643 /* Virtual tables, construction virtual tables, and virtual table
16644 tables all go in a single COMDAT group, named after the primary
16646 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
16647 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
16648 /* For all other DECLs, the COMDAT group is the mangled name of the
16649 declaration itself. */
16652 while (DECL_THUNK_P (decl
))
16654 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
16655 into the same section as the target function. In that case
16656 we must return target's name. */
16657 tree target
= THUNK_TARGET (decl
);
16658 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
16659 && DECL_SECTION_NAME (target
) != NULL
16660 && DECL_ONE_ONLY (target
))
16670 /* Returns the return type for FN as written by the user, which may include
16671 a placeholder for a deduced return type. */
16674 fndecl_declared_return_type (tree fn
)
16676 fn
= STRIP_TEMPLATE (fn
);
16677 if (FNDECL_USED_AUTO (fn
))
16679 struct language_function
*f
= NULL
;
16680 if (DECL_STRUCT_FUNCTION (fn
))
16681 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
16683 f
= DECL_SAVED_FUNCTION_DATA (fn
);
16684 return f
->x_auto_return_pattern
;
16686 return TREE_TYPE (TREE_TYPE (fn
));
16689 /* Returns true iff DECL is a variable or function declared with an auto type
16690 that has not yet been deduced to a real type. */
16693 undeduced_auto_decl (tree decl
)
16695 if (cxx_dialect
< cxx11
)
16697 STRIP_ANY_LOCATION_WRAPPER (decl
);
16698 return ((VAR_OR_FUNCTION_DECL_P (decl
)
16699 || TREE_CODE (decl
) == TEMPLATE_DECL
)
16700 && type_uses_auto (TREE_TYPE (decl
)));
16703 /* Complain if DECL has an undeduced return type. */
16706 require_deduced_type (tree decl
, tsubst_flags_t complain
)
16708 if (undeduced_auto_decl (decl
))
16710 if (complain
& tf_error
)
16711 error ("use of %qD before deduction of %<auto%>", decl
);
16717 /* Create a representation of the explicit-specifier with
16718 constant-expression of EXPR. COMPLAIN is as for tsubst. */
16721 build_explicit_specifier (tree expr
, tsubst_flags_t complain
)
16723 if (instantiation_dependent_expression_p (expr
))
16724 /* Wait for instantiation, tsubst_function_decl will handle it. */
16727 expr
= instantiate_non_dependent_expr_sfinae (expr
, complain
);
16728 /* Don't let convert_like_real create more template codes. */
16729 processing_template_decl_sentinel s
;
16730 expr
= build_converted_constant_bool_expr (expr
, complain
);
16731 expr
= cxx_constant_value (expr
);
16735 #include "gt-cp-decl.h"