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 if (!flag_permissive
)
1113 global_dc
->pedantic_errors
= 1;
1114 auto s
= make_temp_override (global_dc
->dc_warn_system_headers
, true);
1115 pedwarn (loc
, OPT_Wnarrowing
,
1116 "narrowing conversion of %qE from %qH to %qI",
1118 if (errorcount
== savederrorcount
)
1120 global_dc
->pedantic_errors
= flag_pedantic_errors
;
1127 /* True iff TYPE is a C++20 "ordinary" character type. */
1130 ordinary_char_type_p (tree type
)
1132 type
= TYPE_MAIN_VARIANT (type
);
1133 return (type
== char_type_node
1134 || type
== signed_char_type_node
1135 || type
== unsigned_char_type_node
);
1138 /* True iff the string literal INIT has a type suitable for initializing array
1142 array_string_literal_compatible_p (tree type
, tree init
)
1144 tree to_char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1145 tree from_char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
1147 if (to_char_type
== from_char_type
)
1149 /* The array element type does not match the initializing string
1150 literal element type; this is only allowed when both types are
1151 ordinary character type. There are no string literals of
1152 signed or unsigned char type in the language, but we can get
1153 them internally from converting braced-init-lists to
1155 if (ordinary_char_type_p (to_char_type
)
1156 && ordinary_char_type_p (from_char_type
))
1159 /* P2513 (C++20/C++23): "an array of char or unsigned char may
1160 be initialized by a UTF-8 string literal, or by such a string
1161 literal enclosed in braces." */
1162 if (from_char_type
== char8_type_node
1163 && (to_char_type
== char_type_node
1164 || to_char_type
== unsigned_char_type_node
))
1170 /* Process the initializer INIT for a variable of type TYPE, emitting
1171 diagnostics for invalid initializers and converting the initializer as
1174 For aggregate types, it assumes that reshape_init has already run, thus the
1175 initializer will have the right shape (brace elision has been undone).
1177 NESTED is non-zero iff we are being called for an element of a CONSTRUCTOR,
1178 2 iff the element of a CONSTRUCTOR is inside another CONSTRUCTOR. */
1181 digest_init_r (tree type
, tree init
, int nested
, int flags
,
1182 tsubst_flags_t complain
)
1184 enum tree_code code
= TREE_CODE (type
);
1186 if (error_operand_p (init
))
1187 return error_mark_node
;
1191 /* We must strip the outermost array type when completing the type,
1192 because the its bounds might be incomplete at the moment. */
1193 if (!complete_type_or_maybe_complain (code
== ARRAY_TYPE
1194 ? TREE_TYPE (type
) : type
, NULL_TREE
,
1196 return error_mark_node
;
1198 location_t loc
= cp_expr_loc_or_input_loc (init
);
1200 tree stripped_init
= init
;
1202 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1203 && CONSTRUCTOR_IS_PAREN_INIT (init
))
1204 flags
|= LOOKUP_AGGREGATE_PAREN_INIT
;
1206 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
1207 (g++.old-deja/g++.law/casts2.C). */
1208 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
1209 stripped_init
= TREE_OPERAND (init
, 0);
1211 stripped_init
= tree_strip_any_location_wrapper (stripped_init
);
1213 /* Initialization of an array of chars from a string constant. The initializer
1214 can be optionally enclosed in braces, but reshape_init has already removed
1215 them if they were present. */
1216 if (code
== ARRAY_TYPE
)
1218 if (nested
&& !TYPE_DOMAIN (type
))
1219 /* C++ flexible array members have a null domain. */
1221 if (flags
& LOOKUP_ALLOW_FLEXARRAY_INIT
)
1222 pedwarn (loc
, OPT_Wpedantic
,
1223 "initialization of a flexible array member");
1226 if (complain
& tf_error
)
1227 error_at (loc
, "non-static initialization of"
1228 " a flexible array member");
1229 return error_mark_node
;
1233 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1234 if (char_type_p (typ1
)
1235 && TREE_CODE (stripped_init
) == STRING_CST
)
1237 if (!array_string_literal_compatible_p (type
, init
))
1239 if (complain
& tf_error
)
1240 error_at (loc
, "cannot initialize array of %qT from "
1241 "a string literal with type array of %qT",
1243 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
))));
1244 return error_mark_node
;
1247 if (nested
== 2 && !TYPE_DOMAIN (type
))
1249 if (complain
& tf_error
)
1250 error_at (loc
, "initialization of flexible array member "
1251 "in a nested context");
1252 return error_mark_node
;
1255 if (type
!= TREE_TYPE (init
)
1256 && !variably_modified_type_p (type
, NULL_TREE
))
1258 init
= copy_node (init
);
1259 TREE_TYPE (init
) = type
;
1260 /* If we have a location wrapper, then also copy the wrapped
1261 node, and update the copy's type. */
1262 if (location_wrapper_p (init
))
1264 stripped_init
= copy_node (stripped_init
);
1265 TREE_OPERAND (init
, 0) = stripped_init
;
1266 TREE_TYPE (stripped_init
) = type
;
1269 if (TYPE_DOMAIN (type
) && TREE_CONSTANT (TYPE_SIZE (type
)))
1271 /* Not a flexible array member. */
1272 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
1273 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
1274 /* In C it is ok to subtract 1 from the length of the string
1275 because it's ok to ignore the terminating null char that is
1276 counted in the length of the constant, but in C++ this would
1278 if (size
< TREE_STRING_LENGTH (stripped_init
))
1280 permerror (loc
, "initializer-string for %qT is too long",
1283 init
= build_string (size
,
1284 TREE_STRING_POINTER (stripped_init
));
1285 TREE_TYPE (init
) = type
;
1292 /* Handle scalar types (including conversions) and references. */
1293 if ((code
!= COMPLEX_TYPE
|| BRACE_ENCLOSED_INITIALIZER_P (stripped_init
))
1294 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
1296 /* Narrowing is OK when initializing an aggregate from
1297 a parenthesized list. */
1298 if (nested
&& !(flags
& LOOKUP_AGGREGATE_PAREN_INIT
))
1299 flags
|= LOOKUP_NO_NARROWING
;
1300 init
= convert_for_initialization (0, type
, init
, flags
,
1301 ICR_INIT
, NULL_TREE
, 0,
1307 /* Come here only for aggregates: records, arrays, unions, complex numbers
1309 gcc_assert (code
== ARRAY_TYPE
1310 || VECTOR_TYPE_P (type
)
1311 || code
== RECORD_TYPE
1312 || code
== UNION_TYPE
1313 || code
== OPAQUE_TYPE
1314 || code
== COMPLEX_TYPE
);
1316 /* "If T is a class type and the initializer list has a single
1317 element of type cv U, where U is T or a class derived from T,
1318 the object is initialized from that element." */
1319 if (cxx_dialect
>= cxx11
1320 && BRACE_ENCLOSED_INITIALIZER_P (stripped_init
)
1321 && !CONSTRUCTOR_IS_DESIGNATED_INIT (stripped_init
)
1322 && CONSTRUCTOR_NELTS (stripped_init
) == 1
1323 && ((CLASS_TYPE_P (type
) && !CLASSTYPE_NON_AGGREGATE (type
))
1324 || VECTOR_TYPE_P (type
)))
1326 tree elt
= CONSTRUCTOR_ELT (stripped_init
, 0)->value
;
1327 if (reference_related_p (type
, TREE_TYPE (elt
)))
1329 /* In C++17, aggregates can have bases, thus participate in
1330 aggregate initialization. In the following case:
1332 struct B { int c; };
1336 there's an extra set of braces, so the D temporary initializes
1337 the first element of d, which is the B base subobject. The base
1338 of type B is copy-initialized from the D temporary, causing
1340 tree field
= next_aggregate_field (TYPE_FIELDS (type
));
1341 if (field
&& DECL_FIELD_IS_BASE (field
))
1343 if (warning_at (loc
, 0, "initializing a base class of type %qT "
1344 "results in object slicing", TREE_TYPE (field
)))
1345 inform (loc
, "remove %<{ }%> around initializer");
1347 else if (flag_checking
)
1348 /* We should have fixed this in reshape_init. */
1353 if (SIMPLE_TARGET_EXPR_P (stripped_init
))
1354 stripped_init
= TARGET_EXPR_INITIAL (stripped_init
);
1356 if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init
)
1357 && !TYPE_NON_AGGREGATE_CLASS (type
))
1358 return process_init_constructor (type
, stripped_init
, nested
, flags
,
1362 if (COMPOUND_LITERAL_P (stripped_init
) && code
== ARRAY_TYPE
)
1364 if (complain
& tf_error
)
1365 error_at (loc
, "cannot initialize aggregate of type %qT with "
1366 "a compound literal", type
);
1368 return error_mark_node
;
1371 if (code
== ARRAY_TYPE
1372 && !BRACE_ENCLOSED_INITIALIZER_P (stripped_init
))
1374 /* Allow the result of build_array_copy and of
1375 build_value_init_noctor. */
1376 if ((TREE_CODE (stripped_init
) == VEC_INIT_EXPR
1377 || TREE_CODE (stripped_init
) == CONSTRUCTOR
)
1378 && (same_type_ignoring_top_level_qualifiers_p
1379 (type
, TREE_TYPE (init
))))
1382 if (complain
& tf_error
)
1383 error_at (loc
, "array must be initialized with a brace-enclosed"
1385 return error_mark_node
;
1388 return convert_for_initialization (NULL_TREE
, type
, init
,
1390 ICR_INIT
, NULL_TREE
, 0,
1396 digest_init (tree type
, tree init
, tsubst_flags_t complain
)
1398 return digest_init_r (type
, init
, 0, LOOKUP_IMPLICIT
, complain
);
1402 digest_init_flags (tree type
, tree init
, int flags
, tsubst_flags_t complain
)
1404 return digest_init_r (type
, init
, 0, flags
, complain
);
1407 /* Return true if SUBOB initializes the same object as FULL_EXPR.
1410 A a = A{}; // initializer
1411 A a = (A{}); // initializer
1412 A a = (1, A{}); // initializer
1413 A a = true ? A{} : A{}; // initializer
1414 auto x = A{}.x; // temporary materialization
1415 auto x = foo(A{}); // temporary materialization
1417 FULL_EXPR is the whole expression, SUBOB is its TARGET_EXPR subobject. */
1420 potential_prvalue_result_of (tree subob
, tree full_expr
)
1422 if (subob
== full_expr
)
1424 else if (TREE_CODE (full_expr
) == TARGET_EXPR
)
1426 tree init
= TARGET_EXPR_INITIAL (full_expr
);
1427 if (TREE_CODE (init
) == COND_EXPR
)
1428 return (potential_prvalue_result_of (subob
, TREE_OPERAND (init
, 1))
1429 || potential_prvalue_result_of (subob
, TREE_OPERAND (init
, 2)));
1430 else if (TREE_CODE (init
) == COMPOUND_EXPR
)
1431 return potential_prvalue_result_of (subob
, TREE_OPERAND (init
, 1));
1432 /* ??? I don't know if this can be hit. */
1433 else if (TREE_CODE (init
) == PAREN_EXPR
)
1435 gcc_checking_assert (false);
1436 return potential_prvalue_result_of (subob
, TREE_OPERAND (init
, 0));
1442 /* Callback to replace PLACEHOLDER_EXPRs in a TARGET_EXPR (which isn't used
1443 in the context of guaranteed copy elision). */
1446 replace_placeholders_for_class_temp_r (tree
*tp
, int *, void *data
)
1449 tree full_expr
= *static_cast<tree
*>(data
);
1451 /* We're looking for a TARGET_EXPR nested in the whole expression. */
1452 if (TREE_CODE (t
) == TARGET_EXPR
1453 && !potential_prvalue_result_of (t
, full_expr
))
1455 tree init
= TARGET_EXPR_INITIAL (t
);
1456 while (TREE_CODE (init
) == COMPOUND_EXPR
)
1457 init
= TREE_OPERAND (init
, 1);
1458 if (TREE_CODE (init
) == CONSTRUCTOR
1459 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
))
1461 tree obj
= TARGET_EXPR_SLOT (t
);
1462 replace_placeholders (init
, obj
);
1463 /* We should have dealt with all PLACEHOLDER_EXPRs. */
1464 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = false;
1465 gcc_checking_assert (!find_placeholders (init
));
1472 /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL). */
1474 digest_nsdmi_init (tree decl
, tree init
, tsubst_flags_t complain
)
1476 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1478 tree type
= TREE_TYPE (decl
);
1479 if (DECL_BIT_FIELD_TYPE (decl
))
1480 type
= DECL_BIT_FIELD_TYPE (decl
);
1481 int flags
= LOOKUP_IMPLICIT
;
1482 if (DIRECT_LIST_INIT_P (init
))
1484 flags
= LOOKUP_NORMAL
;
1485 complain
|= tf_no_cleanup
;
1487 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1488 && CP_AGGREGATE_TYPE_P (type
))
1489 init
= reshape_init (type
, init
, complain
);
1490 init
= digest_init_flags (type
, init
, flags
, complain
);
1491 set_target_expr_eliding (init
);
1493 /* We may have temporary materialization in a NSDMI, if the initializer
1494 has something like A{} in it. Digesting the {} could have introduced
1495 a PLACEHOLDER_EXPR referring to A. Now that we've got a TARGET_EXPR,
1496 we have an object we can refer to. The reason we bother doing this
1497 here is for code like
1506 int y = A{x}.y; // #1
1509 where in #1 we don't want to end up with two PLACEHOLDER_EXPRs for
1510 different types on the same level in a {} when lookup_placeholder
1511 wouldn't find a named object for the PLACEHOLDER_EXPR for A. Note,
1512 temporary materialization does not occur when initializing an object
1513 from a prvalue of the same type, therefore we must not replace the
1514 placeholder with a temporary object so that it can be elided. */
1515 cp_walk_tree (&init
, replace_placeholders_for_class_temp_r
, &init
,
1521 /* Set of flags used within process_init_constructor to describe the
1523 #define PICFLAG_ERRONEOUS 1
1524 #define PICFLAG_NOT_ALL_CONSTANT 2
1525 #define PICFLAG_NOT_ALL_SIMPLE 4
1526 #define PICFLAG_SIDE_EFFECTS 8
1527 #define PICFLAG_VEC_INIT 16
1529 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1533 picflag_from_initializer (tree init
)
1535 if (init
== error_mark_node
)
1536 return PICFLAG_ERRONEOUS
;
1537 else if (!TREE_CONSTANT (init
))
1539 if (TREE_SIDE_EFFECTS (init
))
1540 return PICFLAG_SIDE_EFFECTS
;
1542 return PICFLAG_NOT_ALL_CONSTANT
;
1544 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
1545 return PICFLAG_NOT_ALL_SIMPLE
;
1549 /* Adjust INIT for going into a CONSTRUCTOR. */
1552 massage_init_elt (tree type
, tree init
, int nested
, int flags
,
1553 tsubst_flags_t complain
)
1555 int new_flags
= LOOKUP_IMPLICIT
;
1556 if (flags
& LOOKUP_ALLOW_FLEXARRAY_INIT
)
1557 new_flags
|= LOOKUP_ALLOW_FLEXARRAY_INIT
;
1558 if (flags
& LOOKUP_AGGREGATE_PAREN_INIT
)
1559 new_flags
|= LOOKUP_AGGREGATE_PAREN_INIT
;
1560 init
= digest_init_r (type
, init
, nested
? 2 : 1, new_flags
, complain
);
1561 /* When we defer constant folding within a statement, we may want to
1562 defer this folding as well. Don't call this on CONSTRUCTORs because
1563 their elements have already been folded, and we must avoid folding
1564 the result of get_nsdmi. */
1565 if (TREE_CODE (init
) != CONSTRUCTOR
)
1567 tree t
= fold_non_dependent_init (init
, complain
);
1568 if (TREE_CONSTANT (t
))
1570 set_target_expr_eliding (init
);
1575 /* Subroutine of process_init_constructor, which will process an initializer
1576 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1577 which describe the initializers. */
1580 process_init_constructor_array (tree type
, tree init
, int nested
, int flags
,
1581 tsubst_flags_t complain
)
1583 unsigned HOST_WIDE_INT i
, len
= 0;
1585 bool unbounded
= false;
1586 constructor_elt
*ce
;
1587 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (init
);
1589 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1590 || VECTOR_TYPE_P (type
));
1592 if (TREE_CODE (type
) == ARRAY_TYPE
)
1594 /* C++ flexible array members have a null domain. */
1595 tree domain
= TYPE_DOMAIN (type
);
1596 if (domain
&& TREE_CONSTANT (TYPE_MAX_VALUE (domain
)))
1597 len
= wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain
))
1598 - wi::to_offset (TYPE_MIN_VALUE (domain
)) + 1,
1599 TYPE_PRECISION (TREE_TYPE (domain
)),
1600 TYPE_SIGN (TREE_TYPE (domain
))).to_uhwi ();
1602 unbounded
= true; /* Take as many as there are. */
1604 if (nested
== 2 && !domain
&& !vec_safe_is_empty (v
))
1606 if (complain
& tf_error
)
1607 error_at (cp_expr_loc_or_input_loc (init
),
1608 "initialization of flexible array member "
1609 "in a nested context");
1610 return PICFLAG_ERRONEOUS
;
1614 /* Vectors are like simple fixed-size arrays. */
1615 unbounded
= !TYPE_VECTOR_SUBPARTS (type
).is_constant (&len
);
1617 /* There must not be more initializers than needed. */
1618 if (!unbounded
&& vec_safe_length (v
) > len
)
1620 if (complain
& tf_error
)
1621 error ("too many initializers for %qT", type
);
1623 return PICFLAG_ERRONEOUS
;
1626 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
1629 ce
->index
= size_int (i
);
1630 else if (!check_array_designated_initializer (ce
, i
))
1631 ce
->index
= error_mark_node
;
1632 gcc_assert (ce
->value
);
1634 = massage_init_elt (TREE_TYPE (type
), ce
->value
, nested
, flags
,
1638 (ce
->value
== error_mark_node
1639 || (same_type_ignoring_top_level_qualifiers_p
1640 (strip_array_types (TREE_TYPE (type
)),
1641 strip_array_types (TREE_TYPE (ce
->value
)))));
1643 picflags
|= picflag_from_initializer (ce
->value
);
1644 /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer
1646 if (TREE_CODE (ce
->value
) == CONSTRUCTOR
1647 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce
->value
))
1649 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1650 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce
->value
) = 0;
1654 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1655 we must add initializers ourselves. */
1657 for (; i
< len
; ++i
)
1661 if (type_build_ctor_call (TREE_TYPE (type
)))
1663 /* If this type needs constructors run for default-initialization,
1664 we can't rely on the back end to do it for us, so make the
1665 initialization explicit by list-initializing from T{}. */
1666 next
= build_constructor (init_list_type_node
, NULL
);
1667 next
= massage_init_elt (TREE_TYPE (type
), next
, nested
, flags
,
1669 if (initializer_zerop (next
))
1670 /* The default zero-initialization is fine for us; don't
1671 add anything to the CONSTRUCTOR. */
1674 else if (!zero_init_p (TREE_TYPE (type
)))
1675 next
= build_zero_init (TREE_TYPE (type
),
1676 /*nelts=*/NULL_TREE
,
1677 /*static_storage_p=*/false);
1679 /* The default zero-initialization is fine for us; don't
1680 add anything to the CONSTRUCTOR. */
1685 if (next
!= error_mark_node
1686 && (initializer_constant_valid_p (next
, TREE_TYPE (next
))
1687 != null_pointer_node
))
1689 /* Use VEC_INIT_EXPR for non-constant initialization of
1690 trailing elements with no explicit initializers. */
1691 picflags
|= PICFLAG_VEC_INIT
;
1695 picflags
|= picflag_from_initializer (next
);
1696 /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer
1698 if (TREE_CODE (next
) == CONSTRUCTOR
1699 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next
))
1701 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1702 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next
) = 0;
1706 tree range
= build2 (RANGE_EXPR
, size_type_node
,
1707 build_int_cst (size_type_node
, i
),
1708 build_int_cst (size_type_node
, len
- 1));
1709 CONSTRUCTOR_APPEND_ELT (v
, range
, next
);
1713 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1716 /* Don't bother checking all the other elements. */
1720 CONSTRUCTOR_ELTS (init
) = v
;
1724 /* Subroutine of process_init_constructor, which will process an initializer
1725 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1726 the initializers. */
1729 process_init_constructor_record (tree type
, tree init
, int nested
, int flags
,
1730 tsubst_flags_t complain
)
1732 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1736 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1737 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1738 gcc_assert (!TYPE_BINFO (type
)
1739 || cxx_dialect
>= cxx17
1740 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1741 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1745 unsigned HOST_WIDE_INT idx
= 0;
1746 int designator_skip
= -1;
1747 /* Generally, we will always have an index for each initializer (which is
1748 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1749 reshape_init. So we need to handle both cases. */
1750 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1754 if (TREE_CODE (field
) != FIELD_DECL
1755 || (DECL_ARTIFICIAL (field
)
1756 && !(cxx_dialect
>= cxx17
&& DECL_FIELD_IS_BASE (field
))))
1759 if (DECL_UNNAMED_BIT_FIELD (field
))
1762 /* If this is a bitfield, first convert to the declared type. */
1763 tree fldtype
= TREE_TYPE (field
);
1764 if (DECL_BIT_FIELD_TYPE (field
))
1765 fldtype
= DECL_BIT_FIELD_TYPE (field
);
1766 if (fldtype
== error_mark_node
)
1767 return PICFLAG_ERRONEOUS
;
1770 if (idx
< CONSTRUCTOR_NELTS (init
))
1772 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1775 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1776 latter case can happen in templates where lookup has to be
1778 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1779 || identifier_p (ce
->index
));
1780 if (ce
->index
== field
|| ce
->index
== DECL_NAME (field
))
1785 if (designator_skip
== -1)
1786 designator_skip
= 1;
1791 designator_skip
= 0;
1797 gcc_assert (ce
->value
);
1798 next
= massage_init_elt (fldtype
, next
, nested
, flags
, complain
);
1799 /* We can't actually elide the temporary when initializing a
1800 potentially-overlapping field from a function that returns by
1803 && TREE_CODE (next
) == TARGET_EXPR
1804 && unsafe_copy_elision_p (ce
->index
, next
))
1805 TARGET_EXPR_ELIDING_P (next
) = false;
1809 if (next
== error_mark_node
)
1810 /* We skip initializers for empty bases/fields, so skipping an invalid
1811 one could make us accept invalid code. */
1812 return PICFLAG_ERRONEOUS
;
1814 /* Already handled above. */;
1815 else if (DECL_INITIAL (field
))
1819 /* We're using an NSDMI past a field with implicit
1820 zero-init. Go back and make it explicit. */
1822 vec_safe_truncate (v
, 0);
1825 /* C++14 aggregate NSDMI. */
1826 next
= get_nsdmi (field
, /*ctor*/false, complain
);
1827 if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
)
1828 && find_placeholders (next
))
1829 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1831 else if (type_build_ctor_call (fldtype
))
1833 /* If this type needs constructors run for
1834 default-initialization, we can't rely on the back end to do it
1835 for us, so build up TARGET_EXPRs. If the type in question is
1836 a class, just build one up; if it's an array, recurse. */
1837 next
= build_constructor (init_list_type_node
, NULL
);
1838 next
= massage_init_elt (fldtype
, next
, nested
, flags
, complain
);
1839 if (TREE_CODE (next
) == TARGET_EXPR
1840 && unsafe_copy_elision_p (field
, next
))
1841 TARGET_EXPR_ELIDING_P (next
) = false;
1843 /* Warn when some struct elements are implicitly initialized. */
1844 if ((complain
& tf_warning
)
1845 && !cp_unevaluated_operand
1846 && !EMPTY_CONSTRUCTOR_P (init
))
1847 warning (OPT_Wmissing_field_initializers
,
1848 "missing initializer for member %qD", field
);
1852 if (TYPE_REF_P (fldtype
))
1854 if (complain
& tf_error
)
1855 error ("member %qD is uninitialized reference", field
);
1857 return PICFLAG_ERRONEOUS
;
1859 else if (CLASSTYPE_REF_FIELDS_NEED_INIT (fldtype
))
1861 if (complain
& tf_error
)
1862 error ("member %qD with uninitialized reference fields", field
);
1864 return PICFLAG_ERRONEOUS
;
1866 /* Do nothing for flexible array members since they need not have any
1867 elements. Don't worry about 'skipped' because a flexarray has to
1868 be the last field. */
1869 else if (TREE_CODE (fldtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (fldtype
))
1872 /* Warn when some struct elements are implicitly initialized
1874 if ((complain
& tf_warning
)
1875 && !cp_unevaluated_operand
1876 && !EMPTY_CONSTRUCTOR_P (init
)
1877 && !is_really_empty_class (fldtype
, /*ignore_vptr*/false))
1878 warning (OPT_Wmissing_field_initializers
,
1879 "missing initializer for member %qD", field
);
1881 if (!zero_init_p (fldtype
) || skipped
< 0)
1883 if (TYPE_REF_P (fldtype
))
1884 next
= build_zero_cst (fldtype
);
1886 next
= build_zero_init (fldtype
, /*nelts=*/NULL_TREE
,
1887 /*static_storage_p=*/false);
1891 /* The default zero-initialization is fine for us; don't
1892 add anything to the CONSTRUCTOR. */
1898 if (is_empty_field (field
)
1899 && !TREE_SIDE_EFFECTS (next
))
1900 /* Don't add trivial initialization of an empty base/field to the
1901 constructor, as they might not be ordered the way the back-end
1905 /* If this is a bitfield, now convert to the lowered type. */
1906 if (fldtype
!= TREE_TYPE (field
))
1907 next
= cp_convert_and_check (TREE_TYPE (field
), next
, complain
);
1908 picflags
|= picflag_from_initializer (next
);
1909 /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer CONSTRUCTOR. */
1910 if (TREE_CODE (next
) == CONSTRUCTOR
1911 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next
))
1913 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1914 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next
) = 0;
1916 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1919 if (idx
< CONSTRUCTOR_NELTS (init
))
1921 if (complain
& tf_error
)
1923 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1924 /* For better diagnostics, try to find out if it is really
1925 the case of too many initializers or if designators are
1926 in incorrect order. */
1927 if (designator_skip
== 1 && ce
->index
)
1929 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1930 || identifier_p (ce
->index
));
1931 for (field
= TYPE_FIELDS (type
);
1932 field
; field
= DECL_CHAIN (field
))
1934 if (TREE_CODE (field
) != FIELD_DECL
1935 || (DECL_ARTIFICIAL (field
)
1936 && !(cxx_dialect
>= cxx17
1937 && DECL_FIELD_IS_BASE (field
))))
1940 if (DECL_UNNAMED_BIT_FIELD (field
))
1943 if (ce
->index
== field
|| ce
->index
== DECL_NAME (field
))
1948 error ("designator order for field %qD does not match declaration "
1949 "order in %qT", field
, type
);
1951 error ("too many initializers for %qT", type
);
1954 return PICFLAG_ERRONEOUS
;
1957 CONSTRUCTOR_ELTS (init
) = v
;
1961 /* Subroutine of process_init_constructor, which will process a single
1962 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1963 which describe the initializer. */
1966 process_init_constructor_union (tree type
, tree init
, int nested
, int flags
,
1967 tsubst_flags_t complain
)
1969 constructor_elt
*ce
;
1972 /* If the initializer was empty, use the union's NSDMI if it has one.
1973 Otherwise use default zero initialization. */
1974 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1976 for (tree field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1978 if (TREE_CODE (field
) == FIELD_DECL
1979 && DECL_INITIAL (field
) != NULL_TREE
)
1981 tree val
= get_nsdmi (field
, /*in_ctor=*/false, complain
);
1982 if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
)
1983 && find_placeholders (val
))
1984 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1985 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init
), field
, val
);
1990 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1994 len
= CONSTRUCTOR_ELTS (init
)->length ();
1997 if (!(complain
& tf_error
))
1998 return PICFLAG_ERRONEOUS
;
1999 error ("too many initializers for %qT", type
);
2000 CONSTRUCTOR_ELTS (init
)->block_remove (1, len
-1);
2003 ce
= &(*CONSTRUCTOR_ELTS (init
))[0];
2005 /* If this element specifies a field, initialize via that field. */
2008 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
2010 else if (identifier_p (ce
->index
))
2012 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
2013 tree name
= ce
->index
;
2015 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
2016 if (DECL_NAME (field
) == name
)
2020 if (complain
& tf_error
)
2021 error ("no field %qD found in union being initialized",
2023 ce
->value
= error_mark_node
;
2029 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
2030 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
2031 if (complain
& tf_error
)
2032 error ("index value instead of field name in union initializer");
2033 ce
->value
= error_mark_node
;
2038 /* Find the first named field. ANSI decided in September 1990
2039 that only named fields count here. */
2040 tree field
= TYPE_FIELDS (type
);
2041 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
2042 field
= TREE_CHAIN (field
);
2043 if (field
== NULL_TREE
)
2045 if (complain
& tf_error
)
2046 error ("too many initializers for %qT", type
);
2047 ce
->value
= error_mark_node
;
2052 if (ce
->value
&& ce
->value
!= error_mark_node
)
2053 ce
->value
= massage_init_elt (TREE_TYPE (ce
->index
), ce
->value
, nested
,
2056 /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer CONSTRUCTOR. */
2058 && TREE_CODE (ce
->value
) == CONSTRUCTOR
2059 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce
->value
))
2061 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
2062 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce
->value
) = 0;
2064 return picflag_from_initializer (ce
->value
);
2067 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
2068 constructor is a brace-enclosed initializer, and will be modified in-place.
2070 Each element is converted to the right type through digest_init, and
2071 missing initializers are added following the language rules (zero-padding,
2074 After the execution, the initializer will have TREE_CONSTANT if all elts are
2075 constant, and TREE_STATIC set if, in addition, all elts are simple enough
2076 constants that the assembler and linker can compute them.
2078 The function returns the initializer itself, or error_mark_node in case
2082 process_init_constructor (tree type
, tree init
, int nested
, int flags
,
2083 tsubst_flags_t complain
)
2087 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
2089 if (TREE_CODE (type
) == ARRAY_TYPE
|| VECTOR_TYPE_P (type
))
2090 picflags
= process_init_constructor_array (type
, init
, nested
, flags
,
2092 else if (TREE_CODE (type
) == RECORD_TYPE
)
2093 picflags
= process_init_constructor_record (type
, init
, nested
, flags
,
2095 else if (TREE_CODE (type
) == UNION_TYPE
)
2096 picflags
= process_init_constructor_union (type
, init
, nested
, flags
,
2101 if (picflags
& PICFLAG_ERRONEOUS
)
2102 return error_mark_node
;
2104 TREE_TYPE (init
) = type
;
2105 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
2106 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
2107 if (picflags
& PICFLAG_SIDE_EFFECTS
)
2109 TREE_CONSTANT (init
) = false;
2110 TREE_SIDE_EFFECTS (init
) = true;
2112 else if (picflags
& PICFLAG_NOT_ALL_CONSTANT
)
2114 /* Make sure TREE_CONSTANT isn't set from build_constructor. */
2115 TREE_CONSTANT (init
) = false;
2116 TREE_SIDE_EFFECTS (init
) = false;
2120 TREE_CONSTANT (init
) = 1;
2121 TREE_SIDE_EFFECTS (init
) = false;
2122 if (!(picflags
& PICFLAG_NOT_ALL_SIMPLE
))
2123 TREE_STATIC (init
) = 1;
2125 if (picflags
& PICFLAG_VEC_INIT
)
2127 /* Defer default-initialization of array elements with no corresponding
2128 initializer-clause until later so we can use a loop. */
2129 TREE_TYPE (init
) = init_list_type_node
;
2130 init
= build_vec_init_expr (type
, init
, complain
);
2131 init
= get_target_expr (init
);
2136 /* Given a structure or union value DATUM, construct and return
2137 the structure or union component which results from narrowing
2138 that value to the base specified in BASETYPE. For example, given the
2141 class L { int ii; };
2142 class A : L { ... };
2143 class B : L { ... };
2144 class C : A, B { ... };
2152 x.A::ii refers to the ii member of the L part of
2153 the A part of the C object named by X. In this case,
2154 DATUM would be x, and BASETYPE would be A.
2156 I used to think that this was nonconformant, that the standard specified
2157 that first we look up ii in A, then convert x to an L& and pull out the
2158 ii part. But in fact, it does say that we convert x to an A&; A here
2159 is known as the "naming class". (jason 2000-12-19)
2161 BINFO_P points to a variable initialized either to NULL_TREE or to the
2162 binfo for the specific base subobject we want to convert to. */
2165 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
2169 if (datum
== error_mark_node
)
2170 return error_mark_node
;
2174 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
,
2175 NULL
, tf_warning_or_error
);
2177 if (!binfo
|| binfo
== error_mark_node
)
2179 *binfo_p
= NULL_TREE
;
2181 error_not_base_type (basetype
, TREE_TYPE (datum
));
2182 return error_mark_node
;
2186 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1,
2187 tf_warning_or_error
);
2190 /* Build a reference to an object specified by the C++ `->' operator.
2191 Usually this just involves dereferencing the object, but if the
2192 `->' operator is overloaded, then such overloads must be
2193 performed until an object which does not have the `->' operator
2194 overloaded is found. An error is reported when circular pointer
2195 delegation is detected. */
2198 build_x_arrow (location_t loc
, tree expr
, tsubst_flags_t complain
)
2200 tree orig_expr
= expr
;
2201 tree type
= TREE_TYPE (expr
);
2202 tree last_rval
= NULL_TREE
;
2203 vec
<tree
, va_gc
> *types_memoized
= NULL
;
2205 if (type
== error_mark_node
)
2206 return error_mark_node
;
2208 if (processing_template_decl
)
2210 tree ttype
= NULL_TREE
;
2211 if (type
&& TYPE_PTR_P (type
))
2212 ttype
= TREE_TYPE (type
);
2213 if (ttype
&& !dependent_scope_p (ttype
))
2214 /* Pointer to current instantiation, don't treat as dependent. */;
2215 else if (type_dependent_expression_p (expr
))
2217 expr
= build_min_nt_loc (loc
, ARROW_EXPR
, expr
);
2218 TREE_TYPE (expr
) = ttype
;
2221 expr
= build_non_dependent_expr (expr
);
2224 if (MAYBE_CLASS_TYPE_P (type
))
2226 struct tinst_level
*actual_inst
= current_instantiation ();
2229 while ((expr
= build_new_op (loc
, COMPONENT_REF
,
2230 LOOKUP_NORMAL
, expr
, NULL_TREE
, NULL_TREE
,
2231 NULL_TREE
, &fn
, complain
)))
2233 if (expr
== error_mark_node
)
2234 return error_mark_node
;
2236 /* This provides a better instantiation backtrace in case of
2238 if (fn
&& DECL_USE_TEMPLATE (fn
))
2239 push_tinst_level_loc (fn
,
2240 (current_instantiation () != actual_inst
)
2241 ? DECL_SOURCE_LOCATION (fn
)
2245 if (vec_member (TREE_TYPE (expr
), types_memoized
))
2247 if (complain
& tf_error
)
2248 error ("circular pointer delegation detected");
2249 return error_mark_node
;
2252 vec_safe_push (types_memoized
, TREE_TYPE (expr
));
2256 while (current_instantiation () != actual_inst
)
2259 if (last_rval
== NULL_TREE
)
2261 if (complain
& tf_error
)
2262 error ("base operand of %<->%> has non-pointer type %qT", type
);
2263 return error_mark_node
;
2266 if (TYPE_REF_P (TREE_TYPE (last_rval
)))
2267 last_rval
= convert_from_reference (last_rval
);
2271 last_rval
= decay_conversion (expr
, complain
);
2272 if (last_rval
== error_mark_node
)
2273 return error_mark_node
;
2276 if (TYPE_PTR_P (TREE_TYPE (last_rval
)))
2278 if (processing_template_decl
)
2280 expr
= build_min (ARROW_EXPR
, TREE_TYPE (TREE_TYPE (last_rval
)),
2282 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (last_rval
);
2286 return cp_build_indirect_ref (loc
, last_rval
, RO_ARROW
, complain
);
2289 if (complain
& tf_error
)
2292 error ("result of %<operator->()%> yields non-pointer result");
2294 error ("base operand of %<->%> is not a pointer");
2296 return error_mark_node
;
2299 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
2300 already been checked out to be of aggregate type. */
2303 build_m_component_ref (tree datum
, tree component
, tsubst_flags_t complain
)
2311 datum
= mark_lvalue_use (datum
);
2312 component
= mark_rvalue_use (component
);
2314 if (error_operand_p (datum
) || error_operand_p (component
))
2315 return error_mark_node
;
2317 ptrmem_type
= TREE_TYPE (component
);
2318 if (!TYPE_PTRMEM_P (ptrmem_type
))
2320 if (complain
& tf_error
)
2321 error ("%qE cannot be used as a member pointer, since it is of "
2322 "type %qT", component
, ptrmem_type
);
2323 return error_mark_node
;
2326 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
2327 if (! MAYBE_CLASS_TYPE_P (objtype
))
2329 if (complain
& tf_error
)
2330 error ("cannot apply member pointer %qE to %qE, which is of "
2331 "non-class type %qT", component
, datum
, objtype
);
2332 return error_mark_node
;
2335 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
2336 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
2338 if (!COMPLETE_TYPE_P (ctype
))
2340 if (!same_type_p (ctype
, objtype
))
2346 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
, complain
);
2351 if (complain
& tf_error
)
2352 error ("pointer to member type %qT incompatible with object "
2353 "type %qT", type
, objtype
);
2354 return error_mark_node
;
2356 else if (binfo
== error_mark_node
)
2357 return error_mark_node
;
2360 if (TYPE_PTRDATAMEM_P (ptrmem_type
))
2362 bool is_lval
= real_lvalue_p (datum
);
2365 /* Compute the type of the field, as described in [expr.ref].
2366 There's no such thing as a mutable pointer-to-member, so
2367 things are not as complex as they are for references to
2368 non-static data members. */
2369 type
= cp_build_qualified_type (type
,
2370 (cp_type_quals (type
)
2371 | cp_type_quals (TREE_TYPE (datum
))));
2373 datum
= build_address (datum
);
2375 /* Convert object to the correct base. */
2378 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1, complain
);
2379 if (datum
== error_mark_node
)
2380 return error_mark_node
;
2383 /* Build an expression for "object + offset" where offset is the
2384 value stored in the pointer-to-data-member. */
2385 ptype
= build_pointer_type (type
);
2386 datum
= fold_build_pointer_plus (fold_convert (ptype
, datum
), component
);
2387 datum
= cp_build_fold_indirect_ref (datum
);
2388 if (datum
== error_mark_node
)
2389 return error_mark_node
;
2391 /* If the object expression was an rvalue, return an rvalue. */
2393 datum
= move (datum
);
2398 /* 5.5/6: In a .* expression whose object expression is an rvalue, the
2399 program is ill-formed if the second operand is a pointer to member
2400 function with ref-qualifier & (for C++20: unless its cv-qualifier-seq
2401 is const). In a .* expression whose object expression is an lvalue,
2402 the program is ill-formed if the second operand is a pointer to member
2403 function with ref-qualifier &&. */
2404 if (FUNCTION_REF_QUALIFIED (type
))
2406 bool lval
= lvalue_p (datum
);
2407 if (lval
&& FUNCTION_RVALUE_QUALIFIED (type
))
2409 if (complain
& tf_error
)
2410 error ("pointer-to-member-function type %qT requires an rvalue",
2412 return error_mark_node
;
2414 else if (!lval
&& !FUNCTION_RVALUE_QUALIFIED (type
))
2416 if ((type_memfn_quals (type
)
2417 & (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
))
2420 if (complain
& tf_error
)
2421 error ("pointer-to-member-function type %qT requires "
2422 "an lvalue", ptrmem_type
);
2423 return error_mark_node
;
2425 else if (cxx_dialect
< cxx20
)
2427 if (complain
& tf_warning_or_error
)
2428 pedwarn (input_location
, OPT_Wpedantic
,
2429 "pointer-to-member-function type %qT requires "
2430 "an lvalue before C++20", ptrmem_type
);
2432 return error_mark_node
;
2436 return build2 (OFFSET_REF
, type
, datum
, component
);
2440 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
2443 build_functional_cast_1 (location_t loc
, tree exp
, tree parms
,
2444 tsubst_flags_t complain
)
2446 /* This is either a call to a constructor,
2447 or a C cast in C++'s `functional' notation. */
2449 /* The type to which we are casting. */
2452 if (error_operand_p (exp
) || parms
== error_mark_node
)
2453 return error_mark_node
;
2455 if (TREE_CODE (exp
) == TYPE_DECL
)
2457 type
= TREE_TYPE (exp
);
2459 if (DECL_ARTIFICIAL (exp
))
2460 cp_handle_deprecated_or_unavailable (type
);
2465 /* We need to check this explicitly, since value-initialization of
2466 arrays is allowed in other situations. */
2467 if (TREE_CODE (type
) == ARRAY_TYPE
)
2469 if (complain
& tf_error
)
2470 error_at (loc
, "functional cast to array type %qT", type
);
2471 return error_mark_node
;
2474 if (tree anode
= type_uses_auto (type
))
2477 if (CLASS_PLACEHOLDER_TEMPLATE (anode
))
2479 /* C++23 auto(x). */
2480 else if (!AUTO_IS_DECLTYPE (anode
)
2481 && list_length (parms
) == 1)
2483 init
= TREE_VALUE (parms
);
2484 if (is_constrained_auto (anode
))
2486 if (complain
& tf_error
)
2487 error_at (loc
, "%<auto(x)%> cannot be constrained");
2488 return error_mark_node
;
2490 else if (cxx_dialect
< cxx23
)
2491 pedwarn (loc
, OPT_Wc__23_extensions
,
2492 "%<auto(x)%> only available with "
2493 "%<-std=c++2b%> or %<-std=gnu++2b%>");
2497 if (complain
& tf_error
)
2498 error_at (loc
, "invalid use of %qT", anode
);
2499 return error_mark_node
;
2501 type
= do_auto_deduction (type
, init
, anode
, complain
,
2503 if (type
== error_mark_node
)
2504 return error_mark_node
;
2507 if (processing_template_decl
)
2511 /* Diagnose this even in a template. We could also try harder
2512 to give all the usual errors when the type and args are
2514 if (TYPE_REF_P (type
) && !parms
)
2516 if (complain
& tf_error
)
2517 error_at (loc
, "invalid value-initialization of reference type");
2518 return error_mark_node
;
2521 t
= build_min (CAST_EXPR
, type
, parms
);
2522 /* We don't know if it will or will not have side effects. */
2523 TREE_SIDE_EFFECTS (t
) = 1;
2527 if (! MAYBE_CLASS_TYPE_P (type
))
2529 if (parms
== NULL_TREE
)
2531 if (VOID_TYPE_P (type
))
2533 return build_value_init (cv_unqualified (type
), complain
);
2536 /* This must build a C cast. */
2537 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
2538 return cp_build_c_cast (loc
, type
, parms
, complain
);
2541 /* Prepare to evaluate as a call to a constructor. If this expression
2542 is actually used, for example,
2544 return X (arg1, arg2, ...);
2546 then the slot being initialized will be filled in. */
2548 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
2549 return error_mark_node
;
2550 if (abstract_virtuals_error (ACU_CAST
, type
, complain
))
2551 return error_mark_node
;
2555 If the expression list is a single-expression, the type
2556 conversion is equivalent (in definedness, and if defined in
2557 meaning) to the corresponding cast expression. */
2558 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
2559 return cp_build_c_cast (loc
, type
, TREE_VALUE (parms
), complain
);
2563 The expression T(), where T is a simple-type-specifier for a
2564 non-array complete object type or the (possibly cv-qualified)
2565 void type, creates an rvalue of the specified type, which is
2566 value-initialized. */
2568 if (parms
== NULL_TREE
)
2570 exp
= build_value_init (type
, complain
);
2571 exp
= get_target_expr (exp
, complain
);
2575 /* Call the constructor. */
2576 releasing_vec parmvec
;
2577 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
2578 vec_safe_push (parmvec
, TREE_VALUE (parms
));
2579 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2580 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
2582 if (exp
== error_mark_node
)
2583 return error_mark_node
;
2585 return build_cplus_new (type
, exp
, complain
);
2589 build_functional_cast (location_t loc
, tree exp
, tree parms
,
2590 tsubst_flags_t complain
)
2592 tree result
= build_functional_cast_1 (loc
, exp
, parms
, complain
);
2593 protected_set_expr_location (result
, loc
);
2598 /* Add new exception specifier SPEC, to the LIST we currently have.
2599 If it's already in LIST then do nothing.
2600 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
2601 know what we're doing. */
2604 add_exception_specifier (tree list
, tree spec
, tsubst_flags_t complain
)
2609 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
2611 if (spec
== error_mark_node
)
2614 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
2616 /* [except.spec] 1, type in an exception specifier shall not be
2617 incomplete, or pointer or ref to incomplete other than pointer
2619 is_ptr
= TYPE_PTR_P (core
);
2620 if (is_ptr
|| TYPE_REF_P (core
))
2621 core
= TREE_TYPE (core
);
2624 else if (VOID_TYPE_P (core
))
2626 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
2628 else if (processing_template_decl
)
2630 else if (!verify_type_context (input_location
, TCTX_EXCEPTIONS
, core
,
2631 !(complain
& tf_error
)))
2632 return error_mark_node
;
2636 /* 15.4/1 says that types in an exception specifier must be complete,
2637 but it seems more reasonable to only require this on definitions
2638 and calls. So just give a pedwarn at this point; we will give an
2639 error later if we hit one of those two cases. */
2640 if (!COMPLETE_TYPE_P (complete_type (core
)))
2641 diag_type
= DK_PEDWARN
; /* pedwarn */
2648 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
2649 if (same_type_p (TREE_VALUE (probe
), spec
))
2652 list
= tree_cons (NULL_TREE
, spec
, list
);
2655 diag_type
= DK_ERROR
; /* error */
2657 if (diag_type
!= DK_UNSPECIFIED
2658 && (complain
& tf_warning_or_error
))
2659 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
2664 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
2667 nothrow_spec_p_uninst (const_tree spec
)
2669 if (DEFERRED_NOEXCEPT_SPEC_P (spec
))
2671 return nothrow_spec_p (spec
);
2674 /* Combine the two exceptions specifier lists LIST and ADD, and return
2678 merge_exception_specifiers (tree list
, tree add
)
2680 tree noex
, orig_list
;
2682 if (list
== error_mark_node
|| add
== error_mark_node
)
2683 return error_mark_node
;
2685 /* No exception-specifier or noexcept(false) are less strict than
2686 anything else. Prefer the newer variant (LIST). */
2687 if (!list
|| list
== noexcept_false_spec
)
2689 else if (!add
|| add
== noexcept_false_spec
)
2692 /* noexcept(true) and throw() are stricter than anything else.
2693 As above, prefer the more recent one (LIST). */
2694 if (nothrow_spec_p_uninst (add
))
2697 /* Two implicit noexcept specs (e.g. on a destructor) are equivalent. */
2698 if (UNEVALUATED_NOEXCEPT_SPEC_P (add
)
2699 && UNEVALUATED_NOEXCEPT_SPEC_P (list
))
2701 /* We should have instantiated other deferred noexcept specs by now. */
2702 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add
));
2704 if (nothrow_spec_p_uninst (list
))
2706 noex
= TREE_PURPOSE (list
);
2707 gcc_checking_assert (!TREE_PURPOSE (add
)
2708 || errorcount
|| !flag_exceptions
2709 || cp_tree_equal (noex
, TREE_PURPOSE (add
)));
2711 /* Combine the dynamic-exception-specifiers, if any. */
2713 for (; add
&& TREE_VALUE (add
); add
= TREE_CHAIN (add
))
2715 tree spec
= TREE_VALUE (add
);
2718 for (probe
= orig_list
; probe
&& TREE_VALUE (probe
);
2719 probe
= TREE_CHAIN (probe
))
2720 if (same_type_p (TREE_VALUE (probe
), spec
))
2724 spec
= build_tree_list (NULL_TREE
, spec
);
2725 TREE_CHAIN (spec
) = list
;
2730 /* Keep the noexcept-specifier at the beginning of the list. */
2731 if (noex
!= TREE_PURPOSE (list
))
2732 list
= tree_cons (noex
, TREE_VALUE (list
), TREE_CHAIN (list
));
2737 /* Subroutine of build_call. Ensure that each of the types in the
2738 exception specification is complete. Technically, 15.4/1 says that
2739 they need to be complete when we see a declaration of the function,
2740 but we should be able to get away with only requiring this when the
2741 function is defined or called. See also add_exception_specifier. */
2744 require_complete_eh_spec_types (tree fntype
, tree decl
)
2747 /* Don't complain about calls to op new. */
2748 if (decl
&& DECL_ARTIFICIAL (decl
))
2750 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
2751 raises
= TREE_CHAIN (raises
))
2753 tree type
= TREE_VALUE (raises
);
2754 if (type
&& !COMPLETE_TYPE_P (type
))
2758 ("call to function %qD which throws incomplete type %q#T",
2761 error ("call to function which throws incomplete type %q#T",
2767 /* Record that any TARGET_EXPR in T are going to be elided in
2768 cp_gimplify_init_expr (or sooner). */
2771 set_target_expr_eliding (tree t
)
2775 switch (TREE_CODE (t
))
2778 TARGET_EXPR_ELIDING_P (t
) = true;
2781 set_target_expr_eliding (TREE_OPERAND (t
, 1));
2784 set_target_expr_eliding (TREE_OPERAND (t
, 1));
2785 set_target_expr_eliding (TREE_OPERAND (t
, 2));
2793 /* Call the above in the process of building an INIT_EXPR. */
2796 cp_build_init_expr (location_t loc
, tree target
, tree init
)
2798 set_target_expr_eliding (init
);
2799 tree ie
= build2_loc (loc
, INIT_EXPR
, TREE_TYPE (target
),
2801 TREE_SIDE_EFFECTS (ie
) = true;