diff --git a/libclc/libspirv/include/libspirv/atomic/atomic_helper.h b/libclc/libspirv/include/libspirv/atomic/atomic_helper.h new file mode 100644 index 0000000000000..adb63375b8d51 --- /dev/null +++ b/libclc/libspirv/include/libspirv/atomic/atomic_helper.h @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __CLC_LIBSPIRV_ATOMIC_ATOMIC_HELPER_H__ +#define __CLC_LIBSPIRV_ATOMIC_ATOMIC_HELPER_H__ + +#include +#include + +static _CLC_INLINE int __spirv_get_clang_memory_scope(int Scope) { + switch (Scope) { + case CrossDevice: + return __MEMORY_SCOPE_SYSTEM; + case Device: + return __MEMORY_SCOPE_DEVICE; + case Workgroup: + return __MEMORY_SCOPE_WRKGRP; + case Subgroup: + return __MEMORY_SCOPE_WVFRNT; + case Invocation: + return __MEMORY_SCOPE_SINGLE; + default: + __builtin_unreachable(); + } +} + +static _CLC_INLINE int __spirv_get_clang_memory_order(int Semantics) { + switch (Semantics & 0x1F) { + case None: + return __ATOMIC_RELAXED; + case Acquire: + return __ATOMIC_ACQUIRE; + case Release: + return __ATOMIC_RELEASE; + case (Acquire | Release): + case AcquireRelease: + return __ATOMIC_ACQ_REL; + case SequentiallyConsistent: + // FIXME use __ATOMIC_SEQ_CST + return __ATOMIC_ACQ_REL; + default: + __builtin_unreachable(); + } +} + +#endif // __CLC_LIBSPIRV_ATOMIC_ATOMIC_HELPER_H__ diff --git a/libclc/libspirv/lib/generic/SOURCES b/libclc/libspirv/lib/generic/SOURCES index 82a74fff0d311..e0030ea972246 100644 --- a/libclc/libspirv/lib/generic/SOURCES +++ b/libclc/libspirv/lib/generic/SOURCES @@ -1,7 +1,3 @@ -atomic/loadstore_helpers_unordered.ll -atomic/loadstore_helpers_release.ll -atomic/loadstore_helpers_acquire.ll -atomic/loadstore_helpers_seq_cst.ll subnormal_config.cl subnormal_helper_func.ll async/async_work_group_strided_copy.cl @@ -12,14 +8,14 @@ atomic/atomic_and.cl atomic/atomic_cmpxchg.cl atomic/atomic_dec.cl atomic/atomic_inc.cl +atomic/atomic_load.cl atomic/atomic_max.cl atomic/atomic_min.cl atomic/atomic_or.cl +atomic/atomic_store.cl atomic/atomic_sub.cl atomic/atomic_xchg.cl atomic/atomic_xor.cl -atomic/atomic_load.cl -atomic/atomic_store.cl common/degrees.cl common/fclamp.cl common/mix.cl diff --git a/libclc/libspirv/lib/generic/atomic/atomic_add.cl b/libclc/libspirv/lib/generic/atomic/atomic_add.cl index 96b170d263f70..eb9f142edc070 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_add.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_add.cl @@ -6,38 +6,18 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -#define IMPL(TYPE, AS, FN_NAME) \ - _CLC_OVERLOAD _CLC_DEF TYPE __spirv_AtomicIAdd(AS TYPE *p, int scope, \ - int semantics, TYPE val) { \ - return FN_NAME(p, val); \ - } +#define __CLC_FUNCTION __spirv_AtomicIAdd +#define __CLC_IMPL_FUNCTION __clc_atomic_fetch_add -IMPL(int, global, __sync_fetch_and_add) -IMPL(unsigned int, global, __sync_fetch_and_add) -IMPL(int, local, __sync_fetch_and_add) -IMPL(unsigned int, local, __sync_fetch_and_add) +#define __CLC_BODY +#include -#ifdef cl_khr_int64_base_atomics -IMPL(long, global, __sync_fetch_and_add_8) -IMPL(unsigned long, global, __sync_fetch_and_add_8) -IMPL(long, local, __sync_fetch_and_add_8) -IMPL(unsigned long, local, __sync_fetch_and_add_8) -#endif +#undef __CLC_FUNCTION +#define __CLC_FUNCTION __spirv_AtomicFAddEXT -#if _CLC_GENERIC_AS_SUPPORTED - -#define IMPL_GENERIC(TYPE, FN_NAME) IMPL(TYPE, , FN_NAME) - -IMPL_GENERIC(int, __sync_fetch_and_add) -IMPL_GENERIC(unsigned int, __sync_fetch_and_add) - -#ifdef cl_khr_int64_base_atomics -IMPL_GENERIC(long, __sync_fetch_and_add_8) -IMPL_GENERIC(unsigned long, __sync_fetch_and_add_8) -#endif - -#endif //_CLC_GENERIC_AS_SUPPORTED - -#undef IMPL +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_and.cl b/libclc/libspirv/lib/generic/atomic/atomic_and.cl index a332fe17d793e..1cb2ccbc58a6b 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_and.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_and.cl @@ -6,38 +6,12 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -#define IMPL(TYPE, AS, FN_NAME) \ - _CLC_OVERLOAD _CLC_DEF TYPE __spirv_AtomicAnd(AS TYPE *p, int scope, \ - int semantics, TYPE val) { \ - return FN_NAME(p, val); \ - } +#define __CLC_FUNCTION __spirv_AtomicAnd +#define __CLC_IMPL_FUNCTION __clc_atomic_fetch_and -IMPL(int, global, __sync_fetch_and_and) -IMPL(unsigned int, global, __sync_fetch_and_and) -IMPL(int, local, __sync_fetch_and_and) -IMPL(unsigned int, local, __sync_fetch_and_and) - -#ifdef cl_khr_int64_extended_atomics -IMPL(long, global, __sync_fetch_and_and_8) -IMPL(unsigned long, global, __sync_fetch_and_and_8) -IMPL(long, local, __sync_fetch_and_and_8) -IMPL(unsigned long, local, __sync_fetch_and_and_8) -#endif - -#if _CLC_GENERIC_AS_SUPPORTED - -#define IMPL_GENERIC(TYPE, FN_NAME) IMPL(TYPE, , FN_NAME) - -IMPL_GENERIC(int, __sync_fetch_and_and) -IMPL_GENERIC(unsigned int, __sync_fetch_and_and) - -#ifdef cl_khr_int64_base_atomics -IMPL_GENERIC(long, __sync_fetch_and_and_8) -IMPL_GENERIC(unsigned long, __sync_fetch_and_and_8) -#endif - -#endif //_CLC_GENERIC_AS_SUPPORTED - -#undef IMPL +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_cmpxchg.cl b/libclc/libspirv/lib/generic/atomic/atomic_cmpxchg.cl index cce74d0e7b91e..e789caa445553 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_cmpxchg.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_cmpxchg.cl @@ -6,96 +6,23 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -_CLC_OVERLOAD _CLC_DEF int __spirv_AtomicCompareExchange(local int *p, - int scope, int eq, - int neq, int val, - int cmp) { - return __sync_val_compare_and_swap(p, cmp, val); -} +#define __CLC_FUNCTION __spirv_AtomicCompareExchange +#define __CLC_IMPL_FUNCTION __clc_atomic_compare_exchange +#define __CLC_COMPARE_EXCHANGE -_CLC_OVERLOAD _CLC_DEF int __spirv_AtomicCompareExchange(global int *p, - int scope, int eq, - int neq, int val, - int cmp) { - return __sync_val_compare_and_swap(p, cmp, val); -} +#define __CLC_BODY +#include -_CLC_OVERLOAD _CLC_DEF uint __spirv_AtomicCompareExchange(local uint *p, - int scope, int eq, - int neq, uint val, - uint cmp) { - return __sync_val_compare_and_swap(p, cmp, val); -} +#define __CLC_FLOAT_ONLY +#define __CLC_BODY +#include -_CLC_OVERLOAD _CLC_DEF uint __spirv_AtomicCompareExchange(global uint *p, - int scope, int eq, - int neq, uint val, - uint cmp) { - return __sync_val_compare_and_swap(p, cmp, val); -} +#undef __CLC_FUNCTION +#define __CLC_FUNCTION __spirv_AtomicCompareExchangeWeak -#ifdef cl_khr_int64_base_atomics -_CLC_OVERLOAD _CLC_DEF long __spirv_AtomicCompareExchange(local long *p, - int scope, int eq, - int neq, long val, - long cmp) { - return __sync_val_compare_and_swap_8(p, cmp, val); -} - -_CLC_OVERLOAD _CLC_DEF long __spirv_AtomicCompareExchange(global long *p, - int scope, int eq, - int neq, long val, - long cmp) { - return __sync_val_compare_and_swap_8(p, cmp, val); -} - -_CLC_OVERLOAD _CLC_DEF ulong __spirv_AtomicCompareExchange(local ulong *p, - int scope, int eq, - int neq, ulong val, - ulong cmp) { - return __sync_val_compare_and_swap_8(p, cmp, val); -} - -_CLC_OVERLOAD _CLC_DEF ulong __spirv_AtomicCompareExchange(global ulong *p, - int scope, int eq, - int neq, ulong val, - ulong cmp) { - return __sync_val_compare_and_swap_8(p, cmp, val); -} - -#endif - -#if _CLC_GENERIC_AS_SUPPORTED - -_CLC_OVERLOAD _CLC_DEF int __spirv_AtomicCompareExchange(int *p, int scope, - int eq, int neq, - int val, int cmp) { - return __sync_val_compare_and_swap(p, cmp, val); -} - -_CLC_OVERLOAD _CLC_DEF uint __spirv_AtomicCompareExchange(uint *p, int scope, - int eq, int neq, - uint val, uint cmp) { - return __sync_val_compare_and_swap(p, cmp, val); -} - -#ifdef cl_khr_int64_base_atomics - -_CLC_OVERLOAD _CLC_DEF long __spirv_AtomicCompareExchange(long *p, int scope, - int eq, int neq, - long val, long cmp) { - return __sync_val_compare_and_swap_8(p, cmp, val); -} - -_CLC_OVERLOAD _CLC_DEF ulong __spirv_AtomicCompareExchange(ulong *p, int scope, - int eq, int neq, - ulong val, - ulong cmp) { - return __sync_val_compare_and_swap_8(p, cmp, val); -} - -#endif - -#endif //_CLC_GENERIC_AS_SUPPORTED +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_dec.cl b/libclc/libspirv/lib/generic/atomic/atomic_dec.cl index 156e881836cc2..27118eb724719 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_dec.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_dec.cl @@ -6,47 +6,13 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -_CLC_OVERLOAD _CLC_DEF int __spirv_AtomicIDecrement(local int *p, int scope, - int semantics) { - return __sync_fetch_and_sub(p, (int)1); -} +#define __CLC_FUNCTION __spirv_AtomicIDecrement +#define __CLC_IMPL_FUNCTION __clc_atomic_dec +#define __CLC_NO_VALUE_ARG -_CLC_OVERLOAD _CLC_DEF int __spirv_AtomicIDecrement(global int *p, int scope, - int semantics) { - return __sync_fetch_and_sub(p, (int)1); -} - -_CLC_OVERLOAD _CLC_DEF uint __spirv_AtomicIDecrement(local uint *p, int scope, - int semantics) { - return __sync_fetch_and_sub(p, (uint)1); -} - -_CLC_OVERLOAD _CLC_DEF uint __spirv_AtomicIDecrement(global uint *p, int scope, - int semantics) { - return __sync_fetch_and_sub(p, (uint)1); -} - -#ifdef cl_khr_int64_base_atomics -_CLC_OVERLOAD _CLC_DEF long __spirv_AtomicIDecrement(local long *p, int scope, - int semantics) { - return __sync_fetch_and_sub(p, (long)1); -} - -_CLC_OVERLOAD _CLC_DEF long __spirv_AtomicIDecrement(global long *p, int scope, - int semantics) { - return __sync_fetch_and_sub(p, (long)1); -} - -_CLC_OVERLOAD _CLC_DEF ulong __spirv_AtomicIDecrement(local ulong *p, int scope, - int semantics) { - return __sync_fetch_and_sub(p, (ulong)1); -} - -_CLC_OVERLOAD _CLC_DEF ulong __spirv_AtomicIDecrement(global ulong *p, - int scope, - int semantics) { - return __sync_fetch_and_sub(p, (ulong)1); -} -#endif +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_def.inc b/libclc/libspirv/lib/generic/atomic/atomic_def.inc new file mode 100644 index 0000000000000..a2430cdbce3f9 --- /dev/null +++ b/libclc/libspirv/lib/generic/atomic/atomic_def.inc @@ -0,0 +1,75 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===---------------------------------------------------------------------- + +#if defined(__CLC_SCALAR) && (defined(__CLC_FPSIZE) || (__CLC_GENSIZE >= 32)) + +#ifdef __CLC_NO_VALUE_ARG +#define __CLC_DEFINE_ATOMIC(ADDRSPACE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_FUNCTION( \ + ADDRSPACE __CLC_GENTYPE *Ptr, int Scope, int Semantics) { \ + __CLC_GENTYPE Res = \ + __CLC_IMPL_FUNCTION((ADDRSPACE __CLC_GENTYPE *)Ptr, \ + __spirv_get_clang_memory_order(Semantics), \ + __spirv_get_clang_memory_scope(Scope)); \ + return Res; \ + } +#elif defined(__CLC_INC_DEC) +#define __CLC_DEFINE_ATOMIC(ADDRSPACE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_FUNCTION( \ + ADDRSPACE __CLC_GENTYPE *Ptr, int Scope, int Semantics) { \ + __CLC_GENTYPE Res = \ + __CLC_IMPL_FUNCTION((ADDRSPACE __CLC_GENTYPE *)Ptr, \ + __spirv_get_clang_memory_order(Semantics), \ + __spirv_get_clang_memory_scope(Scope)); \ + return Res; \ + } +#elif defined(__CLC_RETURN_VOID) +#define __CLC_DEFINE_ATOMIC(ADDRSPACE) \ + _CLC_OVERLOAD _CLC_DEF void __CLC_FUNCTION(ADDRSPACE __CLC_GENTYPE *Ptr, \ + int Scope, int Semantics, \ + __CLC_GENTYPE Value) { \ + __CLC_IMPL_FUNCTION((ADDRSPACE __CLC_GENTYPE *)Ptr, Value, \ + __spirv_get_clang_memory_order(Semantics), \ + __spirv_get_clang_memory_scope(Scope)); \ + } +#elif defined(__CLC_COMPARE_EXCHANGE) +#define __CLC_DEFINE_ATOMIC(ADDRSPACE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_FUNCTION( \ + ADDRSPACE __CLC_GENTYPE *Ptr, int Scope, int Equal, int Unequal, \ + __CLC_GENTYPE Value, __CLC_GENTYPE Comparator) { \ + __CLC_GENTYPE Res = \ + __CLC_IMPL_FUNCTION((ADDRSPACE __CLC_GENTYPE *)Ptr, Comparator, Value, \ + __spirv_get_clang_memory_order(Equal), \ + __spirv_get_clang_memory_order(Unequal), \ + __spirv_get_clang_memory_scope(Scope)); \ + return Res; \ + } +#else +#define __CLC_DEFINE_ATOMIC(ADDRSPACE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_FUNCTION( \ + ADDRSPACE __CLC_GENTYPE *Ptr, int Scope, int Semantics, \ + __CLC_GENTYPE Value) { \ + __CLC_GENTYPE Res = \ + __CLC_IMPL_FUNCTION((ADDRSPACE __CLC_GENTYPE *)Ptr, Value, \ + __spirv_get_clang_memory_order(Semantics), \ + __spirv_get_clang_memory_scope(Scope)); \ + return Res; \ + } +#endif + +__CLC_DEFINE_ATOMIC(private) +__CLC_DEFINE_ATOMIC(global) +__CLC_DEFINE_ATOMIC(local) +#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED +__CLC_DEFINE_ATOMIC() +#endif + +#undef __CLC_DEFINE_ATOMIC + +#endif // defined(__CLC_SCALAR) && (defined(__CLC_FPSIZE) || (__CLC_GENSIZE >= + // 32)) diff --git a/libclc/libspirv/lib/generic/atomic/atomic_inc.cl b/libclc/libspirv/lib/generic/atomic/atomic_inc.cl index 4d5f1473a136e..d06c0c3da5626 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_inc.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_inc.cl @@ -6,47 +6,13 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -_CLC_OVERLOAD _CLC_DEF int __spirv_AtomicIIncrement(local int *p, int scope, - int semantics) { - return __sync_fetch_and_add(p, (int)1); -} +#define __CLC_FUNCTION __spirv_AtomicIIncrement +#define __CLC_IMPL_FUNCTION __clc_atomic_inc +#define __CLC_NO_VALUE_ARG -_CLC_OVERLOAD _CLC_DEF int __spirv_AtomicIIncrement(global int *p, int scope, - int semantics) { - return __sync_fetch_and_add(p, (int)1); -} - -_CLC_OVERLOAD _CLC_DEF uint __spirv_AtomicIIncrement(local uint *p, int scope, - int semantics) { - return __sync_fetch_and_add(p, (uint)1); -} - -_CLC_OVERLOAD _CLC_DEF uint __spirv_AtomicIIncrement(global uint *p, int scope, - int semantics) { - return __sync_fetch_and_add(p, (uint)1); -} - -#ifdef cl_khr_int64_base_atomics -_CLC_OVERLOAD _CLC_DEF long __spirv_AtomicIIncrement(local long *p, int scope, - int semantics) { - return __sync_fetch_and_add(p, (long)1); -} - -_CLC_OVERLOAD _CLC_DEF long __spirv_AtomicIIncrement(global long *p, int scope, - int semantics) { - return __sync_fetch_and_add(p, (long)1); -} - -_CLC_OVERLOAD _CLC_DEF ulong __spirv_AtomicIIncrement(local ulong *p, int scope, - int semantics) { - return __sync_fetch_and_add(p, (ulong)1); -} - -_CLC_OVERLOAD _CLC_DEF ulong __spirv_AtomicIIncrement(global ulong *p, - int scope, - int semantics) { - return __sync_fetch_and_add(p, (ulong)1); -} -#endif +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_load.cl b/libclc/libspirv/lib/generic/atomic/atomic_load.cl index 9e485f6d4f36f..8627b9737c26f 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_load.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_load.cl @@ -6,53 +6,16 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -#define FDECL(TYPE, PREFIX, AS, BYTE_SIZE, MEM_ORDER) \ - TYPE __clc__atomic_##PREFIX##load_##AS##_##BYTE_SIZE##_##MEM_ORDER( \ - AS const TYPE *); +#define __CLC_FUNCTION __spirv_AtomicLoad +#define __CLC_IMPL_FUNCTION __clc_atomic_load +#define __CLC_NO_VALUE_ARG -#define IMPL(TYPE, AS, PREFIX, BYTE_SIZE) \ - FDECL(TYPE, PREFIX, AS, BYTE_SIZE, unordered) \ - FDECL(TYPE, PREFIX, AS, BYTE_SIZE, acquire) \ - FDECL(TYPE, PREFIX, AS, BYTE_SIZE, seq_cst) \ - _CLC_OVERLOAD _CLC_DEF TYPE __spirv_AtomicLoad(AS TYPE *p, int scope, \ - int semantics) { \ - if (semantics & Acquire) { \ - return __clc__atomic_##PREFIX##load_##AS##_##BYTE_SIZE##_acquire(p); \ - } \ - if (semantics & SequentiallyConsistent) { \ - return __clc__atomic_##PREFIX##load_##AS##_##BYTE_SIZE##_seq_cst(p); \ - } \ - return __clc__atomic_##PREFIX##load_##AS##_##BYTE_SIZE##_unordered(p); \ - } +#define __CLC_BODY +#include -#define IMPL_AS(TYPE, PREFIX, BYTE_SIZE) \ - IMPL(TYPE, global, PREFIX, BYTE_SIZE) \ - IMPL(TYPE, local, PREFIX, BYTE_SIZE) - -IMPL_AS(int, , 4) -IMPL_AS(unsigned int, u, 4) - -#ifdef cl_khr_int64_base_atomics -IMPL_AS(long, , 8) -IMPL_AS(unsigned long, u, 8) -#endif - -#if _CLC_GENERIC_AS_SUPPORTED - -#define IMPL_GENERIC(TYPE, PREFIX, BYTE_SIZE) IMPL(TYPE, , PREFIX, BYTE_SIZE) - -IMPL_GENERIC(int, , 4) -IMPL_GENERIC(unsigned int, u, 4) - -#ifdef cl_khr_int64_base_atomics -IMPL_GENERIC(long, , 8) -IMPL_GENERIC(unsigned long, u, 8) -#endif - -#endif //_CLC_GENERIC_AS_SUPPORTED - -#undef FDECL -#undef IMPL_AS -#undef IMPL +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_max.cl b/libclc/libspirv/lib/generic/atomic/atomic_max.cl index e6665cbcb2fba..e31f55bc59bfc 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_max.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_max.cl @@ -6,48 +6,16 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -#define IMPL(TYPE, AS, NAME, PREFIX, SUFFIX) \ - _CLC_OVERLOAD _CLC_DEF TYPE NAME(AS TYPE *p, int scope, int semantics, \ - TYPE val) { \ - return PREFIX##__sync_fetch_and_##SUFFIX(p, val); \ - } +#define __CLC_IMPL_FUNCTION __clc_atomic_fetch_max -IMPL(int, global, __spirv_AtomicSMax, , max) -IMPL(unsigned int, global, __spirv_AtomicUMax, , umax) -IMPL(int, local, __spirv_AtomicSMax, , max) -IMPL(unsigned int, local, __spirv_AtomicUMax, , umax) +#define __CLC_BODY +#include -#ifdef cl_khr_int64_extended_atomics -unsigned long __clc__sync_fetch_and_max_local_8(volatile local long *, long); -unsigned long __clc__sync_fetch_and_max_global_8(volatile global long *, long); -unsigned long __clc__sync_fetch_and_umax_local_8(volatile local unsigned long *, unsigned long); -unsigned long __clc__sync_fetch_and_umax_global_8(volatile global unsigned long *, unsigned long); +#define __CLC_FUNCTION __spirv_AtomicFMaxEXT -IMPL(long, global, __spirv_AtomicSMax, __clc, max_global_8) -IMPL(unsigned long, global, __spirv_AtomicUMax, __clc, umax_global_8) -IMPL(long, local, __spirv_AtomicSMax, __clc, max_local_8) -IMPL(unsigned long, local, __spirv_AtomicUMax, __clc, umax_local_8) -#endif - -#if _CLC_GENERIC_AS_SUPPORTED - -#define IMPL_GENERIC(TYPE, NAME, PREFIX, SUFFIX) \ - IMPL(TYPE, , NAME, PREFIX, SUFFIX) - -IMPL_GENERIC(int, __spirv_AtomicSMax, , max) -IMPL_GENERIC(unsigned int, __spirv_AtomicUMax, , umax) - -#ifdef cl_khr_int64_extended_atomics - -unsigned long __clc__sync_fetch_and_max_generic_8(volatile generic long *, long); -unsigned long __clc__sync_fetch_and_umax_generic_8(volatile __generic unsigned long *, unsigned long); - -IMPL_GENERIC(long, __spirv_AtomicSMax, __clc, max_generic_8) -IMPL_GENERIC(unsigned long, __spirv_AtomicUMax, __clc, umax_generic_8) -#endif - - -#endif //_CLC_GENERIC_AS_SUPPORTED -#undef IMPL +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_min.cl b/libclc/libspirv/lib/generic/atomic/atomic_min.cl index d2f8d6360721b..9af4ef21bd419 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_min.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_min.cl @@ -6,48 +6,17 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -#define IMPL(TYPE, AS, NAME, PREFIX, SUFFIX) \ - _CLC_OVERLOAD _CLC_DEF TYPE NAME(AS TYPE *p, int scope, int semantics, \ - TYPE val) { \ - return PREFIX##__sync_fetch_and_##SUFFIX(p, val); \ - } +#define __CLC_IMPL_FUNCTION __clc_atomic_fetch_min +#define __CLC_ATOMIC_MIN -IMPL(int, global, __spirv_AtomicSMin, , min) -IMPL(unsigned int, global, __spirv_AtomicUMin, , umin) -IMPL(int, local, __spirv_AtomicSMin, , min) -IMPL(unsigned int, local, __spirv_AtomicUMin, , umin) +#define __CLC_BODY +#include -#ifdef cl_khr_int64_extended_atomics -unsigned long __clc__sync_fetch_and_min_local_8(volatile local long *, long); -unsigned long __clc__sync_fetch_and_min_global_8(volatile global long *, long); -unsigned long __clc__sync_fetch_and_umin_local_8(volatile local unsigned long *, unsigned long); -unsigned long __clc__sync_fetch_and_umin_global_8(volatile global unsigned long *, unsigned long); +#define __CLC_FUNCTION __spirv_AtomicFMinEXT -IMPL(long, global, __spirv_AtomicSMin, __clc, min_global_8) -IMPL(unsigned long, global, __spirv_AtomicUMin, __clc, umin_global_8) -IMPL(long, local, __spirv_AtomicSMin, __clc, min_local_8) -IMPL(unsigned long, local, __spirv_AtomicUMin, __clc, umin_local_8) -#endif - -#if _CLC_GENERIC_AS_SUPPORTED - -#define IMPL_GENERIC(TYPE, NAME, PREFIX, SUFFIX) \ - IMPL(TYPE, , NAME, PREFIX, SUFFIX) - -IMPL_GENERIC(int, __spirv_AtomicSMin, , min) -IMPL_GENERIC(unsigned int, __spirv_AtomicUMin, , umin) - -#ifdef cl_khr_int64_extended_atomics - -unsigned long __clc__sync_fetch_and_min_generic_8(volatile generic long *, long); -unsigned long __clc__sync_fetch_and_umin_generic_8(volatile __generic unsigned long *, unsigned long); - -IMPL_GENERIC(long, __spirv_AtomicSMin, __clc, min_generic_8) -IMPL_GENERIC(unsigned long, __spirv_AtomicUMin, __clc, umin_generic_8) -#endif - - -#endif //_CLC_GENERIC_AS_SUPPORTED -#undef IMPL +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_minmax.inc b/libclc/libspirv/lib/generic/atomic/atomic_minmax.inc new file mode 100644 index 0000000000000..8096e954eccbe --- /dev/null +++ b/libclc/libspirv/lib/generic/atomic/atomic_minmax.inc @@ -0,0 +1,29 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifdef __CLC_GEN_S + +#ifdef __CLC_ATOMIC_MIN +#define __CLC_FUNCTION __spirv_AtomicSMin +#else +#define __CLC_FUNCTION __spirv_AtomicSMax +#endif + +#else + +#ifdef __CLC_ATOMIC_MIN +#define __CLC_FUNCTION __spirv_AtomicUMin +#else +#define __CLC_FUNCTION __spirv_AtomicUMax +#endif + +#endif + +#include + +#undef __CLC_FUNCTION diff --git a/libclc/libspirv/lib/generic/atomic/atomic_or.cl b/libclc/libspirv/lib/generic/atomic/atomic_or.cl index 43259a7828210..31fcc2e627acf 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_or.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_or.cl @@ -6,38 +6,12 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -#define IMPL(TYPE, AS, FN_NAME) \ - _CLC_OVERLOAD _CLC_DEF TYPE __spirv_AtomicOr(AS TYPE *p, int scope, \ - int semantics, TYPE val) { \ - return FN_NAME(p, val); \ - } +#define __CLC_FUNCTION __spirv_AtomicOr +#define __CLC_IMPL_FUNCTION __clc_atomic_fetch_or -IMPL(int, global, __sync_fetch_and_or) -IMPL(unsigned int, global, __sync_fetch_and_or) -IMPL(int, local, __sync_fetch_and_or) -IMPL(unsigned int, local, __sync_fetch_and_or) - -#ifdef cl_khr_int64_extended_atomics -IMPL(long, global, __sync_fetch_and_or_8) -IMPL(unsigned long, global, __sync_fetch_and_or_8) -IMPL(long, local, __sync_fetch_and_or_8) -IMPL(unsigned long, local, __sync_fetch_and_or_8) -#endif - -#if _CLC_GENERIC_AS_SUPPORTED - -#define IMPL_GENERIC(TYPE, FN_NAME) IMPL(TYPE, , FN_NAME) - -IMPL_GENERIC(int, __sync_fetch_and_or) -IMPL_GENERIC(unsigned int, __sync_fetch_and_or) - -#ifdef cl_khr_int64_base_atomics -IMPL_GENERIC(long, __sync_fetch_and_or_8) -IMPL_GENERIC(unsigned long, __sync_fetch_and_or_8) -#endif - -#endif //_CLC_GENERIC_AS_SUPPORTED - -#undef IMPL +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_store.cl b/libclc/libspirv/lib/generic/atomic/atomic_store.cl index adec4a1b83416..3c5fdbaec609e 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_store.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_store.cl @@ -6,63 +6,16 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -_CLC_OVERLOAD _CLC_DEF void __spirv_AtomicStore(global float *p, int scope, - int semantics, float val) { - __spirv_AtomicStore((global uint *)p, scope, semantics, __clc_as_uint(val)); -} +#define __CLC_FUNCTION __spirv_AtomicStore +#define __CLC_IMPL_FUNCTION __clc_atomic_store +#define __CLC_RETURN_VOID -_CLC_OVERLOAD _CLC_DEF void __spirv_AtomicStore(local float *p, int scope, - int semantics, float val) { - __spirv_AtomicStore((local uint *)p, scope, semantics, __clc_as_uint(val)); -} +#define __CLC_BODY +#include -#define FDECL(TYPE, PREFIX, AS, BYTE_SIZE, MEM_ORDER) \ - TYPE __clc__atomic_##PREFIX##store_##AS##_##BYTE_SIZE##_##MEM_ORDER( \ - AS const TYPE *, TYPE); - -#define IMPL(TYPE, AS, PREFIX, BYTE_SIZE) \ - FDECL(TYPE, PREFIX, AS, BYTE_SIZE, unordered) \ - FDECL(TYPE, PREFIX, AS, BYTE_SIZE, release) \ - FDECL(TYPE, PREFIX, AS, BYTE_SIZE, seq_cst) \ - _CLC_OVERLOAD _CLC_DEF void __spirv_AtomicStore(AS TYPE *p, int scope, \ - int semantics, TYPE val) { \ - if (semantics == Release) { \ - __clc__atomic_##PREFIX##store_##AS##_##BYTE_SIZE##_release(p, val); \ - } else if (semantics == SequentiallyConsistent) { \ - __clc__atomic_##PREFIX##store_##AS##_##BYTE_SIZE##_seq_cst(p, val); \ - } else { \ - __clc__atomic_##PREFIX##store_##AS##_##BYTE_SIZE##_unordered(p, val); \ - } \ - } - -#define IMPL_AS(TYPE, PREFIX, BYTE_SIZE) \ - IMPL(TYPE, global, PREFIX, BYTE_SIZE) \ - IMPL(TYPE, local, PREFIX, BYTE_SIZE) - -IMPL_AS(int, , 4) -IMPL_AS(unsigned int, u, 4) - -#ifdef cl_khr_int64_base_atomics -IMPL_AS(long, , 8) -IMPL_AS(unsigned long, u, 8) -#endif - -#if _CLC_GENERIC_AS_SUPPORTED - -#define IMPL_GENERIC(TYPE, PREFIX, BYTE_SIZE) IMPL(TYPE, , PREFIX, BYTE_SIZE) - -IMPL_GENERIC(int, , 4) -IMPL_GENERIC(unsigned int, u, 4) - -#ifdef cl_khr_int64_base_atomics -IMPL_GENERIC(long, , 8) -IMPL_GENERIC(unsigned long, u, 8) -#endif - -#endif //_CLC_GENERIC_AS_SUPPORTED - -#undef FDECL -#undef IMPL_AS -#undef IMPL +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_sub.cl b/libclc/libspirv/lib/generic/atomic/atomic_sub.cl index bafa60d4ac3f8..35b154b2dde9b 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_sub.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_sub.cl @@ -6,37 +6,12 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -#define IMPL(TYPE, AS, FN_NAME) \ - _CLC_OVERLOAD _CLC_DEF TYPE __spirv_AtomicISub(AS TYPE *p, int scope, \ - int semantics, TYPE val) { \ - return FN_NAME(p, val); \ - } +#define __CLC_FUNCTION __spirv_AtomicISub +#define __CLC_IMPL_FUNCTION __clc_atomic_fetch_sub -IMPL(int, global, __sync_fetch_and_sub) -IMPL(unsigned int, global, __sync_fetch_and_sub) -IMPL(int, local, __sync_fetch_and_sub) -IMPL(unsigned int, local, __sync_fetch_and_sub) - -#ifdef cl_khr_int64_base_atomics -IMPL(long, global, __sync_fetch_and_sub_8) -IMPL(unsigned long, global, __sync_fetch_and_sub_8) -IMPL(long, local, __sync_fetch_and_sub_8) -IMPL(unsigned long, local, __sync_fetch_and_sub_8) -#endif - -#if _CLC_GENERIC_AS_SUPPORTED - -#define IMPL_GENERIC(TYPE, FN_NAME) IMPL(TYPE, , FN_NAME) - -IMPL_GENERIC(int, __sync_fetch_and_sub) -IMPL_GENERIC(unsigned int, __sync_fetch_and_sub) - -#ifdef cl_khr_int64_base_atomics -IMPL_GENERIC(long, __sync_fetch_and_sub_8) -IMPL_GENERIC(unsigned long, __sync_fetch_and_sub_8) -#endif - -#endif //_CLC_GENERIC_AS_SUPPORTED -#undef IMPL +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_xchg.cl b/libclc/libspirv/lib/generic/atomic/atomic_xchg.cl index f71d7d5596310..af89ea0c8c348 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_xchg.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_xchg.cl @@ -6,50 +6,15 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -_CLC_OVERLOAD _CLC_DEF float __spirv_AtomicExchange(global float *p, int scope, - int semantics, float val) { - return __clc_as_float(__spirv_AtomicExchange((global uint *)p, scope, - semantics, __clc_as_uint(val))); -} +#define __CLC_FUNCTION __spirv_AtomicExchange +#define __CLC_IMPL_FUNCTION __clc_atomic_exchange -_CLC_OVERLOAD _CLC_DEF float __spirv_AtomicExchange(local float *p, int scope, - int semantics, float val) { - return __clc_as_float(__spirv_AtomicExchange((local uint *)p, scope, - semantics, __clc_as_uint(val))); -} +#define __CLC_BODY +#include -#define IMPL(TYPE, AS, FN_NAME) \ - _CLC_OVERLOAD _CLC_DEF TYPE __spirv_AtomicExchange( \ - AS TYPE *p, int scope, int semantics, TYPE val) { \ - return FN_NAME(p, val); \ - } - -IMPL(int, global, __sync_swap_4) -IMPL(unsigned int, global, __sync_swap_4) -IMPL(int, local, __sync_swap_4) -IMPL(unsigned int, local, __sync_swap_4) - -#ifdef cl_khr_int64_base_atomics -IMPL(long, global, __sync_swap_8) -IMPL(unsigned long, global, __sync_swap_8) -IMPL(long, local, __sync_swap_8) -IMPL(unsigned long, local, __sync_swap_8) -#endif - -#if _CLC_GENERIC_AS_SUPPORTED - -#define IMPL_GENERIC(TYPE, FN_NAME) IMPL(TYPE, , FN_NAME) - -IMPL_GENERIC(int, __sync_swap_4) -IMPL_GENERIC(unsigned int, __sync_swap_4) - -#ifdef cl_khr_int64_base_atomics -IMPL_GENERIC(long, __sync_swap_8) -IMPL_GENERIC(unsigned long, __sync_swap_8) -#endif - -#endif //_CLC_GENERIC_AS_SUPPORTED - -#undef IMPL +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/atomic_xor.cl b/libclc/libspirv/lib/generic/atomic/atomic_xor.cl index 291eba060c6e2..89f08fdf697c5 100644 --- a/libclc/libspirv/lib/generic/atomic/atomic_xor.cl +++ b/libclc/libspirv/lib/generic/atomic/atomic_xor.cl @@ -6,37 +6,12 @@ // //===----------------------------------------------------------------------===// +#include +#include #include -#define IMPL(TYPE, AS, FN_NAME) \ - _CLC_OVERLOAD _CLC_DEF TYPE __spirv_AtomicXor(AS TYPE *p, int scope, \ - int semantics, TYPE val) { \ - return FN_NAME(p, val); \ - } +#define __CLC_FUNCTION __spirv_AtomicXor +#define __CLC_IMPL_FUNCTION __clc_atomic_fetch_xor -IMPL(int, global, __sync_fetch_and_xor) -IMPL(unsigned int, global, __sync_fetch_and_xor) -IMPL(int, local, __sync_fetch_and_xor) -IMPL(unsigned int, local, __sync_fetch_and_xor) - -#ifdef cl_khr_int64_extended_atomics -IMPL(long, global, __sync_fetch_and_xor_8) -IMPL(unsigned long, global, __sync_fetch_and_xor_8) -IMPL(long, local, __sync_fetch_and_xor_8) -IMPL(unsigned long, local, __sync_fetch_and_xor_8) -#endif - -#if _CLC_GENERIC_AS_SUPPORTED - -#define IMPL_GENERIC(TYPE, FN_NAME) IMPL(TYPE, , FN_NAME) - -IMPL_GENERIC(int, __sync_fetch_and_xor) -IMPL_GENERIC(unsigned int, __sync_fetch_and_xor) - -#ifdef cl_khr_int64_base_atomics -IMPL_GENERIC(long, __sync_fetch_and_xor_8) -IMPL_GENERIC(unsigned long, __sync_fetch_and_xor_8) -#endif - -#endif //_CLC_GENERIC_AS_SUPPORTED -#undef IMPL +#define __CLC_BODY +#include diff --git a/libclc/libspirv/lib/generic/atomic/loadstore_helpers_acquire.ll b/libclc/libspirv/lib/generic/atomic/loadstore_helpers_acquire.ll deleted file mode 100644 index 666c2d9fdf5d6..0000000000000 --- a/libclc/libspirv/lib/generic/atomic/loadstore_helpers_acquire.ll +++ /dev/null @@ -1,76 +0,0 @@ -; This file contains helper functions for the acquire memory ordering constraint. -; Other targets can specialize this file to account for unsupported features in their backend. - -declare void @llvm.trap() - -define i32 @__clc__atomic_load_global_4_acquire(i32 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i32 @__clc__atomic_load_local_4_acquire(i32 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i32 @__clc__atomic_load__4_acquire(i32 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_load_global_8_acquire(i64 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_load_local_8_acquire(i64 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_load__8_acquire(i64 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i32 @__clc__atomic_uload_global_4_acquire(i32 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i32, i32 addrspace(1)* %ptr acquire, align 4 - ret i32 %0 -} - -define i32 @__clc__atomic_uload_local_4_acquire(i32 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i32 @__clc__atomic_uload__4_acquire(i32 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i32, i32 addrspace(0)* %ptr acquire, align 4 - ret i32 %0 -} - -define i64 @__clc__atomic_uload_global_8_acquire(i64 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_uload_local_8_acquire(i64 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_uload__8_acquire(i64 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} diff --git a/libclc/libspirv/lib/generic/atomic/loadstore_helpers_release.ll b/libclc/libspirv/lib/generic/atomic/loadstore_helpers_release.ll deleted file mode 100644 index 1adde32bc9f0d..0000000000000 --- a/libclc/libspirv/lib/generic/atomic/loadstore_helpers_release.ll +++ /dev/null @@ -1,77 +0,0 @@ -; This file contains helper functions for the release memory ordering constraint. -; Other targets can specialize this file to account for unsupported features in their backend. - -declare void @llvm.trap() - -define void @__clc__atomic_store_global_4_release(i32 addrspace(1)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store_local_4_release(i32 addrspace(3)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store__4_release(i32 addrspace(0)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store_global_8_release(i64 addrspace(1)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store_local_8_release(i64 addrspace(3)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store__8_release(i64 addrspace(0)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore_global_4_release(i32 addrspace(1)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore_local_4_release(i32 addrspace(3)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore__4_release(i32 addrspace(0)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore_global_8_release(i64 addrspace(1)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore_local_8_release(i64 addrspace(3)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore__8_release(i64 addrspace(0)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - diff --git a/libclc/libspirv/lib/generic/atomic/loadstore_helpers_seq_cst.ll b/libclc/libspirv/lib/generic/atomic/loadstore_helpers_seq_cst.ll deleted file mode 100644 index fc84b72252aa0..0000000000000 --- a/libclc/libspirv/lib/generic/atomic/loadstore_helpers_seq_cst.ll +++ /dev/null @@ -1,148 +0,0 @@ -; This file contains helper functions for the seq_cst memory ordering constraint. -; Other targets can specialize this file to account for unsupported features in their backend. - -declare void @llvm.trap() - -define i32 @__clc__atomic_load_global_4_seq_cst(i32 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i32 @__clc__atomic_load_local_4_seq_cst(i32 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i32 @__clc__atomic_load__4_seq_cst(i32 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_load_global_8_seq_cst(i64 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_load_local_8_seq_cst(i64 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_load__8_seq_cst(i64 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i32 @__clc__atomic_uload_global_4_seq_cst(i32 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i32, i32 addrspace(1)* %ptr seq_cst, align 4 - ret i32 %0 -} - -define i32 @__clc__atomic_uload_local_4_seq_cst(i32 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i32 @__clc__atomic_uload__4_seq_cst(i32 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_uload_global_8_seq_cst(i64 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_uload_local_8_seq_cst(i64 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define i64 @__clc__atomic_uload__8_seq_cst(i64 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store_global_4_seq_cst(i32 addrspace(1)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store_local_4_seq_cst(i32 addrspace(3)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store__4_seq_cst(i32 addrspace(0)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store_global_8_seq_cst(i64 addrspace(1)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store_local_8_seq_cst(i64 addrspace(3)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_store__8_seq_cst(i64 addrspace(0)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore_global_4_seq_cst(i32 addrspace(1)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore_local_4_seq_cst(i32 addrspace(3)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore__4_seq_cst(i32 addrspace(0)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore_global_8_seq_cst(i64 addrspace(1)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore_local_8_seq_cst(i64 addrspace(3)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} - -define void @__clc__atomic_ustore__8_seq_cst(i64 addrspace(0)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - tail call void @llvm.trap() - unreachable -} diff --git a/libclc/libspirv/lib/generic/atomic/loadstore_helpers_unordered.ll b/libclc/libspirv/lib/generic/atomic/loadstore_helpers_unordered.ll deleted file mode 100644 index ea58fa495d607..0000000000000 --- a/libclc/libspirv/lib/generic/atomic/loadstore_helpers_unordered.ll +++ /dev/null @@ -1,149 +0,0 @@ -; This file contains helper functions for the unordered memory ordering constraint. -; Other targets can specialize this file to account for unsupported features in their backend. - -declare void @llvm.trap() - -define i32 @__clc__atomic_load_global_4_unordered(i32 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i32, i32 addrspace(1)* %ptr unordered, align 4 - ret i32 %0 -} - -define i32 @__clc__atomic_load_local_4_unordered(i32 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i32, i32 addrspace(3)* %ptr unordered, align 4 - ret i32 %0 -} - -define i32 @__clc__atomic_load__4_unordered(i32 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i32, i32 addrspace(0)* %ptr unordered, align 4 - ret i32 %0 -} - -define i64 @__clc__atomic_load_global_8_unordered(i64 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i64, i64 addrspace(1)* %ptr unordered, align 8 - ret i64 %0 -} - -define i64 @__clc__atomic_load_local_8_unordered(i64 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i64, i64 addrspace(3)* %ptr unordered, align 8 - ret i64 %0 -} - -define i64 @__clc__atomic_load__8_unordered(i64 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i64, i64 addrspace(0)* %ptr unordered, align 8 - ret i64 %0 -} - -define i32 @__clc__atomic_uload_global_4_unordered(i32 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i32, i32 addrspace(1)* %ptr unordered, align 4 - ret i32 %0 -} - -define i32 @__clc__atomic_uload_local_4_unordered(i32 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i32, i32 addrspace(3)* %ptr unordered, align 4 - ret i32 %0 -} - -define i32 @__clc__atomic_uload__4_unordered(i32 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i32, i32 addrspace(0)* %ptr unordered, align 4 - ret i32 %0 -} - -define i64 @__clc__atomic_uload_global_8_unordered(i64 addrspace(1)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i64, i64 addrspace(1)* %ptr unordered, align 8 - ret i64 %0 -} - -define i64 @__clc__atomic_uload_local_8_unordered(i64 addrspace(3)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i64, i64 addrspace(3)* %ptr unordered, align 8 - ret i64 %0 -} - -define i64 @__clc__atomic_uload__8_unordered(i64 addrspace(0)* nocapture %ptr) nounwind alwaysinline { -entry: - %0 = load atomic volatile i64, i64 addrspace(0)* %ptr unordered, align 8 - ret i64 %0 -} - -define void @__clc__atomic_store_global_4_unordered(i32 addrspace(1)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - store atomic volatile i32 %value, i32 addrspace(1)* %ptr unordered, align 4 - ret void -} - -define void @__clc__atomic_store_local_4_unordered(i32 addrspace(3)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - store atomic volatile i32 %value, i32 addrspace(3)* %ptr unordered, align 4 - ret void -} - -define void @__clc__atomic_store__4_unordered(i32 addrspace(0)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - store atomic volatile i32 %value, i32 addrspace(0)* %ptr unordered, align 4 - ret void -} - -define void @__clc__atomic_store_global_8_unordered(i64 addrspace(1)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - store atomic volatile i64 %value, i64 addrspace(1)* %ptr unordered, align 8 - ret void -} - -define void @__clc__atomic_store_local_8_unordered(i64 addrspace(3)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - store atomic volatile i64 %value, i64 addrspace(3)* %ptr unordered, align 8 - ret void -} - -define void @__clc__atomic_store__8_unordered(i64 addrspace(0)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - store atomic volatile i64 %value, i64 addrspace(0)* %ptr unordered, align 8 - ret void -} - -define void @__clc__atomic_ustore_global_4_unordered(i32 addrspace(1)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - store atomic volatile i32 %value, i32 addrspace(1)* %ptr unordered, align 4 - ret void -} - -define void @__clc__atomic_ustore_local_4_unordered(i32 addrspace(3)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - store atomic volatile i32 %value, i32 addrspace(3)* %ptr unordered, align 4 - ret void -} - -define void @__clc__atomic_ustore__4_unordered(i32 addrspace(0)* nocapture %ptr, i32 %value) nounwind alwaysinline { -entry: - store atomic volatile i32 %value, i32 addrspace(0)* %ptr unordered, align 4 - ret void -} - -define void @__clc__atomic_ustore_global_8_unordered(i64 addrspace(1)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - store atomic volatile i64 %value, i64 addrspace(1)* %ptr unordered, align 8 - ret void -} - -define void @__clc__atomic_ustore_local_8_unordered(i64 addrspace(3)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - store atomic volatile i64 %value, i64 addrspace(3)* %ptr unordered, align 8 - ret void -} - -define void @__clc__atomic_ustore__8_unordered(i64 addrspace(0)* nocapture %ptr, i64 %value) nounwind alwaysinline { -entry: - store atomic volatile i64 %value, i64 addrspace(0)* %ptr unordered, align 8 - ret void -} - diff --git a/sycl/test-e2e/WorkGroupMemory/reduction_lambda.cpp b/sycl/test-e2e/WorkGroupMemory/reduction_lambda.cpp index decdb730c5259..39f591cff37c3 100644 --- a/sycl/test-e2e/WorkGroupMemory/reduction_lambda.cpp +++ b/sycl/test-e2e/WorkGroupMemory/reduction_lambda.cpp @@ -3,8 +3,6 @@ // RUN: %{run} %t.out // XFAIL: spirv-backend // XFAIL-TRACKER: https://github.com/intel/llvm/issues/18230 -// XFAIL: target-native_cpu -// XFAIL-TRACKER: https://github.com/intel/llvm/issues/20142 #include "common.hpp"