partway through porting, implicit address space conversion is used all over devicertl

JonChesterfield · JonChesterfield · commit a8970f60a980 · 2025-02-24T19:35:23.000Z
diff --git a/offload/DeviceRTL/CMakeLists.txt b/offload/DeviceRTL/CMakeLists.txt
@@ -98,6 +98,7 @@ list(TRANSFORM LIBOMPTARGET_LLVM_INCLUDE_DIRS_DEVICERTL PREPEND "-I")
 set(bc_flags -c -flto -std=c++17 -fvisibility=hidden
              ${clang_opt_flags} -nogpulib -nostdlibinc
              -fno-rtti -fno-exceptions -fconvergent-functions
+             -Wno-atomic-alignment # spir-v complains about 4 byte atomics then Werror :(
              -Wno-unknown-cuda-version
              -DOMPTARGET_DEVICE_RUNTIME
              -I${include_directory}
@@ -257,6 +258,10 @@ endfunction()
 add_custom_target(omptarget.devicertl.amdgpu)
 compileDeviceRTLLibrary(amdgpu amdgcn-amd-amdhsa -Xclang -mcode-object-version=none)
 
+add_custom_target(omptarget.devicertl.amdgpu-spirv)
+compileDeviceRTLLibrary(amdgpu-spirv spirv64-amd-amdhsa -Xclang -mcode-object-version=none)
+
+
 add_custom_target(omptarget.devicertl.nvptx)
 compileDeviceRTLLibrary(nvptx nvptx64-nvidia-cuda --cuda-feature=+ptx63)
 
diff --git a/offload/DeviceRTL/include/State.h b/offload/DeviceRTL/include/State.h
@@ -102,12 +102,21 @@ struct ThreadStateTy {
   ThreadStateTy *PreviousThreadState;
 
   void init() {
-    ICVState = TeamState.ICVState;
+    // assignment relies on implicit conversion between address spaces
+    // ICVState = TeamState.ICVState;
+    __builtin_memcpy(&ICVState,
+                     &TeamState.ICVState,
+                     sizeof(ICVState));
     PreviousThreadState = nullptr;
   }
 
   void init(ThreadStateTy *PreviousTS) {
-    ICVState = PreviousTS ? PreviousTS->ICVState : TeamState.ICVState;
+    __builtin_memcpy(&ICVState,
+                     PreviousTS ?
+                     (state::ICVStateTy*) & PreviousTS->ICVState
+                     : (state::ICVStateTy*) &TeamState.ICVState,
+                     sizeof(ICVState));
+    
     PreviousThreadState = PreviousTS;
   }
 };
@@ -159,7 +168,7 @@ void resetStateForThread(uint32_t TId);
   {                                                                            \
     if (OMP_LIKELY(ForceTeamState || !config::mayUseThreadStates() ||          \
                    !TeamState.HasThreadState))                                 \
-      return TeamState.ICVState.Member;                                        \
+      return (uint32_t &)TeamState.ICVState.Member;                            \
     uint32_t TId = mapping::getThreadIdInBlock();                              \
     if (OMP_UNLIKELY(!ThreadStates[TId])) {                                    \
       ThreadStates[TId] = reinterpret_cast<ThreadStateTy *>(                   \
@@ -169,7 +178,7 @@ void resetStateForThread(uint32_t TId);
       TeamState.HasThreadState = true;                                         \
       ThreadStates[TId]->init();                                               \
     }                                                                          \
-    return ThreadStates[TId]->ICVState.Member;                                 \
+    return (uint32_t &)ThreadStates[TId]->ICVState.Member;              \
   }
 
 // FIXME: https://github.com/llvm/llvm-project/issues/123241.
@@ -178,8 +187,8 @@ void resetStateForThread(uint32_t TId);
     auto TId = mapping::getThreadIdInBlock();                                  \
     if (OMP_UNLIKELY(!ForceTeamState && config::mayUseThreadStates() &&        \
                      TeamState.HasThreadState && ThreadStates[TId]))           \
-      return ThreadStates[TId]->ICVState.Member;                               \
-    return TeamState.ICVState.Member;                                          \
+      return (uint32_t &)ThreadStates[TId]->ICVState.Member;            \
+    return (uint32_t &)TeamState.ICVState.Member;                       \
   }
 
 [[gnu::always_inline, gnu::flatten]] inline uint32_t &
@@ -210,9 +219,9 @@ lookup32(ValueKind Kind, bool IsReadonly, IdentTy *Ident, bool ForceTeamState) {
       lookupImpl(RunSchedChunkVar, ForceTeamState);
     lookupForModify32Impl(RunSchedChunkVar, Ident, ForceTeamState);
   case state::VK_ParallelTeamSize:
-    return TeamState.ParallelTeamSize;
+    return (uint32_t &)TeamState.ParallelTeamSize;
   case state::VK_HasThreadState:
-    return TeamState.HasThreadState;
+    return (uint32_t &)TeamState.HasThreadState;
   default:
     break;
   }
@@ -223,7 +232,7 @@ lookup32(ValueKind Kind, bool IsReadonly, IdentTy *Ident, bool ForceTeamState) {
 lookupPtr(ValueKind Kind, bool IsReadonly, bool ForceTeamState) {
   switch (Kind) {
   case state::VK_ParallelRegionFn:
-    return TeamState.ParallelRegionFnVar;
+    return (void *&)TeamState.ParallelRegionFnVar;
   default:
     break;
   }
diff --git a/offload/DeviceRTL/src/State.cpp b/offload/DeviceRTL/src/State.cpp
@@ -160,7 +160,7 @@ void SharedMemorySmartStackTy::pop(void *Ptr, uint64_t Bytes) {
 
 } // namespace
 
-void *memory::getDynamicBuffer() { return DynamicSharedBuffer; }
+void *memory::getDynamicBuffer() { return (void *)DynamicSharedBuffer; }
 
 void *memory::allocShared(uint64_t Bytes, const char *Reason) {
   return SharedMemorySmartStack.push(Bytes);
@@ -219,6 +219,7 @@ bool state::TeamStateTy::operator==(const TeamStateTy &Other) const {
 
 void state::TeamStateTy::assertEqual(TeamStateTy &Other) const {
   ICVState.assertEqual(Other.ICVState);
+  // Other.ICVState.assertEqual(ICVState);
   ASSERT(ParallelTeamSize == Other.ParallelTeamSize, nullptr);
   ASSERT(HasThreadState == Other.HasThreadState, nullptr);
 }
@@ -273,7 +274,7 @@ void state::enterDataEnvironment(IdentTy *Ident) {
   unsigned TId = mapping::getThreadIdInBlock();
   ThreadStateTy *NewThreadState = static_cast<ThreadStateTy *>(
       memory::allocGlobal(sizeof(ThreadStateTy), "ThreadStates alloc"));
-  uintptr_t *ThreadStatesBitsPtr = reinterpret_cast<uintptr_t *>(&ThreadStates);
+  uintptr_t *ThreadStatesBitsPtr = (uintptr_t *)(&ThreadStates);
   if (!atomic::load(ThreadStatesBitsPtr, atomic::seq_cst)) {
     uint32_t Bytes =
         sizeof(ThreadStates[0]) * mapping::getNumberOfThreadsInBlock();
@@ -313,18 +314,22 @@ void state::resetStateForThread(uint32_t TId) {
 }
 
 void state::runAndCheckState(void(Func(void))) {
-  TeamStateTy OldTeamState = TeamState;
-  OldTeamState.assertEqual(TeamState);
+  // TeamStateTy OldTeamState = TeamState;
+  TeamStateTy OldTeamState;
+  __builtin_memcpy(&OldTeamState,
+                   &TeamState,
+                   sizeof(TeamStateTy));
+  OldTeamState.assertEqual((TeamStateTy&)TeamState);
 
   Func();
 
-  OldTeamState.assertEqual(TeamState);
+  OldTeamState.assertEqual((TeamStateTy&)TeamState);
 }
 
 void state::assumeInitialState(bool IsSPMD) {
   TeamStateTy InitialTeamState;
   InitialTeamState.init(IsSPMD);
-  InitialTeamState.assertEqual(TeamState);
+  InitialTeamState.assertEqual((TeamStateTy&)TeamState);
   ASSERT(mapping::isSPMDMode() == IsSPMD, nullptr);
 }
 
@@ -461,7 +466,7 @@ constexpr uint64_t NUM_SHARED_VARIABLES_IN_SHARED_MEM = 64;
 
 void __kmpc_begin_sharing_variables(void ***GlobalArgs, uint64_t nArgs) {
   if (nArgs <= NUM_SHARED_VARIABLES_IN_SHARED_MEM) {
-    SharedMemVariableSharingSpacePtr = &SharedMemVariableSharingSpace[0];
+    SharedMemVariableSharingSpacePtr = (void**)&SharedMemVariableSharingSpace[0];
   } else {
     SharedMemVariableSharingSpacePtr = (void **)memory::allocGlobal(
         nArgs * sizeof(void *), "new extended args");
@@ -472,7 +477,7 @@ void __kmpc_begin_sharing_variables(void ***GlobalArgs, uint64_t nArgs) {
 }
 
 void __kmpc_end_sharing_variables() {
-  if (SharedMemVariableSharingSpacePtr != &SharedMemVariableSharingSpace[0])
+  if ((void*)SharedMemVariableSharingSpacePtr != (void*)&SharedMemVariableSharingSpace[0])
     memory::freeGlobal(SharedMemVariableSharingSpacePtr, "new extended args");
 }
 
diff --git a/offload/cmake/caches/Offload.cmake b/offload/cmake/caches/Offload.cmake
@@ -1,9 +1,9 @@
 set(LLVM_ENABLE_PROJECTS "clang;clang-tools-extra;lld" CACHE STRING "")
-set(LLVM_ENABLE_RUNTIMES "compiler-rt;libunwind;libcxx;libcxxabi;openmp;offload" CACHE STRING "")
+set(LLVM_ENABLE_RUNTIMES "compiler-rt;openmp;offload" CACHE STRING "")
 set(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR ON CACHE BOOL "")
 
 set(LLVM_RUNTIME_TARGETS default;amdgcn-amd-amdhsa;nvptx64-nvidia-cuda CACHE STRING "") 
-set(RUNTIMES_nvptx64-nvidia-cuda_CACHE_FILES "${CMAKE_SOURCE_DIR}/../libcxx/cmake/caches/NVPTX.cmake" CACHE STRING "")
-set(RUNTIMES_amdgcn-amd-amdhsa_CACHE_FILES "${CMAKE_SOURCE_DIR}/../libcxx/cmake/caches/AMDGPU.cmake" CACHE STRING "")
-set(RUNTIMES_nvptx64-nvidia-cuda_LLVM_ENABLE_RUNTIMES "compiler-rt;libc;libcxx;libcxxabi" CACHE STRING "")
-set(RUNTIMES_amdgcn-amd-amdhsa_LLVM_ENABLE_RUNTIMES "compiler-rt;libc;libcxx;libcxxabi" CACHE STRING "")
+# set(RUNTIMES_nvptx64-nvidia-cuda_CACHE_FILES "${CMAKE_SOURCE_DIR}/../libcxx/cmake/caches/NVPTX.cmake" CACHE STRING "")
+# set(RUNTIMES_amdgcn-amd-amdhsa_CACHE_FILES "${CMAKE_SOURCE_DIR}/../libcxx/cmake/caches/AMDGPU.cmake" CACHE STRING "")
+set(RUNTIMES_nvptx64-nvidia-cuda_LLVM_ENABLE_RUNTIMES "compiler-rt;libc" CACHE STRING "")
+set(RUNTIMES_amdgcn-amd-amdhsa_LLVM_ENABLE_RUNTIMES "compiler-rt;libc" CACHE STRING "")
diff --git a/offload/test/offloading/bug64959.c b/offload/test/offloading/bug64959.c
@@ -55,6 +55,6 @@ int main(void) {
     return 1;
   }
   // CHECK: Success
-  printf("Success\n");
+  printf("Suc disabled cess\n");
   return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,6 @@ int main(void) {`
`55`	`55`	`return 1;`
`56`	`56`	`}`
`57`	`57`	`// CHECK: Success`
`58`		`- printf("Success\n");`
	`58`	`+ printf("Suc disabled cess\n");`
`59`	`59`	`return 0;`
`60`	`60`	`}`