[compiler-rt] asan: refactor interceptor allocation/deallocation functions (PR #145087)
Justin King via llvm-commits
llvm-commits at lists.llvm.org
Wed Jul 2 12:06:10 PDT 2025
https://github.com/jcking updated https://github.com/llvm/llvm-project/pull/145087
>From 49eb25f026c4fb0f92772c1cf1e9b0781d725933 Mon Sep 17 00:00:00 2001
From: Justin King <jcking at google.com>
Date: Fri, 20 Jun 2025 11:23:09 -0700
Subject: [PATCH] asan: refactor interceptor allocation/deallocation functions
Signed-off-by: Justin King <jcking at google.com>
---
compiler-rt/lib/asan/asan_allocator.cpp | 107 ++++++++++++++++--
compiler-rt/lib/asan/asan_allocator.h | 24 +++-
compiler-rt/lib/asan/asan_mac.cpp | 2 +-
compiler-rt/lib/asan/asan_malloc_linux.cpp | 8 +-
compiler-rt/lib/asan/asan_malloc_mac.cpp | 6 +-
compiler-rt/lib/asan/asan_malloc_win.cpp | 10 +-
compiler-rt/lib/asan/asan_new_delete.cpp | 64 +++++------
.../lib/asan/tests/asan_noinst_test.cpp | 18 ++-
8 files changed, 169 insertions(+), 70 deletions(-)
diff --git a/compiler-rt/lib/asan/asan_allocator.cpp b/compiler-rt/lib/asan/asan_allocator.cpp
index 3a55c2af65653..9ed0fb2ee88b8 100644
--- a/compiler-rt/lib/asan/asan_allocator.cpp
+++ b/compiler-rt/lib/asan/asan_allocator.cpp
@@ -997,13 +997,8 @@ void PrintInternalAllocatorStats() {
instance.PrintStats();
}
-void asan_free(void *ptr, BufferedStackTrace *stack, AllocType alloc_type) {
- instance.Deallocate(ptr, 0, 0, stack, alloc_type);
-}
-
-void asan_delete(void *ptr, uptr size, uptr alignment,
- BufferedStackTrace *stack, AllocType alloc_type) {
- instance.Deallocate(ptr, size, alignment, stack, alloc_type);
+void asan_free(void *ptr, BufferedStackTrace *stack) {
+ instance.Deallocate(ptr, 0, 0, stack, FROM_MALLOC);
}
void *asan_malloc(uptr size, BufferedStackTrace *stack) {
@@ -1058,8 +1053,7 @@ void *asan_pvalloc(uptr size, BufferedStackTrace *stack) {
instance.Allocate(size, PageSize, stack, FROM_MALLOC, true));
}
-void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack,
- AllocType alloc_type) {
+void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack) {
if (UNLIKELY(!IsPowerOfTwo(alignment))) {
errno = errno_EINVAL;
if (AllocatorMayReturnNull())
@@ -1067,7 +1061,7 @@ void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack,
ReportInvalidAllocationAlignment(alignment, stack);
}
return SetErrnoOnNull(
- instance.Allocate(size, alignment, stack, alloc_type, true));
+ instance.Allocate(size, alignment, stack, FROM_MALLOC, true));
}
void *asan_aligned_alloc(uptr alignment, uptr size, BufferedStackTrace *stack) {
@@ -1107,6 +1101,99 @@ uptr asan_malloc_usable_size(const void *ptr, uptr pc, uptr bp) {
return usable_size;
}
+namespace {
+
+void *asan_new(uptr size, BufferedStackTrace *stack, bool array) {
+ return SetErrnoOnNull(
+ instance.Allocate(size, 0, stack, array ? FROM_NEW_BR : FROM_NEW, true));
+}
+
+void *asan_new_aligned(uptr size, uptr alignment, BufferedStackTrace *stack,
+ bool array) {
+ if (UNLIKELY(alignment == 0 || !IsPowerOfTwo(alignment))) {
+ errno = errno_EINVAL;
+ if (AllocatorMayReturnNull())
+ return nullptr;
+ ReportInvalidAllocationAlignment(alignment, stack);
+ }
+ return SetErrnoOnNull(instance.Allocate(
+ size, alignment, stack, array ? FROM_NEW_BR : FROM_NEW, true));
+}
+
+void asan_delete(void *ptr, BufferedStackTrace *stack, bool array) {
+ instance.Deallocate(ptr, 0, 0, stack, array ? FROM_NEW_BR : FROM_NEW);
+}
+
+void asan_delete_aligned(void *ptr, uptr alignment, BufferedStackTrace *stack,
+ bool array) {
+ instance.Deallocate(ptr, 0, alignment, stack, array ? FROM_NEW_BR : FROM_NEW);
+}
+
+void asan_delete_sized(void *ptr, uptr size, BufferedStackTrace *stack,
+ bool array) {
+ instance.Deallocate(ptr, size, 0, stack, array ? FROM_NEW_BR : FROM_NEW);
+}
+
+void asan_delete_sized_aligned(void *ptr, uptr size, uptr alignment,
+ BufferedStackTrace *stack, bool array) {
+ instance.Deallocate(ptr, size, alignment, stack,
+ array ? FROM_NEW_BR : FROM_NEW);
+}
+
+} // namespace
+
+void *asan_new(uptr size, BufferedStackTrace *stack) {
+ return asan_new(size, stack, /*array=*/false);
+}
+
+void *asan_new_aligned(uptr size, uptr alignment, BufferedStackTrace *stack) {
+ return asan_new_aligned(size, alignment, stack, /*array=*/false);
+}
+
+void *asan_new_array(uptr size, BufferedStackTrace *stack) {
+ return asan_new(size, stack, /*array=*/true);
+}
+
+void *asan_new_array_aligned(uptr size, uptr alignment,
+ BufferedStackTrace *stack) {
+ return asan_new_aligned(size, alignment, stack, /*array=*/true);
+}
+
+void asan_delete(void *ptr, BufferedStackTrace *stack) {
+ asan_delete(ptr, stack, /*array=*/false);
+}
+
+void asan_delete_aligned(void *ptr, uptr alignment, BufferedStackTrace *stack) {
+ asan_delete_aligned(ptr, alignment, stack, /*array=*/false);
+}
+
+void asan_delete_sized(void *ptr, uptr size, BufferedStackTrace *stack) {
+ asan_delete_sized(ptr, size, stack, /*array=*/false);
+}
+
+void asan_delete_sized_aligned(void *ptr, uptr size, uptr alignment,
+ BufferedStackTrace *stack) {
+ asan_delete_sized_aligned(ptr, size, alignment, stack, /*array=*/false);
+}
+
+void asan_delete_array(void *ptr, BufferedStackTrace *stack) {
+ asan_delete(ptr, stack, /*array=*/true);
+}
+
+void asan_delete_array_aligned(void *ptr, uptr alignment,
+ BufferedStackTrace *stack) {
+ asan_delete_aligned(ptr, alignment, stack, /*array=*/true);
+}
+
+void asan_delete_array_sized(void *ptr, uptr size, BufferedStackTrace *stack) {
+ asan_delete_sized(ptr, size, stack, /*array=*/true);
+}
+
+void asan_delete_array_sized_aligned(void *ptr, uptr size, uptr alignment,
+ BufferedStackTrace *stack) {
+ asan_delete_sized_aligned(ptr, size, alignment, stack, /*array=*/true);
+}
+
uptr asan_mz_size(const void *ptr) {
return instance.AllocationSize(reinterpret_cast<uptr>(ptr));
}
diff --git a/compiler-rt/lib/asan/asan_allocator.h b/compiler-rt/lib/asan/asan_allocator.h
index db8dc3bebfc62..1ec56f23663f2 100644
--- a/compiler-rt/lib/asan/asan_allocator.h
+++ b/compiler-rt/lib/asan/asan_allocator.h
@@ -269,11 +269,8 @@ struct AsanThreadLocalMallocStorage {
AsanThreadLocalMallocStorage() {}
};
-void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack,
- AllocType alloc_type);
-void asan_free(void *ptr, BufferedStackTrace *stack, AllocType alloc_type);
-void asan_delete(void *ptr, uptr size, uptr alignment,
- BufferedStackTrace *stack, AllocType alloc_type);
+void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack);
+void asan_free(void *ptr, BufferedStackTrace *stack);
void *asan_malloc(uptr size, BufferedStackTrace *stack);
void *asan_calloc(uptr nmemb, uptr size, BufferedStackTrace *stack);
@@ -288,6 +285,23 @@ int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
BufferedStackTrace *stack);
uptr asan_malloc_usable_size(const void *ptr, uptr pc, uptr bp);
+void *asan_new(uptr size, BufferedStackTrace *stack);
+void *asan_new_aligned(uptr size, uptr alignment, BufferedStackTrace *stack);
+void *asan_new_array(uptr size, BufferedStackTrace *stack);
+void *asan_new_array_aligned(uptr size, uptr alignment,
+ BufferedStackTrace *stack);
+void asan_delete(void *ptr, BufferedStackTrace *stack);
+void asan_delete_aligned(void *ptr, uptr alignment, BufferedStackTrace *stack);
+void asan_delete_sized(void *ptr, uptr size, BufferedStackTrace *stack);
+void asan_delete_sized_aligned(void *ptr, uptr size, uptr alignment,
+ BufferedStackTrace *stack);
+void asan_delete_array(void *ptr, BufferedStackTrace *stack);
+void asan_delete_array_aligned(void *ptr, uptr alignment,
+ BufferedStackTrace *stack);
+void asan_delete_array_sized(void *ptr, uptr size, BufferedStackTrace *stack);
+void asan_delete_array_sized_aligned(void *ptr, uptr size, uptr alignment,
+ BufferedStackTrace *stack);
+
uptr asan_mz_size(const void *ptr);
void asan_mz_force_lock();
void asan_mz_force_unlock();
diff --git a/compiler-rt/lib/asan/asan_mac.cpp b/compiler-rt/lib/asan/asan_mac.cpp
index be513a03ed5cd..4bc2c88e7d88a 100644
--- a/compiler-rt/lib/asan/asan_mac.cpp
+++ b/compiler-rt/lib/asan/asan_mac.cpp
@@ -176,7 +176,7 @@ void asan_dispatch_call_block_and_release(void *block) {
asan_register_worker_thread(context->parent_tid, &stack);
// Call the original dispatcher for the block.
context->func(context->block);
- asan_free(context, &stack, FROM_MALLOC);
+ asan_free(context, &stack);
}
} // namespace __asan
diff --git a/compiler-rt/lib/asan/asan_malloc_linux.cpp b/compiler-rt/lib/asan/asan_malloc_linux.cpp
index 3f023d4c2ed0a..add57318785be 100644
--- a/compiler-rt/lib/asan/asan_malloc_linux.cpp
+++ b/compiler-rt/lib/asan/asan_malloc_linux.cpp
@@ -49,7 +49,7 @@ INTERCEPTOR(void, free, void *ptr) {
if (DlsymAlloc::PointerIsMine(ptr))
return DlsymAlloc::Free(ptr);
GET_STACK_TRACE_FREE;
- asan_free(ptr, &stack, FROM_MALLOC);
+ asan_free(ptr, &stack);
}
#if SANITIZER_INTERCEPT_CFREE
@@ -57,7 +57,7 @@ INTERCEPTOR(void, cfree, void *ptr) {
if (DlsymAlloc::PointerIsMine(ptr))
return DlsymAlloc::Free(ptr);
GET_STACK_TRACE_FREE;
- asan_free(ptr, &stack, FROM_MALLOC);
+ asan_free(ptr, &stack);
}
#endif // SANITIZER_INTERCEPT_CFREE
@@ -93,12 +93,12 @@ INTERCEPTOR(void*, reallocarray, void *ptr, uptr nmemb, uptr size) {
#if SANITIZER_INTERCEPT_MEMALIGN
INTERCEPTOR(void*, memalign, uptr boundary, uptr size) {
GET_STACK_TRACE_MALLOC;
- return asan_memalign(boundary, size, &stack, FROM_MALLOC);
+ return asan_memalign(boundary, size, &stack);
}
INTERCEPTOR(void*, __libc_memalign, uptr boundary, uptr size) {
GET_STACK_TRACE_MALLOC;
- return asan_memalign(boundary, size, &stack, FROM_MALLOC);
+ return asan_memalign(boundary, size, &stack);
}
#endif // SANITIZER_INTERCEPT_MEMALIGN
diff --git a/compiler-rt/lib/asan/asan_malloc_mac.cpp b/compiler-rt/lib/asan/asan_malloc_mac.cpp
index f25d7e1901536..a442bdbbaa4d3 100644
--- a/compiler-rt/lib/asan/asan_malloc_mac.cpp
+++ b/compiler-rt/lib/asan/asan_malloc_mac.cpp
@@ -31,7 +31,7 @@ using namespace __asan;
# define COMMON_MALLOC_FORCE_UNLOCK() asan_mz_force_unlock()
# define COMMON_MALLOC_MEMALIGN(alignment, size) \
GET_STACK_TRACE_MALLOC; \
- void *p = asan_memalign(alignment, size, &stack, FROM_MALLOC)
+ void *p = asan_memalign(alignment, size, &stack)
# define COMMON_MALLOC_MALLOC(size) \
GET_STACK_TRACE_MALLOC; \
void *p = asan_malloc(size, &stack)
@@ -46,10 +46,10 @@ using namespace __asan;
int res = asan_posix_memalign(memptr, alignment, size, &stack);
# define COMMON_MALLOC_VALLOC(size) \
GET_STACK_TRACE_MALLOC; \
- void *p = asan_memalign(GetPageSizeCached(), size, &stack, FROM_MALLOC);
+ void *p = asan_memalign(GetPageSizeCached(), size, &stack);
# define COMMON_MALLOC_FREE(ptr) \
GET_STACK_TRACE_FREE; \
- asan_free(ptr, &stack, FROM_MALLOC);
+ asan_free(ptr, &stack);
# define COMMON_MALLOC_SIZE(ptr) uptr size = asan_mz_size(ptr);
# define COMMON_MALLOC_FILL_STATS(zone, stats) \
AsanMallocStats malloc_stats; \
diff --git a/compiler-rt/lib/asan/asan_malloc_win.cpp b/compiler-rt/lib/asan/asan_malloc_win.cpp
index 3278f07219876..8d98da940800f 100644
--- a/compiler-rt/lib/asan/asan_malloc_win.cpp
+++ b/compiler-rt/lib/asan/asan_malloc_win.cpp
@@ -69,7 +69,7 @@ __declspec(noinline) size_t _msize_base(void *ptr) { return _msize(ptr); }
__declspec(noinline) void free(void *ptr) {
GET_STACK_TRACE_FREE;
- return asan_free(ptr, &stack, FROM_MALLOC);
+ return asan_free(ptr, &stack);
}
__declspec(noinline) void _free_dbg(void *ptr, int) { free(ptr); }
@@ -252,7 +252,7 @@ INTERCEPTOR_WINAPI(BOOL, HeapFree, HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) {
CHECK((HEAP_FREE_UNSUPPORTED_FLAGS & dwFlags) != 0 && "unsupported flags");
}
GET_STACK_TRACE_FREE;
- asan_free(lpMem, &stack, FROM_MALLOC);
+ asan_free(lpMem, &stack);
return true;
}
@@ -306,7 +306,7 @@ void *SharedReAlloc(ReAllocFunction reallocFunc, SizeFunction heapSizeFunc,
if (replacement_alloc) {
size_t old_size = heapSizeFunc(hHeap, dwFlags, lpMem);
if (old_size == ((size_t)0) - 1) {
- asan_free(replacement_alloc, &stack, FROM_MALLOC);
+ asan_free(replacement_alloc, &stack);
return nullptr;
}
REAL(memcpy)(replacement_alloc, lpMem, old_size);
@@ -331,7 +331,7 @@ void *SharedReAlloc(ReAllocFunction reallocFunc, SizeFunction heapSizeFunc,
old_usable_size = asan_malloc_usable_size(lpMem, pc, bp);
REAL(memcpy)(replacement_alloc, lpMem,
Min<size_t>(dwBytes, old_usable_size));
- asan_free(lpMem, &stack, FROM_MALLOC);
+ asan_free(lpMem, &stack);
}
return replacement_alloc;
}
@@ -429,7 +429,7 @@ INTERCEPTOR_WINAPI(BOOL, RtlFreeHeap, HANDLE HeapHandle, DWORD Flags,
return REAL(RtlFreeHeap)(HeapHandle, Flags, BaseAddress);
}
GET_STACK_TRACE_FREE;
- asan_free(BaseAddress, &stack, FROM_MALLOC);
+ asan_free(BaseAddress, &stack);
return true;
}
diff --git a/compiler-rt/lib/asan/asan_new_delete.cpp b/compiler-rt/lib/asan/asan_new_delete.cpp
index 99c7c9938dfb3..4b1e497d49050 100644
--- a/compiler-rt/lib/asan/asan_new_delete.cpp
+++ b/compiler-rt/lib/asan/asan_new_delete.cpp
@@ -60,42 +60,42 @@ enum class align_val_t: size_t {};
// TODO(alekseyshl): throw std::bad_alloc instead of dying on OOM.
// For local pool allocation, align to SHADOW_GRANULARITY to match asan
// allocator behavior.
-#define OPERATOR_NEW_BODY \
- GET_STACK_TRACE_MALLOC; \
- void *res = asan_memalign(0, size, &stack, FROM_NEW); \
- if (UNLIKELY(!res)) \
- ReportOutOfMemory(size, &stack); \
+#define OPERATOR_NEW_BODY \
+ GET_STACK_TRACE_MALLOC; \
+ void *res = asan_new(size, &stack); \
+ if (UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
return res
#define OPERATOR_NEW_BODY_NOTHROW \
GET_STACK_TRACE_MALLOC; \
- return asan_memalign(0, size, &stack, FROM_NEW)
-#define OPERATOR_NEW_BODY_ARRAY \
- GET_STACK_TRACE_MALLOC; \
- void *res = asan_memalign(0, size, &stack, FROM_NEW_BR); \
- if (UNLIKELY(!res)) \
- ReportOutOfMemory(size, &stack); \
+ return asan_new(size, &stack)
+#define OPERATOR_NEW_BODY_ARRAY \
+ GET_STACK_TRACE_MALLOC; \
+ void *res = asan_new_array(size, &stack); \
+ if (UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
return res
#define OPERATOR_NEW_BODY_ARRAY_NOTHROW \
GET_STACK_TRACE_MALLOC; \
- return asan_memalign(0, size, &stack, FROM_NEW_BR)
-#define OPERATOR_NEW_BODY_ALIGN \
- GET_STACK_TRACE_MALLOC; \
- void *res = asan_memalign((uptr)align, size, &stack, FROM_NEW); \
- if (UNLIKELY(!res)) \
- ReportOutOfMemory(size, &stack); \
+ return asan_new_array(size, &stack)
+#define OPERATOR_NEW_BODY_ALIGN \
+ GET_STACK_TRACE_MALLOC; \
+ void *res = asan_new_aligned((uptr)align, size, &stack); \
+ if (UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
return res
#define OPERATOR_NEW_BODY_ALIGN_NOTHROW \
GET_STACK_TRACE_MALLOC; \
- return asan_memalign((uptr)align, size, &stack, FROM_NEW)
-#define OPERATOR_NEW_BODY_ALIGN_ARRAY \
- GET_STACK_TRACE_MALLOC; \
- void *res = asan_memalign((uptr)align, size, &stack, FROM_NEW_BR); \
- if (UNLIKELY(!res)) \
- ReportOutOfMemory(size, &stack); \
+ return asan_new_aligned((uptr)align, size, &stack)
+#define OPERATOR_NEW_BODY_ALIGN_ARRAY \
+ GET_STACK_TRACE_MALLOC; \
+ void *res = asan_new_array_aligned((uptr)align, size, &stack); \
+ if (UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
return res
#define OPERATOR_NEW_BODY_ALIGN_ARRAY_NOTHROW \
GET_STACK_TRACE_MALLOC; \
- return asan_memalign((uptr)align, size, &stack, FROM_NEW_BR)
+ return asan_new_array_aligned((uptr)align, size, &stack)
// On OS X it's not enough to just provide our own 'operator new' and
// 'operator delete' implementations, because they're going to be in the
@@ -149,28 +149,28 @@ INTERCEPTOR(void *, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&) {
#define OPERATOR_DELETE_BODY \
GET_STACK_TRACE_FREE; \
- asan_delete(ptr, 0, 0, &stack, FROM_NEW)
+ asan_delete(ptr, &stack)
#define OPERATOR_DELETE_BODY_ARRAY \
GET_STACK_TRACE_FREE; \
- asan_delete(ptr, 0, 0, &stack, FROM_NEW_BR)
+ asan_delete_array(ptr, &stack)
#define OPERATOR_DELETE_BODY_ALIGN \
GET_STACK_TRACE_FREE; \
- asan_delete(ptr, 0, static_cast<uptr>(align), &stack, FROM_NEW)
+ asan_delete_aligned(ptr, static_cast<uptr>(align), &stack)
#define OPERATOR_DELETE_BODY_ALIGN_ARRAY \
GET_STACK_TRACE_FREE; \
- asan_delete(ptr, 0, static_cast<uptr>(align), &stack, FROM_NEW_BR)
+ asan_delete_array_aligned(ptr, static_cast<uptr>(align), &stack)
#define OPERATOR_DELETE_BODY_SIZE \
GET_STACK_TRACE_FREE; \
- asan_delete(ptr, size, 0, &stack, FROM_NEW)
+ asan_delete_sized(ptr, size, &stack)
#define OPERATOR_DELETE_BODY_SIZE_ARRAY \
GET_STACK_TRACE_FREE; \
- asan_delete(ptr, size, 0, &stack, FROM_NEW_BR)
+ asan_delete_array_sized(ptr, size, &stack)
#define OPERATOR_DELETE_BODY_SIZE_ALIGN \
GET_STACK_TRACE_FREE; \
- asan_delete(ptr, size, static_cast<uptr>(align), &stack, FROM_NEW)
+ asan_delete_sized_aligned(ptr, size, static_cast<uptr>(align), &stack)
#define OPERATOR_DELETE_BODY_SIZE_ALIGN_ARRAY \
GET_STACK_TRACE_FREE; \
- asan_delete(ptr, size, static_cast<uptr>(align), &stack, FROM_NEW_BR)
+ asan_delete_array_sized_aligned(ptr, size, static_cast<uptr>(align), &stack)
#if !SANITIZER_APPLE
CXX_OPERATOR_ATTRIBUTE
diff --git a/compiler-rt/lib/asan/tests/asan_noinst_test.cpp b/compiler-rt/lib/asan/tests/asan_noinst_test.cpp
index f485404758b54..401219ac3628c 100644
--- a/compiler-rt/lib/asan/tests/asan_noinst_test.cpp
+++ b/compiler-rt/lib/asan/tests/asan_noinst_test.cpp
@@ -71,7 +71,7 @@ static void *MallocStress(void *NumOfItrPtr) {
void *ptr = vec[idx];
vec[idx] = vec.back();
vec.pop_back();
- __asan::asan_free(ptr, &stack1, __asan::FROM_MALLOC);
+ __asan::asan_free(ptr, &stack1);
} else {
size_t size = my_rand_r(&seed) % 1000 + 1;
switch ((my_rand_r(&seed) % 128)) {
@@ -80,8 +80,7 @@ static void *MallocStress(void *NumOfItrPtr) {
case 2: size += 4096; break;
}
size_t alignment = 1 << (my_rand_r(&seed) % 10 + 1);
- char *ptr = (char *)__asan::asan_memalign(alignment, size, &stack2,
- __asan::FROM_MALLOC);
+ char *ptr = (char *)__asan::asan_memalign(alignment, size, &stack2);
EXPECT_EQ(size, __asan::asan_malloc_usable_size(ptr, 0, 0));
vec.push_back(ptr);
ptr[0] = 0;
@@ -89,8 +88,7 @@ static void *MallocStress(void *NumOfItrPtr) {
ptr[size/2] = 0;
}
}
- for (size_t i = 0; i < vec.size(); i++)
- __asan::asan_free(vec[i], &stack3, __asan::FROM_MALLOC);
+ for (size_t i = 0; i < vec.size(); i++) __asan::asan_free(vec[i], &stack3);
return nullptr;
}
@@ -143,12 +141,12 @@ TEST(AddressSanitizer, QuarantineTest) {
const int size = 1024;
void *p = __asan::asan_malloc(size, &stack);
- __asan::asan_free(p, &stack, __asan::FROM_MALLOC);
+ __asan::asan_free(p, &stack);
size_t i;
size_t max_i = 1 << 30;
for (i = 0; i < max_i; i++) {
void *p1 = __asan::asan_malloc(size, &stack);
- __asan::asan_free(p1, &stack, __asan::FROM_MALLOC);
+ __asan::asan_free(p1, &stack);
if (p1 == p) break;
}
EXPECT_GE(i, 10000U);
@@ -165,7 +163,7 @@ void *ThreadedQuarantineTestWorker(void *unused) {
for (size_t i = 0; i < 1000; i++) {
void *p = __asan::asan_malloc(1 + (my_rand_r(&seed) % 4000), &stack);
- __asan::asan_free(p, &stack, __asan::FROM_MALLOC);
+ __asan::asan_free(p, &stack);
}
return NULL;
}
@@ -204,7 +202,7 @@ void *ThreadedOneSizeMallocStress(void *unused) {
p[i] = __asan::asan_malloc(32, &stack);
}
for (size_t i = 0; i < kNumMallocs; i++) {
- __asan::asan_free(p[i], &stack, __asan::FROM_MALLOC);
+ __asan::asan_free(p[i], &stack);
}
}
return NULL;
@@ -260,7 +258,7 @@ static void TestLoadStoreCallbacks(CB cb[2][5]) {
}
}
}
- __asan::asan_free(ptr, &stack, __asan::FROM_MALLOC);
+ __asan::asan_free(ptr, &stack);
}
__asan_test_only_reported_buggy_pointer = 0;
}
More information about the llvm-commits
mailing list