Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/CodeGen/CodeGenerator.cc (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -119,10 +119,11 @@ string CodeGenerator::mangleName( DeclarationWithType * decl ) { - if ( pretty ) return decl->get_name(); - if ( decl->get_mangleName() != "" ) { + // GCC builtins should always be printed unmangled + if ( pretty || decl->linkage.is_gcc_builtin ) return decl->name; + if ( decl->mangleName != "" ) { // need to incorporate scope level in order to differentiate names for destructors return decl->get_scopedMangleName(); } else { - return decl->get_name(); + return decl->name; } // if } Index: src/Parser/LinkageSpec.h =================================================================== --- src/Parser/LinkageSpec.h (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/Parser/LinkageSpec.h (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -27,6 +27,7 @@ Overrideable = 1 << 2, Builtin = 1 << 3, + GccBuiltin = 1 << 4, - NoOfSpecs = 1 << 4, + NoOfSpecs = 1 << 5, }; @@ -38,4 +39,5 @@ bool is_overridable : 1; bool is_builtin : 1; + bool is_gcc_builtin : 1; }; constexpr Spec( unsigned int val ) : val( val ) {} @@ -61,4 +63,5 @@ inline bool isOverridable( Spec spec ) { return spec.is_overridable; } inline bool isBuiltin( Spec spec ) { return spec.is_builtin; } + inline bool isGccBuiltin( Spec spec ) { return spec.is_gcc_builtin; } // Pre-defined flag combinations: @@ -72,5 +75,5 @@ constexpr Spec const AutoGen = { Mangle | Generate | Overrideable }; // gcc internal - constexpr Spec const Compiler = { Builtin }; + constexpr Spec const Compiler = { Mangle | Builtin | GccBuiltin }; // mangled builtins constexpr Spec const BuiltinCFA = { Mangle | Generate | Builtin }; Index: src/libcfa/bits/locks.h =================================================================== --- src/libcfa/bits/locks.h (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/libcfa/bits/locks.h (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -39,18 +39,14 @@ #endif -#if __SIZEOF_SIZE_T__ == 8 - #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_8( &(lock), 1 ) == 0 - #define __lock_release( lock ) __sync_lock_release_8( &(lock) ); -#elif __SIZEOF_SIZE_T__ == 4 - #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_4( &(lock), 1 ) == 0 - #define __lock_release( lock ) __sync_lock_release_4( &(lock) ); -#else - #error unsupported architecture -#endif - struct __spinlock_t { - __ALIGN__ volatile size_t lock; + // Wrap in struct to prevent false sharing with debug info + struct { + // Align lock on 128-bit boundary + __ALIGN__ volatile _Bool lock; + }; #ifdef __CFA_DEBUG__ + // previous function to acquire the lock const char * prev_name; + // previous thread to acquire the lock void* prev_thrd; #endif @@ -78,5 +74,5 @@ // Lock the spinlock, return false if already acquired static inline _Bool try_lock ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { - _Bool result = __lock_test_and_test_and_set( this.lock ); + _Bool result = (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0); if( result ) { disable_interrupts(); @@ -94,5 +90,5 @@ for ( unsigned int i = 1;; i += 1 ) { - if ( __lock_test_and_test_and_set( this.lock ) ) break; + if ( (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0) ) break; #ifndef NOEXPBACK // exponential spin @@ -112,20 +108,7 @@ } - // // Lock the spinlock, yield if already acquired - // static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { - // for ( unsigned int i = 1;; i += 1 ) { - // if ( __lock_test_and_test_and_set( this.lock ) ) break; - // yield( i ); - // } - // disable_interrupts(); - // __cfaabi_dbg_debug_do( - // this.prev_name = caller; - // this.prev_thrd = this_thread; - // ) - // } - static inline void unlock( __spinlock_t & this ) { enable_interrupts_noPoll(); - __lock_release( this.lock ); + __atomic_clear( &this.lock, __ATOMIC_RELEASE ); } #endif Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/libcfa/concurrency/preemption.c (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -161,5 +161,14 @@ void disable_interrupts() { with( kernelTLS.preemption_state ) { - enabled = false; + static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free"); + + // Set enabled flag to false + // should be atomic to avoid preemption in the middle of the operation. + // use memory order RELAXED since there is no inter-thread on this variable requirements + __atomic_store_n(&enabled, false, __ATOMIC_RELAXED); + + // Signal the compiler that a fence is needed but only for signal handlers + __atomic_signal_fence(__ATOMIC_ACQUIRE); + __attribute__((unused)) unsigned short new_val = disable_count + 1; disable_count = new_val; @@ -171,6 +180,6 @@ // If counter reaches 0, execute any pending CtxSwitch void enable_interrupts( __cfaabi_dbg_ctx_param ) { - processor * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic add - thread_desc * thrd = kernelTLS.this_thread; // Cache the thread now since interrupts can start happening after the atomic add + processor * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic store + thread_desc * thrd = kernelTLS.this_thread; // Cache the thread now since interrupts can start happening after the atomic store with( kernelTLS.preemption_state ){ @@ -181,5 +190,13 @@ // Check if we need to prempt the thread because an interrupt was missed if( prev == 1 ) { - enabled = true; + static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free"); + + // Set enabled flag to true + // should be atomic to avoid preemption in the middle of the operation. + // use memory order RELAXED since there is no inter-thread on this variable requirements + __atomic_store_n(&enabled, true, __ATOMIC_RELAXED); + + // Signal the compiler that a fence is needed but only for signal handlers + __atomic_signal_fence(__ATOMIC_RELEASE); if( proc->pending_preemption ) { proc->pending_preemption = false; @@ -200,5 +217,12 @@ verifyf( prev != 0u, "Incremented from %u\n", prev ); // If this triggers someone is enabled already enabled interrupts if( prev == 1 ) { - kernelTLS.preemption_state.enabled = true; + static_assert(__atomic_always_lock_free(sizeof(kernelTLS.preemption_state.enabled), &kernelTLS.preemption_state.enabled), "Must be lock-free"); + // Set enabled flag to true + // should be atomic to avoid preemption in the middle of the operation. + // use memory order RELAXED since there is no inter-thread on this variable requirements + __atomic_store_n(&kernelTLS.preemption_state.enabled, true, __ATOMIC_RELAXED); + + // Signal the compiler that a fence is needed but only for signal handlers + __atomic_signal_fence(__ATOMIC_RELEASE); } } Index: src/prelude/Makefile.am =================================================================== --- src/prelude/Makefile.am (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/prelude/Makefile.am (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -37,7 +37,7 @@ # create forward declarations for gcc builtins gcc-builtins.cf : gcc-builtins.c prototypes.sed - ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@ + ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -r -f prototypes.sed > $@ -gcc-builtins.c : builtins.def prototypes.awk +gcc-builtins.c : builtins.def prototypes.awk sync-builtins.cf ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@ Index: src/prelude/Makefile.in =================================================================== --- src/prelude/Makefile.in (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/prelude/Makefile.in (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -506,7 +506,7 @@ # create forward declarations for gcc builtins gcc-builtins.cf : gcc-builtins.c prototypes.sed - ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@ - -gcc-builtins.c : builtins.def prototypes.awk + ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -r -f prototypes.sed > $@ + +gcc-builtins.c : builtins.def prototypes.awk sync-builtins.cf ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@ Index: src/prelude/builtins.def =================================================================== --- src/prelude/builtins.def (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/prelude/builtins.def (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -190,5 +190,5 @@ /* Builtin used by implementation of Cilk Plus. Most of these are decomposed - by the compiler but a few are implemented in libcilkrts. */ + by the compiler but a few are implemented in libcilkrts. */ #undef DEF_CILK_BUILTIN_STUB #define DEF_CILK_BUILTIN_STUB(ENUM, NAME) \ @@ -204,5 +204,5 @@ /* Builtin used by the implementation of libsanitizer. These - functions are mapped to the actual implementation of the + functions are mapped to the actual implementation of the libtsan library. */ #undef DEF_SANITIZER_BUILTIN @@ -217,5 +217,5 @@ #define DEF_CILKPLUS_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_FN_INT_VAR, BT_LAST, \ - false, false, false, ATTRS, false, flag_cilkplus) + false, false, false, ATTRS, false, flag_cilkplus) /* Builtin used by the implementation of Pointer Bounds Checker. */ @@ -927,8 +927,8 @@ DEF_GCC_BUILTIN (BUILT_IN_LINE, "LINE", BT_FN_INT, ATTR_NOTHROW_LEAF_LIST) +#if 0 //Ifdefed out because we hard-coded the proper overloadings of the atomic built-ins /* Synchronization Primitives. */ #include "sync-builtins.def" -#if 0 /* Offloading and Multi Processing builtins. */ #include "omp-builtins.def" Index: src/prelude/prelude.cf =================================================================== --- src/prelude/prelude.cf (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/prelude/prelude.cf (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -458,4 +458,5 @@ signed long long int ?=?( signed long long int &, signed long long int ), ?=?( volatile signed long long int &, signed long long int ); unsigned long long int ?=?( unsigned long long int &, unsigned long long int ), ?=?( volatile unsigned long long int &, unsigned long long int ); +__int128 ?=?( __int128 &, __int128 ), ?=?( volatile __int128 &, __int128 ); zero_t ?=?( zero_t &, zero_t ); one_t ?=?( one_t &, one_t ); Index: src/prelude/prototypes.awk =================================================================== --- src/prelude/prototypes.awk (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/prelude/prototypes.awk (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -5,5 +5,5 @@ # file "LICENCE" distributed with Cforall. # -# prototypes.awk -- +# prototypes.awk -- # # Author : Peter A. Buhr @@ -12,5 +12,5 @@ # Last Modified On : Tue Jul 5 14:32:52 2016 # Update Count : 32 -# +# # http://llvm.org/svn/llvm-project/cfe/trunk/include/clang/Basic/Builtins.def @@ -83,5 +83,5 @@ } # BEGIN -/BT_FN/ { +/BT_FN/ { for (i = 1; i <= NF; i++) { if( match($i, "BT_FN") != 0 ) { @@ -116,5 +116,5 @@ # generate function return type as macro - for ( t = 0; t < N; t += 1 ) { # find longest match + for ( t = 0; t < N; t += 1 ) { # find longest match type = types[t]; if ( index( prototype, type ) == 1 ) { # found match @@ -150,4 +150,5 @@ # extras printf( "\n#include \"builtins.def\"\n\n" ); + printf( "\n#include \"sync-builtins.cf\"\n\n" ); printf( "extern const char *__PRETTY_FUNCTION__;\n" ); } # END Index: src/prelude/prototypes.sed =================================================================== --- src/prelude/prototypes.sed (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/prelude/prototypes.sed (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -2,5 +2,21 @@ /targetm/s/.*// #Remove targetm declarations /__Unsupported/s/.*// #Remove Unsupported types declarations -s/void (const char \*)0();// #Remove void (const char \*)0(); +s/void \(const char \*\)0\(\);// #Remove void (const char \*)0(); s/\"//g #Remove extraenous quotes in declarations -/__builtin_/s/_ /_/g #Remove extraenous spaces in declarations +/__builtin_/s/_ /_/g #Remove extraenous spaces in declarations + +#Fix gcc overloading +# various sed rules for the gcc sync builtins which are overloaded +# kept here because they generate an acceptable approximate of the correct prototypes + +#/__sync_/s/_[0-9][0-9]*\(.*\)/\(\);/g #hack since it will accept any parameters +#/__atomic_/s/_[0-9][0-9]*\(.*\)/\(\);/g #hack since it will accept any parameters + +#/_16/s/void \*/__int128 \*/g +#/_8/s/void \*/long long int \*/g +#/_4/s/void \*/int \*/g +#/_2/s/void \*/short \*/g +#/_1/s/void \*/char \*/g + +#s/([a-zA-Z0-9_ ]+)\s+__sync([a-z_]+)_([0-9]+)\((.*)\);/\1 __sync\2\(\4\,...); \1 __sync\2_\3\(\4\,...);/ +#s/([a-zA-Z0-9_ ]+)\s+__atomic([a-z_]+)_([0-9]+)\((.*)\);/\1 __atomic\2\(\4\); \1 __atomic\2_\3\(\4\);/ Index: src/prelude/sync-builtins.cf =================================================================== --- src/prelude/sync-builtins.cf (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) +++ src/prelude/sync-builtins.cf (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -0,0 +1,399 @@ +char __sync_fetch_and_add(volatile char *, char,...); +char __sync_fetch_and_add_1(volatile char *, char,...); +short __sync_fetch_and_add(volatile short *, short,...); +short __sync_fetch_and_add_2(volatile short *, short,...); +int __sync_fetch_and_add(volatile int *, int,...); +int __sync_fetch_and_add_4(volatile int *, int,...); +long long int __sync_fetch_and_add(volatile long long int *, long long int,...); +long long int __sync_fetch_and_add_8(volatile long long int *, long long int,...); +__int128 __sync_fetch_and_add(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_add_16(volatile __int128 *, __int128,...); + +char __sync_fetch_and_sub(volatile char *, char,...); +char __sync_fetch_and_sub_1(volatile char *, char,...); +short __sync_fetch_and_sub(volatile short *, short,...); +short __sync_fetch_and_sub_2(volatile short *, short,...); +int __sync_fetch_and_sub(volatile int *, int,...); +int __sync_fetch_and_sub_4(volatile int *, int,...); +long long int __sync_fetch_and_sub(volatile long long int *, long long int,...); +long long int __sync_fetch_and_sub_8(volatile long long int *, long long int,...); +__int128 __sync_fetch_and_sub(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_sub_16(volatile __int128 *, __int128,...); + +char __sync_fetch_and_or(volatile char *, char,...); +char __sync_fetch_and_or_1(volatile char *, char,...); +short __sync_fetch_and_or(volatile short *, short,...); +short __sync_fetch_and_or_2(volatile short *, short,...); +int __sync_fetch_and_or(volatile int *, int,...); +int __sync_fetch_and_or_4(volatile int *, int,...); +long long int __sync_fetch_and_or(volatile long long int *, long long int,...); +long long int __sync_fetch_and_or_8(volatile long long int *, long long int,...); +__int128 __sync_fetch_and_or(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_or_16(volatile __int128 *, __int128,...); + +char __sync_fetch_and_and(volatile char *, char,...); +char __sync_fetch_and_and_1(volatile char *, char,...); +short __sync_fetch_and_and(volatile short *, short,...); +short __sync_fetch_and_and_2(volatile short *, short,...); +int __sync_fetch_and_and(volatile int *, int,...); +int __sync_fetch_and_and_4(volatile int *, int,...); +long long int __sync_fetch_and_and(volatile long long int *, long long int,...); +long long int __sync_fetch_and_and_8(volatile long long int *, long long int,...); +__int128 __sync_fetch_and_and(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_and_16(volatile __int128 *, __int128,...); + +char __sync_fetch_and_xor(volatile char *, char,...); +char __sync_fetch_and_xor_1(volatile char *, char,...); +short __sync_fetch_and_xor(volatile short *, short,...); +short __sync_fetch_and_xor_2(volatile short *, short,...); +int __sync_fetch_and_xor(volatile int *, int,...); +int __sync_fetch_and_xor_4(volatile int *, int,...); +long long int __sync_fetch_and_xor(volatile long long int *, long long int,...); +long long int __sync_fetch_and_xor_8(volatile long long int *, long long int,...); +__int128 __sync_fetch_and_xor(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_xor_16(volatile __int128 *, __int128,...); + +char __sync_fetch_and_nand(volatile char *, char,...); +char __sync_fetch_and_nand_1(volatile char *, char,...); +short __sync_fetch_and_nand(volatile short *, short,...); +short __sync_fetch_and_nand_2(volatile short *, short,...); +int __sync_fetch_and_nand(volatile int *, int,...); +int __sync_fetch_and_nand_4(volatile int *, int,...); +long long int __sync_fetch_and_nand(volatile long long int *, long long int,...); +long long int __sync_fetch_and_nand_8(volatile long long int *, long long int,...); +__int128 __sync_fetch_and_nand(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_nand_16(volatile __int128 *, __int128,...); + +char __sync_add_and_fetch(volatile char *, char,...); +char __sync_add_and_fetch_1(volatile char *, char,...); +short __sync_add_and_fetch(volatile short *, short,...); +short __sync_add_and_fetch_2(volatile short *, short,...); +int __sync_add_and_fetch(volatile int *, int,...); +int __sync_add_and_fetch_4(volatile int *, int,...); +long long int __sync_add_and_fetch(volatile long long int *, long long int,...); +long long int __sync_add_and_fetch_8(volatile long long int *, long long int,...); +__int128 __sync_add_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_add_and_fetch_16(volatile __int128 *, __int128,...); + +char __sync_sub_and_fetch(volatile char *, char,...); +char __sync_sub_and_fetch_1(volatile char *, char,...); +short __sync_sub_and_fetch(volatile short *, short,...); +short __sync_sub_and_fetch_2(volatile short *, short,...); +int __sync_sub_and_fetch(volatile int *, int,...); +int __sync_sub_and_fetch_4(volatile int *, int,...); +long long int __sync_sub_and_fetch(volatile long long int *, long long int,...); +long long int __sync_sub_and_fetch_8(volatile long long int *, long long int,...); +__int128 __sync_sub_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_sub_and_fetch_16(volatile __int128 *, __int128,...); + +char __sync_or_and_fetch(volatile char *, char,...); +char __sync_or_and_fetch_1(volatile char *, char,...); +short __sync_or_and_fetch(volatile short *, short,...); +short __sync_or_and_fetch_2(volatile short *, short,...); +int __sync_or_and_fetch(volatile int *, int,...); +int __sync_or_and_fetch_4(volatile int *, int,...); +long long int __sync_or_and_fetch(volatile long long int *, long long int,...); +long long int __sync_or_and_fetch_8(volatile long long int *, long long int,...); +__int128 __sync_or_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_or_and_fetch_16(volatile __int128 *, __int128,...); + +char __sync_and_and_fetch(volatile char *, char,...); +char __sync_and_and_fetch_1(volatile char *, char,...); +short __sync_and_and_fetch(volatile short *, short,...); +short __sync_and_and_fetch_2(volatile short *, short,...); +int __sync_and_and_fetch(volatile int *, int,...); +int __sync_and_and_fetch_4(volatile int *, int,...); +long long int __sync_and_and_fetch(volatile long long int *, long long int,...); +long long int __sync_and_and_fetch_8(volatile long long int *, long long int,...); +__int128 __sync_and_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_and_and_fetch_16(volatile __int128 *, __int128,...); + +char __sync_xor_and_fetch(volatile char *, char,...); +char __sync_xor_and_fetch_1(volatile char *, char,...); +short __sync_xor_and_fetch(volatile short *, short,...); +short __sync_xor_and_fetch_2(volatile short *, short,...); +int __sync_xor_and_fetch(volatile int *, int,...); +int __sync_xor_and_fetch_4(volatile int *, int,...); +long long int __sync_xor_and_fetch(volatile long long int *, long long int,...); +long long int __sync_xor_and_fetch_8(volatile long long int *, long long int,...); +__int128 __sync_xor_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_xor_and_fetch_16(volatile __int128 *, __int128,...); + +char __sync_nand_and_fetch(volatile char *, char,...); +char __sync_nand_and_fetch_1(volatile char *, char,...); +short __sync_nand_and_fetch(volatile short *, short,...); +short __sync_nand_and_fetch_2(volatile short *, short,...); +int __sync_nand_and_fetch(volatile int *, int,...); +int __sync_nand_and_fetch_4(volatile int *, int,...); +long long int __sync_nand_and_fetch(volatile long long int *, long long int,...); +long long int __sync_nand_and_fetch_8(volatile long long int *, long long int,...); +__int128 __sync_nand_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_nand_and_fetch_16(volatile __int128 *, __int128,...); + +_Bool __sync_bool_compare_and_swap(volatile char *, char, char,...); +_Bool __sync_bool_compare_and_swap_1(volatile char *, char, char,...); +_Bool __sync_bool_compare_and_swap(volatile short *, short, short,...); +_Bool __sync_bool_compare_and_swap_2(volatile short *, short, short,...); +_Bool __sync_bool_compare_and_swap(volatile int *, int, int,...); +_Bool __sync_bool_compare_and_swap_4(volatile int *, int, int,...); +_Bool __sync_bool_compare_and_swap(volatile long long int *, long long int, long long int,...); +_Bool __sync_bool_compare_and_swap_8(volatile long long int *, long long int, long long int,...); +_Bool __sync_bool_compare_and_swap(volatile __int128 *, __int128, __int128,...); +_Bool __sync_bool_compare_and_swap_16(volatile __int128 *, __int128, __int128,...); + +char __sync_val_compare_and_swap(volatile char *, char, char,...); +char __sync_val_compare_and_swap_1(volatile char *, char, char,...); +short __sync_val_compare_and_swap(volatile short *, short, short,...); +short __sync_val_compare_and_swap_2(volatile short *, short, short,...); +int __sync_val_compare_and_swap(volatile int *, int, int,...); +int __sync_val_compare_and_swap_4(volatile int *, int, int,...); +long long int __sync_val_compare_and_swap(volatile long long int *, long long int, long long int,...); +long long int __sync_val_compare_and_swap_8(volatile long long int *, long long int, long long int,...); +__int128 __sync_val_compare_and_swap(volatile __int128 *, __int128, __int128,...); +__int128 __sync_val_compare_and_swap_16(volatile __int128 *, __int128, __int128,...); + +char __sync_lock_test_and_set(volatile char *, char,...); +char __sync_lock_test_and_set_1(volatile char *, char,...); +short __sync_lock_test_and_set(volatile short *, short,...); +short __sync_lock_test_and_set_2(volatile short *, short,...); +int __sync_lock_test_and_set(volatile int *, int,...); +int __sync_lock_test_and_set_4(volatile int *, int,...); +long long int __sync_lock_test_and_set(volatile long long int *, long long int,...); +long long int __sync_lock_test_and_set_8(volatile long long int *, long long int,...); +__int128 __sync_lock_test_and_set(volatile __int128 *, __int128,...); +__int128 __sync_lock_test_and_set_16(volatile __int128 *, __int128,...); + +void __sync_lock_release(volatile char *,...); +void __sync_lock_release_1(volatile char *,...); +void __sync_lock_release(volatile short *,...); +void __sync_lock_release_2(volatile short *,...); +void __sync_lock_release(volatile int *,...); +void __sync_lock_release_4(volatile int *,...); +void __sync_lock_release(volatile long long int *,...); +void __sync_lock_release_8(volatile long long int *,...); +void __sync_lock_release(volatile __int128 *,...); +void __sync_lock_release_16(volatile __int128 *,...); + +void __sync_synchronize(); + + + + +_Bool __atomic_test_and_set(volatile _Bool *, int); +_Bool __atomic_test_and_set(volatile char *, int); +_Bool __atomic_test_and_set(volatile short *, int); +_Bool __atomic_test_and_set(volatile int *, int); +_Bool __atomic_test_and_set(volatile long long int *, int); +_Bool __atomic_test_and_set(volatile __int128 *, int); +void __atomic_clear(volatile _Bool *, int); +void __atomic_clear(volatile char *, int); +void __atomic_clear(volatile short *, int); +void __atomic_clear(volatile int *, int); +void __atomic_clear(volatile long long int *, int); +void __atomic_clear(volatile __int128 *, int); + +char __atomic_exchange_n(volatile char *, volatile char *, int); +char __atomic_exchange_1(volatile char *, char, int); +void __atomic_exchange(volatile char *, volatile char *, volatile char *, int); +short __atomic_exchange_n(volatile short *, volatile short *, int); +short __atomic_exchange_2(volatile short *, short, int); +void __atomic_exchange(volatile short *, volatile short *, volatile short *, int); +int __atomic_exchange_n(volatile int *, volatile int *, int); +int __atomic_exchange_4(volatile int *, int, int); +void __atomic_exchange(volatile int *, volatile int *, volatile int *, int); +long long int __atomic_exchange_n(volatile long long int *, volatile long long int *, int); +long long int __atomic_exchange_8(volatile long long int *, long long int, int); +void __atomic_exchange(volatile long long int *, volatile long long int *, volatile long long int *, int); +__int128 __atomic_exchange_n(volatile __int128 *, volatile __int128 *, int); +__int128 __atomic_exchange_16(volatile __int128 *, __int128, int); +void __atomic_exchange(volatile __int128 *, volatile __int128 *, volatile __int128 *, int); + +char __atomic_load_n(const volatile char *, int); +char __atomic_load_1(const volatile char *, int); +void __atomic_load(const volatile char *, volatile char *, int); +short __atomic_load_n(const volatile short *, int); +short __atomic_load_2(const volatile short *, int); +void __atomic_load(const volatile short *, volatile short *, int); +int __atomic_load_n(const volatile int *, int); +int __atomic_load_4(const volatile int *, int); +void __atomic_load(const volatile int *, volatile int *, int); +long long int __atomic_load_n(const volatile long long int *, int); +long long int __atomic_load_8(const volatile long long int *, int); +void __atomic_load(const volatile long long int *, volatile long long int *, int); +__int128 __atomic_load_n(const volatile __int128 *, int); +__int128 __atomic_load_16(const volatile __int128 *, int); +void __atomic_load(const volatile __int128 *, volatile __int128 *, int); + +_Bool __atomic_compare_exchange_n(volatile char *, char *, char, _Bool, int, int); +_Bool __atomic_compare_exchange_1(volatile char *, char *, char, _Bool, int, int); +_Bool __atomic_compare_exchange (volatile char *, char *, char *, _Bool, int, int); +_Bool __atomic_compare_exchange_n(volatile short *, short *, short, _Bool, int, int); +_Bool __atomic_compare_exchange_2(volatile short *, short *, short, _Bool, int, int); +_Bool __atomic_compare_exchange (volatile short *, short *, short *, _Bool, int, int); +_Bool __atomic_compare_exchange_n(volatile int *, int *, int, _Bool, int, int); +_Bool __atomic_compare_exchange_4(volatile int *, int *, int, _Bool, int, int); +_Bool __atomic_compare_exchange (volatile int *, int *, int *, _Bool, int, int); +_Bool __atomic_compare_exchange_n(volatile long long int *, long long int *, long long int, _Bool, int, int); +_Bool __atomic_compare_exchange_8(volatile long long int *, long long int *, long long int, _Bool, int, int); +_Bool __atomic_compare_exchange (volatile long long int *, long long int *, long long int *, _Bool, int, int); +_Bool __atomic_compare_exchange_n (volatile __int128 *, __int128 *, __int128, _Bool, int, int); +_Bool __atomic_compare_exchange_16(volatile __int128 *, __int128 *, __int128, _Bool, int, int); +_Bool __atomic_compare_exchange (volatile __int128 *, __int128 *, __int128 *, _Bool, int, int); + +void __atomic_store_n(volatile _Bool *, _Bool, int); +void __atomic_store_1(volatile _Bool *, _Bool, int); +void __atomic_store(volatile _Bool *, _Bool *, int); +void __atomic_store_n(volatile char *, char, int); +void __atomic_store_1(volatile char *, char, int); +void __atomic_store(volatile char *, char *, int); +void __atomic_store_n(volatile short *, short, int); +void __atomic_store_2(volatile short *, short, int); +void __atomic_store(volatile short *, short *, int); +void __atomic_store_n(volatile int *, int, int); +void __atomic_store_4(volatile int *, int, int); +void __atomic_store(volatile int *, int *, int); +void __atomic_store_n(volatile long long int *, long long int, int); +void __atomic_store_8(volatile long long int *, long long int, int); +void __atomic_store(volatile long long int *, long long int *, int); +void __atomic_store_n(volatile __int128 *, __int128, int); +void __atomic_store_16(volatile __int128 *, __int128, int); +void __atomic_store(volatile __int128 *, __int128 *, int); + +char __atomic_add_fetch (volatile char *, char, int); +char __atomic_add_fetch_1(volatile char *, char, int); +short __atomic_add_fetch (volatile short *, short, int); +short __atomic_add_fetch_2(volatile short *, short, int); +int __atomic_add_fetch (volatile int *, int, int); +int __atomic_add_fetch_4(volatile int *, int, int); +long long int __atomic_add_fetch (volatile long long int *, long long int, int); +long long int __atomic_add_fetch_8(volatile long long int *, long long int, int); +__int128 __atomic_add_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_add_fetch_16(volatile __int128 *, __int128, int); + +char __atomic_sub_fetch (volatile char *, char, int); +char __atomic_sub_fetch_1(volatile char *, char, int); +short __atomic_sub_fetch (volatile short *, short, int); +short __atomic_sub_fetch_2(volatile short *, short, int); +int __atomic_sub_fetch (volatile int *, int, int); +int __atomic_sub_fetch_4(volatile int *, int, int); +long long int __atomic_sub_fetch (volatile long long int *, long long int, int); +long long int __atomic_sub_fetch_8(volatile long long int *, long long int, int); +__int128 __atomic_sub_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_sub_fetch_16(volatile __int128 *, __int128, int); + +char __atomic_and_fetch (volatile char *, char, int); +char __atomic_and_fetch_1(volatile char *, char, int); +short __atomic_and_fetch (volatile short *, short, int); +short __atomic_and_fetch_2(volatile short *, short, int); +int __atomic_and_fetch (volatile int *, int, int); +int __atomic_and_fetch_4(volatile int *, int, int); +long long int __atomic_and_fetch (volatile long long int *, long long int, int); +long long int __atomic_and_fetch_8(volatile long long int *, long long int, int); +__int128 __atomic_and_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_and_fetch_16(volatile __int128 *, __int128, int); + +char __atomic_nand_fetch (volatile char *, char, int); +char __atomic_nand_fetch_1(volatile char *, char, int); +short __atomic_nand_fetch (volatile short *, short, int); +short __atomic_nand_fetch_2(volatile short *, short, int); +int __atomic_nand_fetch (volatile int *, int, int); +int __atomic_nand_fetch_4(volatile int *, int, int); +long long int __atomic_nand_fetch (volatile long long int *, long long int, int); +long long int __atomic_nand_fetch_8(volatile long long int *, long long int, int); +__int128 __atomic_nand_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_nand_fetch_16(volatile __int128 *, __int128, int); + +char __atomic_xor_fetch (volatile char *, char, int); +char __atomic_xor_fetch_1(volatile char *, char, int); +short __atomic_xor_fetch (volatile short *, short, int); +short __atomic_xor_fetch_2(volatile short *, short, int); +int __atomic_xor_fetch (volatile int *, int, int); +int __atomic_xor_fetch_4(volatile int *, int, int); +long long int __atomic_xor_fetch (volatile long long int *, long long int, int); +long long int __atomic_xor_fetch_8(volatile long long int *, long long int, int); +__int128 __atomic_xor_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_xor_fetch_16(volatile __int128 *, __int128, int); + +char __atomic_or_fetch (volatile char *, char, int); +char __atomic_or_fetch_1(volatile char *, char, int); +short __atomic_or_fetch (volatile short *, short, int); +short __atomic_or_fetch_2(volatile short *, short, int); +int __atomic_or_fetch (volatile int *, int, int); +int __atomic_or_fetch_4(volatile int *, int, int); +long long int __atomic_or_fetch (volatile long long int *, long long int, int); +long long int __atomic_or_fetch_8(volatile long long int *, long long int, int); +__int128 __atomic_or_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_or_fetch_16(volatile __int128 *, __int128, int); + +char __atomic_fetch_add (volatile char *, char, int); +char __atomic_fetch_add_1(volatile char *, char, int); +short __atomic_fetch_add (volatile short *, short, int); +short __atomic_fetch_add_2(volatile short *, short, int); +int __atomic_fetch_add (volatile int *, int, int); +int __atomic_fetch_add_4(volatile int *, int, int); +long long int __atomic_fetch_add (volatile long long int *, long long int, int); +long long int __atomic_fetch_add_8(volatile long long int *, long long int, int); +__int128 __atomic_fetch_add (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_add_16(volatile __int128 *, __int128, int); + +char __atomic_fetch_sub (volatile char *, char, int); +char __atomic_fetch_sub_1(volatile char *, char, int); +short __atomic_fetch_sub (volatile short *, short, int); +short __atomic_fetch_sub_2(volatile short *, short, int); +int __atomic_fetch_sub (volatile int *, int, int); +int __atomic_fetch_sub_4(volatile int *, int, int); +long long int __atomic_fetch_sub (volatile long long int *, long long int, int); +long long int __atomic_fetch_sub_8(volatile long long int *, long long int, int); +__int128 __atomic_fetch_sub (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_sub_16(volatile __int128 *, __int128, int); + +char __atomic_fetch_and (volatile char *, char, int); +char __atomic_fetch_and_1(volatile char *, char, int); +short __atomic_fetch_and (volatile short *, short, int); +short __atomic_fetch_and_2(volatile short *, short, int); +int __atomic_fetch_and (volatile int *, int, int); +int __atomic_fetch_and_4(volatile int *, int, int); +long long int __atomic_fetch_and (volatile long long int *, long long int, int); +long long int __atomic_fetch_and_8(volatile long long int *, long long int, int); +__int128 __atomic_fetch_and (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_and_16(volatile __int128 *, __int128, int); + +char __atomic_fetch_nand (volatile char *, char, int); +char __atomic_fetch_nand_1(volatile char *, char, int); +short __atomic_fetch_nand (volatile short *, short, int); +short __atomic_fetch_nand_2(volatile short *, short, int); +int __atomic_fetch_nand (volatile int *, int, int); +int __atomic_fetch_nand_4(volatile int *, int, int); +long long int __atomic_fetch_nand (volatile long long int *, long long int, int); +long long int __atomic_fetch_nand_8(volatile long long int *, long long int, int); +__int128 __atomic_fetch_nand (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_nand_16(volatile __int128 *, __int128, int); + +char __atomic_fetch_xor (volatile char *, char, int); +char __atomic_fetch_xor_1(volatile char *, char, int); +short __atomic_fetch_xor (volatile short *, short, int); +short __atomic_fetch_xor_2(volatile short *, short, int); +int __atomic_fetch_xor (volatile int *, int, int); +int __atomic_fetch_xor_4(volatile int *, int, int); +long long int __atomic_fetch_xor (volatile long long int *, long long int, int); +long long int __atomic_fetch_xor_8(volatile long long int *, long long int, int); +__int128 __atomic_fetch_xor (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_xor_16(volatile __int128 *, __int128, int); + +char __atomic_fetch_or (volatile char *, char, int); +char __atomic_fetch_or_1(volatile char *, char, int); +short __atomic_fetch_or (volatile short *, short, int); +short __atomic_fetch_or_2(volatile short *, short, int); +int __atomic_fetch_or (volatile int *, int, int); +int __atomic_fetch_or_4(volatile int *, int, int); +long long int __atomic_fetch_or (volatile long long int *, long long int, int); +long long int __atomic_fetch_or_8(volatile long long int *, long long int, int); +__int128 __atomic_fetch_or (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_or_16(volatile __int128 *, __int128, int); + +_Bool __atomic_always_lock_free(unsigned long, const volatile void *); +_Bool __atomic_is_lock_free(unsigned long, const volatile void *); + +void __atomic_thread_fence (int); +void __atomic_signal_fence (int); +void __atomic_feraiseexcept(int); Index: src/tests/Makefile.am =================================================================== --- src/tests/Makefile.am (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/tests/Makefile.am (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -129,2 +129,6 @@ warnings/self-assignment: warnings/self-assignment.c @CFA_BINDIR@/@CFA_NAME@ ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only + +#builtins +builtins/sync: builtins/sync.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only Index: src/tests/Makefile.in =================================================================== --- src/tests/Makefile.in (revision 45040f0642ea065bd868eb5faccdb7c55cc58030) +++ src/tests/Makefile.in (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -807,4 +807,8 @@ ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only +#builtins +builtins/sync: builtins/sync.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only + # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. Index: src/tests/builtins/sync.c =================================================================== --- src/tests/builtins/sync.c (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) +++ src/tests/builtins/sync.c (revision 58e822a10f30dad8a7f188f7c7fb9c07c071994c) @@ -0,0 +1,402 @@ +#include +#include + +void foo() { + volatile _Bool * vpB = 0; _Bool vB = 0; + volatile char * vp1 = 0; char * rp1 = 0; char v1 = 0; + volatile short * vp2 = 0; short * rp2 = 0; short v2 = 0; + 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; + volatile __int128 * vp16 = 0; __int128 * rp16 = 0; __int128 v16 = 0; + + { char ret; ret = __sync_fetch_and_add(vp1, v1); } + { char ret; ret = __sync_fetch_and_add_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_add(vp2, v2); } + { short ret; ret = __sync_fetch_and_add_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_add(vp4, v4); } + { int ret; ret = __sync_fetch_and_add_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_add(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_add_8(vp8, v8); } + { __int128 ret; ret = __sync_fetch_and_add(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_add_16(vp16, v16); } + + { char ret; ret = __sync_fetch_and_sub(vp1, v1); } + { char ret; ret = __sync_fetch_and_sub_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_sub(vp2, v2); } + { short ret; ret = __sync_fetch_and_sub_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_sub(vp4, v4); } + { int ret; ret = __sync_fetch_and_sub_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_sub(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_sub_8(vp8, v8); } + { __int128 ret; ret = __sync_fetch_and_sub(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_sub_16(vp16, v16); } + + { char ret; ret = __sync_fetch_and_or(vp1, v1); } + { char ret; ret = __sync_fetch_and_or_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_or(vp2, v2); } + { short ret; ret = __sync_fetch_and_or_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_or(vp4, v4); } + { int ret; ret = __sync_fetch_and_or_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_or(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_or_8(vp8, v8); } + { __int128 ret; ret = __sync_fetch_and_or(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_or_16(vp16, v16); } + + { char ret; ret = __sync_fetch_and_and(vp1, v1); } + { char ret; ret = __sync_fetch_and_and_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_and(vp2, v2); } + { short ret; ret = __sync_fetch_and_and_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_and(vp4, v4); } + { int ret; ret = __sync_fetch_and_and_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_and(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_and_8(vp8, v8); } + { __int128 ret; ret = __sync_fetch_and_and(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_and_16(vp16, v16); } + + { char ret; ret = __sync_fetch_and_xor(vp1, v1); } + { char ret; ret = __sync_fetch_and_xor_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_xor(vp2, v2); } + { short ret; ret = __sync_fetch_and_xor_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_xor(vp4, v4); } + { int ret; ret = __sync_fetch_and_xor_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_xor(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_xor_8(vp8, v8); } + { __int128 ret; ret = __sync_fetch_and_xor(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_xor_16(vp16, v16); } + + { char ret; ret = __sync_fetch_and_nand(vp1, v1); } + { char ret; ret = __sync_fetch_and_nand_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_nand(vp2, v2); } + { short ret; ret = __sync_fetch_and_nand_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_nand(vp4, v4); } + { int ret; ret = __sync_fetch_and_nand_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_nand(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_nand_8(vp8, v8); } + { __int128 ret; ret = __sync_fetch_and_nand(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_nand_16(vp16, v16); } + + { char ret; ret = __sync_add_and_fetch(vp1, v1); } + { char ret; ret = __sync_add_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_add_and_fetch(vp2, v2); } + { short ret; ret = __sync_add_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_add_and_fetch(vp4, v4); } + { int ret; ret = __sync_add_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_add_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_add_and_fetch_8(vp8, v8); } + { __int128 ret; ret = __sync_add_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_add_and_fetch_16(vp16, v16); } + + { char ret; ret = __sync_sub_and_fetch(vp1, v1); } + { char ret; ret = __sync_sub_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_sub_and_fetch(vp2, v2); } + { short ret; ret = __sync_sub_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_sub_and_fetch(vp4, v4); } + { int ret; ret = __sync_sub_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_sub_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_sub_and_fetch_8(vp8, v8); } + { __int128 ret; ret = __sync_sub_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_sub_and_fetch_16(vp16, v16); } + + { char ret; ret = __sync_or_and_fetch(vp1, v1); } + { char ret; ret = __sync_or_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_or_and_fetch(vp2, v2); } + { short ret; ret = __sync_or_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_or_and_fetch(vp4, v4); } + { int ret; ret = __sync_or_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_or_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_or_and_fetch_8(vp8, v8); } + { __int128 ret; ret = __sync_or_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_or_and_fetch_16(vp16, v16); } + + { char ret; ret = __sync_and_and_fetch(vp1, v1); } + { char ret; ret = __sync_and_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_and_and_fetch(vp2, v2); } + { short ret; ret = __sync_and_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_and_and_fetch(vp4, v4); } + { int ret; ret = __sync_and_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_and_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_and_and_fetch_8(vp8, v8); } + { __int128 ret; ret = __sync_and_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_and_and_fetch_16(vp16, v16); } + + { char ret; ret = __sync_xor_and_fetch(vp1, v1); } + { char ret; ret = __sync_xor_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_xor_and_fetch(vp2, v2); } + { short ret; ret = __sync_xor_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_xor_and_fetch(vp4, v4); } + { int ret; ret = __sync_xor_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_xor_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_xor_and_fetch_8(vp8, v8); } + { __int128 ret; ret = __sync_xor_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_xor_and_fetch_16(vp16, v16); } + + { char ret; ret = __sync_nand_and_fetch(vp1, v1); } + { char ret; ret = __sync_nand_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_nand_and_fetch(vp2, v2); } + { short ret; ret = __sync_nand_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_nand_and_fetch(vp4, v4); } + { int ret; ret = __sync_nand_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_nand_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_nand_and_fetch_8(vp8, v8); } + { __int128 ret; ret = __sync_nand_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_nand_and_fetch_16(vp16, v16); } + + { _Bool ret; ret = __sync_bool_compare_and_swap(vp1, v1, v1); } + { _Bool ret; ret = __sync_bool_compare_and_swap_1(vp1, v1, v1); } + { _Bool ret; ret = __sync_bool_compare_and_swap(vp2, v2, v2); } + { _Bool ret; ret = __sync_bool_compare_and_swap_2(vp2, v2, v2); } + { _Bool ret; ret = __sync_bool_compare_and_swap(vp4, v4, v4); } + { _Bool ret; ret = __sync_bool_compare_and_swap_4(vp4, v4, v4); } + { _Bool ret; ret = __sync_bool_compare_and_swap(vp8, v8, v8); } + { _Bool ret; ret = __sync_bool_compare_and_swap_8(vp8, v8, v8); } + { _Bool ret; ret = __sync_bool_compare_and_swap(vp16, v16, v16); } + { _Bool ret; ret = __sync_bool_compare_and_swap_16(vp16, v16,v16); } + + { char ret; ret = __sync_val_compare_and_swap(vp1, v1, v1); } + { char ret; ret = __sync_val_compare_and_swap_1(vp1, v1, v1); } + { short ret; ret = __sync_val_compare_and_swap(vp2, v2, v2); } + { short ret; ret = __sync_val_compare_and_swap_2(vp2, v2, v2); } + { int ret; ret = __sync_val_compare_and_swap(vp4, v4, v4); } + { int ret; ret = __sync_val_compare_and_swap_4(vp4, v4, v4); } + { 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); } + { __int128 ret; ret = __sync_val_compare_and_swap(vp16, v16, v16); } + { __int128 ret; ret = __sync_val_compare_and_swap_16(vp16, v16,v16); } + + { char ret; ret = __sync_lock_test_and_set(vp1, v1); } + { char ret; ret = __sync_lock_test_and_set_1(vp1, v1); } + { short ret; ret = __sync_lock_test_and_set(vp2, v2); } + { short ret; ret = __sync_lock_test_and_set_2(vp2, v2); } + { int ret; ret = __sync_lock_test_and_set(vp4, v4); } + { int ret; ret = __sync_lock_test_and_set_4(vp4, v4); } + { 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); } + { __int128 ret; ret = __sync_lock_test_and_set(vp16, v16); } + { __int128 ret; ret = __sync_lock_test_and_set_16(vp16, v16); } + + { __sync_lock_release(vp1); } + { __sync_lock_release_1(vp1); } + { __sync_lock_release(vp2); } + { __sync_lock_release_2(vp2); } + { __sync_lock_release(vp4); } + { __sync_lock_release_4(vp4); } + { __sync_lock_release(vp8); } + { __sync_lock_release_8(vp8); } + { __sync_lock_release(vp16); } + { __sync_lock_release_16(vp16); } + + { __sync_synchronize(); } + + + + + { _Bool ret; ret = __atomic_test_and_set(vpB, vB); } + { _Bool ret; ret = __atomic_test_and_set(vp1, v1); } + { __atomic_clear(vpB, vB); } + { __atomic_clear(vp1, v1); } + + { char ret; ret = __atomic_exchange_n(vp1, &v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_exchange_1(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; __atomic_exchange(vp1, &v1, &ret, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_exchange_n(vp2, &v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_exchange_2(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; __atomic_exchange(vp2, &v2, &ret, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_exchange_n(vp4, &v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_exchange_4(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; __atomic_exchange(vp4, &v4, &ret, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_exchange_n(vp8, &v8, __ATOMIC_SEQ_CST); } + { 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); } + { __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); } + + { char ret; ret = __atomic_load_n(vp1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_load_1(vp1, __ATOMIC_SEQ_CST); } + { char ret; __atomic_load(vp1, &ret, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_load_n(vp2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_load_2(vp2, __ATOMIC_SEQ_CST); } + { short ret; __atomic_load(vp2, &ret, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_load_n(vp4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_load_4(vp4, __ATOMIC_SEQ_CST); } + { int ret; __atomic_load(vp4, &ret, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_load_n(vp8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_load_8(vp8, __ATOMIC_SEQ_CST); } + { long long int ret; __atomic_load(vp8, &ret, __ATOMIC_SEQ_CST); } + { __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); } + + { _Bool ret; ret = __atomic_compare_exchange_n(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_1(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange(vp1, rp1, &v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_n(vp2, rp2, v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_2(vp2, rp2, v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange(vp2, rp2, &v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_n(vp4, rp4, v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_4(vp4, rp4, v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange(vp4, rp4, &v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_n(vp8, rp8, v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _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); } + { _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); } + + { __atomic_store_n(vp1, v1, __ATOMIC_SEQ_CST); } + { __atomic_store_1(vp1, v1, __ATOMIC_SEQ_CST); } + { __atomic_store(vp1, &v1, __ATOMIC_SEQ_CST); } + { __atomic_store_n(vp2, v2, __ATOMIC_SEQ_CST); } + { __atomic_store_2(vp2, v2, __ATOMIC_SEQ_CST); } + { __atomic_store(vp2, &v2, __ATOMIC_SEQ_CST); } + { __atomic_store_n(vp4, v4, __ATOMIC_SEQ_CST); } + { __atomic_store_4(vp4, v4, __ATOMIC_SEQ_CST); } + { __atomic_store(vp4, &v4, __ATOMIC_SEQ_CST); } + { __atomic_store_n(vp8, v8, __ATOMIC_SEQ_CST); } + { __atomic_store_8(vp8, v8, __ATOMIC_SEQ_CST); } + { __atomic_store(vp8, &v8, __ATOMIC_SEQ_CST); } + { __atomic_store_n(vp16, v16, __ATOMIC_SEQ_CST); } + { __atomic_store_16(vp16, v16, __ATOMIC_SEQ_CST); } + { __atomic_store(vp16, &v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_add_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_add_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_add_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_add_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_add_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_add_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_add_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_add_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_sub_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_sub_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_sub_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_sub_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_sub_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_sub_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_sub_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_sub_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_and_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_and_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_and_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_and_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_and_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_and_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_and_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_and_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_nand_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_nand_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_nand_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_nand_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_nand_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_nand_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_nand_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_nand_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_xor_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_xor_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_xor_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_xor_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_xor_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_xor_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_xor_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_xor_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_or_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_or_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_or_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_or_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_or_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_or_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_or_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_or_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_fetch_add(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_add_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_add(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_add_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_add(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_add_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_fetch_add(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_add_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_fetch_sub(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_sub_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_sub(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_sub_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_sub(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_sub_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_fetch_sub(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_sub_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_fetch_and(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_and_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_and(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_and_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_and(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_and_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_fetch_and(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_and_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_fetch_nand(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_nand_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_nand(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_nand_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_nand(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_nand_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_fetch_nand(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_nand_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_fetch_xor(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_xor_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_xor(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_xor_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_xor(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_xor_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_fetch_xor(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_xor_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { char ret; ret = __atomic_fetch_or(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_or_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_or(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_or_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_or(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_or_4(vp4, v4, __ATOMIC_SEQ_CST); } + { 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); } + { __int128 ret; ret = __atomic_fetch_or(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_or_16(vp16, v16, __ATOMIC_SEQ_CST); } + + { _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vp4); } + { _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vp4); } + { __atomic_thread_fence(__ATOMIC_SEQ_CST); } + { __atomic_signal_fence(__ATOMIC_SEQ_CST); } +} + +int main() { + return 0; +}