Index: src/tests/builtins/sync.c
===================================================================
--- src/tests/builtins/sync.c	(revision 13073be42dba9d23e1eb3322d700f265381ae024)
+++ src/tests/builtins/sync.c	(revision 533540a2637374251ff8466708ef82ad66b25a16)
@@ -8,5 +8,7 @@
 	volatile int * vp4 = 0; int * rp4 = 0; int v4 = 0;
 	volatile long long int * vp8 = 0; long long int * rp8 = 0; long long int v8 = 0;
+	#if defined(__SIZEOF_INT128__)
 	volatile __int128 * vp16 = 0; __int128 * rp16 = 0; __int128 v16 = 0;
+	#endif
 
 	{ char ret; ret = __sync_fetch_and_add(vp1, v1); }
@@ -18,6 +20,8 @@
 	{ long long int ret; ret = __sync_fetch_and_add(vp8, v8); }
 	{ long long int ret; ret = __sync_fetch_and_add_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_fetch_and_add(vp16, v16); }
 	{ __int128 ret; ret = __sync_fetch_and_add_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_fetch_and_sub(vp1, v1); }
@@ -29,6 +33,8 @@
 	{ long long int ret; ret = __sync_fetch_and_sub(vp8, v8); }
 	{ long long int ret; ret = __sync_fetch_and_sub_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_fetch_and_sub(vp16, v16); }
 	{ __int128 ret; ret = __sync_fetch_and_sub_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_fetch_and_or(vp1, v1); }
@@ -40,6 +46,8 @@
 	{ long long int ret; ret = __sync_fetch_and_or(vp8, v8); }
 	{ long long int ret; ret = __sync_fetch_and_or_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_fetch_and_or(vp16, v16); }
 	{ __int128 ret; ret = __sync_fetch_and_or_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_fetch_and_and(vp1, v1); }
@@ -51,6 +59,8 @@
 	{ long long int ret; ret = __sync_fetch_and_and(vp8, v8); }
 	{ long long int ret; ret = __sync_fetch_and_and_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_fetch_and_and(vp16, v16); }
 	{ __int128 ret; ret = __sync_fetch_and_and_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_fetch_and_xor(vp1, v1); }
@@ -62,6 +72,8 @@
 	{ long long int ret; ret = __sync_fetch_and_xor(vp8, v8); }
 	{ long long int ret; ret = __sync_fetch_and_xor_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_fetch_and_xor(vp16, v16); }
 	{ __int128 ret; ret = __sync_fetch_and_xor_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_fetch_and_nand(vp1, v1); }
@@ -73,6 +85,8 @@
 	{ long long int ret; ret = __sync_fetch_and_nand(vp8, v8); }
 	{ long long int ret; ret = __sync_fetch_and_nand_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_fetch_and_nand(vp16, v16); }
 	{ __int128 ret; ret = __sync_fetch_and_nand_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_add_and_fetch(vp1, v1); }
@@ -84,6 +98,8 @@
 	{ long long int ret; ret = __sync_add_and_fetch(vp8, v8); }
 	{ long long int ret; ret = __sync_add_and_fetch_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_add_and_fetch(vp16, v16); }
 	{ __int128 ret; ret = __sync_add_and_fetch_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_sub_and_fetch(vp1, v1); }
@@ -95,6 +111,8 @@
 	{ long long int ret; ret = __sync_sub_and_fetch(vp8, v8); }
 	{ long long int ret; ret = __sync_sub_and_fetch_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_sub_and_fetch(vp16, v16); }
 	{ __int128 ret; ret = __sync_sub_and_fetch_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_or_and_fetch(vp1, v1); }
@@ -106,6 +124,8 @@
 	{ long long int ret; ret = __sync_or_and_fetch(vp8, v8); }
 	{ long long int ret; ret = __sync_or_and_fetch_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_or_and_fetch(vp16, v16); }
 	{ __int128 ret; ret = __sync_or_and_fetch_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_and_and_fetch(vp1, v1); }
@@ -117,6 +137,8 @@
 	{ long long int ret; ret = __sync_and_and_fetch(vp8, v8); }
 	{ long long int ret; ret = __sync_and_and_fetch_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_and_and_fetch(vp16, v16); }
 	{ __int128 ret; ret = __sync_and_and_fetch_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_xor_and_fetch(vp1, v1); }
@@ -128,6 +150,8 @@
 	{ long long int ret; ret = __sync_xor_and_fetch(vp8, v8); }
 	{ long long int ret; ret = __sync_xor_and_fetch_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_xor_and_fetch(vp16, v16); }
 	{ __int128 ret; ret = __sync_xor_and_fetch_16(vp16, v16); }
+	#endif
 
 	{ char ret; ret = __sync_nand_and_fetch(vp1, v1); }
@@ -139,6 +163,8 @@
 	{ long long int ret; ret = __sync_nand_and_fetch(vp8, v8); }
 	{ long long int ret; ret = __sync_nand_and_fetch_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_nand_and_fetch(vp16, v16); }
 	{ __int128 ret; ret = __sync_nand_and_fetch_16(vp16, v16); }
+	#endif
 
 	{ _Bool ret; ret = __sync_bool_compare_and_swap(vp1, v1, v1); }
@@ -150,6 +176,8 @@
 	{ _Bool ret; ret = __sync_bool_compare_and_swap(vp8, v8, v8); }
 	{ _Bool ret; ret = __sync_bool_compare_and_swap_8(vp8, v8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ _Bool ret; ret = __sync_bool_compare_and_swap(vp16, v16, v16); }
 	{ _Bool ret; ret = __sync_bool_compare_and_swap_16(vp16, v16,v16); }
+	#endif
 
 	{ char ret; ret = __sync_val_compare_and_swap(vp1, v1, v1); }
@@ -161,6 +189,8 @@
 	{ long long int ret; ret = __sync_val_compare_and_swap(vp8, v8, v8); }
 	{ long long int ret; ret = __sync_val_compare_and_swap_8(vp8, v8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_val_compare_and_swap(vp16, v16, v16); }
 	{ __int128 ret; ret = __sync_val_compare_and_swap_16(vp16, v16,v16); }
+	#endif
 
 	{ char ret; ret = __sync_lock_test_and_set(vp1, v1); }
@@ -172,6 +202,8 @@
 	{ long long int ret; ret = __sync_lock_test_and_set(vp8, v8); }
 	{ long long int ret; ret = __sync_lock_test_and_set_8(vp8, v8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __sync_lock_test_and_set(vp16, v16); }
 	{ __int128 ret; ret = __sync_lock_test_and_set_16(vp16, v16); }
+	#endif
 
 	{ __sync_lock_release(vp1); }
@@ -183,6 +215,8 @@
 	{ __sync_lock_release(vp8); }
 	{ __sync_lock_release_8(vp8); }
+	#if defined(__SIZEOF_INT128__)
 	{ __sync_lock_release(vp16); }
 	{ __sync_lock_release_16(vp16); }
+	#endif
 
 	{ __sync_synchronize(); }
@@ -208,7 +242,9 @@
 	{ long long int ret; ret = __atomic_exchange_8(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; __atomic_exchange(vp8, &v8, &ret, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_exchange_n(vp16, &v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_exchange_16(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; __atomic_exchange(vp16, &v16, &ret, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_load_n(vp1, __ATOMIC_SEQ_CST); }
@@ -224,7 +260,9 @@
 	{ long long int ret; ret = __atomic_load_8(vp8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; __atomic_load(vp8, &ret, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_load_n(vp16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_load_16(vp16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; __atomic_load(vp16, &ret, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ _Bool ret; ret = __atomic_compare_exchange_n(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
@@ -240,7 +278,9 @@
 	{ _Bool ret; ret = __atomic_compare_exchange_8(vp8, rp8, v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
 	{ _Bool ret; ret = __atomic_compare_exchange(vp8, rp8, &v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ _Bool ret; ret = __atomic_compare_exchange_n(vp16, rp16, v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
 	{ _Bool ret; ret = __atomic_compare_exchange_16(vp16, rp16, v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
 	{ _Bool ret; ret = __atomic_compare_exchange(vp16, rp16, &v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ __atomic_store_n(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -256,7 +296,9 @@
 	{ __atomic_store_8(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ __atomic_store(vp8, &v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __atomic_store_n(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __atomic_store_16(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __atomic_store(vp16, &v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_add_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -268,6 +310,8 @@
 	{ long long int ret; ret = __atomic_add_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_add_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_add_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_add_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_sub_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -279,6 +323,8 @@
 	{ long long int ret; ret = __atomic_sub_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_sub_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_sub_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_sub_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_and_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -290,6 +336,8 @@
 	{ long long int ret; ret = __atomic_and_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_and_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_and_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_and_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_nand_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -301,6 +349,8 @@
 	{ long long int ret; ret = __atomic_nand_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_nand_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_nand_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_nand_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_xor_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -312,6 +362,8 @@
 	{ long long int ret; ret = __atomic_xor_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_xor_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_xor_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_xor_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_or_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -323,6 +375,8 @@
 	{ long long int ret; ret = __atomic_or_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_or_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_or_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_or_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_fetch_add(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -334,6 +388,8 @@
 	{ long long int ret; ret = __atomic_fetch_add(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_fetch_add_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_fetch_add(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_fetch_add_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_fetch_sub(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -345,6 +401,8 @@
 	{ long long int ret; ret = __atomic_fetch_sub(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_fetch_sub_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_fetch_sub(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_fetch_sub_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_fetch_and(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -356,6 +414,8 @@
 	{ long long int ret; ret = __atomic_fetch_and(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_fetch_and_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_fetch_and(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_fetch_and_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_fetch_nand(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -367,6 +427,8 @@
 	{ long long int ret; ret = __atomic_fetch_nand(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_fetch_nand_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_fetch_nand(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_fetch_nand_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_fetch_xor(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -378,6 +440,8 @@
 	{ long long int ret; ret = __atomic_fetch_xor(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_fetch_xor_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_fetch_xor(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_fetch_xor_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ char ret; ret = __atomic_fetch_or(vp1, v1, __ATOMIC_SEQ_CST); }
@@ -389,6 +453,8 @@
 	{ long long int ret; ret = __atomic_fetch_or(vp8, v8, __ATOMIC_SEQ_CST); }
 	{ long long int ret; ret = __atomic_fetch_or_8(vp8, v8, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
 	{ __int128 ret; ret = __atomic_fetch_or(vp16, v16, __ATOMIC_SEQ_CST); }
 	{ __int128 ret; ret = __atomic_fetch_or_16(vp16, v16, __ATOMIC_SEQ_CST); }
+	#endif
 
 	{ _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vp4); }
