maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

tsan: s/CHECK/DCHECK/ in tsan_interface_java.cpp 

We are very paranoid with CHECKs in all Java entry points.
These CHECKs were added along with Java support.
At that point it wasn't clear what exactly to expect from JVM part
and if JVM part is correct or not. Thus CHECK paranoia.
These CHECKs never fired in practice, but we pay runtime cost
in every entry point all the time.
Replace CHECKs with DCHECKs.

Depends on D107069.

Reviewed By: melver

Differential Revision: https://reviews.llvm.org/D107071
This commit is contained in:
Dmitry Vyukov 2021-07-29 13:33:07 +02:00
parent 0bc10d9a8e
commit 17f650cb00
1 changed files with 62 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
compiler-rt/lib/tsan/rtl/tsan_interface_java.cpp
View File

@ -64,19 +64,19 @@ void __tsan_java_init(jptr heap_begin, jptr heap_size) {
JAVA_FUNC_ENTER(__tsan_java_init);
Initialize(thr);
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);
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() {
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);
@ -86,12 +86,12 @@ int __tsan_java_fini() {
void __tsan_java_alloc(jptr ptr, jptr size) {
JAVA_FUNC_ENTER(__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);
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, 0, ptr, size, false);
}
@ -99,12 +99,12 @@ void __tsan_java_alloc(jptr ptr, jptr size) {
void __tsan_java_free(jptr ptr, jptr size) {
JAVA_FUNC_ENTER(__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);
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);
}
@ -112,17 +112,17 @@ void __tsan_java_free(jptr ptr, jptr size) {
void __tsan_java_move(jptr src, jptr dst, jptr size) {
JAVA_FUNC_ENTER(__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);
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).
@ -148,10 +148,10 @@ void __tsan_java_move(jptr src, jptr dst, jptr size) {
jptr __tsan_java_find(jptr *from_ptr, jptr to) {
JAVA_FUNC_ENTER(__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);
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) {
@ -171,9 +171,9 @@ void __tsan_java_finalize() {
void __tsan_java_mutex_lock(jptr addr) {
JAVA_FUNC_ENTER(__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);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
MutexPostLock(thr, 0, addr,
MutexFlagLinkerInit | MutexFlagWriteReentrant |
@ -183,9 +183,9 @@ void __tsan_java_mutex_lock(jptr addr) {
void __tsan_java_mutex_unlock(jptr addr) {
JAVA_FUNC_ENTER(__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);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
MutexUnlock(thr, 0, addr);
}
@ -193,9 +193,9 @@ void __tsan_java_mutex_unlock(jptr addr) {
void __tsan_java_mutex_read_lock(jptr addr) {
JAVA_FUNC_ENTER(__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);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
MutexPostReadLock(thr, 0, addr,
MutexFlagLinkerInit | MutexFlagWriteReentrant |
@ -205,9 +205,9 @@ void __tsan_java_mutex_read_lock(jptr addr) {
void __tsan_java_mutex_read_unlock(jptr addr) {
JAVA_FUNC_ENTER(__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);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
MutexReadUnlock(thr, 0, addr);
}
@ -215,10 +215,10 @@ void __tsan_java_mutex_read_unlock(jptr addr) {
void __tsan_java_mutex_lock_rec(jptr addr, int rec) {
JAVA_FUNC_ENTER(__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);
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, 0, addr,
MutexFlagLinkerInit | MutexFlagWriteReentrant |
@ -229,9 +229,9 @@ void __tsan_java_mutex_lock_rec(jptr addr, int rec) {
int __tsan_java_mutex_unlock_rec(jptr addr) {
JAVA_FUNC_ENTER(__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);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
return MutexUnlock(thr, 0, addr, MutexFlagRecursiveUnlock);
}
@ -239,9 +239,9 @@ int __tsan_java_mutex_unlock_rec(jptr addr) {
void __tsan_java_acquire(jptr addr) {
JAVA_FUNC_ENTER(__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);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
Acquire(thr, 0, addr);
}
@ -249,9 +249,9 @@ void __tsan_java_acquire(jptr addr) {
void __tsan_java_release(jptr addr) {
JAVA_FUNC_ENTER(__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);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
Release(thr, 0, addr);
}
@ -259,9 +259,9 @@ void __tsan_java_release(jptr addr) {
void __tsan_java_release_store(jptr addr) {
JAVA_FUNC_ENTER(__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);
DCHECK_NE(jctx, 0);
DCHECK_GE(addr, jctx->heap_begin);
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
ReleaseStore(thr, 0, addr);
}