From 1de913282989ffc039fc2a7b0879df2e1dbaead4 Mon Sep 17 00:00:00 2001
From: Sam Clegg <sbc@chromium.org>
Date: Mon, 9 Sep 2024 15:29:14 -0700
Subject: [PATCH] [test] Cleanup gcc pthread operations tests

- Convert to C
- Tabs to spaces
- And some print status
---
 ...st_pthread_gcc_64bit_atomic_fetch_and_op.c | 269 +++++++++---------
 ...st_pthread_gcc_64bit_atomic_op_and_fetch.c | 269 +++++++++---------
 .../test_pthread_gcc_atomic_fetch_and_op.c    | 246 ++++++++--------
 .../test_pthread_gcc_atomic_op_and_fetch.c    | 248 ++++++++--------
 test/pthread/test_pthread_gcc_atomics.c       | 132 ++++-----
 test/pthread/test_pthread_gcc_spinlock.c      |  71 +++--
 6 files changed, 603 insertions(+), 632 deletions(-)

diff --git a/test/pthread/test_pthread_gcc_64bit_atomic_fetch_and_op.c b/test/pthread/test_pthread_gcc_64bit_atomic_fetch_and_op.c
index 3150e801f3ca8..6b0c5b5dc2db3 100644
--- a/test/pthread/test_pthread_gcc_64bit_atomic_fetch_and_op.c
+++ b/test/pthread/test_pthread_gcc_64bit_atomic_fetch_and_op.c
@@ -16,161 +16,154 @@
 
 #define T uint64_t
 
-void *thread_fetch_and_add(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_fetch_and_add((T*)arg, 0x0000000100000001ULL);
-	pthread_exit(0);
+void *thread_fetch_and_add(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_fetch_and_add((T*)arg, 0x0000000100000001ULL);
+  }
+  pthread_exit(0);
 }
 
-void *thread_fetch_and_sub(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_fetch_and_sub((T*)arg, 0x0000000100000001ULL);
-	pthread_exit(0);
+void *thread_fetch_and_sub(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_fetch_and_sub((T*)arg, 0x0000000100000001ULL);
+  }
+  pthread_exit(0);
 }
+
 volatile T fetch_and_or_data = 0;
-void *thread_fetch_and_or(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_fetch_and_or((T*)&fetch_and_or_data, *(T*)arg);
-	pthread_exit(0);
+void *thread_fetch_and_or(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_fetch_and_or((T*)&fetch_and_or_data, *(T*)arg);
+  }
+  pthread_exit(0);
 }
 
 volatile T fetch_and_and_data = 0;
-void *thread_fetch_and_and(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_fetch_and_and((T*)&fetch_and_and_data, *(T*)arg);
-	pthread_exit(0);
+void *thread_fetch_and_and(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_fetch_and_and((T*)&fetch_and_and_data, *(T*)arg);
+  }
+  pthread_exit(0);
 }
 
 volatile T fetch_and_xor_data = 0;
-void *thread_fetch_and_xor(void *arg)
-{
-	for(int i = 0; i < 9999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
-		__sync_fetch_and_xor((T*)&fetch_and_xor_data, *(T*)arg);
-	pthread_exit(0);
+void *thread_fetch_and_xor(void *arg) {
+  for (int i = 0; i < 9999; ++i) { // Odd number of times so that the operation doesn't cancel itself out.
+    __sync_fetch_and_xor((T*)&fetch_and_xor_data, *(T*)arg);
+  }
+  pthread_exit(0);
 }
 
 volatile long fetch_and_nand_data = 0;
-void *thread_fetch_and_nand(void *arg)
-{
-	for(int i = 0; i < 9999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
-		__sync_fetch_and_nand((long*)&fetch_and_nand_data, (long)arg);
-	pthread_exit(0);
+void *thread_fetch_and_nand(void *arg) {
+  for (int i = 0; i < 9999; ++i) { // Odd number of times so that the operation doesn't cancel itself out.
+    __sync_fetch_and_nand((long*)&fetch_and_nand_data, (long)arg);
+  }
+  pthread_exit(0);
 }
 
-T threadArg[NUM_THREADS];
-pthread_t thread[NUM_THREADS];
-
 #define HILO(hi, lo) ((((uint64_t)(hi)) << 32) | ((uint64_t)(lo)))
 #define DUP(x) HILO((x), (x))
 
-int main()
-{
-	{
-		T x = HILO(5, 3);
-		T y = __sync_fetch_and_add(&x, DUP(1));
-		assert(y == HILO(5, 3));
-		assert(x == HILO(6, 4));
-		volatile T n = HILO(2, 1);
-		if (emscripten_has_threading_support())
-		{
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_add, (void*)&n);
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-			printf("n: %llx\n", n);
-			assert(n == HILO(NUM_THREADS*10000ULL+2ULL, NUM_THREADS*10000ULL+1ULL));
-		}
-	}
-	{
-		T x = HILO(15, 13);
-		T y = __sync_fetch_and_sub(&x, HILO(10, 10));
-		assert(y == HILO(15, 13));
-		assert(x == HILO(5, 3));
-		volatile T n = HILO(NUM_THREADS*10000ULL+5ULL, NUM_THREADS*10000ULL+3ULL);
-		if (emscripten_has_threading_support())
-		{
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_sub, (void*)&n);
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-			printf("n: %llx\n", n);
-			assert(n == HILO(5,3));
-		}
-	}
-	{
-		T x = HILO(32768 + 5, 5);
-		T y = __sync_fetch_and_or(&x, HILO(65536 + 9, 9));
-		assert(y == HILO(32768 + 5, 5));
-		assert(x == HILO(32768 + 65536 + 13, 13));
-		if (emscripten_has_threading_support())
-		{
-			for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-			{
-				fetch_and_or_data = HILO(65536 + (1<<NUM_THREADS), 1<<NUM_THREADS);
-				for(int i = 0; i < NUM_THREADS; ++i)
-				{
-					threadArg[i] = DUP(1 << i);
-					pthread_create(&thread[i], NULL, thread_fetch_and_or, &threadArg[i]);
-				}
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(fetch_and_or_data == HILO(65536 + (1<<(NUM_THREADS+1))-1, (1<<(NUM_THREADS+1))-1));
-			}
-		}
-	}
-	{
-		T x = HILO(32768 + 5, 5);
-		T y = __sync_fetch_and_and(&x, HILO(32768 + 9, 9));
-		assert(y == HILO(32768 + 5, 5));
-		assert(x == HILO(32768 + 1, 1));
-		if (emscripten_has_threading_support())
-		{
-			for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-			{
-				fetch_and_and_data = HILO(65536 + (1<<(NUM_THREADS+1))-1, (1<<(NUM_THREADS+1))-1);
-				for(int i = 0; i < NUM_THREADS; ++i)
-				{
-					threadArg[i] = DUP(~(1u<<i));
-					pthread_create(&thread[i], NULL, thread_fetch_and_and, (void*)&threadArg[i]);
-				}
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(fetch_and_and_data == HILO(65536 + (1<<NUM_THREADS), 1<<NUM_THREADS));
-			}
-		}
-	}
-	{
-		T x = HILO(32768 + 5, 5);
-		T y = __sync_fetch_and_xor(&x, HILO(16384 + 9, 9));
-		assert(y == HILO(32768 + 5, 5));
-		assert(x == HILO(32768 + 16384 + 12, 12));
-		if (emscripten_has_threading_support())
-		{
-			for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-			{
-				fetch_and_xor_data = HILO(32768 + (1<<NUM_THREADS), 1<<NUM_THREADS);
-				for(int i = 0; i < NUM_THREADS; ++i)
-				{
-					threadArg[i] = DUP(~(1u<<i));
-					pthread_create(&thread[i], NULL, thread_fetch_and_xor, (void*)&threadArg[i]);
-				}
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(fetch_and_xor_data == HILO(32768 + ((1<<(NUM_THREADS+1))-1), (1<<(NUM_THREADS+1))-1));
-			}
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_fetch_and_nand(&x, 9);
-		assert(y == 5);
-		assert(x == -2);
-		const int oddNThreads = NUM_THREADS-1;
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			fetch_and_nand_data = 0;
-			for(int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_nand, (void*)-1);
-			for(int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
-			assert(fetch_and_nand_data == -1);
-		}
-	}
+int main() {
+  T threadArg[NUM_THREADS];
+  pthread_t thread[NUM_THREADS];
+  {
+    printf("__sync_fetch_and_add ..\n");
+    T x = HILO(5, 3);
+    T y = __sync_fetch_and_add(&x, DUP(1));
+    assert(y == HILO(5, 3));
+    assert(x == HILO(6, 4));
+    volatile T n = HILO(2, 1);
+    if (emscripten_has_threading_support()) {
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_add, (void*)&n);
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+      printf("n: %llx\n", n);
+      assert(n == HILO(NUM_THREADS*10000ULL+2ULL, NUM_THREADS*10000ULL+1ULL));
+    }
+  }
+  {
+    printf("__sync_fetch_and_sub ..\n");
+    T x = HILO(15, 13);
+    T y = __sync_fetch_and_sub(&x, HILO(10, 10));
+    assert(y == HILO(15, 13));
+    assert(x == HILO(5, 3));
+    volatile T n = HILO(NUM_THREADS*10000ULL+5ULL, NUM_THREADS*10000ULL+3ULL);
+    if (emscripten_has_threading_support()) {
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_sub, (void*)&n);
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+      printf("n: %llx\n", n);
+      assert(n == HILO(5,3));
+    }
+  }
+  {
+    printf("__sync_fetch_and_or ..\n");
+    T x = HILO(32768 + 5, 5);
+    T y = __sync_fetch_and_or(&x, HILO(65536 + 9, 9));
+    assert(y == HILO(32768 + 5, 5));
+    assert(x == HILO(32768 + 65536 + 13, 13));
+    if (emscripten_has_threading_support()) {
+      for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+        fetch_and_or_data = HILO(65536 + (1<<NUM_THREADS), 1<<NUM_THREADS);
+        for (int i = 0; i < NUM_THREADS; ++i) {
+          threadArg[i] = DUP(1 << i);
+          pthread_create(&thread[i], NULL, thread_fetch_and_or, &threadArg[i]);
+        }
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(fetch_and_or_data == HILO(65536 + (1<<(NUM_THREADS+1))-1, (1<<(NUM_THREADS+1))-1));
+      }
+    }
+  }
+  {
+    printf("__sync_fetch_and_and ..\n");
+    T x = HILO(32768 + 5, 5);
+    T y = __sync_fetch_and_and(&x, HILO(32768 + 9, 9));
+    assert(y == HILO(32768 + 5, 5));
+    assert(x == HILO(32768 + 1, 1));
+    if (emscripten_has_threading_support()) {
+      for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+        fetch_and_and_data = HILO(65536 + (1<<(NUM_THREADS+1))-1, (1<<(NUM_THREADS+1))-1);
+        for (int i = 0; i < NUM_THREADS; ++i) {
+          threadArg[i] = DUP(~(1u<<i));
+          pthread_create(&thread[i], NULL, thread_fetch_and_and, (void*)&threadArg[i]);
+        }
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(fetch_and_and_data == HILO(65536 + (1<<NUM_THREADS), 1<<NUM_THREADS));
+      }
+    }
+  }
+  {
+    printf("__sync_fetch_and_xor ..\n");
+    T x = HILO(32768 + 5, 5);
+    T y = __sync_fetch_and_xor(&x, HILO(16384 + 9, 9));
+    assert(y == HILO(32768 + 5, 5));
+    assert(x == HILO(32768 + 16384 + 12, 12));
+    if (emscripten_has_threading_support()) {
+      for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+        fetch_and_xor_data = HILO(32768 + (1<<NUM_THREADS), 1<<NUM_THREADS);
+        for (int i = 0; i < NUM_THREADS; ++i) {
+          threadArg[i] = DUP(~(1u<<i));
+          pthread_create(&thread[i], NULL, thread_fetch_and_xor, (void*)&threadArg[i]);
+        }
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(fetch_and_xor_data == HILO(32768 + ((1<<(NUM_THREADS+1))-1), (1<<(NUM_THREADS+1))-1));
+      }
+    }
+  }
+  {
+    printf("__sync_fetch_and_nand ..\n");
+    T x = 5;
+    T y = __sync_fetch_and_nand(&x, 9);
+    assert(y == 5);
+    assert(x == -2);
+    const int oddNThreads = NUM_THREADS-1;
+    for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+      fetch_and_nand_data = 0;
+      for (int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_nand, (void*)-1);
+      for (int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
+      assert(fetch_and_nand_data == -1);
+    }
+  }
 
-	return 0;
+  return 0;
 }
diff --git a/test/pthread/test_pthread_gcc_64bit_atomic_op_and_fetch.c b/test/pthread/test_pthread_gcc_64bit_atomic_op_and_fetch.c
index 7045619154c27..5089812cef9b4 100644
--- a/test/pthread/test_pthread_gcc_64bit_atomic_op_and_fetch.c
+++ b/test/pthread/test_pthread_gcc_64bit_atomic_op_and_fetch.c
@@ -16,161 +16,156 @@
 
 #define T uint64_t
 
-void *thread_add_and_fetch(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_add_and_fetch((T*)arg, 0x0000000100000001ULL);
-	pthread_exit(0);
+void *thread_add_and_fetch(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_add_and_fetch((T*)arg, 0x0000000100000001ULL);
+  }
+  pthread_exit(0);
 }
 
-void *thread_sub_and_fetch(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_sub_and_fetch((T*)arg, 0x0000000100000001ULL);
-	pthread_exit(0);
+void *thread_sub_and_fetch(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_sub_and_fetch((T*)arg, 0x0000000100000001ULL);
+  }
+  pthread_exit(0);
 }
+
 volatile T or_and_fetch_data = 0;
-void *thread_or_and_fetch(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_or_and_fetch((T*)&or_and_fetch_data, *(T*)arg);
-	pthread_exit(0);
+void *thread_or_and_fetch(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_or_and_fetch((T*)&or_and_fetch_data, *(T*)arg);
+  }
+  pthread_exit(0);
 }
 
 volatile T and_and_fetch_data = 0;
-void *thread_and_and_fetch(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_and_and_fetch((T*)&and_and_fetch_data, *(T*)arg);
-	pthread_exit(0);
+void *thread_and_and_fetch(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_and_and_fetch((T*)&and_and_fetch_data, *(T*)arg);
+  }
+  pthread_exit(0);
 }
 
 volatile T xor_and_fetch_data = 0;
-void *thread_xor_and_fetch(void *arg)
-{
-	for(int i = 0; i < 9999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
-		__sync_xor_and_fetch((T*)&xor_and_fetch_data, *(T*)arg);
-	pthread_exit(0);
+void *thread_xor_and_fetch(void *arg) {
+  for (int i = 0; i < 9999; ++i) { // Odd number of times so that the operation doesn't cancel itself out.
+    __sync_xor_and_fetch((T*)&xor_and_fetch_data, *(T*)arg);
+  }
+  pthread_exit(0);
 }
 
 volatile T nand_and_fetch_data = 0;
-void *thread_nand_and_fetch(void *arg)
-{
-	for(int i = 0; i < 9999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
-		__sync_nand_and_fetch((T*)&nand_and_fetch_data, (T)arg);
-	pthread_exit(0);
+void *thread_nand_and_fetch(void *arg) {
+  for (int i = 0; i < 9999; ++i) { // Odd number of times so that the operation doesn't cancel itself out.
+    __sync_nand_and_fetch((T*)&nand_and_fetch_data, (T)arg);
+  }
+  pthread_exit(0);
 }
 
-T threadArg[NUM_THREADS];
-pthread_t thread[NUM_THREADS];
 
 #define HILO(hi, lo) ((((uint64_t)(hi)) << 32) | ((uint64_t)(lo)))
 #define DUP(x) HILO((x), (x))
 
-int main()
-{
-	{
-		T x = HILO(5, 3);
-		T y = __sync_add_and_fetch(&x, DUP(1));
-		assert(y == HILO(6, 4));
-		assert(x == HILO(6, 4));
-		volatile T n = HILO(2, 1);
-		if (emscripten_has_threading_support())
-		{
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_add_and_fetch, (void*)&n);
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-			printf("n: %llx\n", n);
-			assert(n == HILO(NUM_THREADS*10000ULL+2ULL, NUM_THREADS*10000ULL+1ULL));
-		}
-	}
-	{
-		T x = HILO(15, 13);
-		T y = __sync_sub_and_fetch(&x, HILO(10, 10));
-		assert(y == HILO(5, 3));
-		assert(x == HILO(5, 3));
-		volatile T n = HILO(NUM_THREADS*10000ULL+5ULL, NUM_THREADS*10000ULL+3ULL);
-		if (emscripten_has_threading_support())
-		{
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_sub_and_fetch, (void*)&n);
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-			printf("n: %llx\n", n);
-			assert(n == HILO(5,3));
-		}
-	}
-	{
-		T x = HILO(32768 + 5, 5);
-		T y = __sync_or_and_fetch(&x, HILO(65536 + 9, 9));
-		assert(y == HILO(32768 + 65536 + 13, 13));
-		assert(x == HILO(32768 + 65536 + 13, 13));
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			or_and_fetch_data = HILO(65536 + (1<<NUM_THREADS), 1<<NUM_THREADS);
-			if (emscripten_has_threading_support())
-			{
-				for(int i = 0; i < NUM_THREADS; ++i)
-				{
-					threadArg[i] = DUP(1 << i);
-					pthread_create(&thread[i], NULL, thread_or_and_fetch, (void*)&threadArg[i]);
-				}
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(or_and_fetch_data == HILO(65536 + (1<<(NUM_THREADS+1))-1, (1<<(NUM_THREADS+1))-1));
-			}
-		}
-	}
-	{
-		T x = HILO(32768 + 5, 5);
-		T y = __sync_and_and_fetch(&x, HILO(32768 + 9, 9));
-		assert(y == HILO(32768 + 1, 1));
-		assert(x == HILO(32768 + 1, 1));
-		if (emscripten_has_threading_support())
-		{
-			for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-			{
-				and_and_fetch_data = HILO(65536 + (1<<(NUM_THREADS+1))-1, (1<<(NUM_THREADS+1))-1);
-				for(int i = 0; i < NUM_THREADS; ++i)
-				{
-					threadArg[i] = DUP(~(1U<<i));
-					pthread_create(&thread[i], NULL, thread_and_and_fetch, (void*)&threadArg[i]);
-				}
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(and_and_fetch_data == HILO(65536 + (1<<NUM_THREADS), 1<<NUM_THREADS));
-			}
-		}
-	}
-	{
-		T x = HILO(32768 + 5, 5);
-		T y = __sync_xor_and_fetch(&x, HILO(16384 + 9, 9));
-		assert(y == HILO(32768 + 16384 + 12, 12));
-		assert(x == HILO(32768 + 16384 + 12, 12));
-		if (emscripten_has_threading_support())
-		{
-			for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-			{
-				xor_and_fetch_data = HILO(32768 + (1<<NUM_THREADS), 1<<NUM_THREADS);
-				for(int i = 0; i < NUM_THREADS; ++i)
-				{
-					threadArg[i] = DUP(~(1U<<i));
-					pthread_create(&thread[i], NULL, thread_xor_and_fetch, (void*)&threadArg[i]);
-				}
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(xor_and_fetch_data == HILO(32768 + ((1<<(NUM_THREADS+1))-1), (1<<(NUM_THREADS+1))-1));
-			}
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_nand_and_fetch(&x, 9);
-		assert(y == -2);
-		assert(x == -2);
-		const int oddNThreads = NUM_THREADS-1;
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			nand_and_fetch_data = 0;
-			for(int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_nand_and_fetch, (void*)-1);
-			for(int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
-			assert(nand_and_fetch_data == -1);
-		}
-	}
+int main() {
+  T threadArg[NUM_THREADS];
+  pthread_t thread[NUM_THREADS];
+
+  {
+    printf("__sync_add_and_fetch ..\n");
+    T x = HILO(5, 3);
+    T y = __sync_add_and_fetch(&x, DUP(1));
+    assert(y == HILO(6, 4));
+    assert(x == HILO(6, 4));
+    volatile T n = HILO(2, 1);
+    if (emscripten_has_threading_support()) {
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_add_and_fetch, (void*)&n);
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+      printf("n: %llx\n", n);
+      assert(n == HILO(NUM_THREADS*10000ULL+2ULL, NUM_THREADS*10000ULL+1ULL));
+    }
+  }
+  {
+    printf("__sync_sub_and_fetch ..\n");
+    T x = HILO(15, 13);
+    T y = __sync_sub_and_fetch(&x, HILO(10, 10));
+    assert(y == HILO(5, 3));
+    assert(x == HILO(5, 3));
+    volatile T n = HILO(NUM_THREADS*10000ULL+5ULL, NUM_THREADS*10000ULL+3ULL);
+    if (emscripten_has_threading_support()) {
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_sub_and_fetch, (void*)&n);
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+      printf("n: %llx\n", n);
+      assert(n == HILO(5,3));
+    }
+  }
+  {
+    printf("__sync_or_and_fetch ..\n");
+    T x = HILO(32768 + 5, 5);
+    T y = __sync_or_and_fetch(&x, HILO(65536 + 9, 9));
+    assert(y == HILO(32768 + 65536 + 13, 13));
+    assert(x == HILO(32768 + 65536 + 13, 13));
+    for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+      or_and_fetch_data = HILO(65536 + (1<<NUM_THREADS), 1<<NUM_THREADS);
+      if (emscripten_has_threading_support()) {
+        for (int i = 0; i < NUM_THREADS; ++i) {
+          threadArg[i] = DUP(1 << i);
+          pthread_create(&thread[i], NULL, thread_or_and_fetch, (void*)&threadArg[i]);
+        }
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(or_and_fetch_data == HILO(65536 + (1<<(NUM_THREADS+1))-1, (1<<(NUM_THREADS+1))-1));
+      }
+    }
+  }
+  {
+    printf("__sync_and_and_fetch ..\n");
+    T x = HILO(32768 + 5, 5);
+    T y = __sync_and_and_fetch(&x, HILO(32768 + 9, 9));
+    assert(y == HILO(32768 + 1, 1));
+    assert(x == HILO(32768 + 1, 1));
+    if (emscripten_has_threading_support()) {
+      for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+        and_and_fetch_data = HILO(65536 + (1<<(NUM_THREADS+1))-1, (1<<(NUM_THREADS+1))-1);
+        for (int i = 0; i < NUM_THREADS; ++i) {
+          threadArg[i] = DUP(~(1U<<i));
+          pthread_create(&thread[i], NULL, thread_and_and_fetch, (void*)&threadArg[i]);
+        }
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(and_and_fetch_data == HILO(65536 + (1<<NUM_THREADS), 1<<NUM_THREADS));
+      }
+    }
+  }
+  {
+    printf("__sync_xor_and_fetch ..\n");
+    T x = HILO(32768 + 5, 5);
+    T y = __sync_xor_and_fetch(&x, HILO(16384 + 9, 9));
+    assert(y == HILO(32768 + 16384 + 12, 12));
+    assert(x == HILO(32768 + 16384 + 12, 12));
+    if (emscripten_has_threading_support()) {
+      for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+        xor_and_fetch_data = HILO(32768 + (1<<NUM_THREADS), 1<<NUM_THREADS);
+        for (int i = 0; i < NUM_THREADS; ++i) {
+          threadArg[i] = DUP(~(1U<<i));
+          pthread_create(&thread[i], NULL, thread_xor_and_fetch, (void*)&threadArg[i]);
+        }
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(xor_and_fetch_data == HILO(32768 + ((1<<(NUM_THREADS+1))-1), (1<<(NUM_THREADS+1))-1));
+      }
+    }
+  }
+  {
+    printf("__sync_nand_and_fetch ..\n");
+    T x = 5;
+    T y = __sync_nand_and_fetch(&x, 9);
+    assert(y == -2);
+    assert(x == -2);
+    const int oddNThreads = NUM_THREADS-1;
+    for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+      nand_and_fetch_data = 0;
+      for (int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_nand_and_fetch, (void*)-1);
+      for (int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
+      assert(nand_and_fetch_data == -1);
+    }
+  }
 
-	return 0;
+  return 0;
 }
diff --git a/test/pthread/test_pthread_gcc_atomic_fetch_and_op.c b/test/pthread/test_pthread_gcc_atomic_fetch_and_op.c
index 1130f2452b78c..dfa72e27b0945 100644
--- a/test/pthread/test_pthread_gcc_atomic_fetch_and_op.c
+++ b/test/pthread/test_pthread_gcc_atomic_fetch_and_op.c
@@ -16,150 +16,146 @@
 
 #define T int
 
-void *thread_fetch_and_add(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_fetch_and_add((int*)arg, 1);
-	pthread_exit(0);
+void *thread_fetch_and_add(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_fetch_and_add((int*)arg, 1);
+  }
+  pthread_exit(0);
 }
 
-void *thread_fetch_and_sub(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_fetch_and_sub((int*)arg, 1);
-	pthread_exit(0);
+void *thread_fetch_and_sub(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_fetch_and_sub((int*)arg, 1);
+  }
+  pthread_exit(0);
 }
 
 volatile long fetch_and_or_data = 0;
-void *thread_fetch_and_or(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_fetch_and_or(&fetch_and_or_data, (long)arg);
-	pthread_exit(0);
+void *thread_fetch_and_or(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_fetch_and_or(&fetch_and_or_data, (long)arg);
+  }
+  pthread_exit(0);
 }
 
 volatile long fetch_and_and_data = 0;
-void *thread_fetch_and_and(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_fetch_and_and(&fetch_and_and_data, (long)arg);
-	pthread_exit(0);
+void *thread_fetch_and_and(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_fetch_and_and(&fetch_and_and_data, (long)arg);
+  }
+  pthread_exit(0);
 }
 
 volatile long fetch_and_xor_data = 0;
-void *thread_fetch_and_xor(void *arg)
-{
-	for(int i = 0; i < 9999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
-		__sync_fetch_and_xor(&fetch_and_xor_data, (long)arg);
-	pthread_exit(0);
+void *thread_fetch_and_xor(void *arg) {
+  for (int i = 0; i < 9999; ++i) { // Odd number of times so that the operation doesn't cancel itself out.
+    __sync_fetch_and_xor(&fetch_and_xor_data, (long)arg);
+  }
+  pthread_exit(0);
 }
 
 // XXX NAND support does not exist in Atomics API.
 volatile long fetch_and_nand_data = 0;
-void *thread_fetch_and_nand(void *arg)
-{
-	for(int i = 0; i < 9999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
-		__sync_fetch_and_nand(&fetch_and_nand_data, (long)arg);
-	pthread_exit(0);
+void *thread_fetch_and_nand(void *arg) {
+  for (int i = 0; i < 9999; ++i) { // Odd number of times so that the operation doesn't cancel itself out.
+    __sync_fetch_and_nand(&fetch_and_nand_data, (long)arg);
+  }
+  pthread_exit(0);
 }
 
-pthread_t thread[NUM_THREADS];
+int main() {
+  pthread_t thread[NUM_THREADS];
 
-int main()
-{
-	{
-		T x = 5;
-		T y = __sync_fetch_and_add(&x, 10);
-		assert(y == 5);
-		assert(x == 15);
-		volatile int n = 1;
-		if (emscripten_has_threading_support())
-		{
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_add, (void*)&n);
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-			assert(n == NUM_THREADS*10000+1);
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_fetch_and_sub(&x, 10);
-		assert(y == 5);
-		assert(x == -5);
-		volatile int n = 1;
-		if (emscripten_has_threading_support())
-		{
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_sub, (void*)&n);
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-			assert(n == 1-NUM_THREADS*10000);
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_fetch_and_or(&x, 9);
-		assert(y == 5);
-		assert(x == 13);
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			fetch_and_or_data = (1<<NUM_THREADS);
-			if (emscripten_has_threading_support())
-			{
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_or, (void*)(1ll<<i));
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(fetch_and_or_data == (1<<(NUM_THREADS+1))-1);
-			}
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_fetch_and_and(&x, 9);
-		assert(y == 5);
-		assert(x == 1);
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			fetch_and_and_data = (1<<(NUM_THREADS+1))-1;
-			if (emscripten_has_threading_support())
-			{
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_and, (void*)(~(1ll<<i)));
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(fetch_and_and_data == 1<<NUM_THREADS);
-			}
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_fetch_and_xor(&x, 9);
-		assert(y == 5);
-		assert(x == 12);
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			fetch_and_xor_data = 1<<NUM_THREADS;
-			if (emscripten_has_threading_support())
-			{
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_xor, (void*)(~(1ll<<i)));
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(fetch_and_xor_data == (1<<(NUM_THREADS+1))-1);
-			}
-		}
-	}
+  {
+    printf("__sync_fetch_and_add ..\n");
+    T x = 5;
+    T y = __sync_fetch_and_add(&x, 10);
+    assert(y == 5);
+    assert(x == 15);
+    volatile int n = 1;
+    if (emscripten_has_threading_support()) {
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_add, (void*)&n);
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+      assert(n == NUM_THREADS*10000+1);
+    }
+  }
+  {
+    printf("__sync_fetch_and_sub ..\n");
+    T x = 5;
+    T y = __sync_fetch_and_sub(&x, 10);
+    assert(y == 5);
+    assert(x == -5);
+    volatile int n = 1;
+    if (emscripten_has_threading_support()) {
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_sub, (void*)&n);
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+      assert(n == 1-NUM_THREADS*10000);
+    }
+  }
+  {
+    printf("__sync_fetch_and_or ..\n");
+    T x = 5;
+    T y = __sync_fetch_and_or(&x, 9);
+    assert(y == 5);
+    assert(x == 13);
+    for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+      fetch_and_or_data = (1<<NUM_THREADS);
+      if (emscripten_has_threading_support()) {
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_or, (void*)(1ll<<i));
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(fetch_and_or_data == (1<<(NUM_THREADS+1))-1);
+      }
+    }
+  }
+  {
+    printf("__sync_fetch_and_and ..\n");
+    T x = 5;
+    T y = __sync_fetch_and_and(&x, 9);
+    assert(y == 5);
+    assert(x == 1);
+    for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+      fetch_and_and_data = (1<<(NUM_THREADS+1))-1;
+      if (emscripten_has_threading_support()) {
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_and, (void*)(~(1ll<<i)));
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(fetch_and_and_data == 1<<NUM_THREADS);
+      }
+    }
+  }
+  {
+    printf("__sync_fetch_and_xor ..\n");
+    T x = 5;
+    T y = __sync_fetch_and_xor(&x, 9);
+    assert(y == 5);
+    assert(x == 12);
+    for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+      fetch_and_xor_data = 1<<NUM_THREADS;
+      if (emscripten_has_threading_support()) {
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_xor, (void*)(~(1ll<<i)));
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(fetch_and_xor_data == (1<<(NUM_THREADS+1))-1);
+      }
+    }
+  }
 
-	{
-		T x = 5;
-		T y = __sync_fetch_and_nand(&x, 9);
-		assert(y == 5);
-		assert(x == -2);
-		const int oddNThreads = NUM_THREADS-1;
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			fetch_and_nand_data = 0;
-			for(int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_nand, (void*)-1);
-			for(int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
-			assert(fetch_and_nand_data == -1);
-		}
-	}
+  {
+    printf("__sync_fetch_and_nand ..\n");
+    T x = 5;
+    T y = __sync_fetch_and_nand(&x, 9);
+    assert(y == 5);
+    assert(x == -2);
+    const int oddNThreads = NUM_THREADS-1;
+    for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+      fetch_and_nand_data = 0;
+      for (int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_fetch_and_nand, (void*)-1);
+      for (int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
+      assert(fetch_and_nand_data == -1);
+    }
+  }
 
-	// Test that regex replacing also works on these.
-	emscripten_atomic_fence();
-	__sync_synchronize();
+  // Test that regex replacing also works on these.
+  emscripten_atomic_fence();
+  __sync_synchronize();
 
-	return 0;
+  return 0;
 }
diff --git a/test/pthread/test_pthread_gcc_atomic_op_and_fetch.c b/test/pthread/test_pthread_gcc_atomic_op_and_fetch.c
index 7c13dcc86844c..4b89d3ba13db3 100644
--- a/test/pthread/test_pthread_gcc_atomic_op_and_fetch.c
+++ b/test/pthread/test_pthread_gcc_atomic_op_and_fetch.c
@@ -16,144 +16,148 @@
 
 #define T int
 
-void *thread_add_and_fetch(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_add_and_fetch((int*)arg, 1);
-	pthread_exit(0);
+void *thread_add_and_fetch(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_add_and_fetch((int*)arg, 1);
+  }
+  pthread_exit(0);
 }
 
-void *thread_sub_and_fetch(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_sub_and_fetch((int*)arg, 1);
-	pthread_exit(0);
+void *thread_sub_and_fetch(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_sub_and_fetch((int*)arg, 1);
+  }
+  pthread_exit(0);
 }
 
 volatile long or_and_fetch_data = 0;
-void *thread_or_and_fetch(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_or_and_fetch((long*)&or_and_fetch_data, (long)arg);
-	pthread_exit(0);
+void *thread_or_and_fetch(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_or_and_fetch((long*)&or_and_fetch_data, (long)arg);
+  }
+  pthread_exit(0);
 }
 
 volatile long and_and_fetch_data = 0;
-void *thread_and_and_fetch(void *arg)
-{
-	for(int i = 0; i < 10000; ++i)
-		__sync_and_and_fetch((long*)&and_and_fetch_data, (long)arg);
-	pthread_exit(0);
+void *thread_and_and_fetch(void *arg) {
+  for (int i = 0; i < 10000; ++i) {
+    __sync_and_and_fetch((long*)&and_and_fetch_data, (long)arg);
+  }
+  pthread_exit(0);
 }
 
 volatile long xor_and_fetch_data = 0;
-void *thread_xor_and_fetch(void *arg)
-{
-	for(int i = 0; i < 9999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
-		__sync_xor_and_fetch((long*)&xor_and_fetch_data, (long)arg);
-	pthread_exit(0);
+void *thread_xor_and_fetch(void *arg) {
+  for (int i = 0; i < 9999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
+    __sync_xor_and_fetch((long*)&xor_and_fetch_data, (long)arg);
+  pthread_exit(0);
 }
 
 volatile long nand_and_fetch_data = 0;
-void *thread_nand_and_fetch(void *arg)
-{
-	for(int i = 0; i < 9999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
-		__sync_nand_and_fetch((long*)&nand_and_fetch_data, (long)arg);
-	pthread_exit(0);
+void *thread_nand_and_fetch(void *arg) {
+  for (int i = 0; i < 9999; ++i) { // Odd number of times so that the operation doesn't cancel itself out.
+    __sync_nand_and_fetch((long*)&nand_and_fetch_data, (long)arg);
+  }
+  pthread_exit(0);
 }
 
-pthread_t thread[NUM_THREADS];
+int main() {
+  pthread_t thread[NUM_THREADS];
 
-int main()
-{
-	{
-		T x = 5;
-		T y = __sync_add_and_fetch(&x, 10);
-		assert(y == 15);
-		assert(x == 15);
-		volatile int n = 1;
-		if (emscripten_has_threading_support())
-		{
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_add_and_fetch, (void*)&n);
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-			assert(n == NUM_THREADS*10000+1);
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_sub_and_fetch(&x, 10);
-		assert(y == -5);
-		assert(x == -5);
-		volatile int n = 1;
-		if (emscripten_has_threading_support())
-		{
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_sub_and_fetch, (void*)&n);
-			for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-			assert(n == 1-NUM_THREADS*10000);
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_or_and_fetch(&x, 9);
-		assert(y == 13);
-		assert(x == 13);
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			or_and_fetch_data = (1<<NUM_THREADS);
-			if (emscripten_has_threading_support())
-			{
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_or_and_fetch, (void*)(1ll<<i));
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(or_and_fetch_data == (1<<(NUM_THREADS+1))-1);
-			}
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_and_and_fetch(&x, 9);
-		assert(y == 1);
-		assert(x == 1);
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			and_and_fetch_data = (1<<(NUM_THREADS+1))-1;
-			if (emscripten_has_threading_support())
-			{
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_and_and_fetch, (void*)(~(1ll<<i)));
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(and_and_fetch_data == 1<<NUM_THREADS);
-			}
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_xor_and_fetch(&x, 9);
-		assert(y == 12);
-		assert(x == 12);
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			xor_and_fetch_data = 1<<NUM_THREADS;
-			if (emscripten_has_threading_support())
-			{
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_xor_and_fetch, (void*)(~(1ll<<i)));
-				for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
-				assert(xor_and_fetch_data == (1<<(NUM_THREADS+1))-1);
-			}
-		}
-	}
-	{
-		T x = 5;
-		T y = __sync_nand_and_fetch(&x, 9);
-		assert(y == -2);
-		assert(x == -2);
-		const int oddNThreads = NUM_THREADS-1;
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			nand_and_fetch_data = 0;
-			for(int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_nand_and_fetch, (void*)-1);
-			for(int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
-			assert(nand_and_fetch_data == -1);
-		}
-	}
+  {
+    printf("__sync_add_and_fetch ..\n");
+    T x = 5;
+    T y = __sync_add_and_fetch(&x, 10);
+    assert(y == 15);
+    assert(x == 15);
+    volatile int n = 1;
+    if (emscripten_has_threading_support())
+    {
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_add_and_fetch, (void*)&n);
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+      assert(n == NUM_THREADS*10000+1);
+    }
+  }
+  {
+    printf("__sync_sub_and_fetch ..\n");
+    T x = 5;
+    T y = __sync_sub_and_fetch(&x, 10);
+    assert(y == -5);
+    assert(x == -5);
+    volatile int n = 1;
+    if (emscripten_has_threading_support())
+    {
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_sub_and_fetch, (void*)&n);
+      for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+      assert(n == 1-NUM_THREADS*10000);
+    }
+  }
+  {
+    printf("__sync_or_and_fetch ..\n");
+    T x = 5;
+    T y = __sync_or_and_fetch(&x, 9);
+    assert(y == 13);
+    assert(x == 13);
+    for (int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
+    {
+      or_and_fetch_data = (1<<NUM_THREADS);
+      if (emscripten_has_threading_support())
+      {
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_or_and_fetch, (void*)(1ll<<i));
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(or_and_fetch_data == (1<<(NUM_THREADS+1))-1);
+      }
+    }
+  }
+  {
+    printf("__sync_and_and_fetch ..\n");
+    T x = 5;
+    T y = __sync_and_and_fetch(&x, 9);
+    assert(y == 1);
+    assert(x == 1);
+    for (int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
+    {
+      and_and_fetch_data = (1<<(NUM_THREADS+1))-1;
+      if (emscripten_has_threading_support())
+      {
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_and_and_fetch, (void*)(~(1ll<<i)));
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(and_and_fetch_data == 1<<NUM_THREADS);
+      }
+    }
+  }
+  {
+    printf("__sync_xor_and_fetch ..\n");
+    T x = 5;
+    T y = __sync_xor_and_fetch(&x, 9);
+    assert(y == 12);
+    assert(x == 12);
+    for (int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
+    {
+      xor_and_fetch_data = 1<<NUM_THREADS;
+      if (emscripten_has_threading_support())
+      {
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_xor_and_fetch, (void*)(~(1ll<<i)));
+        for (int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
+        assert(xor_and_fetch_data == (1<<(NUM_THREADS+1))-1);
+      }
+    }
+  }
+  {
+    printf("__sync_nand_and_fetch ..\n");
+    T x = 5;
+    T y = __sync_nand_and_fetch(&x, 9);
+    assert(y == -2);
+    assert(x == -2);
+    const int oddNThreads = NUM_THREADS-1;
+    for (int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
+    {
+      nand_and_fetch_data = 0;
+      for (int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_nand_and_fetch, (void*)-1);
+      for (int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
+      assert(nand_and_fetch_data == -1);
+    }
+  }
 
-	return 0;
+  return 0;
 }
diff --git a/test/pthread/test_pthread_gcc_atomics.c b/test/pthread/test_pthread_gcc_atomics.c
index 79f667925f13e..0ab87efeb0687 100644
--- a/test/pthread/test_pthread_gcc_atomics.c
+++ b/test/pthread/test_pthread_gcc_atomics.c
@@ -23,90 +23,80 @@
 
 #define Bool int
 
-Bool atomic_bool_cas_u32(T *ptr, T oldVal, T newVal)
-{
-	T old = emscripten_atomic_cas_u32(ptr, oldVal, newVal);
-	return old == oldVal;
+Bool atomic_bool_cas_u32(T *ptr, T oldVal, T newVal) {
+  T old = emscripten_atomic_cas_u32(ptr, oldVal, newVal);
+  return old == oldVal;
 }
 
 // Test __sync_val_compare_and_swap.
-T nand_and_fetch(T *ptr, T x)
-{
-	for(;;)
-	{
-		T old = emscripten_atomic_load_u32(ptr);
-		T newVal = ~(old & x);
-		T old2 = __sync_val_compare_and_swap(ptr, old, newVal);
-		if (old2 == old) return newVal;
-	}
+T nand_and_fetch(T *ptr, T x) {
+  for (;;) {
+    T old = emscripten_atomic_load_u32(ptr);
+    T newVal = ~(old & x);
+    T old2 = __sync_val_compare_and_swap(ptr, old, newVal);
+    if (old2 == old) return newVal;
+  }
 }
 
 // Test __sync_bool_compare_and_swap.
-T nand_and_fetch_bool(T *ptr, T x)
-{
-	for(;;)
-	{
-		T old = emscripten_atomic_load_u32(ptr);
-		T newVal = ~(old & x);
-		Bool success = __sync_bool_compare_and_swap(ptr, old, newVal);
-		if (success) return newVal;
-	}
+T nand_and_fetch_bool(T *ptr, T x) {
+  for (;;) {
+    T old = emscripten_atomic_load_u32(ptr);
+    T newVal = ~(old & x);
+    Bool success = __sync_bool_compare_and_swap(ptr, old, newVal);
+    if (success) return newVal;
+  }
 }
 
 volatile int nand_and_fetch_data = 0;
-void *thread_nand_and_fetch(void *arg)
-{
-	for(int i = 0; i < 999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
-		nand_and_fetch((int*)&nand_and_fetch_data, (int)(long)arg);
-	pthread_exit(0);
+void *thread_nand_and_fetch(void *arg) {
+  for (int i = 0; i < 999; ++i) { // Odd number of times so that the operation doesn't cancel itself out.
+    nand_and_fetch((int*)&nand_and_fetch_data, (int)(long)arg);
+  }
+  pthread_exit(0);
 }
 
-void *thread_nand_and_fetch_bool(void *arg)
-{
-	for(int i = 0; i < 999; ++i) // Odd number of times so that the operation doesn't cancel itself out.
-		nand_and_fetch_bool((int*)&nand_and_fetch_data, (int)(long)arg);
-	pthread_exit(0);
+void *thread_nand_and_fetch_bool(void *arg) {
+  for (int i = 0; i < 999; ++i) { // Odd number of times so that the operation doesn't cancel itself out.
+    nand_and_fetch_bool((int*)&nand_and_fetch_data, (int)(long)arg);
+  }
+  pthread_exit(0);
 }
 
-pthread_t thread[NUM_THREADS];
+int main() {
+  pthread_t thread[NUM_THREADS];
 
-int main()
-{
-	{
-		T x = 5;
-		T y = nand_and_fetch(&x, 9);
-		assert(y == -2);
-		assert(x == -2);
-		const int oddNThreads = NUM_THREADS-1;
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			nand_and_fetch_data = 0;
-			__sync_synchronize(); // This has no effect in this code, but called in here just to test that the compiler generates a valid expression for this.
-			if (emscripten_has_threading_support())
-			{
-				for(int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_nand_and_fetch, (void*)-1);
-				for(int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
-				assert(nand_and_fetch_data == -1);
-			}
-		}
-	}
-	{
-		T x = 5;
-		T y = nand_and_fetch_bool(&x, 9);
-		assert(y == -2);
-		assert(x == -2);
-		const int oddNThreads = NUM_THREADS-1;
-		for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
-		{
-			nand_and_fetch_data = 0;
-			if (emscripten_has_threading_support())
-			{
-				for(int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_nand_and_fetch_bool, (void*)-1);
-				for(int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
-				assert(nand_and_fetch_data == -1);
-			}
-		}
-	}
+  {
+    T x = 5;
+    T y = nand_and_fetch(&x, 9);
+    assert(y == -2);
+    assert(x == -2);
+    const int oddNThreads = NUM_THREADS-1;
+    for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+      nand_and_fetch_data = 0;
+      __sync_synchronize(); // This has no effect in this code, but called in here just to test that the compiler generates a valid expression for this.
+      if (emscripten_has_threading_support()) {
+        for (int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_nand_and_fetch, (void*)-1);
+        for (int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
+        assert(nand_and_fetch_data == -1);
+      }
+    }
+  }
+  {
+    T x = 5;
+    T y = nand_and_fetch_bool(&x, 9);
+    assert(y == -2);
+    assert(x == -2);
+    const int oddNThreads = NUM_THREADS-1;
+    for (int x = 0; x < 100; ++x) { // Test a few times for robustness, since this test is so short-lived.
+      nand_and_fetch_data = 0;
+      if (emscripten_has_threading_support()) {
+        for (int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_nand_and_fetch_bool, (void*)-1);
+        for (int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
+        assert(nand_and_fetch_data == -1);
+      }
+    }
+  }
 
-	return 0;
+  return 0;
 }
diff --git a/test/pthread/test_pthread_gcc_spinlock.c b/test/pthread/test_pthread_gcc_spinlock.c
index a233781323ab4..6deeb7e963dff 100644
--- a/test/pthread/test_pthread_gcc_spinlock.c
+++ b/test/pthread/test_pthread_gcc_spinlock.c
@@ -14,56 +14,49 @@
 volatile int counter = 0; // Shared data
 volatile int lock = 0; // spinlock "mutex" variable
 
-
-void *ThreadMain(void *arg)
-{
-	printf("Thread started.\n");
-	for(int i = 0; i < 100; ++i)
-	{
+void *ThreadMain(void *arg) {
+  printf("Thread started.\n");
+  for (int i = 0; i < 100; ++i) {
 #ifdef USE_EMSCRIPTEN_INTRINSICS
-		while(emscripten_atomic_exchange_u32((void*)&lock, 1))
+    while(emscripten_atomic_exchange_u32((void*)&lock, 1))
 #else
-		while(__sync_lock_test_and_set(&lock, 1))
+    while(__sync_lock_test_and_set(&lock, 1))
 #endif
-		{
-			/*nop*/;
-		}
-		int c = counter;
-		usleep(5 * 1000); // Create contention on the lock.
-		++c;
-		counter = c;
+    {
+      /*nop*/;
+    }
+    int c = counter;
+    usleep(5 * 1000); // Create contention on the lock.
+    ++c;
+    counter = c;
 #ifdef USE_EMSCRIPTEN_INTRINSICS
-		emscripten_atomic_store_u32((void*)&lock, 0);
+    emscripten_atomic_store_u32((void*)&lock, 0);
 #else
-		__sync_lock_release(&lock);
+    __sync_lock_release(&lock);
 #endif
-	}
-	printf("Thread done.\n");
-	pthread_exit(0);
+  }
+  printf("Thread done.\n");
+  pthread_exit(0);
 }
 
 #define NUM_THREADS 8
 
-int main()
-{
-	int result = 0;
-
-	pthread_t thread[NUM_THREADS];
+int main() {
+  pthread_t thread[NUM_THREADS];
 
-	for(int i = 0; i < NUM_THREADS; ++i)
-	{
-		int rc = pthread_create(&thread[i], NULL, ThreadMain, 0);
-		if (rc != 0 || thread[i] == 0)
-			printf("Failed to create thread!\n");
-	}
+  for (int i = 0; i < NUM_THREADS; ++i) {
+    int rc = pthread_create(&thread[i], NULL, ThreadMain, 0);
+    if (rc != 0 || thread[i] == 0) {
+      printf("Failed to create thread!\n");
+    }
+  }
 
-	for(int i = 0; i < NUM_THREADS; ++i)
-	{
-		int rc = pthread_join(thread[i], 0);
-		assert(rc == 0);
-	}
+  for (int i = 0; i < NUM_THREADS; ++i) {
+    int rc = pthread_join(thread[i], 0);
+    assert(rc == 0);
+  }
 
-	printf("counter: %d\n", counter);
-	assert(counter == 800);
-	return 0;
+  printf("counter: %d\n", counter);
+  assert(counter == 800);
+  return 0;
 }