[compiler-rt] hwasan: refactor interceptor allocation/deallocation functions (PR #145357)
Justin King via llvm-commits
llvm-commits at lists.llvm.org
Thu Jul 10 06:32:27 PDT 2025
https://github.com/jcking updated https://github.com/llvm/llvm-project/pull/145357
>From 92dd6bff2db665c7ab210179678d9cb9caa8e5f3 Mon Sep 17 00:00:00 2001
From: Justin King <jcking at google.com>
Date: Mon, 23 Jun 2025 09:18:45 -0700
Subject: [PATCH] hwasan: refactor interceptor allocation/deallocation
functions
Signed-off-by: Justin King <jcking at google.com>
---
compiler-rt/lib/hwasan/hwasan.h | 15 +++
compiler-rt/lib/hwasan/hwasan_allocator.cpp | 130 ++++++++++++++++---
compiler-rt/lib/hwasan/hwasan_allocator.h | 11 +-
compiler-rt/lib/hwasan/hwasan_new_delete.cpp | 96 +++++++-------
4 files changed, 190 insertions(+), 62 deletions(-)
diff --git a/compiler-rt/lib/hwasan/hwasan.h b/compiler-rt/lib/hwasan/hwasan.h
index 1ae463f845c81..4bdeb51873787 100644
--- a/compiler-rt/lib/hwasan/hwasan.h
+++ b/compiler-rt/lib/hwasan/hwasan.h
@@ -136,6 +136,21 @@ int hwasan_posix_memalign(void **memptr, uptr alignment, uptr size,
StackTrace *stack);
void hwasan_free(void *ptr, StackTrace *stack);
+void *hwasan_new(uptr size, StackTrace *stack);
+void *hwasan_new_aligned(uptr size, uptr alignment, StackTrace *stack);
+void *hwasan_new_array(uptr size, StackTrace *stack);
+void *hwasan_new_array_aligned(uptr size, uptr alignment, StackTrace *stack);
+void hwasan_delete(void *ptr, StackTrace *stack);
+void hwasan_delete_aligned(void *ptr, uptr alignment, StackTrace *stack);
+void hwasan_delete_sized(void *ptr, uptr size, StackTrace *stack);
+void hwasan_delete_sized_aligned(void *ptr, uptr size, uptr alignment,
+ StackTrace *stack);
+void hwasan_delete_array(void *ptr, StackTrace *stack);
+void hwasan_delete_array_aligned(void *ptr, uptr alignment, StackTrace *stack);
+void hwasan_delete_array_sized(void *ptr, uptr size, StackTrace *stack);
+void hwasan_delete_array_sized_aligned(void *ptr, uptr size, uptr alignment,
+ StackTrace *stack);
+
void InstallAtExitHandler();
#define GET_MALLOC_STACK_TRACE \
diff --git a/compiler-rt/lib/hwasan/hwasan_allocator.cpp b/compiler-rt/lib/hwasan/hwasan_allocator.cpp
index 75dbb336e3445..ec47be27f0e7e 100644
--- a/compiler-rt/lib/hwasan/hwasan_allocator.cpp
+++ b/compiler-rt/lib/hwasan/hwasan_allocator.cpp
@@ -128,6 +128,12 @@ inline __lsan::ChunkTag Metadata::GetLsanTag() const {
return static_cast<__lsan::ChunkTag>(lsan_tag);
}
+inline void Metadata::SetAllocType(AllocType type) { alloc_type = type; }
+
+inline AllocType Metadata::GetAllocType() const {
+ return static_cast<AllocType>(alloc_type);
+}
+
uptr GetAliasRegionStart() {
#if defined(HWASAN_ALIASING_MODE)
constexpr uptr kAliasRegionOffset = 1ULL << (kTaggableRegionCheckShift - 1);
@@ -181,7 +187,7 @@ static uptr TaggedSize(uptr size) {
}
static void *HwasanAllocate(StackTrace *stack, uptr orig_size, uptr alignment,
- bool zeroise) {
+ AllocType alloc_type, bool zeroise) {
// Keep this consistent with LSAN and ASAN behavior.
if (UNLIKELY(orig_size == 0))
orig_size = 1;
@@ -259,6 +265,7 @@ static void *HwasanAllocate(StackTrace *stack, uptr orig_size, uptr alignment,
meta->SetLsanTag(__lsan::DisabledInThisThread() ? __lsan::kIgnored
: __lsan::kDirectlyLeaked);
#endif
+ meta->SetAllocType(alloc_type);
meta->SetAllocated(StackDepotPut(*stack), orig_size);
RunMallocHooks(user_ptr, orig_size);
return user_ptr;
@@ -285,7 +292,7 @@ static bool CheckInvalidFree(StackTrace *stack, void *untagged_ptr,
return false;
}
-static void HwasanDeallocate(StackTrace *stack, void *tagged_ptr) {
+static void HwasanDeallocate(StackTrace *stack, void *tagged_ptr, AllocType) {
CHECK(tagged_ptr);
void *untagged_ptr = UntagPtr(tagged_ptr);
@@ -379,15 +386,15 @@ static void *HwasanReallocate(StackTrace *stack, void *tagged_ptr_old,
void *untagged_ptr_old = UntagPtr(tagged_ptr_old);
if (CheckInvalidFree(stack, untagged_ptr_old, tagged_ptr_old))
return nullptr;
- void *tagged_ptr_new =
- HwasanAllocate(stack, new_size, alignment, false /*zeroise*/);
+ void *tagged_ptr_new = HwasanAllocate(stack, new_size, alignment, FROM_MALLOC,
+ false /*zeroise*/);
if (tagged_ptr_old && tagged_ptr_new) {
Metadata *meta =
reinterpret_cast<Metadata *>(allocator.GetMetaData(untagged_ptr_old));
void *untagged_ptr_new = UntagPtr(tagged_ptr_new);
internal_memcpy(untagged_ptr_new, untagged_ptr_old,
Min(new_size, static_cast<uptr>(meta->GetRequestedSize())));
- HwasanDeallocate(stack, tagged_ptr_old);
+ HwasanDeallocate(stack, tagged_ptr_old, FROM_MALLOC);
}
return tagged_ptr_new;
}
@@ -398,7 +405,7 @@ static void *HwasanCalloc(StackTrace *stack, uptr nmemb, uptr size) {
return nullptr;
ReportCallocOverflow(nmemb, size, stack);
}
- return HwasanAllocate(stack, nmemb * size, sizeof(u64), true);
+ return HwasanAllocate(stack, nmemb * size, sizeof(u64), FROM_MALLOC, true);
}
HwasanChunkView FindHeapChunkByAddress(uptr address) {
@@ -449,7 +456,8 @@ static uptr AllocationSizeFast(const void *p) {
}
void *hwasan_malloc(uptr size, StackTrace *stack) {
- return SetErrnoOnNull(HwasanAllocate(stack, size, sizeof(u64), false));
+ return SetErrnoOnNull(
+ HwasanAllocate(stack, size, sizeof(u64), FROM_MALLOC, false));
}
void *hwasan_calloc(uptr nmemb, uptr size, StackTrace *stack) {
@@ -458,9 +466,10 @@ void *hwasan_calloc(uptr nmemb, uptr size, StackTrace *stack) {
void *hwasan_realloc(void *ptr, uptr size, StackTrace *stack) {
if (!ptr)
- return SetErrnoOnNull(HwasanAllocate(stack, size, sizeof(u64), false));
+ return SetErrnoOnNull(
+ HwasanAllocate(stack, size, sizeof(u64), FROM_MALLOC, false));
if (size == 0) {
- HwasanDeallocate(stack, ptr);
+ HwasanDeallocate(stack, ptr, FROM_MALLOC);
return nullptr;
}
return SetErrnoOnNull(HwasanReallocate(stack, ptr, size, sizeof(u64)));
@@ -478,7 +487,7 @@ void *hwasan_reallocarray(void *ptr, uptr nmemb, uptr size, StackTrace *stack) {
void *hwasan_valloc(uptr size, StackTrace *stack) {
return SetErrnoOnNull(
- HwasanAllocate(stack, size, GetPageSizeCached(), false));
+ HwasanAllocate(stack, size, GetPageSizeCached(), FROM_MALLOC, false));
}
void *hwasan_pvalloc(uptr size, StackTrace *stack) {
@@ -491,7 +500,8 @@ void *hwasan_pvalloc(uptr size, StackTrace *stack) {
}
// pvalloc(0) should allocate one page.
size = size ? RoundUpTo(size, PageSize) : PageSize;
- return SetErrnoOnNull(HwasanAllocate(stack, size, PageSize, false));
+ return SetErrnoOnNull(
+ HwasanAllocate(stack, size, PageSize, FROM_MALLOC, false));
}
void *hwasan_aligned_alloc(uptr alignment, uptr size, StackTrace *stack) {
@@ -501,7 +511,8 @@ void *hwasan_aligned_alloc(uptr alignment, uptr size, StackTrace *stack) {
return nullptr;
ReportInvalidAlignedAllocAlignment(size, alignment, stack);
}
- return SetErrnoOnNull(HwasanAllocate(stack, size, alignment, false));
+ return SetErrnoOnNull(
+ HwasanAllocate(stack, size, alignment, FROM_MALLOC, false));
}
void *hwasan_memalign(uptr alignment, uptr size, StackTrace *stack) {
@@ -511,7 +522,8 @@ void *hwasan_memalign(uptr alignment, uptr size, StackTrace *stack) {
return nullptr;
ReportInvalidAllocationAlignment(alignment, stack);
}
- return SetErrnoOnNull(HwasanAllocate(stack, size, alignment, false));
+ return SetErrnoOnNull(
+ HwasanAllocate(stack, size, alignment, FROM_MALLOC, false));
}
int hwasan_posix_memalign(void **memptr, uptr alignment, uptr size,
@@ -521,7 +533,7 @@ int hwasan_posix_memalign(void **memptr, uptr alignment, uptr size,
return errno_EINVAL;
ReportInvalidPosixMemalignAlignment(alignment, stack);
}
- void *ptr = HwasanAllocate(stack, size, alignment, false);
+ void *ptr = HwasanAllocate(stack, size, alignment, FROM_MALLOC, false);
if (UNLIKELY(!ptr))
// OOM error is already taken care of by HwasanAllocate.
return errno_ENOMEM;
@@ -531,7 +543,95 @@ int hwasan_posix_memalign(void **memptr, uptr alignment, uptr size,
}
void hwasan_free(void *ptr, StackTrace *stack) {
- return HwasanDeallocate(stack, ptr);
+ HwasanDeallocate(stack, ptr, FROM_MALLOC);
+}
+
+namespace {
+
+void *hwasan_new(uptr size, StackTrace *stack, bool array) {
+ return SetErrnoOnNull(HwasanAllocate(stack, size, sizeof(u64),
+ array ? FROM_NEW_BR : FROM_NEW, true));
+}
+
+void *hwasan_new_aligned(uptr size, uptr alignment, StackTrace *stack,
+ bool array) {
+ if (UNLIKELY(alignment == 0 || !IsPowerOfTwo(alignment))) {
+ errno = errno_EINVAL;
+ if (AllocatorMayReturnNull())
+ return nullptr;
+ ReportInvalidAllocationAlignment(alignment, stack);
+ }
+ return SetErrnoOnNull(HwasanAllocate(stack, size, alignment,
+ array ? FROM_NEW_BR : FROM_NEW, false));
+}
+
+void hwasan_delete(void *ptr, StackTrace *stack, bool array) {
+ HwasanDeallocate(stack, ptr, array ? FROM_NEW_BR : FROM_NEW);
+}
+
+void hwasan_delete_aligned(void *ptr, uptr, StackTrace *stack, bool array) {
+ HwasanDeallocate(stack, ptr, array ? FROM_NEW_BR : FROM_NEW);
+}
+
+void hwasan_delete_sized(void *ptr, uptr, StackTrace *stack, bool array) {
+ HwasanDeallocate(stack, ptr, array ? FROM_NEW_BR : FROM_NEW);
+}
+
+void hwasan_delete_sized_aligned(void *ptr, uptr, uptr, StackTrace *stack,
+ bool array) {
+ HwasanDeallocate(stack, ptr, array ? FROM_NEW_BR : FROM_NEW);
+}
+
+} // namespace
+
+void *hwasan_new(uptr size, StackTrace *stack) {
+ return hwasan_new(size, stack, /*array=*/false);
+}
+
+void *hwasan_new_aligned(uptr size, uptr alignment, StackTrace *stack) {
+ return hwasan_new_aligned(size, alignment, stack, /*array=*/false);
+}
+
+void *hwasan_new_array(uptr size, StackTrace *stack) {
+ return hwasan_new(size, stack, /*array=*/true);
+}
+
+void *hwasan_new_array_aligned(uptr size, uptr alignment, StackTrace *stack) {
+ return hwasan_new_aligned(size, alignment, stack, /*array=*/true);
+}
+
+void hwasan_delete(void *ptr, StackTrace *stack) {
+ hwasan_delete(ptr, stack, /*array=*/false);
+}
+
+void hwasan_delete_aligned(void *ptr, uptr alignment, StackTrace *stack) {
+ hwasan_delete_aligned(ptr, alignment, stack, /*array=*/false);
+}
+
+void hwasan_delete_sized(void *ptr, uptr size, StackTrace *stack) {
+ hwasan_delete_sized(ptr, size, stack, /*array=*/false);
+}
+
+void hwasan_delete_sized_aligned(void *ptr, uptr size, uptr alignment,
+ StackTrace *stack) {
+ hwasan_delete_sized_aligned(ptr, size, alignment, stack, /*array=*/false);
+}
+
+void hwasan_delete_array(void *ptr, StackTrace *stack) {
+ hwasan_delete(ptr, stack, /*array=*/true);
+}
+
+void hwasan_delete_array_aligned(void *ptr, uptr alignment, StackTrace *stack) {
+ hwasan_delete_aligned(ptr, alignment, stack, /*array=*/true);
+}
+
+void hwasan_delete_array_sized(void *ptr, uptr size, StackTrace *stack) {
+ hwasan_delete_sized(ptr, size, stack, /*array=*/true);
+}
+
+void hwasan_delete_array_sized_aligned(void *ptr, uptr size, uptr alignment,
+ StackTrace *stack) {
+ hwasan_delete_sized_aligned(ptr, size, alignment, stack, /*array=*/true);
}
} // namespace __hwasan
diff --git a/compiler-rt/lib/hwasan/hwasan_allocator.h b/compiler-rt/lib/hwasan/hwasan_allocator.h
index 2ada2a0b1851a..6c28ffed591e6 100644
--- a/compiler-rt/lib/hwasan/hwasan_allocator.h
+++ b/compiler-rt/lib/hwasan/hwasan_allocator.h
@@ -31,13 +31,20 @@
namespace __hwasan {
+enum AllocType {
+ FROM_MALLOC = 1, // Memory block came from malloc, calloc, realloc, etc.
+ FROM_NEW = 2, // Memory block came from operator new.
+ FROM_NEW_BR = 3 // Memory block came from operator new [ ]
+};
+
struct Metadata {
private:
atomic_uint64_t alloc_context_id;
u32 requested_size_low;
u16 requested_size_high;
atomic_uint8_t chunk_state;
- u8 lsan_tag;
+ u8 lsan_tag : 2;
+ u8 alloc_type : 2;
public:
inline void SetAllocated(u32 stack, u64 size);
@@ -49,6 +56,8 @@ struct Metadata {
inline u32 GetAllocThreadId() const;
inline void SetLsanTag(__lsan::ChunkTag tag);
inline __lsan::ChunkTag GetLsanTag() const;
+ inline void SetAllocType(AllocType type);
+ inline AllocType GetAllocType() const;
};
static_assert(sizeof(Metadata) == 16);
diff --git a/compiler-rt/lib/hwasan/hwasan_new_delete.cpp b/compiler-rt/lib/hwasan/hwasan_new_delete.cpp
index 232eb0eb6da67..88ab06d8693eb 100644
--- a/compiler-rt/lib/hwasan/hwasan_new_delete.cpp
+++ b/compiler-rt/lib/hwasan/hwasan_new_delete.cpp
@@ -22,75 +22,77 @@
#if HWASAN_REPLACE_OPERATORS_NEW_AND_DELETE
// TODO(alekseys): throw std::bad_alloc instead of dying on OOM.
-# define OPERATOR_NEW_BODY \
- GET_MALLOC_STACK_TRACE; \
- void *res = hwasan_malloc(size, &stack); \
- if (UNLIKELY(!res)) \
- ReportOutOfMemory(size, &stack); \
+# define OPERATOR_NEW_BODY \
+ GET_MALLOC_STACK_TRACE; \
+ void *res = hwasan_new(size, &stack); \
+ if (UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
return res
# define OPERATOR_NEW_BODY_NOTHROW \
GET_MALLOC_STACK_TRACE; \
- return hwasan_malloc(size, &stack)
-# define OPERATOR_NEW_BODY_ARRAY \
- GET_MALLOC_STACK_TRACE; \
- void *res = hwasan_malloc(size, &stack); \
- if (UNLIKELY(!res)) \
- ReportOutOfMemory(size, &stack); \
+ return hwasan_new(size, &stack)
+# define OPERATOR_NEW_BODY_ARRAY \
+ GET_MALLOC_STACK_TRACE; \
+ void *res = hwasan_new_array(size, &stack); \
+ if (UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
return res
# define OPERATOR_NEW_BODY_ARRAY_NOTHROW \
GET_MALLOC_STACK_TRACE; \
- return hwasan_malloc(size, &stack)
-# define OPERATOR_NEW_BODY_ALIGN \
- GET_MALLOC_STACK_TRACE; \
- void *res = hwasan_memalign(static_cast<uptr>(align), size, &stack); \
- if (UNLIKELY(!res)) \
- ReportOutOfMemory(size, &stack); \
+ return hwasan_new_array(size, &stack)
+# define OPERATOR_NEW_BODY_ALIGN \
+ GET_MALLOC_STACK_TRACE; \
+ void *res = hwasan_new_aligned(size, static_cast<uptr>(align), &stack); \
+ if (UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
return res
# define OPERATOR_NEW_BODY_ALIGN_NOTHROW \
GET_MALLOC_STACK_TRACE; \
- return hwasan_memalign(static_cast<uptr>(align), size, &stack)
-# define OPERATOR_NEW_BODY_ALIGN_ARRAY \
- GET_MALLOC_STACK_TRACE; \
- void *res = hwasan_memalign(static_cast<uptr>(align), size, &stack); \
- if (UNLIKELY(!res)) \
- ReportOutOfMemory(size, &stack); \
+ return hwasan_new_aligned(size, static_cast<uptr>(align), &stack)
+# define OPERATOR_NEW_BODY_ALIGN_ARRAY \
+ GET_MALLOC_STACK_TRACE; \
+ void *res = \
+ hwasan_new_array_aligned(size, static_cast<uptr>(align), &stack); \
+ if (UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
return res
# define OPERATOR_NEW_BODY_ALIGN_ARRAY_NOTHROW \
GET_MALLOC_STACK_TRACE; \
- return hwasan_memalign(static_cast<uptr>(align), size, &stack)
+ return hwasan_new_array_aligned(size, static_cast<uptr>(align), &stack)
# define OPERATOR_DELETE_BODY \
GET_MALLOC_STACK_TRACE; \
if (ptr) \
- hwasan_free(ptr, &stack)
+ hwasan_delete(ptr, &stack)
# define OPERATOR_DELETE_BODY_ARRAY \
GET_MALLOC_STACK_TRACE; \
if (ptr) \
- hwasan_free(ptr, &stack)
+ hwasan_delete_array(ptr, &stack)
# define OPERATOR_DELETE_BODY_ALIGN \
GET_MALLOC_STACK_TRACE; \
if (ptr) \
- hwasan_free(ptr, &stack)
+ hwasan_delete_aligned(ptr, static_cast<uptr>(align), &stack)
# define OPERATOR_DELETE_BODY_ALIGN_ARRAY \
GET_MALLOC_STACK_TRACE; \
if (ptr) \
- hwasan_free(ptr, &stack)
+ hwasan_delete_array_aligned(ptr, static_cast<uptr>(align), &stack)
# define OPERATOR_DELETE_BODY_SIZE \
GET_MALLOC_STACK_TRACE; \
if (ptr) \
- hwasan_free(ptr, &stack)
+ hwasan_delete_sized(ptr, size, &stack)
# define OPERATOR_DELETE_BODY_SIZE_ARRAY \
GET_MALLOC_STACK_TRACE; \
if (ptr) \
- hwasan_free(ptr, &stack)
+ hwasan_delete_array_sized(ptr, size, &stack)
# define OPERATOR_DELETE_BODY_SIZE_ALIGN \
GET_MALLOC_STACK_TRACE; \
if (ptr) \
- hwasan_free(ptr, &stack)
-# define OPERATOR_DELETE_BODY_SIZE_ALIGN_ARRAY \
- GET_MALLOC_STACK_TRACE; \
- if (ptr) \
- hwasan_free(ptr, &stack)
+ hwasan_delete_sized_aligned(ptr, size, static_cast<uptr>(align), &stack)
+# define OPERATOR_DELETE_BODY_SIZE_ALIGN_ARRAY \
+ GET_MALLOC_STACK_TRACE; \
+ if (ptr) \
+ hwasan_delete_array_sized_aligned(ptr, size, static_cast<uptr>(align), \
+ &stack)
#elif defined(__ANDROID__)
@@ -136,7 +138,7 @@ INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *operator new[](
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
void *ptr) NOEXCEPT {
- OPERATOR_DELETE_BODY;
+ OPERATOR_DELETE_BODY(false /*array*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
void *ptr) NOEXCEPT {
@@ -144,18 +146,18 @@ INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
void *ptr, std::nothrow_t const &) {
- OPERATOR_DELETE_BODY;
+ OPERATOR_DELETE_BODY(false /*array*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
void *ptr, std::nothrow_t const &) {
OPERATOR_DELETE_BODY_ARRAY;
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
- void *ptr, size_t) NOEXCEPT {
+ void *ptr, size_t size) NOEXCEPT {
OPERATOR_DELETE_BODY_SIZE;
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
- void *ptr, size_t) NOEXCEPT {
+ void *ptr, size_t size) NOEXCEPT {
OPERATOR_DELETE_BODY_SIZE_ARRAY;
}
@@ -189,31 +191,33 @@ INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
OPERATOR_DELETE_BODY_ALIGN;
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
- void *ptr, std::align_val_t) NOEXCEPT {
+ void *ptr, std::align_val_t align) NOEXCEPT {
OPERATOR_DELETE_BODY_ALIGN_ARRAY;
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
- void *ptr, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
+ void *ptr, std::align_val_t align, std::nothrow_t const &) NOEXCEPT {
OPERATOR_DELETE_BODY_ALIGN;
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
- void *ptr, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
+ void *ptr, std::align_val_t align, std::nothrow_t const &) NOEXCEPT {
OPERATOR_DELETE_BODY_ALIGN_ARRAY;
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
- void *ptr, size_t, std::align_val_t) NOEXCEPT {
+ void *ptr, size_t size, std::align_val_t align) NOEXCEPT {
OPERATOR_DELETE_BODY_SIZE_ALIGN;
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
- void *ptr, size_t, std::align_val_t) NOEXCEPT {
+ void *ptr, size_t size, std::align_val_t align) NOEXCEPT {
OPERATOR_DELETE_BODY_SIZE_ALIGN_ARRAY;
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
- void *ptr, size_t, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
+ void *ptr, size_t size, std::align_val_t align,
+ std::nothrow_t const &) NOEXCEPT {
OPERATOR_DELETE_BODY_SIZE_ALIGN;
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
- void *ptr, size_t, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
+ void *ptr, size_t size, std::align_val_t align,
+ std::nothrow_t const &) NOEXCEPT {
OPERATOR_DELETE_BODY_SIZE_ALIGN_ARRAY;
}
More information about the llvm-commits
mailing list