[PATCH] c++, libstdc++, v2: Implement C++26 P3074R7, P3726R0 and CWG3189 - trivial unions [PR119059]
Tomasz Kaminski
tkaminsk@redhat.com
Wed May 20 15:45:57 GMT 2026
On Wed, May 20, 2026 at 5:41 PM Jakub Jelinek <jakub@redhat.com> wrote:
> On Wed, May 20, 2026 at 02:00:27PM +0200, Tomasz Kaminski wrote:
> > I would like to see test user-provided constructors for union-like types,
> > something like:
> > union U { U(); int x; X b; }; // trivial for X = int, and deleted for
> T
> > = G (non-trivial destructor)
> > struct UL { UL(); union { int x; X b; } }; // same
> >
> > Also, for a non-default constructor and a union-like version of the above
> > union U { U(int); int x; X b; }; // All constructors matter, not only
> the
> > default one,
> > union U { U() = default; U(int); int x; X b; }; // all cosntructor
> > matters, not only default,
> > (above with union-like versions)
>
> I've added some tests.
>
> > This would be a follow-up regardless, but could you check if codegen for
> > the below
> > is now the same:
> > FixedVector<char, 4> f() {
> > return {'a', 'b', 'c'};
> > }
> > FixedVector<char, 4> g() {
> > constexpr FixedVector<char, 4> result{'a', 'b', 'c'};
> > return result;
> > }
> >
> > (Need a FixedVector from initializer_liust constructor )
> >
> > // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=124121
>
> The FixedVector doesn't have ctor from initializer_list; when using
> inplace_vector as is in the headers, f gets worse code generated,
> e.g. because start_lifetime_as uses inline asm.
>
Yes, but I removed asm locally (should not be need for runtime anyway
in this case), and the difference was still there. From what I could tell
it was because the constructor of inplace_vector from {'a', 'b', 'c'} was
not
constant folded, due unitialized element.
I will check that with your patch tomorrow.
>
> > > +constexpr A fA () { A a; a.a[0] = 1; return a; }
> > > +constexpr A a = fA (); // { dg-error "is not a constant
> > > expression" "" { xfail *-*-* } }
> > > +constexpr B fB () { B a; a.b[0] = 1; return a; }
> > > +constexpr B b = fB (); // { dg-error "is not a constant
> > > expression" "" { target c++23_down } }
> > > +constexpr C fC () { C a; a.b[0][0] = 1; a.b[1][0] = 2; a.b[1][1] = 3;
> > > return a; }
> > > +constexpr C c = fC (); // { dg-error "is not a constant
> > > expression" "" { target c++23_down } }
> > > +constexpr D fD () { D a; a.a.b[0] = 1; return a; }
> > > +constexpr D d = fD (); // { dg-error "is not a constant
> > > expression" "" { target c++23_down } }
> > > +constexpr E fE () { E a; a.a.b[0][0] = 1; a.a.b[1][0] = 2;
> a.a.b[1][1] =
> > > 3; return a; }
> > > +constexpr E e = fE (); // { dg-error "is not a constant
> > > expression" "" { target c++23_down } }
> > >
> > I think it's already mentioned in the commit message, but all of the
> above
> > should also fails in C++26 mode.
> > The assigments rules were not changed so a.b[0][0] = 1, starts the whole
> > array with all the elements,
> > and we have uninitialized elements inside, that are in-lifetime.
> >
> > To achieve the above, you should start_lifetime of the array first and
> only
> > then assign values to its elements,
> > so https://eel.is/c++draft/class.union#general-5 does not create an
> array
> > with elements.
>
> Haven't touched this yet.
> >
> > +static_assert (!is_defaulted (Octor) && !is_deleted (Octor));
> > > +static_assert (is_defaulted (Odtor) && is_deleted (Odtor));
> > >
> > I assume you are skipping questions about the constructor/destructor
> > anonymous union inside
> > union-like types on purpose?
>
> CWG3130 says they don't exist and I plan to work on resolving that soon,
> so trying to test those is pointless.
>
> > > +#if __glibcxx_start_lifetime >= 202603L // C++ >= 26
> > > +namespace std _GLIBCXX_VISIBILITY(default)
> > > +{
> > > +_GLIBCXX_BEGIN_NAMESPACE_VERSION
> > > +
> > > + template <class _Tp>
> > > + constexpr void
> > > + start_lifetime(_Tp& __r) noexcept
> > >
> > Could you move the declaration to
> libstdc++-v3/include/bits/stl_construct.h,
> > (we start_lifetime_as, cosntruct_as is). We do not not want to include
> > whole header.
>
> Moved.
>
> 2026-05-20 Jakub Jelinek <jakub@redhat.com>
>
> gcc/c-family/
> * c-cppbuiltin.cc (c_cpp_builtins): For C++26 predefine
> __cpp_trivial_union to 202603L.
> gcc/cp/
> * method.cc: Implement C++26 P3074R7 - trivial unions (was
> std::uninitialized<T>), P3726R2 - Adjustments to Union Lifetime
> Rules
> and proposed resolution of CWG3189 - Implicitly deleted destructors
> for union-like classes.
> (walk_field_subobs): Don't do default_init_uninitialized_part
> checks
> for variant members. Don't check subobject ctor/dtor for variant
> members for ctor/inheriting ctor or when subobject doesn't have
> member
> initializer for dtor and it is either the dtor_from_ctor case or
> the current class doesn't have user provided ctors.
> * class.cc (check_field_decl): Don't or in
> TYPE_HAS_NONTRIVIAL_DESTRUCTOR or TYPE_HAS_DEFAULT_CONSTRUCTOR of
> variant subobjects for C++26.
> * cp-tree.h (enum cp_built_in_function): Add
> CP_BUILT_IN_START_LIFETIME.
> (check_builtin_start_lifetime): Declare.
> (reduced_constant_expression_p): Add a bool argument defaulted to
> false.
> * tree.cc (builtin_valid_in_constant_expr_p): Handle
> CP_BUILT_IN_START_LIFETIME.
> * decl.cc (cxx_init_decl_processing): Create
> __builtin_start_lifetime
> decl.
> * cp-gimplify.cc (cp_gimplify_expr): Handle
> CP_BUILT_IN_START_LIFETIME.
> * semantics.cc (check_builtin_start_lifetime): New function.
> * constexpr.cc (cxx_eval_start_lifetime): New function.
> (cxx_eval_builtin_function_call): Handle
> CP_BUILT_IN_START_LIFETIME.
> (reduced_constant_expression_p): Add union_elemental_subobject
> argument and propagate it to recursive calls. If set, ignore holes
> in array initializers.
> (cxx_eval_store_expression): Add start_lifetime argument. Don't
> preevaluate init in tha tcase, return early if !seen_union after
> loop around the possibly nested ARRAY_REFs/COMPONENT_REFs etc.
> or when all union members are already active.
> gcc/testsuite/
> * g++.dg/DRs/dr2581-1.C: Expect warning for __cpp_trivial_union.
> * g++.dg/DRs/dr2581-2.C: Expect error for __cpp_trivial_union.
> * g++.dg/cpp26/feat-cxx26.C: Add __cpp_trivial_union checking.
> * g++.dg/cpp26/trivial-union1.C: New test.
> * g++.dg/cpp26/trivial-union2.C: New test.
> * g++.dg/cpp26/trivial-union3.C: New test.
> * g++.dg/cpp26/trivial-union4.C: New test.
> * g++.dg/cpp26/trivial-union5.C: New test.
> * g++.dg/cpp26/trivial-union6.C: New test.
> * g++.dg/reflect/trivial-union1.C: New test.
> * g++.dg/reflect/type_trait6.C: Adjust expected result of
> one is_destructible_type and two is_nothrow_destructible_type
> calls.
> * g++.dg/reflect/is_constructible_type1.C: Adjust expected result
> of one is_constructible_type call.
> * g++.dg/init/pr43719.C: Don't expect one error.
> * g++.dg/init/pr25811.C: Don't expect 3 diagnostic messages,
> instead expect a different one for C++98 only.
> * g++.dg/other/anon-union2.C: Only expect one diagnostic for
> C++23 and older.
> * g++.dg/cpp0x/union1.C: Only expect 6 diagnostic messages for
> C++23 and older.
> * g++.dg/cpp0x/union4.C: Only expect 3 diagnostic messages for
> C++23 and older.
> * g++.dg/cpp0x/defaulted2.C: Only expect 2 diagnostic messages for
> C++23 and older.
> libstdc++-v3/
> * include/bits/version.def (start_lifetime): New.
> * include/bits/version.h: Regenerate.
> * include/bits/stl_construct.h (std::start_lifetime): New function
> template.
> * include/std/memory: Define __glibcxx_want_start_lifetime before
> including bits/version.h.
> * src/c++23/std.cc.in: Add export std::start_lifetime.
>
> --- gcc/c-family/c-cppbuiltin.cc.jj 2026-05-20 08:43:02.545478650 +0200
> +++ gcc/c-family/c-cppbuiltin.cc 2026-05-20 14:26:01.233439033 +0200
> @@ -1122,6 +1122,7 @@ c_cpp_builtins (cpp_reader *pfile)
> cpp_define (pfile, "__cpp_impl_reflection=202603L");
> else
> cpp_warn (pfile, "__cpp_impl_reflection");
> + cpp_define (pfile, "__cpp_trivial_union=202603L");
> }
> if (flag_concepts && cxx_dialect > cxx14)
> cpp_define (pfile, "__cpp_concepts=202002L");
> --- gcc/cp/method.cc.jj 2026-05-20 08:43:02.566478296 +0200
> +++ gcc/cp/method.cc 2026-05-20 14:26:01.234439016 +0200
> @@ -2692,6 +2692,7 @@ walk_field_subobs (tree fields, special_
> enum { unknown, no, yes }
> only_dmi_mem = (sfk == sfk_constructor && TREE_CODE (ctx) == UNION_TYPE
> ? unknown : no);
> + int has_user_provided_ctor = -1;
>
> again:
> for (tree field = fields; field; field = DECL_CHAIN (field))
> @@ -2771,6 +2772,7 @@ walk_field_subobs (tree fields, special_
>
> bad = false;
> if (CP_TYPE_CONST_P (mem_type)
> + && TREE_CODE (ctx) != UNION_TYPE
> && default_init_uninitialized_part (mem_type))
> {
> if (diag)
> @@ -2847,6 +2849,22 @@ walk_field_subobs (tree fields, special_
> else
> argtype = NULL_TREE;
>
> + if (cxx_dialect >= cxx26 && TREE_CODE (ctx) == UNION_TYPE)
> + {
> + if (sfk == sfk_constructor || sfk == sfk_inheriting_constructor)
> + continue;
> +
> + if (sfk == sfk_destructor)
> + {
> + if (!dtor_from_ctor && has_user_provided_ctor == -1)
> + has_user_provided_ctor
> + = type_has_user_provided_constructor
> (current_class_type);
> + if (DECL_INITIAL (field) == NULL_TREE
> + && (dtor_from_ctor || !has_user_provided_ctor))
> + continue;
> + }
> + }
> +
> rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
>
> process_subob_fn (rval, sfk, spec_p, trivial_p, deleted_p,
> --- gcc/cp/class.cc.jj 2026-05-20 08:43:02.551478549 +0200
> +++ gcc/cp/class.cc 2026-05-20 14:26:01.235439000 +0200
> @@ -3903,17 +3903,25 @@ check_field_decl (tree field,
> else
> {
> TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
> - TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
> - |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
> TYPE_HAS_COMPLEX_COPY_ASSIGN (t)
> |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (type)
> || !TYPE_HAS_COPY_ASSIGN (type));
> TYPE_HAS_COMPLEX_COPY_CTOR (t) |= (TYPE_HAS_COMPLEX_COPY_CTOR
> (type)
> || !TYPE_HAS_COPY_CTOR
> (type));
> - TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) |= TYPE_HAS_COMPLEX_MOVE_ASSIGN
> (type);
> + TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
> + |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (type);
> TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_HAS_COMPLEX_MOVE_CTOR
> (type);
> - TYPE_HAS_COMPLEX_DFLT (t) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR
> (type)
> - || TYPE_HAS_COMPLEX_DFLT (type));
> + /* In C++26, triviality of default ctor or dtor of a variant
> member
> + doesn't matter for triviality of the t's default ctor or
> dtor. */
> + if (cxx_dialect < cxx26
> + || TREE_CODE (DECL_CONTEXT (field)) != UNION_TYPE)
> + {
> + TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
> + |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
> + TYPE_HAS_COMPLEX_DFLT (t)
> + |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)
> + || TYPE_HAS_COMPLEX_DFLT (type));
> + }
> }
>
> if (TYPE_HAS_COPY_CTOR (type)
> --- gcc/cp/cp-tree.h.jj 2026-05-20 08:43:07.245399375 +0200
> +++ gcc/cp/cp-tree.h 2026-05-20 14:26:01.237438967 +0200
> @@ -7245,6 +7245,7 @@ enum cp_built_in_function {
> CP_BUILT_IN_CONSTEXPR_DIAG,
> CP_BUILT_IN_CURRENT_EXCEPTION,
> CP_BUILT_IN_UNCAUGHT_EXCEPTIONS,
> + CP_BUILT_IN_START_LIFETIME,
> CP_BUILT_IN_LAST
> };
>
> @@ -8666,6 +8667,7 @@ extern tree fold_builtin_is_correspondin
> extern bool pointer_interconvertible_base_of_p (tree, tree, bool = false);
> extern tree fold_builtin_is_pointer_inverconvertible_with_class
> (location_t, int, tree *);
> extern tree fold_builtin_is_string_literal (location_t, int, tree *);
> +extern bool check_builtin_start_lifetime (location_t, int, tree *,
> tsubst_flags_t);
> extern tree finish_structured_binding_size (location_t, tree,
> tsubst_flags_t);
> extern tree finish_trait_expr (location_t, enum
> cp_trait_kind, tree, tree);
> extern tree finish_trait_type (enum cp_trait_kind, tree,
> tree, tsubst_flags_t);
> @@ -9435,7 +9437,7 @@ extern tree fold_non_dependent_init (tr
> bool = false, tree =
> NULL_TREE);
> extern tree fold_simple (tree);
> extern tree fold_to_constant (tree);
> -extern bool reduced_constant_expression_p (tree, tree = NULL_TREE);
> +extern bool reduced_constant_expression_p (tree, tree = NULL_TREE,
> bool = false);
> extern bool is_instantiation_of_constexpr (tree);
> extern bool var_in_constexpr_fn (tree);
> extern bool var_in_maybe_constexpr_fn (tree);
> --- gcc/cp/tree.cc.jj 2026-05-20 08:43:02.572478195 +0200
> +++ gcc/cp/tree.cc 2026-05-20 14:26:01.238177470 +0200
> @@ -574,6 +574,7 @@ builtin_valid_in_constant_expr_p (const_
> case CP_BUILT_IN_CONSTEXPR_DIAG:
> case CP_BUILT_IN_CURRENT_EXCEPTION:
> case CP_BUILT_IN_UNCAUGHT_EXCEPTIONS:
> + case CP_BUILT_IN_START_LIFETIME:
> return true;
> default:
> break;
> --- gcc/cp/decl.cc.jj 2026-05-20 08:43:02.564478330 +0200
> +++ gcc/cp/decl.cc 2026-05-20 14:26:01.240438917 +0200
> @@ -5663,6 +5663,13 @@ cxx_init_decl_processing (void)
> BUILT_IN_FRONTEND, NULL, NULL_TREE);
> set_call_expr_flags (decl, ECF_NOTHROW | ECF_LEAF);
>
> + tree void_vaftype = build_varargs_function_type_list (boolean_type_node,
> + NULL_TREE);
> + decl = add_builtin_function ("__builtin_start_lifetime",
> + void_vaftype, CP_BUILT_IN_START_LIFETIME,
> + BUILT_IN_FRONTEND, NULL, NULL_TREE);
> + set_call_expr_flags (decl, ECF_NOTHROW | ECF_LEAF);
> +
> integer_two_node = build_int_cst (NULL_TREE, 2);
>
> /* Guess at the initial static decls size. */
> --- gcc/cp/cp-gimplify.cc.jj 2026-05-20 08:43:02.554478498 +0200
> +++ gcc/cp/cp-gimplify.cc 2026-05-20 14:26:01.241438900 +0200
> @@ -1015,6 +1015,14 @@ cp_gimplify_expr (tree *expr_p, gimple_s
> case CP_BUILT_IN_CONSTEXPR_DIAG:
> *expr_p = void_node;
> break;
> + case CP_BUILT_IN_START_LIFETIME:
> + check_builtin_start_lifetime (EXPR_LOCATION (*expr_p),
> + call_expr_nargs (*expr_p),
> + call_expr_nargs (*expr_p)
> + ? &CALL_EXPR_ARG (*expr_p, 0)
> + : NULL,
> + tf_warning_or_error);
> + *expr_p = void_node;
> default:
> break;
> }
> --- gcc/cp/semantics.cc.jj 2026-05-20 08:43:07.247399342 +0200
> +++ gcc/cp/semantics.cc 2026-05-20 14:26:01.242438884 +0200
> @@ -13989,6 +13989,53 @@ fold_builtin_is_string_literal (location
> return boolean_true_node;
> }
>
> +/* Perform __builtin_start_lifetime call checking, return false
> + when errors are reported. */
> +
> +bool
> +check_builtin_start_lifetime (location_t loc, int nargs, tree *args,
> + tsubst_flags_t complain)
> +{
> + /* Unless users call the builtin directly, the following 2 checks
> should be
> + ensured from std::start_lifetime template. */
> + if (nargs != 1)
> + {
> + if (complain & tf_error)
> + error_at (loc, "%<__builtin_start_lifetime%> needs a single "
> + "argument");
> + return false;
> + }
> + tree arg = args[0];
> + if (error_operand_p (arg))
> + return false;
> + tree ptype = TREE_TYPE (arg);
> + if (!POINTER_TYPE_P (ptype))
> + {
> + if (complain & tf_error)
> + error_at (loc, "%<__builtin_start_lifetime%> argument type %qT "
> + "is not pointer type", ptype);
> + return false;
> + }
> + tree type = TREE_TYPE (ptype);
> + if (!complete_type_or_else (type, NULL_TREE))
> + return false;
> + if (!CP_AGGREGATE_TYPE_P (type))
> + {
> + if (complain & tf_error)
> + error_at (loc, "%<__builtin_start_lifetime%> argument type %qT "
> + "is not a pointer to aggregate type", ptype);
> + return false;
> + }
> + if (!implicit_lifetime_type_p (type))
> + {
> + if (complain & tf_error)
> + error_at (loc, "%<__builtin_start_lifetime%> argument type %qT "
> + "is not a pointer to implicit-lifetime type", ptype);
> + return false;
> + }
> + return true;
> +}
> +
> /* [basic.types] 8. True iff TYPE is an object type. */
>
> static bool
> --- gcc/cp/constexpr.cc.jj 2026-05-20 08:43:07.244399392 +0200
> +++ gcc/cp/constexpr.cc 2026-05-20 14:26:01.243438867 +0200
> @@ -2456,6 +2456,49 @@ cxx_eval_constexpr_diag (const constexpr
> return void_node;
> }
>
> +static tree cxx_eval_store_expression (const constexpr_ctx *, tree,
> + value_cat, bool *, bool *,
> + tree *, bool = false);
> +
> +/* Attempt to evaluate T which represents a call to
> + __builtin_start_lifetime. */
> +
> +static tree
> +cxx_eval_start_lifetime (const constexpr_ctx *ctx, tree t, bool
> *non_constant_p,
> + bool *overflow_p, tree *jump_target)
> +{
> + location_t loc = EXPR_LOCATION (t);
> + if (!check_builtin_start_lifetime (loc, call_expr_nargs (t),
> + call_expr_nargs (t)
> + ? &CALL_EXPR_ARG (t, 0) : NULL,
> + ctx->quiet ? tf_none
> + : tf_warning_or_error))
> + {
> + *non_constant_p = true;
> + return t;
> + }
> + tree arg = CALL_EXPR_ARG (t, 0);
> + arg = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (arg)), arg);
> + arg = cxx_eval_constant_expression (ctx, arg, vc_glvalue,
> + non_constant_p, overflow_p,
> + jump_target);
> + if (*jump_target)
> + return NULL_TREE;
> + if (*non_constant_p)
> + return t;
> + tree ctor = build_constructor (TREE_TYPE (arg), NULL);
> + CONSTRUCTOR_NO_CLEARING (ctor) = 1;
> + tree modexpr = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, ctor);
> + arg = cxx_eval_store_expression (ctx, modexpr, vc_discard,
> non_constant_p,
> + overflow_p, jump_target, true);
> + ggc_free (modexpr);
> + if (*jump_target)
> + return NULL_TREE;
> + if (*non_constant_p)
> + return t;
> + return void_node;
> +}
> +
> /* Attempt to evaluate T which represents a call to a builtin function.
> We assume here that all builtin functions evaluate to scalar types
> represented by _CST nodes. */
> @@ -2529,6 +2572,10 @@ cxx_eval_builtin_function_call (const co
> return cxx_eval_constexpr_diag (ctx, t, non_constant_p, overflow_p,
> jump_target);
>
> + case CP_BUILT_IN_START_LIFETIME:
> + return cxx_eval_start_lifetime (ctx, t, non_constant_p,
> overflow_p,
> + jump_target);
> +
> default:
> break;
> }
> @@ -4708,7 +4755,8 @@ cxx_eval_call_expression (const constexp
> FIXME speed this up, it's taking 16% of compile time on sieve
> testcase. */
>
> bool
> -reduced_constant_expression_p (tree t, tree sz /* = NULL_TREE */)
> +reduced_constant_expression_p (tree t, tree sz /* = NULL_TREE */,
> + bool union_elemental_subobject /* = false
> */)
> {
> if (t == NULL_TREE)
> return false;
> @@ -4732,7 +4780,10 @@ reduced_constant_expression_p (tree t, t
> return false;
> if (CONSTRUCTOR_NO_CLEARING (t))
> {
> - if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
> + if (union_elemental_subobject
> + && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
> + field = NULL_TREE;
> + else if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
> {
> /* There must be a valid constant initializer at every array
> index. */
> @@ -4766,12 +4817,25 @@ reduced_constant_expression_p (tree t, t
> active member has no constituent values, so all
> constituent
> values are constant. */
> field = NULL_TREE;
> + union_elemental_subobject = cxx_dialect >= cxx26;
> }
> else
> - field = next_subobject_field (TYPE_FIELDS (TREE_TYPE (t)));
> + {
> + field = next_subobject_field (TYPE_FIELDS (TREE_TYPE (t)));
> + union_elemental_subobject = false;
> + }
> }
> else
> - field = NULL_TREE;
> + {
> + field = NULL_TREE;
> + if (cxx_dialect >= cxx26)
> + {
> + if (TREE_CODE (TREE_TYPE (t)) == UNION_TYPE)
> + union_elemental_subobject = true;
> + else if (TREE_CODE (TREE_TYPE (t)) != ARRAY_TYPE)
> + union_elemental_subobject = false;
> + }
> + }
> for (auto &e: CONSTRUCTOR_ELTS (t))
> {
> /* If VAL is null, we're in the middle of initializing this
> @@ -4781,7 +4845,8 @@ reduced_constant_expression_p (tree t, t
> && (TREE_CODE (e.index)
> == FIELD_DECL))
> ? DECL_SIZE (e.index)
> - : NULL_TREE))
> + : NULL_TREE,
> + union_elemental_subobject))
> return false;
> /* We want to remove initializers for empty fields in a struct to
> avoid confusing output_constructor. */
> @@ -7817,7 +7882,7 @@ static tree
> cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
> value_cat lval,
> bool *non_constant_p, bool *overflow_p,
> - tree *jump_target)
> + tree *jump_target, bool
> start_lifetime/*=false*/)
> {
> constexpr_ctx new_ctx = *ctx;
>
> @@ -7830,7 +7895,7 @@ cxx_eval_store_expression (const constex
>
> tree type = TREE_TYPE (target);
> bool preeval = SCALAR_TYPE_P (type) || TREE_CODE (t) == MODIFY_EXPR;
> - if (preeval && !TREE_CLOBBER_P (init))
> + if (preeval && !TREE_CLOBBER_P (init) && !start_lifetime)
> {
> /* Ignore var = .DEFERRED_INIT (); for now, until PR121965 is
> fixed. */
> if (flag_auto_var_init > AUTO_INIT_UNINITIALIZED
> @@ -8037,6 +8102,11 @@ cxx_eval_store_expression (const constex
> const_object_being_modified = NULL_TREE;
> }
>
> + /* For __builtin_start_lifetime, if no union is involved, no need to
> + change anything. */
> + if (start_lifetime && !seen_union)
> + return void_node;
> +
> type = TREE_TYPE (object);
> bool no_zero_init = true;
> bool zero_padding_bits = false;
> @@ -8170,12 +8240,13 @@ cxx_eval_store_expression (const constex
> index);
> *non_constant_p = true;
> }
> - else if (!is_access_expr
> - || (TREE_CLOBBER_P (init)
> - && CLOBBER_KIND (init) >= CLOBBER_OBJECT_END)
> - || (TREE_CODE (t) == MODIFY_EXPR
> - && CLASS_TYPE_P (inner)
> - && !type_has_non_deleted_trivial_default_ctor
> (inner)))
> + else if ((!is_access_expr
> + || (TREE_CLOBBER_P (init)
> + && CLOBBER_KIND (init) >= CLOBBER_OBJECT_END)
> + || (TREE_CODE (t) == MODIFY_EXPR
> + && CLASS_TYPE_P (inner)
> + && !type_has_non_deleted_trivial_default_ctor
> (inner)))
> + && !start_lifetime)
> {
> /* Diagnose changing active union member after initialization
> without a valid member access expression, as described in
> @@ -8221,6 +8292,10 @@ cxx_eval_store_expression (const constex
> }
> no_zero_init = true;
> }
> + /* If this is the innermost union and we aren't changing active
> member
> + of it during start_lifetime, we don't need to change anything. */
> + else if (code == UNION_TYPE && start_lifetime && seen_union == 1)
> + return void_node;
>
> /* Ending the lifetime of the active union member means the union no
> longer has an active member. */
> --- gcc/testsuite/g++.dg/DRs/dr2581-1.C.jj 2026-05-20
> 08:43:02.577478111 +0200
> +++ gcc/testsuite/g++.dg/DRs/dr2581-1.C 2026-05-20 14:26:01.244438851 +0200
> @@ -94,7 +94,7 @@
> #undef __cpp_template_parameters
> #undef __cpp_template_template_args // { dg-warning "undefining
> '__cpp_template_template_args'" "" { target c++20 } }
> #undef __cpp_threadsafe_static_init // { dg-warning "undefining
> '__cpp_threadsafe_static_init'" "" { target c++20 } }
> -#undef __cpp_trivial_union
> +#undef __cpp_trivial_union // { dg-warning "undefining
> '__cpp_trivial_union'" "" { target c++26 } }
> #undef __cpp_unicode_characters // { dg-warning
> "undefining '__cpp_unicode_characters'" "" { target c++20 } }
> #undef __cpp_unicode_literals // { dg-warning "undefining
> '__cpp_unicode_literals'" "" { target c++20 } }
> #undef __cpp_user_defined_literals // { dg-warning "undefining
> '__cpp_user_defined_literals'" "" { target c++20 } }
> --- gcc/testsuite/g++.dg/DRs/dr2581-2.C.jj 2026-05-20
> 08:43:02.577478111 +0200
> +++ gcc/testsuite/g++.dg/DRs/dr2581-2.C 2026-05-20 14:26:01.244751680 +0200
> @@ -95,7 +95,7 @@
> #define __cpp_template_parameters 202502L
> #define __cpp_template_template_args 201611L // { dg-error
> "'__cpp_template_template_args' redefined" "" { target c++20 } }
> #define __cpp_threadsafe_static_init 200806L // { dg-error
> "'__cpp_threadsafe_static_init' redefined" "" { target c++20 } }
> -#define __cpp_trivial_union 202502L
> +#define __cpp_trivial_union 202603L // { dg-error
> "'__cpp_trivial_union' redefined" "" { target c++26 } }
> #define __cpp_unicode_characters 200704L // { dg-error
> "'__cpp_unicode_characters' redefined" "" { target c++17 } }
> #define __cpp_unicode_literals 200710L // { dg-error
> "'__cpp_unicode_literals' redefined" "" { target c++20 } }
> #define __cpp_user_defined_literals 200809L // { dg-error
> "'__cpp_user_defined_literals' redefined" "" { target c++20 } }
> --- gcc/testsuite/g++.dg/cpp0x/union1.C.jj 2026-03-27
> 10:17:15.542307763 +0100
> +++ gcc/testsuite/g++.dg/cpp0x/union1.C 2026-05-20 14:26:01.248075538 +0200
> @@ -14,7 +14,7 @@ union B
> A a; // { dg-error "union member" }
> };
>
> -B b; // { dg-error "B::B\\(\\)" "B::B" }
> +B b; // { dg-error "B::B\\(\\)" "B::B" { target
> c++23_down } }
> B b2(b); // { dg-error "B::B\\(const B&\\)" "B::B" }
>
> struct C
> @@ -25,10 +25,10 @@ struct C
> };
> };
>
> -C c; // { dg-error "C::C\\(\\)" "C::C" }
> +C c; // { dg-error "C::C\\(\\)" "C::C" { target
> c++23_down } }
> C c2(c); // { dg-error "C::C\\(const C&\\)" "C::C" }
>
> -// { dg-error "B::~B" "B::~B" { target *-*-* } 17 }
> -// { dg-error "B::~B" "B::~B" { target *-*-* } 18 }
> -// { dg-error "C::~C" "C::~C" { target *-*-* } 28 }
> -// { dg-error "C::~C" "C::~C" { target *-*-* } 29 }
> +// { dg-error "B::~B" "B::~B" { target c++23_down } 17 }
> +// { dg-error "B::~B" "B::~B" { target c++23_down } 18 }
> +// { dg-error "C::~C" "C::~C" { target c++23_down } 28 }
> +// { dg-error "C::~C" "C::~C" { target c++23_down } 29 }
> --- gcc/testsuite/g++.dg/cpp0x/union4.C.jj 2026-03-27
> 10:17:15.542307763 +0100
> +++ gcc/testsuite/g++.dg/cpp0x/union4.C 2026-05-20 14:26:01.248438784 +0200
> @@ -3,15 +3,15 @@
>
> struct SFoo
> {
> - SFoo() =delete; // { dg-message "declared" }
> + SFoo() =delete; // { dg-message "declared" "" { target
> c++23_down } }
> };
>
> -union UFoo // { dg-error "deleted" }
> +union UFoo // { dg-error "deleted" "" { target
> c++23_down } }
> {
> SFoo foo;
> };
>
> int main()
> {
> - UFoo(); // { dg-error "deleted" }
> + UFoo(); // { dg-error "deleted" "" { target
> c++23_down } }
> }
> --- gcc/testsuite/g++.dg/cpp0x/defaulted2.C.jj 2026-03-27
> 10:17:15.446309330 +0100
> +++ gcc/testsuite/g++.dg/cpp0x/defaulted2.C 2026-05-20
> 14:26:01.248646182 +0200
> @@ -55,7 +55,7 @@ G::G() = default;
>
> union U
> {
> - G g; // { dg-error "union member.*non-trivial" }
> + G g; // { dg-error "union member.*non-trivial"
> "" { target c++23_down } }
> };
>
> int main()
> @@ -63,7 +63,7 @@ int main()
> F f;
> F f2(f); // { dg-error "use" }
> const B* b = new const B; // { dg-error "uninitialized
> const" }
> - U u; // { dg-error "deleted" }
> + U u; // { dg-error "deleted" "" { target
> c++23_down } }
> }
>
> // { dg-prune-output "implicitly deleted because" }
> --- gcc/testsuite/g++.dg/cpp26/feat-cxx26.C.jj 2026-05-20
> 08:43:02.579478077 +0200
> +++ gcc/testsuite/g++.dg/cpp26/feat-cxx26.C 2026-05-20
> 14:26:01.245053195 +0200
> @@ -652,3 +652,9 @@
> #elif __cpp_expansion_statements != 202506
> # error "__cpp_expansion_statements != 202506"
> #endif
> +
> +#ifndef __cpp_trivial_union
> +# error "__cpp_trivial_union"
> +#elif __cpp_trivial_union != 202603
> +# error "__cpp_trivial_union != 202603"
> +#endif
> --- gcc/testsuite/g++.dg/cpp26/trivial-union1.C.jj 2026-05-20
> 14:26:01.245197174 +0200
> +++ gcc/testsuite/g++.dg/cpp26/trivial-union1.C 2026-05-20
> 17:26:39.297942500 +0200
> @@ -0,0 +1,93 @@
> +// P3074R7 - trivial unions (was std::uninitialized<T>)
> +// P3726R2 - Adjustments to Union Lifetime Rules
> +// { dg-do compile { target c++11 } }
> +
> +#include <type_traits>
> +
> +// These two were incorrectly deleted.
> +union A { int a; const int b; };
> +static_assert (std::is_default_constructible <A>::value, "");
> +static_assert (std::is_trivially_default_constructible <A>::value, "");
> +static_assert (std::is_destructible <A>::value, "");
> +static_assert (std::is_trivially_destructible <A>::value, "");
> +struct B { int a; union { int b; const int c; }; };
> +static_assert (std::is_default_constructible <B>::value, "");
> +static_assert (std::is_trivially_default_constructible <B>::value, "");
> +static_assert (std::is_destructible <B>::value, "");
> +static_assert (std::is_trivially_destructible <B>::value, "");
> +// C::C() is incorrectly not deleted in C++11 to 23, but in C++26 it
> should
> +// not be deleted.
> +union C { const int a = 42; const long b; ~C (); };
> +#if __cpp_trivial_union >= 202502L
> +static_assert (std::is_default_constructible <C>::value, "");
> +static_assert (!std::is_trivially_default_constructible <C>::value, "");
> +static_assert (std::is_destructible <C>::value, "");
> +static_assert (!std::is_trivially_destructible <C>::value, "");
> +#endif
> +struct D { D () = delete; D (int); ~D () = default; };
> +union E { D a = 42; D b; ~E (); };
> +static_assert (std::is_default_constructible <E>::value, "");
> +static_assert (std::is_destructible <E>::value, "");
> +struct F { int a; union { D b = 42; D c; }; };
> +static_assert (std::is_default_constructible <F>::value, "");
> +static_assert (std::is_destructible <F>::value, "");
> +struct G { G (); ~G (); };
> +union I { int a; const int b; ~I (); };
> +static_assert (std::is_default_constructible <I>::value, "");
> +static_assert (!std::is_trivially_default_constructible <I>::value, "");
> +static_assert (std::is_destructible <I>::value, "");
> +static_assert (!std::is_trivially_destructible <I>::value, "");
> +union J { D a; int b; };
> +#if __cpp_trivial_union >= 202502L
> +static_assert (std::is_default_constructible <J>::value, "");
> +static_assert (std::is_trivially_default_constructible <J>::value, "");
> +#else
> +static_assert (!std::is_default_constructible <J>::value, "");
> +static_assert (!std::is_trivially_default_constructible <J>::value, "");
> +#endif
> +static_assert (std::is_destructible <J>::value, "");
> +static_assert (std::is_trivially_destructible <J>::value, "");
> +union K { G a; int b; };
> +#if __cpp_trivial_union >= 202502L
> +static_assert (std::is_default_constructible <K>::value, "");
> +static_assert (std::is_trivially_default_constructible <K>::value, "");
> +static_assert (std::is_destructible <K>::value, "");
> +static_assert (std::is_trivially_destructible <K>::value, "");
> +#else
> +static_assert (!std::is_default_constructible <K>::value, "");
> +static_assert (!std::is_trivially_default_constructible <K>::value, "");
> +static_assert (!std::is_destructible <K>::value, "");
> +static_assert (!std::is_trivially_destructible <K>::value, "");
> +#endif
> +struct L { int a; union { G b; int c; }; };
> +#if __cpp_trivial_union >= 202502L
> +static_assert (std::is_default_constructible <L>::value, "");
> +static_assert (std::is_trivially_default_constructible <L>::value, "");
> +static_assert (std::is_destructible <L>::value, "");
> +static_assert (std::is_trivially_destructible <L>::value, "");
> +#else
> +static_assert (!std::is_default_constructible <L>::value, "");
> +static_assert (!std::is_trivially_default_constructible <L>::value, "");
> +static_assert (!std::is_destructible <L>::value, "");
> +static_assert (!std::is_trivially_destructible <L>::value, "");
> +#endif
> +union M { M (); int a; int b; };
> +static_assert (std::is_default_constructible <M>::value, "");
> +static_assert (!std::is_trivially_default_constructible <M>::value, "");
> +static_assert (std::is_destructible <M>::value, "");
> +static_assert (std::is_trivially_destructible <M>::value, "");
> +union N { N (); int a; G b; };
> +static_assert (!std::is_default_constructible <N>::value, "");
> +static_assert (!std::is_trivially_default_constructible <N>::value, "");
> +static_assert (!std::is_destructible <N>::value, "");
> +static_assert (!std::is_trivially_destructible <N>::value, "");
> +struct O { O (); union { int a; int b; }; };
> +static_assert (std::is_default_constructible <O>::value, "");
> +static_assert (!std::is_trivially_default_constructible <O>::value, "");
> +static_assert (std::is_destructible <O>::value, "");
> +static_assert (std::is_trivially_destructible <O>::value, "");
> +struct P { P (); union { int a; G b; }; };
> +static_assert (!std::is_default_constructible <P>::value, "");
> +static_assert (!std::is_trivially_default_constructible <P>::value, "");
> +static_assert (!std::is_destructible <P>::value, "");
> +static_assert (!std::is_trivially_destructible <P>::value, "");
> --- gcc/testsuite/g++.dg/cpp26/trivial-union2.C.jj 2026-05-20
> 14:26:01.245359408 +0200
> +++ gcc/testsuite/g++.dg/cpp26/trivial-union2.C 2026-05-20
> 14:26:01.245359408 +0200
> @@ -0,0 +1,8 @@
> +// P3074R7 - trivial unions (was std::uninitialized<T>)
> +// P3726R2 - Adjustments to Union Lifetime Rules
> +// { dg-do compile { target c++20 } }
> +
> +union U { int a, b; };
> +template<U u> class X {};
> +constexpr U make() { U u; return u; }
> +void f(X<make()>) {}
> --- gcc/testsuite/g++.dg/cpp26/trivial-union3.C.jj 2026-05-20
> 14:26:01.245486713 +0200
> +++ gcc/testsuite/g++.dg/cpp26/trivial-union3.C 2026-05-20
> 14:26:01.245486713 +0200
> @@ -0,0 +1,28 @@
> +// P3074R7 - trivial unions (was std::uninitialized<T>)
> +// P3726R2 - Adjustments to Union Lifetime Rules
> +// { dg-do compile { target c++26 } }
> +
> +#include <memory>
> +#include <string>
> +
> +template <typename T, size_t N>
> +struct FixedVector {
> + union { T storage[N]; };
> + size_t size = 0;
> +
> + constexpr FixedVector () { std::start_lifetime (storage); }
> +
> + constexpr ~FixedVector() { std::destroy(storage, storage + size); }
> +
> + constexpr void push_back(T const& v) { ::new (storage + size) T(v);
> ++size; }
> +};
> +
> +constexpr size_t
> +silly_test ()
> +{
> + FixedVector <std::string, 3> v;
> + v.push_back ("some sufficiently longer string");
> + return v.size;
> +}
> +
> +static_assert (silly_test () == 1);
> --- gcc/testsuite/g++.dg/cpp26/trivial-union4.C.jj 2026-05-20
> 14:26:01.245562152 +0200
> +++ gcc/testsuite/g++.dg/cpp26/trivial-union4.C 2026-05-20
> 14:26:01.245562152 +0200
> @@ -0,0 +1,63 @@
> +// P3074R7 - trivial unions (was std::uninitialized<T>)
> +// P3726R2 - Adjustments to Union Lifetime Rules
> +// { dg-do compile { target c++26 } }
> +
> +namespace std {
> + template <class T>
> + constexpr void
> + start_lifetime (T &r) noexcept
> + {
> + __builtin_start_lifetime (__builtin_addressof (r));
> + }
> +}
> +
> +struct S { int a; };
> +union U { int a; S b[3]; };
> +union V { int a; U b[2]; };
> +
> +consteval
> +{
> + S s;
> + s.a = 42;
> + std::start_lifetime (s);
> + if (s.a != 42)
> + throw 1;
> + U u;
> + u.b[0].a = 42;
> + std::start_lifetime (u.b);
> + std::start_lifetime (u.b[0]);
> + std::start_lifetime (u.b[2]);
> + u.a = 42;
> + std::start_lifetime (u.b);
> + std::start_lifetime (u.b[0]);
> + std::start_lifetime (u.b[1]);
> + V v;
> + v.a = 42;
> + std::start_lifetime (v.b);
> + std::start_lifetime (v.b[1]);
> + v.b[1].a = 42;
> + std::start_lifetime (v.b[1].b);
> + std::start_lifetime (v.b[1].b[1]);
> + v.b[1].b[1].a = 43;
> + std::start_lifetime (v.b);
> + std::start_lifetime (v.b[1].b[1]);
> + if (v.b[1].b[1].a != 43)
> + throw 2;
> + const S cs = { 42 };
> + std::start_lifetime (cs);
> + if (cs.a != 42)
> + throw 3;
> + const U cu = { .b = { { 41 }, { 42 }, { 43 } } };
> + std::start_lifetime (cu.b);
> + std::start_lifetime (cu.b[0]);
> + std::start_lifetime (cu.b[2]);
> + if (cu.b[2].a != 43)
> + throw 4;
> + const V cv = { .b = { { .b = { { 44 } } } } };
> + std::start_lifetime (cv.b);
> + std::start_lifetime (cv.b[0]);
> + std::start_lifetime (cv.b[0].b);
> + std::start_lifetime (cv.b[0].b[0]);
> + if (cv.b[0].b[0].a != 44)
> + throw 5;
> +}
> --- gcc/testsuite/g++.dg/cpp26/trivial-union5.C.jj 2026-05-20
> 14:26:01.245655416 +0200
> +++ gcc/testsuite/g++.dg/cpp26/trivial-union5.C 2026-05-20
> 14:26:01.245655416 +0200
> @@ -0,0 +1,37 @@
> +// P3074R7 - trivial unions (was std::uninitialized<T>)
> +// P3726R2 - Adjustments to Union Lifetime Rules
> +// { dg-do compile { target c++26 } }
> +
> +struct S { int a; };
> +S a = { 5 };
> +struct T { constexpr T () : a (42) {} int a; };
> +struct R { int a; constexpr ~R () {} };
> +union U { int a; S b[2]; };
> +
> +consteval { int a = 5; __builtin_start_lifetime (&a); } //
> { dg-error "'__builtin_start_lifetime' argument type 'int\\\*' is not a
> pointer to aggregate type" }
> +consteval { __builtin_start_lifetime (&a); }; // {
> dg-error "modification of 'a' from outside current evaluation is not a
> constant expression" }
> +consteval { __builtin_start_lifetime (); }; // {
> dg-error "'__builtin_start_lifetime' needs a single argument" }
> +consteval { S a = { 6 }; __builtin_start_lifetime (&a, &a); }; // {
> dg-error "'__builtin_start_lifetime' needs a single argument" }
> +consteval { __builtin_start_lifetime (42); }; // {
> dg-error "'__builtin_start_lifetime' argument type 'int' is not pointer
> type" }
> +consteval { T t; __builtin_start_lifetime (&t); } // {
> dg-error "'__builtin_start_lifetime' argument type 'T\\\*' is not a pointer
> to aggregate type" }
> +consteval { R r; __builtin_start_lifetime (&r); } // {
> dg-error "'__builtin_start_lifetime' argument type 'R\\\*' is not a pointer
> to implicit-lifetime type" }
> +consteval { const U u = { .a = 42 }; __builtin_start_lifetime (&u.a); }
> // { dg-error "'__builtin_start_lifetime' argument type 'const
> int\\\*' is not a pointer to aggregate type" }
> +consteval { const U u = { .a = 42 }; __builtin_start_lifetime (&u.b); }
> // { dg-error "modifying a const object 'u.U::b' is not allowed in a
> constant expression" }
> +
> +void
> +foo ()
> +{
> + S s;
> + __builtin_start_lifetime (&s);
> + int a = 5;
> + __builtin_start_lifetime (&a); // { dg-error
> "'__builtin_start_lifetime' argument type 'int\\\*' is not a pointer to
> aggregate type" }
> + __builtin_start_lifetime (&::a);
> + __builtin_start_lifetime (); // { dg-error
> "'__builtin_start_lifetime' needs a single argument" }
> + S b = { 6 };
> + __builtin_start_lifetime (&b, &b); // { dg-error
> "'__builtin_start_lifetime' needs a single argument" }
> + __builtin_start_lifetime (42); // { dg-error
> "'__builtin_start_lifetime' argument type 'int' is not pointer type" }
> + T t;
> + __builtin_start_lifetime (&t); // { dg-error
> "'__builtin_start_lifetime' argument type 'T\\\*' is not a pointer to
> aggregate type" }
> + R r;
> + __builtin_start_lifetime (&r); // { dg-error
> "'__builtin_start_lifetime' argument type 'R\\\*' is not a pointer to
> implicit-lifetime type" }
> +}
> --- gcc/testsuite/g++.dg/cpp26/trivial-union6.C.jj 2026-05-20
> 14:26:01.245756124 +0200
> +++ gcc/testsuite/g++.dg/cpp26/trivial-union6.C 2026-05-20
> 14:26:01.245756124 +0200
> @@ -0,0 +1,26 @@
> +// P3074R7 - trivial unions (was std::uninitialized<T>)
> +// P3726R2 - Adjustments to Union Lifetime Rules
> +// { dg-do compile { target c++20 } }
> +
> +struct A { int a[2]; };
> +union B { int a; int b[2]; };
> +union C { int a; int b[2][2]; };
> +struct D { B a; };
> +struct E { C a; };
> +union F { int a; A b; };
> +union G { int a; A b[2]; };
> +
> +constexpr A fA () { A a; a.a[0] = 1; return a; }
> +constexpr A a = fA (); // { dg-error "is not a constant
> expression" "" { xfail *-*-* } }
> +constexpr B fB () { B a; a.b[0] = 1; return a; }
> +constexpr B b = fB (); // { dg-error "is not a constant
> expression" "" { target c++23_down } }
> +constexpr C fC () { C a; a.b[0][0] = 1; a.b[1][0] = 2; a.b[1][1] = 3;
> return a; }
> +constexpr C c = fC (); // { dg-error "is not a constant
> expression" "" { target c++23_down } }
> +constexpr D fD () { D a; a.a.b[0] = 1; return a; }
> +constexpr D d = fD (); // { dg-error "is not a constant
> expression" "" { target c++23_down } }
> +constexpr E fE () { E a; a.a.b[0][0] = 1; a.a.b[1][0] = 2; a.a.b[1][1] =
> 3; return a; }
> +constexpr E e = fE (); // { dg-error "is not a constant
> expression" "" { target c++23_down } }
> +constexpr F fF () { F a; a.b.a[0] = 1; return a; }
> +constexpr F f = fF (); // { dg-error "is not a constant
> expression" }
> +constexpr G fG () { G a; a.b[0].a[0] = 1; return a; }
> +constexpr G g = fG (); // { dg-error "is not a constant
> expression" }
> --- gcc/testsuite/g++.dg/init/pr43719.C.jj 2026-04-29
> 07:45:23.186351218 +0200
> +++ gcc/testsuite/g++.dg/init/pr43719.C 2026-05-20 14:26:01.247279549 +0200
> @@ -109,7 +109,7 @@ struct Z // { dg-error "deleted" "" { t
> Z5 z5;
> };
>
> -union U // { dg-error "uninitialized" "" { target c++11 } }
> +union U
> {
> int const i; // { dg-message "should be initialized" }
> };
> --- gcc/testsuite/g++.dg/init/pr25811.C.jj 2026-04-29
> 07:45:23.183351272 +0200
> +++ gcc/testsuite/g++.dg/init/pr25811.C 2026-05-20 14:26:01.247438801 +0200
> @@ -124,10 +124,9 @@ struct Z // { dg-error "deleted" "" { ta
> Z5 z5;
> };
>
> -union U // { dg-message "implicitly deleted" "" { target c++11 } }
> - // { dg-error "uninitialized" "" { target c++11 } .-1 }
> +union U
> {
> - int const i; // { dg-message "should be initialized" }
> + int const i;
> };
>
> void f1 ()
> @@ -207,5 +206,5 @@ void f15 ()
>
> void f16 ()
> {
> - new U; // { dg-error "deleted|uninitialized const member" }
> + new U; // { dg-error "uninitialized const member in 'union U' using
> 'new' without new-initializer" "" { target c++98_only } }
> }
> --- gcc/testsuite/g++.dg/other/anon-union2.C.jj 2026-03-27
> 10:17:16.040299637 +0100
> +++ gcc/testsuite/g++.dg/other/anon-union2.C 2026-05-20
> 14:26:01.247698101 +0200
> @@ -6,5 +6,5 @@ struct S {
> };
>
> void f() {
> - union { S a; }; // { dg-error "constructor|no match" }
> + union { S a; }; // { dg-error "constructor|no match" "" {
> target c++23_down } }
> }
> --- gcc/testsuite/g++.dg/reflect/trivial-union1.C.jj 2026-05-20
> 14:26:01.245919804 +0200
> +++ gcc/testsuite/g++.dg/reflect/trivial-union1.C 2026-05-20
> 14:26:01.245919804 +0200
> @@ -0,0 +1,108 @@
> +// P3074R7 - trivial unions (was std::uninitialized<T>)
> +// P3726R2 - Adjustments to Union Lifetime Rules
> +// { dg-do compile { target c++26 } }
> +// { dg-additional-options "-freflection" }
> +
> +#include <meta>
> +#include <ranges>
> +
> +using namespace std::meta;
> +constexpr auto ctx = std::meta::access_context::unchecked ();
> +union A { int a; const int b; };
> +static_assert (is_default_constructible_type (^^A));
> +static_assert (is_trivially_default_constructible_type (^^A));
> +static_assert (is_destructible_type (^^A));
> +static_assert (is_trivially_destructible_type (^^A));
> +constexpr auto Actor = (members_of (^^A, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Adtor = (members_of (^^A, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (is_defaulted (Actor) && !is_deleted (Actor));
> +static_assert (is_defaulted (Adtor) && !is_deleted (Adtor));
> +struct B { int a; union { int b; const int c; }; };
> +static_assert (is_default_constructible_type (^^B));
> +static_assert (is_trivially_default_constructible_type (^^B));
> +static_assert (is_destructible_type (^^B));
> +static_assert (is_trivially_destructible_type (^^B));
> +constexpr auto Bctor = (members_of (^^B, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Bdtor = (members_of (^^B, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (is_defaulted (Bctor) && !is_deleted (Bctor));
> +static_assert (is_defaulted (Bdtor) && !is_deleted (Bdtor));
> +union C { const int a = 42; const long b; ~C (); };
> +static_assert (is_default_constructible_type (^^C));
> +static_assert (!is_trivially_default_constructible_type (^^C));
> +static_assert (is_destructible_type (^^C));
> +static_assert (!is_trivially_destructible_type (^^C));
> +constexpr auto Cctor = (members_of (^^C, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Cdtor = (members_of (^^C, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (is_defaulted (Cctor) && !is_deleted (Cctor));
> +static_assert (!is_defaulted (Cdtor) && !is_deleted (Cdtor));
> +struct D { D () = delete; D (int); ~D () = default; };
> +union E { D a = 42; D b; ~E (); };
> +static_assert (is_default_constructible_type (^^E));
> +static_assert (is_destructible_type (^^E));
> +constexpr auto Ector = (members_of (^^E, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Edtor = (members_of (^^E, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (is_defaulted (Ector) && !is_deleted (Ector));
> +static_assert (!is_defaulted (Edtor) && !is_deleted (Edtor));
> +struct F { int a; union { D b = 42; D c; }; };
> +static_assert (is_default_constructible_type (^^F));
> +static_assert (is_destructible_type (^^F));
> +constexpr auto Fctor = (members_of (^^F, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Fdtor = (members_of (^^F, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (is_defaulted (Fctor) && !is_deleted (Fctor));
> +static_assert (is_defaulted (Fdtor) && !is_deleted (Fdtor));
> +struct G { G (); ~G (); };
> +union I { int a; const int b; ~I (); };
> +static_assert (is_default_constructible_type (^^I));
> +static_assert (!is_trivially_default_constructible_type (^^I));
> +static_assert (is_destructible_type (^^I));
> +static_assert (!is_trivially_destructible_type (^^I));
> +constexpr auto Ictor = (members_of (^^I, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Idtor = (members_of (^^I, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (is_defaulted (Ictor) && !is_deleted (Ictor));
> +static_assert (!is_defaulted (Idtor) && !is_deleted (Idtor));
> +union J { D a; int b; };
> +static_assert (is_default_constructible_type (^^J));
> +static_assert (is_trivially_default_constructible_type (^^J));
> +static_assert (is_destructible_type (^^J));
> +static_assert (is_trivially_destructible_type (^^J));
> +constexpr auto Jctor = (members_of (^^J, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Jdtor = (members_of (^^J, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (is_defaulted (Jctor) && !is_deleted (Jctor));
> +static_assert (is_defaulted (Jdtor) && !is_deleted (Jdtor));
> +union K { G a; int b; };
> +static_assert (is_default_constructible_type (^^K));
> +static_assert (is_trivially_default_constructible_type (^^K));
> +static_assert (is_destructible_type (^^K));
> +static_assert (is_trivially_destructible_type (^^K));
> +constexpr auto Kctor = (members_of (^^K, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Kdtor = (members_of (^^K, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (is_defaulted (Kctor) && !is_deleted (Kctor));
> +static_assert (is_defaulted (Kdtor) && !is_deleted (Kdtor));
> +struct L { int a; union { G b; int c; }; };
> +static_assert (is_default_constructible_type (^^L));
> +static_assert (is_trivially_default_constructible_type (^^L));
> +static_assert (is_destructible_type (^^L));
> +static_assert (is_trivially_destructible_type (^^L));
> +constexpr auto Lctor = (members_of (^^L, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Ldtor = (members_of (^^L, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (is_defaulted (Lctor) && !is_deleted (Lctor));
> +static_assert (is_defaulted (Ldtor) && !is_deleted (Ldtor));
> +union M { M (); int a; long b; };
> +static_assert (is_default_constructible_type (^^M));
> +static_assert (!is_trivially_default_constructible_type (^^M));
> +static_assert (is_destructible_type (^^M));
> +static_assert (is_trivially_destructible_type (^^M));
> +constexpr auto Mctor = (members_of (^^M, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Mdtor = (members_of (^^M, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (!is_defaulted (Mctor) && !is_deleted (Mctor));
> +static_assert (is_defaulted (Mdtor) && !is_deleted (Mdtor));
> +struct N { N () = default; N (const N &) = default; int a; ~N (); };
> +union O { O (); int a; N b; };
> +static_assert (!is_default_constructible_type (^^O));
> +static_assert (!is_trivially_default_constructible_type (^^O));
> +static_assert (!is_destructible_type (^^O));
> +static_assert (!is_trivially_destructible_type (^^O));
> +constexpr auto Octor = (members_of (^^O, ctx) | std::views::filter
> (is_default_constructor) | std::ranges::to <std::vector> ())[0];
> +constexpr auto Odtor = (members_of (^^O, ctx) | std::views::filter
> (is_destructor) | std::ranges::to <std::vector> ())[0];
> +static_assert (!is_defaulted (Octor) && !is_deleted (Octor));
> +static_assert (is_defaulted (Odtor) && is_deleted (Odtor));
> --- gcc/testsuite/g++.dg/reflect/type_trait6.C.jj 2026-05-20
> 08:43:02.581478043 +0200
> +++ gcc/testsuite/g++.dg/reflect/type_trait6.C 2026-05-20
> 14:26:01.246323664 +0200
> @@ -985,7 +985,7 @@ static_assert (!is_destructible_type (^^
> static_assert (!is_destructible_type (^^const N2::Del [1]));
> static_assert (!is_destructible_type (^^N2::Del []));
> static_assert (!is_destructible_type (^^const N2::Del []));
> -static_assert (!is_destructible_type (^^N2::NontrivialUnion));
> +static_assert (is_destructible_type (^^N2::NontrivialUnion));
> static_assert (is_destructible_type (^^N2::UnusualCopy));
>
> static_assert (is_trivially_default_constructible_type (^^int));
> @@ -1367,8 +1367,8 @@ static_assert (!is_nothrow_destructible_
> static_assert (!is_nothrow_destructible_type (^^N2::Aggr2));
> static_assert (!is_nothrow_destructible_type (^^N2::Aggr2 [1]));
> static_assert (!is_nothrow_destructible_type (^^N2::TD1 [1][2]));
> -static_assert (!is_nothrow_destructible_type (^^N2::Ut));
> -static_assert (!is_nothrow_destructible_type (^^N2::Ut [3]));
> +static_assert (is_nothrow_destructible_type (^^N2::Ut));
> +static_assert (is_nothrow_destructible_type (^^N2::Ut [3]));
> static_assert (!is_nothrow_destructible_type (^^N2::AbstractDelDtor));
> static_assert (!is_nothrow_destructible_type (^^N2::Abstract2));
> static_assert (!is_nothrow_destructible_type (^^N2::Abstract3));
> --- gcc/testsuite/g++.dg/reflect/is_constructible_type1.C.jj 2026-05-20
> 08:43:02.580478060 +0200
> +++ gcc/testsuite/g++.dg/reflect/is_constructible_type1.C 2026-05-20
> 14:26:01.246691288 +0200
> @@ -603,7 +603,7 @@ static_assert (!is_constructible_type (^
> static_assert (!is_constructible_type (^^const DelnAny, { ^^int, ^^void *
> }));
> static_assert (!is_constructible_type (^^DelnAny, { ^^Empty, ^^B, ^^D }));
> static_assert (!is_constructible_type (^^const DelnAny, { ^^Empty, ^^B,
> ^^D }));
> -static_assert (!is_constructible_type (^^NontrivialUnion, {}));
> +static_assert (is_constructible_type (^^NontrivialUnion, {}));
> static_assert (!is_constructible_type (^^NontrivialUnion, { ^^const
> NontrivialUnion & }));
> static_assert (!is_constructible_type (^^UnusualCopy, {}));
> static_assert (!is_constructible_type (^^UnusualCopy, { ^^UnusualCopy }));
> --- libstdc++-v3/include/bits/version.def.jj 2026-05-20
> 08:43:02.584477993 +0200
> +++ libstdc++-v3/include/bits/version.def 2026-05-20
> 14:26:01.249947842 +0200
> @@ -2410,6 +2410,15 @@ ftms = {
> };
> };
>
> +ftms = {
> + name = start_lifetime;
> + values = {
> + v = 202603;
> + cxxmin = 26;
> + extra_cond = "__has_builtin(__builtin_start_lifetime)";
> + };
> +};
> +
> // Standard test specifications.
> stds[97] = ">= 199711L";
> stds[03] = ">= 199711L";
> --- libstdc++-v3/include/bits/version.h.jj 2026-05-20
> 08:43:02.584477993 +0200
> +++ libstdc++-v3/include/bits/version.h 2026-05-20 14:26:01.250438751 +0200
> @@ -2675,4 +2675,14 @@
> #endif /* !defined(__cpp_lib_is_structural) */
> #undef __glibcxx_want_is_structural
>
> +#if !defined(__cpp_lib_start_lifetime)
> +# if (__cplusplus > 202302L) && (__has_builtin(__builtin_start_lifetime))
> +# define __glibcxx_start_lifetime 202603L
> +# if defined(__glibcxx_want_all) ||
> defined(__glibcxx_want_start_lifetime)
> +# define __cpp_lib_start_lifetime 202603L
> +# endif
> +# endif
> +#endif /* !defined(__cpp_lib_start_lifetime) */
> +#undef __glibcxx_want_start_lifetime
> +
> #undef __glibcxx_want_all
> --- libstdc++-v3/include/bits/stl_construct.h.jj 2026-03-27
> 10:17:22.883187971 +0100
> +++ libstdc++-v3/include/bits/stl_construct.h 2026-05-20
> 14:30:52.025619611 +0200
> @@ -404,6 +404,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> }
> #endif // C++23
>
> +#if __glibcxx_start_lifetime >= 202603L // C++ >= 26
> + template <typename _Tp>
> + constexpr void
> + start_lifetime(_Tp& __r) noexcept
> + {
> +#ifdef __cpp_lib_is_implicit_lifetime
> + static_assert(std::is_implicit_lifetime_v<_Tp>);
> +#endif
> +#ifdef __cpp_lib_is_aggregate
> + static_assert(std::is_aggregate_v<_Tp>);
> +#endif
> + __builtin_start_lifetime(__builtin_addressof(__r));
> + }
> +#endif // C++26
> +
> _GLIBCXX_END_NAMESPACE_VERSION
> } // namespace std
>
> --- libstdc++-v3/include/std/memory.jj 2026-05-20 08:43:02.586477959 +0200
> +++ libstdc++-v3/include/std/memory 2026-05-20 14:28:05.835373954 +0200
> @@ -126,6 +126,7 @@
> #define __glibcxx_want_transparent_operators
> #define __glibcxx_want_smart_ptr_owner_equality
> #define __glibcxx_want_allocate_at_least
> +#define __glibcxx_want_start_lifetime
> #include <bits/version.h>
>
> #if __cplusplus >= 201103L && __cplusplus <= 202002L && _GLIBCXX_HOSTED
> --- libstdc++-v3/src/c++23/std.cc.in.jj 2026-05-20 08:43:02.591477875 +0200
> +++ libstdc++-v3/src/c++23/std.cc.in 2026-05-20 14:26:01.251438735
> +0200
> @@ -2062,6 +2062,9 @@ export namespace std
> #ifdef __glibcxx_allocate_at_least
> using std::allocation_result;
> #endif
> +#if __cpp_lib_start_lifetime
> + using std::start_lifetime;
> +#endif
> }
>
> // 20.4 <memory_resource>
>
>
> Jakub
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://gcc.gnu.org/pipermail/libstdc++/attachments/20260520/6e665fc5/attachment-0001.htm>
More information about the Libstdc++
mailing list