Solve MacOs compile errors and threading atomic detection.

viferga · viferga · commit 8bb69332f12f · 2023-02-02T17:00:09.000+01:00
diff --git a/cmake/CompileOptions.cmake b/cmake/CompileOptions.cmake
@@ -37,7 +37,7 @@ include(Portability)
 # Test for GNU 4.9+, Clang 3.6+ or ((Visual Studio C++ or Clang with MSVC backend) and Visual Studio 2022 or superior)
 if(("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" AND ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 4.9) OR
 	((("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") OR
-	("${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")) AND AND ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 3.6) OR
+	("${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")) AND ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 3.6) OR
 	(
 		(("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC") OR
 		(("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") AND ("${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC"))) AND
diff --git a/source/benchmarks/metacall_py_c_api_bench/source/metacall_py_c_api_bench.cpp b/source/benchmarks/metacall_py_c_api_bench/source/metacall_py_c_api_bench.cpp
@@ -150,4 +150,4 @@ BENCHMARK_REGISTER_F(metacall_py_c_api_bench, call_object)
 	->Iterations(1)
 	->Repetitions(5);
 
-BENCHMARK_MAIN();
+BENCHMARK_MAIN();
diff --git a/source/tests/sanitizer/tsan.supp b/source/tests/sanitizer/tsan.supp
@@ -16,8 +16,8 @@
 # NodeJS
 #
 race:v8::platform::tracing::TracingController::GetCategoryGroupEnabled
-# TODO: Review this race condition, it started to happen after NodeJS v12
 race:v8::platform::DefaultJobWorker::~DefaultJobWorker()
+race:v8::platform::DefaultJobState::~DefaultJobState
 #
 # Ruby
 #
diff --git a/source/threading/include/threading/threading_atomic_ref_count.h b/source/threading/include/threading/threading_atomic_ref_count.h
@@ -62,7 +62,7 @@ typedef struct threading_atomic_ref_count_type *threading_atomic_ref_count;
 
 /* -- Methods -- */
 
-inline void threading_atomic_ref_count_store(threading_atomic_ref_count ref, uintmax_t v)
+static inline void threading_atomic_ref_count_store(threading_atomic_ref_count ref, uintmax_t v)
 {
 #if defined(__THREAD_SANITIZER__)
 	threading_mutex_store(&ref->m, &ref->count, &v, sizeof(uintmax_t));
@@ -71,7 +71,7 @@ inline void threading_atomic_ref_count_store(threading_atomic_ref_count ref, uin
 #endif
 }
 
-inline void threading_atomic_ref_count_initialize(threading_atomic_ref_count ref)
+static inline void threading_atomic_ref_count_initialize(threading_atomic_ref_count ref)
 {
 #if defined(__THREAD_SANITIZER__)
 	uintmax_t init = THREADING_ATOMIC_REF_COUNT_MIN;
@@ -84,7 +84,7 @@ inline void threading_atomic_ref_count_initialize(threading_atomic_ref_count ref
 #endif
 }
 
-inline uintmax_t threading_atomic_ref_count_load(threading_atomic_ref_count ref)
+static inline uintmax_t threading_atomic_ref_count_load(threading_atomic_ref_count ref)
 {
 #if defined(__THREAD_SANITIZER__)
 	uintmax_t result = 0;
@@ -97,7 +97,7 @@ inline uintmax_t threading_atomic_ref_count_load(threading_atomic_ref_count ref)
 #endif
 }
 
-inline int threading_atomic_ref_count_increment(threading_atomic_ref_count ref)
+static inline int threading_atomic_ref_count_increment(threading_atomic_ref_count ref)
 {
 #if defined(__THREAD_SANITIZER__)
 	threading_mutex_lock(&ref->m);
@@ -117,7 +117,7 @@ inline int threading_atomic_ref_count_increment(threading_atomic_ref_count ref)
 	return 0;
 }
 
-inline int threading_atomic_ref_count_decrement(threading_atomic_ref_count ref)
+static inline int threading_atomic_ref_count_decrement(threading_atomic_ref_count ref)
 {
 #if defined(__THREAD_SANITIZER__)
 	threading_mutex_lock(&ref->m);
@@ -142,7 +142,7 @@ inline int threading_atomic_ref_count_decrement(threading_atomic_ref_count ref)
 	return 0;
 }
 
-inline void threading_atomic_ref_count_destroy(threading_atomic_ref_count ref)
+static inline void threading_atomic_ref_count_destroy(threading_atomic_ref_count ref)
 {
 #if defined(__THREAD_SANITIZER__)
 	threading_mutex_destroy(&ref->m);
diff --git a/source/threading/include/threading/threading_atomic_win32.h b/source/threading/include/threading/threading_atomic_win32.h
@@ -122,7 +122,7 @@ typedef LONG volatile atomic_flag;
 
 #undef __atomic_is_lock_free_power_of_2
 
-inline void atomic_store_explicit8(CHAR volatile *obj, CHAR desired, memory_order order)
+static inline void atomic_store_explicit8(CHAR volatile *obj, CHAR desired, memory_order order)
 {
 	if (order == memory_order_seq_cst)
 	{
@@ -134,7 +134,7 @@ inline void atomic_store_explicit8(CHAR volatile *obj, CHAR desired, memory_orde
 	}
 }
 
-inline void atomic_store_explicit16(SHORT volatile *obj, SHORT desired, memory_order order)
+static inline void atomic_store_explicit16(SHORT volatile *obj, SHORT desired, memory_order order)
 {
 	if (order == memory_order_seq_cst)
 	{
@@ -146,7 +146,7 @@ inline void atomic_store_explicit16(SHORT volatile *obj, SHORT desired, memory_o
 	}
 }
 
-inline void atomic_store_explicit32(LONG volatile *obj, LONG desired, memory_order order)
+static inline void atomic_store_explicit32(LONG volatile *obj, LONG desired, memory_order order)
 {
 	if (order == memory_order_seq_cst)
 	{
@@ -158,7 +158,7 @@ inline void atomic_store_explicit32(LONG volatile *obj, LONG desired, memory_ord
 	}
 }
 
-inline void atomic_store_explicit64(LONG64 volatile *obj, LONG64 desired, memory_order order)
+static inline void atomic_store_explicit64(LONG64 volatile *obj, LONG64 desired, memory_order order)
 {
 	if (order == memory_order_seq_cst)
 #ifdef _M_IX86
@@ -224,7 +224,7 @@ inline void atomic_store_explicit64(LONG64 volatile *obj, LONG64 desired, memory
 		(sizeof *(obj) == 8) ? _InterlockedExchange64((LONG64 volatile *)obj, (LONG64)desired) : \
 								 (abort(), 0))
 
-inline bool atomic_compare_exchange8(CHAR volatile *obj, CHAR *expected, CHAR desired)
+static inline bool atomic_compare_exchange8(CHAR volatile *obj, CHAR *expected, CHAR desired)
 {
 	CHAR previous = _InterlockedCompareExchange8(obj, desired, *expected);
 	bool result = (previous == *expected);
@@ -237,7 +237,7 @@ inline bool atomic_compare_exchange8(CHAR volatile *obj, CHAR *expected, CHAR de
 	return result;
 }
 
-inline bool atomic_compare_exchange16(SHORT volatile *obj, SHORT *expected, SHORT desired)
+static inline bool atomic_compare_exchange16(SHORT volatile *obj, SHORT *expected, SHORT desired)
 {
 	SHORT previous = _InterlockedCompareExchange16(obj, desired, *expected);
 	bool result = (previous == *expected);
@@ -250,7 +250,7 @@ inline bool atomic_compare_exchange16(SHORT volatile *obj, SHORT *expected, SHOR
 	return result;
 }
 
-inline bool atomic_compare_exchange32(LONG volatile *obj, LONG *expected, LONG desired)
+static inline bool atomic_compare_exchange32(LONG volatile *obj, LONG *expected, LONG desired)
 {
 	LONG previous = _InterlockedCompareExchange(obj, desired, *expected);
 	bool result = (previous == *expected);
@@ -263,7 +263,7 @@ inline bool atomic_compare_exchange32(LONG volatile *obj, LONG *expected, LONG d
 	return result;
 }
 
-inline bool atomic_compare_exchange64(LONG64 volatile *obj, LONG64 *expected, LONG64 desired)
+static inline bool atomic_compare_exchange64(LONG64 volatile *obj, LONG64 *expected, LONG64 desired)
 {
 	LONG64 previous = _InterlockedCompareExchange64(obj, desired, *expected);
 	bool result = (previous == *expected);
@@ -346,7 +346,7 @@ inline bool atomic_compare_exchange64(LONG64 volatile *obj, LONG64 *expected, LO
 		}                                 \
 	} while (0)
 
-inline void atomic_thread_fence(memory_order order)
+static inline void atomic_thread_fence(memory_order order)
 {
 	__atomic_compiler_barrier(order);
 
@@ -357,7 +357,7 @@ inline void atomic_thread_fence(memory_order order)
 	}
 }
 
-inline void atomic_signal_fence(memory_order order)
+static inline void atomic_signal_fence(memory_order order)
 {
 	__atomic_compiler_barrier(order);
 }
diff --git a/source/threading/include/threading/threading_mutex.h b/source/threading/include/threading/threading_mutex.h
@@ -75,7 +75,7 @@ int threading_mutex_unlock(threading_mutex m);
 
 int threading_mutex_destroy(threading_mutex m);
 
-inline int threading_mutex_store(threading_mutex m, void *dest, void *src, size_t size)
+static inline int threading_mutex_store(threading_mutex m, void *dest, void *src, size_t size)
 {
 	if (threading_mutex_lock(m) != 0)
 	{
diff --git a/source/threading/source/threading_mutex_macos.c b/source/threading/source/threading_mutex_macos.c
@@ -22,9 +22,11 @@
 
 #include <threading/threading_mutex.h>
 
+#include <string.h>
+
 int threading_mutex_initialize(threading_mutex m)
 {
-	m->impl = 0;
+	memset(&m->impl, 0, sizeof(os_unfair_lock));
 
 	return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ include(Portability)`
`37`	`37`	`# Test for GNU 4.9+, Clang 3.6+ or ((Visual Studio C++ or Clang with MSVC backend) and Visual Studio 2022 or superior)`
`38`	`38`	`if(("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" AND ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 4.9) OR`
`39`	`39`	`((("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") OR`
`40`		`- ("${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")) AND AND ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 3.6) OR`
	`40`	`+ ("${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")) AND ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 3.6) OR`
`41`	`41`	`(`
`42`	`42`	`(("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC") OR`
`43`	`43`	`(("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") AND ("${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC"))) AND`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,8 @@`
`16`	`16`	`# NodeJS`
`17`	`17`	`#`
`18`	`18`	`race:v8::platform::tracing::TracingController::GetCategoryGroupEnabled`
`19`		`-# TODO: Review this race condition, it started to happen after NodeJS v12`
`20`	`19`	`race:v8::platform::DefaultJobWorker::~DefaultJobWorker()`
	`20`	`+race:v8::platform::DefaultJobState::~DefaultJobState`
`21`	`21`	`#`
`22`	`22`	`# Ruby`
`23`	`23`	`#`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ typedef struct threading_atomic_ref_count_type *threading_atomic_ref_count;`
`62`	`62`
`63`	`63`	`/* -- Methods -- */`
`64`	`64`
`65`		`-inline void threading_atomic_ref_count_store(threading_atomic_ref_count ref, uintmax_t v)`
	`65`	`+static inline void threading_atomic_ref_count_store(threading_atomic_ref_count ref, uintmax_t v)`
`66`	`66`	`{`
`67`	`67`	`#if defined(__THREAD_SANITIZER__)`
`68`	`68`	`threading_mutex_store(&ref->m, &ref->count, &v, sizeof(uintmax_t));`
`@@ -71,7 +71,7 @@ inline void threading_atomic_ref_count_store(threading_atomic_ref_count ref, uin`
`71`	`71`	`#endif`
`72`	`72`	`}`
`73`	`73`
`74`		`-inline void threading_atomic_ref_count_initialize(threading_atomic_ref_count ref)`
	`74`	`+static inline void threading_atomic_ref_count_initialize(threading_atomic_ref_count ref)`
`75`	`75`	`{`
`76`	`76`	`#if defined(__THREAD_SANITIZER__)`
`77`	`77`	`uintmax_t init = THREADING_ATOMIC_REF_COUNT_MIN;`
`@@ -84,7 +84,7 @@ inline void threading_atomic_ref_count_initialize(threading_atomic_ref_count ref`
`84`	`84`	`#endif`
`85`	`85`	`}`
`86`	`86`
`87`		`-inline uintmax_t threading_atomic_ref_count_load(threading_atomic_ref_count ref)`
	`87`	`+static inline uintmax_t threading_atomic_ref_count_load(threading_atomic_ref_count ref)`
`88`	`88`	`{`
`89`	`89`	`#if defined(__THREAD_SANITIZER__)`
`90`	`90`	`uintmax_t result = 0;`
`@@ -97,7 +97,7 @@ inline uintmax_t threading_atomic_ref_count_load(threading_atomic_ref_count ref)`
`97`	`97`	`#endif`
`98`	`98`	`}`
`99`	`99`
`100`		`-inline int threading_atomic_ref_count_increment(threading_atomic_ref_count ref)`
	`100`	`+static inline int threading_atomic_ref_count_increment(threading_atomic_ref_count ref)`
`101`	`101`	`{`
`102`	`102`	`#if defined(__THREAD_SANITIZER__)`
`103`	`103`	`threading_mutex_lock(&ref->m);`
`@@ -117,7 +117,7 @@ inline int threading_atomic_ref_count_increment(threading_atomic_ref_count ref)`
`117`	`117`	`return 0;`
`118`	`118`	`}`
`119`	`119`
`120`		`-inline int threading_atomic_ref_count_decrement(threading_atomic_ref_count ref)`
	`120`	`+static inline int threading_atomic_ref_count_decrement(threading_atomic_ref_count ref)`
`121`	`121`	`{`
`122`	`122`	`#if defined(__THREAD_SANITIZER__)`
`123`	`123`	`threading_mutex_lock(&ref->m);`
`@@ -142,7 +142,7 @@ inline int threading_atomic_ref_count_decrement(threading_atomic_ref_count ref)`
`142`	`142`	`return 0;`
`143`	`143`	`}`
`144`	`144`
`145`		`-inline void threading_atomic_ref_count_destroy(threading_atomic_ref_count ref)`
	`145`	`+static inline void threading_atomic_ref_count_destroy(threading_atomic_ref_count ref)`
`146`	`146`	`{`
`147`	`147`	`#if defined(__THREAD_SANITIZER__)`
`148`	`148`	`threading_mutex_destroy(&ref->m);`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ typedef LONG volatile atomic_flag;`
`122`	`122`
`123`	`123`	`#undef __atomic_is_lock_free_power_of_2`
`124`	`124`
`125`		`-inline void atomic_store_explicit8(CHAR volatile *obj, CHAR desired, memory_order order)`
	`125`	`+static inline void atomic_store_explicit8(CHAR volatile *obj, CHAR desired, memory_order order)`
`126`	`126`	`{`
`127`	`127`	`if (order == memory_order_seq_cst)`
`128`	`128`	`{`
`@@ -134,7 +134,7 @@ inline void atomic_store_explicit8(CHAR volatile *obj, CHAR desired, memory_orde`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`
`137`		`-inline void atomic_store_explicit16(SHORT volatile *obj, SHORT desired, memory_order order)`
	`137`	`+static inline void atomic_store_explicit16(SHORT volatile *obj, SHORT desired, memory_order order)`
`138`	`138`	`{`
`139`	`139`	`if (order == memory_order_seq_cst)`
`140`	`140`	`{`
`@@ -146,7 +146,7 @@ inline void atomic_store_explicit16(SHORT volatile *obj, SHORT desired, memory_o`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
`149`		`-inline void atomic_store_explicit32(LONG volatile *obj, LONG desired, memory_order order)`
	`149`	`+static inline void atomic_store_explicit32(LONG volatile *obj, LONG desired, memory_order order)`
`150`	`150`	`{`
`151`	`151`	`if (order == memory_order_seq_cst)`
`152`	`152`	`{`
`@@ -158,7 +158,7 @@ inline void atomic_store_explicit32(LONG volatile *obj, LONG desired, memory_ord`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`		`-inline void atomic_store_explicit64(LONG64 volatile *obj, LONG64 desired, memory_order order)`
	`161`	`+static inline void atomic_store_explicit64(LONG64 volatile *obj, LONG64 desired, memory_order order)`
`162`	`162`	`{`
`163`	`163`	`if (order == memory_order_seq_cst)`
`164`	`164`	`#ifdef _M_IX86`
`@@ -224,7 +224,7 @@ inline void atomic_store_explicit64(LONG64 volatile *obj, LONG64 desired, memory`
`224`	`224`	`(sizeof (obj) == 8) ? _InterlockedExchange64((LONG64 volatile )obj, (LONG64)desired) : \`
`225`	`225`	`(abort(), 0))`
`226`	`226`
`227`		`-inline bool atomic_compare_exchange8(CHAR volatile obj, CHAR expected, CHAR desired)`
	`227`	`+static inline bool atomic_compare_exchange8(CHAR volatile obj, CHAR expected, CHAR desired)`
`228`	`228`	`{`
`229`	`229`	`CHAR previous = _InterlockedCompareExchange8(obj, desired, *expected);`
`230`	`230`	`bool result = (previous == *expected);`
`@@ -237,7 +237,7 @@ inline bool atomic_compare_exchange8(CHAR volatile obj, CHAR expected, CHAR de`
`237`	`237`	`return result;`
`238`	`238`	`}`
`239`	`239`
`240`		`-inline bool atomic_compare_exchange16(SHORT volatile obj, SHORT expected, SHORT desired)`
	`240`	`+static inline bool atomic_compare_exchange16(SHORT volatile obj, SHORT expected, SHORT desired)`
`241`	`241`	`{`
`242`	`242`	`SHORT previous = _InterlockedCompareExchange16(obj, desired, *expected);`
`243`	`243`	`bool result = (previous == *expected);`
`@@ -250,7 +250,7 @@ inline bool atomic_compare_exchange16(SHORT volatile obj, SHORT expected, SHOR`
`250`	`250`	`return result;`
`251`	`251`	`}`
`252`	`252`
`253`		`-inline bool atomic_compare_exchange32(LONG volatile obj, LONG expected, LONG desired)`
	`253`	`+static inline bool atomic_compare_exchange32(LONG volatile obj, LONG expected, LONG desired)`
`254`	`254`	`{`
`255`	`255`	`LONG previous = _InterlockedCompareExchange(obj, desired, *expected);`
`256`	`256`	`bool result = (previous == *expected);`
`@@ -263,7 +263,7 @@ inline bool atomic_compare_exchange32(LONG volatile obj, LONG expected, LONG d`
`263`	`263`	`return result;`
`264`	`264`	`}`
`265`	`265`
`266`		`-inline bool atomic_compare_exchange64(LONG64 volatile obj, LONG64 expected, LONG64 desired)`
	`266`	`+static inline bool atomic_compare_exchange64(LONG64 volatile obj, LONG64 expected, LONG64 desired)`
`267`	`267`	`{`
`268`	`268`	`LONG64 previous = _InterlockedCompareExchange64(obj, desired, *expected);`
`269`	`269`	`bool result = (previous == *expected);`
`@@ -346,7 +346,7 @@ inline bool atomic_compare_exchange64(LONG64 volatile obj, LONG64 expected, LO`
`346`	`346`	`} \`
`347`	`347`	`} while (0)`
`348`	`348`
`349`		`-inline void atomic_thread_fence(memory_order order)`
	`349`	`+static inline void atomic_thread_fence(memory_order order)`
`350`	`350`	`{`
`351`	`351`	`__atomic_compiler_barrier(order);`
`352`	`352`
`@@ -357,7 +357,7 @@ inline void atomic_thread_fence(memory_order order)`
`357`	`357`	`}`
`358`	`358`	`}`
`359`	`359`
`360`		`-inline void atomic_signal_fence(memory_order order)`
	`360`	`+static inline void atomic_signal_fence(memory_order order)`
`361`	`361`	`{`
`362`	`362`	`__atomic_compiler_barrier(order);`
`363`	`363`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ int threading_mutex_unlock(threading_mutex m);`
`75`	`75`
`76`	`76`	`int threading_mutex_destroy(threading_mutex m);`
`77`	`77`
`78`		`-inline int threading_mutex_store(threading_mutex m, void dest, void src, size_t size)`
	`78`	`+static inline int threading_mutex_store(threading_mutex m, void dest, void src, size_t size)`
`79`	`79`	`{`
`80`	`80`	`if (threading_mutex_lock(m) != 0)`
`81`	`81`	`{`
Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,11 @@`
`22`	`22`
`23`	`23`	`#include <threading/threading_mutex.h>`
`24`	`24`
	`25`	`+#include <string.h>`
	`26`	`+`
`25`	`27`	`int threading_mutex_initialize(threading_mutex m)`
`26`	`28`	`{`
`27`		`- m->impl = 0;`
	`29`	`+ memset(&m->impl, 0, sizeof(os_unfair_lock));`
`28`	`30`
`29`	`31`	`return 0;`
`30`	`32`	`}`