[libomptarget][nfc] Drop __kmpc_data_sharing_slot flexible array member

[JonChesterfield]

Summary

[libomptarget][nfc] Drop __kmpc_data_sharing_slot flexible array member

The C99 flexible array member is accepted as an extension in cuda/hip. Accessing
the data[] member of a __kmpc_data_sharing_worker_slot_static through a pointer
to __kmpc_data_sharing_slot.data[] is probably an aliasing violation. Casting the
pointer to the first member is well defined for a standard layout type.

This change is non-functional in practice as the compiler does the right thing
with the aliasing violation and supports the flexible array member from C99.

[JonChesterfield]

• remove now-dead casts

[JonChesterfield]

This was written as part of debugging a port of the deviceRTL to openmp. It probably isn't necessary for that goal after all, but replacing benign UB with .b in a number of places seems worth having anyway.

openmp/libomptarget/deviceRTLs/common/omptarget.h

85

equivalent to the data[] field, slightly different syntax

[JonChesterfield]

This probably doesn't apply against trunk anymore, abandoning.

openmp/libomptarget/deviceRTLs/common/omptarget.h

 //===---- omptarget.h - OpenMP GPU initialization ---------------- CUDA -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the declarations of all library macros, types,
 // and functions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef OMPTARGET_H
 #define OMPTARGET_H
 
 #include "target_impl.h"
 #include "common/debug.h"     // debug
 #include "interface.h" // interfaces with omp, compiler, and user
 #include "common/state-queue.h"
 #include "common/support.h"
 
 #define OMPTARGET_NVPTX_VERSION 1.1
 
 // used by the library for the interface with the app
private:
   void **args;
   // starts off as MAX_SHARED_ARGS but can increase in size.
   uint32_t nArgs;
 };
 
 extern DEVICE SHARED omptarget_nvptx_SharedArgs
     omptarget_nvptx_globalArgs;
 
+// The slot used for data sharing by the master and worker threads. We use a
+// complete (default size version and an incomplete one so that we allow sizes
+// greater than the default). Is standard layout.
+struct __kmpc_data_sharing_slot {
+  __kmpc_data_sharing_slot *Next;
+  __kmpc_data_sharing_slot *Prev;
+  void *PrevSlotStackPtr;
+  void *DataEnd;
+  DEVICE char *Data() {
+    return reinterpret_cast<char *>(this) + sizeof(__kmpc_data_sharing_slot);
+  }
+};
+
 // Data structure to keep in shared memory that traces the current slot, stack,
 // and frame pointer as well as the active threads that didn't exit the current
 // environment.
 struct DataSharingStateTy {
   __kmpc_data_sharing_slot *SlotPtr[DS_Max_Warp_Number];
   void *StackPtr[DS_Max_Warp_Number];
   void * volatile FramePtr[DS_Max_Warp_Number];
   __kmpc_impl_lanemask_t ActiveThreads[DS_Max_Warp_Number];
 };
 // Additional worker slot type which is initialized with the default worker slot
 // size of 4*32 bytes.
 struct __kmpc_data_sharing_worker_slot_static {
-  __kmpc_data_sharing_slot *Next;
-  __kmpc_data_sharing_slot *Prev;
-  void *PrevSlotStackPtr;
-  void *DataEnd;
+  __kmpc_data_sharing_slot b;
   char Data[DS_Worker_Warp_Slot_Size];
 };
 // Additional master slot type which is initialized with the default master slot
 // size of 4 bytes.
 struct __kmpc_data_sharing_master_slot_static {
-  __kmpc_data_sharing_slot *Next;
-  __kmpc_data_sharing_slot *Prev;
-  void *PrevSlotStackPtr;
-  void *DataEnd;
+  __kmpc_data_sharing_slot b;
   char Data[DS_Slot_Size];
 };
 extern DEVICE SHARED DataSharingStateTy DataSharingState;
 
 ////////////////////////////////////////////////////////////////////////////////
 // task ICV and (implicit & explicit) task state
 
 class omptarget_nvptx_TaskDescr {
public:
   // init
   INLINE void InitTeamDescr();
 
   INLINE __kmpc_data_sharing_slot *RootS(int wid, bool IsMasterThread) {
     // If this is invoked by the master thread of the master warp then
     // initialize it with a smaller slot.
     if (IsMasterThread) {
       // Do not initialize this slot again if it has already been initalized.
-      if (master_rootS[0].DataEnd == &master_rootS[0].Data[0] + DS_Slot_Size)
+      if (master_rootS[0].b.DataEnd == master_rootS[0].b.Data() + DS_Slot_Size)
         return 0;
       // Initialize the pointer to the end of the slot given the size of the
       // data section. DataEnd is non-inclusive.
-      master_rootS[0].DataEnd = &master_rootS[0].Data[0] + DS_Slot_Size;
+      master_rootS[0].b.DataEnd = master_rootS[0].b.Data() + DS_Slot_Size;
       // We currently do not have a next slot.
-      master_rootS[0].Next = 0;
-      master_rootS[0].Prev = 0;
-      master_rootS[0].PrevSlotStackPtr = 0;
+      master_rootS[0].b.Next = 0;
+      master_rootS[0].b.Prev = 0;
+      master_rootS[0].b.PrevSlotStackPtr = 0;
       return (__kmpc_data_sharing_slot *)&master_rootS[0];
     }
     // Do not initialize this slot again if it has already been initalized.
-    if (worker_rootS[wid].DataEnd ==
-        &worker_rootS[wid].Data[0] + DS_Worker_Warp_Slot_Size)
+    if (worker_rootS[wid].b.DataEnd ==
+        worker_rootS[wid].b.Data() + DS_Worker_Warp_Slot_Size)
       return 0;
     // Initialize the pointer to the end of the slot given the size of the data
     // section. DataEnd is non-inclusive.
-    worker_rootS[wid].DataEnd =
-        &worker_rootS[wid].Data[0] + DS_Worker_Warp_Slot_Size;
+    worker_rootS[wid].b.DataEnd =
+        worker_rootS[wid].b.Data() + DS_Worker_Warp_Slot_Size;
     // We currently do not have a next slot.
-    worker_rootS[wid].Next = 0;
-    worker_rootS[wid].Prev = 0;
-    worker_rootS[wid].PrevSlotStackPtr = 0;
-    return (__kmpc_data_sharing_slot *)&worker_rootS[wid];
+    worker_rootS[wid].b.Next = 0;
+    worker_rootS[wid].b.Prev = 0;
+    worker_rootS[wid].b.PrevSlotStackPtr = 0;
+    return &worker_rootS[wid].b;
   }
 
   INLINE __kmpc_data_sharing_slot *GetPreallocatedSlotAddr(int wid) {
-    worker_rootS[wid].DataEnd =
-        &worker_rootS[wid].Data[0] + DS_Worker_Warp_Slot_Size;
+    worker_rootS[wid].b.DataEnd =
+        worker_rootS[wid].b.Data() + DS_Worker_Warp_Slot_Size;
     // We currently do not have a next slot.
-    worker_rootS[wid].Next = 0;
-    worker_rootS[wid].Prev = 0;
-    worker_rootS[wid].PrevSlotStackPtr = 0;
-    return (__kmpc_data_sharing_slot *)&worker_rootS[wid];
+    worker_rootS[wid].b.Next = 0;
+    worker_rootS[wid].b.Prev = 0;
+    worker_rootS[wid].b.PrevSlotStackPtr = 0;
+    return &worker_rootS[wid].b;
   }
 
 private:
   omptarget_nvptx_TaskDescr
       levelZeroTaskDescr; // icv for team master initial thread
   omptarget_nvptx_WorkDescr
       workDescrForActiveParallel; // one, ONLY for the active par
 

openmp/libomptarget/deviceRTLs/common/src/data_sharing.cu

 INLINE static void data_sharing_init_stack_common() {
   ASSERT0(LT_FUSSY, isRuntimeInitialized(), "Runtime must be initialized.");
   omptarget_nvptx_TeamDescr *teamDescr =
       &omptarget_nvptx_threadPrivateContext->TeamContext();
 
   for (int WID = 0; WID < WARPSIZE; WID++) {
     __kmpc_data_sharing_slot *RootS = teamDescr->GetPreallocatedSlotAddr(WID);
     DataSharingState.SlotPtr[WID] = RootS;
-    DataSharingState.StackPtr[WID] = (void *)&RootS->Data[0];
+    DataSharingState.StackPtr[WID] = (void *)RootS->Data();
   }
 }
 
 // Initialize data sharing data structure. This function needs to be called
 // once at the beginning of a data sharing context (coincides with the kernel
 // initialization). This function is called only by the MASTER thread of each
 // team in non-SPMD mode.
 EXTERN void __kmpc_data_sharing_init_stack() {
if (EndAddress < RequestedEndAddress) {
         NewSize = DefaultSlotSize;
       NewSlot = (__kmpc_data_sharing_slot *) SafeMalloc(
           sizeof(__kmpc_data_sharing_slot) + NewSize,
           "Global memory slot allocation.");
 
       NewSlot->Next = 0;
       NewSlot->Prev = SlotP;
       NewSlot->PrevSlotStackPtr = StackP;
-      NewSlot->DataEnd = &NewSlot->Data[0] + NewSize;
+      NewSlot->DataEnd = NewSlot->Data() + NewSize;
 
       // Make previous slot point to the newly allocated slot.
       SlotP->Next = NewSlot;
       // The current slot becomes the new slot.
       SlotP = NewSlot;
       // The stack pointer always points to the next free stack frame.
-      StackP = &NewSlot->Data[0] + PushSize;
+      StackP = NewSlot->Data() + PushSize;
       // The frame pointer always points to the beginning of the frame.
-      FrameP = DataSharingState.FramePtr[WID] = &NewSlot->Data[0];
+      FrameP = DataSharingState.FramePtr[WID] = NewSlot->Data();
     } else {
       // Add the data chunk to the current slot. The frame pointer is set to
       // point to the start of the new frame held in StackP.
       FrameP = DataSharingState.FramePtr[WID] = StackP;
       // Reset stack pointer to the requested address.
       StackP = (void *)RequestedEndAddress;
     }
   }
if (GetThreadIdInBlock() % WARPSIZE == 0) {
     // Pointer to next available stack.
     void *&StackP = DataSharingState.StackPtr[WID];
 
     // Pop the frame.
     StackP = FrameStart;
 
     // If the current slot is empty, we need to free the slot after the
     // pop.
-    bool SlotEmpty = (StackP == &SlotP->Data[0]);
+    bool SlotEmpty = (StackP == SlotP->Data());
 
     if (SlotEmpty && SlotP->Prev) {
       // Before removing the slot we need to reset StackP.
       StackP = SlotP->PrevSlotStackPtr;
 
       // Remove the slot.
       SlotP = SlotP->Prev;
       SafeFree(SlotP->Next, "Free slot.");

openmp/libomptarget/deviceRTLs/common/src/omptarget.cu

PRINT(LD_PAR,
         (int)newTaskDescr->ThreadId(), (int)ThreadLimit);
 
   if (RequiresDataSharing && GetLaneId() == 0) {
     // Warp master initializes data sharing environment.
     unsigned WID = threadId / WARPSIZE;
     __kmpc_data_sharing_slot *RootS = currTeamDescr.RootS(
         WID, WID == WARPSIZE - 1);
     DataSharingState.SlotPtr[WID] = RootS;
-    DataSharingState.StackPtr[WID] = (void *)&RootS->Data[0];
+    DataSharingState.StackPtr[WID] = (void *)RootS->Data();
   }
 }
 
 EXTERN void __kmpc_spmd_kernel_deinit_v2(int16_t RequiresOMPRuntime) {
   // We're not going to pop the task descr stack of each thread since
   // there are no more parallel regions in SPMD mode.
   if (!RequiresOMPRuntime)
     return;

openmp/libomptarget/deviceRTLs/interface.h

 EXTERN void *__kmpc_data_sharing_coalesced_push_stack(size_t size,
     int16_t UseSharedMemory);
 EXTERN void *__kmpc_data_sharing_push_stack(size_t size, int16_t UseSharedMemory);
 EXTERN void __kmpc_data_sharing_pop_stack(void *a);
 EXTERN void __kmpc_begin_sharing_variables(void ***GlobalArgs, size_t nArgs);
 EXTERN void __kmpc_end_sharing_variables();
 EXTERN void __kmpc_get_shared_variables(void ***GlobalArgs);
 
-// The slot used for data sharing by the master and worker threads. We use a
-// complete (default size version and an incomplete one so that we allow sizes
-// greater than the default).
-struct __kmpc_data_sharing_slot {
-  __kmpc_data_sharing_slot *Next;
-  __kmpc_data_sharing_slot *Prev;
-  void *PrevSlotStackPtr;
-  void *DataEnd;
-  char Data[];
-};
-
 // SPMD execution mode interrogation function.
 EXTERN int8_t __kmpc_is_spmd_exec_mode();
 
 EXTERN void __kmpc_get_team_static_memory(int16_t isSPMDExecutionMode,
                                           const void *buf, size_t size,
                                           int16_t is_shared, const void **res);
 
 EXTERN void __kmpc_restore_team_static_memory(int16_t isSPMDExecutionMode,
                                               int16_t is_shared);
 
 #endif