From 826a3b3012b781c972d3550b3999f6a9b4a09508 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 6 Sep 2022 13:50:23 +0100 Subject: [PATCH] Begin work in helgrind calls --- core/sys/valgrind/callgrind.odin | 4 +- core/sys/valgrind/helgrind.odin | 178 +++++++++++++++++++++++++++++++ core/sys/valgrind/memcheck.odin | 4 +- core/sys/valgrind/valgrind.odin | 8 +- 4 files changed, 186 insertions(+), 8 deletions(-) create mode 100644 core/sys/valgrind/helgrind.odin diff --git a/core/sys/valgrind/callgrind.odin b/core/sys/valgrind/callgrind.odin index 1396f82ad..cf377e353 100644 --- a/core/sys/valgrind/callgrind.odin +++ b/core/sys/valgrind/callgrind.odin @@ -13,10 +13,10 @@ Callgrind_Client_Request :: enum uintptr { } @(require_results) -callgrind_client_request_expr :: proc "c" (default: uintptr, request: Callgrind_Client_Request, a0, a1, a2, a3, a4: uintptr) -> uintptr { +callgrind_client_request_expr :: #force_inline proc "c" (default: uintptr, request: Callgrind_Client_Request, a0, a1, a2, a3, a4: uintptr) -> uintptr { return intrinsics.valgrind_client_request(default, uintptr(request), a0, a1, a2, a3, a4) } -callgrind_client_request_stmt :: proc "c" (request: Callgrind_Client_Request, a0, a1, a2, a3, a4: uintptr) { +callgrind_client_request_stmt :: #force_inline proc "c" (request: Callgrind_Client_Request, a0, a1, a2, a3, a4: uintptr) { _ = intrinsics.valgrind_client_request(0, uintptr(request), a0, a1, a2, a3, a4) } diff --git a/core/sys/valgrind/helgrind.odin b/core/sys/valgrind/helgrind.odin new file mode 100644 index 000000000..41c047d05 --- /dev/null +++ b/core/sys/valgrind/helgrind.odin @@ -0,0 +1,178 @@ +//+build amd64 +package sys_valgrind + +import "core:intrinsics" + +Helgrind_Client_Request :: enum uintptr { + Clean_Memory = 'H'<<24 | 'G'<<16, + Set_My_pthread_t = ('H'<<25 | 'G'<<16)+256, + Pthread_Join_Post, + Pthread_Mutex_Init_Post, + Pthread_Mutex_Destroy_Pre, + Pthread_Mutex_Unlock_Pre, + Pthread_Mutex_Unlock_Post, + Pthread_Mutex_Lock_Pre, + Pthread_Mutex_Lock_Post, + Pthread_Cond_Signal_Pre, + Pthread_Cond_Broadcast_Pre, + Pthread_Cond_Wait_Pre, + Pthread_Cond_Wait_Post, + Pthread_Cond_Destroy_Pre, + Pthread_Rwlock_Init_Post, + Pthread_Rwlock_Destroy_Pre, + Pthread_Rwlock_Lock_Pre, + Pthread_Rwlock_Lock_Post, + Pthread_Rwlock_Unlock_Pre, + Pthread_Rwlock_Unlock_Post, + Posix_Sem_Init_Post, + Posix_Sem_Destroy_Pre, + Posix_Sem_Post_Pre, + Posix_Sem_Wait_Post, + Pthread_Barrier_Init_Pre, + Pthread_Barrier_Wait_Pre, + Pthread_Barrier_Destroy_Pre, + Pthread_Spin_Init_Or_Unlock_Pre, + Pthread_Spin_Init_Or_Unlock_Post, + Pthread_Spin_Lock_Pre, + Pthread_Spin_Lock_Post, + Pthread_Spin_Destroy_Pre, + Clientreq_Unimp, + Userso_Send_Pre, + Userso_Recv_Post, + Userso_Forget_All, + Reserved2, + Reserved3, + Reserved4, + Arange_Make_Untracked, + Arange_Make_Tracked, + Pthread_Barrier_Resize_Pre, + Clean_Memory_Heapblock, + Pthread_Cond_Init_Post, +} + +@(require_results) +helgrind_client_request_expr :: #force_inline proc "c" (default: uintptr, request: Helgrind_Client_Request, a0, a1, a2, a3, a4: uintptr) -> uintptr { + return intrinsics.valgrind_client_request(default, uintptr(request), a0, a1, a2, a3, a4) +} +helgrind_client_request_stmt :: #force_inline proc "c" (request: Helgrind_Client_Request, a0, a1, a2, a3, a4: uintptr) { + _ = intrinsics.valgrind_client_request(0, uintptr(request), a0, a1, a2, a3, a4) +} + +helgrind_mutex_init_post :: proc "c" (mutex: rawptr, mb_rec: uint) { + helgrind_client_request_stmt(.Pthread_Mutex_Init_Post, uintptr(mutex), uintptr(mb_rec), 0, 0, 0) +} +helgrind_mutex_destroy_pre :: proc "c" (mutex: rawptr) { + helgrind_client_request_stmt(.Pthread_Mutex_Destroy_Pre, uintptr(mutex), 0, 0, 0, 0) +} +helgrind_mutex_lock_pre :: proc "c" (mutex: rawptr, is_try_lock: bool) { + helgrind_client_request_stmt(.Pthread_Mutex_Lock_Pre, uintptr(mutex), uintptr(is_try_lock), 0, 0, 0) +} +helgrind_mutex_lock_post :: proc "c" (mutex: rawptr) { + helgrind_client_request_stmt(.Pthread_Mutex_Lock_Post, uintptr(mutex), 0, 0, 0, 0) +} +helgrind_mutex_unlock_pre :: proc "c" (mutex: rawptr) { + helgrind_client_request_stmt(.Pthread_Mutex_Unlock_Pre, uintptr(mutex), 0, 0, 0, 0) +} +helgrind_mutex_unlock_post :: proc "c" (mutex: rawptr) { + helgrind_client_request_stmt(.Pthread_Mutex_Unlock_Post, uintptr(mutex), 0, 0, 0, 0) +} + +helgrind_rwlock_init_post :: proc "c" (lock: rawptr) { + helgrind_client_request_stmt(.Pthread_Rwlock_Init_Post, uintptr(lock), 0, 0, 0, 0) +} +helgrind_rwlock_destroy_pre :: proc "c" (lock: rawptr) { + helgrind_client_request_stmt(.Pthread_Rwlock_Destroy_Pre, uintptr(lock), 0, 0, 0, 0) +} +helgrind_rwlock_lock_pre :: proc "c" (lock: rawptr, is_w: bool) { + helgrind_client_request_stmt(.Pthread_Rwlock_Lock_Pre, uintptr(lock), uintptr(is_w), 0, 0, 0) +} +helgrind_rwlock_unlock_post :: proc "c" (lock: rawptr, is_w: bool) { + helgrind_client_request_stmt(.Pthread_Rwlock_Unlock_Pre, uintptr(lock), uintptr(is_w), 0, 0, 0) +} + + +helgrind_sem_init_post :: proc "c" (sem: rawptr, value: uint) { + helgrind_client_request_stmt(.Posix_Sem_Init_Post, uintptr(sem), uintptr(value), 0, 0, 0) +} +helgrind_sem_wait_post :: proc "c" (sem: rawptr) { + helgrind_client_request_stmt(.Posix_Sem_Wait_Post, uintptr(sem), 0, 0, 0, 0) +} +helgrind_sem_post_pre :: proc "c" (sem: rawptr) { + helgrind_client_request_stmt(.Posix_Sem_Post_Pre, uintptr(sem), 0, 0, 0, 0) +} +helgrind_sem_destroy_pre :: proc "c" (sem: rawptr) { + helgrind_client_request_stmt(.Posix_Sem_Destroy_Pre, uintptr(sem), 0, 0, 0, 0) +} + + +helgrind_barrier_init_pre :: proc "c" (bar: rawptr, count: uint, resizable: bool) { + helgrind_client_request_stmt(.Pthread_Barrier_Init_Pre, uintptr(bar), uintptr(count), uintptr(resizable), 0, 0) +} +helgrind_barrier_wait_pre :: proc "c" (bar: rawptr) { + helgrind_client_request_stmt(.Pthread_Barrier_Wait_Pre, uintptr(bar), 0, 0, 0, 0) +} +helgrind_barrier_resize_pre :: proc "c" (bar: rawptr, new_count: uint) { + helgrind_client_request_stmt(.Pthread_Barrier_Resize_Pre, uintptr(bar), uintptr(new_count), 0, 0, 0) +} +helgrind_barrier_destroy_pre :: proc "c" (bar: rawptr) { + helgrind_client_request_stmt(.Pthread_Barrier_Destroy_Pre, uintptr(bar), 0, 0, 0, 0) +} + + + +helgrind_clean_memory :: proc "c" (qzz_start: rawptr, qzz_len: uint) { + helgrind_client_request_stmt(.Clean_Memory, uintptr(qzz_start), uintptr(qzz_len), 0, 0, 0) +} +helgrind_clean_memory_slice :: proc "c" (qzz: []byte) { + helgrind_client_request_stmt(.Clean_Memory, uintptr(raw_data(qzz)), uintptr(len(qzz)), 0, 0, 0) +} +helgrind_clean_memory_heap_block :: proc "c" (qzz_blockstart: rawptr) -> int { + return int(helgrind_client_request_expr(~uintptr(1), .Clean_Memory_Heapblock, uintptr(qzz_blockstart), 0, 0, 0, 0)) +} + + +helgrind_disable_checking :: proc "c" (qzz_start: rawptr, qzz_len: uint) { + helgrind_client_request_stmt(.Arange_Make_Untracked, uintptr(qzz_start), uintptr(qzz_len), 0, 0, 0) +} +helgrind_enable_checking :: proc "c" (qzz_start: rawptr, qzz_len: uint) { + helgrind_client_request_stmt(.Arange_Make_Tracked, uintptr(qzz_start), uintptr(qzz_len), 0, 0, 0) +} + + +helgrind_cond_init_post :: proc "c" (cond: rawptr) { + helgrind_client_request_stmt(.Pthread_Cond_Init_Post, uintptr(cond), 0, 0, 0, 0) +} +helgrind_cond_destroy_pre :: proc "c" (cond: rawptr) { + helgrind_client_request_stmt(.Pthread_Cond_Destroy_Pre, uintptr(cond), 0, 0, 0, 0) +} +helgrind_cond_signal_pre :: proc "c" (cond: rawptr) { + helgrind_client_request_stmt(.Pthread_Cond_Signal_Pre, uintptr(cond), 0, 0, 0, 0) +} +helgrind_cond_broadcast_pre :: proc "c" (cond: rawptr) { + helgrind_client_request_stmt(.Pthread_Cond_Broadcast_Pre, uintptr(cond), 0, 0, 0, 0) +} +helgrind_cond_wait_pre :: proc "c" (cond: rawptr, lock: rawptr) -> bool { + return 0 != helgrind_client_request_expr(0, .Pthread_Cond_Wait_Pre, uintptr(cond), uintptr(lock), 0, 0, 0) +} +helgrind_cond_wait_post :: proc "c" (cond: rawptr, lock: rawptr) -> bool { + return 0 != helgrind_client_request_expr(0, .Pthread_Cond_Wait_Post, uintptr(cond), uintptr(lock), 0, 0, 0) +} + + +helgrind_client_request_unimp :: #force_inline proc "c" (msg: cstring) { + helgrind_client_request_stmt(.Clientreq_Unimp, uintptr(rawptr(msg)), 0, 0, 0, 0) +} + + +helgrind_annotate_condvar_lock_wait :: #force_inline proc "c" (cv: rawptr, lock: rawptr) { + helgrind_client_request_unimp("ANNOTATE_CONDVAR_LOCK_WAIT") +} +helgrind_annotate_condvar_wait :: proc "c" (cv: rawptr) { + helgrind_client_request_unimp("ANNOTATE_CONDVAR_WAIT") +} +helgrind_annotate_condvar_signal :: proc "c" (cv: rawptr) { + helgrind_client_request_unimp("ANNOTATE_CONDVAR_SIGNAL") +} +helgrind_annotate_condvar_signal_all :: proc "c" (cv: rawptr) { + helgrind_client_request_unimp("ANNOTATE_CONDVAR_SIGNAL_ALL") +} \ No newline at end of file diff --git a/core/sys/valgrind/memcheck.odin b/core/sys/valgrind/memcheck.odin index 99c65272a..6a9fab854 100644 --- a/core/sys/valgrind/memcheck.odin +++ b/core/sys/valgrind/memcheck.odin @@ -22,10 +22,10 @@ Mem_Check_Client_Request :: enum uintptr { } @(require_results) -mem_check_client_request_expr :: proc "c" (default: uintptr, request: Mem_Check_Client_Request, a0, a1, a2, a3, a4: uintptr) -> uintptr { +mem_check_client_request_expr :: #force_inline proc "c" (default: uintptr, request: Mem_Check_Client_Request, a0, a1, a2, a3, a4: uintptr) -> uintptr { return intrinsics.valgrind_client_request(default, uintptr(request), a0, a1, a2, a3, a4) } -mem_check_client_request_stmt :: proc "c" (request: Mem_Check_Client_Request, a0, a1, a2, a3, a4: uintptr) { +mem_check_client_request_stmt :: #force_inline proc "c" (request: Mem_Check_Client_Request, a0, a1, a2, a3, a4: uintptr) { _ = intrinsics.valgrind_client_request(0, uintptr(request), a0, a1, a2, a3, a4) } diff --git a/core/sys/valgrind/valgrind.odin b/core/sys/valgrind/valgrind.odin index 2fb95588f..b587ea3bf 100644 --- a/core/sys/valgrind/valgrind.odin +++ b/core/sys/valgrind/valgrind.odin @@ -38,10 +38,10 @@ Client_Request :: enum uintptr { } @(require_results) -client_request_expr :: proc "c" (default: uintptr, request: Client_Request, a0, a1, a2, a3, a4: uintptr) -> uintptr { +client_request_expr :: #force_inline proc "c" (default: uintptr, request: Client_Request, a0, a1, a2, a3, a4: uintptr) -> uintptr { return intrinsics.valgrind_client_request(default, uintptr(request), a0, a1, a2, a3, a4) } -client_request_stmt :: proc "c" (request: Client_Request, a0, a1, a2, a3, a4: uintptr) { +client_request_stmt :: #force_inline proc "c" (request: Client_Request, a0, a1, a2, a3, a4: uintptr) { _ = intrinsics.valgrind_client_request(0, uintptr(request), a0, a1, a2, a3, a4) } @@ -49,8 +49,8 @@ client_request_stmt :: proc "c" (request: Client_Request, a0, a1, a2, a3, a4: ui // 0 - running natively // 1 - running under Valgrind // 2 - running under Valgrind which is running under another Valgrind -running_on_valgrind :: proc "c" () -> uintptr { - return client_request_expr(0, .Running_On_Valgrind, 0, 0, 0, 0, 0) +running_on_valgrind :: proc "c" () -> uint { + return uint(client_request_expr(0, .Running_On_Valgrind, 0, 0, 0, 0, 0)) } // Discard translation of code in the slice qzz. Useful if you are debugging a JIT-er or some such,