Fix clang-format noise.

Author: ampandey-AMD

compiler-rt/lib/asan/asan_allocator.cpp

@@ -1409,36 +1409,36 @@ namespace __asan {
 static const size_t kPageSize_ = 4096;
 
 hsa_status_t asan_hsa_amd_memory_pool_allocate(
-    hsa_amd_memory_pool_t memory_pool, size_t size, uint32_t flags, void** ptr,
-    BufferedStackTrace* stack) {
+  hsa_amd_memory_pool_t memory_pool, size_t size, uint32_t flags, void **ptr,
+  BufferedStackTrace *stack) {
   AmdgpuAllocationInfo aa_info;
   aa_info.alloc_func =
-      reinterpret_cast<void*>(asan_hsa_amd_memory_pool_allocate);
+    reinterpret_cast<void *>(asan_hsa_amd_memory_pool_allocate);
   aa_info.memory_pool = memory_pool;
   aa_info.size = size;
   aa_info.flags = flags;
   aa_info.ptr = nullptr;
-  SetErrnoOnNull(*ptr = instance.Allocate(size, kPageSize_, stack, FROM_MALLOC,
-                                          false, &aa_info));
+  SetErrnoOnNull(*ptr = instance.Allocate(size, kPageSize_, stack,
+                                          FROM_MALLOC, false, &aa_info));
   return aa_info.status;
 }
 
-hsa_status_t asan_hsa_amd_memory_pool_free(void* ptr,
-                                           BufferedStackTrace* stack) {
-  void* p = get_allocator().GetBlockBegin(ptr);
+hsa_status_t asan_hsa_amd_memory_pool_free(
+  void *ptr,
+  BufferedStackTrace *stack) {
+  void *p = get_allocator().GetBlockBegin(ptr);
   if (p) {
     instance.Deallocate(ptr, 0, 0, stack, FROM_MALLOC);
     return HSA_STATUS_SUCCESS;
   }
   return REAL(hsa_amd_memory_pool_free)(ptr);
 }
 
-hsa_status_t asan_hsa_amd_agents_allow_access(uint32_t num_agents,
-                                              const hsa_agent_t* agents,
-                                              const uint32_t* flags,
-                                              const void* ptr,
-                                              BufferedStackTrace* stack) {
-  void* p = get_allocator().GetBlockBegin(ptr);
+hsa_status_t asan_hsa_amd_agents_allow_access(
+  uint32_t num_agents, const hsa_agent_t *agents, const uint32_t *flags,
+  const void *ptr,
+  BufferedStackTrace *stack) {
+  void *p = get_allocator().GetBlockBegin(ptr);
   return REAL(hsa_amd_agents_allow_access)(num_agents, agents, flags,
                                            p ? p : ptr);
 }
@@ -1448,45 +1448,44 @@ hsa_status_t asan_hsa_amd_agents_allow_access(uint32_t num_agents,
 // is always one kPageSize_
 // IPC calls use static_assert to make sure kMetadataSize = 0
 //
-#  if SANITIZER_CAN_USE_ALLOCATOR64
+#if SANITIZER_CAN_USE_ALLOCATOR64
 static struct AP64<LocalAddressSpaceView> AP_;
-#  else
+#else
 static struct AP32<LocalAddressSpaceView> AP_;
-#  endif
+#endif
 
-hsa_status_t asan_hsa_amd_ipc_memory_create(void* ptr, size_t len,
-                                            hsa_amd_ipc_memory_t* handle) {
-  void* ptr_;
+hsa_status_t asan_hsa_amd_ipc_memory_create(void *ptr, size_t len,
+  hsa_amd_ipc_memory_t * handle) {
+  void *ptr_;
   size_t len_ = get_allocator().GetActuallyAllocatedSize(ptr);
   if (len_) {
     static_assert(AP_.kMetadataSize == 0, "Expression below requires this");
-    ptr_ = reinterpret_cast<void*>(reinterpret_cast<uptr>(ptr) - kPageSize_);
+    ptr_ = reinterpret_cast<void *>(reinterpret_cast<uptr>(ptr) - kPageSize_);
   } else {
     ptr_ = ptr;
     len_ = len;
   }
   return REAL(hsa_amd_ipc_memory_create)(ptr_, len_, handle);
 }
 
-hsa_status_t asan_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) {
+hsa_status_t asan_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) {
   static_assert(AP_.kMetadataSize == 0, "Expression below requires this");
   size_t len_ = len + kPageSize_;
   hsa_status_t status = REAL(hsa_amd_ipc_memory_attach)(
-      handle, len_, num_agents, mapping_agents, mapped_ptr);
+    handle, len_, num_agents, mapping_agents, mapped_ptr);
   if (status == HSA_STATUS_SUCCESS && mapped_ptr) {
-    *mapped_ptr = reinterpret_cast<void*>(reinterpret_cast<uptr>(*mapped_ptr) +
-                                          kPageSize_);
+    *mapped_ptr = reinterpret_cast<void *>(reinterpret_cast<uptr>(*mapped_ptr) +
+                                           kPageSize_);
   }
   return status;
 }
 
-hsa_status_t asan_hsa_amd_ipc_memory_detach(void* mapped_ptr) {
+hsa_status_t asan_hsa_amd_ipc_memory_detach(void *mapped_ptr) {
   static_assert(AP_.kMetadataSize == 0, "Expression below requires this");
-  void* mapped_ptr_ =
-      reinterpret_cast<void*>(reinterpret_cast<uptr>(mapped_ptr) - kPageSize_);
+  void *mapped_ptr_ =
+      reinterpret_cast<void *>(reinterpret_cast<uptr>(mapped_ptr) - kPageSize_);
   return REAL(hsa_amd_ipc_memory_detach)(mapped_ptr_);
 }
 

compiler-rt/lib/asan/asan_interceptors.cpp

@@ -950,6 +950,7 @@ INTERCEPTOR(hsa_status_t, hsa_amd_vmem_address_free, void* ptr, size_t size) {
 
 INTERCEPTOR(hsa_status_t, hsa_init) {
   AsanInitFromRtl();
+  ENSURE_HSA_INITED();
   return asan_hsa_init();
 }
 

compiler-rt/lib/sanitizer_common/sanitizer_allocator_amdgpu.cpp

@@ -11,29 +11,28 @@
 //===----------------------------------------------------------------------===//
 #if SANITIZER_AMDGPU
 #  include <dlfcn.h>  // For dlsym
-
 #  include "sanitizer_allocator.h"
 #  include "sanitizer_atomic.h"
 
 namespace __sanitizer {
 struct HsaFunctions {
   // ---------------- Memory Functions ----------------
   hsa_status_t (*memory_pool_allocate)(hsa_amd_memory_pool_t memory_pool,
-                                       size_t size, uint32_t flags, void** ptr);
-  hsa_status_t (*memory_pool_free)(void* ptr);
-  hsa_status_t (*pointer_info)(void* ptr, hsa_amd_pointer_info_t* info,
-                               void* (*alloc)(size_t),
-                               uint32_t* num_agents_accessible,
-                               hsa_agent_t** accessible);
+                                       size_t size, uint32_t flags, void **ptr);
+  hsa_status_t (*memory_pool_free)(void *ptr);
+  hsa_status_t (*pointer_info)(void *ptr, hsa_amd_pointer_info_t *info,
+                               void *(*alloc)(size_t),
+                               uint32_t *num_agents_accessible,
+                               hsa_agent_t **accessible);
   hsa_status_t (*vmem_address_reserve_align)(void** ptr, size_t size,
                                              uint64_t address,
                                              uint64_t alignment,
                                              uint64_t flags);
-  hsa_status_t (*vmem_address_free)(void* ptr, size_t size);
+  hsa_status_t (*vmem_address_free)(void *ptr, size_t size);
 
   // ----------------Event Functions ----------------
   hsa_status_t (*register_system_event_handler)(
-      hsa_amd_system_event_callback_t callback, void* data);
+      hsa_amd_system_event_callback_t callback, void *data);
 };
 
 static HsaFunctions hsa_amd;