From 858c5f8fd8c3c02e9da4b0a229435ee97b26236e Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 27 Jun 2020 11:36:48 +0100
Subject: [PATCH] Update thread_unix logic

---
 core/sys/unix/pthread_unix.odin |  2 +-
 core/thread/thread_unix.odin    | 20 ++++++++++++++------
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/core/sys/unix/pthread_unix.odin b/core/sys/unix/pthread_unix.odin
index f28e25676..a8a680bce 100644
--- a/core/sys/unix/pthread_unix.odin
+++ b/core/sys/unix/pthread_unix.odin
@@ -14,7 +14,7 @@ foreign pthread {
 	pthread_create :: proc(t: ^pthread_t, attrs: ^pthread_attr_t, routine: proc(data: rawptr) -> rawptr, arg: rawptr) -> c.int ---;
 
 	// retval is a pointer to a location to put the return value of the thread proc.
-	pthread_join :: proc(t: pthread_t, retval: rawptr) -> c.int ---;
+	pthread_join :: proc(t: pthread_t, retval: ^rawptr) -> c.int ---;
 
 	pthread_self :: proc() -> pthread_t ---;
 
diff --git a/core/thread/thread_unix.odin b/core/thread/thread_unix.odin
index 8d8476043..b2718487a 100644
--- a/core/thread/thread_unix.odin
+++ b/core/thread/thread_unix.odin
@@ -120,7 +120,9 @@ is_done :: proc(t: ^Thread) -> bool {
 }
 
 join :: proc(t: ^Thread) {
-	if unix.pthread_equal(unix.pthread_self(), t.unix_thread) do return;
+	if unix.pthread_equal(unix.pthread_self(), t.unix_thread) {
+		return;
+	}
 	// if unix.pthread_self().x == t.unix_thread.x do return;
 
 	// NOTE(tetra): It's apparently UB for multiple threads to join the same thread
@@ -131,7 +133,9 @@ join :: proc(t: ^Thread) {
 	// sure it makes sense to need to join from multiple threads?
 	if sync.atomic_swap(&t.already_joined, true, .Sequentially_Consistent) {
 		for {
-			if sync.atomic_load(&t.done, .Sequentially_Consistent) do return;
+			if sync.atomic_load(&t.done, .Sequentially_Consistent) {
+				return;
+			}
 			intrinsics.cpu_relax();
 		}
 	}
@@ -141,11 +145,15 @@ join :: proc(t: ^Thread) {
 	// We do this instead because I don't know if there is a danger
 	// that you may join a different thread from the one you called join on,
 	// if the thread handle is reused.
-	if sync.atomic_load(&t.done, .Sequentially_Consistent) do return;
+	if sync.atomic_load(&t.done, .Sequentially_Consistent) {
+		return;
+	}
 
-	ret := unix.pthread_join(t.unix_thread, nil);
-	assert(ret == 0, "cannot join thread");
-	assert(sync.atomic_load(&t.done, .Sequentially_Consistent), "thread not done after join");
+	ret_val: rawptr;
+	_ = unix.pthread_join(t.unix_thread, &ret_val);
+	if !sync.atomic_load(&t.done, .Sequentially_Consistent) {
+		panic("thread not done after join");
+	}
 }
 
 destroy :: proc(t: ^Thread) {