[AMDGPU] ASan Patches for OpenMP

[jdoerfert]

This doesn't seem to be based on LLVM upstream, among other issues. Blocking it for now w/o looking at the actual patch.

[ampandey-AMD]

The changes proposed here require hostrpc to be upstreamed first which may not be available for the time begin.

clang/lib/Driver/ToolChains/AMDGPUOpenMP.cpp

LibraryPaths.push_back(
       Args.MakeArgString(C.getDriver().Dir + "/../../lib/libdevice"));
   LibraryPaths.push_back(Args.MakeArgString(C.getDriver().Dir + "/../../lib"));
 
   // Add bitcode library in --hip-device-lib.
   for (auto Lib : Args.getAllArgValues(options::OPT_hip_device_lib_EQ)) {
     BCLibs.push_back(Args.MakeArgString(Lib));
   }
 
+  if (Args.hasFlag(options::OPT_fgpu_sanitize,
+                  options::OPT_fno_gpu_sanitize,false)) {
+    BCLibs.push_back("asanrtl.bc");
+  }
+
+
   // Add libm for Fortran.
   if (C.getDriver().IsFlangMode()) {
     BCLibs.push_back(Args.MakeArgString("libm-amdgcn-" + SubArchName + ".bc"));
     if (Args.hasArg(options::OPT_cl_finite_math_only))
       BCLibs.push_back(Args.MakeArgString("oclc_finite_only_on.bc"));
     else
       BCLibs.push_back(Args.MakeArgString("oclc_finite_only_off.bc"));
   }
else {
     BCLibs.append(
         {Args.MakeArgString("libomptarget-amdgcn-" + SubArchName + ".bc"),
          Args.MakeArgString("libaompextras-amdgcn-" + SubArchName + ".bc"),
          "hip.bc", "ockl.bc",
          Args.MakeArgString("libbc-hostrpc-amdgcn.a"),
          std::string(WaveFrontSizeBC)});
   }
 
-  if (Args.hasFlag(options::OPT_fgpu_sanitize,
-                   options::OPT_fno_gpu_sanitize, false)) {
-    BCLibs.push_back("asanrtl.bc");
-  }
-
-  for (auto Lib : BCLibs)
+  for (auto Lib : BCLibs)
     addBCLib(C.getDriver(), Args, CmdArgs, LibraryPaths, Lib,
              /* PostClang Link? */ false);
 
   // This will find .a and .bc files that match naming convention.
   AddStaticDeviceLibs(C, *this, JA, Inputs, Args, CmdArgs, "amdgcn",
                       SubArchName,
                       /* bitcode SDL?*/ true,
                       /* PostClang Link? */ false);

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

if (isUnsupportedAMDGPUAddrspace(Addr))
     return nullptr;
   Type *PtrTy = cast<PointerType>(Addr->getType()->getScalarType());
   // Follow host instrumentation for global and constant addresses.
   if (PtrTy->getPointerAddressSpace() != 0)
     return InsertBefore;
   // Instrument generic addresses in supported addressspaces.
   IRBuilder<> IRB(InsertBefore);
   Value *AddrLong = IRB.CreatePointerCast(Addr, IRB.getInt8PtrTy());
+
+
   Value *IsShared = IRB.CreateCall(AMDGPUAddressShared, {AddrLong});
   Value *IsPrivate = IRB.CreateCall(AMDGPUAddressPrivate, {AddrLong});
   Value *IsSharedOrPrivate = IRB.CreateOr(IsShared, IsPrivate);
   Value *Cmp = IRB.CreateICmpNE(IRB.getTrue(), IsSharedOrPrivate);
-  Value *AddrSpaceZeroLanding =
-      SplitBlockAndInsertIfThen(Cmp, InsertBefore, false);
+  Value *AddrSpaceZeroLanding = SplitBlockAndInsertIfThen(Cmp, InsertBefore, false);
   InsertBefore = cast<Instruction>(AddrSpaceZeroLanding);
+
   return InsertBefore;
 }
 
 void AddressSanitizer::instrumentAddress(Instruction *OrigIns,
                                          Instruction *InsertBefore, Value *Addr,
                                          uint32_t TypeSize, bool IsWrite,
                                          Value *SizeArgument, bool UseCalls,
                                          uint32_t Exp) {

openmp/libomptarget/hostrpc/services/CMakeLists.txt

 
 if (OPENMP_ENABLE_LIBOMPTARGET_HSA)
-  add_library(hostrpc_services STATIC hostcall.cpp hostrpc_execute_service.c hostrpc_externs.c)
+  add_library(hostrpc_services STATIC hostcall.cpp hostrpc_execute_service.c hostrpc_externs.c devsanitizer.cpp)
   set_property(TARGET hostrpc_services PROPERTY POSITION_INDEPENDENT_CODE ON)
   find_path(HSA_INCLUDE hsa.h HINTS ${CMAKE_INSTALL_PREFIX}/include/hsa ${CMAKE_INSTALL_PREFIX}/../include/hsa /opt/rocm/include/hsa PATH_SUFFIXES hsa)
   include_directories(${HSA_INCLUDE})
+  target_link_libraries(hostrpc_services /home/ampandey/git/aomp/lib/clang/14.0.0/lib/linux/libclang_rt.asan-x86_64.so)
 endif()

openmp/libomptarget/hostrpc/services/hostcall.cpp

+#include "../src/hostrpc.h"
 #include "hostrpc_internal.h"
 #include "hsa.h"
 #include "../plugins/amdgpu/impl/rt.h"
 
 #include <assert.h>
 #include <atomic>
 #include <cstring>
 #include <functional>
static header_t *get_header(buffer_t *buffer, ulong ptr) {
   return buffer->headers + get_ptr_index(ptr, buffer->index_size);
 }
 
 static payload_t *get_payload(buffer_t *buffer, ulong ptr) {
   return buffer->payloads + get_ptr_index(ptr, buffer->index_size);
 }
 
 extern "C" void hostrpc_execute_service(uint32_t service, uint32_t device_id,
-                                        uint64_t *payload);
+                                        uint64_t *payload, uint64_t *activemask);
+
+static hostrpc_status_t hostrpc_version_check(unsigned int device_vrm) {
+
+ if (device_vrm == (unsigned int)HOSTRPC_VRM)
+         return HOSTRPC_SUCCESS;
+
+ uint device_version_release = device_vrm >> 6;
+ if (device_version_release != HOSTRPC_VERSION_RELEASE) {
+    printf("ERROR Incompatible device and host version \n Device "
+                    "release(%d)\n Host Version(%d)\n",
+                    device_version_release,HOSTRPC_VERSION_RELEASE);
+    return HOSTRPC_WRONGVERSION_ERROR;
+ }
+ if( device_vrm  > HOSTRPC_VRM) {
+  printf("ERROR Incompatible device and host version \n Device"
+         "version(%d)\n Host version(%d)\n",
+         device_vrm,HOSTRPC_VERSION_RELEASE);
+  printf("Upgrade libomptarget runtime on your system. \n");
+  return HOSTRPC_OLDHOSTVERSIONMOD_ERROR;
+ }
+ if( device_vrm < HOSTRPC_VRM) {
+ unsigned int host_ver = ((unsigned int)HOSTRPC_VRM) >> 12;
+ unsigned int host_rel = (((unsigned int)HOSTRPC_VRM) << 20) >> 26;
+ unsigned int host_mod = (((unsigned int)HOSTRPC_VRM) << 26) >> 26;
+ unsigned int dev_ver = ((unsigned int)device_vrm) >> 12;
+ unsigned int dev_rel = (((unsigned int)device_vrm) << 20) >> 26;
+ unsigned int dev_mod = (((unsigned int)device_vrm) << 26) >> 26;
+ printf("WARNING: Device mod version < host mod version \n Device"
+        "version: %d.%d.%d\n Host version: %d.%d.%d\n",
+        dev_ver,dev_rel,dev_mod,host_ver,host_rel,host_mod);
+ printf("Consider rebuild binary with more recent compiler.\n");
+ return HOSTRPC_SUCCESS;
+ }
+}
+
+static void hostrpc_abort(int rc) {
+  printf("hostrpc_abort called with code %d\n",rc);
+  abort();
+}
+
+extern "C" void handleSanitizerService(payload_t* payload,uint64_t activemask,uint32_t* dev_ptr);
 
 void amd_hostcall_consumer_t::process_packets(buffer_t *buffer,
                                               uint64_t ready_stack) const {
-  // This function is always called from consume_packets, which owns
+
+  bool hostrpc_version_checked;
+  // This function is always called from consume_packets, which owns
   // the lock for the critical data.
 
   WHEN_DEBUG(std::cout << "process packets starting with " << ready_stack
                        << std::endl);
 
+
   // Each wave can submit at most one packet at a time, and all
   // waves independently push ready packets. The stack of packets at
   // this point cannot contain multiple packets from the same wave,
   // so consuming ready packets in a latest-first order does not
   // affect any wave.
   for (decltype(ready_stack) iter = ready_stack, next = 0; iter; iter = next) {
     WHEN_DEBUG(std::cout << "processing ptr: " << iter << std::endl);
     WHEN_DEBUG(std::cout << "packet index: " << std::dec
                          << get_ptr_index(iter, buffer->index_size)
                          << std::endl);
 
     // Remember the next packet pointer. The current packet will
     // get reused from the free stack after we process it.
     auto header = get_header(buffer, iter);
     next = header->next;
 
     WHEN_DEBUG(std::cout << "packet service: " << (uint32_t)header->service
                          << std::endl);
 
     auto payload = get_payload(buffer, iter);
     uint64_t activemask = header->activemask;
     WHEN_DEBUG(std::cout << "activemask: " << std::hex << activemask
                          << std::endl);
 
+    // split the 32-bit service number into service_id and VRM to be checked
+    // if device hostrpc or stubs are ahead of this host runtime.
+    uint service = header->service;
+    uint service_id = (service << 16) >> 16;
+    if (!hostrpc_version_checked) {
+    uint device_vrm = ((uint)service >> 16);
+    hostrpc_status_t err = hostrpc_version_check(device_vrm);
+    if (err != HOSTRPC_SUCCESS)
+      hostrpc_abort(err);
+    hostrpc_version_checked = true;
+    }
+    if(service_id == HOSTRPC_SERVICE_SANITIZER) {
+    handleSanitizerService(payload,activemask,&(buffer->device_id));
+    //activemask zeroed to avoid subsequent handling for each work-item.
+    activemask = 0;
+    }
+
     // TODO: One could use ffs to skip inactive lanes faster.
+    if(activemask) {
     for (uint32_t wi = 0; wi != 64; ++wi) {
       uint64_t flag = activemask & ((uint64_t)1 << wi);
       if (flag == 0)
         continue;
       uint64_t *slot = payload->slots[wi];
-      hostrpc_execute_service(header->service, buffer->device_id, slot);
-    }
+      hostrpc_execute_service(service_id, (buffer->device_id), slot,&activemask);
+    }
+    }
     __atomic_store_n(&header->control, reset_ready_flag(header->control),
                      std::memory_order_release);
   }
 }
 
 void amd_hostcall_consumer_t::consume_packets() {
   /* TODO: The consumer iterates over all registered buffers in an
      unspecified order, and for each buffer, processes packets also

 extern "C" {
   hsa_status_t host_malloc(void **mem, size_t size) {
     return core::Runtime::HostMalloc(mem, size);
   }
 
   hsa_status_t device_malloc(void **mem, size_t size, int device_id) {
     return core::Runtime::DeviceMalloc(mem, size, device_id);
   }
-  
   hsa_status_t atmi_free(void *mem) {
     return core::Runtime::Memfree(mem);
   }
 
   hsa_status_t ftn_assign_wrapper(void *arg0, void *arg1, void *arg2, void *arg3, void *arg4) {
     return core::Runtime::FtnAssignWrapper(arg0, arg1, arg2, arg3, arg4);
   }
 
 }

openmp/libomptarget/hostrpc/services/hostrpc_execute_service.c

 #include <stdarg.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#if 0
 // Error codes for service handler functions used in this file
 // Some error codes may be returned to device stub functions.
 typedef enum hostrpc_status_t {
   HOSTRPC_SUCCESS = 0,
   HOSTRPC_STATUS_UNKNOWN = 1,
   HOSTRPC_STATUS_ERROR = 2,
   HOSTRPC_STATUS_TERMINATE = 3,
   HOSTRPC_DATA_USED_ERROR = 4,
   HOSTRPC_ADDINT_ERROR = 5,
   HOSTRPC_ADDFLOAT_ERROR = 6,
   HOSTRPC_ADDSTRING_ERROR = 7,
   HOSTRPC_UNSUPPORTED_ID_ERROR = 8,
   HOSTRPC_INVALID_ID_ERROR = 9,
   HOSTRPC_ERROR_INVALID_REQUEST = 10,
   HOSTRPC_EXCEED_MAXVARGS_ERROR = 11,
   HOSTRPC_WRONGVERSION_ERROR = 12,
   HOSTRPC_OLDHOSTVERSIONMOD_ERROR = 13,
   HOSTRPC_INVALIDSERVICE_ERROR = 14,
 } hostrpc_status_t;
+#endif
 
 // MAXVARGS is more than a static array size.
 // It is for user vargs functions only.
 // It does not apply to printf.
 #define MAXVARGS 32
 
 // We would like to get llvm typeID enum from Type.h. e.g.
 // #include "../../../../../llvm/include/llvm/IR/Type.h"
static void hostrpc_handler_SERVICE_DEMO(uint32_t device_id,
   copyerr = atmi_memcpy_no_signal(B, B_D, N * sizeof(int), false);
 
   int num_zeros = local_vector_product_zeros(N, A, B, C);
   copyerr = atmi_memcpy_no_signal(C_D, C, N * sizeof(int), true);
   payload[0] = (uint64_t)copyerr;
   payload[1] = (uint64_t)num_zeros;
 }
 
+#if 0
 // FIXME: Clean up this diagnostic and die properly
 static bool hostrpc_version_checked;
 static hostrpc_status_t hostrpc_version_check(unsigned int device_vrm) {
   if (device_vrm == (unsigned int)HOSTRPC_VRM)
     return HOSTRPC_SUCCESS;
   uint device_version_release = device_vrm >> 6;
   if (device_version_release != HOSTRPC_VERSION_RELEASE) {
     printf("ERROR Incompatible device and host release\n      Device "
if (device_vrm < HOSTRPC_VRM) {
     unsigned int dev_mod = (((unsigned int)device_vrm) << 26) >> 26;
     printf("WARNING:  Device mod version < host mod version \n          Device "
            "version: %d.%d.%d\n          Host version:   %d.%d.%d\n",
            dev_ver, dev_rel, dev_mod, host_ver, host_rel, host_mod);
     printf("          Consider rebuild binary with more recent compiler.\n");
   }
   return HOSTRPC_SUCCESS;
 }
+#endif
 
 static void hostrpc_abort(int rc) {
   printf("hostrpc_abort called with code %d\n", rc);
   abort();
 }
 
 // The architecture-specific implementation of hostrpc will
 // call this single external function for each service request.
 // Host service functions are architecturally independent.
-extern void hostrpc_execute_service(uint32_t service, uint32_t device_id,
-                                    uint64_t *payload) {
-
+extern void hostrpc_execute_service(uint32_t service_id, uint32_t *dev_ptr_,
+                                    uint64_t *payload, uint64_t *activemask) {
+#if 0
   // split the 32-bit service number into service_id and VRM to be checked
   // if device hostrpc or stubs are ahead of this host runtime.
   uint service_id = (service << 16) >> 16;
+  uint device_id = *dev_ptr_;
   if (!hostrpc_version_checked) {
     uint device_vrm = ((uint)service >> 16);
     hostrpc_status_t err = hostrpc_version_check(device_vrm);
     if (err != HOSTRPC_SUCCESS)
       hostrpc_abort(err);
     hostrpc_version_checked = true;
   }
+#endif
+
+  uint device_id = *dev_ptr_;
 
-  switch (service_id) {
+  switch (service_id) {
   case HOSTRPC_SERVICE_PRINTF:
     hostrpc_handler_SERVICE_PRINTF(device_id, payload);
     break;
   case HOSTRPC_SERVICE_FPRINTF:
     hostrpc_handler_SERVICE_FPRINTF(device_id, payload);
     break;
   case HOSTRPC_SERVICE_VARFNUINT:
     hostrpc_handler_SERVICE_VARFNUINT(device_id, payload);
case HOSTRPC_SERVICE_FTNASSIGN:
     hostrpc_handler_SERVICE_FTNASSIGN(device_id, payload);
     break;
   case HOSTRPC_SERVICE_FREE:
     hostrpc_handler_SERVICE_FREE(device_id, payload);
     break;
   case HOSTRPC_SERVICE_FUNCTIONCALL:
     hostrpc_handler_SERVICE_FUNCTIONCALL(device_id, payload);
     break;
+  case HOSTRPC_SERVICE_DEVMEM:
+    fprintf(stderr, "NO HOSTRPC_SERVICE_DEVMEM handler \n");
+    break;
+  case HOSTRPC_SERVICE_SANITIZER:
+    abort();
+    break;
   case HOSTRPC_SERVICE_DEMO:
     hostrpc_handler_SERVICE_DEMO(device_id, payload);
     break;
   default:
     hostrpc_abort(HOSTRPC_INVALIDSERVICE_ERROR);
-    printf("ERROR: hostrpc got a bad service id:%d\n", service);
+    printf("ERROR: hostrpc got a bad service id:%d\n", service_id);
   }
 }
 
 //---------------- Support for hostrpc_printf service ---------------------
 
 // Handle overflow when building the va_list for vprintf
 static hostrpc_status_t hostrpc_pfGetOverflow(hostrpc_ValistExt_t *valist,
                                               size_t needsize) {

openmp/libomptarget/hostrpc/services/hostrpc_internal.h

 #ifndef AMD_HOSTCALL_H
 #define AMD_HOSTCALL_H
 
 #include <stddef.h>
 #include <stdint.h>
 #include <hsa.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+// Error codes for hostrpc functions.
+typedef enum hostrpc_status_t {
+  HOSTRPC_SUCCESS = 0,
+  HOSTRPC_STATUS_UNKNOWN = 1,
+  HOSTRPC_STATUS_ERROR = 2,
+  HOSTRPC_STATUS_TERMINATE = 3,
+  HOSTRPC_DATA_USED_ERROR = 4,
+  HOSTRPC_ADDINT_ERROR = 5,
+  HOSTRPC_ADDFLOAT_ERROR = 6,
+  HOSTRPC_ADDSTRING_ERROR = 7,
+  HOSTRPC_UNSUPPORTED_ID_ERROR = 8,
+  HOSTRPC_INVALID_ID_ERROR = 9,
+  HOSTRPC_ERROR_INVALID_REQUEST = 10,
+  HOSTRPC_EXCEED_MAXVARGS_ERROR = 11,
+  HOSTRPC_WRONGVERSION_ERROR = 12,
+  HOSTRPC_OLDHOSTVERSIONMOD_ERROR = 13,
+  HOSTRPC_INVALIDSERVICE_ERROR = 14,
+} hostrpc_status_t;
+
 /** \file Support library for invoking host services from the device.
  *
  *  The hostcall consumer defined here is used by the language runtime
  *  to serve requests originating from kernels running on GPU
  *  devices. A typical flow is as follows:
  *
  *  - Create and launch one or more hostcall consumers.
  *  - Create and initialize a hostcall buffer per command queue.

openmp/libomptarget/hostrpc/src/hostrpc.h

enum hostcall_service_id {
   HOSTRPC_SERVICE_FREE,
   HOSTRPC_SERVICE_DEMO,
   HOSTRPC_SERVICE_FUNCTIONCALL,
   HOSTRPC_SERVICE_VARFNUINT,
   HOSTRPC_SERVICE_VARFNUINT64,
   HOSTRPC_SERVICE_VARFNDOUBLE,
   HOSTRPC_SERVICE_FPRINTF,
   HOSTRPC_SERVICE_FTNASSIGN,
+  HOSTRPC_SERVICE_DEVMEM,
+  HOSTRPC_SERVICE_SANITIZER,
 };
 typedef enum hostcall_service_id hostcall_service_id_t;
 
 #endif // __HOSTRPC_H__

openmp/libomptarget/hostrpc/src/hostrpc.cpp

EXTERN double hostrpc_varfn_double_execute(char *print_buffer, uint32_t bufsz) {
   union {
     uint64_t val;
     double dval;
   } unionarg;
   unionarg.val = result.arg0;
   return unionarg.dval;
 }
 
+EXTERN void __ockl_sanitizer_report(uint64_t addr, uint64_t pc, uint64_t wgidx,
+                                    uint64_t wgidy, uint64_t wgidz,
+                                    uint64_t wave_id, uint64_t is_read,
+                                    uint64_t access_size) {
+  hostrpc_result_t value =
+      hostrpc_invoke(PACK_VERS(HOSTRPC_SERVICE_SANITIZER), addr, pc, wgidx,
+                     wgidy, wgidz, wave_id, is_read, access_size);
+  return (void)value.arg0;
+}
+
+EXTERN uint64_t __hostrpc_devmem_request(uint64_t addr, uint64_t size) {
+  hostrpc_result_t result = hostrpc_invoke(PACK_VERS(HOSTRPC_SERVICE_DEVMEM),
+                                           addr, size, 0, 0, 0, 0, 0, 0);
+  return (uint64_t)result.arg0;
+}
+
 // -----------------------------------------------------------------------------
 //
 // vector_product_zeros: Example stub to demonstrate hostrpc services
 //
 // This is an example hostrpc stub for a service called vector_product_zeros.
 // This function calculates C = A*B and returns the number of zeros.
 // Naturally, one would typically do this type of operation on a GPU.
 // But this is a demo  to illustrate the use of hostrpc to run a service

openmp/libomptarget/src/rtl.cpp

static void RegisterGlobalCtorsDtorsForImage(__tgt_bin_desc *desc,
                                              RTLInfoTy *RTL) {
 
   for (int32_t i = 0; i < RTL->NumberOfDevices; ++i) {
     DeviceTy &Device = PM->Devices[RTL->Idx + i];
     Device.PendingGlobalsMtx.lock();
     Device.HasPendingGlobals = true;
     for (__tgt_offload_entry *entry = img->EntriesBegin;
          entry != img->EntriesEnd; ++entry) {
+       entry.size=32;
       if (entry->flags & OMP_DECLARE_TARGET_CTOR) {
         DP("Adding ctor " DPxMOD " to the pending list.\n",
            DPxPTR(entry->addr));
         Device.PendingCtorsDtors[desc].PendingCtors.push_back(entry->addr);
       } else if (entry->flags & OMP_DECLARE_TARGET_DTOR) {
         // Dtors are pushed in reverse order so they are executed from end
         // to beginning when unregistering the library!
         DP("Adding dtor " DPxMOD " to the pending list.\n",