koffi 2.1.0 → 2.1.1

package/ChangeLog.md

@@ -2,12 +2,18 @@
 
 ## History
 
+### Koffi 2.1.1
+
+**Main fixes:**
+
+- Fix potential memory allocation bugs
+
 ### Koffi 2.1.0
 
 **Main changes:**
 
 - Add [koffi.as()](functions.md#polymorphic-parameters) to support polymorphic APIs based on `void *` parameters
-- Add [endian-sensitive integer types](types.md#endian-sensitive-types): `intX_le_t`, `intX_be_t`
+- Add [endian-sensitive integer types](types.md#endian-sensitive-types): `intX_le_t`, `intX_be_t`, `uintX_le_t`, `uintX_be_t`
 - Accept typed arrays for `void *` parameters
 - Introduce `koffi.opaque()` to replace `koffi.handle()` (which remains supported until Koffi 3.0)
 - Support JS Array and TypedArray to fill struct and array pointer members

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koffi",
-  "version": "2.1.0",
-  "stable": "2.1.0",
+  "version": "2.1.1",
+  "stable": "2.1.1",
   "description": "Fast and simple C FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",

package/src/call.cc

@@ -70,7 +70,7 @@ bool CallData::PushString(Napi::Value value, const char **out_str)
             status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
             RG_ASSERT(status == napi_ok);
 
-            buf = AllocateMemory<char>(&call_alloc, (Size)len + 1);
+            buf = AllocateSpan<char>(&call_alloc, (Size)len + 1);
 
             status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
             RG_ASSERT(status == napi_ok);
@@ -109,7 +109,7 @@ bool CallData::PushString16(Napi::Value value, const char16_t **out_str16)
             status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
             RG_ASSERT(status == napi_ok);
 
-            buf = AllocateMemory<char16_t>(&call_alloc, ((Size)len + 1) * 2);
+            buf = AllocateSpan<char16_t>(&call_alloc, ((Size)len + 1) * 2);
 
             status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
             RG_ASSERT(status == napi_ok);

package/src/call.hh

@@ -161,7 +161,7 @@ inline T *CallData::AllocHeap(Size size, Size align)
         int flags = 0;
 #endif
 
-        ptr = AllocateMemory<uint8_t>(&call_alloc, size + align, flags).ptr;
+        ptr = (uint8_t *)AllocateRaw(&call_alloc, size + align, flags);
         ptr = AlignUp(ptr, align);
 
         return ptr;

package/vendor/libcc/libcc.cc

@@ -148,13 +148,13 @@ protected:
         return ptr;
     }
 
-    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags) override
+    void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags) override
     {
         if (!new_size) {
-            Release(*ptr, old_size);
-            *ptr = nullptr;
+            Release(ptr, old_size);
+            ptr = nullptr;
         } else {
-            void *new_ptr = realloc(*ptr, (size_t)new_size);
+            void *new_ptr = realloc(ptr, (size_t)new_size);
             RG_CRITICAL(new_ptr || !new_size, "Failed to resize %1 memory block to %2",
                                               FmtMemSize(old_size), FmtMemSize(new_size));
 
@@ -162,8 +162,10 @@ protected:
                 memset_safe((uint8_t *)new_ptr + old_size, 0, (size_t)(new_size - old_size));
             }
 
-            *ptr = new_ptr;
+            ptr = new_ptr;
         }
+
+        return ptr;
     }
 
     void Release(void *ptr, Size) override
@@ -175,7 +177,7 @@ protected:
 class NullAllocator: public Allocator {
 protected:
     void *Allocate(Size, unsigned int) override { RG_UNREACHABLE(); }
-    void Resize(void **, Size, Size, unsigned int) override { RG_UNREACHABLE(); }
+    void *Resize(void *, Size, Size, unsigned int) override { RG_UNREACHABLE(); }
     void Release(void *, Size) override {}
 };
 
@@ -205,7 +207,7 @@ void LinkedAllocator::ReleaseAll()
     Node *head = list.next;
     while (head) {
         Node *next = head->next;
-        ReleaseMemory(allocator, head, -1);
+        ReleaseRaw(allocator, head, -1);
         head = next;
     }
     list = {};
@@ -213,7 +215,7 @@ void LinkedAllocator::ReleaseAll()
 
 void *LinkedAllocator::Allocate(Size size, unsigned int flags)
 {
-    Bucket *bucket = AllocateMemory<Bucket>(allocator, RG_SIZE(*bucket) + size, flags).ptr;
+    Bucket *bucket = (Bucket *)AllocateRaw(allocator, RG_SIZE(Node) + size, flags);
 
     if (list.prev) {
         list.prev->next = &bucket->head;
@@ -227,26 +229,21 @@ void *LinkedAllocator::Allocate(Size size, unsigned int flags)
         bucket->head.next = nullptr;
     }
 
-    uint8_t *data = bucket->data;
-    uint8_t *aligned = AlignUp(data, 16);
-
-    RG_ASSERT(aligned - data <= 8);
-
-    return (void *)aligned;
+    return (void *)bucket->data;
 }
 
-void LinkedAllocator::Resize(void **ptr, Size old_size, Size new_size, unsigned int flags)
+void *LinkedAllocator::Resize(void *ptr, Size old_size, Size new_size, unsigned int flags)
 {
-    if (!*ptr) {
-        *ptr = Allocate(new_size, flags);
+    if (!ptr) {
+        ptr = Allocate(new_size, flags);
     } else if (!new_size) {
-        Release(*ptr, old_size);
-        *ptr = nullptr;
+        Release(ptr, old_size);
+        ptr = nullptr;
     } else {
-        Bucket *bucket = PointerToBucket(*ptr);
+        Bucket *bucket = PointerToBucket(ptr);
 
-        bucket = ResizeMemory(allocator, bucket, RG_SIZE(*bucket) + old_size,
-                                                 RG_SIZE(*bucket) + new_size, flags).ptr;
+        bucket = (Bucket *)ResizeRaw(allocator, bucket, RG_SIZE(Node) + old_size,
+                                                        RG_SIZE(Node) + new_size, flags);
 
         if (bucket->head.next) {
             bucket->head.next->prev = &bucket->head;
@@ -259,13 +256,10 @@ void LinkedAllocator::Resize(void **ptr, Size old_size, Size new_size, unsigned
             list.next = &bucket->head;
         }
 
-        uint8_t *data = bucket->data;
-        uint8_t *aligned = AlignUp(data, 16);
-
-        RG_ASSERT(aligned - data <= 8);
-
-        *ptr = (void *)aligned;
+        ptr = (void *)bucket->data;
     }
+
+    return ptr;
 }
 
 void LinkedAllocator::Release(void *ptr, Size size)
@@ -284,10 +278,16 @@ void LinkedAllocator::Release(void *ptr, Size size)
             list.next = bucket->head.next;
         }
 
-        ReleaseMemory(allocator, bucket, size);
+        ReleaseRaw(allocator, bucket, RG_SIZE(Bucket) + size);
     }
 }
 
+LinkedAllocator::Bucket *LinkedAllocator::PointerToBucket(void *ptr)
+{
+    uint8_t *data = (uint8_t *)ptr;
+    return (Bucket *)(data - RG_OFFSET_OF(Bucket, data));
+}
+
 void *BlockAllocatorBase::Allocate(Size size, unsigned int flags)
 {
     RG_ASSERT(size >= 0);
@@ -298,15 +298,13 @@ void *BlockAllocatorBase::Allocate(Size size, unsigned int flags)
     Size aligned_size = AlignLen(size, 8);
 
     if (AllocateSeparately(aligned_size)) {
-        uint8_t *ptr = AllocateMemory<uint8_t>(alloc, size, flags).ptr;
+        uint8_t *ptr = (uint8_t *)AllocateRaw(alloc, size, flags);
         return ptr;
     } else {
         if (!current_bucket || (current_bucket->used + aligned_size) > block_size) {
-            current_bucket = AllocateMemory<Bucket>(alloc, RG_SIZE(Bucket) + block_size,
-                                                           flags & ~(int)Allocator::Flag::Zero).ptr;
-            current_bucket->used = AlignUp(current_bucket->data, 16) - current_bucket->data;
-
-            RG_ASSERT(current_bucket->used <= 8);
+            current_bucket = (Bucket *)AllocateRaw(alloc, RG_SIZE(Bucket) + block_size,
+                                                   flags & ~(int)Allocator::Flag::Zero);
+            current_bucket->used = 0;
         }
 
         uint8_t *ptr = current_bucket->data + current_bucket->used;
@@ -321,15 +319,16 @@ void *BlockAllocatorBase::Allocate(Size size, unsigned int flags)
     }
 }
 
-void BlockAllocatorBase::Resize(void **ptr, Size old_size, Size new_size, unsigned int flags)
+void *BlockAllocatorBase::Resize(void *ptr, Size old_size, Size new_size, unsigned int flags)
 {
     RG_ASSERT(old_size >= 0);
     RG_ASSERT(new_size >= 0);
 
     if (!new_size) {
-        Release(*ptr, old_size);
+        Release(ptr, old_size);
+        ptr = nullptr;
     } else {
-        if (!*ptr) {
+        if (!ptr) {
             old_size = 0;
         }
 
@@ -338,32 +337,34 @@ void BlockAllocatorBase::Resize(void **ptr, Size old_size, Size new_size, unsign
         Size aligned_delta = aligned_new_size - aligned_old_size;
 
         // Try fast path
-        if (*ptr && *ptr == last_alloc &&
+        if (ptr && ptr == last_alloc &&
                 (current_bucket->used + aligned_delta) <= block_size &&
                 !AllocateSeparately(aligned_new_size)) {
             current_bucket->used += aligned_delta;
 
             if ((flags & (int)Allocator::Flag::Zero) && new_size > old_size) {
-                memset_safe(ptr + old_size, 0, new_size - old_size);
+                memset_safe((uint8_t *)ptr + old_size, 0, new_size - old_size);
             }
         } else if (AllocateSeparately(aligned_old_size)) {
             LinkedAllocator *alloc = GetAllocator();
-            ptr = ResizeMemory(alloc, ptr, old_size, new_size, flags).ptr;
+            ptr = ResizeRaw(alloc, ptr, old_size, new_size, flags);
         } else {
             void *new_ptr = Allocate(new_size, flags & ~(int)Allocator::Flag::Zero);
             if (new_size > old_size) {
-                memcpy_safe(new_ptr, *ptr, old_size);
+                memcpy_safe(new_ptr, ptr, old_size);
 
                 if (flags & (int)Allocator::Flag::Zero) {
-                    memset_safe(ptr + old_size, 0, new_size - old_size);
+                    memset_safe((uint8_t *)ptr + old_size, 0, new_size - old_size);
                 }
             } else {
-                memcpy_safe(new_ptr, *ptr, new_size);
+                memcpy_safe(new_ptr, ptr, new_size);
             }
 
-            *ptr = new_ptr;
+            ptr = new_ptr;
         }
     }
+
+    return ptr;
 }
 
 void BlockAllocatorBase::Release(void *ptr, Size size)
@@ -377,13 +378,15 @@ void BlockAllocatorBase::Release(void *ptr, Size size)
 
         if (ptr == last_alloc) {
             current_bucket->used -= aligned_size;
+
             if (!current_bucket->used) {
-                ReleaseMemory(alloc, current_bucket, RG_SIZE(Bucket) + block_size);
+                ReleaseRaw(alloc, current_bucket, RG_SIZE(Bucket) + block_size);
                 current_bucket = nullptr;
             }
+
             last_alloc = nullptr;
         } else if (AllocateSeparately(aligned_size)) {
-            ReleaseMemory(alloc, ptr, size);
+            ReleaseRaw(alloc, ptr, size);
         }
     }
 }
@@ -762,7 +765,7 @@ bool CopyString(Span<const char> str, Span<char> buf)
 
 Span<char> DuplicateString(Span<const char> str, Allocator *alloc)
 {
-    char *new_str = AllocateMemory<char>(alloc, str.len + 1).ptr;
+    char *new_str = (char *)AllocateRaw(alloc, str.len + 1);
     memcpy_safe(new_str, str.ptr, (size_t)str.len);
     new_str[str.len] = 0;
     return MakeSpan(new_str, str.len);
@@ -2771,7 +2774,7 @@ const char *GetApplicationExecutable()
             RG_ASSERT(strlen(path) < RG_SIZE(executable_path));
 
             CopyString(path, executable_path);
-            ReleaseMemory(nullptr, (void *)path, -1);
+            ReleaseRaw(nullptr, (void *)path, -1);
         }
     }
 
@@ -3560,8 +3563,8 @@ bool ExecuteCommandLine(const char *cmd_line, FunctionRef<Span<const uint8_t>()>
     STARTUPINFOW si = {};
 
     // Convert command line
-    Span<wchar_t> cmd_line_w = AllocateMemory<wchar_t>(nullptr, 4 * strlen(cmd_line) + 2);
-    RG_DEFER { ReleaseMemory(nullptr, cmd_line_w.ptr, cmd_line_w.len); };
+    Span<wchar_t> cmd_line_w = AllocateSpan<wchar_t>(nullptr, 2 * strlen(cmd_line) + 1);
+    RG_DEFER { ReleaseSpan(nullptr, cmd_line_w); };
     if (ConvertUtf8ToWin32Wide(cmd_line, cmd_line_w) < 0)
         return false;
 
@@ -5444,7 +5447,7 @@ Fiber::~Fiber()
         fib_run = nullptr;
     }
 
-    ReleaseMemory(nullptr, ucp.uc_stack.ss_sp, (Size)ucp.uc_stack.ss_size);
+    ReleaseRaw(nullptr, ucp.uc_stack.ss_sp, (Size)ucp.uc_stack.ss_size);
 }
 
 void Fiber::SwitchTo()
@@ -5726,7 +5729,7 @@ bool StreamReader::Close(bool implicit)
         case CompressionType::Gzip:
         case CompressionType::Zlib: {
 #ifdef MZ_VERSION
-            ReleaseMemory(nullptr, compression.u.miniz, RG_SIZE(*compression.u.miniz));
+            ReleaseOne(nullptr, compression.u.miniz);
             compression.u.miniz = nullptr;
 #else
             RG_UNREACHABLE();
@@ -5742,7 +5745,7 @@ bool StreamReader::Close(bool implicit)
                     BrotliDecoderDestroyInstance(ctx->state);
                 }
 
-                ReleaseMemory(nullptr, ctx, RG_SIZE(*ctx));
+                ReleaseOne(nullptr, ctx);
                 compression.u.brotli = nullptr;
             }
 #else
@@ -5975,8 +5978,7 @@ bool StreamReader::InitDecompressor(CompressionType type)
         case CompressionType::Gzip:
         case CompressionType::Zlib: {
 #ifdef MZ_VERSION
-            compression.u.miniz =
-                AllocateMemory<MinizInflateContext>(nullptr, RG_SIZE(MinizInflateContext), (int)Allocator::Flag::Zero).ptr;
+            compression.u.miniz = AllocateOne<MinizInflateContext>(nullptr, (int)Allocator::Flag::Zero);
             tinfl_init(&compression.u.miniz->inflator);
             compression.u.miniz->crc32 = MZ_CRC32_INIT;
 #else
@@ -5988,8 +5990,7 @@ bool StreamReader::InitDecompressor(CompressionType type)
 
         case CompressionType::Brotli: {
 #ifdef BROTLI_DEFAULT_MODE
-            compression.u.brotli =
-                AllocateMemory<BrotliDecompressContext>(nullptr, RG_SIZE(BrotliDecompressContext), (int)Allocator::Flag::Zero).ptr;
+            compression.u.brotli = AllocateOne<BrotliDecompressContext>(nullptr, (int)Allocator::Flag::Zero);
             compression.u.brotli->state = BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
 #else
             LogError("Brotli decompression not available for '%1'", filename);
@@ -6527,7 +6528,7 @@ bool StreamWriter::Close(bool implicit)
             MinizDeflateContext *ctx = compression.u.miniz;
 
             RG_DEFER { 
-                ReleaseMemory(nullptr, ctx, RG_SIZE(*ctx));
+                ReleaseOne(nullptr, ctx);
                 compression.u.miniz = nullptr;
             };
 
@@ -6665,8 +6666,7 @@ bool StreamWriter::InitCompressor(CompressionType type, CompressionSpeed speed)
         case CompressionType::Gzip:
         case CompressionType::Zlib: {
 #ifdef MZ_VERSION
-            compression.u.miniz =
-                AllocateMemory<MinizDeflateContext>(nullptr, RG_SIZE(MinizDeflateContext), (int)Allocator::Flag::Zero).ptr;
+            compression.u.miniz = AllocateOne<MinizDeflateContext>(nullptr, (int)Allocator::Flag::Zero);
             compression.u.miniz->crc32 = MZ_CRC32_INIT;
 
             int flags = 0;
@@ -7033,7 +7033,7 @@ bool ReloadAssets()
         AssetInfo asset_copy;
 
         asset_copy.name = DuplicateString(asset.name, &assets_alloc).ptr;
-        asset_copy.data = AllocateMemory<uint8_t>(&assets_alloc, asset.data.len);
+        asset_copy.data = AllocateSpan<uint8_t>(&assets_alloc, asset.data.len);
         memcpy_safe((void *)asset_copy.data.ptr, asset.data.ptr, (size_t)asset.data.len);
         asset_copy.compression_type = asset.compression_type;
         asset_copy.source_map = DuplicateString(asset.source_map, &assets_alloc).ptr;

package/vendor/libcc/libcc.hh

@@ -837,15 +837,14 @@ public:
     virtual ~Allocator() = default;
 
     virtual void *Allocate(Size size, unsigned int flags = 0) = 0;
-    virtual void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) = 0;
+    virtual void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) = 0;
     virtual void Release(void *ptr, Size size) = 0;
 };
 
 Allocator *GetDefaultAllocator();
 Allocator *GetNullAllocator();
 
-template <typename T>
-Span<T> AllocateMemory(Allocator *alloc, Size size, unsigned int flags = 0)
+static inline void *AllocateRaw(Allocator *alloc, Size size, unsigned int flags = 0)
 {
     RG_ASSERT(size >= 0);
 
@@ -853,13 +852,40 @@ Span<T> AllocateMemory(Allocator *alloc, Size size, unsigned int flags = 0)
         alloc = GetDefaultAllocator();
     }
 
+    void *ptr = alloc->Allocate(size, flags);
+    return ptr;
+}
+
+template <typename T>
+T *AllocateOne(Allocator *alloc, unsigned int flags = 0)
+{
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
+    }
+
+    Size size = RG_SIZE(T);
+
     T *ptr = (T *)alloc->Allocate(size, flags);
-    return MakeSpan(ptr, size);
+    return ptr;
 }
 
 template <typename T>
-Span<T> ResizeMemory(Allocator *alloc, T *ptr, Size old_size, Size new_size,
-                         unsigned int flags = 0)
+Span<T> AllocateSpan(Allocator *alloc, Size len, unsigned int flags = 0)
+{
+    RG_ASSERT(len >= 0);
+
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
+    }
+
+    Size size = len * RG_SIZE(T);
+
+    T *ptr = (T *)alloc->Allocate(size, flags);
+    return MakeSpan(ptr, len);
+}
+
+static inline void *ResizeRaw(Allocator *alloc, void *ptr, Size old_size, Size new_size,
+                              unsigned int flags = 0)
 {
     RG_ASSERT(new_size >= 0);
 
@@ -867,28 +893,56 @@ Span<T> ResizeMemory(Allocator *alloc, T *ptr, Size old_size, Size new_size,
         alloc = GetDefaultAllocator();
     }
 
-    alloc->Resize((void **)&ptr, old_size, new_size, flags);
-    return MakeSpan(ptr, new_size);
+    ptr = alloc->Resize(ptr, old_size, new_size, flags);
+    return ptr;
+}
+
+template <typename T>
+Span<T> ResizeSpan(Allocator *alloc, Span<T> mem, Size new_len,
+                     unsigned int flags = 0)
+{
+    RG_ASSERT(new_len >= 0);
+
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
+    }
+
+    Size old_size = mem.len * RG_SIZE(T);
+    Size new_size = new_len * RG_SIZE(T);
+
+    mem.ptr = (T *)alloc->Resize(mem.ptr, old_size, new_size, flags);
+    return MakeSpan(mem.ptr, new_len);
+}
+
+static inline void ReleaseRaw(Allocator *alloc, void *ptr, Size size)
+{
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
+    }
+
+    alloc->Release(ptr, size);
 }
 
 template<typename T>
-void ReleaseMemory(Allocator *alloc, Span<T> mem)
+void ReleaseOne(Allocator *alloc, T *ptr)
 {
     if (!alloc) {
         alloc = GetDefaultAllocator();
     }
 
-    alloc->Release((void *)mem.ptr, mem.len);
+    alloc->Release((void *)ptr, RG_SIZE(T));
 }
 
 template<typename T>
-void ReleaseMemory(Allocator *alloc, T *ptr, Size size)
+void ReleaseSpan(Allocator *alloc, Span<T> mem)
 {
     if (!alloc) {
         alloc = GetDefaultAllocator();
     }
 
-    alloc->Release((void *)ptr, size);
+    Size size = mem.len * RG_SIZE(T);
+
+    alloc->Release((void *)mem.ptr, size);
 }
 
 class LinkedAllocator final: public Allocator {
@@ -899,7 +953,7 @@ class LinkedAllocator final: public Allocator {
     struct Bucket {
          // Keep head first or stuff will break
         Node head;
-        uint8_t data[8]; // Extra size is used to align pointer
+        uint8_t data[];
     };
 
     Allocator *allocator;
@@ -917,18 +971,17 @@ public:
     void ReleaseAll();
 
     void *Allocate(Size size, unsigned int flags = 0) override;
-    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
+    void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
     void Release(void *ptr, Size size) override;
 
 private:
-    static Bucket *PointerToBucket(void *ptr)
-        { return (Bucket *)((uint8_t *)ptr - RG_OFFSET_OF(Bucket, data)); }
+    static Bucket *PointerToBucket(void *ptr);
 };
 
 class BlockAllocatorBase: public Allocator {
     struct Bucket {
         Size used;
-        uint8_t data[8]; // Extra size is used to align pointer
+        uint8_t data[];
     };
 
     Size block_size;
@@ -944,7 +997,7 @@ public:
     }
 
     void *Allocate(Size size, unsigned int flags = 0) override;
-    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
+    void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
     void Release(void *ptr, Size size) override;
 
 protected:
@@ -1315,7 +1368,7 @@ public:
                 len = new_capacity;
             }
 
-            ptr = ResizeMemory(allocator, ptr, capacity * RG_SIZE(T), new_capacity * RG_SIZE(T)).ptr;
+            ptr = (T *)ResizeRaw(allocator, ptr, capacity * RG_SIZE(T), new_capacity * RG_SIZE(T));
             capacity = new_capacity;
         }
     }
@@ -1612,9 +1665,9 @@ public:
         Size bucket_offset = (offset + len) % BucketSize;
 
         if (bucket_idx >= buckets.len) {
-            Bucket *new_bucket = AllocateMemory<Bucket>(buckets.allocator, RG_SIZE(Bucket)).ptr;
+            Bucket *new_bucket = AllocateOne<Bucket>(buckets.allocator);
             new (&new_bucket->allocator) AllocatorType();
-            new_bucket->values = AllocateMemory<T>(&new_bucket->allocator, BucketSize * RG_SIZE(T)).ptr;
+            new_bucket->values = (T *)AllocateRaw(&new_bucket->allocator, BucketSize * RG_SIZE(T));
 
             buckets.Append(new_bucket);
         }
@@ -1731,7 +1784,7 @@ private:
     void DeleteBucket(Bucket *bucket)
     {
         bucket->allocator.~AllocatorType();
-        ReleaseMemory(buckets.allocator, bucket, RG_SIZE(Bucket));
+        ReleaseOne(buckets.allocator, bucket);
     }
 };
 
@@ -2244,10 +2297,10 @@ private:
         Size old_capacity = capacity;
 
         if (new_capacity) {
-            used = AllocateMemory<size_t>(allocator,
-                                                 (new_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t),
-                                                 (int)Allocator::Flag::Zero).ptr;
-            data = AllocateMemory<ValueType>(allocator, new_capacity * RG_SIZE(ValueType)).ptr;
+            used = (size_t *)AllocateRaw(allocator,
+                                         (new_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t),
+                                         (int)Allocator::Flag::Zero);
+            data = (ValueType *)AllocateRaw(allocator, new_capacity * RG_SIZE(ValueType));
             for (Size i = 0; i < new_capacity; i++) {
                 new (&data[i]) ValueType();
             }
@@ -2269,9 +2322,8 @@ private:
             capacity = 0;
         }
 
-        ReleaseMemory(allocator, old_used,
-                           (old_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t));
-        ReleaseMemory(allocator, old_data, old_capacity * RG_SIZE(ValueType));
+        ReleaseRaw(allocator, old_used, (old_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t));
+        ReleaseRaw(allocator, old_data, old_capacity * RG_SIZE(ValueType));
     }
 
     void MarkUsed(Size idx)