[compiler-rt] scudo: Support free_sized and free_aligned_sized from C23 (PR #146556)
Justin King via llvm-commits
llvm-commits at lists.llvm.org
Tue Jul 1 11:19:56 PDT 2025
https://github.com/jcking updated https://github.com/llvm/llvm-project/pull/146556
>From d0192c3c4691ac747009d20d902e3ae8c4f1e780 Mon Sep 17 00:00:00 2001
From: Justin King <jcking at google.com>
Date: Tue, 17 Jun 2025 10:52:16 -0700
Subject: [PATCH] scudo: Support free_sized and free_aligned_sized from C23
Signed-off-by: Justin King <jcking at google.com>
---
compiler-rt/lib/scudo/standalone/chunk.h | 2 +-
compiler-rt/lib/scudo/standalone/combined.h | 52 ++++++++--
compiler-rt/lib/scudo/standalone/flags.inc | 15 +++
compiler-rt/lib/scudo/standalone/options.h | 3 +
compiler-rt/lib/scudo/standalone/report.cpp | 19 ++++
compiler-rt/lib/scudo/standalone/report.h | 6 +-
.../scudo/standalone/tests/scudo_unit_test.h | 10 ++
.../standalone/tests/scudo_unit_test_main.cpp | 8 --
.../standalone/tests/wrappers_c_test.cpp | 98 +++++++++++++++++++
.../lib/scudo/standalone/wrappers_c.inc | 24 +++--
.../lib/scudo/standalone/wrappers_cpp.cpp | 28 +++---
11 files changed, 224 insertions(+), 41 deletions(-)
diff --git a/compiler-rt/lib/scudo/standalone/chunk.h b/compiler-rt/lib/scudo/standalone/chunk.h
index 9da2dc57e71a1..f64c1eb93127c 100644
--- a/compiler-rt/lib/scudo/standalone/chunk.h
+++ b/compiler-rt/lib/scudo/standalone/chunk.h
@@ -56,7 +56,7 @@ enum Origin : u8 {
Malloc = 0,
New = 1,
NewArray = 2,
- Memalign = 3,
+ AlignedAlloc = 3,
};
enum State : u8 { Available = 0, Allocated = 1, Quarantined = 2 };
diff --git a/compiler-rt/lib/scudo/standalone/combined.h b/compiler-rt/lib/scudo/standalone/combined.h
index 87acdec2a3bac..414274e9ebf39 100644
--- a/compiler-rt/lib/scudo/standalone/combined.h
+++ b/compiler-rt/lib/scudo/standalone/combined.h
@@ -170,6 +170,12 @@ class Allocator {
Primary.Options.set(OptionBit::DeallocTypeMismatch);
if (getFlags()->delete_size_mismatch)
Primary.Options.set(OptionBit::DeleteSizeMismatch);
+ if (getFlags()->free_size_mismatch)
+ Primary.Options.set(OptionBit::FreeSizeMismatch);
+ if (getFlags()->free_alignment_mismatch)
+ Primary.Options.set(OptionBit::FreeAlignmentMismatch);
+ if (getFlags()->delete_alignment_mismatch)
+ Primary.Options.set(OptionBit::DeleteAlignmentMismatch);
if (allocatorSupportsMemoryTagging<AllocatorConfig>() &&
systemSupportsMemoryTagging())
Primary.Options.set(OptionBit::UseMemoryTagging);
@@ -433,7 +439,9 @@ class Allocator {
}
NOINLINE void deallocate(void *Ptr, Chunk::Origin Origin, uptr DeleteSize = 0,
- UNUSED uptr Alignment = MinAlignment) {
+ bool HasDeleteSize = false,
+ uptr DeleteAlignment = MinAlignment,
+ bool HasDeleteAlignment = false) {
if (UNLIKELY(!Ptr))
return;
@@ -456,6 +464,9 @@ class Allocator {
}
#endif // GWP_ASAN_HOOKS
+ if (UNLIKELY(HasDeleteAlignment && !isPowerOfTwo(DeleteAlignment)))
+ reportAlignmentNotPowerOfTwo(DeleteAlignment);
+
if (UNLIKELY(!isAligned(reinterpret_cast<uptr>(Ptr), MinAlignment)))
reportMisalignedPointer(AllocatorAction::Deallocating, Ptr);
@@ -471,19 +482,37 @@ class Allocator {
const Options Options = Primary.Options.load();
if (Options.get(OptionBit::DeallocTypeMismatch)) {
if (UNLIKELY(Header.OriginOrWasZeroed != Origin)) {
- // With the exception of memalign'd chunks, that can be still be free'd.
- if (Header.OriginOrWasZeroed != Chunk::Origin::Memalign ||
- Origin != Chunk::Origin::Malloc)
+ // With the exception of aligned_alloc'd chunks, which can be free'd or
+ // free_aligned_sized'd but not free_sized'd.
+ if (UNLIKELY(Header.OriginOrWasZeroed != Chunk::Origin::AlignedAlloc ||
+ Origin != Chunk::Origin::Malloc || !HasDeleteSize))
reportDeallocTypeMismatch(AllocatorAction::Deallocating, Ptr,
Header.OriginOrWasZeroed, Origin);
}
}
const uptr Size = getSize(Ptr, &Header);
- if (DeleteSize && Options.get(OptionBit::DeleteSizeMismatch)) {
+ if ((Origin == Chunk::Origin::New || Origin == Chunk::Origin::NewArray) &&
+ HasDeleteSize && Options.get(OptionBit::DeleteSizeMismatch)) {
if (UNLIKELY(DeleteSize != Size))
reportDeleteSizeMismatch(Ptr, DeleteSize, Size);
}
+ if ((Origin == Chunk::Origin::New || Origin == Chunk::Origin::NewArray) &&
+ HasDeleteAlignment && Options.get(OptionBit::DeleteAlignmentMismatch)) {
+ if (UNLIKELY(!isAligned(reinterpret_cast<uptr>(Ptr), DeleteAlignment)))
+ reportDeleteAlignmentMismatch(Ptr, DeleteAlignment);
+ }
+ if ((Origin == Chunk::Origin::Malloc ||
+ Origin == Chunk::Origin::AlignedAlloc) &&
+ HasDeleteSize && Options.get(OptionBit::FreeSizeMismatch)) {
+ if (UNLIKELY(DeleteSize != Size))
+ reportFreeSizeMismatch(Ptr, DeleteSize, Size);
+ }
+ if (Origin == Chunk::Origin::AlignedAlloc && HasDeleteAlignment &&
+ Options.get(OptionBit::FreeAlignmentMismatch)) {
+ if (UNLIKELY(!isAligned(reinterpret_cast<uptr>(Ptr), DeleteAlignment)))
+ reportFreeAlignmentMismatch(Ptr, DeleteAlignment);
+ }
quarantineOrDeallocateChunk(Options, TaggedPtr, &Header, Size);
}
@@ -520,7 +549,7 @@ class Allocator {
void *OldTaggedPtr = OldPtr;
OldPtr = getHeaderTaggedPointer(OldPtr);
- if (UNLIKELY(!isAligned(reinterpret_cast<uptr>(OldPtr), MinAlignment)))
+ if (UNLIKELY(!isAligned(reinterpret_cast<uptr>(OldPtr), Alignment)))
reportMisalignedPointer(AllocatorAction::Reallocating, OldPtr);
Chunk::UnpackedHeader Header;
@@ -529,11 +558,14 @@ class Allocator {
if (UNLIKELY(Header.State != Chunk::State::Allocated))
reportInvalidChunkState(AllocatorAction::Reallocating, OldPtr);
- // Pointer has to be allocated with a malloc-type function. Some
- // applications think that it is OK to realloc a memalign'ed pointer, which
- // will trigger this check. It really isn't.
if (Options.get(OptionBit::DeallocTypeMismatch)) {
- if (UNLIKELY(Header.OriginOrWasZeroed != Chunk::Origin::Malloc))
+ // There is no language prohibiting the use of realloc with
+ // aligned_alloc/posix_memalign/memalign and etc. However there is no
+ // guarantee that the allocator being used with malloc is the same as
+ // operator new. There is also no guarantee that they share the same
+ // minimum alignment guarantees. So we reject these.
+ if (UNLIKELY(Header.OriginOrWasZeroed == Chunk::Origin::New ||
+ Header.OriginOrWasZeroed == Chunk::Origin::NewArray))
reportDeallocTypeMismatch(AllocatorAction::Reallocating, OldPtr,
Header.OriginOrWasZeroed,
Chunk::Origin::Malloc);
diff --git a/compiler-rt/lib/scudo/standalone/flags.inc b/compiler-rt/lib/scudo/standalone/flags.inc
index ff0c28e1db7c4..cd83d962509b7 100644
--- a/compiler-rt/lib/scudo/standalone/flags.inc
+++ b/compiler-rt/lib/scudo/standalone/flags.inc
@@ -49,3 +49,18 @@ SCUDO_FLAG(int, release_to_os_interval_ms, 5000,
SCUDO_FLAG(int, allocation_ring_buffer_size, 32768,
"Entries to keep in the allocation ring buffer for scudo. "
"Values less or equal to zero disable the buffer.")
+
+SCUDO_FLAG(bool, delete_alignment_mismatch, true,
+ "Terminate on an alignment mismatch between a aligned-delete and "
+ "the actual "
+ "alignment of a chunk (as provided to new/new[]).")
+
+SCUDO_FLAG(bool, free_size_mismatch, true,
+ "Terminate on a size mismatch between a free_sized and the actual "
+ "size of a chunk (as provided to malloc/calloc/realloc).")
+
+SCUDO_FLAG(bool, free_alignment_mismatch, true,
+ "Terminate on an alignment mismatch between a free_aligned_sized "
+ "and the actual "
+ "alignment of a chunk (as provided to "
+ "aligned_alloc/posix_memalign/memalign).")
diff --git a/compiler-rt/lib/scudo/standalone/options.h b/compiler-rt/lib/scudo/standalone/options.h
index b20142a415903..d77b9111890cc 100644
--- a/compiler-rt/lib/scudo/standalone/options.h
+++ b/compiler-rt/lib/scudo/standalone/options.h
@@ -25,6 +25,9 @@ enum class OptionBit {
UseOddEvenTags,
UseMemoryTagging,
AddLargeAllocationSlack,
+ DeleteAlignmentMismatch,
+ FreeSizeMismatch,
+ FreeAlignmentMismatch,
};
struct Options {
diff --git a/compiler-rt/lib/scudo/standalone/report.cpp b/compiler-rt/lib/scudo/standalone/report.cpp
index b97a74b078c2f..13705bfd4deb5 100644
--- a/compiler-rt/lib/scudo/standalone/report.cpp
+++ b/compiler-rt/lib/scudo/standalone/report.cpp
@@ -161,6 +161,25 @@ void NORETURN reportDeleteSizeMismatch(const void *Ptr, uptr Size,
Size, ExpectedSize);
}
+void NORETURN reportDeleteAlignmentMismatch(const void *Ptr, uptr Alignment) {
+ ScopedErrorReport Report;
+ Report.append("invalid aligned delete when deallocating address %p (%zu)\n",
+ Ptr, Alignment);
+}
+
+void NORETURN reportFreeSizeMismatch(const void *Ptr, uptr Size, uptr ExpectedSize) {
+ ScopedErrorReport Report;
+ Report.append(
+ "invalid sized free when deallocating address %p (%zu vs %zu)\n", Ptr,
+ Size, ExpectedSize);
+}
+
+void NORETURN reportFreeAlignmentMismatch(const void *Ptr, uptr Alignment) {
+ ScopedErrorReport Report;
+ Report.append("invalid aligned free when deallocating address %p (%zu)\n",
+ Ptr, Alignment);
+}
+
void NORETURN reportAlignmentNotPowerOfTwo(uptr Alignment) {
ScopedErrorReport Report;
Report.append(
diff --git a/compiler-rt/lib/scudo/standalone/report.h b/compiler-rt/lib/scudo/standalone/report.h
index c397dd3fc9c65..75416dd89336f 100644
--- a/compiler-rt/lib/scudo/standalone/report.h
+++ b/compiler-rt/lib/scudo/standalone/report.h
@@ -45,8 +45,10 @@ void NORETURN reportInvalidChunkState(AllocatorAction Action, const void *Ptr);
void NORETURN reportMisalignedPointer(AllocatorAction Action, const void *Ptr);
void NORETURN reportDeallocTypeMismatch(AllocatorAction Action, const void *Ptr,
u8 TypeA, u8 TypeB);
-void NORETURN reportDeleteSizeMismatch(const void *Ptr, uptr Size,
- uptr ExpectedSize);
+void NORETURN reportDeleteSizeMismatch(const void *Ptr, uptr Size, uptr ExpectedSize);
+void NORETURN reportDeleteAlignmentMismatch(const void *Ptr, uptr Alignment);
+void NORETURN reportFreeSizeMismatch(const void *Ptr, uptr Size, uptr ExpectedSize);
+void NORETURN reportFreeAlignmentMismatch(const void *Ptr, uptr Alignment);
// C wrappers errors.
void NORETURN reportAlignmentNotPowerOfTwo(uptr Alignment);
diff --git a/compiler-rt/lib/scudo/standalone/tests/scudo_unit_test.h b/compiler-rt/lib/scudo/standalone/tests/scudo_unit_test.h
index 27c0e591a2099..a7e614676d8e2 100644
--- a/compiler-rt/lib/scudo/standalone/tests/scudo_unit_test.h
+++ b/compiler-rt/lib/scudo/standalone/tests/scudo_unit_test.h
@@ -58,4 +58,14 @@ using Test = ::testing::Test;
#define SCUDO_NO_TEST_MAIN
#endif
+// Match Android's default configuration, which disables Scudo's mismatch
+// allocation check, as it is being triggered by some third party code.
+#if SCUDO_ANDROID
+#define DEALLOC_TYPE_MISMATCH "false"
+#define SKIP_ON_ANDROID(T) DISABLED_##T
+#else
+#define DEALLOC_TYPE_MISMATCH "true"
+#define SKIP_ON_ANDROID(T) T
+#endif
+
extern bool UseQuarantine;
diff --git a/compiler-rt/lib/scudo/standalone/tests/scudo_unit_test_main.cpp b/compiler-rt/lib/scudo/standalone/tests/scudo_unit_test_main.cpp
index 881e0265bb341..d672abb99db0c 100644
--- a/compiler-rt/lib/scudo/standalone/tests/scudo_unit_test_main.cpp
+++ b/compiler-rt/lib/scudo/standalone/tests/scudo_unit_test_main.cpp
@@ -9,14 +9,6 @@
#include "memtag.h"
#include "tests/scudo_unit_test.h"
-// Match Android's default configuration, which disables Scudo's mismatch
-// allocation check, as it is being triggered by some third party code.
-#if SCUDO_ANDROID
-#define DEALLOC_TYPE_MISMATCH "false"
-#else
-#define DEALLOC_TYPE_MISMATCH "true"
-#endif
-
static void EnableMemoryTaggingIfSupported() {
if (!scudo::archSupportsMemoryTagging())
return;
diff --git a/compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp b/compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp
index f5e17d7214863..bd838f627aea3 100644
--- a/compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp
+++ b/compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp
@@ -45,6 +45,8 @@ int malloc_iterate(uintptr_t base, size_t size,
void *arg);
void *valloc(size_t size);
void *pvalloc(size_t size);
+void free_sized(void *ptr, size_t size);
+void free_aligned_sized(void *ptr, size_t alignment, size_t size);
#ifndef SCUDO_ENABLE_HOOKS_TESTS
#define SCUDO_ENABLE_HOOKS_TESTS 0
@@ -186,6 +188,102 @@ TEST_F(ScudoWrappersCDeathTest, Malloc) {
EXPECT_EQ(errno, ENOMEM);
}
+TEST_F(ScudoWrappersCDeathTest, MallocFreeSized) {
+ void *P = malloc(Size);
+ EXPECT_NE(P, nullptr);
+ EXPECT_LE(Size, malloc_usable_size(P));
+ EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % FIRST_32_SECOND_64(8U, 16U), 0U);
+ verifyAllocHookPtr(P);
+ verifyAllocHookSize(Size);
+
+ EXPECT_DEATH(free_sized(P, Size - 1), "");
+ EXPECT_DEATH(free_sized(P, Size + 1), "");
+
+ // An update to this warning in Clang now triggers in this line, but it's ok
+ // because the check is expecting a bad pointer and should fail.
+#if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
+#endif
+ EXPECT_DEATH(
+ free_sized(reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(P) | 1U),
+ Size),
+ "");
+#if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
+#pragma GCC diagnostic pop
+#endif
+
+ free_sized(P, Size);
+ verifyDeallocHookPtr(P);
+ EXPECT_DEATH(free_sized(P, Size), "");
+}
+
+TEST_F(ScudoWrappersCTest, AlignedAllocFreeAlignedSized) {
+ const size_t PageSize = static_cast<size_t>(sysconf(_SC_PAGESIZE));
+
+ const size_t Alignment = 4096U;
+ const size_t Size = Alignment * 4U;
+ void *P = aligned_alloc(Alignment, Size);
+ EXPECT_NE(P, nullptr);
+ EXPECT_LE(Size, malloc_usable_size(P));
+ EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+ verifyAllocHookPtr(P);
+ verifyAllocHookSize(Size);
+
+ EXPECT_DEATH(free_aligned_sized(P, Alignment, Size - 1), "");
+ EXPECT_DEATH(free_aligned_sized(P, Alignment, Size + 1), "");
+ EXPECT_DEATH(free_aligned_sized(P, PageSize << 1, Size), "");
+
+ // An update to this warning in Clang now triggers in this line, but it's ok
+ // because the check is expecting a bad pointer and should fail.
+#if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
+#endif
+ EXPECT_DEATH(free_aligned_sized(reinterpret_cast<void *>(
+ reinterpret_cast<uintptr_t>(P) | 1U),
+ Alignment, Size),
+ "");
+#if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
+#pragma GCC diagnostic pop
+#endif
+
+ free_aligned_sized(P, Alignment, Size);
+ verifyDeallocHookPtr(P);
+ EXPECT_DEATH(free_aligned_sized(P, Alignment, Size), "");
+}
+
+TEST_F(ScudoWrappersCDeathTest, SKIP_ON_ANDROID(MallocFreeAlignedSized)) {
+ void *P = malloc(Size);
+ EXPECT_NE(P, nullptr);
+ EXPECT_LE(Size, malloc_usable_size(P));
+ EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % FIRST_32_SECOND_64(8U, 16U), 0U);
+ verifyAllocHookPtr(P);
+ verifyAllocHookSize(Size);
+
+ EXPECT_DEATH(free_aligned_sized(P, 8, Size), "");
+ EXPECT_DEATH(free_aligned_sized(P, alignof(std::max_align_t), Size), "");
+
+ free_sized(P, Size);
+ verifyDeallocHookPtr(P);
+}
+
+TEST_F(ScudoWrappersCDeathTest, SKIP_ON_ANDROID(AlignedAllocFreeSized)) {
+ const size_t Alignment = 4096U;
+ const size_t Size = Alignment * 4U;
+ void *P = aligned_alloc(Alignment, Size);
+ EXPECT_NE(P, nullptr);
+ EXPECT_LE(Size, malloc_usable_size(P));
+ EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+ verifyAllocHookPtr(P);
+ verifyAllocHookSize(Size);
+
+ EXPECT_DEATH(free_sized(P, Size), "");
+
+ free_aligned_sized(P, Alignment, Size);
+ verifyDeallocHookPtr(P);
+}
+
TEST_F(ScudoWrappersCTest, Calloc) {
void *P = calloc(1U, Size);
EXPECT_NE(P, nullptr);
diff --git a/compiler-rt/lib/scudo/standalone/wrappers_c.inc b/compiler-rt/lib/scudo/standalone/wrappers_c.inc
index 59f3fb0962f8b..714160220974a 100644
--- a/compiler-rt/lib/scudo/standalone/wrappers_c.inc
+++ b/compiler-rt/lib/scudo/standalone/wrappers_c.inc
@@ -68,6 +68,18 @@ INTERFACE WEAK void SCUDO_PREFIX(free)(void *ptr) {
SCUDO_ALLOCATOR.deallocate(ptr, scudo::Chunk::Origin::Malloc);
}
+INTERFACE WEAK void SCUDO_PREFIX(free_sized)(void *ptr, size_t size) {
+ reportDeallocation(ptr);
+ SCUDO_ALLOCATOR.deallocate(ptr, scudo::Chunk::Origin::Malloc, size, true);
+}
+
+INTERFACE WEAK void
+SCUDO_PREFIX(free_aligned_sized)(void *ptr, size_t alignment, size_t size) {
+ reportDeallocation(ptr);
+ SCUDO_ALLOCATOR.deallocate(ptr, scudo::Chunk::Origin::AlignedAlloc, size,
+ true, alignment, true);
+}
+
INTERFACE WEAK struct SCUDO_MALLINFO SCUDO_PREFIX(mallinfo)(void) {
struct SCUDO_MALLINFO Info = {};
scudo::StatCounters Stats;
@@ -140,7 +152,7 @@ INTERFACE WEAK void *SCUDO_PREFIX(memalign)(size_t alignment, size_t size) {
}
}
void *Ptr =
- SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Memalign, alignment);
+ SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc, alignment);
reportAllocation(Ptr, size);
return Ptr;
}
@@ -153,7 +165,7 @@ INTERFACE WEAK int SCUDO_PREFIX(posix_memalign)(void **memptr, size_t alignment,
return EINVAL;
}
void *Ptr =
- SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Memalign, alignment);
+ SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc, alignment);
if (UNLIKELY(!Ptr))
return ENOMEM;
reportAllocation(Ptr, size);
@@ -174,7 +186,7 @@ INTERFACE WEAK void *SCUDO_PREFIX(pvalloc)(size_t size) {
// pvalloc(0) should allocate one page.
void *Ptr =
SCUDO_ALLOCATOR.allocate(size ? scudo::roundUp(size, PageSize) : PageSize,
- scudo::Chunk::Origin::Memalign, PageSize);
+ scudo::Chunk::Origin::Malloc, PageSize);
reportAllocation(Ptr, scudo::roundUp(size, PageSize));
return scudo::setErrnoOnNull(Ptr);
@@ -218,7 +230,7 @@ INTERFACE WEAK void *SCUDO_PREFIX(realloc)(void *ptr, size_t size) {
}
INTERFACE WEAK void *SCUDO_PREFIX(valloc)(size_t size) {
- void *Ptr = SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Memalign,
+ void *Ptr = SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc,
scudo::getPageSizeCached());
reportAllocation(Ptr, size);
@@ -307,8 +319,8 @@ INTERFACE WEAK void *SCUDO_PREFIX(aligned_alloc)(size_t alignment,
scudo::reportInvalidAlignedAllocAlignment(alignment, size);
}
- void *Ptr =
- SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc, alignment);
+ void *Ptr = SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::AlignedAlloc,
+ alignment);
reportAllocation(Ptr, size);
return scudo::setErrnoOnNull(Ptr);
diff --git a/compiler-rt/lib/scudo/standalone/wrappers_cpp.cpp b/compiler-rt/lib/scudo/standalone/wrappers_cpp.cpp
index 098d4f71acc4a..ac51082d10120 100644
--- a/compiler-rt/lib/scudo/standalone/wrappers_cpp.cpp
+++ b/compiler-rt/lib/scudo/standalone/wrappers_cpp.cpp
@@ -104,47 +104,47 @@ INTERFACE WEAK void operator delete[](void *ptr,
}
INTERFACE WEAK void operator delete(void *ptr, size_t size) NOEXCEPT {
reportDeallocation(ptr);
- Allocator.deallocate(ptr, scudo::Chunk::Origin::New, size);
+ Allocator.deallocate(ptr, scudo::Chunk::Origin::New, size, true);
}
INTERFACE WEAK void operator delete[](void *ptr, size_t size) NOEXCEPT {
reportDeallocation(ptr);
- Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, size);
+ Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, size, true);
}
INTERFACE WEAK void operator delete(void *ptr,
std::align_val_t align) NOEXCEPT {
reportDeallocation(ptr);
- Allocator.deallocate(ptr, scudo::Chunk::Origin::New, 0,
- static_cast<scudo::uptr>(align));
+ Allocator.deallocate(ptr, scudo::Chunk::Origin::New, 0, false,
+ static_cast<scudo::uptr>(align), true);
}
INTERFACE WEAK void operator delete[](void *ptr,
std::align_val_t align) NOEXCEPT {
reportDeallocation(ptr);
- Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, 0,
- static_cast<scudo::uptr>(align));
+ Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, 0, false,
+ static_cast<scudo::uptr>(align), true);
}
INTERFACE WEAK void operator delete(void *ptr, std::align_val_t align,
std::nothrow_t const &) NOEXCEPT {
reportDeallocation(ptr);
- Allocator.deallocate(ptr, scudo::Chunk::Origin::New, 0,
- static_cast<scudo::uptr>(align));
+ Allocator.deallocate(ptr, scudo::Chunk::Origin::New, 0, false,
+ static_cast<scudo::uptr>(align), true);
}
INTERFACE WEAK void operator delete[](void *ptr, std::align_val_t align,
std::nothrow_t const &) NOEXCEPT {
reportDeallocation(ptr);
- Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, 0,
- static_cast<scudo::uptr>(align));
+ Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, 0, false,
+ static_cast<scudo::uptr>(align), true);
}
INTERFACE WEAK void operator delete(void *ptr, size_t size,
std::align_val_t align) NOEXCEPT {
reportDeallocation(ptr);
- Allocator.deallocate(ptr, scudo::Chunk::Origin::New, size,
- static_cast<scudo::uptr>(align));
+ Allocator.deallocate(ptr, scudo::Chunk::Origin::New, size, true,
+ static_cast<scudo::uptr>(align), true);
}
INTERFACE WEAK void operator delete[](void *ptr, size_t size,
std::align_val_t align) NOEXCEPT {
reportDeallocation(ptr);
- Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, size,
- static_cast<scudo::uptr>(align));
+ Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, size, true,
+ static_cast<scudo::uptr>(align), true);
}
#endif // !SCUDO_ANDROID || !_BIONIC
More information about the llvm-commits
mailing list