From: Jonathan Wakely Date: Mon, 21 Sep 2020 13:28:58 +0000 (+0100) Subject: libstdc++: Make std::assume_aligned a constexpr function [PR 97132] X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=f10ed928e2f8ecc2c859abff8f2f9296b11b8d95;p=gcc.git libstdc++: Make std::assume_aligned a constexpr function [PR 97132] The cast from void* to T* in std::assume_aligned is not valid in a constexpr function. The optimization hint is redundant during constant evaluation anyway (the compiler can see the object and knows its alignment). Simply return the original pointer without applying the __builtin_assume_aligned hint to it when doing constant evaluation. This change also removes the preprocessor branch that works around uintptr_t not being available. We already assume that type is present elsewhere in the library. libstdc++-v3/ChangeLog: PR libstdc++/97132 * include/bits/align.h (align) [!_GLIBCXX_USE_C99_STDINT_TR1]: Remove unused code. (assume_aligned): Do not use __builtin_assume_aligned during constant evaluation. * testsuite/20_util/assume_aligned/1.cc: Improve test. * testsuite/20_util/assume_aligned/97132.cc: New test. --- diff --git a/libstdc++-v3/include/bits/align.h b/libstdc++-v3/include/bits/align.h index c3267f22934..faa92bec2f8 100644 --- a/libstdc++-v3/include/bits/align.h +++ b/libstdc++-v3/include/bits/align.h @@ -41,7 +41,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /** * @brief Fit aligned storage in buffer. - * @ingroup memory * * This function tries to fit @a __size bytes of storage with alignment * @a __align into the buffer @a __ptr of size @a __space bytes. If such @@ -56,18 +55,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * @param __space Size of the buffer pointed to by @a __ptr. * @return the updated pointer if the aligned storage fits, otherwise nullptr. * + * @ingroup memory */ inline void* align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept { -#ifdef _GLIBCXX_USE_C99_STDINT_TR1 const auto __intptr = reinterpret_cast(__ptr); -#else - // Cannot use std::uintptr_t so assume that std::size_t can be used instead. - static_assert(sizeof(size_t) >= sizeof(void*), - "std::size_t must be a suitable substitute for std::uintptr_t"); - const auto __intptr = reinterpret_cast(__ptr); -#endif const auto __aligned = (__intptr - 1u + __align) & -__align; const auto __diff = __aligned - __intptr; if ((__size + __diff) > __space) @@ -86,15 +79,26 @@ align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept * @tparam _Align An alignment value (i.e. a power of two) * @tparam _Tp An object type * @param __ptr A pointer that is aligned to _Align + * + * C++20 20.10.6 [ptr.align] + * * @ingroup memory */ template [[nodiscard,__gnu__::__always_inline__]] - constexpr _Tp* assume_aligned(_Tp* __ptr) + constexpr _Tp* + assume_aligned(_Tp* __ptr) noexcept { static_assert(std::has_single_bit(_Align)); - _GLIBCXX_DEBUG_ASSERT((std::uintptr_t)__ptr % _Align == 0); - return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Align)); + if (std::is_constant_evaluated()) + return __ptr; + else + { + // This function is expected to be used in hot code, where + // __glibcxx_assert would add unwanted overhead. + _GLIBCXX_DEBUG_ASSERT((uintptr_t)__ptr % _Align == 0); + return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Align)); + } } #endif // C++2a diff --git a/libstdc++-v3/testsuite/20_util/assume_aligned/1.cc b/libstdc++-v3/testsuite/20_util/assume_aligned/1.cc index 1a34cc4bc63..16bf22caefe 100644 --- a/libstdc++-v3/testsuite/20_util/assume_aligned/1.cc +++ b/libstdc++-v3/testsuite/20_util/assume_aligned/1.cc @@ -15,7 +15,7 @@ // with this library; see the file COPYING3. If not see // . -// { dg-options "-std=gnu++2a" } +// { dg-options "-std=gnu++2a -O2" } // { dg-do run { target c++2a } } #include @@ -29,7 +29,28 @@ test01() VERIFY( p == &i ); } +[[gnu::noipa,gnu::noinline]] +int* +create_aligned(std::size_t alignment, void* p, std::size_t n) +{ + return ::new(std::align(alignment, sizeof(int), p, n)) int(42); +} + +extern "C" void undefined(); // call to this should be optimized away + +void +test02() +{ + unsigned char buf[sizeof(int) * 128]; + int* p = create_aligned(64, buf + 1, sizeof(buf) - 1); + int* q = std::assume_aligned<64>(p); + if ((std::uintptr_t)q % 64) + undefined(); + VERIFY( p == q ); +} + int main() { test01(); + test02(); } diff --git a/libstdc++-v3/testsuite/20_util/assume_aligned/97132.cc b/libstdc++-v3/testsuite/20_util/assume_aligned/97132.cc new file mode 100644 index 00000000000..887e3470651 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/assume_aligned/97132.cc @@ -0,0 +1,34 @@ +// Copyright (C) 2020 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// { dg-options "-std=gnu++2a" } +// { dg-do compile { target c++2a } } + +#include + +// PR libstdc++/97132 - assume_aligned is not constexpr + +constexpr bool test01() +{ + struct alignas(32) S { int i; }; + S s{42}; + int* p = std::assume_aligned<32>(&s.i); + *p = 48; + return s.i == 48; +} + +static_assert( test01() );