[compiler-rt] hwasan: refactor interceptor allocation/deallocation functions (PR #145357)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Jun 23 09:21:20 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-compiler-rt-sanitizer
Author: Justin King (jcking)
<details>
<summary>Changes</summary>
Do some refactoring to allocation/deallocation interceptors. Expose explicit per-alloc_type functions. This is similar to #<!-- -->145087 for ASan.
NOTE: This change rejects attempts to call `operator new(<some_size>, static_cast<std::align_val_t>(0))`.
For https://github.com/llvm/llvm-project/issues/144435
---
Patch is 20.42 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/145357.diff
4 Files Affected:
- (modified) compiler-rt/lib/hwasan/hwasan.h (+15)
- (modified) compiler-rt/lib/hwasan/hwasan_allocator.cpp (+115-15)
- (modified) compiler-rt/lib/hwasan/hwasan_allocator.h (+10-1)
- (modified) compiler-rt/lib/hwasan/hwasan_new_delete.cpp (+67-54)
``````````diff
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..8eb49e388d705 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, 0, 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 f0fd3726ef1b1..3517364436bc2 100644
--- a/compiler-rt/lib/hwasan/hwasan_new_delete.cpp
+++ b/compiler-rt/lib/hwasan/hwasan_new_delete.cpp
@@ -22,23 +22,43 @@
#if HWASAN_REPLACE_OPERATORS_NEW_AND_DELETE
// TODO(alekseys): throw std::bad_alloc instead of dying on OOM.
-# define OPERATOR_NEW_BODY(nothrow) \
- GET_MALLOC_STACK_TRACE; \
- void *res = hwasan_malloc(size, &stack); \
- if (!nothrow && UNLIKELY(!res)) \
- ReportOutOfMemory(size, &stack); \
- return res
-# define OPERATOR_NEW_ALIGN_BODY(nothrow) \
- GET_MALLOC_STACK_TRACE; \
- void *res = hwasan_memalign(static_cast<uptr>(align), size, &stack); \
- if (!nothrow && UNLIKELY(!res)) \
- ReportOutOfMemory(size, &stack); \
- return res
-
-# define OPERATOR_DELETE_BODY \
- GET_MALLOC_STACK_TRACE; \
- if (ptr) \
- hwasan_free(ptr, &stack)
+# define OPERATOR_NEW_BODY(array, nothrow) \
+ GET_MALLOC_STACK_TRACE; \
+ void *res = \
+ array ? hwasan_new_array(size, &stack) : hwasan_new(size, &stack); \
+ if (!nothrow && UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
+ return res;
+# define OPERATOR_NEW_BODY_ALIGN(array, nothrow) \
+ GET_MALLOC_STACK_TRACE; \
+ void *res = \
+ array \
+ ? hwasan_new_array_aligned(size, static_cast<uptr>(align), &stack) \
+ : hwasan_new_aligned(size, static_cast<uptr>(align), &stack); \
+ if (!nothrow && UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
+ return res;
+
+# define OPERATOR_DELETE_BODY(array) \
+ GET_MALLOC_STACK_TRACE; \
+ array ? hwasan_delete_array(ptr, &stack) : hwasan_delete(ptr, &stack);
+
+# define OPERATOR_DELETE_BODY_SIZE(array) \
+ GET_MALLOC_STACK_TRACE; \
+ array ? hwasan_delete_array_sized(ptr, size, &stack) \
+ : hwasan_delete_sized(ptr, size, &stack);
+
+# define OPERATOR_DELETE_BODY_ALIGN(array) \
+ GET_MALLOC_STACK_TRACE; \
+ array ? hwasan_delete_array_aligned(ptr, static_cast<uptr>(align), &stack) \
+ : hwasan_delete_aligned(ptr, static_cast<uptr>(align), &stack);
+
+# define OPERATOR_DELETE_BODY_SIZE_ALIGN(array) \
+ GET_MALLOC_STACK_TRACE; \
+ array ? hwasan_delete_array_sized_aligned( \
+ ptr, size, static_cast<uptr>(align), &stack) \
+ : hwasan_delete_sized_aligned(ptr, size, static_cast<uptr>(align), \
+ &stack);
#elif defined(__ANDROID__)
@@ -46,8 +66,9 @@
// since we previously released a runtime that intercepted these functions,
// removing the interceptors would break ABI. Therefore we simply forward to
// malloc and free.
-# define OPERATOR_NEW_BODY(nothrow) return malloc(size)
-# define OPERATOR_DELETE_BODY free(ptr)
+# define OPERATOR_NEW_BODY(array, nothrow) return malloc(size)
+# define OPERATOR_DELETE_BODY(array) free(ptr)
+# define OPERATOR_DELETE_BODY_SIZE(array) free(ptr)
#endif
@@ -61,44 +82,44 @@ struct nothrow_t {};
} // namespace std
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *operator new(size_t size) {
- OPERATOR_NEW_BODY(false /*nothrow*/);
+ OPERATOR_NEW_BODY(false /*array*/, false /*nothrow*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *operator new[](
size_t size) {
- OPERATOR_NEW_BODY(false /*nothrow*/);
+ OPERATOR_NEW_BODY(true /*array*/, false /*nothrow*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *operator new(
size_t size, std::nothrow_t const &) {
- OPERATOR_NEW_BODY(true /*nothrow*/);
+ OPERATOR_NEW_BODY(false /*array*/, true /*nothrow*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *operator new[](
size_t size, std::nothrow_t const &) {
- OPERATOR_NEW_BODY(true /*nothrow*/);
+ OPERATOR_NEW_BODY(true /*array*/, true /*nothrow*/);
}
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 {
- OPERATOR_DELETE_BODY;
+ OPERATOR_DELETE_BODY(true /*array*/);
}
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;
+ OPERATOR_DELETE_BODY(true /*array*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
- void *ptr, size_t) NOEXCEPT {
- OPERATOR_DELETE_BODY;
+ void *ptr, size_t size) NOEXCEPT {
+ OPERATOR_DELETE_BODY_SIZE(false /*array*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
- void *ptr, size_t) NOEXCEPT {
- OPERATOR_DELETE_BODY;
+ void *ptr, size_t size) NOEXCEPT {
+ OPERATOR_DELETE_BODY_SIZE(true /*array*/);
}
#endif // OPERATOR_NEW_BODY
@@ -111,52 +132,44 @@ enum class align_val_t : size_t {};
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *operator new(
size_t size, std::align_val_t align) {
- OPERATOR_NEW_ALIGN_BODY(false /*nothrow*/);
+ OPERATOR_NEW_BODY_ALIGN(false /*array*/, false /*nothrow*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *operator new[](
size_t size, std::align_val_t align) {
- OPERATOR_NEW_ALIGN_BODY(false /*nothrow*/);
+ OPERATOR_NEW_BODY_ALIGN(true /*array*/, false /*nothrow*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *operator new(
size_t size, std::align_val_t align, std::nothrow_t const &) {
- OPERATOR_NEW_ALIGN_BODY(true /*nothrow*/);
+ OPERATOR_NEW_BODY_ALIGN(false /*array*/, true /*nothrow*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *operator new[](
size_t size, std::align_val_t align, std::nothrow_t const &) {
- OPERATOR_NEW_ALIGN_BODY(true /*nothrow*/);
+ OPERATOR_NEW_BODY_ALIGN(true /*array*/, true /*nothrow*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
void *ptr, std::align_val_t align) NOEXCEPT {
- OPERATOR_DELETE_BODY;
+ OPERATOR_DELETE_BODY_ALIGN(false /*array*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
- void *ptr, std::align_val_t) NOEXCEPT {
- OPERATOR_DELETE_BODY;
-}
-INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
- void *ptr, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
- OPERATOR_DELETE_BODY;
-}
-INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
- void *ptr, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
- OPERATOR_DELETE_BODY;
+ void *ptr, std::align_val_t align) NOEXCEPT {
+ OPERATOR_DELETE_BODY_ALIGN(true /*array*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
- void *ptr, size_t, std::align_val_t) NOEXCEPT {
- OPERATOR_DELETE_BODY;
+ void *ptr, std::align_val_t align, std::nothrow_t const &) {
+ OPERATOR_DELETE_BODY_ALIGN(false /*array*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
- void *ptr, size_t, std::align_val_t) NOEXCEPT {
- OPERATOR_DELETE_BODY;
+ void *ptr, std::align_val_t align, std::nothrow_t const &) {
+ OPERATOR_DELETE_BODY_ALIGN(true /*array*/);
}
INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
- void *ptr, size_t, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
- OPERATOR_DELETE_BODY;
+ void *ptr, size_t siz...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/145357
More information about the llvm-commits
mailing list