motiejus/zig
1
Fork 0
Code Releases Activity

tsan: update rtl files to LLVM 17.0.6

Browse Source
This commit is contained in:
Andrew Kelley
2024-01-10 00:59:52 -07:00
parent 036e9fd479
commit 854b88fda0
213 changed files with 15760 additions and 9960 deletions
Download Patch File Download Diff File Expand all files Collapse all files

284
lib/tsan/tsan_interface_java.cpp vendored
View File

@@ -34,52 +34,49 @@ struct JavaContext {
}
};
class ScopedJavaFunc {
public:
ScopedJavaFunc(ThreadState *thr, uptr pc)
: thr_(thr) {
Initialize(thr_);
FuncEntry(thr, pc);
}
~ScopedJavaFunc() {
FuncExit(thr_);
// FIXME(dvyukov): process pending signals.
}
private:
ThreadState *thr_;
};
static u64 jctx_buf[sizeof(JavaContext) / sizeof(u64) + 1];
static JavaContext *jctx;
MBlock *JavaHeapBlock(uptr addr, uptr *start) {
if (!jctx || addr < jctx->heap_begin ||
addr >= jctx->heap_begin + jctx->heap_size)
return nullptr;
for (uptr p = RoundDown(addr, kMetaShadowCell); p >= jctx->heap_begin;
p -= kMetaShadowCell) {
MBlock *b = ctx->metamap.GetBlock(p);
if (!b)
continue;
if (p + b->siz <= addr)
return nullptr;
*start = p;
return b;
}
return nullptr;
}
} // namespace __tsan
#define SCOPED_JAVA_FUNC(func) \
#define JAVA_FUNC_ENTER(func) \
ThreadState *thr = cur_thread(); \
const uptr caller_pc = GET_CALLER_PC(); \
const uptr pc = StackTrace::GetCurrentPc(); \
(void)pc; \
ScopedJavaFunc scoped(thr, caller_pc); \
/**/
(void)thr;
void __tsan_java_init(jptr heap_begin, jptr heap_size) {
SCOPED_JAVA_FUNC(__tsan_java_init);
DPrintf("#%d: java_init(%p, %p)\n", thr->tid, heap_begin, heap_size);
CHECK_EQ(jctx, 0);
CHECK_GT(heap_begin, 0);
CHECK_GT(heap_size, 0);
CHECK_EQ(heap_begin % kHeapAlignment, 0);
CHECK_EQ(heap_size % kHeapAlignment, 0);
CHECK_LT(heap_begin, heap_begin + heap_size);
JAVA_FUNC_ENTER(__tsan_java_init);
Initialize(thr);
DPrintf("#%d: java_init(0x%zx, 0x%zx)\n", thr->tid, heap_begin, heap_size);
DCHECK_EQ(jctx, 0);
DCHECK_GT(heap_begin, 0);
DCHECK_GT(heap_size, 0);
DCHECK_EQ(heap_begin % kHeapAlignment, 0);
DCHECK_EQ(heap_size % kHeapAlignment, 0);
DCHECK_LT(heap_begin, heap_begin + heap_size);
jctx = new(jctx_buf) JavaContext(heap_begin, heap_size);
}
int __tsan_java_fini() {
SCOPED_JAVA_FUNC(__tsan_java_fini);
JAVA_FUNC_ENTER(__tsan_java_fini);
DPrintf("#%d: java_fini()\n", thr->tid);
CHECK_NE(jctx, 0);
DCHECK_NE(jctx, 0);
// FIXME(dvyukov): this does not call atexit() callbacks.
int status = Finalize(thr);
DPrintf("#%d: java_fini() = %d\n", thr->tid, status);
@@ -87,74 +84,65 @@ int __tsan_java_fini() {
}
void __tsan_java_alloc(jptr ptr, jptr size) {
SCOPED_JAVA_FUNC(__tsan_java_alloc);
DPrintf("#%d: java_alloc(%p, %p)\n", thr->tid, ptr, size);
CHECK_NE(jctx, 0);
CHECK_NE(size, 0);
CHECK_EQ(ptr % kHeapAlignment, 0);
CHECK_EQ(size % kHeapAlignment, 0);
CHECK_GE(ptr, jctx->heap_begin);
CHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_alloc);
DPrintf("#%d: java_alloc(0x%zx, 0x%zx)\n", thr->tid, ptr, size);
DCHECK_NE(jctx, 0);
DCHECK_NE(size, 0);
DCHECK_EQ(ptr % kHeapAlignment, 0);
DCHECK_EQ(size % kHeapAlignment, 0);
DCHECK_GE(ptr, jctx->heap_begin);
DCHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
OnUserAlloc(thr, pc, ptr, size, false);
OnUserAlloc(thr, 0, ptr, size, false);
}
void __tsan_java_free(jptr ptr, jptr size) {
SCOPED_JAVA_FUNC(__tsan_java_free);
DPrintf("#%d: java_free(%p, %p)\n", thr->tid, ptr, size);
CHECK_NE(jctx, 0);
CHECK_NE(size, 0);
CHECK_EQ(ptr % kHeapAlignment, 0);
CHECK_EQ(size % kHeapAlignment, 0);
CHECK_GE(ptr, jctx->heap_begin);
CHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_free);
DPrintf("#%d: java_free(0x%zx, 0x%zx)\n", thr->tid, ptr, size);
DCHECK_NE(jctx, 0);
DCHECK_NE(size, 0);
DCHECK_EQ(ptr % kHeapAlignment, 0);
DCHECK_EQ(size % kHeapAlignment, 0);
DCHECK_GE(ptr, jctx->heap_begin);
DCHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
ctx->metamap.FreeRange(thr->proc(), ptr, size);
ctx->metamap.FreeRange(thr->proc(), ptr, size, false);
}
void __tsan_java_move(jptr src, jptr dst, jptr size) {
SCOPED_JAVA_FUNC(__tsan_java_move);
DPrintf("#%d: java_move(%p, %p, %p)\n", thr->tid, src, dst, size);
CHECK_NE(jctx, 0);
CHECK_NE(size, 0);
CHECK_EQ(src % kHeapAlignment, 0);
CHECK_EQ(dst % kHeapAlignment, 0);
CHECK_EQ(size % kHeapAlignment, 0);
CHECK_GE(src, jctx->heap_begin);
CHECK_LE(src + size, jctx->heap_begin + jctx->heap_size);
CHECK_GE(dst, jctx->heap_begin);
CHECK_LE(dst + size, jctx->heap_begin + jctx->heap_size);
CHECK_NE(dst, src);
CHECK_NE(size, 0);
JAVA_FUNC_ENTER(__tsan_java_move);
DPrintf("#%d: java_move(0x%zx, 0x%zx, 0x%zx)\n", thr->tid, src, dst, size);
DCHECK_NE(jctx, 0);
DCHECK_NE(size, 0);
DCHECK_EQ(src % kHeapAlignment, 0);
DCHECK_EQ(dst % kHeapAlignment, 0);
DCHECK_EQ(size % kHeapAlignment, 0);
DCHECK_GE(src, jctx->heap_begin);
DCHECK_LE(src + size, jctx->heap_begin + jctx->heap_size);
DCHECK_GE(dst, jctx->heap_begin);
DCHECK_LE(dst + size, jctx->heap_begin + jctx->heap_size);
DCHECK_NE(dst, src);
DCHECK_NE(size, 0);
// Assuming it's not running concurrently with threads that do
// memory accesses and mutex operations (stop-the-world phase).
ctx->metamap.MoveMemory(src, dst, size);
// Move shadow.
u64 *s = (u64*)MemToShadow(src);
u64 *d = (u64*)MemToShadow(dst);
u64 *send = (u64*)MemToShadow(src + size);
uptr inc = 1;
if (dst > src) {
s = (u64*)MemToShadow(src + size) - 1;
d = (u64*)MemToShadow(dst + size) - 1;
send = (u64*)MemToShadow(src) - 1;
inc = -1;
}
for (; s != send; s += inc, d += inc) {
*d = *s;
*s = 0;
}
// Clear the destination shadow range.
// We used to move shadow from src to dst, but the trace format does not
// support that anymore as it contains addresses of accesses.
RawShadow *d = MemToShadow(dst);
RawShadow *dend = MemToShadow(dst + size);
ShadowSet(d, dend, Shadow::kEmpty);
}
jptr __tsan_java_find(jptr *from_ptr, jptr to) {
SCOPED_JAVA_FUNC(__tsan_java_find);
DPrintf("#%d: java_find(&%p, %p)\n", *from_ptr, to);
CHECK_EQ((*from_ptr) % kHeapAlignment, 0);
CHECK_EQ(to % kHeapAlignment, 0);
CHECK_GE(*from_ptr, jctx->heap_begin);
CHECK_LE(to, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_find);
DPrintf("#%d: java_find(&0x%zx, 0x%zx)\n", thr->tid, *from_ptr, to);
DCHECK_EQ((*from_ptr) % kHeapAlignment, 0);
DCHECK_EQ(to % kHeapAlignment, 0);
DCHECK_GE(*from_ptr, jctx->heap_begin);
DCHECK_LE(to, jctx->heap_begin + jctx->heap_size);
for (uptr from = *from_ptr; from < to; from += kHeapAlignment) {
MBlock *b = ctx->metamap.GetBlock(from);
if (b) {
@@ -166,101 +154,105 @@ jptr __tsan_java_find(jptr *from_ptr, jptr to) {
}
void __tsan_java_finalize() {
SCOPED_JAVA_FUNC(__tsan_java_finalize);
DPrintf("#%d: java_mutex_finalize()\n", thr->tid);
AcquireGlobal(thr, 0);
JAVA_FUNC_ENTER(__tsan_java_finalize);
DPrintf("#%d: java_finalize()\n", thr->tid);
AcquireGlobal(thr);
}
void __tsan_java_mutex_lock(jptr addr) {
SCOPED_JAVA_FUNC(__tsan_java_mutex_lock);
DPrintf("#%d: java_mutex_lock(%p)\n", thr->tid, addr);
CHECK_NE(jctx, 0);
CHECK_GE(addr, jctx->heap_begin);
CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_mutex_lock);
DPrintf("#%d: java_mutex_lock(0x%zx)\n", thr->tid, addr);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
MutexPostLock(thr, pc, addr, MutexFlagLinkerInit | MutexFlagWriteReentrant |
MutexFlagDoPreLockOnPostLock);
MutexPostLock(thr, 0, addr,
MutexFlagLinkerInit | MutexFlagWriteReentrant |
MutexFlagDoPreLockOnPostLock);
}
void __tsan_java_mutex_unlock(jptr addr) {
SCOPED_JAVA_FUNC(__tsan_java_mutex_unlock);
DPrintf("#%d: java_mutex_unlock(%p)\n", thr->tid, addr);
CHECK_NE(jctx, 0);
CHECK_GE(addr, jctx->heap_begin);
CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_mutex_unlock);
DPrintf("#%d: java_mutex_unlock(0x%zx)\n", thr->tid, addr);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
MutexUnlock(thr, pc, addr);
MutexUnlock(thr, 0, addr);
}
void __tsan_java_mutex_read_lock(jptr addr) {
SCOPED_JAVA_FUNC(__tsan_java_mutex_read_lock);
DPrintf("#%d: java_mutex_read_lock(%p)\n", thr->tid, addr);
CHECK_NE(jctx, 0);
CHECK_GE(addr, jctx->heap_begin);
CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_mutex_read_lock);
DPrintf("#%d: java_mutex_read_lock(0x%zx)\n", thr->tid, addr);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
MutexPostReadLock(thr, pc, addr, MutexFlagLinkerInit |
MutexFlagWriteReentrant | MutexFlagDoPreLockOnPostLock);
MutexPostReadLock(thr, 0, addr,
MutexFlagLinkerInit | MutexFlagWriteReentrant |
MutexFlagDoPreLockOnPostLock);
}
void __tsan_java_mutex_read_unlock(jptr addr) {
SCOPED_JAVA_FUNC(__tsan_java_mutex_read_unlock);
DPrintf("#%d: java_mutex_read_unlock(%p)\n", thr->tid, addr);
CHECK_NE(jctx, 0);
CHECK_GE(addr, jctx->heap_begin);
CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_mutex_read_unlock);
DPrintf("#%d: java_mutex_read_unlock(0x%zx)\n", thr->tid, addr);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
MutexReadUnlock(thr, pc, addr);
MutexReadUnlock(thr, 0, addr);
}
void __tsan_java_mutex_lock_rec(jptr addr, int rec) {
SCOPED_JAVA_FUNC(__tsan_java_mutex_lock_rec);
DPrintf("#%d: java_mutex_lock_rec(%p, %d)\n", thr->tid, addr, rec);
CHECK_NE(jctx, 0);
CHECK_GE(addr, jctx->heap_begin);
CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
CHECK_GT(rec, 0);
JAVA_FUNC_ENTER(__tsan_java_mutex_lock_rec);
DPrintf("#%d: java_mutex_lock_rec(0x%zx, %d)\n", thr->tid, addr, rec);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
DCHECK_GT(rec, 0);
MutexPostLock(thr, pc, addr, MutexFlagLinkerInit | MutexFlagWriteReentrant |
MutexFlagDoPreLockOnPostLock | MutexFlagRecursiveLock, rec);
MutexPostLock(thr, 0, addr,
MutexFlagLinkerInit | MutexFlagWriteReentrant |
MutexFlagDoPreLockOnPostLock | MutexFlagRecursiveLock,
rec);
}
int __tsan_java_mutex_unlock_rec(jptr addr) {
SCOPED_JAVA_FUNC(__tsan_java_mutex_unlock_rec);
DPrintf("#%d: java_mutex_unlock_rec(%p)\n", thr->tid, addr);
CHECK_NE(jctx, 0);
CHECK_GE(addr, jctx->heap_begin);
CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_mutex_unlock_rec);
DPrintf("#%d: java_mutex_unlock_rec(0x%zx)\n", thr->tid, addr);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
return MutexUnlock(thr, pc, addr, MutexFlagRecursiveUnlock);
return MutexUnlock(thr, 0, addr, MutexFlagRecursiveUnlock);
}
void __tsan_java_acquire(jptr addr) {
SCOPED_JAVA_FUNC(__tsan_java_acquire);
DPrintf("#%d: java_acquire(%p)\n", thr->tid, addr);
CHECK_NE(jctx, 0);
CHECK_GE(addr, jctx->heap_begin);
CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_acquire);
DPrintf("#%d: java_acquire(0x%zx)\n", thr->tid, addr);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
Acquire(thr, caller_pc, addr);
Acquire(thr, 0, addr);
}
void __tsan_java_release(jptr addr) {
SCOPED_JAVA_FUNC(__tsan_java_release);
DPrintf("#%d: java_release(%p)\n", thr->tid, addr);
CHECK_NE(jctx, 0);
CHECK_GE(addr, jctx->heap_begin);
CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_release);
DPrintf("#%d: java_release(0x%zx)\n", thr->tid, addr);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
Release(thr, caller_pc, addr);
Release(thr, 0, addr);
}
void __tsan_java_release_store(jptr addr) {
SCOPED_JAVA_FUNC(__tsan_java_release);
DPrintf("#%d: java_release_store(%p)\n", thr->tid, addr);
CHECK_NE(jctx, 0);
CHECK_GE(addr, jctx->heap_begin);
CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
JAVA_FUNC_ENTER(__tsan_java_release);
DPrintf("#%d: java_release_store(0x%zx)\n", thr->tid, addr);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
ReleaseStore(thr, caller_pc, addr);
ReleaseStore(thr, 0, addr);
}