Add std::assume_aligned

[ldionne]

Summary

Implements C++20 std::assume_aligned from p1007:
http://wg21.link/p1007

Only Clang is initially supported.

[gonzalobg]

Fix missing N in __builtin_assume_aligned

[lebedev.ri]

Dup of D54966 - that one seems stuck, do the concerns raised there no longer apply?

[gonzalobg]

Use attribute assume_aligned instead of __builtin_assume_aligned

[gonzalobg]

Remove GCC support, add fail test.

[gonzalobg]

Add missing maybe_unused attributes.

[gonzalobg]

nodiscard causes a warning, not an error

[gonzalobg]

Disable -Wgnu-compat for the new tests since this functionality is specific to clang.

[ldionne]

Thanks for the patch!

Can you follow the check-list at https://libcxx.llvm.org/Contributing.html (re-generating auto-gen-files, updating status pages, updating synopses, etc.)?

libcxx/include/memory

959

This can be just constexpr since it's C++20-and-above.

960

This should be _LIBCPP_HIDE_FROM_ABI.

961

Please move this to a new header __memory/assumed_aligned.h.

libcxx/test/std/utilities/memory/ptr.align/assume_aligned.fail.cpp

1 ↗

(On Diff #369458)

Can you please rename this to assume_alligned.verify.cpp?

libcxx/test/std/utilities/memory/ptr.align/assume_aligned.pass.cpp

18–22 ↗

(On Diff #369458)

We generally follow this pattern:

constexpr bool test() {
  // ... tests go here

  return true;
}

int main(int, char**) {
  test();
  static_assert(test());

  return 0;
}

As to the tests themselves, can you look at https://reviews.llvm.org/D54966 and grab what's relevant? I'm seeing a lot more tests in https://reviews.llvm.org/D54966. For example, we should at least test that assume_aligned returns the same pointer that it is being passed. We should also test with a couple different types, etc.

[ldionne]

Also, I just re-read the thread in https://reviews.llvm.org/D54966 (in particular Chandler's comment in https://reviews.llvm.org/D54966#1340163) and my understanding was that we really want to use __builtin_assume_aligned because that will propagate the correct alignment assumption in the IR.

I think the constexpr issue can be solved as:

template <size_t N, typename T>
[[nodiscard]]
_LIBCPP_HIDE_FROM_ABI
constexpr T* assume_aligned(T* __ptr) {
  if (is_constant_evaluated()) {
    return __ptr;
  } else {
    return __builtin_assume_aligned(__ptr, N);
  }
}

As a side benefit, this should also work on GCC (and in fact this implementation is basically what libstdc++ does).

What do you think?

libcxx/include/memory

957

Those parameters should be uglified (<size_t _Np, class _Tp>). Also, we use class instead of typename -- I don't like that, but it's consistent with the rest of the code base.

libcxx/test/std/utilities/memory/ptr.align/assume_aligned.fail.cpp

1 ↗

(On Diff #369458)

assume_aligned.verify.cpp

[• Quuxplusone]

libcxx/include/memory

968

@ldionne wrote:

template<size_t _Np, class _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr _Tp *assume_aligned(_Tp *__ptr) {
    if (is_constant_evaluated()) {
        return __ptr;
    } else {
        return static_cast<_Tp *>(__builtin_assume_aligned(__ptr, _Np));
    }
}

AIUI, the non-constexpr-ness problem is due entirely to that static_cast from void* back to _Tp*. ("Constexpr casts are like the Bay Bridge: free in one direction but not the other.") Did anyone think about this during the design of __builtin_assume_aligned? Could we just convince the compiler folks to fix it? The obvious solution is that __builtin_assume_aligned, just like std::assume_aligned, should return the same type that is passed in. Compiler builtins deal with way harder problems than "return the same type" on a daily basis; this should be a piece of cake, I'd think. And then we could use the builtin (and get the optimization assumption) even in constant-folded contexts.

template<size_t _Np, class _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr _Tp *assume_aligned(_Tp *__ptr) {
#ifdef HAS_SANE_BUILTIN_SEMANTICS
    return __builtin_assume_aligned(__ptr, _Np);
#else
    if (is_constant_evaluated()) {
        return __ptr;
    } else {
        return static_cast<_Tp *>(__builtin_assume_aligned(__ptr, _Np));
    }
#endif
}

[ldionne]

Commandeering to abandon since this is superseded by D118938.

[ldionne]

(Thanks for the patch, I did keep some content in D118938 and I credit you for it)

libcxx/include/memory

struct __builtin_new_allocator {
 
   template <class _Tp>
   _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
   static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
       __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
   }
 };
 
+#if _LIBCPP_STD_VER >= 20
+template <size_t N, typename T>
+[[nodiscard]]
+_LIBCPP_CONSTEXPR
+_LIBCPP_ALWAYS_INLINE
+T* assume_aligned(T* __ptr) {
+  #if defined(__clang__) || (defined(__GNUC__) && !defined(__ICC))
+    return reinterpret_cast<T*>(__builtin_assume_aligned(__ptr, N));
+  #else
+    return __ptr;
+  #endif
+}
+#endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_memory>
 #endif
 
 #endif // _LIBCPP_MEMORY

libcxx/test/libcxx/memory/assume_aligned.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+
+// <memory>
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// template<std::size_t N, typename T>
+// [[nodiscard]] T* assume_aligned(T*);
+
+#include <memory>
+
+constexpr int test() {
+  int a;
+  int* b = std::assume_aligned<4>(&a);
+  return sizeof(int);
+}
+
+int main(int, char**)
+{
+  constexpr int N = test();
+  int* a = (int*)malloc(N);
+  int* b = std::assume_aligned<4>(a);
+
+  return 0;
+}