[SYCL] Add SPIR-V atomic builtins declarations to clang/lib/Sema/SPIRVBuiltins.td

clang/lib/Sema/SPIRVBuiltins.td

@@ -392,10 +392,13 @@ def AIGenTypeNNoScalar     : GenericType<"AIGenTypeNNoScalar", TLAllInts, VecNoS
 // All integer to unsigned
 def AI2UGenTypeN           : GenericType<"AI2UGenTypeN", TLAllUIntsTwice, VecAndScalar>;
 // Signed integer
+def SGenType1 : GenericType<"SGenType1", TLSignedInts, Vec1>;
 def SGenTypeN              : GenericType<"SGenTypeN", TLSignedInts, VecAndScalar>;
 // Unsigned integer
+def UGenType1 : GenericType<"UGenType1", TLUnsignedInts, Vec1>;
 def UGenTypeN              : GenericType<"UGenTypeN", TLUnsignedInts, VecAndScalar>;
 // Float
+def FGenType1 : GenericType<"FGenType1", TLFloat, Vec1>;
 def FGenTypeN              : GenericType<"FGenTypeN", TLFloat, VecAndScalar>;
 // (u)int, (u)long, and all floats
 def IntLongFloatGenType1   : GenericType<"IntLongFloatGenType1", TLIntLongFloats, Vec1>;
@@ -960,3 +963,67 @@ foreach name = ["GroupSMin", "GroupSMax"] in {
 foreach name = ["GroupLogicalAndKHR", "GroupLogicalOrKHR"] in {
   def : SPVBuiltin<name, [Bool, UInt, UInt, Bool], Attr.Convergent>;
 }
+
+// 3.56.18. Atomic Instructions
+
+foreach AS = [GlobalAS, LocalAS, PrivateAS, GenericAS] in {
+  def : SPVBuiltin<
+            "AtomicLoad", [AGenType1, PointerType<AGenType1, AS>, Int, Int],
+            Attr.Convergent>;
+
+  def : SPVBuiltin<"AtomicStore",
+                   [Void, PointerType<AGenType1, AS>, Int, Int, AGenType1],
+                   Attr.Convergent>;
+
+  def : SPVBuiltin<"AtomicExchange",
+                   [AGenType1, PointerType<AGenType1, AS>, Int, Int, AGenType1],
+                   Attr.Convergent>;
+
+  foreach name = ["AtomicCompareExchange", "AtomicCompareExchangeWeak"] in {
+    def : SPVBuiltin<name,
+                     [AIGenType1, PointerType<AIGenType1, AS>, Int, Int, Int,
+                      AIGenType1, AIGenType1],
+                     Attr.Convergent>;
+  }
+
+  foreach name = ["AtomicIIncrement", "AtomicIDecrement"] in {
+    def : SPVBuiltin<name, [AIGenType1, PointerType<AIGenType1, AS>, Int, Int],
+                     Attr.Convergent>;
+  }
+
+  foreach name = ["AtomicSMin", "AtomicSMax"] in {
+    def : SPVBuiltin<name,
+                     [SGenType1, PointerType<SGenType1, AS>, Int, Int,
+                      SGenType1],
+                     Attr.Convergent>;
+  }
+
+  foreach name = ["AtomicUMin", "AtomicUMax"] in {
+    def : SPVBuiltin<name,
+                     [UGenType1, PointerType<UGenType1, AS>, Int, Int,
+                      UGenType1],
+                     Attr.Convergent>;
+  }
+
+  foreach name = ["AtomicIAdd", "AtomicISub", "AtomicAnd", "AtomicOr",
+                  "AtomicXor"] in {
+    def : SPVBuiltin<name,
+                     [AIGenType1, PointerType<AIGenType1, AS>, Int, Int,
+                      AIGenType1],
+                     Attr.Convergent>;
+  }
+
+  def : SPVBuiltin<
+            "AtomicFlagTestAndSet", [Bool, PointerType<Int, AS>, Int, Int],
+            Attr.Convergent>;
+
+  def : SPVBuiltin<"AtomicFlagClear", [Void, PointerType<Int, AS>, Int, Int],
+                   Attr.Convergent>;
+
+  foreach name = ["AtomicFMaxEXT", "AtomicFMinEXT", "AtomicFAddEXT"] in {
+    def : SPVBuiltin<name,
+                     [FGenType1, PointerType<FGenType1, AS>, Int, Int,
+                      FGenType1],
+                     Attr.Convergent>;
+  }
+}

libclc/generic/lib/atomic/atomic_add.cl

@@ -1,16 +1,13 @@
 #include <clc/clc.h>
 #include <libspirv/spirv.h>
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED)                                                                                  \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_add(volatile AS TYPE *p, TYPE val) {                                                         \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                                     \
-     * exact mangling. */                                                                                                         \
-    return _Z18__spirv_AtomicIAddPU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagE##TYPE_MANGLED( \
-        p, Device, SequentiallyConsistent, val);                                                                                  \
+#define IMPL(TYPE, AS)                                                            \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_add(volatile AS TYPE *p, TYPE val) {         \
+    return __spirv_AtomicIAdd((AS TYPE *)p, Device, SequentiallyConsistent, val); \
   }
 
-IMPL(int, i, global, AS1)
-IMPL(unsigned int, j, global, AS1)
-IMPL(int, i, local, AS3)
-IMPL(unsigned int, j, local, AS3)
+IMPL(int, global)
+IMPL(unsigned int, global)
+IMPL(int, local)
+IMPL(unsigned int, local)
 #undef IMPL

libclc/generic/lib/atomic/atomic_and.cl

@@ -1,16 +1,13 @@
 #include <clc/clc.h>
 #include <libspirv/spirv.h>
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED)                                                                                 \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_and(volatile AS TYPE *p, TYPE val) {                                                        \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                                    \
-     * exact mangling. */                                                                                                        \
-    return _Z17__spirv_AtomicAndPU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagE##TYPE_MANGLED( \
-        p, Device, SequentiallyConsistent, val);                                                                                 \
+#define IMPL(TYPE, AS)                                                           \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_and(volatile AS TYPE *p, TYPE val) {        \
+    return __spirv_AtomicAnd((AS TYPE *)p, Device, SequentiallyConsistent, val); \
   }
 
-IMPL(int, i, global, AS1)
-IMPL(unsigned int, j, global, AS1)
-IMPL(int, i, local, AS3)
-IMPL(unsigned int, j, local, AS3)
+IMPL(int, global)
+IMPL(unsigned int, global)
+IMPL(int, local)
+IMPL(unsigned int, local)
 #undef IMPL

libclc/generic/lib/atomic/atomic_cmpxchg.cl

@@ -1,17 +1,15 @@
 #include <clc/clc.h>
 #include <libspirv/spirv.h>
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED)                                                                                                              \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_cmpxchg(volatile AS TYPE *p, TYPE cmp,                                                                                   \
-                                             TYPE val) {                                                                                                      \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                                                                 \
-     * exact mangling. */                                                                                                                                     \
-    return _Z29__spirv_AtomicCompareExchangePU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagES5_##TYPE_MANGLED##TYPE_MANGLED( \
-        p, Device, SequentiallyConsistent, SequentiallyConsistent, val, cmp);                                                                                 \
+#define IMPL(TYPE, AS)                                                      \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_cmpxchg(volatile AS TYPE *p, TYPE cmp, \
+                                             TYPE val) {                    \
+    return __spirv_AtomicCompareExchange((AS TYPE *)p, Device,              \
+        SequentiallyConsistent, SequentiallyConsistent, val, cmp);          \
   }
 
-IMPL(int, i, global, AS1)
-IMPL(unsigned int, j, global, AS1)
-IMPL(int, i, local, AS3)
-IMPL(unsigned int, j, local, AS3)
+IMPL(int, global)
+IMPL(unsigned int, global)
+IMPL(int, local)
+IMPL(unsigned int, local)
 #undef IMPL

libclc/generic/lib/atomic/atomic_dec.cl

@@ -1,16 +1,14 @@
 #include <clc/clc.h>
 #include <libspirv/spirv.h>
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED)                                                                          \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_dec(volatile AS TYPE *p) {                                                           \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                             \
-     * exact mangling. */                                                                                                 \
-    return _Z24__spirv_AtomicIDecrementPU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagE( \
-        p, Device, SequentiallyConsistent);                                                                               \
+#define IMPL(TYPE, AS)                                          \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_dec(volatile AS TYPE *p) { \
+    return __spirv_AtomicIDecrement(                            \
+        (AS TYPE *)p, Device, SequentiallyConsistent);          \
   }
 
-IMPL(int, i, global, AS1)
-IMPL(unsigned int, j, global, AS1)
-IMPL(int, i, local, AS3)
-IMPL(unsigned int, j, local, AS3)
+IMPL(int, global)
+IMPL(unsigned int, global)
+IMPL(int, local)
+IMPL(unsigned int, local)
 #undef IMPL

libclc/generic/lib/atomic/atomic_inc.cl

@@ -1,16 +1,14 @@
 #include <clc/clc.h>
 #include <libspirv/spirv.h>
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED)                                                                          \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_inc(volatile AS TYPE *p) {                                                           \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                             \
-     * exact mangling. */                                                                                                 \
-    return _Z24__spirv_AtomicIIncrementPU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagE( \
-        p, Device, SequentiallyConsistent);                                                                               \
+#define IMPL(TYPE, AS)                                          \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_inc(volatile AS TYPE *p) { \
+    return __spirv_AtomicIIncrement(                            \
+        (AS TYPE *)p, Device, SequentiallyConsistent);          \
   }
 
-IMPL(int, i, global, AS1)
-IMPL(unsigned int, j, global, AS1)
-IMPL(int, i, local, AS3)
-IMPL(unsigned int, j, local, AS3)
+IMPL(int, global)
+IMPL(unsigned int, global)
+IMPL(int, local)
+IMPL(unsigned int, local)
 #undef IMPL

libclc/generic/lib/atomic/atomic_max.cl

@@ -1,16 +1,13 @@
 #include <clc/clc.h>
 #include <libspirv/spirv.h>
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED, OP)                                                                  \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_max(volatile AS TYPE *p, TYPE val) {                                             \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                         \
-     * exact mangling. */                                                                                             \
-    return _Z18##OP##PU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagE##TYPE_MANGLED( \
-        p, Device, SequentiallyConsistent, val);                                                                      \
+#define IMPL(TYPE, AS, OP)                                                \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_max(volatile AS TYPE *p, TYPE val) { \
+    return OP((AS TYPE *)p, Device, SequentiallyConsistent, val);         \
   }
 
-IMPL(int, i, global, AS1, __spirv_AtomicSMax)
-IMPL(unsigned int, j, global, AS1, __spirv_AtomicUMax)
-IMPL(int, i, local, AS3, __spirv_AtomicSMax)
-IMPL(unsigned int, j, local, AS3, __spirv_AtomicUMax)
+IMPL(int, global, __spirv_AtomicSMax)
+IMPL(unsigned int, global, __spirv_AtomicUMax)
+IMPL(int, local, __spirv_AtomicSMax)
+IMPL(unsigned int, local, __spirv_AtomicUMax)
 #undef IMPL

libclc/generic/lib/atomic/atomic_min.cl

@@ -1,16 +1,13 @@
 #include <clc/clc.h>
 #include <libspirv/spirv.h>
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED, OP)                                                                  \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_min(volatile AS TYPE *p, TYPE val) {                                             \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                         \
-     * exact mangling. */                                                                                             \
-    return _Z18##OP##PU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagE##TYPE_MANGLED( \
-        p, Device, SequentiallyConsistent, val);                                                                      \
+#define IMPL(TYPE, AS, OP)                                                \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_min(volatile AS TYPE *p, TYPE val) { \
+    return OP((AS TYPE *)p, Device, SequentiallyConsistent, val);         \
   }
 
-IMPL(int, i, global, AS1, __spirv_AtomicSMin)
-IMPL(unsigned int, j, global, AS1, __spirv_AtomicUMin)
-IMPL(int, i, local, AS3, __spirv_AtomicSMin)
-IMPL(unsigned int, j, local, AS3, __spirv_AtomicUMin)
+IMPL(int, global, __spirv_AtomicSMin)
+IMPL(unsigned int, global, __spirv_AtomicUMin)
+IMPL(int, local, __spirv_AtomicSMin)
+IMPL(unsigned int, local, __spirv_AtomicUMin)
 #undef IMPL

libclc/generic/lib/atomic/atomic_or.cl

@@ -1,16 +1,13 @@
 #include <clc/clc.h>
 #include <libspirv/spirv.h>
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED)                                                                                \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_or(volatile AS TYPE *p, TYPE val) {                                                        \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                                   \
-     * exact mangling. */                                                                                                       \
-    return _Z16__spirv_AtomicOrPU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagE##TYPE_MANGLED( \
-        p, Device, SequentiallyConsistent, val);                                                                                \
+#define IMPL(TYPE, AS)                                                          \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_or(volatile AS TYPE *p, TYPE val) {        \
+    return __spirv_AtomicOr((AS TYPE *)p, Device, SequentiallyConsistent, val); \
   }
 
-IMPL(int, i, global, AS1)
-IMPL(unsigned int, j, global, AS1)
-IMPL(int, i, local, AS3)
-IMPL(unsigned int, j, local, AS3)
+IMPL(int, global)
+IMPL(unsigned int, global)
+IMPL(int, local)
+IMPL(unsigned int, local)
 #undef IMPL

libclc/generic/lib/atomic/atomic_sub.cl

@@ -1,16 +1,13 @@
 #include <clc/clc.h>
 #include <libspirv/spirv.h>
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED)                                                                                  \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_sub(volatile AS TYPE *p, TYPE val) {                                                         \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                                     \
-     * exact mangling. */                                                                                                         \
-    return _Z18__spirv_AtomicISubPU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagE##TYPE_MANGLED( \
-        p, Device, SequentiallyConsistent, val);                                                                                  \
+#define IMPL(TYPE, AS)                                                            \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_sub(volatile AS TYPE *p, TYPE val) {         \
+    return __spirv_AtomicISub((AS TYPE *)p, Device, SequentiallyConsistent, val); \
   }
 
-IMPL(int, i, global, AS1)
-IMPL(unsigned int, j, global, AS1)
-IMPL(int, i, local, AS3)
-IMPL(unsigned int, j, local, AS3)
+IMPL(int, global)
+IMPL(unsigned int, global)
+IMPL(int, local)
+IMPL(unsigned int, local)
 #undef IMPL

libclc/generic/lib/atomic/atomic_xchg.cl

@@ -2,27 +2,20 @@
 #include <libspirv/spirv.h>
 
 _CLC_OVERLOAD _CLC_DEF float atomic_xchg(volatile global float *p, float val) {
-  /* TODO: Stop manually mangling this name. Need C++ namespaces to get the exact mangling. */
-  return _Z22__spirv_AtomicExchangePU3AS1fN5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagEf(
-      p, Device, SequentiallyConsistent, val);
+  return __spirv_AtomicExchange((global float *)p, Device, SequentiallyConsistent, val);
 }
 
 _CLC_OVERLOAD _CLC_DEF float atomic_xchg(volatile local float *p, float val) {
-  /* TODO: Stop manually mangling this name. Need C++ namespaces to get the exact mangling. */
-  return _Z22__spirv_AtomicExchangePU3AS3fN5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagEf(
-      p, Device, SequentiallyConsistent, val);
+  return __spirv_AtomicExchange((local float *)p, Device, SequentiallyConsistent, val);
 }
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED)                                                                                      \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_xchg(volatile AS TYPE *p, TYPE val) {                                                            \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                                         \
-     * exact mangling. */                                                                                                             \
-    return _Z22__spirv_AtomicExchangePU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagE##TYPE_MANGLED( \
-        p, Device, SequentiallyConsistent, val);                                                                                      \
+#define IMPL(TYPE, AS)                                                                \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_xchg(volatile AS TYPE *p, TYPE val) {            \
+    return __spirv_AtomicExchange((AS TYPE *)p, Device, SequentiallyConsistent, val); \
   }
 
-IMPL(int, i, global, AS1)
-IMPL(unsigned int, j, global, AS1)
-IMPL(int, i, local, AS3)
-IMPL(unsigned int, j, local, AS3)
+IMPL(int, global)
+IMPL(unsigned int, global)
+IMPL(int, local)
+IMPL(unsigned int, local)
 #undef IMPL

libclc/generic/lib/atomic/atomic_xor.cl

@@ -1,16 +1,13 @@
 #include <clc/clc.h>
 #include <libspirv/spirv.h>
 
-#define IMPL(TYPE, TYPE_MANGLED, AS, AS_MANGLED)                                                                                 \
-  _CLC_OVERLOAD _CLC_DEF TYPE atomic_xor(volatile AS TYPE *p, TYPE val) {                                                        \
-    /* TODO: Stop manually mangling this name. Need C++ namespaces to get the                                                    \
-     * exact mangling. */                                                                                                        \
-    return _Z17__spirv_AtomicXorPU3##AS_MANGLED##TYPE_MANGLED##N5__spv5Scope4FlagENS1_19MemorySemanticsMask4FlagE##TYPE_MANGLED( \
-        p, Device, SequentiallyConsistent, val);                                                                                 \
+#define IMPL(TYPE, AS)                                                           \
+  _CLC_OVERLOAD _CLC_DEF TYPE atomic_xor(volatile AS TYPE *p, TYPE val) {        \
+    return __spirv_AtomicXor((AS TYPE *)p, Device, SequentiallyConsistent, val); \
   }
 
-IMPL(int, i, global, AS1)
-IMPL(unsigned int, j, global, AS1)
-IMPL(int, i, local, AS3)
-IMPL(unsigned int, j, local, AS3)
+IMPL(int, global)
+IMPL(unsigned int, global)
+IMPL(int, local)
+IMPL(unsigned int, local)
 #undef IMPL