On Thu, Aug 28, 2025 at 10:49:36AM +0200, Jason Merrill wrote:
> > I know, but P2590R2 is not implemented yet and as written in
> > https://gcc.gnu.org/PR106658 I have actually no idea what needs to be done
> > if anything on the compiler side. Because at least the GIMPLE model
> > basically allows placement new anywhere without anything in the IL marking
> > up that the dynamic type has changed. Though perhaps for constant
> > expression evaluation we want something...
>
> Note this is fixed by PR121068 (r16-3022).
So, do you think for P2590R2 we want a purely library implementation which
does nothing (well, define the needed templates)?
Or do you prefer some builtin which will do nothing initially but might be
changed to do something when needed?
The first version actually clears the array, not sure if that is desirable
(especially for the const, volatile and const volatile overloads).
And we apparently even don't have std::is_implicit_lifetime trait.
Guess I should implement that first (C++23 P2674R1). clang uses
__builtin_is_implicit_lifetime for that.
void *operator new(__SIZE_TYPE__ __sz, void *__p) { return __p; }
void *operator new[](__SIZE_TYPE__ __sz, void *__p) { return __p; }
namespace std {
template <typename T>
[[nodiscard]] T* start_lifetime_as1(void* __p) noexcept
{
// static_assert(__is_implicit_lifetime(T));
auto __b = new (__p) unsigned char[sizeof(T)];
auto __r = reinterpret_cast<T*>(__b);
(void)*__r;
return __r;
}
template <typename T>
[[nodiscard]] T* start_lifetime_as2(void* __p) noexcept
{
// static_assert(__is_implicit_lifetime(T));
return reinterpret_cast<T*>(__p);
}
}
struct S { int a; long long b; };
S *f1 (void *p) { return std::start_lifetime_as1<S>(p); }
S *f2 (void *p) { return std::start_lifetime_as2<S>(p); }
long double *f3 (void *p) { return std::start_lifetime_as1<long double>(p); }
long double *f4 (void *p) { return std::start_lifetime_as2<long double>(p); }
Jakub
