[compiler-rt] [NFC][TSan] Check IsFiredSuppression before ScopedReport in ReportErrnoSpoiling (PR #228811)
Vitaly Buka via llvm-commits
llvm-commits at lists.llvm.org
Mon Oct 5 23:23:13 PDT 2026
https://github.com/vitalybuka updated https://github.com/llvm/llvm-project/pull/228811
>From 504e1b64c76bc6c9c02132dafefb90c98af57daa Mon Sep 17 00:00:00 2001
From: Vitaly Buka <vitalybuka at google.com>
Date: Sat, 3 Oct 2026 20:14:27 -0700
Subject: [PATCH] =?UTF-8?q?[=F0=9D=98=80=F0=9D=97=BD=F0=9D=97=BF]=20change?=
=?UTF-8?q?s=20to=20main=20this=20commit=20is=20based=20on?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Created using spr 1.3.7
[skip ci]
---
.../lib/tsan/rtl/tsan_interceptors_posix.cpp | 13 +---
.../lib/tsan/rtl/tsan_interface_ann.cpp | 17 ++---
compiler-rt/lib/tsan/rtl/tsan_mman.cpp | 11 +--
compiler-rt/lib/tsan/rtl/tsan_report.cpp | 22 ++----
compiler-rt/lib/tsan/rtl/tsan_report.h | 64 +++++++++-------
compiler-rt/lib/tsan/rtl/tsan_rtl.cpp | 4 +-
compiler-rt/lib/tsan/rtl/tsan_rtl_mutex.cpp | 61 ++++++---------
compiler-rt/lib/tsan/rtl/tsan_rtl_report.cpp | 75 +++++++++++--------
compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cpp | 13 +---
9 files changed, 126 insertions(+), 154 deletions(-)
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp b/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp
index b2ba666741e89..233985c419be1 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp
+++ b/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp
@@ -2176,24 +2176,19 @@ static void ReportErrnoSpoiling(ThreadState *thr, uptr pc, int sig) {
// StackTrace::GetNestInstructionPc(pc) is used because return address is
// expected, OutputReport() will undo this.
ObtainCurrentStack(thr, StackTrace::GetNextInstructionPc(pc), &stack);
- // Use alloca, because malloc during signal handling deadlocks
- ScopedReport *rep = (ScopedReport *)__builtin_alloca(sizeof(ScopedReport));
+ ScopedReport rep(ReportTypeErrnoInSignal);
bool suppressed;
// Release locks before symbolizing and outputting the report to avoid
// deadlocks.
{
ThreadRegistryLock l(&ctx->thread_registry);
- new (rep) ScopedReport(ReportTypeErrnoInSignal);
- rep->SetSigNum(sig);
+ rep.SetSigNum(sig);
suppressed = IsFiredSuppression(ctx, ReportTypeErrnoInSignal, stack);
if (!suppressed)
- rep->AddStack(stack, true);
+ rep.AddStack(stack, true);
}
if (!suppressed)
- OutputReport(thr, *rep);
-
- // Need to manually destroy this because we used placement new to allocate
- rep->~ScopedReport();
+ OutputReport(thr, rep);
}
static void CallUserSignalHandler(ThreadState *thr, bool sync, bool acquire,
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interface_ann.cpp b/compiler-rt/lib/tsan/rtl/tsan_interface_ann.cpp
index 526dc5a753c24..11311ce8e901f 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_interface_ann.cpp
+++ b/compiler-rt/lib/tsan/rtl/tsan_interface_ann.cpp
@@ -441,25 +441,20 @@ void __tsan_mutex_post_divert(void *addr, unsigned flagz) {
}
static void ReportMutexHeldWrongContext(ThreadState *thr, uptr pc) {
- // Use alloca, because malloc during signal handling deadlocks
- ScopedReport *rep = (ScopedReport *)__builtin_alloca(sizeof(ScopedReport));
+ VarSizeStackTrace trace;
+ ObtainCurrentStack(thr, pc, &trace);
+ ScopedReport rep(ReportTypeMutexHeldWrongContext);
// Release locks before symbolizing and outputting the report to avoid
// deadlocks.
{
ThreadRegistryLock l(&ctx->thread_registry);
- new (rep) ScopedReport(ReportTypeMutexHeldWrongContext);
for (uptr i = 0; i < thr->mset.Size(); ++i) {
MutexSet::Desc desc = thr->mset.Get(i);
- rep->AddMutex(desc.addr, desc.stack_id);
+ rep.AddMutex(desc.addr, desc.stack_id);
}
- VarSizeStackTrace trace;
- ObtainCurrentStack(thr, pc, &trace);
- rep->AddStack(trace, true);
+ rep.AddStack(trace, true);
}
- OutputReport(thr, *rep);
-
- // Need to manually destroy this because we used placement new to allocate
- rep->~ScopedReport();
+ OutputReport(thr, rep);
}
INTERFACE_ATTRIBUTE
diff --git a/compiler-rt/lib/tsan/rtl/tsan_mman.cpp b/compiler-rt/lib/tsan/rtl/tsan_mman.cpp
index cea833054551d..7a39b8a71a0a7 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_mman.cpp
+++ b/compiler-rt/lib/tsan/rtl/tsan_mman.cpp
@@ -182,19 +182,14 @@ static void SignalUnsafeCall(ThreadState *thr, uptr pc) {
ObtainCurrentStack(thr, pc, &stack);
if (IsFiredSuppression(ctx, ReportTypeSignalUnsafe, stack))
return;
- // Use alloca, because malloc during signal handling deadlocks
- ScopedReport *rep = (ScopedReport *)__builtin_alloca(sizeof(ScopedReport));
+ ScopedReport rep(ReportTypeSignalUnsafe);
// Release locks before symbolizing and outputting the report to avoid
// deadlocks.
{
ThreadRegistryLock l(&ctx->thread_registry);
- new (rep) ScopedReport(ReportTypeSignalUnsafe);
- rep->AddStack(stack, true);
+ rep.AddStack(stack, true);
}
- OutputReport(thr, *rep);
-
- // Need to manually destroy this because we used placement new to allocate
- rep->~ScopedReport();
+ OutputReport(thr, rep);
}
diff --git a/compiler-rt/lib/tsan/rtl/tsan_report.cpp b/compiler-rt/lib/tsan/rtl/tsan_report.cpp
index 17fd3064fb85a..ca04f9e1faf07 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_report.cpp
+++ b/compiler-rt/lib/tsan/rtl/tsan_report.cpp
@@ -29,25 +29,13 @@ class Decorator: public __sanitizer::SanitizerCommonDecorator {
const char *Mutex() { return Magenta(); }
};
-ReportDesc::ReportDesc()
- : tag(kExternalTagNone)
- , stacks()
- , mops()
- , locs()
- , mutexes()
- , threads()
- , unique_tids()
- , sleep()
- , count() {
-}
+ReportDesc::ReportDesc() = default;
-ReportMop::ReportMop()
- : mset() {
-}
+ReportMop::ReportMop() = default;
+ReportMop::~ReportMop() = default;
-ReportDesc::~ReportDesc() {
- // FIXME(dvyukov): it must be leaking a lot of memory.
-}
+// FIXME(dvyukov): it must be leaking a lot of memory.
+ReportDesc::~ReportDesc() = default;
#if !SANITIZER_GO
diff --git a/compiler-rt/lib/tsan/rtl/tsan_report.h b/compiler-rt/lib/tsan/rtl/tsan_report.h
index 53bb21964dbba..13171aa270684 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_report.h
+++ b/compiler-rt/lib/tsan/rtl/tsan_report.h
@@ -46,22 +46,23 @@ struct ReportStack {
};
struct ReportMopMutex {
- int id;
- bool write;
+ int id = 0;
+ bool write = false;
};
struct ReportMop {
- int tid;
- uptr addr;
- int size;
- bool write;
- bool atomic;
- uptr external_tag;
+ int tid = kInvalidTid;
+ uptr addr = 0;
+ int size = 0;
+ bool write = false;
+ bool atomic = false;
+ uptr external_tag = 0;
Vector<ReportMopMutex> mset;
StackTrace stack_trace;
- ReportStack *stack;
+ ReportStack* stack = nullptr;
ReportMop();
+ ~ReportMop();
};
enum ReportLocationType {
@@ -87,42 +88,49 @@ struct ReportLocation {
};
struct ReportThread {
- Tid id;
- ThreadID os_id;
- bool running;
- ThreadType thread_type;
- char *name;
- Tid parent_tid;
- StackID stack_id;
- ReportStack *stack;
- bool suppressable;
+ Tid id = kInvalidTid;
+ ThreadID os_id = 0;
+ bool running = false;
+ ThreadType thread_type = ThreadType::Regular;
+ char* name = nullptr;
+ Tid parent_tid = kInvalidTid;
+ StackID stack_id = 0;
+ ReportStack* stack = nullptr;
+ bool suppressable = false;
};
struct ReportMutex {
- int id;
- uptr addr;
- StackID stack_id;
- ReportStack *stack;
+ int id = 0;
+ uptr addr = 0;
+ StackID stack_id = 0;
+ ReportStack* stack = nullptr;
};
struct AddedLocationAddr {
- uptr addr;
- usize locs_idx;
+ uptr addr = 0;
+ usize locs_idx = 0;
+};
+
+struct AddedStack {
+ StackTrace stack_trace;
+ bool suppressable = false;
};
class ReportDesc {
public:
- ReportType typ;
- uptr tag;
+ ReportType typ = ReportTypeRace;
+ uptr tag = kExternalTagNone;
Vector<ReportStack*> stacks;
+ Vector<AddedStack> added_stacks;
Vector<ReportMop*> mops;
Vector<ReportLocation*> locs;
Vector<AddedLocationAddr> added_location_addrs;
Vector<ReportMutex*> mutexes;
Vector<ReportThread*> threads;
Vector<Tid> unique_tids;
- ReportStack *sleep;
- int count;
+ ReportStack* sleep = nullptr;
+ StackID sleep_stack_id = 0;
+ int count = 0;
int signum = 0;
ReportDesc();
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl.cpp b/compiler-rt/lib/tsan/rtl/tsan_rtl.cpp
index c6e7dce5ecb18..7328caab0a918 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_rtl.cpp
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl.cpp
@@ -841,10 +841,10 @@ void ForkBefore(ThreadState* thr, uptr pc) SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
// Detaching from the slot makes OnUserFree skip writing to the shadow.
// The slot will be locked so any attempts to use it will deadlock anyway.
SlotDetach(thr);
+ ScopedErrorReportLock::Lock();
for (auto& slot : ctx->slots) slot.mtx.Lock();
ctx->thread_registry.Lock();
ctx->slot_mtx.Lock();
- ScopedErrorReportLock::Lock();
AllocatorLockBeforeFork();
// Suppress all reports in the pthread_atfork callbacks.
// Reports may deadlock.
@@ -871,10 +871,10 @@ static void ForkAfter(ThreadState* thr,
thr->ignore_interceptors--;
thr->ignore_reads_and_writes--;
AllocatorUnlockAfterFork(child);
- ScopedErrorReportLock::Unlock();
ctx->slot_mtx.Unlock();
ctx->thread_registry.Unlock();
for (auto& slot : ctx->slots) slot.mtx.Unlock();
+ ScopedErrorReportLock::Unlock();
SlotAttachAndLock(thr);
SlotUnlock(thr);
GlobalProcessorUnlock();
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl_mutex.cpp b/compiler-rt/lib/tsan/rtl/tsan_rtl_mutex.cpp
index 271412f4c4088..8ae9c1f4b20e9 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_rtl_mutex.cpp
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl_mutex.cpp
@@ -11,7 +11,6 @@
//===----------------------------------------------------------------------===//
#include <sanitizer_common/sanitizer_deadlock_detector_interface.h>
-#include <sanitizer_common/sanitizer_placement_new.h>
#include <sanitizer_common/sanitizer_stackdepot.h>
#include "tsan_flags.h"
@@ -56,23 +55,18 @@ static void ReportMutexMisuse(ThreadState *thr, uptr pc, ReportType typ,
return;
if (!ShouldReport(thr, typ))
return;
- // Use alloca, because malloc during signal handling deadlocks
- ScopedReport *rep = (ScopedReport *)__builtin_alloca(sizeof(ScopedReport));
+ VarSizeStackTrace trace;
+ ObtainCurrentStack(thr, pc, &trace);
+ ScopedReport rep(typ);
// Release locks before symbolizing and outputting the report to avoid
// deadlocks.
{
ThreadRegistryLock l(&ctx->thread_registry);
- new (rep) ScopedReport(typ);
- rep->AddMutex(addr, creation_stack_id);
- VarSizeStackTrace trace;
- ObtainCurrentStack(thr, pc, &trace);
- rep->AddStack(trace, true);
- rep->AddLocation(addr, 1);
+ rep.AddMutex(addr, creation_stack_id);
+ rep.AddStack(trace, true);
+ rep.AddLocation(addr, 1);
}
- OutputReport(thr, *rep);
-
- // Need to manually destroy this because we used placement new to allocate
- rep->~ScopedReport();
+ OutputReport(thr, rep);
}
static void RecordMutexLock(ThreadState *thr, uptr pc, uptr addr,
@@ -538,19 +532,17 @@ void AfterSleep(ThreadState *thr, uptr pc) {
void ReportDeadlock(ThreadState *thr, uptr pc, DDReport *r) {
if (r == 0 || !ShouldReport(thr, ReportTypeDeadlock))
return;
- // Use alloca, because malloc during signal handling deadlocks
- ScopedReport *rep = (ScopedReport *)__builtin_alloca(sizeof(ScopedReport));
+ uptr dummy_pc = 0x42;
+ ScopedReport rep(ReportTypeDeadlock);
// Release locks before symbolizing and outputting the report to avoid
// deadlocks.
{
ThreadRegistryLock l(&ctx->thread_registry);
- new (rep) ScopedReport(ReportTypeDeadlock);
for (int i = 0; i < r->n; i++) {
- rep->AddMutex(r->loop[i].mtx_ctx0, r->loop[i].stk[0]);
- rep->AddUniqueTid((int)r->loop[i].thr_ctx);
- rep->AddThread((int)r->loop[i].thr_ctx);
+ rep.AddMutex(r->loop[i].mtx_ctx0, r->loop[i].stk[0]);
+ rep.AddUniqueTid((int)r->loop[i].thr_ctx);
+ rep.AddThread((int)r->loop[i].thr_ctx);
}
- uptr dummy_pc = 0x42;
for (int i = 0; i < r->n; i++) {
for (int j = 0; j < (flags()->second_deadlock_stack ? 2 : 1); j++) {
u32 stk = r->loop[i].stk[j];
@@ -562,14 +554,11 @@ void ReportDeadlock(ThreadState *thr, uptr pc, DDReport *r) {
// but we should still produce some stack trace in the report.
stack = StackTrace(&dummy_pc, 1);
}
- rep->AddStack(stack, true);
+ rep.AddStack(stack, true);
}
}
}
- OutputReport(thr, *rep);
-
- // Need to manually destroy this because we used placement new to allocate
- rep->~ScopedReport();
+ OutputReport(thr, rep);
}
void ReportDestroyLocked(ThreadState *thr, uptr pc, uptr addr,
@@ -590,24 +579,20 @@ void ReportDestroyLocked(ThreadState *thr, uptr pc, uptr addr,
return;
}
- // Use alloca, because malloc during signal handling deadlocks
- ScopedReport* rep = (ScopedReport*)__builtin_alloca(sizeof(ScopedReport));
+ VarSizeStackTrace trace;
+ ObtainCurrentStack(thr, pc, &trace);
+
+ ScopedReport rep(ReportTypeMutexDestroyLocked);
// Release locks before symbolizing and outputting the report to avoid
// deadlocks.
{
ThreadRegistryLock l0(&ctx->thread_registry);
- new (rep) ScopedReport(ReportTypeMutexDestroyLocked);
- rep->AddMutex(addr, creation_stack_id);
- VarSizeStackTrace trace;
- ObtainCurrentStack(thr, pc, &trace);
- rep->AddStack(trace, true);
- rep->AddStack(last_lock_stack, true);
- rep->AddLocation(addr, 1);
+ rep.AddMutex(addr, creation_stack_id);
+ rep.AddStack(trace, true);
+ rep.AddStack(last_lock_stack, true);
+ rep.AddLocation(addr, 1);
}
- OutputReport(thr, *rep);
-
- // Need to manually destroy this because we used placement new to allocate
- rep->~ScopedReport();
+ OutputReport(thr, rep);
}
} // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl_report.cpp b/compiler-rt/lib/tsan/rtl/tsan_rtl_report.cpp
index be444eec3a4b7..5644456bb2864 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_rtl_report.cpp
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl_report.cpp
@@ -164,7 +164,7 @@ bool ShouldReport(ThreadState *thr, ReportType typ) {
}
ScopedReport::ScopedReport(ReportType typ, uptr tag) {
- ctx->thread_registry.CheckLocked();
+ CheckedMutex::CheckNoLocks();
rep_ = New<ReportDesc>();
rep_->typ = typ;
rep_->tag = tag;
@@ -173,9 +173,7 @@ ScopedReport::ScopedReport(ReportType typ, uptr tag) {
ScopedReport::~ScopedReport() { DestroyAndFree(rep_); }
void ScopedReport::AddStack(StackTrace stack, bool suppressable) {
- ReportStack **rs = rep_->stacks.PushBack();
- *rs = SymbolizeStack(stack);
- (*rs)->suppressable = suppressable;
+ rep_->added_stacks.PushBack({stack, suppressable});
}
void ScopedReport::AddMemoryAccess(uptr addr, uptr external_tag, Shadow s,
@@ -202,6 +200,15 @@ void ScopedReport::AddMemoryAccess(uptr addr, uptr external_tag, Shadow s,
}
void ScopedReport::SymbolizeStackElems() {
+ // symbolize stacks
+ for (usize i = 0, size = rep_->added_stacks.Size(); i < size; i++) {
+ AddedStack& as = rep_->added_stacks[i];
+ ReportStack* rs = SymbolizeStack(as.stack_trace);
+ if (rs)
+ rs->suppressable = as.suppressable;
+ rep_->stacks.PushBack(rs);
+ }
+
// symbolize memory ops
for (usize i = 0, size = rep_->mops.Size(); i < size; i++) {
ReportMop *mop = rep_->mops[i];
@@ -249,6 +256,10 @@ void ScopedReport::SymbolizeStackElems() {
ReportMutex *rm = rep_->mutexes[i];
rm->stack = SymbolizeStackId(rm->stack_id);
}
+
+#if !SANITIZER_GO
+ rep_->sleep = SymbolizeStackId(rep_->sleep_stack_id);
+#endif
}
void ScopedReport::AddUniqueTid(Tid unique_tid) {
@@ -256,6 +267,7 @@ void ScopedReport::AddUniqueTid(Tid unique_tid) {
}
void ScopedReport::AddThread(const ThreadContext* tctx, bool suppressable) {
+ ctx->thread_registry.CheckLocked();
for (uptr i = 0; i < rep_->threads.Size(); i++) {
if ((u32)rep_->threads[i]->id == tctx->tid)
return;
@@ -380,7 +392,7 @@ void ScopedReport::AddLocation(uptr addr, uptr size) {
#if !SANITIZER_GO
void ScopedReport::AddSleep(StackID stack_id) {
- rep_->sleep = SymbolizeStackId(stack_id);
+ rep_->sleep_stack_id = stack_id;
}
#endif
@@ -671,6 +683,7 @@ static bool HandleRacyStacks(ThreadState *thr, VarSizeStackTrace traces[2]) {
}
bool OutputReport(ThreadState *thr, ScopedReport &srep) {
+ CheckedMutex::CheckNoLocks();
// These should have been checked in ShouldReport.
// It's too late to check them here, we have already taken locks.
CHECK(flags()->report_bugs);
@@ -804,10 +817,6 @@ void ReportRace(ThreadState *thr, RawShadow *shadow_mem, Shadow cur, Shadow old,
DynamicMutexSet mset1;
MutexSet *mset[kMop] = {&thr->mset, mset1};
- // Use alloca, because malloc during signal handling deadlocks
- ScopedReport *rep = (ScopedReport *)__builtin_alloca(sizeof(ScopedReport));
- // Release locks before symbolizing and outputting the report to avoid
- // deadlocks.
{
// We need to lock the slot during RestoreStack because it protects
// the slot journal.
@@ -821,57 +830,59 @@ void ReportRace(ThreadState *thr, RawShadow *shadow_mem, Shadow cur, Shadow old,
StoreShadow(&ctx->last_spurious_race, old.raw());
return;
}
+ }
- if (IsFiredSuppression(ctx, rep_typ, traces[1]))
- return;
+ if (IsFiredSuppression(ctx, rep_typ, traces[1]))
+ return;
- if (HandleRacyStacks(thr, traces))
- return;
+ if (HandleRacyStacks(thr, traces))
+ return;
- // If any of the accesses has a tag, treat this as an "external" race.
- uptr tag = kExternalTagNone;
- for (uptr i = 0; i < kMop; i++) {
- if (tags[i] != kExternalTagNone) {
- rep_typ = ReportTypeExternalRace;
- tag = tags[i];
- break;
- }
+ // If any of the accesses has a tag, treat this as an "external" race.
+ uptr tag = kExternalTagNone;
+ for (uptr i = 0; i < kMop; i++) {
+ if (tags[i] != kExternalTagNone) {
+ rep_typ = ReportTypeExternalRace;
+ tag = tags[i];
+ break;
}
+ }
- new (rep) ScopedReport(rep_typ, tag);
+ ScopedReport rep(rep_typ, tag);
+ // Release locks before symbolizing and outputting the report to avoid
+ // deadlocks.
+ {
+ ThreadRegistryLock l0(&ctx->thread_registry);
for (uptr i = 0; i < kMop; i++)
- rep->AddMemoryAccess(addr, tags[i], s[i], tids[i], traces[i], mset[i]);
+ rep.AddMemoryAccess(addr, tags[i], s[i], tids[i], traces[i], mset[i]);
for (uptr i = 0; i < kMop; i++) {
ThreadContext *tctx = static_cast<ThreadContext *>(
ctx->thread_registry.GetThreadLocked(tids[i]));
- rep->AddThread(tctx);
+ rep.AddThread(tctx);
}
- rep->AddLocation(addr_min, addr_max - addr_min);
+ rep.AddLocation(addr_min, addr_max - addr_min);
if (flags()->print_full_thread_history) {
- const ReportDesc *rep_desc = rep->GetReport();
+ const ReportDesc* rep_desc = rep.GetReport();
for (uptr i = 0; i < rep_desc->threads.Size(); i++) {
Tid parent_tid = rep_desc->threads[i]->parent_tid;
if (parent_tid == kMainTid || parent_tid == kInvalidTid)
continue;
ThreadContext *parent_tctx = static_cast<ThreadContext *>(
ctx->thread_registry.GetThreadLocked(parent_tid));
- rep->AddThread(parent_tctx);
+ rep.AddThread(parent_tctx);
}
}
#if !SANITIZER_GO
if (!((typ0 | typ1) & kAccessFree) &&
s[1].epoch() <= thr->last_sleep_clock.Get(s[1].sid()))
- rep->AddSleep(thr->last_sleep_stack_id);
+ rep.AddSleep(thr->last_sleep_stack_id);
#endif
}
- OutputReport(thr, *rep);
-
- // Need to manually destroy this because we used placement new to allocate
- rep->~ScopedReport();
+ OutputReport(thr, rep);
}
void PrintCurrentStack(ThreadState *thr, uptr pc) {
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cpp b/compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cpp
index afc6b8d4a0b1c..5edf0c16fdd0d 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cpp
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cpp
@@ -96,20 +96,15 @@ void ThreadFinalize(ThreadState *thr) {
}
for (uptr i = 0; i < leaks.Size(); i++) {
- // Use alloca, because malloc during signal handling deadlocks
- ScopedReport *rep = (ScopedReport *)__builtin_alloca(sizeof(ScopedReport));
+ ScopedReport rep(ReportTypeThreadLeak);
// Release locks before symbolizing and outputting the report to avoid
// deadlocks.
{
ThreadRegistryLock l(&ctx->thread_registry);
- new (rep) ScopedReport(ReportTypeThreadLeak);
- rep->AddThread(leaks[i].tctx, true);
- rep->SetCount(leaks[i].count);
+ rep.AddThread(leaks[i].tctx, true);
+ rep.SetCount(leaks[i].count);
}
- OutputReport(thr, *rep);
-
- // Need to manually destroy this because we used placement new to allocate
- rep->~ScopedReport();
+ OutputReport(thr, rep);
}
#endif
}
More information about the llvm-commits
mailing list