[SYCL] Avoid declaring unscoped enums in global namespace

According to C++ spec:

Each enumerator becomes a named constant of the enumeration's type
(that is, name), visible in the enclosing scope, and can be used
whenever constants are required.

Having unscoped enumerations defined in global namespace reserve some
names and prohibits it's using in user's applications. For example,
'Device' might be used as user's class name and it might cause
ambiguity.

This patch aligns declaration of enums in spirv_types.hpp with ones from
SPIRV-Headers project to avoid declaring identifiers in global namespace
and simplify transition in the future. There are few exceptions:
* uint32_t is used as base type for enum instead of unsigned.
* '__spv' namespace is used instead of 'spv'.

Signed-off-by: Alexey Sachkov <[email protected]>

Author: AlexeySachkov

sycl/CMakeLists.txt

@@ -82,7 +82,7 @@ else()
   add_custom_target(ocl-icd DEPENDS ${OpenCL_LIBRARIES} COMMENT "Copying OpenCL ICD Loader ...")
 endif()
 
-set(SYCL_INCLUDE "${CMAKE_CURRENT_BINARY_DIR}/include/")
+set(SYCL_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/include/")
 set(OPENCL_INCLUDE "${OpenCL_INCLUDE_DIRS}")
 
 # Configure SYCL version macro

sycl/include/CL/__spirv/spirv_ops.hpp

@@ -14,57 +14,61 @@
 
 #ifdef __SYCL_DEVICE_ONLY__
 template <typename dataT>
-extern __ocl_event_t __spirv_GroupAsyncCopy(int32_t Scope, __local dataT *Dest,
-                                            __global dataT *Src,
-                                            size_t NumElements, size_t Stride,
-                                            __ocl_event_t E) noexcept;
+extern __ocl_event_t
+__spirv_GroupAsyncCopy(__spv::Scope Execution, __local dataT *Dest,
+                       __global dataT *Src, size_t NumElements, size_t Stride,
+                       __ocl_event_t E) noexcept;
 
 template <typename dataT>
-extern __ocl_event_t __spirv_GroupAsyncCopy(int32_t Scope, __global dataT *Dest,
-                                            __local dataT *Src,
-                                            size_t NumElements, size_t Stride,
-                                            __ocl_event_t E) noexcept;
+extern __ocl_event_t
+__spirv_GroupAsyncCopy(__spv::Scope Execution, __global dataT *Dest,
+                       __local dataT *Src, size_t NumElements, size_t Stride,
+                       __ocl_event_t E) noexcept;
 
 #define OpGroupAsyncCopyGlobalToLocal __spirv_GroupAsyncCopy
 #define OpGroupAsyncCopyLocalToGlobal __spirv_GroupAsyncCopy
 
 // Atomic SPIR-V builtins
 #define __SPIRV_ATOMIC_LOAD(AS, Type)                                          \
-  extern Type __spirv_AtomicLoad(AS const Type *P, Scope S, MemorySemantics O);
+  extern Type __spirv_AtomicLoad(AS const Type *P, __spv::Scope S,             \
+                                 __spv::MemorySemanticsMask O);
 #define __SPIRV_ATOMIC_STORE(AS, Type)                                         \
-  extern void __spirv_AtomicStore(AS Type *P, Scope S, MemorySemantics O,      \
-                                  Type V);
+  extern void __spirv_AtomicStore(AS Type *P, __spv::Scope S,                  \
+                                  __spv::MemorySemanticsMask O, Type V);
 #define __SPIRV_ATOMIC_EXCHANGE(AS, Type)                                      \
-  extern Type __spirv_AtomicExchange(AS Type *P, Scope S, MemorySemantics O,   \
-                                     Type V);
+  extern Type __spirv_AtomicExchange(AS Type *P, __spv::Scope S,               \
+                                     __spv::MemorySemanticsMask O, Type V);
 #define __SPIRV_ATOMIC_CMP_EXCHANGE(AS, Type)                                  \
   extern Type __spirv_AtomicCompareExchange(                                   \
-      AS Type *P, Scope S, MemorySemantics E, MemorySemantics U, Type V,       \
-      Type C);
+      AS Type *P, __spv::Scope S, __spv::MemorySemanticsMask E,                \
+      __spv::MemorySemanticsMask U, Type V, Type C);
 #define __SPIRV_ATOMIC_IADD(AS, Type)                                          \
-  extern Type __spirv_AtomicIAdd(AS Type *P, Scope S, MemorySemantics O,       \
-                                 Type V);
+  extern Type __spirv_AtomicIAdd(AS Type *P, __spv::Scope S,                   \
+                                 __spv::MemorySemanticsMask O, Type V);
 #define __SPIRV_ATOMIC_ISUB(AS, Type)                                          \
-  extern Type __spirv_AtomicISub(AS Type *P, Scope S, MemorySemantics O,       \
-                                 Type V);
+  extern Type __spirv_AtomicISub(AS Type *P, __spv::Scope S,                   \
+                                 __spv::MemorySemanticsMask O, Type V);
 #define __SPIRV_ATOMIC_SMIN(AS, Type)                                          \
-  extern Type __spirv_AtomicSMin(AS Type *P, Scope S, MemorySemantics O,       \
-                                 Type V);
+  extern Type __spirv_AtomicSMin(AS Type *P, __spv::Scope S,                   \
+                                 __spv::MemorySemanticsMask O, Type V);
 #define __SPIRV_ATOMIC_UMIN(AS, Type)                                          \
-  extern Type __spirv_AtomicUMin(AS Type *P, Scope S, MemorySemantics O,       \
-                                 Type V);
+  extern Type __spirv_AtomicUMin(AS Type *P, __spv::Scope S,                   \
+                                 __spv::MemorySemanticsMask O, Type V);
 #define __SPIRV_ATOMIC_SMAX(AS, Type)                                          \
-  extern Type __spirv_AtomicSMax(AS Type *P, Scope S, MemorySemantics O,       \
-                                 Type V);
+  extern Type __spirv_AtomicSMax(AS Type *P, __spv::Scope S,                   \
+                                 __spv::MemorySemanticsMask O, Type V);
 #define __SPIRV_ATOMIC_UMAX(AS, Type)                                          \
-  extern Type __spirv_AtomicUMax(AS Type *P, Scope S, MemorySemantics O,       \
-                                 Type V);
+  extern Type __spirv_AtomicUMax(AS Type *P, __spv::Scope S,                   \
+                                 __spv::MemorySemanticsMask O, Type V);
 #define __SPIRV_ATOMIC_AND(AS, Type)                                           \
-  extern Type __spirv_AtomicAnd(AS Type *P, Scope S, MemorySemantics O, Type V);
+  extern Type __spirv_AtomicAnd(AS Type *P, __spv::Scope S,                    \
+                                __spv::MemorySemanticsMask O, Type V);
 #define __SPIRV_ATOMIC_OR(AS, Type)                                            \
-  extern Type __spirv_AtomicOr(AS Type *P, Scope S, MemorySemantics O, Type V);
+  extern Type __spirv_AtomicOr(AS Type *P, __spv::Scope S,                     \
+                               __spv::MemorySemanticsMask O, Type V);
 #define __SPIRV_ATOMIC_XOR(AS, Type)                                           \
-  extern Type __spirv_AtomicXor(AS Type *P, Scope S, MemorySemantics O, Type V);
+  extern Type __spirv_AtomicXor(AS Type *P, __spv::Scope S,                    \
+                                __spv::MemorySemanticsMask O, Type V);
 
 #define __SPIRV_ATOMIC_FLOAT(AS, Type)                                         \
   __SPIRV_ATOMIC_LOAD(AS, Type)                                                \
@@ -95,15 +99,15 @@ extern __ocl_event_t __spirv_GroupAsyncCopy(int32_t Scope, __global dataT *Dest,
 #define __SPIRV_ATOMIC_MINMAX(AS, Op)                                          \
   template <typename T>                                                        \
   typename std::enable_if<std::is_signed<T>::value, T>::type                   \
-      __spirv_Atomic##Op(AS T *Ptr, Scope Scope, MemorySemantics Semantics,    \
-                         T Value) {                                            \
-    return __spirv_AtomicS##Op(Ptr, Scope, Semantics, Value);                  \
+      __spirv_Atomic##Op(AS T *Ptr, __spv::Scope Memory,                       \
+                         __spv::MemorySemanticsMask Semantics, T Value) {      \
+    return __spirv_AtomicS##Op(Ptr, Memory, Semantics, Value);                 \
   }                                                                            \
   template <typename T>                                                        \
   typename std::enable_if<!std::is_signed<T>::value, T>::type                  \
-      __spirv_Atomic##Op(AS T *Ptr, Scope Scope, MemorySemantics Semantics,    \
-                         T Value) {                                            \
-    return __spirv_AtomicU##Op(Ptr, Scope, Semantics, Value);                  \
+      __spirv_Atomic##Op(AS T *Ptr, __spv::Scope Memory,                       \
+                         __spv::MemorySemanticsMask Semantics, T Value) {      \
+    return __spirv_AtomicU##Op(Ptr, Memory, Semantics, Value);                 \
   }
 
 #define __SPIRV_ATOMICS(macro, Arg) macro(__global, Arg) macro(__local, Arg)
@@ -118,30 +122,38 @@ __SPIRV_ATOMICS(__SPIRV_ATOMIC_UNSIGNED, unsigned long long)
 __SPIRV_ATOMICS(__SPIRV_ATOMIC_MINMAX, Min)
 __SPIRV_ATOMICS(__SPIRV_ATOMIC_MINMAX, Max)
 
-extern bool __spirv_GroupAll(int32_t Scope, bool Predicate) noexcept;
+extern bool __spirv_GroupAll(__spv::Scope Execution, bool Predicate) noexcept;
 
-extern bool __spirv_GroupAny(int32_t Scope, bool Predicate) noexcept;
+extern bool __spirv_GroupAny(__spv::Scope Execution, bool Predicate) noexcept;
 
 template <typename dataT>
-extern dataT __spirv_GroupBroadcast(int32_t Scope, dataT Value,
+extern dataT __spirv_GroupBroadcast(__spv::Scope Execution, dataT Value,
                                     uint32_t LocalId) noexcept;
 
 template <typename dataT>
-extern dataT __spirv_GroupIAdd(int32_t Scope, int32_t Op, dataT Value) noexcept;
+extern dataT __spirv_GroupIAdd(__spv::Scope Execution, __spv::GroupOperation Op,
+                               dataT Value) noexcept;
 template <typename dataT>
-extern dataT __spirv_GroupFAdd(int32_t Scope, int32_t Op, dataT Value) noexcept;
+extern dataT __spirv_GroupFAdd(__spv::Scope Execution, __spv::GroupOperation Op,
+                               dataT Value) noexcept;
 template <typename dataT>
-extern dataT __spirv_GroupUMin(int32_t Scope, int32_t Op, dataT Value) noexcept;
+extern dataT __spirv_GroupUMin(__spv::Scope Execution, __spv::GroupOperation Op,
+                               dataT Value) noexcept;
 template <typename dataT>
-extern dataT __spirv_GroupSMin(int32_t Scope, int32_t Op, dataT Value) noexcept;
+extern dataT __spirv_GroupSMin(__spv::Scope Execution, __spv::GroupOperation Op,
+                               dataT Value) noexcept;
 template <typename dataT>
-extern dataT __spirv_GroupFMin(int32_t Scope, int32_t Op, dataT Value) noexcept;
+extern dataT __spirv_GroupFMin(__spv::Scope Execution, __spv::GroupOperation Op,
+                               dataT Value) noexcept;
 template <typename dataT>
-extern dataT __spirv_GroupUMax(int32_t Scope, int32_t Op, dataT Value) noexcept;
+extern dataT __spirv_GroupUMax(__spv::Scope Execution, __spv::GroupOperation Op,
+                               dataT Value) noexcept;
 template <typename dataT>
-extern dataT __spirv_GroupSMax(int32_t Scope, int32_t Op, dataT Value) noexcept;
+extern dataT __spirv_GroupSMax(__spv::Scope Execution, __spv::GroupOperation Op,
+                               dataT Value) noexcept;
 template <typename dataT>
-extern dataT __spirv_GroupFMax(int32_t Scope, int32_t Op, dataT Value) noexcept;
+extern dataT __spirv_GroupFMax(__spv::Scope Execution, __spv::GroupOperation Op,
+                               dataT Value) noexcept;
 template <typename dataT>
 extern dataT __spirv_SubgroupShuffleINTEL(dataT Data,
                                           uint32_t InvocationId) noexcept;
@@ -178,7 +190,7 @@ extern void __spirv_ocl_prefetch(const __global char *Ptr,
 
 template <typename dataT>
 extern __ocl_event_t
-OpGroupAsyncCopyGlobalToLocal(int32_t Scope, dataT *Dest, dataT *Src,
+OpGroupAsyncCopyGlobalToLocal(__spv::Scope Execution, dataT *Dest, dataT *Src,
                               size_t NumElements, size_t Stride,
                               __ocl_event_t E) noexcept {
   for (int i = 0; i < NumElements; i++) {
@@ -190,7 +202,7 @@ OpGroupAsyncCopyGlobalToLocal(int32_t Scope, dataT *Dest, dataT *Src,
 
 template <typename dataT>
 extern __ocl_event_t
-OpGroupAsyncCopyLocalToGlobal(int32_t Scope, dataT *Dest, dataT *Src,
+OpGroupAsyncCopyLocalToGlobal(__spv::Scope Execution, dataT *Dest, dataT *Src,
                               size_t NumElements, size_t Stride,
                               __ocl_event_t E) noexcept {
   for (int i = 0; i < NumElements; i++) {
@@ -204,11 +216,12 @@ extern void __spirv_ocl_prefetch(const char *Ptr, size_t NumBytes) noexcept;
 
 #endif // !__SYCL_DEVICE_ONLY__
 
-extern void __spirv_ControlBarrier(Scope Execution, Scope Memory,
+extern void __spirv_ControlBarrier(__spv::Scope Execution, __spv::Scope Memory,
                                    uint32_t Semantics) noexcept;
 
-extern void __spirv_MemoryBarrier(Scope Memory, uint32_t Semantics) noexcept;
+extern void __spirv_MemoryBarrier(__spv::Scope Memory,
+                                  uint32_t Semantics) noexcept;
 
-extern void __spirv_GroupWaitEvents(int32_t Scope, uint32_t NumEvents,
+extern void __spirv_GroupWaitEvents(__spv::Scope Execution, uint32_t NumEvents,
                                     __ocl_event_t *WaitEvents) noexcept;
 

sycl/include/CL/__spirv/spirv_types.hpp

@@ -13,7 +13,13 @@
 // TODO: include the header file with SPIR-V declarations from SPIRV-Headers
 // project.
 
-enum Scope {
+// Declarations of enums below is aligned with corresponding declarations in
+// SPIRV-Headers repo with a few exceptions:
+// - base types changed from uint to uint32_t
+// - spv namespace renamed to __spv
+namespace __spv {
+
+enum class Scope : uint32_t {
   CrossDevice = 0,
   Device = 1,
   Workgroup = 2,
@@ -22,7 +28,7 @@ enum Scope {
 };
 
 
-enum MemorySemantics {
+enum class MemorySemanticsMask : uint32_t {
   None = 0x0,
   Acquire = 0x2,
   Release = 0x4,
@@ -36,6 +42,14 @@ enum MemorySemantics {
   ImageMemory = 0x800,
 };
 
+enum class GroupOperation : uint32_t {
+  Reduce = 0,
+  InclusiveScan = 1,
+  ExclusiveScan = 2
+};
+
+} // namespace __spv
+
 // This class does not have definition, it is only predeclared here.
 // The pointers to this class objects can be passed to or returned from
 // SPIRV built-in functions.
@@ -44,5 +58,3 @@ enum MemorySemantics {
 typedef void* __ocl_event_t;
 typedef void* __ocl_sampler_t;
 #endif
-
-enum GroupOperation { Reduce = 0, InclusiveScan = 1, ExclusiveScan = 2 };