1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987-2023 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* This file is part of the C++ front end.
24 It contains routines to build C++ expressions given their operands,
25 including computing the types of the result, C and C++ specific error
26 checks, and some optimization. */
30 #include "coretypes.h"
32 #include "stor-layout.h"
35 #include "gcc-rich-location.h"
39 process_init_constructor (tree type
, tree init
, int nested
, int flags
,
40 tsubst_flags_t complain
);
43 /* Print an error message stemming from an attempt to use
44 BASETYPE as a base class for TYPE. */
47 error_not_base_type (tree basetype
, tree type
)
49 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
50 basetype
= DECL_CONTEXT (basetype
);
51 error ("type %qT is not a base type for type %qT", basetype
, type
);
52 return error_mark_node
;
56 binfo_or_else (tree base
, tree type
)
58 tree binfo
= lookup_base (type
, base
, ba_unique
,
59 NULL
, tf_warning_or_error
);
61 if (binfo
== error_mark_node
)
64 error_not_base_type (base
, type
);
68 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
69 value may not be changed thereafter. */
72 cxx_readonly_error (location_t loc
, tree arg
, enum lvalue_use errstring
)
75 /* This macro is used to emit diagnostics to ensure that all format
76 strings are complete sentences, visible to gettext and checked at
79 #define ERROR_FOR_ASSIGNMENT(LOC, AS, ASM, IN, DE, ARG) \
84 error_at (LOC, AS, ARG); \
87 error_at (LOC, ASM, ARG); \
90 error_at (LOC, IN, ARG); \
93 error_at (LOC, DE, ARG); \
100 /* Handle C++-specific things first. */
103 && DECL_LANG_SPECIFIC (arg
)
104 && DECL_IN_AGGR_P (arg
)
105 && !TREE_STATIC (arg
))
106 ERROR_FOR_ASSIGNMENT (loc
,
107 G_("assignment of constant field %qD"),
108 G_("constant field %qD used as %<asm%> output"),
109 G_("increment of constant field %qD"),
110 G_("decrement of constant field %qD"),
112 else if (INDIRECT_REF_P (arg
)
113 && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (arg
, 0)))
114 && (VAR_P (TREE_OPERAND (arg
, 0))
115 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
116 ERROR_FOR_ASSIGNMENT (loc
,
117 G_("assignment of read-only reference %qD"),
118 G_("read-only reference %qD used as %<asm%> output"),
119 G_("increment of read-only reference %qD"),
120 G_("decrement of read-only reference %qD"),
121 TREE_OPERAND (arg
, 0));
123 readonly_error (loc
, arg
, errstring
);
126 /* If TYPE has abstract virtual functions, issue an error about trying
127 to create an object of that type. DECL is the object declared, or
128 NULL_TREE if the declaration is unavailable, in which case USE specifies
129 the kind of invalid use. Returns 1 if an error occurred; zero if
133 abstract_virtuals_error (tree decl
, tree type
, abstract_class_use use
,
134 tsubst_flags_t complain
)
136 vec
<tree
, va_gc
> *pure
;
138 if (TREE_CODE (type
) == ARRAY_TYPE
)
142 type
= strip_array_types (type
);
145 /* This function applies only to classes. Any other entity can never
147 if (!CLASS_TYPE_P (type
))
149 type
= TYPE_MAIN_VARIANT (type
);
152 /* Instantiation here seems to be required by the standard,
153 but breaks e.g. boost::bind. FIXME! */
154 /* In SFINAE, non-N3276 context, force instantiation. */
155 if (!(complain
& (tf_error
|tf_decltype
)))
156 complete_type (type
);
159 if (!TYPE_SIZE (type
))
160 /* TYPE is being defined, and during that time
161 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
164 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
168 if (!(complain
& tf_error
))
171 auto_diagnostic_group d
;
175 error ("cannot declare variable %q+D to be of abstract "
176 "type %qT", decl
, type
);
177 else if (TREE_CODE (decl
) == PARM_DECL
)
179 if (DECL_NAME (decl
))
180 error ("cannot declare parameter %q+D to be of abstract type %qT",
183 error ("cannot declare parameter to be of abstract type %qT",
186 else if (TREE_CODE (decl
) == FIELD_DECL
)
187 error ("cannot declare field %q+D to be of abstract type %qT",
189 else if (TREE_CODE (decl
) == FUNCTION_DECL
190 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
191 error ("invalid abstract return type for member function %q+#D", decl
);
192 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
193 error ("invalid abstract return type for function %q+#D", decl
);
194 else if (identifier_p (decl
))
195 /* Here we do not have location information. */
196 error ("invalid abstract type %qT for %qE", type
, decl
);
198 error ("invalid abstract type for %q+D", decl
);
203 error ("creating array of %qT, which is an abstract class type", type
);
206 error ("invalid cast to abstract class type %qT", type
);
209 error ("invalid new-expression of abstract class type %qT", type
);
212 error ("invalid abstract return type %qT", type
);
215 error ("invalid abstract parameter type %qT", type
);
218 error ("expression of abstract class type %qT cannot "
219 "be used in throw-expression", type
);
222 error ("cannot declare %<catch%> parameter to be of abstract "
223 "class type %qT", type
);
226 error ("cannot allocate an object of abstract type %qT", type
);
229 /* Only go through this once. */
235 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
236 " because the following virtual functions are pure within %qT:",
239 FOR_EACH_VEC_ELT (*pure
, ix
, fn
)
240 if (! DECL_CLONED_FUNCTION_P (fn
)
241 || DECL_COMPLETE_DESTRUCTOR_P (fn
))
242 inform (DECL_SOURCE_LOCATION (fn
), " %#qD", fn
);
244 /* Now truncate the vector. This leaves it non-null, so we know
245 there are pure virtuals, but empty so we don't list them out
254 abstract_virtuals_error (tree decl
, tree type
,
255 tsubst_flags_t complain
/* = tf_warning_or_error */)
257 return abstract_virtuals_error (decl
, type
, ACU_UNKNOWN
, complain
);
261 abstract_virtuals_error (abstract_class_use use
, tree type
,
262 tsubst_flags_t complain
/* = tf_warning_or_error */)
264 return abstract_virtuals_error (NULL_TREE
, type
, use
, complain
);
268 /* Print an inform about the declaration of the incomplete type TYPE. */
271 cxx_incomplete_type_inform (const_tree type
)
273 if (!TYPE_MAIN_DECL (type
))
276 location_t loc
= DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
));
277 tree ptype
= strip_top_quals (CONST_CAST_TREE (type
));
279 if (current_class_type
280 && TYPE_BEING_DEFINED (current_class_type
)
281 && same_type_p (ptype
, current_class_type
))
282 inform (loc
, "definition of %q#T is not complete until "
283 "the closing brace", ptype
);
284 else if (!TYPE_TEMPLATE_INFO (ptype
))
285 inform (loc
, "forward declaration of %q#T", ptype
);
287 inform (loc
, "declaration of %q#T", ptype
);
290 /* Print an error message for invalid use of an incomplete type.
291 VALUE is the expression that was used (or 0 if that isn't known)
292 and TYPE is the type that was invalid. DIAG_KIND indicates the
293 type of diagnostic (see diagnostic.def). */
296 cxx_incomplete_type_diagnostic (location_t loc
, const_tree value
,
297 const_tree type
, diagnostic_t diag_kind
)
299 bool is_decl
= false, complained
= false;
301 /* Avoid duplicate error message. */
302 if (TREE_CODE (type
) == ERROR_MARK
)
307 STRIP_ANY_LOCATION_WRAPPER (value
);
310 || TREE_CODE (value
) == PARM_DECL
311 || TREE_CODE (value
) == FIELD_DECL
)
313 complained
= emit_diagnostic (diag_kind
, DECL_SOURCE_LOCATION (value
), 0,
314 "%qD has incomplete type", value
);
319 /* We must print an error message. Be clever about what it says. */
321 switch (TREE_CODE (type
))
327 complained
= emit_diagnostic (diag_kind
, loc
, 0,
328 "invalid use of incomplete type %q#T",
331 cxx_incomplete_type_inform (type
);
335 complained
= emit_diagnostic (diag_kind
, loc
, 0,
336 "invalid use of %qT", type
);
340 if (TYPE_DOMAIN (type
))
342 type
= TREE_TYPE (type
);
345 complained
= emit_diagnostic (diag_kind
, loc
, 0,
346 "invalid use of array with unspecified bounds");
352 tree member
= TREE_OPERAND (value
, 1);
353 if (is_overloaded_fn (member
))
354 member
= get_first_fn (member
);
356 if (DECL_FUNCTION_MEMBER_P (member
)
357 && ! flag_ms_extensions
)
359 gcc_rich_location
richloc (loc
);
360 /* If "member" has no arguments (other than "this"), then
361 add a fix-it hint. */
362 if (type_num_arguments (TREE_TYPE (member
)) == 1)
363 richloc
.add_fixit_insert_after ("()");
364 complained
= emit_diagnostic (diag_kind
, &richloc
, 0,
365 "invalid use of member function %qD "
366 "(did you forget the %<()%> ?)", member
);
369 complained
= emit_diagnostic (diag_kind
, loc
, 0,
370 "invalid use of member %qD "
371 "(did you forget the %<&%> ?)", member
);
375 case TEMPLATE_TYPE_PARM
:
378 if (CLASS_PLACEHOLDER_TEMPLATE (type
))
379 complained
= emit_diagnostic (diag_kind
, loc
, 0,
380 "invalid use of placeholder %qT", type
);
382 complained
= emit_diagnostic (diag_kind
, loc
, 0,
383 "invalid use of %qT", type
);
386 complained
= emit_diagnostic (diag_kind
, loc
, 0,
387 "invalid use of template type parameter %qT", type
);
390 case BOUND_TEMPLATE_TEMPLATE_PARM
:
391 complained
= emit_diagnostic (diag_kind
, loc
, 0,
392 "invalid use of template template parameter %qT",
396 case TYPE_PACK_EXPANSION
:
397 complained
= emit_diagnostic (diag_kind
, loc
, 0,
398 "invalid use of pack expansion %qT", type
);
403 complained
= emit_diagnostic (diag_kind
, loc
, 0,
404 "invalid use of dependent type %qT", type
);
408 if (type
== init_list_type_node
)
410 complained
= emit_diagnostic (diag_kind
, loc
, 0,
411 "invalid use of brace-enclosed initializer list");
414 gcc_assert (type
== unknown_type_node
);
415 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
417 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
418 complained
= emit_diagnostic (diag_kind
, loc
, 0,
419 "address of overloaded function with no contextual "
421 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
422 complained
= emit_diagnostic (diag_kind
, loc
, 0,
423 "overloaded function with no contextual type information");
425 complained
= emit_diagnostic (diag_kind
, loc
, 0,
426 "insufficient contextual information to determine type");
436 /* Print an error message for invalid use of an incomplete type.
437 VALUE is the expression that was used (or 0 if that isn't known)
438 and TYPE is the type that was invalid. */
441 cxx_incomplete_type_error (location_t loc
, const_tree value
, const_tree type
)
443 cxx_incomplete_type_diagnostic (loc
, value
, type
, DK_ERROR
);
447 /* We've just initialized subobject SUB; also insert a TARGET_EXPR with an
448 EH-only cleanup for SUB. Because of EH region nesting issues, we need to
449 make the cleanup conditional on a flag that we will clear once the object is
450 fully initialized, so push a new flag onto FLAGS. */
453 maybe_push_temp_cleanup (tree sub
, vec
<tree
,va_gc
> **flags
)
455 if (!flag_exceptions
)
458 = cxx_maybe_build_cleanup (sub
, tf_warning_or_error
))
460 tree tx
= get_target_expr (boolean_true_node
);
461 tree flag
= TARGET_EXPR_SLOT (tx
);
462 CLEANUP_EH_ONLY (tx
) = true;
463 TARGET_EXPR_CLEANUP (tx
) = build3 (COND_EXPR
, void_type_node
,
464 flag
, cleanup
, void_node
);
466 vec_safe_push (*flags
, flag
);
470 /* The recursive part of split_nonconstant_init. DEST is an lvalue
471 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
472 Return true if the whole of the value was initialized by the
473 generated statements. */
476 split_nonconstant_init_1 (tree dest
, tree init
, bool last
,
477 vec
<tree
,va_gc
> **flags
)
479 unsigned HOST_WIDE_INT idx
, tidx
= HOST_WIDE_INT_M1U
;
480 tree field_index
, value
;
481 tree type
= TREE_TYPE (dest
);
482 tree inner_type
= NULL
;
483 bool array_type_p
= false;
484 bool complete_p
= true;
485 HOST_WIDE_INT num_split_elts
= 0;
486 tree last_split_elt
= NULL_TREE
;
488 switch (TREE_CODE (type
))
491 inner_type
= TREE_TYPE (type
);
493 if ((TREE_SIDE_EFFECTS (init
)
494 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
495 || vla_type_p (type
))
497 if (!TYPE_DOMAIN (type
)
498 && TREE_CODE (init
) == CONSTRUCTOR
499 && CONSTRUCTOR_NELTS (init
))
501 /* Flexible array. */
502 cp_complete_array_type (&type
, init
, /*default*/true);
503 dest
= build1 (VIEW_CONVERT_EXPR
, type
, dest
);
506 /* For an array, we only need/want a single cleanup region rather
507 than one per element. build_vec_init will handle it. */
508 tree code
= build_vec_init (dest
, NULL_TREE
, init
, false, 1,
509 tf_warning_or_error
, flags
);
517 case QUAL_UNION_TYPE
:
518 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
521 /* The current implementation of this algorithm assumes that
522 the field was set for all the elements. This is usually done
523 by process_init_constructor. */
524 gcc_assert (field_index
);
527 inner_type
= TREE_TYPE (field_index
);
531 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
532 NULL_TREE
, NULL_TREE
);
534 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
537 bool elt_last
= last
&& idx
== CONSTRUCTOR_NELTS (init
) - 1;
539 /* We need to see sub-array TARGET_EXPR before cp_fold_r so we can
540 handle cleanup flags properly. */
541 gcc_checking_assert (!target_expr_needs_replace (value
));
543 if (TREE_CODE (value
) == CONSTRUCTOR
)
545 if (!split_nonconstant_init_1 (sub
, value
, elt_last
, flags
)
546 /* For flexible array member with initializer we
547 can't remove the initializer, because only the
548 initializer determines how many elements the
549 flexible array member has. */
551 && TREE_CODE (inner_type
) == ARRAY_TYPE
552 && TYPE_DOMAIN (inner_type
) == NULL
553 && TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
554 && COMPLETE_TYPE_P (TREE_TYPE (value
))
555 && !integer_zerop (TYPE_SIZE (TREE_TYPE (value
)))
557 && TYPE_HAS_TRIVIAL_DESTRUCTOR
558 (strip_array_types (inner_type
))))
562 /* Mark element for removal. */
563 last_split_elt
= field_index
;
564 CONSTRUCTOR_ELT (init
, idx
)->index
= NULL_TREE
;
570 else if (tree vi
= get_vec_init_expr (value
))
572 add_stmt (expand_vec_init_expr (sub
, vi
, tf_warning_or_error
,
575 /* Mark element for removal. */
576 last_split_elt
= field_index
;
577 CONSTRUCTOR_ELT (init
, idx
)->index
= NULL_TREE
;
582 else if (!initializer_constant_valid_p (value
, inner_type
))
586 /* Push cleanups for any preceding members with constant
588 if (CLASS_TYPE_P (type
))
589 for (tree prev
= (last_split_elt
?
590 DECL_CHAIN (last_split_elt
)
591 : TYPE_FIELDS (type
));
592 ; prev
= DECL_CHAIN (prev
))
594 prev
= next_aggregate_field (prev
);
595 if (prev
== field_index
)
597 tree ptype
= TREE_TYPE (prev
);
598 if (TYPE_P (ptype
) && type_build_dtor_call (ptype
))
600 tree pcref
= build3 (COMPONENT_REF
, ptype
, dest
, prev
,
602 maybe_push_temp_cleanup (pcref
, flags
);
606 /* Mark element for removal. */
607 CONSTRUCTOR_ELT (init
, idx
)->index
= NULL_TREE
;
611 if (TREE_CODE (field_index
) == RANGE_EXPR
)
613 /* Use build_vec_init to initialize a range. */
614 tree low
= TREE_OPERAND (field_index
, 0);
615 tree hi
= TREE_OPERAND (field_index
, 1);
616 sub
= build4 (ARRAY_REF
, inner_type
, dest
, low
,
617 NULL_TREE
, NULL_TREE
);
618 sub
= cp_build_addr_expr (sub
, tf_warning_or_error
);
619 tree max
= size_binop (MINUS_EXPR
, hi
, low
);
620 code
= build_vec_init (sub
, max
, value
, false, 0,
621 tf_warning_or_error
);
623 if (tree_fits_shwi_p (max
))
624 num_split_elts
+= tree_to_shwi (max
);
628 /* We may need to add a copy constructor call if
629 the field has [[no_unique_address]]. */
630 if (unsafe_return_slot_p (sub
))
632 /* But not if the initializer is an implicit ctor call
633 we just built in digest_init. */
634 if (TREE_CODE (value
) == TARGET_EXPR
635 && TARGET_EXPR_LIST_INIT_P (value
)
636 && make_safe_copy_elision (sub
, value
))
639 tree name
= (DECL_FIELD_IS_BASE (field_index
)
640 ? base_ctor_identifier
641 : complete_ctor_identifier
);
642 releasing_vec args
= make_tree_vector_single (value
);
643 code
= build_special_member_call
644 (sub
, name
, &args
, inner_type
,
645 LOOKUP_NORMAL
, tf_warning_or_error
);
650 code
= cp_build_init_expr (sub
, value
);
652 code
= build_stmt (input_location
, EXPR_STMT
, code
);
655 maybe_push_temp_cleanup (sub
, flags
);
658 last_split_elt
= field_index
;
662 if (num_split_elts
== 1)
663 CONSTRUCTOR_ELTS (init
)->ordered_remove (tidx
);
664 else if (num_split_elts
> 1)
666 /* Perform the delayed ordered removal of non-constant elements
668 for (idx
= tidx
; idx
< CONSTRUCTOR_NELTS (init
); ++idx
)
669 if (CONSTRUCTOR_ELT (init
, idx
)->index
== NULL_TREE
)
673 *CONSTRUCTOR_ELT (init
, tidx
) = *CONSTRUCTOR_ELT (init
, idx
);
676 vec_safe_truncate (CONSTRUCTOR_ELTS (init
), tidx
);
681 if (!initializer_constant_valid_p (init
, type
))
684 tree cons
= copy_node (init
);
685 CONSTRUCTOR_ELTS (init
) = NULL
;
686 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
687 code
= build_stmt (input_location
, EXPR_STMT
, code
);
689 num_split_elts
+= CONSTRUCTOR_NELTS (init
);
697 /* The rest of the initializer is now a constant. */
698 TREE_CONSTANT (init
) = 1;
699 TREE_SIDE_EFFECTS (init
) = 0;
701 /* We didn't split out anything. */
702 if (num_split_elts
== 0)
705 return complete_p
&& complete_ctor_at_level_p (TREE_TYPE (init
),
706 num_split_elts
, inner_type
);
709 /* A subroutine of store_init_value. Splits non-constant static
710 initializer INIT into a constant part and generates code to
711 perform the non-constant part of the initialization to DEST.
712 Returns the code for the runtime init. */
715 split_nonconstant_init (tree dest
, tree init
)
719 if (TREE_CODE (init
) == TARGET_EXPR
)
720 init
= TARGET_EXPR_INITIAL (init
);
721 if (TREE_CODE (init
) == CONSTRUCTOR
)
723 /* Subobject initializers are not full-expressions. */
724 auto fe
= (make_temp_override
725 (current_stmt_tree ()->stmts_are_full_exprs_p
, 0));
727 init
= cp_fully_fold_init (init
);
728 code
= push_stmt_list ();
730 /* If the complete object is an array, build_vec_init's cleanup is
731 enough. Otherwise, collect flags for disabling subobject
732 cleanups once the complete object is fully constructed. */
733 vec
<tree
, va_gc
> *flags
= nullptr;
734 if (TREE_CODE (TREE_TYPE (dest
)) != ARRAY_TYPE
)
735 flags
= make_tree_vector ();
737 if (split_nonconstant_init_1 (dest
, init
, true, &flags
))
742 /* See maybe_push_temp_cleanup. */
744 tree i
= boolean_false_node
;
745 if (TREE_CODE (f
) == TREE_LIST
)
747 /* To disable a build_vec_init cleanup, set
748 iterator = maxindex. */
749 d
= TREE_PURPOSE (f
);
753 add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (d
), d
, i
));
755 release_tree_vector (flags
);
757 code
= pop_stmt_list (code
);
758 if (VAR_P (dest
) && !is_local_temp (dest
))
760 DECL_INITIAL (dest
) = init
;
761 TREE_READONLY (dest
) = 0;
765 tree ie
= cp_build_init_expr (dest
, init
);
766 code
= add_stmt_to_compound (ie
, code
);
769 else if (TREE_CODE (init
) == STRING_CST
770 && array_of_runtime_bound_p (TREE_TYPE (dest
)))
771 code
= build_vec_init (dest
, NULL_TREE
, init
, /*value-init*/false,
772 /*from array*/1, tf_warning_or_error
);
774 code
= cp_build_init_expr (dest
, init
);
779 /* T is the initializer of a constexpr variable. Set CONSTRUCTOR_MUTABLE_POISON
780 for any CONSTRUCTOR within T that contains (directly or indirectly) a mutable
781 member, thereby poisoning it so it can't be copied to another a constexpr
782 variable or read during constexpr evaluation. */
785 poison_mutable_constructors (tree t
)
787 if (TREE_CODE (t
) != CONSTRUCTOR
)
790 if (cp_has_mutable_p (TREE_TYPE (t
)))
792 CONSTRUCTOR_MUTABLE_POISON (t
) = true;
794 if (vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (t
))
795 for (const constructor_elt
&ce
: *elts
)
796 poison_mutable_constructors (ce
.value
);
800 /* Perform appropriate conversions on the initial value of a variable,
801 store it in the declaration DECL,
802 and print any error messages that are appropriate.
803 If the init is invalid, store an ERROR_MARK.
805 C++: Note that INIT might be a TREE_LIST, which would mean that it is
806 a base class initializer for some aggregate type, hopefully compatible
807 with DECL. If INIT is a single element, and DECL is an aggregate
808 type, we silently convert INIT into a TREE_LIST, allowing a constructor
811 If INIT is a TREE_LIST and there is no constructor, turn INIT
812 into a CONSTRUCTOR and use standard initialization techniques.
813 Perhaps a warning should be generated?
815 Returns code to be executed if initialization could not be performed
816 for static variable. In that case, caller must emit the code. */
819 store_init_value (tree decl
, tree init
, vec
<tree
, va_gc
>** cleanups
, int flags
)
823 /* If variable's type was invalidly declared, just ignore it. */
825 type
= TREE_TYPE (decl
);
826 if (TREE_CODE (type
) == ERROR_MARK
)
829 if (MAYBE_CLASS_TYPE_P (type
))
831 if (TREE_CODE (init
) == TREE_LIST
)
833 error ("constructor syntax used, but no constructor declared "
834 "for type %qT", type
);
835 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
839 /* End of special C++ code. */
841 if (flags
& LOOKUP_ALREADY_DIGESTED
)
845 if (TREE_STATIC (decl
))
846 flags
|= LOOKUP_ALLOW_FLEXARRAY_INIT
;
847 /* Digest the specified initializer into an expression. */
848 value
= digest_init_flags (type
, init
, flags
, tf_warning_or_error
);
851 /* Look for braced array initializers for character arrays and
852 recursively convert them into STRING_CSTs. */
853 value
= braced_lists_to_strings (type
, value
);
855 current_ref_temp_count
= 0;
856 value
= extend_ref_init_temps (decl
, value
, cleanups
);
858 /* In C++11 constant expression is a semantic, not syntactic, property.
859 In C++98, make sure that what we thought was a constant expression at
860 template definition time is still constant and otherwise perform this
861 as optimization, e.g. to fold SIZEOF_EXPRs in the initializer. */
862 if (decl_maybe_constant_var_p (decl
) || TREE_STATIC (decl
))
866 if (DECL_DECLARED_CONSTEXPR_P (decl
)
867 || DECL_DECLARED_CONSTINIT_P (decl
)
868 || (DECL_IN_AGGR_P (decl
)
869 && DECL_INITIALIZED_IN_CLASS_P (decl
)))
871 value
= fold_non_dependent_expr (value
, tf_warning_or_error
,
872 /*manifestly_const_eval=*/true,
874 if (value
== error_mark_node
)
876 /* Diagnose a non-constant initializer for constexpr variable or
877 non-inline in-class-initialized static data member. */
878 else if (!is_constant_expression (value
))
880 /* Maybe we want to give this message for constexpr variables as
881 well, but that will mean a lot of testsuite adjustment. */
882 if (DECL_DECLARED_CONSTINIT_P (decl
))
883 error_at (location_of (decl
),
884 "%<constinit%> variable %qD does not have a "
885 "constant initializer", decl
);
886 require_constant_expression (value
);
887 value
= error_mark_node
;
891 value
= maybe_constant_init (value
, decl
, true);
893 /* In a template we might not have done the necessary
894 transformations to make value actually constant,
895 e.g. extend_ref_init_temps. */
896 if (!processing_template_decl
897 && !TREE_CONSTANT (value
))
899 if (DECL_DECLARED_CONSTINIT_P (decl
))
900 error_at (location_of (decl
),
901 "%<constinit%> variable %qD does not have a "
902 "constant initializer", decl
);
903 value
= cxx_constant_init (value
, decl
);
908 value
= fold_non_dependent_init (value
, tf_warning_or_error
,
909 /*manifestly_const_eval=*/true, decl
);
910 poison_mutable_constructors (value
);
911 const_init
= (reduced_constant_expression_p (value
)
912 || error_operand_p (value
));
913 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = const_init
;
914 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
915 if (!TYPE_REF_P (type
))
916 TREE_CONSTANT (decl
) = const_init
&& decl_maybe_constant_var_p (decl
);
920 /* Don't fold initializers of automatic variables in constexpr functions,
921 that might fold away something that needs to be diagnosed at constexpr
923 if (!current_function_decl
924 || !DECL_DECLARED_CONSTEXPR_P (current_function_decl
)
925 || TREE_STATIC (decl
))
926 value
= cp_fully_fold_init (value
);
928 /* Handle aggregate NSDMI in non-constant initializers, too. */
929 value
= replace_placeholders (value
, decl
);
931 /* A COMPOUND_LITERAL_P CONSTRUCTOR is the syntactic form; by the time we get
932 here it should have been digested into an actual value for the type. */
933 gcc_checking_assert (TREE_CODE (value
) != CONSTRUCTOR
934 || processing_template_decl
935 || VECTOR_TYPE_P (type
)
936 || !TREE_HAS_CONSTRUCTOR (value
));
938 /* If the initializer is not a constant, fill in DECL_INITIAL with
939 the bits that are constant, and then return an expression that
940 will perform the dynamic initialization. */
941 if (value
!= error_mark_node
942 && !processing_template_decl
943 && (TREE_SIDE_EFFECTS (value
)
945 || ! reduced_constant_expression_p (value
)))
946 return split_nonconstant_init (decl
, value
);
948 /* DECL may change value; purge caches. */
949 clear_cv_and_fold_caches ();
951 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
952 is an automatic variable, the middle end will turn this into a
953 dynamic initialization later. */
954 DECL_INITIAL (decl
) = value
;
959 /* Give diagnostic about narrowing conversions within { }, or as part of
960 a converted constant expression. If CONST_ONLY, only check
964 check_narrowing (tree type
, tree init
, tsubst_flags_t complain
,
965 bool const_only
/*= false*/)
967 tree ftype
= unlowered_expr_type (init
);
971 if (((!warn_narrowing
|| !(complain
& tf_warning
))
972 && cxx_dialect
== cxx98
)
973 || !ARITHMETIC_TYPE_P (type
)
974 /* Don't emit bogus warnings with e.g. value-dependent trees. */
975 || instantiation_dependent_expression_p (init
))
978 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
979 && TREE_CODE (type
) == COMPLEX_TYPE
)
981 tree elttype
= TREE_TYPE (type
);
982 if (CONSTRUCTOR_NELTS (init
) > 0)
983 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 0)->value
,
985 if (CONSTRUCTOR_NELTS (init
) > 1)
986 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 1)->value
,
991 /* Even non-dependent expressions can still have template
992 codes like CAST_EXPR, so use *_non_dependent_expr to cope. */
993 init
= fold_non_dependent_expr (init
, complain
, /*manifest*/true);
994 if (init
== error_mark_node
)
997 /* If we were asked to only check constants, return early. */
998 if (const_only
&& !TREE_CONSTANT (init
))
1001 if (CP_INTEGRAL_TYPE_P (type
)
1002 && SCALAR_FLOAT_TYPE_P (ftype
))
1004 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
1005 && CP_INTEGRAL_TYPE_P (type
))
1007 if (TREE_CODE (ftype
) == ENUMERAL_TYPE
)
1008 /* Check for narrowing based on the values of the enumeration. */
1009 ftype
= ENUM_UNDERLYING_TYPE (ftype
);
1010 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type
),
1011 TYPE_MAX_VALUE (ftype
))
1012 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype
),
1013 TYPE_MIN_VALUE (type
)))
1014 && (TREE_CODE (init
) != INTEGER_CST
1015 || !int_fits_type_p (init
, type
)))
1018 /* [dcl.init.list]#7.2: "from long double to double or float, or from
1019 double to float". */
1020 else if (SCALAR_FLOAT_TYPE_P (ftype
)
1021 && SCALAR_FLOAT_TYPE_P (type
))
1023 if ((extended_float_type_p (ftype
) || extended_float_type_p (type
))
1024 ? /* "from a floating-point type T to another floating-point type
1025 whose floating-point conversion rank is neither greater than
1026 nor equal to that of T".
1028 cp_compare_floating_point_conversion_ranks (ftype, type)
1029 returns -2 (type has greater conversion rank than ftype)
1030 or [-1..1] (type has equal conversion rank as ftype, possibly
1031 different subrank. Only do this if at least one of the
1032 types is extended floating-point type, otherwise keep doing
1033 what we did before (for the sake of non-standard
1035 cp_compare_floating_point_conversion_ranks (ftype
, type
) >= 2
1036 : ((same_type_p (ftype
, long_double_type_node
)
1037 && (same_type_p (type
, double_type_node
)
1038 || same_type_p (type
, float_type_node
)))
1039 || (same_type_p (ftype
, double_type_node
)
1040 && same_type_p (type
, float_type_node
))
1041 || (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))))
1043 if (TREE_CODE (init
) == REAL_CST
)
1045 /* Issue 703: Loss of precision is OK as long as the value is
1046 within the representable range of the new type. */
1048 d
= TREE_REAL_CST (init
);
1049 real_convert (&r
, TYPE_MODE (type
), &d
);
1050 if (real_isinf (&r
))
1057 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
1058 && SCALAR_FLOAT_TYPE_P (type
))
1061 if (TREE_CODE (init
) == INTEGER_CST
)
1063 d
= real_value_from_int_cst (0, init
);
1064 if (exact_real_truncate (TYPE_MODE (type
), &d
))
1068 else if (TREE_CODE (type
) == BOOLEAN_TYPE
1069 && (TYPE_PTR_P (ftype
) || TYPE_PTRMEM_P (ftype
)))
1070 /* C++20 P1957R2: converting from a pointer type or a pointer-to-member
1071 type to bool should be considered narrowing. This is a DR so is not
1072 limited to C++20 only. */
1075 bool almost_ok
= ok
;
1076 if (!ok
&& !CONSTANT_CLASS_P (init
) && (complain
& tf_warning_or_error
))
1078 tree folded
= cp_fully_fold (init
);
1079 if (TREE_CONSTANT (folded
) && check_narrowing (type
, folded
, tf_none
))
1085 location_t loc
= cp_expr_loc_or_input_loc (init
);
1086 if (cxx_dialect
== cxx98
)
1088 if (complain
& tf_warning
)
1089 warning_at (loc
, OPT_Wnarrowing
, "narrowing conversion of %qE "
1090 "from %qH to %qI is ill-formed in C++11",
1094 else if (!CONSTANT_CLASS_P (init
))
1096 if (complain
& tf_warning_or_error
)
1098 auto_diagnostic_group d
;
1099 if ((!almost_ok
|| pedantic
)
1100 && pedwarn (loc
, OPT_Wnarrowing
,
1101 "narrowing conversion of %qE from %qH to %qI",
1104 inform (loc
, " the expression has a constant value but is not "
1105 "a C++ constant-expression");
1109 else if (complain
& tf_error
)
1111 int savederrorcount
= errorcount
;
1112 permerror_opt (loc
, OPT_Wnarrowing
,
1113 "narrowing conversion of %qE from %qH to %qI",
1115 if (errorcount
== savederrorcount
)
1123 /* True iff TYPE is a C++20 "ordinary" character type. */
1126 ordinary_char_type_p (tree type
)
1128 type
= TYPE_MAIN_VARIANT (type
);
1129 return (type
== char_type_node
1130 || type
== signed_char_type_node
1131 || type
== unsigned_char_type_node
);
1134 /* True iff the string literal INIT has a type suitable for initializing array
1138 array_string_literal_compatible_p (tree type
, tree init
)
1140 tree to_char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1141 tree from_char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
1143 if (to_char_type
== from_char_type
)
1145 /* The array element type does not match the initializing string
1146 literal element type; this is only allowed when both types are
1147 ordinary character type. There are no string literals of
1148 signed or unsigned char type in the language, but we can get
1149 them internally from converting braced-init-lists to
1151 if (ordinary_char_type_p (to_char_type
)
1152 && ordinary_char_type_p (from_char_type
))
1155 /* P2513 (C++20/C++23): "an array of char or unsigned char may
1156 be initialized by a UTF-8 string literal, or by such a string
1157 literal enclosed in braces." */
1158 if (from_char_type
== char8_type_node
1159 && (to_char_type
== char_type_node
1160 || to_char_type
== unsigned_char_type_node
))
1166 /* Process the initializer INIT for a variable of type TYPE, emitting
1167 diagnostics for invalid initializers and converting the initializer as
1170 For aggregate types, it assumes that reshape_init has already run, thus the
1171 initializer will have the right shape (brace elision has been undone).
1173 NESTED is non-zero iff we are being called for an element of a CONSTRUCTOR,
1174 2 iff the element of a CONSTRUCTOR is inside another CONSTRUCTOR. */
1177 digest_init_r (tree type
, tree init
, int nested
, int flags
,
1178 tsubst_flags_t complain
)
1180 enum tree_code code
= TREE_CODE (type
);
1182 if (error_operand_p (init
))
1183 return error_mark_node
;
1187 /* We must strip the outermost array type when completing the type,
1188 because the its bounds might be incomplete at the moment. */
1189 if (!complete_type_or_maybe_complain (code
== ARRAY_TYPE
1190 ? TREE_TYPE (type
) : type
, NULL_TREE
,
1192 return error_mark_node
;
1194 location_t loc
= cp_expr_loc_or_input_loc (init
);
1196 tree stripped_init
= init
;
1198 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1199 && CONSTRUCTOR_IS_PAREN_INIT (init
))
1200 flags
|= LOOKUP_AGGREGATE_PAREN_INIT
;
1202 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
1203 (g++.old-deja/g++.law/casts2.C). */
1204 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
1205 stripped_init
= TREE_OPERAND (init
, 0);
1207 stripped_init
= tree_strip_any_location_wrapper (stripped_init
);
1209 /* Initialization of an array of chars from a string constant. The initializer
1210 can be optionally enclosed in braces, but reshape_init has already removed
1211 them if they were present. */
1212 if (code
== ARRAY_TYPE
)
1214 if (nested
&& !TYPE_DOMAIN (type
))
1215 /* C++ flexible array members have a null domain. */
1217 if (flags
& LOOKUP_ALLOW_FLEXARRAY_INIT
)
1218 pedwarn (loc
, OPT_Wpedantic
,
1219 "initialization of a flexible array member");
1222 if (complain
& tf_error
)
1223 error_at (loc
, "non-static initialization of"
1224 " a flexible array member");
1225 return error_mark_node
;
1229 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1230 if (char_type_p (typ1
)
1231 && TREE_CODE (stripped_init
) == STRING_CST
)
1233 if (!array_string_literal_compatible_p (type
, init
))
1235 if (complain
& tf_error
)
1236 error_at (loc
, "cannot initialize array of %qT from "
1237 "a string literal with type array of %qT",
1239 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
))));
1240 return error_mark_node
;
1243 if (nested
== 2 && !TYPE_DOMAIN (type
))
1245 if (complain
& tf_error
)
1246 error_at (loc
, "initialization of flexible array member "
1247 "in a nested context");
1248 return error_mark_node
;
1251 if (type
!= TREE_TYPE (init
)
1252 && !variably_modified_type_p (type
, NULL_TREE
))
1254 init
= copy_node (init
);
1255 TREE_TYPE (init
) = type
;
1256 /* If we have a location wrapper, then also copy the wrapped
1257 node, and update the copy's type. */
1258 if (location_wrapper_p (init
))
1260 stripped_init
= copy_node (stripped_init
);
1261 TREE_OPERAND (init
, 0) = stripped_init
;
1262 TREE_TYPE (stripped_init
) = type
;
1265 if (TYPE_DOMAIN (type
) && TREE_CONSTANT (TYPE_SIZE (type
)))
1267 /* Not a flexible array member. */
1268 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
1269 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
1270 /* In C it is ok to subtract 1 from the length of the string
1271 because it's ok to ignore the terminating null char that is
1272 counted in the length of the constant, but in C++ this would
1274 if (size
< TREE_STRING_LENGTH (stripped_init
))
1276 permerror (loc
, "initializer-string for %qT is too long",
1279 init
= build_string (size
,
1280 TREE_STRING_POINTER (stripped_init
));
1281 TREE_TYPE (init
) = type
;
1288 /* Handle scalar types (including conversions) and references. */
1289 if ((code
!= COMPLEX_TYPE
|| BRACE_ENCLOSED_INITIALIZER_P (stripped_init
))
1290 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
1292 /* Narrowing is OK when initializing an aggregate from
1293 a parenthesized list. */
1294 if (nested
&& !(flags
& LOOKUP_AGGREGATE_PAREN_INIT
))
1295 flags
|= LOOKUP_NO_NARROWING
;
1296 init
= convert_for_initialization (0, type
, init
, flags
,
1297 ICR_INIT
, NULL_TREE
, 0,
1303 /* Come here only for aggregates: records, arrays, unions, complex numbers
1305 gcc_assert (code
== ARRAY_TYPE
1306 || VECTOR_TYPE_P (type
)
1307 || code
== RECORD_TYPE
1308 || code
== UNION_TYPE
1309 || code
== OPAQUE_TYPE
1310 || code
== COMPLEX_TYPE
);
1312 /* "If T is a class type and the initializer list has a single
1313 element of type cv U, where U is T or a class derived from T,
1314 the object is initialized from that element." */
1315 if (cxx_dialect
>= cxx11
1316 && BRACE_ENCLOSED_INITIALIZER_P (stripped_init
)
1317 && !CONSTRUCTOR_IS_DESIGNATED_INIT (stripped_init
)
1318 && CONSTRUCTOR_NELTS (stripped_init
) == 1
1319 && ((CLASS_TYPE_P (type
) && !CLASSTYPE_NON_AGGREGATE (type
))
1320 || VECTOR_TYPE_P (type
)))
1322 tree elt
= CONSTRUCTOR_ELT (stripped_init
, 0)->value
;
1323 if (reference_related_p (type
, TREE_TYPE (elt
)))
1325 /* In C++17, aggregates can have bases, thus participate in
1326 aggregate initialization. In the following case:
1328 struct B { int c; };
1332 there's an extra set of braces, so the D temporary initializes
1333 the first element of d, which is the B base subobject. The base
1334 of type B is copy-initialized from the D temporary, causing
1336 tree field
= next_aggregate_field (TYPE_FIELDS (type
));
1337 if (field
&& DECL_FIELD_IS_BASE (field
))
1339 if (warning_at (loc
, 0, "initializing a base class of type %qT "
1340 "results in object slicing", TREE_TYPE (field
)))
1341 inform (loc
, "remove %<{ }%> around initializer");
1343 else if (flag_checking
)
1344 /* We should have fixed this in reshape_init. */
1349 if (SIMPLE_TARGET_EXPR_P (stripped_init
))
1350 stripped_init
= TARGET_EXPR_INITIAL (stripped_init
);
1352 if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init
)
1353 && !TYPE_NON_AGGREGATE_CLASS (type
))
1354 return process_init_constructor (type
, stripped_init
, nested
, flags
,
1358 if (COMPOUND_LITERAL_P (stripped_init
) && code
== ARRAY_TYPE
)
1360 if (complain
& tf_error
)
1361 error_at (loc
, "cannot initialize aggregate of type %qT with "
1362 "a compound literal", type
);
1364 return error_mark_node
;
1367 if (code
== ARRAY_TYPE
1368 && !BRACE_ENCLOSED_INITIALIZER_P (stripped_init
))
1370 /* Allow the result of build_array_copy and of
1371 build_value_init_noctor. */
1372 if ((TREE_CODE (stripped_init
) == VEC_INIT_EXPR
1373 || TREE_CODE (stripped_init
) == CONSTRUCTOR
)
1374 && (same_type_ignoring_top_level_qualifiers_p
1375 (type
, TREE_TYPE (init
))))
1378 if (complain
& tf_error
)
1379 error_at (loc
, "array must be initialized with a brace-enclosed"
1381 return error_mark_node
;
1384 return convert_for_initialization (NULL_TREE
, type
, init
,
1386 ICR_INIT
, NULL_TREE
, 0,
1392 digest_init (tree type
, tree init
, tsubst_flags_t complain
)
1394 return digest_init_r (type
, init
, 0, LOOKUP_IMPLICIT
, complain
);
1398 digest_init_flags (tree type
, tree init
, int flags
, tsubst_flags_t complain
)
1400 return digest_init_r (type
, init
, 0, flags
, complain
);
1403 /* Return true if SUBOB initializes the same object as FULL_EXPR.
1406 A a = A{}; // initializer
1407 A a = (A{}); // initializer
1408 A a = (1, A{}); // initializer
1409 A a = true ? A{} : A{}; // initializer
1410 auto x = A{}.x; // temporary materialization
1411 auto x = foo(A{}); // temporary materialization
1413 FULL_EXPR is the whole expression, SUBOB is its TARGET_EXPR subobject. */
1416 potential_prvalue_result_of (tree subob
, tree full_expr
)
1418 if (subob
== full_expr
)
1420 else if (TREE_CODE (full_expr
) == TARGET_EXPR
)
1422 tree init
= TARGET_EXPR_INITIAL (full_expr
);
1423 if (TREE_CODE (init
) == COND_EXPR
)
1424 return (potential_prvalue_result_of (subob
, TREE_OPERAND (init
, 1))
1425 || potential_prvalue_result_of (subob
, TREE_OPERAND (init
, 2)));
1426 else if (TREE_CODE (init
) == COMPOUND_EXPR
)
1427 return potential_prvalue_result_of (subob
, TREE_OPERAND (init
, 1));
1428 /* ??? I don't know if this can be hit. */
1429 else if (TREE_CODE (init
) == PAREN_EXPR
)
1431 gcc_checking_assert (false);
1432 return potential_prvalue_result_of (subob
, TREE_OPERAND (init
, 0));
1438 /* Callback to replace PLACEHOLDER_EXPRs in a TARGET_EXPR (which isn't used
1439 in the context of guaranteed copy elision). */
1442 replace_placeholders_for_class_temp_r (tree
*tp
, int *, void *data
)
1445 tree full_expr
= *static_cast<tree
*>(data
);
1447 /* We're looking for a TARGET_EXPR nested in the whole expression. */
1448 if (TREE_CODE (t
) == TARGET_EXPR
1449 && !potential_prvalue_result_of (t
, full_expr
))
1451 tree init
= TARGET_EXPR_INITIAL (t
);
1452 while (TREE_CODE (init
) == COMPOUND_EXPR
)
1453 init
= TREE_OPERAND (init
, 1);
1454 if (TREE_CODE (init
) == CONSTRUCTOR
1455 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
))
1457 tree obj
= TARGET_EXPR_SLOT (t
);
1458 replace_placeholders (init
, obj
);
1459 /* We should have dealt with all PLACEHOLDER_EXPRs. */
1460 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = false;
1461 gcc_checking_assert (!find_placeholders (init
));
1468 /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL). */
1470 digest_nsdmi_init (tree decl
, tree init
, tsubst_flags_t complain
)
1472 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1474 tree type
= TREE_TYPE (decl
);
1475 if (DECL_BIT_FIELD_TYPE (decl
))
1476 type
= DECL_BIT_FIELD_TYPE (decl
);
1477 int flags
= LOOKUP_IMPLICIT
;
1478 if (DIRECT_LIST_INIT_P (init
))
1480 flags
= LOOKUP_NORMAL
;
1481 complain
|= tf_no_cleanup
;
1483 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1484 && CP_AGGREGATE_TYPE_P (type
))
1485 init
= reshape_init (type
, init
, complain
);
1486 init
= digest_init_flags (type
, init
, flags
, complain
);
1487 set_target_expr_eliding (init
);
1489 /* We may have temporary materialization in a NSDMI, if the initializer
1490 has something like A{} in it. Digesting the {} could have introduced
1491 a PLACEHOLDER_EXPR referring to A. Now that we've got a TARGET_EXPR,
1492 we have an object we can refer to. The reason we bother doing this
1493 here is for code like
1502 int y = A{x}.y; // #1
1505 where in #1 we don't want to end up with two PLACEHOLDER_EXPRs for
1506 different types on the same level in a {} when lookup_placeholder
1507 wouldn't find a named object for the PLACEHOLDER_EXPR for A. Note,
1508 temporary materialization does not occur when initializing an object
1509 from a prvalue of the same type, therefore we must not replace the
1510 placeholder with a temporary object so that it can be elided. */
1511 cp_walk_tree (&init
, replace_placeholders_for_class_temp_r
, &init
,
1517 /* Set of flags used within process_init_constructor to describe the
1519 #define PICFLAG_ERRONEOUS 1
1520 #define PICFLAG_NOT_ALL_CONSTANT 2
1521 #define PICFLAG_NOT_ALL_SIMPLE 4
1522 #define PICFLAG_SIDE_EFFECTS 8
1523 #define PICFLAG_VEC_INIT 16
1525 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1529 picflag_from_initializer (tree init
)
1531 if (init
== error_mark_node
)
1532 return PICFLAG_ERRONEOUS
;
1533 else if (!TREE_CONSTANT (init
))
1535 if (TREE_SIDE_EFFECTS (init
))
1536 return PICFLAG_SIDE_EFFECTS
;
1538 return PICFLAG_NOT_ALL_CONSTANT
;
1540 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
1541 return PICFLAG_NOT_ALL_SIMPLE
;
1545 /* Adjust INIT for going into a CONSTRUCTOR. */
1548 massage_init_elt (tree type
, tree init
, int nested
, int flags
,
1549 tsubst_flags_t complain
)
1551 int new_flags
= LOOKUP_IMPLICIT
;
1552 if (flags
& LOOKUP_ALLOW_FLEXARRAY_INIT
)
1553 new_flags
|= LOOKUP_ALLOW_FLEXARRAY_INIT
;
1554 if (flags
& LOOKUP_AGGREGATE_PAREN_INIT
)
1555 new_flags
|= LOOKUP_AGGREGATE_PAREN_INIT
;
1556 init
= digest_init_r (type
, init
, nested
? 2 : 1, new_flags
, complain
);
1557 /* When we defer constant folding within a statement, we may want to
1558 defer this folding as well. Don't call this on CONSTRUCTORs because
1559 their elements have already been folded, and we must avoid folding
1560 the result of get_nsdmi. */
1561 if (TREE_CODE (init
) != CONSTRUCTOR
)
1563 tree t
= fold_non_dependent_init (init
, complain
);
1564 if (TREE_CONSTANT (t
))
1566 set_target_expr_eliding (init
);
1571 /* Subroutine of process_init_constructor, which will process an initializer
1572 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1573 which describe the initializers. */
1576 process_init_constructor_array (tree type
, tree init
, int nested
, int flags
,
1577 tsubst_flags_t complain
)
1579 unsigned HOST_WIDE_INT i
, len
= 0;
1581 bool unbounded
= false;
1582 constructor_elt
*ce
;
1583 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (init
);
1585 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1586 || VECTOR_TYPE_P (type
));
1588 if (TREE_CODE (type
) == ARRAY_TYPE
)
1590 /* C++ flexible array members have a null domain. */
1591 tree domain
= TYPE_DOMAIN (type
);
1592 if (domain
&& TREE_CONSTANT (TYPE_MAX_VALUE (domain
)))
1593 len
= wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain
))
1594 - wi::to_offset (TYPE_MIN_VALUE (domain
)) + 1,
1595 TYPE_PRECISION (TREE_TYPE (domain
)),
1596 TYPE_SIGN (TREE_TYPE (domain
))).to_uhwi ();
1598 unbounded
= true; /* Take as many as there are. */
1600 if (nested
== 2 && !domain
&& !vec_safe_is_empty (v
))
1602 if (complain
& tf_error
)
1603 error_at (cp_expr_loc_or_input_loc (init
),
1604 "initialization of flexible array member "
1605 "in a nested context");
1606 return PICFLAG_ERRONEOUS
;
1610 /* Vectors are like simple fixed-size arrays. */
1611 unbounded
= !TYPE_VECTOR_SUBPARTS (type
).is_constant (&len
);
1613 /* There must not be more initializers than needed. */
1614 if (!unbounded
&& vec_safe_length (v
) > len
)
1616 if (complain
& tf_error
)
1617 error ("too many initializers for %qT", type
);
1619 return PICFLAG_ERRONEOUS
;
1622 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
1625 ce
->index
= size_int (i
);
1626 else if (!check_array_designated_initializer (ce
, i
))
1627 ce
->index
= error_mark_node
;
1628 gcc_assert (ce
->value
);
1630 = massage_init_elt (TREE_TYPE (type
), ce
->value
, nested
, flags
,
1634 (ce
->value
== error_mark_node
1635 || (same_type_ignoring_top_level_qualifiers_p
1636 (strip_array_types (TREE_TYPE (type
)),
1637 strip_array_types (TREE_TYPE (ce
->value
)))));
1639 picflags
|= picflag_from_initializer (ce
->value
);
1640 /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer
1642 if (TREE_CODE (ce
->value
) == CONSTRUCTOR
1643 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce
->value
))
1645 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1646 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce
->value
) = 0;
1650 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1651 we must add initializers ourselves. */
1653 for (; i
< len
; ++i
)
1657 if (type_build_ctor_call (TREE_TYPE (type
)))
1659 /* If this type needs constructors run for default-initialization,
1660 we can't rely on the back end to do it for us, so make the
1661 initialization explicit by list-initializing from T{}. */
1662 next
= build_constructor (init_list_type_node
, NULL
);
1663 next
= massage_init_elt (TREE_TYPE (type
), next
, nested
, flags
,
1665 if (initializer_zerop (next
))
1666 /* The default zero-initialization is fine for us; don't
1667 add anything to the CONSTRUCTOR. */
1670 else if (!zero_init_p (TREE_TYPE (type
)))
1671 next
= build_zero_init (TREE_TYPE (type
),
1672 /*nelts=*/NULL_TREE
,
1673 /*static_storage_p=*/false);
1675 /* The default zero-initialization is fine for us; don't
1676 add anything to the CONSTRUCTOR. */
1681 if (next
!= error_mark_node
1682 && (initializer_constant_valid_p (next
, TREE_TYPE (next
))
1683 != null_pointer_node
))
1685 /* Use VEC_INIT_EXPR for non-constant initialization of
1686 trailing elements with no explicit initializers. */
1687 picflags
|= PICFLAG_VEC_INIT
;
1691 picflags
|= picflag_from_initializer (next
);
1692 /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer
1694 if (TREE_CODE (next
) == CONSTRUCTOR
1695 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next
))
1697 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1698 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next
) = 0;
1702 tree range
= build2 (RANGE_EXPR
, size_type_node
,
1703 build_int_cst (size_type_node
, i
),
1704 build_int_cst (size_type_node
, len
- 1));
1705 CONSTRUCTOR_APPEND_ELT (v
, range
, next
);
1709 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1712 /* Don't bother checking all the other elements. */
1716 CONSTRUCTOR_ELTS (init
) = v
;
1720 /* Subroutine of process_init_constructor, which will process an initializer
1721 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1722 the initializers. */
1725 process_init_constructor_record (tree type
, tree init
, int nested
, int flags
,
1726 tsubst_flags_t complain
)
1728 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1732 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1733 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1734 gcc_assert (!TYPE_BINFO (type
)
1735 || cxx_dialect
>= cxx17
1736 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1737 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1741 unsigned HOST_WIDE_INT idx
= 0;
1742 int designator_skip
= -1;
1743 /* Generally, we will always have an index for each initializer (which is
1744 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1745 reshape_init. So we need to handle both cases. */
1746 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1750 if (TREE_CODE (field
) != FIELD_DECL
1751 || (DECL_ARTIFICIAL (field
)
1752 && !(cxx_dialect
>= cxx17
&& DECL_FIELD_IS_BASE (field
))))
1755 if (DECL_UNNAMED_BIT_FIELD (field
))
1758 /* If this is a bitfield, first convert to the declared type. */
1759 tree fldtype
= TREE_TYPE (field
);
1760 if (DECL_BIT_FIELD_TYPE (field
))
1761 fldtype
= DECL_BIT_FIELD_TYPE (field
);
1762 if (fldtype
== error_mark_node
)
1763 return PICFLAG_ERRONEOUS
;
1766 if (idx
< CONSTRUCTOR_NELTS (init
))
1768 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1771 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1772 latter case can happen in templates where lookup has to be
1774 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1775 || identifier_p (ce
->index
));
1776 if (ce
->index
== field
|| ce
->index
== DECL_NAME (field
))
1781 if (designator_skip
== -1)
1782 designator_skip
= 1;
1787 designator_skip
= 0;
1793 gcc_assert (ce
->value
);
1794 next
= massage_init_elt (fldtype
, next
, nested
, flags
, complain
);
1795 /* We can't actually elide the temporary when initializing a
1796 potentially-overlapping field from a function that returns by
1799 && TREE_CODE (next
) == TARGET_EXPR
1800 && unsafe_copy_elision_p (ce
->index
, next
))
1801 TARGET_EXPR_ELIDING_P (next
) = false;
1805 if (next
== error_mark_node
)
1806 /* We skip initializers for empty bases/fields, so skipping an invalid
1807 one could make us accept invalid code. */
1808 return PICFLAG_ERRONEOUS
;
1810 /* Already handled above. */;
1811 else if (DECL_INITIAL (field
))
1815 /* We're using an NSDMI past a field with implicit
1816 zero-init. Go back and make it explicit. */
1818 vec_safe_truncate (v
, 0);
1821 /* C++14 aggregate NSDMI. */
1822 next
= get_nsdmi (field
, /*ctor*/false, complain
);
1823 if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
)
1824 && find_placeholders (next
))
1825 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1827 else if (type_build_ctor_call (fldtype
))
1829 /* If this type needs constructors run for
1830 default-initialization, we can't rely on the back end to do it
1831 for us, so build up TARGET_EXPRs. If the type in question is
1832 a class, just build one up; if it's an array, recurse. */
1833 next
= build_constructor (init_list_type_node
, NULL
);
1834 next
= massage_init_elt (fldtype
, next
, nested
, flags
, complain
);
1835 if (TREE_CODE (next
) == TARGET_EXPR
1836 && unsafe_copy_elision_p (field
, next
))
1837 TARGET_EXPR_ELIDING_P (next
) = false;
1839 /* Warn when some struct elements are implicitly initialized. */
1840 if ((complain
& tf_warning
)
1841 && !cp_unevaluated_operand
1842 && !EMPTY_CONSTRUCTOR_P (init
))
1843 warning (OPT_Wmissing_field_initializers
,
1844 "missing initializer for member %qD", field
);
1848 if (TYPE_REF_P (fldtype
))
1850 if (complain
& tf_error
)
1851 error ("member %qD is uninitialized reference", field
);
1853 return PICFLAG_ERRONEOUS
;
1855 else if (CLASSTYPE_REF_FIELDS_NEED_INIT (fldtype
))
1857 if (complain
& tf_error
)
1858 error ("member %qD with uninitialized reference fields", field
);
1860 return PICFLAG_ERRONEOUS
;
1862 /* Do nothing for flexible array members since they need not have any
1863 elements. Don't worry about 'skipped' because a flexarray has to
1864 be the last field. */
1865 else if (TREE_CODE (fldtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (fldtype
))
1868 /* Warn when some struct elements are implicitly initialized
1870 if ((complain
& tf_warning
)
1871 && !cp_unevaluated_operand
1872 && !EMPTY_CONSTRUCTOR_P (init
)
1873 && !is_really_empty_class (fldtype
, /*ignore_vptr*/false))
1874 warning (OPT_Wmissing_field_initializers
,
1875 "missing initializer for member %qD", field
);
1877 if (!zero_init_p (fldtype
) || skipped
< 0)
1879 if (TYPE_REF_P (fldtype
))
1880 next
= build_zero_cst (fldtype
);
1882 next
= build_zero_init (fldtype
, /*nelts=*/NULL_TREE
,
1883 /*static_storage_p=*/false);
1887 /* The default zero-initialization is fine for us; don't
1888 add anything to the CONSTRUCTOR. */
1894 if (is_empty_field (field
)
1895 && !TREE_SIDE_EFFECTS (next
))
1896 /* Don't add trivial initialization of an empty base/field to the
1897 constructor, as they might not be ordered the way the back-end
1901 /* If this is a bitfield, now convert to the lowered type. */
1902 if (fldtype
!= TREE_TYPE (field
))
1903 next
= cp_convert_and_check (TREE_TYPE (field
), next
, complain
);
1904 picflags
|= picflag_from_initializer (next
);
1905 /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer CONSTRUCTOR. */
1906 if (TREE_CODE (next
) == CONSTRUCTOR
1907 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next
))
1909 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1910 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next
) = 0;
1912 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1915 if (idx
< CONSTRUCTOR_NELTS (init
))
1917 if (complain
& tf_error
)
1919 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1920 /* For better diagnostics, try to find out if it is really
1921 the case of too many initializers or if designators are
1922 in incorrect order. */
1923 if (designator_skip
== 1 && ce
->index
)
1925 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1926 || identifier_p (ce
->index
));
1927 for (field
= TYPE_FIELDS (type
);
1928 field
; field
= DECL_CHAIN (field
))
1930 if (TREE_CODE (field
) != FIELD_DECL
1931 || (DECL_ARTIFICIAL (field
)
1932 && !(cxx_dialect
>= cxx17
1933 && DECL_FIELD_IS_BASE (field
))))
1936 if (DECL_UNNAMED_BIT_FIELD (field
))
1939 if (ce
->index
== field
|| ce
->index
== DECL_NAME (field
))
1944 error ("designator order for field %qD does not match declaration "
1945 "order in %qT", field
, type
);
1947 error ("too many initializers for %qT", type
);
1950 return PICFLAG_ERRONEOUS
;
1953 CONSTRUCTOR_ELTS (init
) = v
;
1957 /* Subroutine of process_init_constructor, which will process a single
1958 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1959 which describe the initializer. */
1962 process_init_constructor_union (tree type
, tree init
, int nested
, int flags
,
1963 tsubst_flags_t complain
)
1965 constructor_elt
*ce
;
1968 /* If the initializer was empty, use the union's NSDMI if it has one.
1969 Otherwise use default zero initialization. */
1970 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1972 for (tree field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1974 if (TREE_CODE (field
) == FIELD_DECL
1975 && DECL_INITIAL (field
) != NULL_TREE
)
1977 tree val
= get_nsdmi (field
, /*in_ctor=*/false, complain
);
1978 if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
)
1979 && find_placeholders (val
))
1980 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1981 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init
), field
, val
);
1986 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1990 len
= CONSTRUCTOR_ELTS (init
)->length ();
1993 if (!(complain
& tf_error
))
1994 return PICFLAG_ERRONEOUS
;
1995 error ("too many initializers for %qT", type
);
1996 CONSTRUCTOR_ELTS (init
)->block_remove (1, len
-1);
1999 ce
= &(*CONSTRUCTOR_ELTS (init
))[0];
2001 /* If this element specifies a field, initialize via that field. */
2004 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
2006 else if (identifier_p (ce
->index
))
2008 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
2009 tree name
= ce
->index
;
2011 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
2012 if (DECL_NAME (field
) == name
)
2016 if (complain
& tf_error
)
2017 error ("no field %qD found in union being initialized",
2019 ce
->value
= error_mark_node
;
2025 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
2026 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
2027 if (complain
& tf_error
)
2028 error ("index value instead of field name in union initializer");
2029 ce
->value
= error_mark_node
;
2034 /* Find the first named field. ANSI decided in September 1990
2035 that only named fields count here. */
2036 tree field
= TYPE_FIELDS (type
);
2037 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
2038 field
= TREE_CHAIN (field
);
2039 if (field
== NULL_TREE
)
2041 if (complain
& tf_error
)
2042 error ("too many initializers for %qT", type
);
2043 ce
->value
= error_mark_node
;
2048 if (ce
->value
&& ce
->value
!= error_mark_node
)
2049 ce
->value
= massage_init_elt (TREE_TYPE (ce
->index
), ce
->value
, nested
,
2052 /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer CONSTRUCTOR. */
2054 && TREE_CODE (ce
->value
) == CONSTRUCTOR
2055 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce
->value
))
2057 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
2058 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce
->value
) = 0;
2060 return picflag_from_initializer (ce
->value
);
2063 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
2064 constructor is a brace-enclosed initializer, and will be modified in-place.
2066 Each element is converted to the right type through digest_init, and
2067 missing initializers are added following the language rules (zero-padding,
2070 After the execution, the initializer will have TREE_CONSTANT if all elts are
2071 constant, and TREE_STATIC set if, in addition, all elts are simple enough
2072 constants that the assembler and linker can compute them.
2074 The function returns the initializer itself, or error_mark_node in case
2078 process_init_constructor (tree type
, tree init
, int nested
, int flags
,
2079 tsubst_flags_t complain
)
2083 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
2085 if (TREE_CODE (type
) == ARRAY_TYPE
|| VECTOR_TYPE_P (type
))
2086 picflags
= process_init_constructor_array (type
, init
, nested
, flags
,
2088 else if (TREE_CODE (type
) == RECORD_TYPE
)
2089 picflags
= process_init_constructor_record (type
, init
, nested
, flags
,
2091 else if (TREE_CODE (type
) == UNION_TYPE
)
2092 picflags
= process_init_constructor_union (type
, init
, nested
, flags
,
2097 if (picflags
& PICFLAG_ERRONEOUS
)
2098 return error_mark_node
;
2100 TREE_TYPE (init
) = type
;
2101 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
2102 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
2103 if (picflags
& PICFLAG_SIDE_EFFECTS
)
2105 TREE_CONSTANT (init
) = false;
2106 TREE_SIDE_EFFECTS (init
) = true;
2108 else if (picflags
& PICFLAG_NOT_ALL_CONSTANT
)
2110 /* Make sure TREE_CONSTANT isn't set from build_constructor. */
2111 TREE_CONSTANT (init
) = false;
2112 TREE_SIDE_EFFECTS (init
) = false;
2116 TREE_CONSTANT (init
) = 1;
2117 TREE_SIDE_EFFECTS (init
) = false;
2118 if (!(picflags
& PICFLAG_NOT_ALL_SIMPLE
))
2119 TREE_STATIC (init
) = 1;
2121 if (picflags
& PICFLAG_VEC_INIT
)
2123 /* Defer default-initialization of array elements with no corresponding
2124 initializer-clause until later so we can use a loop. */
2125 TREE_TYPE (init
) = init_list_type_node
;
2126 init
= build_vec_init_expr (type
, init
, complain
);
2127 init
= get_target_expr (init
);
2132 /* Given a structure or union value DATUM, construct and return
2133 the structure or union component which results from narrowing
2134 that value to the base specified in BASETYPE. For example, given the
2137 class L { int ii; };
2138 class A : L { ... };
2139 class B : L { ... };
2140 class C : A, B { ... };
2148 x.A::ii refers to the ii member of the L part of
2149 the A part of the C object named by X. In this case,
2150 DATUM would be x, and BASETYPE would be A.
2152 I used to think that this was nonconformant, that the standard specified
2153 that first we look up ii in A, then convert x to an L& and pull out the
2154 ii part. But in fact, it does say that we convert x to an A&; A here
2155 is known as the "naming class". (jason 2000-12-19)
2157 BINFO_P points to a variable initialized either to NULL_TREE or to the
2158 binfo for the specific base subobject we want to convert to. */
2161 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
2165 if (datum
== error_mark_node
)
2166 return error_mark_node
;
2170 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
,
2171 NULL
, tf_warning_or_error
);
2173 if (!binfo
|| binfo
== error_mark_node
)
2175 *binfo_p
= NULL_TREE
;
2177 error_not_base_type (basetype
, TREE_TYPE (datum
));
2178 return error_mark_node
;
2182 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1,
2183 tf_warning_or_error
);
2186 /* Build a reference to an object specified by the C++ `->' operator.
2187 Usually this just involves dereferencing the object, but if the
2188 `->' operator is overloaded, then such overloads must be
2189 performed until an object which does not have the `->' operator
2190 overloaded is found. An error is reported when circular pointer
2191 delegation is detected. */
2194 build_x_arrow (location_t loc
, tree expr
, tsubst_flags_t complain
)
2196 tree orig_expr
= expr
;
2197 tree type
= TREE_TYPE (expr
);
2198 tree last_rval
= NULL_TREE
;
2199 vec
<tree
, va_gc
> *types_memoized
= NULL
;
2201 if (type
== error_mark_node
)
2202 return error_mark_node
;
2204 if (processing_template_decl
)
2206 tree ttype
= NULL_TREE
;
2207 if (type
&& TYPE_PTR_P (type
))
2208 ttype
= TREE_TYPE (type
);
2209 if (ttype
&& !dependent_scope_p (ttype
))
2210 /* Pointer to current instantiation, don't treat as dependent. */;
2211 else if (type_dependent_expression_p (expr
))
2213 expr
= build_min_nt_loc (loc
, ARROW_EXPR
, expr
);
2214 TREE_TYPE (expr
) = ttype
;
2219 if (MAYBE_CLASS_TYPE_P (type
))
2221 struct tinst_level
*actual_inst
= current_instantiation ();
2224 while ((expr
= build_new_op (loc
, COMPONENT_REF
,
2225 LOOKUP_NORMAL
, expr
, NULL_TREE
, NULL_TREE
,
2226 NULL_TREE
, &fn
, complain
)))
2228 if (expr
== error_mark_node
)
2229 return error_mark_node
;
2231 /* This provides a better instantiation backtrace in case of
2233 if (fn
&& DECL_USE_TEMPLATE (fn
))
2234 push_tinst_level_loc (fn
,
2235 (current_instantiation () != actual_inst
)
2236 ? DECL_SOURCE_LOCATION (fn
)
2240 if (vec_member (TREE_TYPE (expr
), types_memoized
))
2242 if (complain
& tf_error
)
2243 error ("circular pointer delegation detected");
2244 return error_mark_node
;
2247 vec_safe_push (types_memoized
, TREE_TYPE (expr
));
2251 while (current_instantiation () != actual_inst
)
2254 if (last_rval
== NULL_TREE
)
2256 if (complain
& tf_error
)
2257 error ("base operand of %<->%> has non-pointer type %qT", type
);
2258 return error_mark_node
;
2261 if (TYPE_REF_P (TREE_TYPE (last_rval
)))
2262 last_rval
= convert_from_reference (last_rval
);
2266 last_rval
= decay_conversion (expr
, complain
);
2267 if (last_rval
== error_mark_node
)
2268 return error_mark_node
;
2271 if (TYPE_PTR_P (TREE_TYPE (last_rval
)))
2273 if (processing_template_decl
)
2275 expr
= build_min (ARROW_EXPR
, TREE_TYPE (TREE_TYPE (last_rval
)),
2277 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (last_rval
);
2281 return cp_build_indirect_ref (loc
, last_rval
, RO_ARROW
, complain
);
2284 if (complain
& tf_error
)
2287 error ("result of %<operator->()%> yields non-pointer result");
2289 error ("base operand of %<->%> is not a pointer");
2291 return error_mark_node
;
2294 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
2295 already been checked out to be of aggregate type. */
2298 build_m_component_ref (tree datum
, tree component
, tsubst_flags_t complain
)
2306 datum
= mark_lvalue_use (datum
);
2307 component
= mark_rvalue_use (component
);
2309 if (error_operand_p (datum
) || error_operand_p (component
))
2310 return error_mark_node
;
2312 ptrmem_type
= TREE_TYPE (component
);
2313 if (!TYPE_PTRMEM_P (ptrmem_type
))
2315 if (complain
& tf_error
)
2316 error ("%qE cannot be used as a member pointer, since it is of "
2317 "type %qT", component
, ptrmem_type
);
2318 return error_mark_node
;
2321 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
2322 if (! MAYBE_CLASS_TYPE_P (objtype
))
2324 if (complain
& tf_error
)
2325 error ("cannot apply member pointer %qE to %qE, which is of "
2326 "non-class type %qT", component
, datum
, objtype
);
2327 return error_mark_node
;
2330 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
2331 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
2333 if (!COMPLETE_TYPE_P (ctype
))
2335 if (!same_type_p (ctype
, objtype
))
2341 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
, complain
);
2346 if (complain
& tf_error
)
2347 error ("pointer to member type %qT incompatible with object "
2348 "type %qT", type
, objtype
);
2349 return error_mark_node
;
2351 else if (binfo
== error_mark_node
)
2352 return error_mark_node
;
2355 if (TYPE_PTRDATAMEM_P (ptrmem_type
))
2357 bool is_lval
= real_lvalue_p (datum
);
2360 /* Compute the type of the field, as described in [expr.ref].
2361 There's no such thing as a mutable pointer-to-member, so
2362 things are not as complex as they are for references to
2363 non-static data members. */
2364 type
= cp_build_qualified_type (type
,
2365 (cp_type_quals (type
)
2366 | cp_type_quals (TREE_TYPE (datum
))));
2368 datum
= build_address (datum
);
2370 /* Convert object to the correct base. */
2373 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1, complain
);
2374 if (datum
== error_mark_node
)
2375 return error_mark_node
;
2378 /* Build an expression for "object + offset" where offset is the
2379 value stored in the pointer-to-data-member. */
2380 ptype
= build_pointer_type (type
);
2381 datum
= fold_build_pointer_plus (fold_convert (ptype
, datum
), component
);
2382 datum
= cp_build_fold_indirect_ref (datum
);
2383 if (datum
== error_mark_node
)
2384 return error_mark_node
;
2386 /* If the object expression was an rvalue, return an rvalue. */
2388 datum
= move (datum
);
2393 /* 5.5/6: In a .* expression whose object expression is an rvalue, the
2394 program is ill-formed if the second operand is a pointer to member
2395 function with ref-qualifier & (for C++20: unless its cv-qualifier-seq
2396 is const). In a .* expression whose object expression is an lvalue,
2397 the program is ill-formed if the second operand is a pointer to member
2398 function with ref-qualifier &&. */
2399 if (FUNCTION_REF_QUALIFIED (type
))
2401 bool lval
= lvalue_p (datum
);
2402 if (lval
&& FUNCTION_RVALUE_QUALIFIED (type
))
2404 if (complain
& tf_error
)
2405 error ("pointer-to-member-function type %qT requires an rvalue",
2407 return error_mark_node
;
2409 else if (!lval
&& !FUNCTION_RVALUE_QUALIFIED (type
))
2411 if ((type_memfn_quals (type
)
2412 & (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
))
2415 if (complain
& tf_error
)
2416 error ("pointer-to-member-function type %qT requires "
2417 "an lvalue", ptrmem_type
);
2418 return error_mark_node
;
2420 else if (cxx_dialect
< cxx20
)
2422 if (complain
& tf_warning_or_error
)
2423 pedwarn (input_location
, OPT_Wpedantic
,
2424 "pointer-to-member-function type %qT requires "
2425 "an lvalue before C++20", ptrmem_type
);
2427 return error_mark_node
;
2431 return build2 (OFFSET_REF
, type
, datum
, component
);
2435 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
2438 build_functional_cast_1 (location_t loc
, tree exp
, tree parms
,
2439 tsubst_flags_t complain
)
2441 /* This is either a call to a constructor,
2442 or a C cast in C++'s `functional' notation. */
2444 /* The type to which we are casting. */
2447 if (error_operand_p (exp
) || parms
== error_mark_node
)
2448 return error_mark_node
;
2450 if (TREE_CODE (exp
) == TYPE_DECL
)
2452 type
= TREE_TYPE (exp
);
2454 if (DECL_ARTIFICIAL (exp
))
2455 cp_handle_deprecated_or_unavailable (type
);
2460 /* We need to check this explicitly, since value-initialization of
2461 arrays is allowed in other situations. */
2462 if (TREE_CODE (type
) == ARRAY_TYPE
)
2464 if (complain
& tf_error
)
2465 error_at (loc
, "functional cast to array type %qT", type
);
2466 return error_mark_node
;
2469 if (tree anode
= type_uses_auto (type
))
2472 if (CLASS_PLACEHOLDER_TEMPLATE (anode
))
2474 /* C++23 auto(x). */
2475 else if (!AUTO_IS_DECLTYPE (anode
)
2476 && list_length (parms
) == 1)
2478 init
= TREE_VALUE (parms
);
2479 if (is_constrained_auto (anode
))
2481 if (complain
& tf_error
)
2482 error_at (loc
, "%<auto(x)%> cannot be constrained");
2483 return error_mark_node
;
2485 else if (cxx_dialect
< cxx23
)
2486 pedwarn (loc
, OPT_Wc__23_extensions
,
2487 "%<auto(x)%> only available with "
2488 "%<-std=c++2b%> or %<-std=gnu++2b%>");
2492 if (complain
& tf_error
)
2493 error_at (loc
, "invalid use of %qT", anode
);
2494 return error_mark_node
;
2496 type
= do_auto_deduction (type
, init
, anode
, complain
,
2498 if (type
== error_mark_node
)
2499 return error_mark_node
;
2502 if (processing_template_decl
)
2506 /* Diagnose this even in a template. We could also try harder
2507 to give all the usual errors when the type and args are
2509 if (TYPE_REF_P (type
) && !parms
)
2511 if (complain
& tf_error
)
2512 error_at (loc
, "invalid value-initialization of reference type");
2513 return error_mark_node
;
2516 t
= build_min (CAST_EXPR
, type
, parms
);
2517 /* We don't know if it will or will not have side effects. */
2518 TREE_SIDE_EFFECTS (t
) = 1;
2522 if (! MAYBE_CLASS_TYPE_P (type
))
2524 if (parms
== NULL_TREE
)
2526 if (VOID_TYPE_P (type
))
2528 return build_value_init (cv_unqualified (type
), complain
);
2531 /* This must build a C cast. */
2532 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
2533 return cp_build_c_cast (loc
, type
, parms
, complain
);
2536 /* Prepare to evaluate as a call to a constructor. If this expression
2537 is actually used, for example,
2539 return X (arg1, arg2, ...);
2541 then the slot being initialized will be filled in. */
2543 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
2544 return error_mark_node
;
2545 if (abstract_virtuals_error (ACU_CAST
, type
, complain
))
2546 return error_mark_node
;
2550 If the expression list is a single-expression, the type
2551 conversion is equivalent (in definedness, and if defined in
2552 meaning) to the corresponding cast expression. */
2553 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
2554 return cp_build_c_cast (loc
, type
, TREE_VALUE (parms
), complain
);
2558 The expression T(), where T is a simple-type-specifier for a
2559 non-array complete object type or the (possibly cv-qualified)
2560 void type, creates an rvalue of the specified type, which is
2561 value-initialized. */
2563 if (parms
== NULL_TREE
)
2565 exp
= build_value_init (type
, complain
);
2566 exp
= get_target_expr (exp
, complain
);
2570 /* Call the constructor. */
2571 releasing_vec parmvec
;
2572 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
2573 vec_safe_push (parmvec
, TREE_VALUE (parms
));
2574 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2575 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
2577 if (exp
== error_mark_node
)
2578 return error_mark_node
;
2580 return build_cplus_new (type
, exp
, complain
);
2584 build_functional_cast (location_t loc
, tree exp
, tree parms
,
2585 tsubst_flags_t complain
)
2587 tree result
= build_functional_cast_1 (loc
, exp
, parms
, complain
);
2588 protected_set_expr_location (result
, loc
);
2593 /* Add new exception specifier SPEC, to the LIST we currently have.
2594 If it's already in LIST then do nothing.
2595 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
2596 know what we're doing. */
2599 add_exception_specifier (tree list
, tree spec
, tsubst_flags_t complain
)
2604 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
2606 if (spec
== error_mark_node
)
2609 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
2611 /* [except.spec] 1, type in an exception specifier shall not be
2612 incomplete, or pointer or ref to incomplete other than pointer
2614 is_ptr
= TYPE_PTR_P (core
);
2615 if (is_ptr
|| TYPE_REF_P (core
))
2616 core
= TREE_TYPE (core
);
2619 else if (VOID_TYPE_P (core
))
2621 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
2623 else if (processing_template_decl
)
2625 else if (!verify_type_context (input_location
, TCTX_EXCEPTIONS
, core
,
2626 !(complain
& tf_error
)))
2627 return error_mark_node
;
2631 /* 15.4/1 says that types in an exception specifier must be complete,
2632 but it seems more reasonable to only require this on definitions
2633 and calls. So just give a pedwarn at this point; we will give an
2634 error later if we hit one of those two cases. */
2635 if (!COMPLETE_TYPE_P (complete_type (core
)))
2636 diag_type
= DK_PEDWARN
; /* pedwarn */
2643 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
2644 if (same_type_p (TREE_VALUE (probe
), spec
))
2647 list
= tree_cons (NULL_TREE
, spec
, list
);
2650 diag_type
= DK_ERROR
; /* error */
2652 if (diag_type
!= DK_UNSPECIFIED
2653 && (complain
& tf_warning_or_error
))
2654 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
2659 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
2662 nothrow_spec_p_uninst (const_tree spec
)
2664 if (DEFERRED_NOEXCEPT_SPEC_P (spec
))
2666 return nothrow_spec_p (spec
);
2669 /* Combine the two exceptions specifier lists LIST and ADD, and return
2673 merge_exception_specifiers (tree list
, tree add
)
2675 tree noex
, orig_list
;
2677 if (list
== error_mark_node
|| add
== error_mark_node
)
2678 return error_mark_node
;
2680 /* No exception-specifier or noexcept(false) are less strict than
2681 anything else. Prefer the newer variant (LIST). */
2682 if (!list
|| list
== noexcept_false_spec
)
2684 else if (!add
|| add
== noexcept_false_spec
)
2687 /* noexcept(true) and throw() are stricter than anything else.
2688 As above, prefer the more recent one (LIST). */
2689 if (nothrow_spec_p_uninst (add
))
2692 /* Two implicit noexcept specs (e.g. on a destructor) are equivalent. */
2693 if (UNEVALUATED_NOEXCEPT_SPEC_P (add
)
2694 && UNEVALUATED_NOEXCEPT_SPEC_P (list
))
2696 /* We should have instantiated other deferred noexcept specs by now. */
2697 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add
));
2699 if (nothrow_spec_p_uninst (list
))
2701 noex
= TREE_PURPOSE (list
);
2702 gcc_checking_assert (!TREE_PURPOSE (add
)
2703 || errorcount
|| !flag_exceptions
2704 || cp_tree_equal (noex
, TREE_PURPOSE (add
)));
2706 /* Combine the dynamic-exception-specifiers, if any. */
2708 for (; add
&& TREE_VALUE (add
); add
= TREE_CHAIN (add
))
2710 tree spec
= TREE_VALUE (add
);
2713 for (probe
= orig_list
; probe
&& TREE_VALUE (probe
);
2714 probe
= TREE_CHAIN (probe
))
2715 if (same_type_p (TREE_VALUE (probe
), spec
))
2719 spec
= build_tree_list (NULL_TREE
, spec
);
2720 TREE_CHAIN (spec
) = list
;
2725 /* Keep the noexcept-specifier at the beginning of the list. */
2726 if (noex
!= TREE_PURPOSE (list
))
2727 list
= tree_cons (noex
, TREE_VALUE (list
), TREE_CHAIN (list
));
2732 /* Subroutine of build_call. Ensure that each of the types in the
2733 exception specification is complete. Technically, 15.4/1 says that
2734 they need to be complete when we see a declaration of the function,
2735 but we should be able to get away with only requiring this when the
2736 function is defined or called. See also add_exception_specifier. */
2739 require_complete_eh_spec_types (tree fntype
, tree decl
)
2742 /* Don't complain about calls to op new. */
2743 if (decl
&& DECL_ARTIFICIAL (decl
))
2745 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
2746 raises
= TREE_CHAIN (raises
))
2748 tree type
= TREE_VALUE (raises
);
2749 if (type
&& !COMPLETE_TYPE_P (type
))
2753 ("call to function %qD which throws incomplete type %q#T",
2756 error ("call to function which throws incomplete type %q#T",
2762 /* Record that any TARGET_EXPR in T are going to be elided in
2763 cp_gimplify_init_expr (or sooner). */
2766 set_target_expr_eliding (tree t
)
2770 switch (TREE_CODE (t
))
2773 TARGET_EXPR_ELIDING_P (t
) = true;
2776 set_target_expr_eliding (TREE_OPERAND (t
, 1));
2779 set_target_expr_eliding (TREE_OPERAND (t
, 1));
2780 set_target_expr_eliding (TREE_OPERAND (t
, 2));
2788 /* Call the above in the process of building an INIT_EXPR. */
2791 cp_build_init_expr (location_t loc
, tree target
, tree init
)
2793 set_target_expr_eliding (init
);
2794 tree ie
= build2_loc (loc
, INIT_EXPR
, TREE_TYPE (target
),
2796 TREE_SIDE_EFFECTS (ie
) = true;