[PATCH] libstdc++, v3: library side of C++26 P2786R13 - Trivial Relocatability [PR119064]

Tomasz Kaminski tkaminsk@redhat.com
Mon Sep 22 12:00:50 GMT 2025


On Mon, Sep 15, 2025 at 9:35 AM Jakub Jelinek <jakub@redhat.com> wrote:

> Hi!
>
> Here is a new version of the library side of trivial relocatability,
> changed to use std::start_lifetime_as if it is supported (so on top of
> https://gcc.gnu.org/pipermail/gcc-patches/2025-August/693683.html
> and
> https://gcc.gnu.org/pipermail/gcc-patches/2025-August/693665.html
> ).
>
> On Tue, Aug 26, 2025 at 03:28:43PM +0200, Tomasz Kaminski wrote:
> > I would prefer this function to be templated on the tested type (S or T),
> > instead of having the code duplicated. This should reduce the test  code
> by
> > half.
>
> Good idea, done.
>
> > Instead of destroying and then re-constructing local objects, you could
> now
> > use trivial_union
> > that I have sent in another email, to store the arrays.
>
> Is something wrong on the way the test tests it, or is testing through
> trivial union just another way that it should be tested on?
>
Creating an array requires a default constructor, however this is not a
requirement
for implicit lifetime types - requires at least one trivial constructor,
which could be copy/move.
Using an array inside union allows to side-step this requirement, and we
could add test for such
types. So I would prefer a more generic option.


>
> Bootstrapped/regtested on x86_64-linux and i686-linux.
>
> 2025-09-15  Jakub Jelinek  <jakub@redhat.com>
>
>         PR c++/119064
>         * include/bits/version.def (trivially_relocatable): New.
>         * include/bits/version.h: Regenerate.
>         * include/std/type_traits (std::is_trivially_relocatable,
>         std::is_nothrow_relocatable, std::is_replaceable): New traits.
>         std::is_trivially_relocatable_v, std::is_nothrow_relocatable_v,
>         std::is_replaceable_v): New trait variable templates.
>         * include/std/memory (__glibcxx_want_trivially_relocatable): Define
>         before including bits/version.h.
>         (std::trivially_relocate): New template function.
>         (std::relocate): Likewise.
>         * testsuite/std/memory/relocate/relocate.cc: New test.
>
>         * g++.dg/spellcheck-pr78656.C: For c++26 expect relocate rather
> than
>         allocator as spelling hint.
>
> --- libstdc++-v3/include/bits/version.def.jj    2025-09-13
> 16:32:55.720265140 +0200
> +++ libstdc++-v3/include/bits/version.def       2025-09-13
> 16:33:16.650969303 +0200
> @@ -2134,6 +2134,15 @@ ftms = {
>    };
>  };
>
> +ftms = {
> +  name = trivially_relocatable;
> +  values = {
> +    v = 202502;
> +    cxxmin = 26;
> +    extra_cond = "__cpp_trivial_relocatability >= 202502L";
> +  };
> +};
> +
>  // Standard test specifications.
>  stds[97] = ">= 199711L";
>  stds[03] = ">= 199711L";
> --- libstdc++-v3/include/bits/version.h.jj      2025-09-13
> 16:32:55.720265140 +0200
> +++ libstdc++-v3/include/bits/version.h 2025-09-13 16:33:42.762787607 +0200
> @@ -2392,4 +2392,14 @@
>  #endif /* !defined(__cpp_lib_start_lifetime_as) &&
> defined(__glibcxx_want_start_lifetime_as) */
>  #undef __glibcxx_want_start_lifetime_as
>
> +#if !defined(__cpp_lib_trivially_relocatable)
> +# if (__cplusplus >  202302L) && (__cpp_trivial_relocatability >= 202502L)
> +#  define __glibcxx_trivially_relocatable 202502L
> +#  if defined(__glibcxx_want_all) ||
> defined(__glibcxx_want_trivially_relocatable)
> +#   define __cpp_lib_trivially_relocatable 202502L
> +#  endif
> +# endif
> +#endif /* !defined(__cpp_lib_trivially_relocatable) &&
> defined(__glibcxx_want_trivially_relocatable) */
> +#undef __glibcxx_want_trivially_relocatable
> +
>  #undef __glibcxx_want_all
> --- libstdc++-v3/include/std/type_traits.jj     2025-09-13
> 16:32:50.102344547 +0200
> +++ libstdc++-v3/include/std/type_traits        2025-09-13
> 16:33:16.652969275 +0200
> @@ -4690,6 +4690,60 @@ template<typename _Ret, typename _Fn, ty
>      constexpr auto cw = constant_wrapper<_Tp>{};
>  #endif
>
> +#if __glibcxx_trivially_relocatable >= 202502L // C++ >= 26 &&
> __cpp_trivial_relocatability >= 202502
> +  /// True if the type is a trivially relocatable type.
> +  /// @since C++26
> +
> +  template<typename _Tp>
> +    struct is_trivially_relocatable
> +# if __has_builtin(__builtin_is_trivially_relocatable)
> +    : bool_constant<__builtin_is_trivially_relocatable(_Tp)>
> +# else
> +    : bool_constant<__builtin_is_cpp_trivially_relocatable(_Tp)>
> +# endif
> +    { };
> +
> +  template<typename _Tp>
> +    struct is_nothrow_relocatable
> +# if _GLIBCXX_USE_BUILTIN_TRAIT(__builtin_is_nothrow_relocatable)
> +    : bool_constant<__builtin_is_nothrow_relocatable(_Tp)>
> +# else
> +    : public __or_<is_trivially_relocatable<_Tp>,
> +
> __and_<is_nothrow_move_constructible<remove_all_extents<_Tp>>,
> +
>  is_nothrow_destructible<remove_all_extends<_Tp>>>>::type
> +# endif
> +    { };
> +
> +  template<typename _Tp>
> +    struct is_replaceable
> +    : bool_constant<__builtin_is_replaceable(_Tp)>
> +    { };
> +
> +  /// @ingroup variable_templates
> +  /// @since C++26
> +  template<typename _Tp>
> +    inline constexpr bool is_trivially_relocatable_v
> +# if __has_builtin(__builtin_is_trivially_relocatable)
> +      = __builtin_is_trivially_relocatable(_Tp);
> +# else
> +      = __builtin_is_cpp_trivially_relocatable(_Tp);
> +# endif
> +
> +  template<typename _Tp>
> +    inline constexpr bool is_nothrow_relocatable_v
> +# if _GLIBCXX_USE_BUILTIN_TRAIT(__builtin_is_nothrow_relocatable)
> +      = __builtin_is_nothrow_relocatable(_Tp);
> +# else
> +      = (is_trivially_relocatable_v<_Tp>
> +        || (is_nothrow_move_constructible_v<remove_all_extents<_Tp>>
> +            && is_nothrow_destructible_v<remove_all_extents<_Tp>>);
> +# endif
> +
> +  template<typename _Tp>
> +    inline constexpr bool is_replaceable_v
> +      = __builtin_is_replaceable(_Tp);
> +#endif
> +
>    /// @} group metaprogramming
>
>  _GLIBCXX_END_NAMESPACE_VERSION
> --- libstdc++-v3/include/std/memory.jj  2025-09-13 16:32:55.721265126 +0200
> +++ libstdc++-v3/include/std/memory     2025-09-13 16:36:50.801034895 +0200
> @@ -124,6 +124,7 @@
>  #define __glibcxx_want_to_address
>  #define __glibcxx_want_transparent_operators
>  #define __glibcxx_want_smart_ptr_owner_equality
> +#define __glibcxx_want_trivially_relocatable
>  #include <bits/version.h>
>
>  #if __cplusplus >= 201103L && __cplusplus <= 202002L && _GLIBCXX_HOSTED
> @@ -300,6 +301,131 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>  _GLIBCXX_END_NAMESPACE_VERSION
>  } // namespace
>  #endif
> +
> +#ifdef __cpp_lib_trivially_relocatable
> +namespace std _GLIBCXX_VISIBILITY(default)
> +{
> +_GLIBCXX_BEGIN_NAMESPACE_VERSION
> +
> +  template<typename _Tp>
> +    [[__gnu__::__always_inline__]]
> +    inline _Tp*
> +    trivially_relocate(_Tp* __first, _Tp* __last, _Tp* __result) noexcept
> +    {
> +      static_assert(is_trivially_relocatable_v<_Tp> && !is_const_v<_Tp>);
> +      if (__first == __result)
> +       return __last;
> +#if __has_builtin(__builtin_trivially_relocate)
> +      __builtin_trivially_relocate(__result, __first, __last - __first);
> +#else
> +      __builtin_memmove(static_cast<void*>(__result),
> +                       static_cast<const void*>(__first),
> +                       (__last - __first) * sizeof(_Tp));
> +#endif
> +      return __result + (__last - __first);
> +    }
> +
> +  template<typename _Tp>
> +    constexpr _Tp*
> +    relocate(_Tp* __first, _Tp* __last, _Tp* __result) noexcept
> +    {
> +      static_assert(is_nothrow_relocatable_v<_Tp> && !is_const_v<_Tp>);
> +      if !consteval
> +       {
> +         if constexpr (is_trivially_relocatable_v<_Tp>)
> +           return std::trivially_relocate(__first, __last, __result);
> +       }
> +      if (__first == __result)
> +       return __last;
> +      if (__first == __last)
> +       return __result;
> +
> +      size_t __n = __last - __first;
> +      if constexpr (is_move_constructible_v<_Tp>)
> +       {
> +         if !consteval
> +           {
> +             // If there is no overlap, move everything first and then
> +             // destruct.
> +             if ((__UINTPTR_TYPE__)__last <= (__UINTPTR_TYPE__)__result
> +                 || ((__UINTPTR_TYPE__)(__result + __n)
> +                     <= (__UINTPTR_TYPE__)__first))
> +               {
> +                 __result = std::uninitialized_move(__first, __last,
> +                                                    __result);
> +                 std::destroy(__first, __last);
> +                 return __result;
> +               }
> +           }
> +       }
> +
> +      bool __fwd = true;
> +      if consteval
> +       {
> +         // Use __builtin_constant_p to determine if __result and __first
> +         // point into the same object, if they don't, there is no overlap
> +         // and so either __fwd or !__fwd is fine.
> +         if (__builtin_constant_p (__result < __first)
> +             && __result > __first
> +             && __result < __last)
> +           __fwd = false;
> +       }
> +      else
> +       {
> +         __fwd = ((__UINTPTR_TYPE__)__result - (__UINTPTR_TYPE__)__first
> +                  >= (__UINTPTR_TYPE__)__last -
> (__UINTPTR_TYPE__)__first);
> +       }
> +      if (__fwd) [[likely]]
> +       {
> +         for (; __first != __last; ++__first, ++__result)
> +           {
> +             if constexpr (is_array_v<_Tp>)
> +#if __cpp_lib_start_lifetime_as >= 202207L
> +               std::relocate(std::begin(*__first), std::end(*__first),
> +                             *std::start_lifetime_as<_Tp>(__result));
> +#else
> +               std::relocate(std::begin(*__first), std::end(*__first),
> +                             std::addressof(*__result)[0]);
> +#endif
> +             else
> +               {
> +                 ::new(__result) _Tp(std::move(*__first));
> +                 __first->~_Tp();
> +               }
> +           }
> +         return __result;
> +       }
> +      else
> +       {
> +         _Tp *__ret = __result + __n;
> +         for (__result = __ret; __last != __first; )
> +           {
> +             --__last;
> +             --__result;
> +             if constexpr (is_array_v<_Tp>)
> +#if __cpp_lib_start_lifetime_as >= 202207L
> +               std::relocate(std::begin(*__last), std::end(*__last),
> +                             *std::start_lifetime_as<_Tp>(__result));
> +#else
> +               std::relocate(std::begin(*__last), std::end(*__last),
> +                             std::addressof(*__result)[0]);
> +#endif
> +             else
> +               {
> +                 ::new(__result) _Tp(std::move(*__last));
> +                 __last->~_Tp();
> +               }
> +           }
> +         return __ret;
> +       }
> +      // If at constand evaluation is_trivially_relocatable_v<_Tp>
> +      // but not is_move_constructible_V<_Tp>, fail.
> +      __builtin_unreachable();
> +    }
> +
> +_GLIBCXX_END_NAMESPACE_VERSION
> +} // namespace
> +#endif
>
>  #ifdef __cpp_lib_parallel_algorithm // C++ >= 17 && HOSTED
>  // Parallel STL algorithms
> --- libstdc++-v3/testsuite/std/memory/relocate/relocate.cc.jj   2025-09-13
> 16:33:16.652969275 +0200
> +++ libstdc++-v3/testsuite/std/memory/relocate/relocate.cc      2025-09-13
> 17:53:18.674711921 +0200
> @@ -0,0 +1,295 @@
> +// { dg-do run { target c++26 } }
> +
> +#include <memory>
> +
> +#include <testsuite_hooks.h>
> +#include <testsuite_allocator.h>
> +
> +struct S trivially_relocatable_if_eligible
> +{
> +  constexpr S() : s(0) {}
> +  constexpr S(int x) : s(x) {}
> +  constexpr S(S&& x) : s(x.s) {}
> +  constexpr S& operator=(S&& x) { s = x.s; return *this; }
> +  unsigned char s;
> +};
> +
> +struct T
> +{
> +  constexpr T() : s(0) {}
> +  constexpr T(int x) : s(x) {}
> +  constexpr T(T&& x) noexcept : s(x.s) {}
> +  constexpr T& operator=(T&& x) { s = x.s; return *this; }
> +  unsigned char s;
> +};
> +
> +static_assert(std::is_trivially_relocatable_v<S>);
> +static_assert(std::is_nothrow_relocatable_v<S>);
> +static_assert(std::is_nothrow_relocatable_v<T>);
> +
> +template <typename _Tp>
> +void
> +test_relocate()
> +{
> +  unsigned char a[20], c[20];
> +  _Tp *sf, *sl, *sr;
> +  sf = ::new(&a[2]) _Tp(11);
> +  for (int i = 3; i < 8; ++i)
> +    sl = ::new(&a[i]) _Tp(i + 9);
> +  ++sl;
> +  sr = ::new(&c[5]) _Tp(42);
> +  sr->~_Tp();
> +  VERIFY( std::relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( sr->s == i + 11 );
> +      sr->~_Tp();
> +      ++sr;
> +    }
> +  sf = ::new(&a[2]) _Tp(11);
> +  for (int i = 3; i < 8; ++i)
> +    sl = ::new(&a[i]) _Tp(i + 9);
> +  ++sl;
> +  sr = ::new(&a[1]) _Tp(42);
> +  sr->~_Tp();
> +  VERIFY( std::relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( sr->s == i + 11 );
> +      sr->~_Tp();
> +      ++sr;
> +    }
> +  sf = ::new(&a[2]) _Tp(11);
> +  for (int i = 3; i < 8; ++i)
> +    sl = ::new(&a[i]) _Tp(i + 9);
> +  ++sl;
> +  sr = sf + 1;
> +  VERIFY( std::relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( sr->s == i + 11 );
> +      sr->~_Tp();
> +      ++sr;
> +    }
> +}
> +
> +template <typename _Tp>
> +constexpr void
> +test_relocate_constexpr()
> +{
> +  _Tp a[20], c[20];
> +  for (int i = 0; i < 20; ++i)
> +    {
> +      a[i].~_Tp();
> +      c[i].~_Tp();
> +    }
> +  _Tp *sf, *sl, *sr;
> +  sf = ::new(&a[2]) _Tp(11);
> +  for (int i = 3; i < 8; ++i)
> +    sl = ::new(&a[i]) _Tp(i + 9);
> +  ++sl;
> +  sr = ::new(&c[5]) _Tp(42);
> +  sr->~_Tp();
> +  VERIFY( std::relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( sr->s == i + 11 );
> +      sr->~_Tp();
> +      ++sr;
> +    }
> +  sf = ::new(&a[2]) _Tp(11);
> +  for (int i = 3; i < 8; ++i)
> +    sl = ::new(&a[i]) _Tp(i + 9);
> +  ++sl;
> +  sr = ::new(&a[1]) _Tp(42);
> +  sr->~_Tp();
> +  VERIFY( std::relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( sr->s == i + 11 );
> +      sr->~_Tp();
> +      ++sr;
> +    }
> +  sf = ::new(&a[2]) _Tp(11);
> +  for (int i = 3; i < 8; ++i)
> +    sl = ::new(&a[i]) _Tp(i + 9);
> +  ++sl;
> +  sr = sf + 1;
> +  VERIFY( std::relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( sr->s == i + 11 );
> +      sr->~_Tp();
> +      ++sr;
> +    }
> +  for (int i = 0; i < 20; ++i)
> +    {
> +      ::new(&a[i]) _Tp(0);
> +      ::new(&c[i]) _Tp(0);
> +    }
> +}
> +
> +template <typename _Tp>
> +void
> +test_relocate_array()
> +{
> +  unsigned char a[20], c[20];
> +  using A = _Tp[2];
> +  A *sf, *sl, *sr;
> +  sf = (A *)(::new(&a[2]) A{11, 12});
> +  for (int i = 0; i < 5; ++i)
> +    sl = (A *)(::new(&a[4 + 2 * i]) A{13 + 2 * i, 14 + 2 * i});
> +  ++sl;
> +  sr = (A *)(::new(&c[6]) A{42, 42});
> +  (*sr)[0].~_Tp();
> +  (*sr)[1].~_Tp();
> +  VERIFY( std::relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( (*sr)[0].s == 2 * i + 11 && (*sr)[1].s == 2 * i + 12 );
> +      (*sr)[0].~_Tp();
> +      (*sr)[1].~_Tp();
> +      ++sr;
> +    }
> +  sf = (A *)(::new(&a[2]) A{11, 12});
> +  for (int i = 0; i < 5; ++i)
> +    sl = (A *)(::new(&a[4 + 2 * i]) A{13 + 2 * i, 14 + 2 * i});
> +  ++sl;
> +  sr = (A *)(::new(&a[0]) A{42, 42});
> +  (*sr)[0].~_Tp();
> +  (*sr)[1].~_Tp();
> +  VERIFY( std::relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( (*sr)[0].s == 2 * i + 11 && (*sr)[1].s == 2 * i + 12 );
> +      (*sr)[0].~_Tp();
> +      (*sr)[1].~_Tp();
> +      ++sr;
> +    }
> +  sf = (A *)(::new(&a[2]) A{11, 12});
> +  for (int i = 0; i < 5; ++i)
> +    sl = (A *)(::new(&a[4 + 2 * i]) A{13 + 2 * i, 14 + 2 * i});
> +  ++sl;
> +  sr = sf + 1;
> +  VERIFY( std::relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( (*sr)[0].s == 2 * i + 11 && (*sr)[1].s == 2 * i + 12 );
> +      (*sr)[0].~_Tp();
> +      (*sr)[1].~_Tp();
> +      ++sr;
> +    }
> +}
> +
> +void
> +test_trivially_relocate()
> +{
> +  unsigned char a[20], c[20];
> +  S *sf, *sl, *sr;
> +  sf = ::new(&a[2]) S(11);
> +  for (int i = 3; i < 8; ++i)
> +    sl = ::new(&a[i]) S(i + 9);
> +  ++sl;
> +  sr = ::new(&c[5]) S(42);
> +  sr->~S();
> +  VERIFY( std::trivially_relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( sr->s == i + 11 );
> +      sr->~S();
> +      ++sr;
> +    }
> +  sf = ::new(&a[2]) S(11);
> +  for (int i = 3; i < 8; ++i)
> +    sl = ::new(&a[i]) S(i + 9);
> +  ++sl;
> +  sr = ::new(&a[1]) S(42);
> +  sr->~S();
> +  VERIFY( std::trivially_relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( sr->s == i + 11 );
> +      sr->~S();
> +      ++sr;
> +    }
> +  sf = ::new(&a[2]) S(11);
> +  for (int i = 3; i < 8; ++i)
> +    sl = ::new(&a[i]) S(i + 9);
> +  ++sl;
> +  sr = sf + 1;
> +  VERIFY( std::trivially_relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( sr->s == i + 11 );
> +      sr->~S();
> +      ++sr;
> +    }
> +}
> +
> +void
> +test_trivially_relocate_array()
> +{
> +  unsigned char a[20], c[20];
> +  using SA = S[2];
> +  SA *sf, *sl, *sr;
> +  sf = (SA *)(::new(&a[2]) SA{11, 12});
> +  for (int i = 0; i < 5; ++i)
> +    sl = (SA *)(::new(&a[4 + 2 * i]) SA{13 + 2 * i, 14 + 2 * i});
> +  ++sl;
> +  sr = (SA *)(::new(&c[6]) SA{42, 42});
> +  (*sr)[0].~S();
> +  (*sr)[1].~S();
> +  VERIFY( std::trivially_relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( (*sr)[0].s == 2 * i + 11 && (*sr)[1].s == 2 * i + 12 );
> +      (*sr)[0].~S();
> +      (*sr)[1].~S();
> +      ++sr;
> +    }
> +  sf = (SA *)(::new(&a[2]) SA{11, 12});
> +  for (int i = 0; i < 5; ++i)
> +    sl = (SA *)(::new(&a[4 + 2 * i]) SA{13 + 2 * i, 14 + 2 * i});
> +  ++sl;
> +  sr = (SA *)(::new(&a[0]) SA{42, 42});
> +  (*sr)[0].~S();
> +  (*sr)[1].~S();
> +  VERIFY( std::trivially_relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( (*sr)[0].s == 2 * i + 11 && (*sr)[1].s == 2 * i + 12 );
> +      (*sr)[0].~S();
> +      (*sr)[1].~S();
> +      ++sr;
> +    }
> +  sf = (SA *)(::new(&a[2]) SA{11, 12});
> +  for (int i = 0; i < 5; ++i)
> +    sl = (SA *)(::new(&a[4 + 2 * i]) SA{13 + 2 * i, 14 + 2 * i});
> +  ++sl;
> +  sr = sf + 1;
> +  VERIFY( std::trivially_relocate(sf, sl, sr) == sr + 6 );
> +  for (int i = 0; i < 6; ++i)
> +    {
> +      VERIFY( (*sr)[0].s == 2 * i + 11 && (*sr)[1].s == 2 * i + 12 );
> +      (*sr)[0].~S();
> +      (*sr)[1].~S();
> +      ++sr;
> +    }
> +}
> +
> +int main()
> +{
> +  test_relocate<S>();
> +  test_relocate<T>();
> +  test_relocate_constexpr<S>();
> +  test_relocate_constexpr<T>();
> +  test_relocate_array<S>();
> +  test_relocate_array<T>();
> +  test_trivially_relocate();
> +  test_trivially_relocate_array();
> +  static_assert([] {
> +    test_relocate_constexpr<S>();
> +    test_relocate_constexpr<T>();
> +    return true;
> +  }());
> +}
> --- gcc/testsuite/g++.dg/spellcheck-pr78656.C.jj        2020-01-14
> 20:02:46.931607617 +0100
> +++ gcc/testsuite/g++.dg/spellcheck-pr78656.C   2025-09-14
> 19:20:01.492991511 +0200
> @@ -4,15 +4,21 @@
>
>  void* allocate(std::size_t n)
>  {
> -  return std::allocate<char>().allocate(n); // { dg-error ".allocate. is
> not a member of .std.; did you mean 'allocator'\\?" }
> +  // { dg-error ".allocate. is not a member of .std.; did you mean
> 'relocate'\\?" "" { target c++26 } .+1 }
> +  return std::allocate<char>().allocate(n); // { dg-error ".allocate. is
> not a member of .std.; did you mean 'allocator'\\?" "" { target c++23_down
> } }
>    /* { dg-begin-multiline-output "" }
>     return std::allocate<char>().allocate(n);
>                 ^~~~~~~~
>                 allocator
> -     { dg-end-multiline-output "" } */
> +     { dg-end-multiline-output "" { target c++23_down } } */
> +  /* { dg-begin-multiline-output "" }
> +   return std::allocate<char>().allocate(n);
> +               ^~~~~~~~
> +               relocate
> +     { dg-end-multiline-output "" { target c++26 } } */
>
>    // Various errors follow that we don't care about; suppress them:
> -  // { dg-excess-errors "7: " }
> +  // { dg-excess-errors "8: " }
>  }
>
>  void* test_2(std::size_t n)
> @@ -25,5 +31,5 @@ void* test_2(std::size_t n)
>       { dg-end-multiline-output "" } */
>
>    // Various errors follow that we don't care about; suppress them:
> -  // { dg-excess-errors "25: " }
> +  // { dg-excess-errors "26: " }
>  }
>
>
>         Jakub
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://gcc.gnu.org/pipermail/libstdc++/attachments/20250922/ac40d2dd/attachment-0001.htm>


More information about the Libstdc++ mailing list