From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2181) id 6E53E3858D35; Mon, 21 Sep 2020 13:29:06 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 6E53E3858D35 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1600694946; bh=P89SQDvdlEJdInZ0Rq0LTai5heECnLEprjYMRAOYFdc=; h=From:To:Subject:Date:From; b=R8W0Qes54w+D8D/Tm3TsIhna8z7mXUqZGhE8sEn5l86SUHfpqHfXE36WfT0kQa2i5 KFfQL2TY480FxFu3HlXde/9GxjJX+YzsmZzlUpagmqvXaC/J7eeSrLXYr+7Bk/z+vX 27w9jq/jPseynFdlK+3Xg617m7doj+iIGGRPjlPI= Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Jonathan Wakely To: gcc-cvs@gcc.gnu.org, libstdc++-cvs@gcc.gnu.org Subject: [gcc r11-3324] libstdc++: Make std::assume_aligned a constexpr function [PR 97132] X-Act-Checkin: gcc X-Git-Author: Jonathan Wakely X-Git-Refname: refs/heads/master X-Git-Oldrev: 5187b01a4fcbea82f52798240595a32ddf7e0fe5 X-Git-Newrev: f10ed928e2f8ecc2c859abff8f2f9296b11b8d95 Message-Id: <20200921132906.6E53E3858D35@sourceware.org> Date: Mon, 21 Sep 2020 13:29:06 +0000 (GMT) X-BeenThere: libstdc++-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 21 Sep 2020 13:29:06 -0000 https://gcc.gnu.org/g:f10ed928e2f8ecc2c859abff8f2f9296b11b8d95 commit r11-3324-gf10ed928e2f8ecc2c859abff8f2f9296b11b8d95 Author: Jonathan Wakely Date: Mon Sep 21 14:28:58 2020 +0100 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: --- libstdc++-v3/include/bits/align.h | 26 ++++++++++------- libstdc++-v3/testsuite/20_util/assume_aligned/1.cc | 23 ++++++++++++++- .../testsuite/20_util/assume_aligned/97132.cc | 34 ++++++++++++++++++++++ 3 files changed, 71 insertions(+), 12 deletions(-) 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() );