[compiler-rt] [compiler-rt][asan] Add AMDGPU ASan support via HSA API interceptors. (PR #192238)

[via llvm-commits]

github-actions[bot] wrote:

<!--LLVM CODE FORMAT COMMENT: {clang-format}-->


:warning: C/C++ code formatter, clang-format found issues in your code. :warning:

<details>
<summary>
You can test this locally with the following command:
</summary>

``````````bash
git-clang-format --diff origin/main HEAD --extensions cpp -- compiler-rt/lib/asan/asan_interceptors.cpp --diff_from_common_commit
``````````

:warning:
The reproduction instructions above might return results for more than one PR
in a stack if you are using a stacked PR workflow. You can limit the results by
changing `origin/main` to the base branch/commit you want to compare against.
:warning:

</details>

<details>
<summary>
View the diff from clang-format here.
</summary>

``````````diff
diff --git a/compiler-rt/lib/asan/asan_interceptors.cpp b/compiler-rt/lib/asan/asan_interceptors.cpp
index e08a5efa2..924d36afc 100644
--- a/compiler-rt/lib/asan/asan_interceptors.cpp
+++ b/compiler-rt/lib/asan/asan_interceptors.cpp
@@ -895,19 +895,20 @@ DEFINE_REAL(int, vfork, )
 DECLARE_EXTERN_INTERCEPTOR_AND_WRAPPER(int, vfork, )
 #  endif
 
-#if SANITIZER_AMDGPU
+#  if SANITIZER_AMDGPU
 void ENSURE_HSA_INITED();
 
 INTERCEPTOR(hsa_status_t, hsa_amd_memory_pool_allocate,
-  hsa_amd_memory_pool_t memory_pool, size_t size, uint32_t flags, void **ptr) {
+            hsa_amd_memory_pool_t memory_pool, size_t size, uint32_t flags,
+            void** ptr) {
   AsanInitFromRtl();
   ENSURE_HSA_INITED();
   GET_STACK_TRACE_MALLOC;
   return asan_hsa_amd_memory_pool_allocate(memory_pool, size, flags, ptr,
-    &stack);
+                                           &stack);
 }
 
-INTERCEPTOR(hsa_status_t, hsa_amd_memory_pool_free, void *ptr) {
+INTERCEPTOR(hsa_status_t, hsa_amd_memory_pool_free, void* ptr) {
   AsanInitFromRtl();
   ENSURE_HSA_INITED();
   GET_STACK_TRACE_FREE;
@@ -915,16 +916,16 @@ INTERCEPTOR(hsa_status_t, hsa_amd_memory_pool_free, void *ptr) {
 }
 
 INTERCEPTOR(hsa_status_t, hsa_amd_agents_allow_access, uint32_t num_agents,
-  const hsa_agent_t *agents, const uint32_t *flags, const void *ptr) {
+            const hsa_agent_t* agents, const uint32_t* flags, const void* ptr) {
   AsanInitFromRtl();
   ENSURE_HSA_INITED();
   GET_STACK_TRACE_FREE;
   return asan_hsa_amd_agents_allow_access(num_agents, agents, flags, ptr,
-    &stack);
+                                          &stack);
 }
 
-INTERCEPTOR(hsa_status_t, hsa_memory_copy, void *dst, const void *src,
-  size_t size) {
+INTERCEPTOR(hsa_status_t, hsa_memory_copy, void* dst, const void* src,
+            size_t size) {
   AsanInitFromRtl();
   ENSURE_HSA_INITED();
   if (flags()->replace_intrin) {
@@ -938,9 +939,9 @@ INTERCEPTOR(hsa_status_t, hsa_memory_copy, void *dst, const void *src,
 }
 
 INTERCEPTOR(hsa_status_t, hsa_amd_memory_async_copy, void* dst,
-  hsa_agent_t dst_agent, const void* src, hsa_agent_t src_agent, size_t size,
-  uint32_t num_dep_signals, const hsa_signal_t* dep_signals,
-  hsa_signal_t completion_signal) {
+            hsa_agent_t dst_agent, const void* src, hsa_agent_t src_agent,
+            size_t size, uint32_t num_dep_signals,
+            const hsa_signal_t* dep_signals, hsa_signal_t completion_signal) {
   AsanInitFromRtl();
   ENSURE_HSA_INITED();
   if (flags()->replace_intrin) {
@@ -951,15 +952,16 @@ INTERCEPTOR(hsa_status_t, hsa_amd_memory_async_copy, void* dst,
     ASAN_WRITE_RANGE(nullptr, dst, size);
   }
   return REAL(hsa_amd_memory_async_copy)(dst, dst_agent, src, src_agent, size,
-    num_dep_signals, dep_signals, completion_signal);
+                                         num_dep_signals, dep_signals,
+                                         completion_signal);
 }
 
-#if HSA_AMD_INTERFACE_VERSION_MINOR>=1
+#    if HSA_AMD_INTERFACE_VERSION_MINOR >= 1
 INTERCEPTOR(hsa_status_t, hsa_amd_memory_async_copy_on_engine, void* dst,
-  hsa_agent_t dst_agent, const void* src, hsa_agent_t src_agent, size_t size,
-  uint32_t num_dep_signals, const hsa_signal_t* dep_signals,
-  hsa_signal_t completion_signal, hsa_amd_sdma_engine_id_t engine_id,
- bool force_copy_on_sdma) {
+            hsa_agent_t dst_agent, const void* src, hsa_agent_t src_agent,
+            size_t size, uint32_t num_dep_signals,
+            const hsa_signal_t* dep_signals, hsa_signal_t completion_signal,
+            hsa_amd_sdma_engine_id_t engine_id, bool force_copy_on_sdma) {
   AsanInitFromRtl();
   ENSURE_HSA_INITED();
   if (flags()->replace_intrin) {
@@ -971,25 +973,25 @@ INTERCEPTOR(hsa_status_t, hsa_amd_memory_async_copy_on_engine, void* dst,
     ASAN_WRITE_RANGE(nullptr, dst, size);
   }
   return REAL(hsa_amd_memory_async_copy_on_engine)(
-    dst, dst_agent, src, src_agent, size, num_dep_signals, dep_signals,
-    completion_signal, engine_id, force_copy_on_sdma);
+      dst, dst_agent, src, src_agent, size, num_dep_signals, dep_signals,
+      completion_signal, engine_id, force_copy_on_sdma);
 }
-#endif
+#    endif
 
 INTERCEPTOR(hsa_status_t, hsa_amd_ipc_memory_create, void* ptr, size_t len,
-  hsa_amd_ipc_memory_t* handle) {
+            hsa_amd_ipc_memory_t* handle) {
   AsanInitFromRtl();
   ENSURE_HSA_INITED();
   return asan_hsa_amd_ipc_memory_create(ptr, len, handle);
 }
 
 INTERCEPTOR(hsa_status_t, hsa_amd_ipc_memory_attach,
-  const hsa_amd_ipc_memory_t* handle, size_t len, uint32_t num_agents,
-  const hsa_agent_t* mapping_agents, void** mapped_ptr) {
+            const hsa_amd_ipc_memory_t* handle, size_t len, uint32_t num_agents,
+            const hsa_agent_t* mapping_agents, void** mapped_ptr) {
   AsanInitFromRtl();
   ENSURE_HSA_INITED();
   return asan_hsa_amd_ipc_memory_attach(handle, len, num_agents, mapping_agents,
-    mapped_ptr);
+                                        mapped_ptr);
 }
 
 INTERCEPTOR(hsa_status_t, hsa_amd_ipc_memory_detach, void* mapped_ptr) {
@@ -1036,9 +1038,9 @@ void InitializeAmdgpuInterceptors() {
   ASAN_INTERCEPT_FUNC(hsa_amd_memory_pool_free);
   ASAN_INTERCEPT_FUNC(hsa_amd_agents_allow_access);
   ASAN_INTERCEPT_FUNC(hsa_amd_memory_async_copy);
-#if HSA_AMD_INTERFACE_VERSION_MINOR>=1
+#    if HSA_AMD_INTERFACE_VERSION_MINOR >= 1
   ASAN_INTERCEPT_FUNC(hsa_amd_memory_async_copy_on_engine);
-#endif
+#    endif
   ASAN_INTERCEPT_FUNC(hsa_amd_ipc_memory_create);
   ASAN_INTERCEPT_FUNC(hsa_amd_ipc_memory_attach);
   ASAN_INTERCEPT_FUNC(hsa_amd_ipc_memory_detach);
@@ -1051,7 +1053,7 @@ void ENSURE_HSA_INITED() {
   if (!REAL(hsa_init))
     InitializeAmdgpuInterceptors();
 }
-#endif
+#  endif
 
 // ---------------------- InitializeAsanInterceptors ---------------- {{{1
 namespace __asan {
@@ -1169,9 +1171,9 @@ void InitializeAsanInterceptors() {
   ASAN_INTERCEPT_FUNC(vfork);
 #  endif
 
-#if SANITIZER_AMDGPU
+#  if SANITIZER_AMDGPU
   InitializeAmdgpuInterceptors();
-#endif
+#  endif
 
   VReport(1, "AddressSanitizer: libc interceptors initialized\n");
 }

``````````

</details>


https://github.com/llvm/llvm-project/pull/192238