github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code.
:warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff origin/main HEAD --extensions c,cpp,h --
clang/test/Driver/fsanitize-doublefree.c
compiler-rt/include/sanitizer/dsan_interface.h compiler-rt/lib/dsan/dsan.cpp
compiler-rt/lib/dsan/dsan.h compiler-rt/lib/dsan/dsan_allocator.cpp
compiler-rt/lib/dsan/dsan_allocator.h compiler-rt/lib/dsan/dsan_common.cpp
compiler-rt/lib/dsan/dsan_common.h compiler-rt/lib/dsan/dsan_fuchsia.cpp
compiler-rt/lib/dsan/dsan_fuchsia.h compiler-rt/lib/dsan/dsan_interceptors.cpp
compiler-rt/lib/dsan/dsan_linux.cpp compiler-rt/lib/dsan/dsan_mac.cpp
compiler-rt/lib/dsan/dsan_malloc_mac.cpp compiler-rt/lib/dsan/dsan_posix.cpp
compiler-rt/lib/dsan/dsan_posix.h compiler-rt/lib/dsan/dsan_preinit.cpp
compiler-rt/lib/dsan/dsan_thread.cpp compiler-rt/lib/dsan/dsan_thread.h
compiler-rt/test/dsan/TestCases/concurrent-double-free.cpp
compiler-rt/test/dsan/TestCases/double-free.c
compiler-rt/test/dsan/TestCases/invalid-free.c
compiler-rt/test/dsan/TestCases/large-double-free.c
compiler-rt/test/dsan/TestCases/realloc.c
compiler-rt/test/dsan/TestCases/reallocarray.c
compiler-rt/test/dsan/TestCases/smoke.cpp
clang/include/clang/Driver/SanitizerArgs.h clang/lib/Driver/SanitizerArgs.cpp
clang/lib/Driver/ToolChains/CommonArgs.cpp
clang/lib/Driver/ToolChains/Darwin.cpp clang/lib/Driver/ToolChains/Fuchsia.cpp
clang/lib/Driver/ToolChains/Linux.cpp clang/lib/Driver/ToolChains/NetBSD.cpp
--diff_from_common_commit
``````````
:warning:
The reproduction instructions above might return results for more than one PR
in a stack if you are using a stacked PR workflow. You can limit the results by
changing `origin/main` to the base branch/commit you want to compare against.
:warning:
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/clang/lib/Driver/SanitizerArgs.cpp
b/clang/lib/Driver/SanitizerArgs.cpp
index e24d6c179..c1c113d91 100644
--- a/clang/lib/Driver/SanitizerArgs.cpp
+++ b/clang/lib/Driver/SanitizerArgs.cpp
@@ -48,8 +48,8 @@ static const SanitizerMask SupportsCoverage =
SanitizerKind::Type | SanitizerKind::MemtagStack |
SanitizerKind::MemtagHeap | SanitizerKind::MemtagGlobals |
SanitizerKind::Memory | SanitizerKind::KernelMemory | SanitizerKind::Leak |
- SanitizerKind::DoubleFree |
- SanitizerKind::Undefined | SanitizerKind::Integer | SanitizerKind::Bounds |
+ SanitizerKind::DoubleFree | SanitizerKind::Undefined |
+ SanitizerKind::Integer | SanitizerKind::Bounds |
SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
SanitizerKind::DataFlow | SanitizerKind::Fuzzer |
SanitizerKind::FuzzerNoLink | SanitizerKind::FloatDivideByZero |
@@ -711,8 +711,8 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
std::make_pair(SanitizerKind::Leak,
SanitizerKind::Thread | SanitizerKind::Memory),
std::make_pair(SanitizerKind::DoubleFree,
- SanitizerKind::Leak | SanitizerKind::Thread |
- SanitizerKind::Memory | SanitizerKind::Scudo),
+ SanitizerKind::Leak | SanitizerKind::Thread |
+ SanitizerKind::Memory | SanitizerKind::Scudo),
std::make_pair(SanitizerKind::KernelAddress,
SanitizerKind::Address | SanitizerKind::Leak |
SanitizerKind::Thread | SanitizerKind::Memory),
diff --git a/compiler-rt/lib/dsan/dsan.cpp b/compiler-rt/lib/dsan/dsan.cpp
index 524604220..6c134122b 100644
--- a/compiler-rt/lib/dsan/dsan.cpp
+++ b/compiler-rt/lib/dsan/dsan.cpp
@@ -26,17 +26,17 @@ bool dsan_init_is_running;
namespace __dsan {
///// Interface to the common DSan module. /////
-bool WordIsPoisoned(uptr addr) {
- return false;
-}
+bool WordIsPoisoned(uptr addr) { return false; }
} // namespace __dsan
-void __sanitizer::BufferedStackTrace::UnwindImpl(
- uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
+void __sanitizer::BufferedStackTrace::UnwindImpl(uptr pc, uptr bp,
+ void* context,
+ bool request_fast,
+ u32 max_depth) {
using namespace __dsan;
uptr stack_top = 0, stack_bottom = 0;
- if (ThreadContextDsanBase *t = GetCurrentThread()) {
+ if (ThreadContextDsanBase* t = GetCurrentThread()) {
stack_top = t->stack_end();
stack_bottom = t->stack_begin();
}
@@ -66,15 +66,17 @@ static void InitializeFlags() {
RegisterCommonFlags(&parser);
// Override from user-specified string.
- const char *dsan_default_options = __dsan_default_options();
+ const char* dsan_default_options = __dsan_default_options();
parser.ParseString(dsan_default_options);
parser.ParseStringFromEnv("DSAN_OPTIONS");
InitializeCommonFlags();
- if (Verbosity()) ReportUnrecognizedFlags();
+ if (Verbosity())
+ ReportUnrecognizedFlags();
- if (common_flags()->help) parser.PrintFlagDescriptions();
+ if (common_flags()->help)
+ parser.PrintFlagDescriptions();
__sanitizer_set_report_path(common_flags()->log_path);
}
@@ -104,8 +106,7 @@ extern "C" void __dsan_init() {
dsan_init_is_running = false;
}
-extern "C" SANITIZER_INTERFACE_ATTRIBUTE
-void __sanitizer_print_stack_trace() {
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_print_stack_trace() {
GET_STACK_TRACE_FATAL;
stack.Print();
}
diff --git a/compiler-rt/lib/dsan/dsan.h b/compiler-rt/lib/dsan/dsan.h
index a5e06e23c..bd7d1eb9c 100644
--- a/compiler-rt/lib/dsan/dsan.h
+++ b/compiler-rt/lib/dsan/dsan.h
@@ -38,7 +38,7 @@ namespace __dsan {
void InitializeInterceptors();
void ReplaceSystemMalloc();
-void DsanOnDeadlySignal(int signo, void *siginfo, void *context);
+void DsanOnDeadlySignal(int signo, void* siginfo, void* context);
void InstallAtForkHandler();
#define ENSURE_DSAN_INITED \
diff --git a/compiler-rt/lib/dsan/dsan_allocator.cpp
b/compiler-rt/lib/dsan/dsan_allocator.cpp
index 8664b97bb..471fb1841 100644
--- a/compiler-rt/lib/dsan/dsan_allocator.cpp
+++ b/compiler-rt/lib/dsan/dsan_allocator.cpp
@@ -24,7 +24,7 @@
#include "sanitizer_common/sanitizer_stackdepot.h"
#include "sanitizer_common/sanitizer_stacktrace.h"
-extern "C" void *memset(void *ptr, int value, uptr num);
+extern "C" void* memset(void* ptr, int value, uptr num);
namespace __dsan {
#if defined(__i386__) || defined(__arm__)
@@ -40,7 +40,7 @@ static Allocator allocator;
static uptr max_malloc_size;
struct SecondaryTombstone {
- void *ptr;
+ void* ptr;
u32 alloc_stack_id;
u32 free_stack_id;
};
@@ -52,10 +52,10 @@ static uptr next_secondary_tombstone;
static constexpr uptr kPrimaryQuarantineSize = 1024;
static Mutex primary_quarantine_mutex;
-static InternalMmapVector<void *> primary_quarantine;
+static InternalMmapVector<void*> primary_quarantine;
static uptr next_primary_quarantine;
-static bool FindSecondaryTombstone(void *p, SecondaryTombstone *result) {
+static bool FindSecondaryTombstone(void* p, SecondaryTombstone* result) {
Lock lock(&secondary_tombstones_mutex);
for (uptr i = 0; i != secondary_tombstones.size(); ++i) {
if (secondary_tombstones[i].ptr == p) {
@@ -66,10 +66,9 @@ static bool FindSecondaryTombstone(void *p,
SecondaryTombstone *result) {
return false;
}
-static void AddSecondaryTombstone(void *p, const ChunkMetadata *m) {
+static void AddSecondaryTombstone(void* p, const ChunkMetadata* m) {
Lock lock(&secondary_tombstones_mutex);
- const SecondaryTombstone tombstone = {p, m->alloc_stack_id,
- m->free_stack_id};
+ const SecondaryTombstone tombstone = {p, m->alloc_stack_id,
m->free_stack_id};
if (secondary_tombstones.size() < kSecondaryTombstoneLimit) {
secondary_tombstones.push_back(tombstone);
return;
@@ -79,7 +78,7 @@ static void AddSecondaryTombstone(void *p, const
ChunkMetadata *m) {
(next_secondary_tombstone + 1) % kSecondaryTombstoneLimit;
}
-static void RemoveSecondaryTombstone(void *p) {
+static void RemoveSecondaryTombstone(void* p) {
Lock lock(&secondary_tombstones_mutex);
for (uptr i = 0; i != secondary_tombstones.size(); ++i) {
if (secondary_tombstones[i].ptr != p)
@@ -90,8 +89,8 @@ static void RemoveSecondaryTombstone(void *p) {
}
}
-static void QuarantinePrimary(void *p) {
- void *released = nullptr;
+static void QuarantinePrimary(void* p) {
+ void* released = nullptr;
{
Lock lock(&primary_quarantine_mutex);
if (primary_quarantine.size() < kPrimaryQuarantineSize) {
@@ -125,33 +124,34 @@ void AllocatorThreadFinish() {
allocator.DestroyCache(GetAllocatorCache());
}
-static ChunkMetadata *Metadata(const void *p) {
- return reinterpret_cast<ChunkMetadata *>(allocator.GetMetaData(p));
+static ChunkMetadata* Metadata(const void* p) {
+ return reinterpret_cast<ChunkMetadata*>(allocator.GetMetaData(p));
}
-static void RegisterAllocation(const StackTrace &stack, void *p, uptr size) {
- if (!p) return;
+static void RegisterAllocation(const StackTrace& stack, void* p, uptr size) {
+ if (!p)
+ return;
if (!allocator.FromPrimary(p))
RemoveSecondaryTombstone(p);
- ChunkMetadata *m = Metadata(p);
+ ChunkMetadata* m = Metadata(p);
CHECK(m);
m->alloc_stack_id = StackDepotPut(stack);
m->free_stack_id = 0;
m->requested_size = size;
- atomic_store(reinterpret_cast<atomic_uint8_t *>(m), kChunkAllocated,
+ atomic_store(reinterpret_cast<atomic_uint8_t*>(m), kChunkAllocated,
memory_order_release);
RunMallocHooks(p, size);
}
// Report double-free and terminate.
-static void NORETURN ReportDoubleFree(void *p, u32 alloc_stack_id,
+static void NORETURN ReportDoubleFree(void* p, u32 alloc_stack_id,
u32 first_free_stack_id,
- const StackTrace &free_stack) {
+ const StackTrace& free_stack) {
class Decorator : public __sanitizer::SanitizerCommonDecorator {
public:
Decorator() : SanitizerCommonDecorator() {}
- const char *Error() { return Red(); }
- const char *Info() { return Blue(); }
+ const char* Error() { return Red(); }
+ const char* Info() { return Blue(); }
};
Decorator d;
@@ -190,13 +190,13 @@ static void NORETURN ReportDoubleFree(void *p, u32
alloc_stack_id,
Die();
}
-static void NORETURN ReportInvalidFree(void *p, const StackTrace &stack) {
+static void NORETURN ReportInvalidFree(void* p, const StackTrace& stack) {
Report("ERROR: DoubleFreeSanitizer: invalid free on address %p\n", p);
stack.Print();
Die();
}
-static ChunkMetadata *GetChunkMetadata(void *p, const StackTrace &stack) {
+static ChunkMetadata* GetChunkMetadata(void* p, const StackTrace& stack) {
if (!p)
return nullptr;
if (!allocator.PointerIsMine(p)) {
@@ -208,24 +208,24 @@ static ChunkMetadata *GetChunkMetadata(void *p, const
StackTrace &stack) {
}
if (allocator.GetBlockBegin(p) != p)
ReportInvalidFree(p, stack);
- ChunkMetadata *m = Metadata(p);
- if (atomic_load(reinterpret_cast<atomic_uint8_t *>(m), memory_order_acquire)
==
+ ChunkMetadata* m = Metadata(p);
+ if (atomic_load(reinterpret_cast<atomic_uint8_t*>(m), memory_order_acquire)
==
kChunkInvalid)
ReportInvalidFree(p, stack);
return m;
}
-static void RegisterDeallocation(const StackTrace &stack, void *p) {
- ChunkMetadata *m = GetChunkMetadata(p, stack);
+static void RegisterDeallocation(const StackTrace& stack, void* p) {
+ ChunkMetadata* m = GetChunkMetadata(p, stack);
if (!m)
return;
u8 expected = kChunkAllocated;
- if (!atomic_compare_exchange_strong(reinterpret_cast<atomic_uint8_t *>(m),
+ if (!atomic_compare_exchange_strong(reinterpret_cast<atomic_uint8_t*>(m),
&expected, kChunkFreeing,
memory_order_acquire)) {
while (expected == kChunkFreeing)
- expected = atomic_load(reinterpret_cast<atomic_uint8_t *>(m),
+ expected = atomic_load(reinterpret_cast<atomic_uint8_t*>(m),
memory_order_acquire);
if (expected == kChunkFreed)
ReportDoubleFree(p, m->alloc_stack_id, m->free_stack_id, stack);
@@ -233,12 +233,12 @@ static void RegisterDeallocation(const StackTrace &stack,
void *p) {
}
m->free_stack_id = StackDepotPut(stack);
- atomic_store(reinterpret_cast<atomic_uint8_t *>(m), kChunkFreed,
+ atomic_store(reinterpret_cast<atomic_uint8_t*>(m), kChunkFreed,
memory_order_release);
RunFreeHooks(p);
}
-static void *ReportAllocationSizeTooBig(uptr size, const StackTrace &stack) {
+static void* ReportAllocationSizeTooBig(uptr size, const StackTrace& stack) {
if (AllocatorMayReturnNull()) {
Report("WARNING: DoubleFreeSanitizer failed to allocate 0x%zx bytes\n",
size);
@@ -247,7 +247,7 @@ static void *ReportAllocationSizeTooBig(uptr size, const
StackTrace &stack) {
ReportAllocationSizeTooBig(size, max_malloc_size, &stack);
}
-void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
+void* Allocate(const StackTrace& stack, uptr size, uptr alignment,
bool cleared) {
if (size == 0)
size = 1;
@@ -258,7 +258,7 @@ void *Allocate(const StackTrace &stack, uptr size, uptr
alignment,
return nullptr;
ReportRssLimitExceeded(&stack);
}
- void *p = allocator.Allocate(GetAllocatorCache(), size, alignment);
+ void* p = allocator.Allocate(GetAllocatorCache(), size, alignment);
if (UNLIKELY(!p)) {
SetAllocatorOutOfMemory();
if (AllocatorMayReturnNull())
@@ -271,7 +271,7 @@ void *Allocate(const StackTrace &stack, uptr size, uptr
alignment,
return p;
}
-static void *Calloc(uptr nmemb, uptr size, const StackTrace &stack) {
+static void* Calloc(uptr nmemb, uptr size, const StackTrace& stack) {
if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) {
if (AllocatorMayReturnNull())
return nullptr;
@@ -281,7 +281,7 @@ static void *Calloc(uptr nmemb, uptr size, const StackTrace
&stack) {
return Allocate(stack, size, 1, true);
}
-void Deallocate(const StackTrace &stack, void *p) {
+void Deallocate(const StackTrace& stack, void* p) {
if (!p)
return;
RegisterDeallocation(stack, p);
@@ -293,7 +293,7 @@ void Deallocate(const StackTrace &stack, void *p) {
}
}
-void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
+void* Reallocate(const StackTrace& stack, void* p, uptr new_size,
uptr alignment) {
if (!p)
return Allocate(stack, new_size, alignment, kAlwaysClearMemory);
@@ -305,12 +305,12 @@ void *Reallocate(const StackTrace &stack, void *p, uptr
new_size,
ReportAllocationSizeTooBig(new_size, stack);
return nullptr;
}
- ChunkMetadata *m = GetChunkMetadata(p, stack);
- if (atomic_load(reinterpret_cast<atomic_uint8_t *>(m), memory_order_acquire)
!=
+ ChunkMetadata* m = GetChunkMetadata(p, stack);
+ if (atomic_load(reinterpret_cast<atomic_uint8_t*>(m), memory_order_acquire)
!=
kChunkAllocated)
ReportDoubleFree(p, m->alloc_stack_id, m->free_stack_id, stack);
const uptr old_size = m->requested_size;
- void *new_p = Allocate(stack, new_size, alignment, kAlwaysClearMemory);
+ void* new_p = Allocate(stack, new_size, alignment, kAlwaysClearMemory);
if (!new_p)
return nullptr;
internal_memcpy(new_p, p, Min(old_size, new_size));
@@ -318,48 +318,49 @@ void *Reallocate(const StackTrace &stack, void *p, uptr
new_size,
return new_p;
}
-void GetAllocatorCacheRange(uptr *begin, uptr *end) {
+void GetAllocatorCacheRange(uptr* begin, uptr* end) {
*begin = (uptr)GetAllocatorCache();
*end = *begin + sizeof(AllocatorCache);
}
-static const void *GetMallocBegin(const void *p) {
+static const void* GetMallocBegin(const void* p) {
if (!p)
return nullptr;
- void *beg = allocator.GetBlockBegin(p);
+ void* beg = allocator.GetBlockBegin(p);
if (!beg)
return nullptr;
- ChunkMetadata *m = Metadata(beg);
+ ChunkMetadata* m = Metadata(beg);
if (!m)
return nullptr;
- if (atomic_load(reinterpret_cast<atomic_uint8_t *>(m), memory_order_acquire)
!=
+ if (atomic_load(reinterpret_cast<atomic_uint8_t*>(m), memory_order_acquire)
!=
kChunkAllocated)
return nullptr;
if (m->requested_size == 0)
return nullptr;
- return (const void *)beg;
+ return (const void*)beg;
}
-uptr GetMallocUsableSize(const void *p) {
+uptr GetMallocUsableSize(const void* p) {
if (!p)
return 0;
- ChunkMetadata *m = Metadata(p);
- if (!m) return 0;
+ ChunkMetadata* m = Metadata(p);
+ if (!m)
+ return 0;
return m->requested_size;
}
-uptr GetMallocUsableSizeFast(const void *p) {
+uptr GetMallocUsableSizeFast(const void* p) {
return Metadata(p)->requested_size;
}
-int dsan_posix_memalign(void **memptr, uptr alignment, uptr size,
- const StackTrace &stack) {
+int dsan_posix_memalign(void** memptr, uptr alignment, uptr size,
+ const StackTrace& stack) {
if (UNLIKELY(!CheckPosixMemalignAlignment(alignment))) {
if (AllocatorMayReturnNull())
return errno_EINVAL;
ReportInvalidPosixMemalignAlignment(alignment, &stack);
}
- void *ptr = Allocate(stack, size, alignment, kAlwaysClearMemory);
+ void* ptr = Allocate(stack, size, alignment, kAlwaysClearMemory);
if (UNLIKELY(!ptr))
return errno_ENOMEM;
CHECK(IsAligned((uptr)ptr, alignment));
@@ -367,7 +368,7 @@ int dsan_posix_memalign(void **memptr, uptr alignment, uptr
size,
return 0;
}
-void *dsan_aligned_alloc(uptr alignment, uptr size, const StackTrace &stack) {
+void* dsan_aligned_alloc(uptr alignment, uptr size, const StackTrace& stack) {
if (UNLIKELY(!CheckAlignedAllocAlignmentAndSize(alignment, size))) {
errno = errno_EINVAL;
if (AllocatorMayReturnNull())
@@ -377,7 +378,7 @@ void *dsan_aligned_alloc(uptr alignment, uptr size, const
StackTrace &stack) {
return SetErrnoOnNull(Allocate(stack, size, alignment, kAlwaysClearMemory));
}
-void *dsan_memalign(uptr alignment, uptr size, const StackTrace &stack) {
+void* dsan_memalign(uptr alignment, uptr size, const StackTrace& stack) {
if (UNLIKELY(!IsPowerOfTwo(alignment))) {
errno = errno_EINVAL;
if (AllocatorMayReturnNull())
@@ -387,28 +388,26 @@ void *dsan_memalign(uptr alignment, uptr size, const
StackTrace &stack) {
return SetErrnoOnNull(Allocate(stack, size, alignment, kAlwaysClearMemory));
}
-void *dsan_malloc(uptr size, const StackTrace &stack) {
+void* dsan_malloc(uptr size, const StackTrace& stack) {
return SetErrnoOnNull(Allocate(stack, size, 1, kAlwaysClearMemory));
}
-void dsan_free(void *p, const StackTrace &stack) {
- Deallocate(stack, p);
-}
+void dsan_free(void* p, const StackTrace& stack) { Deallocate(stack, p); }
-void dsan_free_sized(void *p, uptr, const StackTrace &stack) {
+void dsan_free_sized(void* p, uptr, const StackTrace& stack) {
Deallocate(stack, p);
}
-void dsan_free_aligned_sized(void *p, uptr, uptr, const StackTrace &stack) {
+void dsan_free_aligned_sized(void* p, uptr, uptr, const StackTrace& stack) {
Deallocate(stack, p);
}
-void *dsan_realloc(void *p, uptr size, const StackTrace &stack) {
+void* dsan_realloc(void* p, uptr size, const StackTrace& stack) {
return SetErrnoOnNull(Reallocate(stack, p, size, 1));
}
-void *dsan_reallocarray(void *ptr, uptr nmemb, uptr size,
- const StackTrace &stack) {
+void* dsan_reallocarray(void* ptr, uptr nmemb, uptr size,
+ const StackTrace& stack) {
if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) {
errno = errno_ENOMEM;
if (AllocatorMayReturnNull())
@@ -418,16 +417,16 @@ void *dsan_reallocarray(void *ptr, uptr nmemb, uptr size,
return dsan_realloc(ptr, nmemb * size, stack);
}
-void *dsan_calloc(uptr nmemb, uptr size, const StackTrace &stack) {
+void* dsan_calloc(uptr nmemb, uptr size, const StackTrace& stack) {
return SetErrnoOnNull(Calloc(nmemb, size, stack));
}
-void *dsan_valloc(uptr size, const StackTrace &stack) {
+void* dsan_valloc(uptr size, const StackTrace& stack) {
return SetErrnoOnNull(
Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory));
}
-void *dsan_pvalloc(uptr size, const StackTrace &stack) {
+void* dsan_pvalloc(uptr size, const StackTrace& stack) {
uptr PageSize = GetPageSizeCached();
if (UNLIKELY(CheckForPvallocOverflow(size, PageSize))) {
errno = errno_ENOMEM;
@@ -439,19 +438,13 @@ void *dsan_pvalloc(uptr size, const StackTrace &stack) {
return SetErrnoOnNull(Allocate(stack, size, PageSize, kAlwaysClearMemory));
}
-uptr dsan_mz_size(const void *p) {
- return GetMallocUsableSize(p);
-}
+uptr dsan_mz_size(const void* p) { return GetMallocUsableSize(p); }
-void LockAllocator() {
- allocator.ForceLock();
-}
+void LockAllocator() { allocator.ForceLock(); }
-void UnlockAllocator() {
- allocator.ForceUnlock();
-}
+void UnlockAllocator() { allocator.ForceUnlock(); }
-} // namespace __dsan
+} // namespace __dsan
using namespace __dsan;
@@ -480,22 +473,22 @@ SANITIZER_INTERFACE_ATTRIBUTE
uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
SANITIZER_INTERFACE_ATTRIBUTE
-int __sanitizer_get_ownership(const void *p) {
+int __sanitizer_get_ownership(const void* p) {
return GetMallocBegin(p) != nullptr;
}
SANITIZER_INTERFACE_ATTRIBUTE
-const void * __sanitizer_get_allocated_begin(const void *p) {
+const void* __sanitizer_get_allocated_begin(const void* p) {
return GetMallocBegin(p);
}
SANITIZER_INTERFACE_ATTRIBUTE
-uptr __sanitizer_get_allocated_size(const void *p) {
+uptr __sanitizer_get_allocated_size(const void* p) {
return GetMallocUsableSize(p);
}
SANITIZER_INTERFACE_ATTRIBUTE
-uptr __sanitizer_get_allocated_size_fast(const void *p) {
+uptr __sanitizer_get_allocated_size_fast(const void* p) {
DCHECK_EQ(p, __sanitizer_get_allocated_begin(p));
uptr ret = GetMallocUsableSizeFast(p);
DCHECK_EQ(ret, __sanitizer_get_allocated_size(p));
@@ -505,4 +498,4 @@ uptr __sanitizer_get_allocated_size_fast(const void *p) {
SANITIZER_INTERFACE_ATTRIBUTE
void __sanitizer_purge_allocator() { allocator.ForceReleaseToOS(); }
-} // extern "C"
+} // extern "C"
diff --git a/compiler-rt/lib/dsan/dsan_allocator.h
b/compiler-rt/lib/dsan/dsan_allocator.h
index 27f5aa74e..31ee1071b 100644
--- a/compiler-rt/lib/dsan/dsan_allocator.h
+++ b/compiler-rt/lib/dsan/dsan_allocator.h
@@ -20,14 +20,14 @@
namespace __dsan {
-void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
+void* Allocate(const StackTrace& stack, uptr size, uptr alignment,
bool cleared);
-void Deallocate(const StackTrace &stack, void *p);
-void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
+void Deallocate(const StackTrace& stack, void* p);
+void* Reallocate(const StackTrace& stack, void* p, uptr new_size,
uptr alignment);
-uptr GetMallocUsableSize(const void *p);
+uptr GetMallocUsableSize(const void* p);
-void GetAllocatorCacheRange(uptr *begin, uptr *end);
+void GetAllocatorCacheRange(uptr* begin, uptr* end);
void AllocatorThreadStart();
void AllocatorThreadFinish();
void InitializeAllocator();
@@ -42,8 +42,8 @@ struct ChunkMetadata {
uptr requested_size : 32;
uptr padding2 : 24;
#endif
- u32 alloc_stack_id; // Stack trace of the allocation
- u32 free_stack_id; // Stack trace of the first free
+ u32 alloc_stack_id; // Stack trace of the allocation
+ u32 free_stack_id; // Stack trace of the first free
};
enum ChunkState : u8 {
@@ -69,7 +69,7 @@ template <typename AddressSpaceView>
using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView>>;
using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
#else
-# if SANITIZER_FUCHSIA || defined(__powerpc64__)
+# if SANITIZER_FUCHSIA || defined(__powerpc64__)
const uptr kAllocatorSpace = ~(uptr)0;
# if SANITIZER_RISCV64
// See the comments in compiler-rt/lib/asan/asan_allocator.h for why these
@@ -85,7 +85,7 @@ static_assert(DSanSizeClassMap::kNumClassesRounded <= 32,
"32 size classes is the optimal number to ensure tests run "
"efficiently on Fuchsia.");
# else
-const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
+const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
using DSanSizeClassMap = DefaultSizeClassMap;
# endif
# elif SANITIZER_RISCV64
@@ -94,7 +94,7 @@ const uptr kAllocatorSize = 0x2000000000ULL; // 128G.
using DSanSizeClassMap = DefaultSizeClassMap;
# elif SANITIZER_APPLE
const uptr kAllocatorSpace = 0x600000000000ULL;
-const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
+const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
using DSanSizeClassMap = DefaultSizeClassMap;
# elif SANITIZER_ANDROID && defined(__aarch64__)
const uptr kAllocatorSpace = 0x3000000000ULL;
@@ -126,24 +126,24 @@ using AllocatorASVT =
CombinedAllocator<PrimaryAllocatorASVT<AddressSpaceView>>;
using Allocator = AllocatorASVT<LocalAddressSpaceView>;
using AllocatorCache = Allocator::AllocatorCache;
-Allocator::AllocatorCache *GetAllocatorCache();
+Allocator::AllocatorCache* GetAllocatorCache();
-int dsan_posix_memalign(void **memptr, uptr alignment, uptr size,
- const StackTrace &stack);
-void *dsan_aligned_alloc(uptr alignment, uptr size, const StackTrace &stack);
-void *dsan_memalign(uptr alignment, uptr size, const StackTrace &stack);
-void *dsan_malloc(uptr size, const StackTrace &stack);
-void dsan_free(void *p, const StackTrace &stack);
-void dsan_free_sized(void *p, uptr size, const StackTrace &stack);
-void dsan_free_aligned_sized(void *p, uptr alignment, uptr size,
- const StackTrace &stack);
-void *dsan_realloc(void *p, uptr size, const StackTrace &stack);
-void *dsan_reallocarray(void *p, uptr nmemb, uptr size,
- const StackTrace &stack);
-void *dsan_calloc(uptr nmemb, uptr size, const StackTrace &stack);
-void *dsan_valloc(uptr size, const StackTrace &stack);
-void *dsan_pvalloc(uptr size, const StackTrace &stack);
-uptr dsan_mz_size(const void *p);
+int dsan_posix_memalign(void** memptr, uptr alignment, uptr size,
+ const StackTrace& stack);
+void* dsan_aligned_alloc(uptr alignment, uptr size, const StackTrace& stack);
+void* dsan_memalign(uptr alignment, uptr size, const StackTrace& stack);
+void* dsan_malloc(uptr size, const StackTrace& stack);
+void dsan_free(void* p, const StackTrace& stack);
+void dsan_free_sized(void* p, uptr size, const StackTrace& stack);
+void dsan_free_aligned_sized(void* p, uptr alignment, uptr size,
+ const StackTrace& stack);
+void* dsan_realloc(void* p, uptr size, const StackTrace& stack);
+void* dsan_reallocarray(void* p, uptr nmemb, uptr size,
+ const StackTrace& stack);
+void* dsan_calloc(uptr nmemb, uptr size, const StackTrace& stack);
+void* dsan_valloc(uptr size, const StackTrace& stack);
+void* dsan_pvalloc(uptr size, const StackTrace& stack);
+uptr dsan_mz_size(const void* p);
} // namespace __dsan
diff --git a/compiler-rt/lib/dsan/dsan_common.cpp
b/compiler-rt/lib/dsan/dsan_common.cpp
index bf5311f18..4a8a45407 100644
--- a/compiler-rt/lib/dsan/dsan_common.cpp
+++ b/compiler-rt/lib/dsan/dsan_common.cpp
@@ -25,7 +25,7 @@ void InitCommonDsan() {
} // namespace __dsan
extern "C" {
-SANITIZER_INTERFACE_WEAK_DEF(const char *, __dsan_default_options, void) {
+SANITIZER_INTERFACE_WEAK_DEF(const char*, __dsan_default_options, void) {
return "";
}
} // extern "C"
diff --git a/compiler-rt/lib/dsan/dsan_common.h
b/compiler-rt/lib/dsan/dsan_common.h
index 6e27e283b..63bf7fa51 100644
--- a/compiler-rt/lib/dsan/dsan_common.h
+++ b/compiler-rt/lib/dsan/dsan_common.h
@@ -26,7 +26,7 @@
#if SANITIZER_ANDROID && (__ANDROID_API__ < 28 || defined(__arm__))
# define CAN_SANITIZE_DOUBLE_FREE 0
#elif (SANITIZER_LINUX || SANITIZER_APPLE) && (SANITIZER_WORDSIZE == 64) && \
- (defined(__x86_64__) || defined(__mips64) || defined(__aarch64__) || \
+ (defined(__x86_64__) || defined(__mips64) || defined(__aarch64__) || \
defined(__powerpc64__) || defined(__s390x__))
# define CAN_SANITIZE_DOUBLE_FREE 1
#elif defined(__i386__) && (SANITIZER_LINUX || SANITIZER_APPLE)
@@ -49,7 +49,7 @@ namespace __sanitizer {
class ThreadRegistry;
class ThreadContextBase;
struct DTLS;
-}
+} // namespace __sanitizer
namespace __dsan {
@@ -64,15 +64,15 @@ void LockThreads() SANITIZER_NO_THREAD_SAFETY_ANALYSIS;
void UnlockThreads() SANITIZER_NO_THREAD_SAFETY_ANALYSIS;
void EnsureMainThreadIDIsCorrect();
-bool GetThreadRangesLocked(ThreadID os_id, uptr *stack_begin, uptr *stack_end,
- uptr *tls_begin, uptr *tls_end, uptr *cache_begin,
- uptr *cache_end, DTLS **dtls);
-void GetAllThreadAllocatorCachesLocked(InternalMmapVector<uptr> *caches);
-void GetThreadExtraStackRangesLocked(InternalMmapVector<Range> *ranges);
+bool GetThreadRangesLocked(ThreadID os_id, uptr* stack_begin, uptr* stack_end,
+ uptr* tls_begin, uptr* tls_end, uptr* cache_begin,
+ uptr* cache_end, DTLS** dtls);
+void GetAllThreadAllocatorCachesLocked(InternalMmapVector<uptr>* caches);
+void GetThreadExtraStackRangesLocked(InternalMmapVector<Range>* ranges);
void GetThreadExtraStackRangesLocked(ThreadID os_id,
- InternalMmapVector<Range> *ranges);
-void GetAdditionalThreadContextPtrsLocked(InternalMmapVector<uptr> *ptrs);
-void GetRunningThreadsLocked(InternalMmapVector<ThreadID> *threads);
+ InternalMmapVector<Range>* ranges);
+void GetAdditionalThreadContextPtrsLocked(InternalMmapVector<uptr>* ptrs);
+void GetRunningThreadsLocked(InternalMmapVector<ThreadID>* threads);
void PrintThreads();
//// --------------------------------------------------------------------------
@@ -82,21 +82,21 @@ void PrintThreads();
void LockAllocator();
void UnlockAllocator();
-void GetAllocatorCacheRange(uptr *begin, uptr *end);
+void GetAllocatorCacheRange(uptr* begin, uptr* end);
void InitCommonDsan();
// Forward declaration - defined in dsan_thread.h
class ThreadContextDsanBase;
-ThreadContextDsanBase *GetCurrentThread();
-void SetCurrentThread(ThreadContextDsanBase *tctx);
+ThreadContextDsanBase* GetCurrentThread();
+void SetCurrentThread(ThreadContextDsanBase* tctx);
} // namespace __dsan
extern "C" {
-SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
-const char *__dsan_default_options();
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE const char*
+__dsan_default_options();
} // extern "C"
diff --git a/compiler-rt/lib/dsan/dsan_fuchsia.cpp
b/compiler-rt/lib/dsan/dsan_fuchsia.cpp
index 5e3e81e8a..f4c698e35 100644
--- a/compiler-rt/lib/dsan/dsan_fuchsia.cpp
+++ b/compiler-rt/lib/dsan/dsan_fuchsia.cpp
@@ -14,10 +14,10 @@
#include "sanitizer_common/sanitizer_platform.h"
#if SANITIZER_FUCHSIA
-#include <zircon/sanitizer.h>
+# include <zircon/sanitizer.h>
-#include "dsan.h"
-#include "dsan_allocator.h"
+# include "dsan.h"
+# include "dsan_allocator.h"
using namespace __dsan;
@@ -28,7 +28,7 @@ void EarlySanitizerInit() {}
namespace __dsan {
-void DsanOnDeadlySignal(int signo, void *siginfo, void *context) {}
+void DsanOnDeadlySignal(int signo, void* siginfo, void* context) {}
ThreadContext::ThreadContext(int tid) : ThreadContextDsanBase(tid) {}
@@ -38,10 +38,10 @@ struct OnCreatedArgs {
// On Fuchsia, the stack bounds of a new thread are available before
// the thread itself has started running.
-void ThreadContext::OnCreated(void *arg) {
+void ThreadContext::OnCreated(void* arg) {
// Stack bounds passed through from __sanitizer_before_thread_create_hook
// or InitializeMainThread.
- auto args = reinterpret_cast<const OnCreatedArgs *>(arg);
+ auto args = reinterpret_cast<const OnCreatedArgs*>(arg);
stack_begin_ = args->stack_begin;
stack_end_ = args->stack_end;
}
@@ -50,9 +50,9 @@ struct OnStartedArgs {
uptr cache_begin, cache_end;
};
-void ThreadContext::OnStarted(void *arg) {
+void ThreadContext::OnStarted(void* arg) {
ThreadContextDsanBase::OnStarted(arg);
- auto args = reinterpret_cast<const OnStartedArgs *>(arg);
+ auto args = reinterpret_cast<const OnStartedArgs*>(arg);
cache_begin_ = args->cache_begin;
cache_end_ = args->cache_end;
}
@@ -73,10 +73,10 @@ void InitializeMainThread() {
ThreadStart(tid);
}
-void GetAllThreadAllocatorCachesLocked(InternalMmapVector<uptr> *caches) {
+void GetAllThreadAllocatorCachesLocked(InternalMmapVector<uptr>* caches) {
GetDsanThreadRegistryLocked()->RunCallbackForEachThreadLocked(
- [](ThreadContextBase *tctx, void *arg) {
- auto ctx = static_cast<ThreadContext *>(tctx);
+ [](ThreadContextBase* tctx, void* arg) {
+ auto ctx = static_cast<ThreadContext*>(tctx);
static_cast<decltype(caches)>(arg)->push_back(ctx->cache_begin());
},
caches);
@@ -92,8 +92,8 @@ void InstallAtForkHandler() {}
// This is called before each thread creation is attempted. So, in
// its first call, the calling thread is the initial and sole thread.
-void *__sanitizer_before_thread_create_hook(thrd_t thread, bool detached,
- const char *name, void *stack_base,
+void* __sanitizer_before_thread_create_hook(thrd_t thread, bool detached,
+ const char* name, void* stack_base,
size_t stack_size) {
ENSURE_DSAN_INITED;
EnsureMainThreadIDIsCorrect();
@@ -102,12 +102,12 @@ void *__sanitizer_before_thread_create_hook(thrd_t
thread, bool detached,
args.stack_end = args.stack_begin + stack_size;
u32 parent_tid = GetCurrentThreadId();
u32 tid = ThreadCreate(parent_tid, detached, &args);
- return reinterpret_cast<void *>(static_cast<uptr>(tid));
+ return reinterpret_cast<void*>(static_cast<uptr>(tid));
}
// This is called after creating a new thread (in the creating thread),
// with the pointer returned by __sanitizer_before_thread_create_hook (above).
-void __sanitizer_thread_create_hook(void *hook, thrd_t thread, int error) {
+void __sanitizer_thread_create_hook(void* hook, thrd_t thread, int error) {
u32 tid = static_cast<u32>(reinterpret_cast<uptr>(hook));
// On success, there is nothing to do here.
if (error != thrd_success) {
@@ -118,7 +118,7 @@ void __sanitizer_thread_create_hook(void *hook, thrd_t
thread, int error) {
// This is called in the newly-created thread before it runs anything else,
// with the pointer returned by __sanitizer_before_thread_create_hook (above).
-void __sanitizer_thread_start_hook(void *hook, thrd_t self) {
+void __sanitizer_thread_start_hook(void* hook, thrd_t self) {
u32 tid = static_cast<u32>(reinterpret_cast<uptr>(hook));
ThreadStart(tid);
}
@@ -126,6 +126,6 @@ void __sanitizer_thread_start_hook(void *hook, thrd_t self)
{
// Each thread runs this just before it exits,
// with the pointer returned by BeforeThreadCreateHook (above).
// All per-thread destructors have already been called.
-void __sanitizer_thread_exit_hook(void *hook, thrd_t self) { ThreadFinish(); }
+void __sanitizer_thread_exit_hook(void* hook, thrd_t self) { ThreadFinish(); }
#endif // SANITIZER_FUCHSIA
diff --git a/compiler-rt/lib/dsan/dsan_fuchsia.h
b/compiler-rt/lib/dsan/dsan_fuchsia.h
index 60efe4e47..e60fc4f2a 100644
--- a/compiler-rt/lib/dsan/dsan_fuchsia.h
+++ b/compiler-rt/lib/dsan/dsan_fuchsia.h
@@ -18,7 +18,7 @@
#include "sanitizer_common/sanitizer_platform.h"
#if !SANITIZER_FUCHSIA
-#error "dsan_fuchsia.h is used only on Fuchsia systems (SANITIZER_FUCHSIA)"
+# error "dsan_fuchsia.h is used only on Fuchsia systems (SANITIZER_FUCHSIA)"
#endif
namespace __dsan {
@@ -26,8 +26,8 @@ namespace __dsan {
class ThreadContext final : public ThreadContextDsanBase {
public:
explicit ThreadContext(int tid);
- void OnCreated(void *arg) override;
- void OnStarted(void *arg) override;
+ void OnCreated(void* arg) override;
+ void OnStarted(void* arg) override;
};
} // namespace __dsan
diff --git a/compiler-rt/lib/dsan/dsan_interceptors.cpp
b/compiler-rt/lib/dsan/dsan_interceptors.cpp
index 099820ec0..8ddb6d582 100644
--- a/compiler-rt/lib/dsan/dsan_interceptors.cpp
+++ b/compiler-rt/lib/dsan/dsan_interceptors.cpp
@@ -26,32 +26,32 @@
#include "sanitizer_common/sanitizer_platform_limits_netbsd.h"
#include "sanitizer_common/sanitizer_platform_limits_posix.h"
#if SANITIZER_POSIX
-#include "sanitizer_common/sanitizer_posix.h"
+# include "sanitizer_common/sanitizer_posix.h"
#endif
+#include <stddef.h>
+
#include "dsan.h"
#include "dsan_allocator.h"
#include "dsan_common.h"
#include "dsan_thread.h"
-#include <stddef.h>
-
using namespace __dsan;
extern "C" {
-int pthread_attr_init(void *attr);
-int pthread_attr_destroy(void *attr);
-int pthread_attr_getdetachstate(void *attr, int *v);
-int pthread_key_create(unsigned *key, void (*destructor)(void* v));
-int pthread_setspecific(unsigned key, const void *v);
+int pthread_attr_init(void* attr);
+int pthread_attr_destroy(void* attr);
+int pthread_attr_getdetachstate(void* attr, int* v);
+int pthread_key_create(unsigned* key, void (*destructor)(void* v));
+int pthread_setspecific(unsigned key, const void* v);
}
struct DlsymAlloc : DlSymAllocator<DlsymAlloc> {
static bool UseImpl() { return dsan_init_is_running; }
- static void OnAllocate(const void *ptr, uptr size) {
+ static void OnAllocate(const void* ptr, uptr size) {
(void)ptr;
(void)size;
}
- static void OnFree(const void *ptr, uptr size) {
+ static void OnFree(const void* ptr, uptr size) {
(void)ptr;
(void)size;
}
@@ -60,9 +60,9 @@ struct DlsymAlloc : DlSymAllocator<DlsymAlloc> {
///// Malloc/free interceptors. /////
namespace std {
- struct nothrow_t;
- enum class align_val_t: size_t;
-}
+struct nothrow_t;
+enum class align_val_t : size_t;
+} // namespace std
#if !SANITIZER_APPLE
INTERCEPTOR(void*, malloc, uptr size) {
@@ -73,7 +73,7 @@ INTERCEPTOR(void*, malloc, uptr size) {
return dsan_malloc(size, stack);
}
-INTERCEPTOR(void, free, void *p) {
+INTERCEPTOR(void, free, void* p) {
if (UNLIKELY(!p))
return;
if (DlsymAlloc::PointerIsMine(p))
@@ -84,7 +84,7 @@ INTERCEPTOR(void, free, void *p) {
}
# if SANITIZER_INTERCEPT_FREE_SIZED
-INTERCEPTOR(void, free_sized, void *p, uptr size) {
+INTERCEPTOR(void, free_sized, void* p, uptr size) {
if (UNLIKELY(!p))
return;
if (DlsymAlloc::PointerIsMine(p))
@@ -99,7 +99,7 @@ INTERCEPTOR(void, free_sized, void *p, uptr size) {
# endif
# if SANITIZER_INTERCEPT_FREE_ALIGNED_SIZED
-INTERCEPTOR(void, free_aligned_sized, void *p, uptr alignment, uptr size) {
+INTERCEPTOR(void, free_aligned_sized, void* p, uptr alignment, uptr size) {
if (UNLIKELY(!p))
return;
if (DlsymAlloc::PointerIsMine(p))
@@ -122,7 +122,7 @@ INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
return dsan_calloc(nmemb, size, stack);
}
-INTERCEPTOR(void *, realloc, void *ptr, uptr size) {
+INTERCEPTOR(void*, realloc, void* ptr, uptr size) {
if (DlsymAlloc::Use() || DlsymAlloc::PointerIsMine(ptr))
return DlsymAlloc::Realloc(ptr, size);
ENSURE_DSAN_INITED;
@@ -130,7 +130,7 @@ INTERCEPTOR(void *, realloc, void *ptr, uptr size) {
return dsan_realloc(ptr, size, stack);
}
-INTERCEPTOR(void*, reallocarray, void *q, uptr nmemb, uptr size) {
+INTERCEPTOR(void*, reallocarray, void* q, uptr nmemb, uptr size) {
if (DlsymAlloc::Use() || DlsymAlloc::PointerIsMine(q)) {
if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) {
errno = errno_ENOMEM;
@@ -143,7 +143,7 @@ INTERCEPTOR(void*, reallocarray, void *q, uptr nmemb, uptr
size) {
return dsan_reallocarray(q, nmemb, size, stack);
}
-INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
+INTERCEPTOR(int, posix_memalign, void** memptr, uptr alignment, uptr size) {
ENSURE_DSAN_INITED;
GET_STACK_TRACE_MALLOC;
return dsan_posix_memalign(memptr, alignment, size, stack);
@@ -165,20 +165,21 @@ INTERCEPTOR(void*, memalign, uptr alignment, uptr size) {
GET_STACK_TRACE_MALLOC;
return dsan_memalign(alignment, size, stack);
}
-#define DSAN_MAYBE_INTERCEPT_MEMALIGN INTERCEPT_FUNCTION(memalign)
+# define DSAN_MAYBE_INTERCEPT_MEMALIGN INTERCEPT_FUNCTION(memalign)
#else
-#define DSAN_MAYBE_INTERCEPT_MEMALIGN
+# define DSAN_MAYBE_INTERCEPT_MEMALIGN
#endif // SANITIZER_INTERCEPT_MEMALIGN
#if SANITIZER_INTERCEPT___LIBC_MEMALIGN
-INTERCEPTOR(void *, __libc_memalign, uptr alignment, uptr size) {
+INTERCEPTOR(void*, __libc_memalign, uptr alignment, uptr size) {
ENSURE_DSAN_INITED;
GET_STACK_TRACE_MALLOC;
return dsan_memalign(alignment, size, stack);
}
-#define DSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN
INTERCEPT_FUNCTION(__libc_memalign)
+# define DSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN \
+ INTERCEPT_FUNCTION(__libc_memalign)
#else
-#define DSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN
+# define DSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN
#endif // SANITIZER_INTERCEPT___LIBC_MEMALIGN
#if SANITIZER_INTERCEPT_ALIGNED_ALLOC
@@ -187,20 +188,20 @@ INTERCEPTOR(void*, aligned_alloc, uptr alignment, uptr
size) {
GET_STACK_TRACE_MALLOC;
return dsan_aligned_alloc(alignment, size, stack);
}
-#define DSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC INTERCEPT_FUNCTION(aligned_alloc)
+# define DSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC INTERCEPT_FUNCTION(aligned_alloc)
#else
-#define DSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC
+# define DSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC
#endif
#if SANITIZER_INTERCEPT_MALLOC_USABLE_SIZE
-INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
+INTERCEPTOR(uptr, malloc_usable_size, void* ptr) {
ENSURE_DSAN_INITED;
return GetMallocUsableSize(ptr);
}
-#define DSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE \
- INTERCEPT_FUNCTION(malloc_usable_size)
+# define DSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE \
+ INTERCEPT_FUNCTION(malloc_usable_size)
#else
-#define DSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE
+# define DSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE
#endif
#if SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
@@ -213,16 +214,14 @@ INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
internal_memset(&res, 0, sizeof(res));
return res;
}
-#define DSAN_MAYBE_INTERCEPT_MALLINFO INTERCEPT_FUNCTION(mallinfo)
+# define DSAN_MAYBE_INTERCEPT_MALLINFO INTERCEPT_FUNCTION(mallinfo)
-INTERCEPTOR(int, mallopt, int cmd, int value) {
- return 0;
-}
-#define DSAN_MAYBE_INTERCEPT_MALLOPT INTERCEPT_FUNCTION(mallopt)
+INTERCEPTOR(int, mallopt, int cmd, int value) { return 0; }
+# define DSAN_MAYBE_INTERCEPT_MALLOPT INTERCEPT_FUNCTION(mallopt)
#else
-#define DSAN_MAYBE_INTERCEPT_MALLINFO
-#define DSAN_MAYBE_INTERCEPT_MALLOPT
-#endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
+# define DSAN_MAYBE_INTERCEPT_MALLINFO
+# define DSAN_MAYBE_INTERCEPT_MALLOPT
+#endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
#if SANITIZER_INTERCEPT_PVALLOC
INTERCEPTOR(void*, pvalloc, uptr size) {
@@ -230,50 +229,45 @@ INTERCEPTOR(void*, pvalloc, uptr size) {
GET_STACK_TRACE_MALLOC;
return dsan_pvalloc(size, stack);
}
-#define DSAN_MAYBE_INTERCEPT_PVALLOC INTERCEPT_FUNCTION(pvalloc)
+# define DSAN_MAYBE_INTERCEPT_PVALLOC INTERCEPT_FUNCTION(pvalloc)
#else
-#define DSAN_MAYBE_INTERCEPT_PVALLOC
-#endif // SANITIZER_INTERCEPT_PVALLOC
+# define DSAN_MAYBE_INTERCEPT_PVALLOC
+#endif // SANITIZER_INTERCEPT_PVALLOC
#if SANITIZER_INTERCEPT_CFREE
-INTERCEPTOR(void, cfree, void *p) ALIAS(WRAP(free));
-#define DSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree)
+INTERCEPTOR(void, cfree, void* p) ALIAS(WRAP(free));
+# define DSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree)
#else
-#define DSAN_MAYBE_INTERCEPT_CFREE
-#endif // SANITIZER_INTERCEPT_CFREE
+# define DSAN_MAYBE_INTERCEPT_CFREE
+#endif // SANITIZER_INTERCEPT_CFREE
#if SANITIZER_INTERCEPT_MCHECK_MPROBE
-INTERCEPTOR(int, mcheck, void (*abortfunc)(int mstatus)) {
- return 0;
-}
+INTERCEPTOR(int, mcheck, void (*abortfunc)(int mstatus)) { return 0; }
-INTERCEPTOR(int, mcheck_pedantic, void (*abortfunc)(int mstatus)) {
- return 0;
-}
-
-INTERCEPTOR(int, mprobe, void *ptr) {
- return 0;
-}
-#endif // SANITIZER_INTERCEPT_MCHECK_MPROBE
+INTERCEPTOR(int, mcheck_pedantic, void (*abortfunc)(int mstatus)) { return 0; }
+INTERCEPTOR(int, mprobe, void* ptr) { return 0; }
+#endif // SANITIZER_INTERCEPT_MCHECK_MPROBE
// TODO(alekseys): throw std::bad_alloc instead of dying on OOM.
-#define OPERATOR_NEW_BODY(nothrow)\
- ENSURE_DSAN_INITED;\
- GET_STACK_TRACE_MALLOC;\
- void *res = dsan_malloc(size, stack);\
- if (!nothrow && UNLIKELY(!res)) ReportOutOfMemory(size, &stack);\
+#define OPERATOR_NEW_BODY(nothrow) \
+ ENSURE_DSAN_INITED; \
+ GET_STACK_TRACE_MALLOC; \
+ void* res = dsan_malloc(size, stack); \
+ if (!nothrow && UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
return res;
-#define OPERATOR_NEW_BODY_ALIGN(nothrow)\
- ENSURE_DSAN_INITED;\
- GET_STACK_TRACE_MALLOC;\
- void *res = dsan_memalign((uptr)align, size, stack);\
- if (!nothrow && UNLIKELY(!res)) ReportOutOfMemory(size, &stack);\
+#define OPERATOR_NEW_BODY_ALIGN(nothrow) \
+ ENSURE_DSAN_INITED; \
+ GET_STACK_TRACE_MALLOC; \
+ void* res = dsan_memalign((uptr)align, size, stack); \
+ if (!nothrow && UNLIKELY(!res)) \
+ ReportOutOfMemory(size, &stack); \
return res;
-#define OPERATOR_DELETE_BODY\
- ENSURE_DSAN_INITED;\
- GET_STACK_TRACE_MALLOC;\
+#define OPERATOR_DELETE_BODY \
+ ENSURE_DSAN_INITED; \
+ GET_STACK_TRACE_MALLOC; \
dsan_free(ptr, stack);
// On OS X it's not enough to just provide our own 'operator new' and
@@ -285,91 +279,104 @@ INTERCEPTOR(int, mprobe, void *ptr) {
#if !SANITIZER_APPLE
INTERCEPTOR_ATTRIBUTE
-void *operator new(size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/); }
+void* operator new(size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/); }
INTERCEPTOR_ATTRIBUTE
-void *operator new[](size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/); }
+void* operator new[](size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/); }
INTERCEPTOR_ATTRIBUTE
-void *operator new(size_t size, std::nothrow_t const&)
-{ OPERATOR_NEW_BODY(true /*nothrow*/); }
+void* operator new(size_t size, std::nothrow_t const&) {
+ OPERATOR_NEW_BODY(true /*nothrow*/);
+}
INTERCEPTOR_ATTRIBUTE
-void *operator new[](size_t size, std::nothrow_t const&)
-{ OPERATOR_NEW_BODY(true /*nothrow*/); }
+void* operator new[](size_t size, std::nothrow_t const&) {
+ OPERATOR_NEW_BODY(true /*nothrow*/);
+}
INTERCEPTOR_ATTRIBUTE
-void *operator new(size_t size, std::align_val_t align)
-{ OPERATOR_NEW_BODY_ALIGN(false /*nothrow*/); }
+void* operator new(size_t size, std::align_val_t align) {
+ OPERATOR_NEW_BODY_ALIGN(false /*nothrow*/);
+}
INTERCEPTOR_ATTRIBUTE
-void *operator new[](size_t size, std::align_val_t align)
-{ OPERATOR_NEW_BODY_ALIGN(false /*nothrow*/); }
+void* operator new[](size_t size, std::align_val_t align) {
+ OPERATOR_NEW_BODY_ALIGN(false /*nothrow*/);
+}
INTERCEPTOR_ATTRIBUTE
-void *operator new(size_t size, std::align_val_t align, std::nothrow_t const&)
-{ OPERATOR_NEW_BODY_ALIGN(true /*nothrow*/); }
+void* operator new(size_t size, std::align_val_t align, std::nothrow_t const&)
{
+ OPERATOR_NEW_BODY_ALIGN(true /*nothrow*/);
+}
INTERCEPTOR_ATTRIBUTE
-void *operator new[](size_t size, std::align_val_t align, std::nothrow_t
const&)
-{ OPERATOR_NEW_BODY_ALIGN(true /*nothrow*/); }
+void* operator new[](size_t size, std::align_val_t align,
+ std::nothrow_t const&) {
+ OPERATOR_NEW_BODY_ALIGN(true /*nothrow*/);
+}
INTERCEPTOR_ATTRIBUTE
-void operator delete(void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
+void operator delete(void* ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
INTERCEPTOR_ATTRIBUTE
-void operator delete[](void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
+void operator delete[](void* ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
INTERCEPTOR_ATTRIBUTE
-void operator delete(void *ptr, std::nothrow_t const&) { OPERATOR_DELETE_BODY;
}
+void operator delete(void* ptr, std::nothrow_t const&) { OPERATOR_DELETE_BODY;
}
INTERCEPTOR_ATTRIBUTE
-void operator delete[](void *ptr, std::nothrow_t const &)
-{ OPERATOR_DELETE_BODY; }
+void operator delete[](void* ptr, std::nothrow_t const&) {
+ OPERATOR_DELETE_BODY;
+}
INTERCEPTOR_ATTRIBUTE
-void operator delete(void *ptr, size_t size) NOEXCEPT
-{ OPERATOR_DELETE_BODY; }
+void operator delete(void* ptr, size_t size) NOEXCEPT { OPERATOR_DELETE_BODY; }
INTERCEPTOR_ATTRIBUTE
-void operator delete[](void *ptr, size_t size) NOEXCEPT
-{ OPERATOR_DELETE_BODY; }
+void operator delete[](void* ptr, size_t size) NOEXCEPT {
+ OPERATOR_DELETE_BODY;
+}
INTERCEPTOR_ATTRIBUTE
-void operator delete(void *ptr, std::align_val_t) NOEXCEPT
-{ OPERATOR_DELETE_BODY; }
+void operator delete(void* ptr, std::align_val_t) NOEXCEPT {
+ OPERATOR_DELETE_BODY;
+}
INTERCEPTOR_ATTRIBUTE
-void operator delete[](void *ptr, std::align_val_t) NOEXCEPT
-{ OPERATOR_DELETE_BODY; }
+void operator delete[](void* ptr, std::align_val_t) NOEXCEPT {
+ OPERATOR_DELETE_BODY;
+}
INTERCEPTOR_ATTRIBUTE
-void operator delete(void *ptr, std::align_val_t, std::nothrow_t const&)
-{ OPERATOR_DELETE_BODY; }
+void operator delete(void* ptr, std::align_val_t, std::nothrow_t const&) {
+ OPERATOR_DELETE_BODY;
+}
INTERCEPTOR_ATTRIBUTE
-void operator delete[](void *ptr, std::align_val_t, std::nothrow_t const&)
-{ OPERATOR_DELETE_BODY; }
+void operator delete[](void* ptr, std::align_val_t, std::nothrow_t const&) {
+ OPERATOR_DELETE_BODY;
+}
INTERCEPTOR_ATTRIBUTE
-void operator delete(void *ptr, size_t size, std::align_val_t) NOEXCEPT
-{ OPERATOR_DELETE_BODY; }
+void operator delete(void* ptr, size_t size, std::align_val_t) NOEXCEPT {
+ OPERATOR_DELETE_BODY;
+}
INTERCEPTOR_ATTRIBUTE
-void operator delete[](void *ptr, size_t size, std::align_val_t) NOEXCEPT
-{ OPERATOR_DELETE_BODY; }
+void operator delete[](void* ptr, size_t size, std::align_val_t) NOEXCEPT {
+ OPERATOR_DELETE_BODY;
+}
#else // SANITIZER_APPLE
-INTERCEPTOR(void *, _Znwm, size_t size)
-{ OPERATOR_NEW_BODY(false /*nothrow*/); }
-INTERCEPTOR(void *, _Znam, size_t size)
-{ OPERATOR_NEW_BODY(false /*nothrow*/); }
-INTERCEPTOR(void *, _ZnwmRKSt9nothrow_t, size_t size, std::nothrow_t const&)
-{ OPERATOR_NEW_BODY(true /*nothrow*/); }
-INTERCEPTOR(void *, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&)
-{ OPERATOR_NEW_BODY(true /*nothrow*/); }
-
-INTERCEPTOR(void, _ZdlPv, void *ptr)
-{ OPERATOR_DELETE_BODY; }
-INTERCEPTOR(void, _ZdaPv, void *ptr)
-{ OPERATOR_DELETE_BODY; }
-INTERCEPTOR(void, _ZdlPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&)
-{ OPERATOR_DELETE_BODY; }
-INTERCEPTOR(void, _ZdaPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&)
-{ OPERATOR_DELETE_BODY; }
+INTERCEPTOR(void*, _Znwm, size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/);
}
+INTERCEPTOR(void*, _Znam, size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/);
}
+INTERCEPTOR(void*, _ZnwmRKSt9nothrow_t, size_t size, std::nothrow_t const&) {
+ OPERATOR_NEW_BODY(true /*nothrow*/);
+}
+INTERCEPTOR(void*, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&) {
+ OPERATOR_NEW_BODY(true /*nothrow*/);
+}
+
+INTERCEPTOR(void, _ZdlPv, void* ptr) { OPERATOR_DELETE_BODY; }
+INTERCEPTOR(void, _ZdaPv, void* ptr) { OPERATOR_DELETE_BODY; }
+INTERCEPTOR(void, _ZdlPvRKSt9nothrow_t, void* ptr, std::nothrow_t const&) {
+ OPERATOR_DELETE_BODY;
+}
+INTERCEPTOR(void, _ZdaPvRKSt9nothrow_t, void* ptr, std::nothrow_t const&) {
+ OPERATOR_DELETE_BODY;
+}
#endif // !SANITIZER_APPLE
-
///// Thread initialization and finalization. /////
#if !SANITIZER_NETBSD && !SANITIZER_FREEBSD && !SANITIZER_FUCHSIA
static unsigned g_thread_finalize_key;
-static void thread_finalize(void *v) {
+static void thread_finalize(void* v) {
uptr iter = (uptr)v;
if (iter > 1) {
if (pthread_setspecific(g_thread_finalize_key, (void*)(iter - 1))) {
@@ -388,31 +395,31 @@ INTERCEPTOR(void, _lwp_exit) {
ThreadFinish();
REAL(_lwp_exit)();
}
-#define DSAN_MAYBE_INTERCEPT__LWP_EXIT INTERCEPT_FUNCTION(_lwp_exit)
+# define DSAN_MAYBE_INTERCEPT__LWP_EXIT INTERCEPT_FUNCTION(_lwp_exit)
#else
-#define DSAN_MAYBE_INTERCEPT__LWP_EXIT
+# define DSAN_MAYBE_INTERCEPT__LWP_EXIT
#endif
#if SANITIZER_INTERCEPT_THR_EXIT
-INTERCEPTOR(void, thr_exit, ThreadID *state) {
+INTERCEPTOR(void, thr_exit, ThreadID* state) {
ENSURE_DSAN_INITED;
ThreadFinish();
REAL(thr_exit)(state);
}
# define DSAN_MAYBE_INTERCEPT_THR_EXIT INTERCEPT_FUNCTION(thr_exit)
#else
-#define DSAN_MAYBE_INTERCEPT_THR_EXIT
+# define DSAN_MAYBE_INTERCEPT_THR_EXIT
#endif
#if SANITIZER_POSIX
template <bool Detached>
-static void *ThreadStartFunc(void *arg) {
+static void* ThreadStartFunc(void* arg) {
u32 parent_tid = (uptr)arg;
uptr tid = ThreadCreate(parent_tid, Detached);
// Wait until the last iteration to maximize the chance that we are the last
// destructor to run.
-#if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
+# if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
if (pthread_setspecific(g_thread_finalize_key,
(void*)GetPthreadDestructorIterations())) {
Report("DoubleFreeSanitizer: failed to set thread key.\n");
@@ -422,13 +429,13 @@ static void *ThreadStartFunc(void *arg) {
ThreadStart(tid, GetTid());
auto self = GetThreadSelf();
auto args = GetThreadArgRetval().GetArgs(self);
- void *retval = (*args.routine)(args.arg_retval);
+ void* retval = (*args.routine)(args.arg_retval);
GetThreadArgRetval().Finish(self, retval);
return retval;
}
-INTERCEPTOR(int, pthread_create, void *th, void *attr,
- void *(*callback)(void *), void *param) {
+INTERCEPTOR(int, pthread_create, void* th, void* attr, void*
(*callback)(void*),
+ void* param) {
ENSURE_DSAN_INITED;
EnsureMainThreadIDIsCorrect();
@@ -448,15 +455,15 @@ INTERCEPTOR(int, pthread_create, void *th, void *attr,
GetThreadArgRetval().Create(detached, {callback, param}, [&]() -> uptr {
result = REAL(pthread_create)(
th, attr, detached ? ThreadStartFunc<true> : ThreadStartFunc<false>,
- (void *)this_tid);
- return result ? 0 : *(uptr *)(th);
+ (void*)this_tid);
+ return result ? 0 : *(uptr*)(th);
});
if (attr == &myattr)
pthread_attr_destroy(&myattr);
return result;
}
-INTERCEPTOR(int, pthread_join, void *thread, void **retval) {
+INTERCEPTOR(int, pthread_join, void* thread, void** retval) {
int result;
GetThreadArgRetval().Join((uptr)thread, [&]() {
result = REAL(pthread_join)(thread, retval);
@@ -465,7 +472,7 @@ INTERCEPTOR(int, pthread_join, void *thread, void **retval)
{
return result;
}
-INTERCEPTOR(int, pthread_detach, void *thread) {
+INTERCEPTOR(int, pthread_detach, void* thread) {
int result;
GetThreadArgRetval().Detach((uptr)thread, [&]() {
result = REAL(pthread_detach)(thread);
@@ -474,13 +481,13 @@ INTERCEPTOR(int, pthread_detach, void *thread) {
return result;
}
-INTERCEPTOR(void, pthread_exit, void *retval) {
+INTERCEPTOR(void, pthread_exit, void* retval) {
GetThreadArgRetval().Finish(GetThreadSelf(), retval);
REAL(pthread_exit)(retval);
}
# if SANITIZER_INTERCEPT_TRYJOIN
-INTERCEPTOR(int, pthread_tryjoin_np, void *thread, void **ret) {
+INTERCEPTOR(int, pthread_tryjoin_np, void* thread, void** ret) {
int result;
GetThreadArgRetval().Join((uptr)thread, [&]() {
result = REAL(pthread_tryjoin_np)(thread, ret);
@@ -494,8 +501,8 @@ INTERCEPTOR(int, pthread_tryjoin_np, void *thread, void
**ret) {
# endif // SANITIZER_INTERCEPT_TRYJOIN
# if SANITIZER_INTERCEPT_TIMEDJOIN
-INTERCEPTOR(int, pthread_timedjoin_np, void *thread, void **ret,
- const struct timespec *abstime) {
+INTERCEPTOR(int, pthread_timedjoin_np, void* thread, void** ret,
+ const struct timespec* abstime) {
int result;
GetThreadArgRetval().Join((uptr)thread, [&]() {
result = REAL(pthread_timedjoin_np)(thread, ret, abstime);
@@ -511,13 +518,11 @@ INTERCEPTOR(int, pthread_timedjoin_np, void *thread, void
**ret,
DEFINE_INTERNAL_PTHREAD_FUNCTIONS
-INTERCEPTOR(void, _exit, int status) {
- REAL(_exit)(status);
-}
+INTERCEPTOR(void, _exit, int status) { REAL(_exit)(status); }
-#define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name)
-#define SIGNAL_INTERCEPTOR_ENTER() ENSURE_DSAN_INITED
-#include "sanitizer_common/sanitizer_signal_interceptors.inc"
+# define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name)
+# define SIGNAL_INTERCEPTOR_ENTER() ENSURE_DSAN_INITED
+# include "sanitizer_common/sanitizer_signal_interceptors.inc"
#endif // SANITIZER_POSIX
@@ -557,14 +562,14 @@ void InitializeInterceptors() {
DSAN_MAYBE_INTERCEPT__LWP_EXIT;
DSAN_MAYBE_INTERCEPT_THR_EXIT;
-#if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
+# if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
Report("DoubleFreeSanitizer: failed to create thread key.\n");
Die();
}
-#endif
+# endif
#endif // !SANITIZER_FUCHSIA
}
-} // namespace __dsan
+} // namespace __dsan
diff --git a/compiler-rt/lib/dsan/dsan_linux.cpp
b/compiler-rt/lib/dsan/dsan_linux.cpp
index 29a1ebdf5..fa5bbffb9 100644
--- a/compiler-rt/lib/dsan/dsan_linux.cpp
+++ b/compiler-rt/lib/dsan/dsan_linux.cpp
@@ -6,7 +6,8 @@
//
//===----------------------------------------------------------------------===//
//
-// This file is a part of DoubleFreeSanitizer. Linux/NetBSD/Fuchsia-specific
code.
+// This file is a part of DoubleFreeSanitizer. Linux/NetBSD/Fuchsia-specific
+// code.
//
//===----------------------------------------------------------------------===//
@@ -19,15 +20,15 @@
namespace __dsan {
-static THREADLOCAL ThreadContextDsanBase *current_thread = nullptr;
-ThreadContextDsanBase *GetCurrentThread() { return current_thread; }
-void SetCurrentThread(ThreadContextDsanBase *tctx) { current_thread = tctx; }
+static THREADLOCAL ThreadContextDsanBase* current_thread = nullptr;
+ThreadContextDsanBase* GetCurrentThread() { return current_thread; }
+void SetCurrentThread(ThreadContextDsanBase* tctx) { current_thread = tctx; }
static THREADLOCAL AllocatorCache allocator_cache;
-AllocatorCache *GetAllocatorCache() { return &allocator_cache; }
+AllocatorCache* GetAllocatorCache() { return &allocator_cache; }
void ReplaceSystemMalloc() {}
-} // namespace __dsan
+} // namespace __dsan
#endif // SANITIZER_LINUX || SANITIZER_NETBSD || SANITIZER_FUCHSIA
diff --git a/compiler-rt/lib/dsan/dsan_mac.cpp
b/compiler-rt/lib/dsan/dsan_mac.cpp
index c646885cf..793689862 100644
--- a/compiler-rt/lib/dsan/dsan_mac.cpp
+++ b/compiler-rt/lib/dsan/dsan_mac.cpp
@@ -14,25 +14,25 @@
#include "sanitizer_common/sanitizer_platform.h"
#if SANITIZER_APPLE
-#include "interception/interception.h"
-#include "dsan.h"
-#include "dsan_allocator.h"
-#include "dsan_thread.h"
-#include "sanitizer_common/sanitizer_allocator_internal.h"
+# include <pthread.h>
-#include <pthread.h>
+# include "dsan.h"
+# include "dsan_allocator.h"
+# include "dsan_thread.h"
+# include "interception/interception.h"
+# include "sanitizer_common/sanitizer_allocator_internal.h"
namespace __dsan {
struct ThreadLocalData {
- ThreadContextDsanBase *current_thread;
+ ThreadContextDsanBase* current_thread;
AllocatorCache cache;
};
static pthread_key_t thread_local_key;
static pthread_once_t thread_local_key_once = PTHREAD_ONCE_INIT;
-static void RestoreThreadLocalData(void *ptr) {
- ThreadLocalData *data = static_cast<ThreadLocalData *>(ptr);
+static void RestoreThreadLocalData(void* ptr) {
+ ThreadLocalData* data = static_cast<ThreadLocalData*>(ptr);
if (data->current_thread)
pthread_setspecific(thread_local_key, data);
}
@@ -41,12 +41,12 @@ static void CreateThreadLocalKey() {
CHECK_EQ(pthread_key_create(&thread_local_key, RestoreThreadLocalData), 0);
}
-static ThreadLocalData *GetThreadLocalData(bool allocate) {
+static ThreadLocalData* GetThreadLocalData(bool allocate) {
pthread_once(&thread_local_key_once, CreateThreadLocalKey);
- ThreadLocalData *data =
- static_cast<ThreadLocalData *>(pthread_getspecific(thread_local_key));
+ ThreadLocalData* data =
+ static_cast<ThreadLocalData*>(pthread_getspecific(thread_local_key));
if (!data && allocate) {
- data = static_cast<ThreadLocalData *>(InternalAlloc(sizeof(*data)));
+ data = static_cast<ThreadLocalData*>(InternalAlloc(sizeof(*data)));
data->current_thread = nullptr;
data->cache = AllocatorCache();
pthread_setspecific(thread_local_key, data);
@@ -54,16 +54,16 @@ static ThreadLocalData *GetThreadLocalData(bool allocate) {
return data;
}
-ThreadContextDsanBase *GetCurrentThread() {
- ThreadLocalData *data = GetThreadLocalData(false);
+ThreadContextDsanBase* GetCurrentThread() {
+ ThreadLocalData* data = GetThreadLocalData(false);
return data ? data->current_thread : nullptr;
}
-void SetCurrentThread(ThreadContextDsanBase *tctx) {
+void SetCurrentThread(ThreadContextDsanBase* tctx) {
GetThreadLocalData(true)->current_thread = tctx;
}
-AllocatorCache *GetAllocatorCache() { return &GetThreadLocalData(true)->cache;
}
+AllocatorCache* GetAllocatorCache() { return &GetThreadLocalData(true)->cache;
}
// Support for the following functions from libdispatch on Mac OS:
// dispatch_async_f()
@@ -94,16 +94,16 @@ AllocatorCache *GetAllocatorCache() { return
&GetThreadLocalData(true)->cache; }
// The implementation details are at
// http://libdispatch.macosforge.org/trac/browser/trunk/src/queue.c
-typedef void *dispatch_group_t;
-typedef void *dispatch_queue_t;
-typedef void *dispatch_source_t;
+typedef void* dispatch_group_t;
+typedef void* dispatch_queue_t;
+typedef void* dispatch_source_t;
typedef u64 dispatch_time_t;
-typedef void (*dispatch_function_t)(void *block);
-typedef void *(*worker_t)(void *block);
+typedef void (*dispatch_function_t)(void* block);
+typedef void* (*worker_t)(void* block);
// A wrapper for the ObjC blocks used to support libdispatch.
typedef struct {
- void *block;
+ void* block;
dispatch_function_t func;
u32 parent_tid;
} dsan_block_context_t;
@@ -118,8 +118,8 @@ void dsan_register_worker_thread(int parent_tid) {
// For use by only those functions that allocated the context via
// alloc_dsan_context().
-extern "C" void dsan_dispatch_call_block_and_release(void *block) {
- dsan_block_context_t *context = (dsan_block_context_t *)block;
+extern "C" void dsan_dispatch_call_block_and_release(void* block) {
+ dsan_block_context_t* context = (dsan_block_context_t*)block;
VReport(2,
"dsan_dispatch_call_block_and_release(): "
"context: %p, pthread_self: %p\n",
@@ -137,11 +137,11 @@ using namespace __dsan;
// Wrap |ctxt| and |func| into an dsan_block_context_t.
// The caller retains control of the allocated context.
-extern "C" dsan_block_context_t *alloc_dsan_context(void *ctxt,
+extern "C" dsan_block_context_t* alloc_dsan_context(void* ctxt,
dispatch_function_t func) {
GET_STACK_TRACE_THREAD;
- dsan_block_context_t *dsan_ctxt =
- (dsan_block_context_t *)dsan_malloc(sizeof(dsan_block_context_t), stack);
+ dsan_block_context_t* dsan_ctxt =
+ (dsan_block_context_t*)dsan_malloc(sizeof(dsan_block_context_t), stack);
dsan_ctxt->block = ctxt;
dsan_ctxt->func = func;
dsan_ctxt->parent_tid = GetCurrentThreadId();
@@ -150,33 +150,33 @@ extern "C" dsan_block_context_t *alloc_dsan_context(void
*ctxt,
// Define interceptor for dispatch_*_f function with the three most common
// parameters: dispatch_queue_t, context, dispatch_function_t.
-#define INTERCEPT_DISPATCH_X_F_3(dispatch_x_f) \
- INTERCEPTOR(void, dispatch_x_f, dispatch_queue_t dq, void *ctxt, \
- dispatch_function_t func) { \
- dsan_block_context_t *dsan_ctxt = alloc_dsan_context(ctxt, func); \
- return REAL(dispatch_x_f)(dq, (void *)dsan_ctxt, \
- dsan_dispatch_call_block_and_release); \
- }
+# define INTERCEPT_DISPATCH_X_F_3(dispatch_x_f) \
+ INTERCEPTOR(void, dispatch_x_f, dispatch_queue_t dq, void* ctxt, \
+ dispatch_function_t func) { \
+ dsan_block_context_t* dsan_ctxt = alloc_dsan_context(ctxt, func); \
+ return REAL(dispatch_x_f)(dq, (void*)dsan_ctxt, \
+ dsan_dispatch_call_block_and_release); \
+ }
INTERCEPT_DISPATCH_X_F_3(dispatch_async_f)
INTERCEPT_DISPATCH_X_F_3(dispatch_sync_f)
INTERCEPT_DISPATCH_X_F_3(dispatch_barrier_async_f)
INTERCEPTOR(void, dispatch_after_f, dispatch_time_t when, dispatch_queue_t dq,
- void *ctxt, dispatch_function_t func) {
- dsan_block_context_t *dsan_ctxt = alloc_dsan_context(ctxt, func);
- return REAL(dispatch_after_f)(when, dq, (void *)dsan_ctxt,
+ void* ctxt, dispatch_function_t func) {
+ dsan_block_context_t* dsan_ctxt = alloc_dsan_context(ctxt, func);
+ return REAL(dispatch_after_f)(when, dq, (void*)dsan_ctxt,
dsan_dispatch_call_block_and_release);
}
INTERCEPTOR(void, dispatch_group_async_f, dispatch_group_t group,
- dispatch_queue_t dq, void *ctxt, dispatch_function_t func) {
- dsan_block_context_t *dsan_ctxt = alloc_dsan_context(ctxt, func);
- REAL(dispatch_group_async_f)
- (group, dq, (void *)dsan_ctxt, dsan_dispatch_call_block_and_release);
+ dispatch_queue_t dq, void* ctxt, dispatch_function_t func) {
+ dsan_block_context_t* dsan_ctxt = alloc_dsan_context(ctxt, func);
+ REAL(dispatch_group_async_f)(group, dq, (void*)dsan_ctxt,
+ dsan_dispatch_call_block_and_release);
}
-#if !defined(MISSING_BLOCKS_SUPPORT)
+# if !defined(MISSING_BLOCKS_SUPPORT)
extern "C" {
void dispatch_async(dispatch_queue_t dq, void (^work)(void));
void dispatch_group_async(dispatch_group_t dg, dispatch_queue_t dq,
@@ -229,6 +229,6 @@ INTERCEPTOR(void, dispatch_source_set_event_handler,
dispatch_source_t ds,
GET_DSAN_BLOCK(work);
REAL(dispatch_source_set_event_handler)(ds, dsan_block);
}
-#endif
+# endif
#endif // SANITIZER_APPLE
diff --git a/compiler-rt/lib/dsan/dsan_malloc_mac.cpp
b/compiler-rt/lib/dsan/dsan_malloc_mac.cpp
index f133515ec..515b26c49 100644
--- a/compiler-rt/lib/dsan/dsan_malloc_mac.cpp
+++ b/compiler-rt/lib/dsan/dsan_malloc_mac.cpp
@@ -14,42 +14,42 @@
#include "sanitizer_common/sanitizer_platform.h"
#if SANITIZER_APPLE
-#include "dsan.h"
-#include "dsan_allocator.h"
-#include "dsan_thread.h"
+# include "dsan.h"
+# include "dsan_allocator.h"
+# include "dsan_thread.h"
using namespace __dsan;
-#define COMMON_MALLOC_ZONE_NAME "dsan"
-#define COMMON_MALLOC_ENTER() ENSURE_DSAN_INITED
-#define COMMON_MALLOC_SANITIZER_INITIALIZED dsan_inited
-#define COMMON_MALLOC_FORCE_LOCK()
-#define COMMON_MALLOC_FORCE_UNLOCK()
-#define COMMON_MALLOC_MEMALIGN(alignment, size) \
- GET_STACK_TRACE_MALLOC; \
- void *p = dsan_memalign(alignment, size, stack)
-#define COMMON_MALLOC_MALLOC(size) \
- GET_STACK_TRACE_MALLOC; \
- void *p = dsan_malloc(size, stack)
-#define COMMON_MALLOC_REALLOC(ptr, size) \
- GET_STACK_TRACE_MALLOC; \
- void *p = dsan_realloc(ptr, size, stack)
-#define COMMON_MALLOC_CALLOC(count, size) \
- GET_STACK_TRACE_MALLOC; \
- void *p = dsan_calloc(count, size, stack)
-#define COMMON_MALLOC_POSIX_MEMALIGN(memptr, alignment, size) \
- GET_STACK_TRACE_MALLOC; \
- int res = dsan_posix_memalign(memptr, alignment, size, stack)
-#define COMMON_MALLOC_VALLOC(size) \
- GET_STACK_TRACE_MALLOC; \
- void *p = dsan_valloc(size, stack)
-#define COMMON_MALLOC_FREE(ptr) \
- GET_STACK_TRACE_MALLOC; \
- dsan_free(ptr, stack)
+# define COMMON_MALLOC_ZONE_NAME "dsan"
+# define COMMON_MALLOC_ENTER() ENSURE_DSAN_INITED
+# define COMMON_MALLOC_SANITIZER_INITIALIZED dsan_inited
+# define COMMON_MALLOC_FORCE_LOCK()
+# define COMMON_MALLOC_FORCE_UNLOCK()
+# define COMMON_MALLOC_MEMALIGN(alignment, size) \
+ GET_STACK_TRACE_MALLOC; \
+ void* p = dsan_memalign(alignment, size, stack)
+# define COMMON_MALLOC_MALLOC(size) \
+ GET_STACK_TRACE_MALLOC; \
+ void* p = dsan_malloc(size, stack)
+# define COMMON_MALLOC_REALLOC(ptr, size) \
+ GET_STACK_TRACE_MALLOC; \
+ void* p = dsan_realloc(ptr, size, stack)
+# define COMMON_MALLOC_CALLOC(count, size) \
+ GET_STACK_TRACE_MALLOC; \
+ void* p = dsan_calloc(count, size, stack)
+# define COMMON_MALLOC_POSIX_MEMALIGN(memptr, alignment, size) \
+ GET_STACK_TRACE_MALLOC; \
+ int res = dsan_posix_memalign(memptr, alignment, size, stack)
+# define COMMON_MALLOC_VALLOC(size) \
+ GET_STACK_TRACE_MALLOC; \
+ void* p = dsan_valloc(size, stack)
+# define COMMON_MALLOC_FREE(ptr) \
+ GET_STACK_TRACE_MALLOC; \
+ dsan_free(ptr, stack)
# define COMMON_MALLOC_FREE_SIZED(ptr, size) \
- GET_STACK_TRACE_MALLOC; \
+ GET_STACK_TRACE_MALLOC; \
dsan_free_sized(ptr, size, stack)
# define COMMON_MALLOC_FREE_ALIGNED_SIZED(ptr, alignment, size) \
- GET_STACK_TRACE_MALLOC; \
+ GET_STACK_TRACE_MALLOC; \
dsan_free_aligned_sized(ptr, alignment, size, stack)
# define COMMON_MALLOC_SIZE(ptr) uptr size = dsan_mz_size(ptr)
# define COMMON_MALLOC_FILL_STATS(zone, stats)
@@ -63,4 +63,4 @@ using namespace __dsan;
# include "sanitizer_common/sanitizer_malloc_mac.inc"
-#endif // SANITIZER_APPLE
+#endif // SANITIZER_APPLE
diff --git a/compiler-rt/lib/dsan/dsan_posix.cpp
b/compiler-rt/lib/dsan/dsan_posix.cpp
index 785207954..b96488f49 100644
--- a/compiler-rt/lib/dsan/dsan_posix.cpp
+++ b/compiler-rt/lib/dsan/dsan_posix.cpp
@@ -35,12 +35,12 @@ struct OnStartedArgs {
uptr cache_end;
uptr tls_begin;
uptr tls_end;
- DTLS *dtls;
+ DTLS* dtls;
};
-void ThreadContext::OnStarted(void *arg) {
+void ThreadContext::OnStarted(void* arg) {
ThreadContextDsanBase::OnStarted(arg);
- auto args = reinterpret_cast<const OnStartedArgs *>(arg);
+ auto args = reinterpret_cast<const OnStartedArgs*>(arg);
stack_begin_ = args->stack_begin;
stack_end_ = args->stack_end;
tls_begin_ = args->tls_begin;
@@ -59,10 +59,10 @@ void ThreadStart(u32 tid, ThreadID os_id, ThreadType
thread_type) {
ThreadContextDsanBase::ThreadStart(tid, os_id, thread_type, &args);
}
-bool GetThreadRangesLocked(ThreadID os_id, uptr *stack_begin, uptr *stack_end,
- uptr *tls_begin, uptr *tls_end, uptr *cache_begin,
- uptr *cache_end, DTLS **dtls) {
- ThreadContext *context = static_cast<ThreadContext *>(
+bool GetThreadRangesLocked(ThreadID os_id, uptr* stack_begin, uptr* stack_end,
+ uptr* tls_begin, uptr* tls_end, uptr* cache_begin,
+ uptr* cache_end, DTLS** dtls) {
+ ThreadContext* context = static_cast<ThreadContext*>(
GetDsanThreadRegistryLocked()->FindThreadContextByOsIDLocked(os_id));
if (!context)
return false;
@@ -82,13 +82,13 @@ void InitializeMainThread() {
ThreadStart(tid, GetTid());
}
-static void OnStackUnwind(const SignalContext &sig, const void *,
- BufferedStackTrace *stack) {
+static void OnStackUnwind(const SignalContext& sig, const void*,
+ BufferedStackTrace* stack) {
stack->Unwind(StackTrace::GetNextInstructionPc(sig.pc), sig.bp, sig.context,
common_flags()->fast_unwind_on_fatal);
}
-void DsanOnDeadlySignal(int signo, void *siginfo, void *context) {
+void DsanOnDeadlySignal(int signo, void* siginfo, void* context) {
HandleDeadlySignal(siginfo, context, GetCurrentThreadId(), &OnStackUnwind,
nullptr);
}
diff --git a/compiler-rt/lib/dsan/dsan_posix.h
b/compiler-rt/lib/dsan/dsan_posix.h
index 314a0eb5d..03b804704 100644
--- a/compiler-rt/lib/dsan/dsan_posix.h
+++ b/compiler-rt/lib/dsan/dsan_posix.h
@@ -18,7 +18,7 @@
#include "sanitizer_common/sanitizer_platform.h"
#if !SANITIZER_POSIX
-#error "dsan_posix.h is used only on POSIX-like systems (SANITIZER_POSIX)"
+# error "dsan_posix.h is used only on POSIX-like systems (SANITIZER_POSIX)"
#endif
namespace __sanitizer {
@@ -30,15 +30,15 @@ namespace __dsan {
class ThreadContext final : public ThreadContextDsanBase {
public:
explicit ThreadContext(int tid);
- void OnStarted(void *arg) override;
+ void OnStarted(void* arg) override;
uptr tls_begin() { return tls_begin_; }
uptr tls_end() { return tls_end_; }
- DTLS *dtls() { return dtls_; }
+ DTLS* dtls() { return dtls_; }
private:
uptr tls_begin_ = 0;
uptr tls_end_ = 0;
- DTLS *dtls_ = nullptr;
+ DTLS* dtls_ = nullptr;
};
void ThreadStart(u32 tid, ThreadID os_id,
diff --git a/compiler-rt/lib/dsan/dsan_thread.cpp
b/compiler-rt/lib/dsan/dsan_thread.cpp
index 5f824e933..617c1c998 100644
--- a/compiler-rt/lib/dsan/dsan_thread.cpp
+++ b/compiler-rt/lib/dsan/dsan_thread.cpp
@@ -24,13 +24,13 @@
namespace __dsan {
-static ThreadRegistry *thread_registry;
-static ThreadArgRetval *thread_arg_retval;
+static ThreadRegistry* thread_registry;
+static ThreadArgRetval* thread_arg_retval;
static Mutex mu_for_thread_context;
static LowLevelAllocator allocator_for_thread_context;
-static ThreadContextBase *CreateThreadContext(u32 tid) {
+static ThreadContextBase* CreateThreadContext(u32 tid) {
Lock lock(&mu_for_thread_context);
return new (allocator_for_thread_context) ThreadContext(tid);
}
@@ -46,12 +46,12 @@ void InitializeThreads() {
thread_arg_retval = new (thread_arg_retval_placeholder) ThreadArgRetval();
}
-ThreadArgRetval &GetThreadArgRetval() { return *thread_arg_retval; }
+ThreadArgRetval& GetThreadArgRetval() { return *thread_arg_retval; }
ThreadContextDsanBase::ThreadContextDsanBase(int tid)
: ThreadContextBase(tid) {}
-void ThreadContextDsanBase::OnStarted(void *arg) {
+void ThreadContextDsanBase::OnStarted(void* arg) {
SetCurrentThread(this);
AllocatorThreadStart();
}
@@ -62,12 +62,12 @@ void ThreadContextDsanBase::OnFinished() {
SetCurrentThread(nullptr);
}
-u32 ThreadCreate(u32 parent_tid, bool detached, void *arg) {
+u32 ThreadCreate(u32 parent_tid, bool detached, void* arg) {
return thread_registry->CreateThread(0, detached, parent_tid, arg);
}
void ThreadContextDsanBase::ThreadStart(u32 tid, ThreadID os_id,
- ThreadType thread_type, void *arg) {
+ ThreadType thread_type, void* arg) {
thread_registry->StartThread(tid, os_id, thread_type, arg);
}
@@ -81,8 +81,8 @@ void EnsureMainThreadIDIsCorrect() {
///// Interface to the common DSan module. /////
void GetThreadExtraStackRangesLocked(ThreadID os_id,
- InternalMmapVector<Range> *ranges) {}
-void GetThreadExtraStackRangesLocked(InternalMmapVector<Range> *ranges) {}
+ InternalMmapVector<Range>* ranges) {}
+void GetThreadExtraStackRangesLocked(InternalMmapVector<Range>* ranges) {}
void LockThreads() {
thread_registry->Lock();
@@ -94,16 +94,16 @@ void UnlockThreads() {
thread_registry->Unlock();
}
-ThreadRegistry *GetDsanThreadRegistryLocked() {
+ThreadRegistry* GetDsanThreadRegistryLocked() {
thread_registry->CheckLocked();
return thread_registry;
}
-void GetRunningThreadsLocked(InternalMmapVector<ThreadID> *threads) {
+void GetRunningThreadsLocked(InternalMmapVector<ThreadID>* threads) {
GetDsanThreadRegistryLocked()->RunCallbackForEachThreadLocked(
- [](ThreadContextBase *tctx, void *threads) {
+ [](ThreadContextBase* tctx, void* threads) {
if (tctx->status == ThreadStatusRunning) {
- reinterpret_cast<InternalMmapVector<ThreadID> *>(threads)->push_back(
+ reinterpret_cast<InternalMmapVector<ThreadID>*>(threads)->push_back(
tctx->os_id);
}
},
@@ -116,7 +116,7 @@ void PrintThreads() {
Report("%s\n", out.data());
}
-void GetAdditionalThreadContextPtrsLocked(InternalMmapVector<uptr> *ptrs) {
+void GetAdditionalThreadContextPtrsLocked(InternalMmapVector<uptr>* ptrs) {
GetThreadArgRetval().GetAllPtrsLocked(ptrs);
}
diff --git a/compiler-rt/lib/dsan/dsan_thread.h
b/compiler-rt/lib/dsan/dsan_thread.h
index 2c4f80d0e..4e252bfc3 100644
--- a/compiler-rt/lib/dsan/dsan_thread.h
+++ b/compiler-rt/lib/dsan/dsan_thread.h
@@ -22,7 +22,7 @@ namespace __dsan {
class ThreadContextDsanBase : public ThreadContextBase {
public:
explicit ThreadContextDsanBase(int tid);
- void OnStarted(void *arg) override;
+ void OnStarted(void* arg) override;
void OnFinished() override;
uptr stack_begin() { return stack_begin_; }
uptr stack_end() { return stack_end_; }
@@ -31,7 +31,7 @@ class ThreadContextDsanBase : public ThreadContextBase {
// The argument is passed on to the subclass's OnStarted member function.
static void ThreadStart(u32 tid, ThreadID os_id, ThreadType thread_type,
- void *onstarted_arg);
+ void* onstarted_arg);
protected:
~ThreadContextDsanBase() {}
@@ -47,18 +47,18 @@ class ThreadContext;
void InitializeThreads();
void InitializeMainThread();
-ThreadRegistry *GetDsanThreadRegistryLocked();
-ThreadArgRetval &GetThreadArgRetval();
+ThreadRegistry* GetDsanThreadRegistryLocked();
+ThreadArgRetval& GetThreadArgRetval();
-u32 ThreadCreate(u32 tid, bool detached, void *arg = nullptr);
+u32 ThreadCreate(u32 tid, bool detached, void* arg = nullptr);
void ThreadFinish();
-ThreadContextDsanBase *GetCurrentThread();
+ThreadContextDsanBase* GetCurrentThread();
inline u32 GetCurrentThreadId() {
- ThreadContextDsanBase *ctx = GetCurrentThread();
+ ThreadContextDsanBase* ctx = GetCurrentThread();
return ctx ? ctx->tid : kInvalidTid;
}
-void SetCurrentThread(ThreadContextDsanBase *tctx);
+void SetCurrentThread(ThreadContextDsanBase* tctx);
void EnsureMainThreadIDIsCorrect();
} // namespace __dsan
``````````
</details>
https://github.com/llvm/llvm-project/pull/213846
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
