[DeviceASAN][NFC] Rename function name and reduce arguments of asan rtl (#19396)

AllanZyne · web-flow · commit 1eef21286258 · 2025-07-11T06:33:03.000-07:00
Use different naming style for internal and interface function
diff --git a/libdevice/sanitizer/asan_rtl.cpp b/libdevice/sanitizer/asan_rtl.cpp
@@ -55,8 +55,18 @@ static __SYCL_CONSTANT__ const char __generic_to[] =
 
 namespace {
 
-void __asan_report_unknown_device();
-void __asan_print_shadow_memory(uptr addr, uptr shadow_address, uint32_t as);
+struct DebugInfo {
+  uptr addr;
+  uint32_t as;
+  size_t access_size;
+  bool is_write;
+  const char __SYCL_CONSTANT__ *file;
+  const char __SYCL_CONSTANT__ *func;
+  uint32_t line;
+};
+
+void ReportUnknownDevice(const DebugInfo *debug);
+void PrintShadowMemory(uptr addr, uptr shadow_address, uint32_t as);
 
 __SYCL_GLOBAL__ void *ToGlobal(void *ptr) {
   return __spirv_GenericCastToPtrExplicit_ToGlobal(ptr, 5);
@@ -88,7 +98,8 @@ inline uptr MemToShadow_CPU(uptr addr) {
   return launch_info->GlobalShadowOffset + (addr >> ASAN_SHADOW_SCALE);
 }
 
-inline uptr MemToShadow_DG2(uptr addr, uint32_t as) {
+inline uptr MemToShadow_DG2(uptr addr, uint32_t as,
+                            [[maybe_unused]] const DebugInfo *debug) {
   if (as == ADDRESS_SPACE_GENERIC) {
     ConvertGenericPointer(addr, as);
   }
@@ -166,7 +177,8 @@ inline uptr MemToShadow_DG2(uptr addr, uint32_t as) {
   return 0;
 }
 
-inline uptr MemToShadow_PVC(uptr addr, uint32_t as) {
+inline uptr MemToShadow_PVC(uptr addr, uint32_t as,
+                            [[maybe_unused]] const DebugInfo *debug) {
   if (as == ADDRESS_SPACE_GENERIC) {
     ConvertGenericPointer(addr, as);
   }
@@ -243,35 +255,36 @@ inline uptr MemToShadow_PVC(uptr addr, uint32_t as) {
   return 0;
 }
 
-inline uptr MemToShadow(uptr addr, uint32_t as) {
+inline uptr MemToShadow(uptr addr, uint32_t as,
+                        const DebugInfo *debug = nullptr) {
   uptr shadow_ptr = 0;
 
 #if defined(__LIBDEVICE_PVC__)
-  shadow_ptr = MemToShadow_PVC(addr, as);
+  shadow_ptr = MemToShadow_PVC(addr, as, debug);
 #elif defined(__LIBDEVICE_CPU__)
   shadow_ptr = MemToShadow_CPU(addr);
 #elif defined(__LIBDEVICE_DG2__)
-  shadow_ptr = MemToShadow_DG2(addr, as);
+  shadow_ptr = MemToShadow_DG2(addr, as, debug);
 #else
   auto launch_info = (__SYCL_GLOBAL__ const AsanRuntimeData *)__AsanLaunchInfo;
   if (launch_info->DeviceTy == DeviceType::CPU) {
     shadow_ptr = MemToShadow_CPU(addr);
   } else if (launch_info->DeviceTy == DeviceType::GPU_PVC) {
-    shadow_ptr = MemToShadow_PVC(addr, as);
+    shadow_ptr = MemToShadow_PVC(addr, as, debug);
   } else if (launch_info->DeviceTy == DeviceType::GPU_DG2) {
-    shadow_ptr = MemToShadow_DG2(addr, as);
+    shadow_ptr = MemToShadow_DG2(addr, as, debug);
   } else {
     ASAN_DEBUG(__spirv_ocl_printf(__asan_print_unsupport_device_type,
                                   (int)launch_info->DeviceTy));
-    __asan_report_unknown_device();
+    ReportUnknownDevice(debug);
     return 0;
   }
 #endif
 
   ASAN_DEBUG(
       if (shadow_ptr) {
         if (as == ADDRESS_SPACE_PRIVATE)
-          __asan_print_shadow_memory(addr, shadow_ptr, as);
+          PrintShadowMemory(addr, shadow_ptr, as);
         else
           __spirv_ocl_printf(__asan_print_shadow_value1, addr, as, shadow_ptr,
                              *(u8 *)shadow_ptr);
@@ -320,7 +333,7 @@ bool MemIsZero(__SYCL_GLOBAL__ const char *beg, uptr size) {
 static __SYCL_CONSTANT__ const char __mem_sanitizer_report[] =
     "[kernel] SanitizerReport (ErrorType=%d, IsRecover=%d)\n";
 
-void __asan_exit(ErrorType error_type) {
+void Exit(ErrorType error_type) {
   // Exit the kernel when we really need it
   switch (error_type) {
   case ErrorType::UNKNOWN:
@@ -333,37 +346,8 @@ void __asan_exit(ErrorType error_type) {
   }
 }
 
-void __asan_internal_report_save(ErrorType error_type) {
-  const int Expected = ASAN_REPORT_NONE;
-  int Desired = ASAN_REPORT_START;
-
-  const size_t wid = WorkGroupLinearId();
-  auto &SanitizerReport = ((__SYCL_GLOBAL__ AsanRuntimeData *)__AsanLaunchInfo)
-                              ->Report[wid % ASAN_MAX_NUM_REPORTS];
-
-  if (atomicCompareAndSet(
-          &(((__SYCL_GLOBAL__ AsanRuntimeData *)__AsanLaunchInfo)->ReportFlag),
-          1, 0) == 0 &&
-      atomicCompareAndSet(&SanitizerReport.Flag, Desired, Expected) ==
-          Expected) {
-    SanitizerReport.ErrorTy = error_type;
-    SanitizerReport.IsRecover = false;
-
-    // Show we've done copying
-    atomicStore(&SanitizerReport.Flag, ASAN_REPORT_FINISH);
-
-    ASAN_DEBUG(__spirv_ocl_printf(__mem_sanitizer_report,
-                                  SanitizerReport.ErrorTy,
-                                  SanitizerReport.IsRecover));
-  }
-  __asan_exit(error_type);
-}
-
-void __asan_internal_report_save(
-    uptr ptr, uint32_t as, const char __SYCL_CONSTANT__ *file, uint32_t line,
-    const char __SYCL_CONSTANT__ *func, bool is_write, uint32_t access_size,
-    MemoryType memory_type, ErrorType error_type, bool is_recover = false) {
-
+void SaveReport(ErrorType error_type, MemoryType memory_type, bool is_recover,
+                const DebugInfo *debug) {
   const int Expected = ASAN_REPORT_NONE;
   int Desired = ASAN_REPORT_START;
 
@@ -378,6 +362,14 @@ void __asan_internal_report_save(
       atomicCompareAndSet(&SanitizerReport.Flag, Desired, Expected) ==
           Expected) {
 
+    const uptr ptr = debug ? debug->addr : 0;
+    const uint32_t as = debug ? debug->as : 5;
+    const char __SYCL_CONSTANT__ *file = debug ? debug->file : nullptr;
+    const uint32_t line = debug ? debug->line : 0;
+    const char __SYCL_CONSTANT__ *func = debug ? debug->func : nullptr;
+    const bool is_write = debug ? debug->is_write : false;
+    const uint32_t access_size = debug ? debug->access_size : 0;
+
     int FileLength = 0;
     int FuncLength = 0;
 
@@ -426,7 +418,7 @@ void __asan_internal_report_save(
                                   SanitizerReport.ErrorTy,
                                   SanitizerReport.IsRecover));
   }
-  __asan_exit(error_type);
+  Exit(error_type);
 }
 
 ///
@@ -459,14 +451,11 @@ MemoryType GetMemoryTypeByShadowValue(int shadow_value) {
   }
 }
 
-void __asan_report_access_error(uptr addr, uint32_t as, size_t size,
-                                bool is_write, uptr poisoned_addr,
-                                const char __SYCL_CONSTANT__ *file,
-                                uint32_t line,
-                                const char __SYCL_CONSTANT__ *func,
-                                bool is_recover = false) {
+void ReportAccessError(uptr poisoned_addr, uint32_t as, bool is_recover,
+                       const DebugInfo *debug) {
   // Check Error Type
-  auto *shadow_address = (__SYCL_GLOBAL__ s8 *)MemToShadow(poisoned_addr, as);
+  auto *shadow_address =
+      (__SYCL_GLOBAL__ s8 *)MemToShadow(poisoned_addr, as, debug);
   int shadow_value = *shadow_address;
   if (shadow_value > 0) {
     shadow_value = *(shadow_address + 1);
@@ -500,39 +489,31 @@ void __asan_report_access_error(uptr addr, uint32_t as, size_t size,
     error_type = ErrorType::UNKNOWN;
   }
 
-  __asan_internal_report_save(addr, as, file, line, func, is_write, size,
-                              memory_type, error_type, is_recover);
+  SaveReport(error_type, memory_type, is_recover, debug);
 }
 
-void __asan_report_misalign_error(uptr addr, uint32_t as, size_t size,
-                                  bool is_write, uptr poisoned_addr,
-                                  const char __SYCL_CONSTANT__ *file,
-                                  uint32_t line,
-                                  const char __SYCL_CONSTANT__ *func,
-                                  bool is_recover = false) {
+void ReportMisalignError(uptr addr, uint32_t as, bool is_recover,
+                         const DebugInfo *debug) {
 
-  auto *shadow = (__SYCL_GLOBAL__ s8 *)MemToShadow(addr, as);
+  auto *shadow = (__SYCL_GLOBAL__ s8 *)MemToShadow(addr, as, debug);
   while (*shadow >= 0) {
     ++shadow;
   }
   int shadow_value = *shadow;
 
-  ErrorType error_type = ErrorType::MISALIGNED;
-  MemoryType memory_type = GetMemoryTypeByShadowValue(shadow_value);
-
-  __asan_internal_report_save(addr, as, file, line, func, is_write, size,
-                              memory_type, error_type, is_recover);
+  SaveReport(ErrorType::MISALIGNED, GetMemoryTypeByShadowValue(shadow_value),
+             is_recover, debug);
 }
 
-void __asan_report_unknown_device() {
-  __asan_internal_report_save(ErrorType::UNKNOWN_DEVICE);
+void ReportUnknownDevice(const DebugInfo *debug) {
+  SaveReport(ErrorType::UNKNOWN_DEVICE, MemoryType::UNKNOWN, false, debug);
 }
 
 ///
 /// ASan utils
 ///
 
-void __asan_print_shadow_memory(uptr addr, uptr shadow_address, uint32_t as) {
+void PrintShadowMemory(uptr addr, uptr shadow_address, uint32_t as) {
   uptr p = shadow_address & (~0xf);
   __spirv_ocl_printf(__asan_shadow_value_start, addr, as, p);
   for (int i = 0; i < 0xf; ++i) {
@@ -546,23 +527,10 @@ void __asan_print_shadow_memory(uptr addr, uptr shadow_address, uint32_t as) {
   __spirv_ocl_printf(__newline);
 }
 
-bool __asan_region_is_value(uptr addr, uint32_t as, std::size_t size,
-                            char value) {
-  if (size == 0)
-    return true;
-  while (size--) {
-    auto *shadow = (__SYCL_GLOBAL__ char *)MemToShadow(addr, as);
-    if (*shadow != value) {
-      return false;
-    }
-    ++addr;
-  }
-  return true;
-}
-
 // NOTE: size <= 16
-inline int __asan_address_is_poisoned(uptr a, uint32_t as, size_t size = 1) {
-  auto *shadow_address = (__SYCL_GLOBAL__ s8 *)MemToShadow(a, as);
+inline int IsAddressPoisoned(uptr a, uint32_t as, size_t size,
+                             const DebugInfo *debug) {
+  auto *shadow_address = (__SYCL_GLOBAL__ s8 *)MemToShadow(a, as, debug);
   if (shadow_address) {
     auto shadow_value = *shadow_address;
     if (shadow_value) {
@@ -575,28 +543,29 @@ inline int __asan_address_is_poisoned(uptr a, uint32_t as, size_t size = 1) {
   return false;
 }
 
-inline uptr __asan_region_is_poisoned(uptr beg, uint32_t as, size_t size) {
+inline uptr IsRegionPoisoned(uptr beg, uint32_t as, size_t size,
+                             const DebugInfo *debug) {
   if (!size)
     return 0;
 
   uptr end = beg + size;
   uptr aligned_b = RoundUpTo(beg, ASAN_SHADOW_GRANULARITY);
   uptr aligned_e = RoundDownTo(end, ASAN_SHADOW_GRANULARITY);
 
-  uptr shadow_beg = MemToShadow(aligned_b, as);
+  uptr shadow_beg = MemToShadow(aligned_b, as, debug);
   if (!shadow_beg) {
     return 0;
   }
-  uptr shadow_end = MemToShadow(aligned_e, as);
+  uptr shadow_end = MemToShadow(aligned_e, as, debug);
   if (!shadow_end) {
     return 0;
   }
 
   // First check the first and the last application bytes,
   // then check the ASAN_SHADOW_GRANULARITY-aligned region by calling
   // MemIsZero on the corresponding shadow.
-  if (!__asan_address_is_poisoned(beg, as) &&
-      !__asan_address_is_poisoned(end - 1, as) &&
+  if (!IsAddressPoisoned(beg, as, 1, debug) &&
+      !IsAddressPoisoned(end - 1, as, 1, debug) &&
       (shadow_end <= shadow_beg ||
        MemIsZero((__SYCL_GLOBAL__ const char *)shadow_beg,
                  shadow_end - shadow_beg)))
@@ -605,7 +574,7 @@ inline uptr __asan_region_is_poisoned(uptr beg, uint32_t as, size_t size) {
   // The fast check failed, so we have a poisoned byte somewhere.
   // Find it slowly.
   for (; beg < end; beg++)
-    if (__asan_address_is_poisoned(beg, as))
+    if (IsAddressPoisoned(beg, as, 1, debug))
       return beg;
 
   return 0;
@@ -628,27 +597,25 @@ constexpr size_t AlignMask(size_t n) { return n - 1; }
       const char __SYCL_CONSTANT__ *func) {                                    \
     if (!__AsanLaunchInfo)                                                     \
       return;                                                                  \
+    DebugInfo debug{addr, as, size, is_write, file, func, line};               \
     if (addr & AlignMask(size)) {                                              \
-      __asan_report_misalign_error(addr, as, size, is_write, addr, file, line, \
-                                   func);                                      \
+      ReportMisalignError(addr, as, false, &debug);                            \
     }                                                                          \
-    if (__asan_address_is_poisoned(addr, as, size)) {                          \
-      __asan_report_access_error(addr, as, size, is_write, addr, file, line,   \
-                                 func);                                        \
+    if (IsAddressPoisoned(addr, as, size, &debug)) {                           \
+      ReportAccessError(addr, as, false, &debug);                              \
     }                                                                          \
   }                                                                            \
   DEVICE_EXTERN_C_NOINLINE void __asan_##type##size##_as##as##_noabort(        \
       uptr addr, const char __SYCL_CONSTANT__ *file, uint32_t line,            \
       const char __SYCL_CONSTANT__ *func) {                                    \
     if (!__AsanLaunchInfo)                                                     \
       return;                                                                  \
+    DebugInfo debug{addr, as, size, is_write, file, func, line};               \
     if (addr & AlignMask(size)) {                                              \
-      __asan_report_misalign_error(addr, as, size, is_write, addr, file, line, \
-                                   func, true);                                \
+      ReportMisalignError(addr, as, true, &debug);                             \
     }                                                                          \
-    if (__asan_address_is_poisoned(addr, as, size)) {                          \
-      __asan_report_access_error(addr, as, size, is_write, addr, file, line,   \
-                                 func, true);                                  \
+    if (IsAddressPoisoned(addr, as, size, &debug)) {                           \
+      ReportAccessError(addr, as, true, &debug);                               \
     }                                                                          \
   }
 
@@ -676,19 +643,19 @@ ASAN_REPORT_ERROR(store, true, 16)
       uint32_t line, const char __SYCL_CONSTANT__ *func) {                     \
     if (!__AsanLaunchInfo)                                                     \
       return;                                                                  \
-    if (auto poisoned_addr = __asan_region_is_poisoned(addr, as, size)) {      \
-      __asan_report_access_error(addr, as, size, is_write, poisoned_addr,      \
-                                 file, line, func);                            \
+    DebugInfo debug{addr, as, size, is_write, file, func, line};               \
+    if (auto poisoned_addr = IsRegionPoisoned(addr, as, size, &debug)) {       \
+      ReportAccessError(poisoned_addr, as, false, &debug);                     \
     }                                                                          \
   }                                                                            \
   DEVICE_EXTERN_C_NOINLINE void __asan_##type##N_as##as##_noabort(             \
       uptr addr, size_t size, const char __SYCL_CONSTANT__ *file,              \
       uint32_t line, const char __SYCL_CONSTANT__ *func) {                     \
     if (!__AsanLaunchInfo)                                                     \
       return;                                                                  \
-    if (auto poisoned_addr = __asan_region_is_poisoned(addr, as, size)) {      \
-      __asan_report_access_error(addr, as, size, is_write, poisoned_addr,      \
-                                 file, line, func, true);                      \
+    DebugInfo debug{addr, as, size, is_write, file, func, line};               \
+    if (auto poisoned_addr = IsRegionPoisoned(addr, as, size, &debug)) {       \
+      ReportAccessError(poisoned_addr, as, true, &debug);                      \
     }                                                                          \
   }
 
diff --git a/libdevice/sanitizer/msan_rtl.cpp b/libdevice/sanitizer/msan_rtl.cpp
@@ -742,9 +742,9 @@ __msan_unpoison_strided_copy(uptr dest, uint32_t dest_as, uptr src,
   MSAN_DEBUG(__spirv_ocl_printf(__msan_print_func_beg,
                                 "__msan_unpoison_strided_copy"));
 
-  uptr shadow_dest = (uptr)__msan_get_shadow(dest, dest_as);
+  uptr shadow_dest = MemToShadow(dest, dest_as);
   if (shadow_dest != GetMsanLaunchInfo->CleanShadow) {
-    uptr shadow_src = (uptr)__msan_get_shadow(src, src_as);
+    uptr shadow_src = MemToShadow(src, src_as);
 
     switch (element_size) {
     case 1:
