[libc++][PMR] Add attributes

[philnik]

Summary

This allows the compiler to do more optimizations.

[philnik]

Try to fix CI

[philnik]

Fix diff

[philnik]

Try to fix CI

[ldionne]

We went over these attributes just now and I believe they are correctly applied. We also discussed how to test this, but since it's not observable in most cases (except those that produce a diagnostic), I think this is acceptable as-is.

[philnik]

Rebased

[philnik]

Rebased

[philnik]

Rebased; Fix CI

[philnik]

Next try

[philnik]

Next try

libcxx/include/__memory_resource/memory_resource.h

 _LIBCPP_DIAGNOSTIC_PUSH
 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wweak-vtables") // TODO: move destructor into the dylib
 class _LIBCPP_TYPE_VIS memory_resource {
   static const size_t __max_align = alignof(max_align_t);
 
 public:
   virtual ~memory_resource() = default;
 
-  _LIBCPP_HIDE_FROM_ABI void* allocate(size_t __bytes, size_t __align = __max_align) {
+  [[using __gnu__: __returns_nonnull__, __alloc_size__(2), __alloc_align__(3)]] _LIBCPP_HIDE_FROM_ABI void*
+  allocate(size_t __bytes, size_t __align = __max_align) {
     return do_allocate(__bytes, __align);
   }
 
-  _LIBCPP_HIDE_FROM_ABI void deallocate(void* __p, size_t __bytes, size_t __align = __max_align) {
+  [[__gnu__::__nonnull__]] _LIBCPP_HIDE_FROM_ABI void
+  deallocate(void* __p, size_t __bytes, size_t __align = __max_align) {
     do_deallocate(__p, __bytes, __align);
   }
 
   _LIBCPP_HIDE_FROM_ABI bool is_equal(const memory_resource& __other) const noexcept { return do_is_equal(__other); }
 
 private:
   virtual void* do_allocate(size_t, size_t)                       = 0;
   virtual void do_deallocate(void*, size_t, size_t)               = 0;
   virtual bool do_is_equal(memory_resource const&) const noexcept = 0;
 };
 _LIBCPP_DIAGNOSTIC_POP
 
 // [mem.res.eq]
 
 inline _LIBCPP_HIDE_FROM_ABI bool operator==(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
   return &__lhs == &__rhs || __lhs.is_equal(__rhs);
 }
 
 inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
   return !(__lhs == __rhs);
 }
 
 // [mem.res.global]
 
-_LIBCPP_FUNC_VIS memory_resource* get_default_resource() noexcept;
-
-_LIBCPP_FUNC_VIS memory_resource* set_default_resource(memory_resource*) noexcept;
-
-_LIBCPP_FUNC_VIS memory_resource* new_delete_resource() noexcept;
-
-_LIBCPP_FUNC_VIS memory_resource* null_memory_resource() noexcept;
+[[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS memory_resource* get_default_resource() noexcept;
+[[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS memory_resource* set_default_resource(memory_resource*) noexcept;
+[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* new_delete_resource() noexcept;
+[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* null_memory_resource() noexcept;
 
 } // namespace pmr
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 14
 
 #endif // _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

public:
   _LIBCPP_HIDE_FROM_ABI ~unsynchronized_pool_resource() override { release(); }
 
   unsynchronized_pool_resource& operator=(const unsynchronized_pool_resource&) = delete;
 
   void release();
 
   _LIBCPP_HIDE_FROM_ABI memory_resource* upstream_resource() const { return __res_; }
 
-  pool_options options() const;
+  [[__gnu__::__pure__]] pool_options options() const;
 
 protected:
   void* do_allocate(size_t __bytes, size_t __align) override; // key function
 
   void do_deallocate(void* __p, size_t __bytes, size_t __align) override;
 
   _LIBCPP_HIDE_FROM_ABI bool do_is_equal(const memory_resource& __other) const _NOEXCEPT override {
     return &__other == this;

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate.pass.cpp

void testAllocForSizeThrows() {
   using T      = typename std::aligned_storage<S>::type;
   using Alloc  = std::pmr::polymorphic_allocator<T>;
   using Traits = std::allocator_traits<Alloc>;
   NullResource R;
   Alloc a(&R);
 
   // Test that allocating exactly the max size does not throw.
   size_t maxSize = Traits::max_size(a);
-  try {
-    a.allocate(maxSize);
-  } catch (...) {
-    assert(false);
-  }
-
   size_t sizeTypeMax = std::numeric_limits<std::size_t>::max();
   if (maxSize != sizeTypeMax) {
     // Test that allocating size_t(~0) throws bad alloc.
     try {
       a.allocate(sizeTypeMax);
       assert(false);
     } catch (const std::exception&) {
     }

libcxx/test/std/utilities/utility/mem.res/mem.res.global/null_memory_resource.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
   }
 #endif
 }
 
 void test_deallocate() {
   globalMemCounter.reset();
 
   int x = 42;
-  std::pmr::null_memory_resource()->deallocate(nullptr, 0);
   std::pmr::null_memory_resource()->deallocate(&x, 0);
 
   assert(globalMemCounter.checkDeleteCalledEq(0));
   assert(globalMemCounter.checkDeleteArrayCalledEq(0));
 }
 
 int main(int, char**) {
   test_return();
   test_equality();
   test_allocate();
   test_deallocate();
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res/mem.res.public/allocate.pass.cpp

 #include "test_macros.h"
 #include "test_std_memory_resource.h"
 
 int main(int, char**) {
   TestResource R(42);
   auto& P                      = R.getController();
   std::pmr::memory_resource& M = R;
   {
-    static_assert(std::is_same<decltype(M.allocate(0, 0)), void*>::value, "Must be void*");
+    static_assert(std::is_same<decltype(M.allocate(0, 1)), void*>::value, "Must be void*");
     static_assert(std::is_same<decltype(M.allocate(0)), void*>::value, "Must be void*");
   }
   {
-    static_assert(!noexcept(M.allocate(0, 0)), "Must not be noexcept.");
+    static_assert(!noexcept(M.allocate(0, 1)), "Must not be noexcept.");
     static_assert(!noexcept(M.allocate(0)), "Must not be noexcept.");
   }
   {
     int s   = 42;
     int a   = 64;
     void* p = M.allocate(s, a);
     assert(P.alloc_count == 1);
     assert(P.checkAlloc(p, s, a));

libcxx/test/std/utilities/utility/mem.res/mem.res/mem.res.public/deallocate.pass.cpp

 #include "test_macros.h"
 #include "test_std_memory_resource.h"
 
 int main(int, char**) {
   NullResource R(42);
   auto& P                      = R.getController();
   std::pmr::memory_resource& M = R;
   {
-    ASSERT_SAME_TYPE(decltype(M.deallocate(nullptr, 0, 0)), void);
-    ASSERT_SAME_TYPE(decltype(M.deallocate(nullptr, 0)), void);
+    ASSERT_SAME_TYPE(decltype(M.deallocate(std::declval<int*>(), 0, 0)), void);
+    ASSERT_SAME_TYPE(decltype(M.deallocate(std::declval<int*>(), 0)), void);
   }
   {
-    static_assert(!noexcept(M.deallocate(nullptr, 0, 0)));
-    static_assert(!noexcept(M.deallocate(nullptr, 0)));
+    static_assert(!noexcept(M.deallocate(std::declval<int*>(), 0, 0)));
+    static_assert(!noexcept(M.deallocate(std::declval<int*>(), 0)));
   }
   {
     int s   = 100;
     int a   = 64;
     void* p = reinterpret_cast<void*>(640);
     M.deallocate(p, s, a);
     assert(P.dealloc_count == 1);
     assert(P.checkDealloc(p, s, a));

libcxx/test/support/test_std_memory_resource.h

 template <class Provider, int N>
 int TestResourceImp<Provider, N>::resource_constructed = 0;
 
 template <class Provider, int N>
 int TestResourceImp<Provider, N>::resource_destructed = 0;
 
 struct NullProvider {
   NullProvider() {}
-  void* allocate(size_t, size_t) { return nullptr; }
+  void* allocate(size_t, size_t) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    throw std::runtime_error("");
+#else
+    std::abort();
+#endif
+  }
   void deallocate(void*, size_t, size_t) {}
   void reset() {}
 
 private:
   DISALLOW_COPY(NullProvider);
 };
 
 struct NewDeleteProvider {

 struct BufferProvider {
   char buffer[Size];
   void* next   = &buffer;
   size_t space = Size;
 
   BufferProvider() {}
 
   void* allocate(size_t s, size_t a) {
-    void* ret = std::align(s, a, next, space);
+    void* ret = std::align(a, s, next, space);
     if (ret == nullptr) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
       throw std::bad_alloc();
 #else
       assert(false);
 #endif
     }