fix Global allocator dyn dispatch on windows

Author: hypengw

src/alloc/src/alloc.cppm

@@ -132,6 +132,23 @@ struct rstd::Impl<rstd::alloc::Allocator, alloc_::Global>
     void deallocate(void* ptr, Layout layout) const noexcept {
         if (layout.size != usize()) ::alloc::dealloc(ptr, layout.cpp_layout());
     }
+
+    // Inherited member pointers in Global's dyn vtable crash Windows Clang with reduced BMIs.
+    auto grow(void* pointer, Layout old_layout, Layout new_layout) const
+        -> Result<Allocation, AllocError> {
+        return DefaultInImpl<Allocator, alloc_::Global>::grow(pointer, old_layout, new_layout);
+    }
+
+    auto grow_zeroed(void* pointer, Layout old_layout, Layout new_layout) const
+        -> Result<Allocation, AllocError> {
+        return DefaultInImpl<Allocator, alloc_::Global>::grow_zeroed(
+            pointer, old_layout, new_layout);
+    }
+
+    auto shrink(void* pointer, Layout old_layout, Layout new_layout) const
+        -> Result<Allocation, AllocError> {
+        return DefaultInImpl<Allocator, alloc_::Global>::shrink(pointer, old_layout, new_layout);
+    }
 };
 
 namespace alloc

tests/main/alloc/module.cppm

@@ -0,0 +1,91 @@
+export module rstd.tests.alloc_module;
+import rstd.alloc;
+
+using namespace rstd::prelude;
+using rstd::alloc::Allocator;
+using rstd::alloc::Layout;
+
+struct GlobalDynAllocation {
+    ref<dyn<Allocator>> allocator = ::alloc::allocator_ref(::alloc::GLOBAL);
+    Layout              layout;
+    void*               pointer;
+
+    ~GlobalDynAllocation() { allocator->deallocate(pointer, layout); }
+
+    auto aligned() const -> bool {
+        return reinterpret_cast<rstd::uintptr_t>(pointer) % layout.align.to_primitive() == 0;
+    }
+
+    auto bytes() const -> unsigned char* { return static_cast<unsigned char*>(pointer); }
+};
+
+export auto global_dyn_resize() -> bool {
+    auto allocator = ::alloc::allocator_ref(::alloc::GLOBAL);
+    auto initial   = Layout::from_size_align(usize(8), usize(64)).unwrap();
+    auto result    = allocator->allocate(initial);
+    if (result.is_err()) return false;
+    GlobalDynAllocation memory { allocator, initial, result.unwrap().pointer };
+    if (! memory.aligned()) return false;
+    for (unsigned i = 0; i < 8; ++i) memory.bytes()[i] = 0x5a;
+
+    auto larger = Layout::from_size_align(usize(16), usize(128)).unwrap();
+    auto grown  = allocator->grow(memory.pointer, memory.layout, larger);
+    if (grown.is_err()) return false;
+    memory.pointer = grown.unwrap().pointer;
+    memory.layout  = larger;
+    if (! memory.aligned()) return false;
+    for (unsigned i = 0; i < 8; ++i)
+        if (memory.bytes()[i] != 0x5a) return false;
+    for (unsigned i = 8; i < 16; ++i) memory.bytes()[i] = 0xa5;
+
+    auto zeroed_layout = Layout::from_size_align(usize(32), usize(256)).unwrap();
+    auto zeroed        = allocator->grow_zeroed(memory.pointer, memory.layout, zeroed_layout);
+    if (zeroed.is_err()) return false;
+    memory.pointer = zeroed.unwrap().pointer;
+    memory.layout  = zeroed_layout;
+    if (! memory.aligned()) return false;
+    for (unsigned i = 0; i < 32; ++i) {
+        auto expected = i < 8 ? 0x5a : i < 16 ? 0xa5 : 0;
+        if (memory.bytes()[i] != expected) return false;
+    }
+
+    auto smaller = Layout::from_size_align(usize(4), usize(512)).unwrap();
+    auto shrunk  = allocator->shrink(memory.pointer, memory.layout, smaller);
+    if (shrunk.is_err()) return false;
+    memory.pointer = shrunk.unwrap().pointer;
+    memory.layout  = smaller;
+    if (! memory.aligned()) return false;
+    for (unsigned i = 0; i < 4; ++i)
+        if (memory.bytes()[i] != 0x5a) return false;
+    return true;
+}
+
+export auto global_dyn_zeroed_and_empty() -> bool {
+    auto allocator = ::alloc::allocator_ref(::alloc::GLOBAL);
+    auto layout    = Layout::from_size_align(usize(16), usize(64)).unwrap();
+    auto result    = allocator->allocate_zeroed(layout);
+    if (result.is_err()) return false;
+    GlobalDynAllocation memory { allocator, layout, result.unwrap().pointer };
+    if (! memory.aligned()) return false;
+    for (unsigned i = 0; i < 16; ++i)
+        if (memory.bytes()[i] != 0) return false;
+
+    auto empty  = Layout::from_size_align(usize(), usize(64)).unwrap();
+    auto shrunk = allocator->shrink(memory.pointer, memory.layout, empty);
+    if (shrunk.is_err()) return false;
+    memory.pointer = shrunk.unwrap().pointer;
+    memory.layout  = empty;
+    if (! memory.aligned() || memory.pointer == nullptr) return false;
+    auto grown = allocator->grow_zeroed(memory.pointer, memory.layout, layout);
+    if (grown.is_err()) return false;
+    memory.pointer = grown.unwrap().pointer;
+    memory.layout  = layout;
+    if (! memory.aligned()) return false;
+    for (unsigned i = 0; i < 16; ++i)
+        if (memory.bytes()[i] != 0) return false;
+
+    auto allocated = allocator->allocate(empty);
+    if (allocated.is_err()) return false;
+    GlobalDynAllocation empty_memory { allocator, empty, allocated.unwrap().pointer };
+    return empty_memory.pointer != nullptr && empty_memory.aligned();
+}

tests/main/alloc/raw.cpp

@@ -1,5 +1,6 @@
 #include <rstd/test/gtest.hpp>
 import rstd.alloc;
+import rstd.tests.alloc_module;
 
 namespace
 {
@@ -40,6 +41,14 @@ TEST(RawAlloc, ValueInitializesAndAcceptsNullDelete) {
     ::alloc::raw_delete(constant);
 }
 
+TEST(RawAlloc, GlobalDynResizeAcrossModules) {
+    EXPECT_TRUE(global_dyn_resize());
+}
+
+TEST(RawAlloc, GlobalDynZeroedAndEmptyAcrossModules) {
+    EXPECT_TRUE(global_dyn_zeroed_and_empty());
+}
+
 #if defined(__cpp_exceptions)
 TEST(RawAlloc, ConstructorFailureReleasesStorageWithoutDestruction) {
     struct Throws {

tests/main/lito.toml

@@ -56,6 +56,7 @@ sources = [
   "hint.cpp",
   "alloc/rc.cpp",
   "alloc/raw.cpp",
+  "alloc/module.cppm",
   "alloc/str.cpp",
   "alloc/boxed.cpp",
   "alloc/ownership.cpp",