[compiler-rt] [llvm] [asan][NFCI] Rename asan_(malloc_)?linux.cpp to ...unix.cpp (PR #132263)

[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 adb57757b9640768e5070e0e3f6b217c774f9205 889126709951d77f65aeb1ed843494bfd0222898 --extensions cpp -- compiler-rt/lib/asan/asan_malloc_unix.cpp compiler-rt/lib/asan/asan_unix.cpp
``````````

</details>

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

``````````diff
diff --git a/compiler-rt/lib/asan/asan_malloc_unix.cpp b/compiler-rt/lib/asan/asan_malloc_unix.cpp
index c9c48cb443..7386d79ef9 100644
--- a/compiler-rt/lib/asan/asan_malloc_unix.cpp
+++ b/compiler-rt/lib/asan/asan_malloc_unix.cpp
@@ -52,62 +52,62 @@ INTERCEPTOR(void, free, void *ptr) {
   asan_free(ptr, &stack, FROM_MALLOC);
 }
 
-#if SANITIZER_INTERCEPT_CFREE
+#  if SANITIZER_INTERCEPT_CFREE
 INTERCEPTOR(void, cfree, void *ptr) {
   if (DlsymAlloc::PointerIsMine(ptr))
     return DlsymAlloc::Free(ptr);
   GET_STACK_TRACE_FREE;
   asan_free(ptr, &stack, FROM_MALLOC);
 }
-#endif // SANITIZER_INTERCEPT_CFREE
+#  endif  // SANITIZER_INTERCEPT_CFREE
 
-INTERCEPTOR(void*, malloc, uptr size) {
+INTERCEPTOR(void *, malloc, uptr size) {
   if (DlsymAlloc::Use())
     return DlsymAlloc::Allocate(size);
   GET_STACK_TRACE_MALLOC;
   return asan_malloc(size, &stack);
 }
 
-INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
+INTERCEPTOR(void *, calloc, uptr nmemb, uptr size) {
   if (DlsymAlloc::Use())
     return DlsymAlloc::Callocate(nmemb, size);
   GET_STACK_TRACE_MALLOC;
   return asan_calloc(nmemb, size, &stack);
 }
 
-INTERCEPTOR(void*, realloc, void *ptr, uptr size) {
+INTERCEPTOR(void *, realloc, void *ptr, uptr size) {
   if (DlsymAlloc::Use() || DlsymAlloc::PointerIsMine(ptr))
     return DlsymAlloc::Realloc(ptr, size);
   GET_STACK_TRACE_MALLOC;
   return asan_realloc(ptr, size, &stack);
 }
 
-#if SANITIZER_INTERCEPT_REALLOCARRAY
-INTERCEPTOR(void*, reallocarray, void *ptr, uptr nmemb, uptr size) {
+#  if SANITIZER_INTERCEPT_REALLOCARRAY
+INTERCEPTOR(void *, reallocarray, void *ptr, uptr nmemb, uptr size) {
   AsanInitFromRtl();
   GET_STACK_TRACE_MALLOC;
   return asan_reallocarray(ptr, nmemb, size, &stack);
 }
-#endif  // SANITIZER_INTERCEPT_REALLOCARRAY
+#  endif  // SANITIZER_INTERCEPT_REALLOCARRAY
 
-#if SANITIZER_INTERCEPT_MEMALIGN
-INTERCEPTOR(void*, memalign, uptr boundary, uptr size) {
+#  if SANITIZER_INTERCEPT_MEMALIGN
+INTERCEPTOR(void *, memalign, uptr boundary, uptr size) {
   GET_STACK_TRACE_MALLOC;
   return asan_memalign(boundary, size, &stack, FROM_MALLOC);
 }
 
-INTERCEPTOR(void*, __libc_memalign, uptr boundary, uptr size) {
+INTERCEPTOR(void *, __libc_memalign, uptr boundary, uptr size) {
   GET_STACK_TRACE_MALLOC;
   return asan_memalign(boundary, size, &stack, FROM_MALLOC);
 }
-#endif // SANITIZER_INTERCEPT_MEMALIGN
+#  endif  // SANITIZER_INTERCEPT_MEMALIGN
 
-#if SANITIZER_INTERCEPT_ALIGNED_ALLOC
-INTERCEPTOR(void*, aligned_alloc, uptr boundary, uptr size) {
+#  if SANITIZER_INTERCEPT_ALIGNED_ALLOC
+INTERCEPTOR(void *, aligned_alloc, uptr boundary, uptr size) {
   GET_STACK_TRACE_MALLOC;
   return asan_aligned_alloc(boundary, size, &stack);
 }
-#endif // SANITIZER_INTERCEPT_ALIGNED_ALLOC
+#  endif  // SANITIZER_INTERCEPT_ALIGNED_ALLOC
 
 INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
   GET_CURRENT_PC_BP_SP;
@@ -115,7 +115,7 @@ INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
   return asan_malloc_usable_size(ptr, pc, bp);
 }
 
-#if SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
+#  if SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 // We avoid including malloc.h for portability reasons.
 // man mallinfo says the fields are "long", but the implementation uses int.
 // It doesn't matter much -- we just need to make sure that the libc's mallinfo
@@ -130,33 +130,29 @@ INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
   return res;
 }
 
-INTERCEPTOR(int, mallopt, int cmd, int value) {
-  return 0;
-}
-#endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
+INTERCEPTOR(int, mallopt, int cmd, int value) { return 0; }
+#  endif  // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 
 INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
   GET_STACK_TRACE_MALLOC;
   return asan_posix_memalign(memptr, alignment, size, &stack);
 }
 
-INTERCEPTOR(void*, valloc, uptr size) {
+INTERCEPTOR(void *, valloc, uptr size) {
   GET_STACK_TRACE_MALLOC;
   return asan_valloc(size, &stack);
 }
 
-#if SANITIZER_INTERCEPT_PVALLOC
-INTERCEPTOR(void*, pvalloc, uptr size) {
+#  if SANITIZER_INTERCEPT_PVALLOC
+INTERCEPTOR(void *, pvalloc, uptr size) {
   GET_STACK_TRACE_MALLOC;
   return asan_pvalloc(size, &stack);
 }
-#endif // SANITIZER_INTERCEPT_PVALLOC
+#  endif  // SANITIZER_INTERCEPT_PVALLOC
 
-INTERCEPTOR(void, malloc_stats, void) {
-  __asan_print_accumulated_stats();
-}
+INTERCEPTOR(void, malloc_stats, void) { __asan_print_accumulated_stats(); }
 
-#if SANITIZER_ANDROID
+#  if SANITIZER_ANDROID
 // Format of __libc_malloc_dispatch has changed in Android L.
 // While we are moving towards a solution that does not depend on bionic
 // internals, here is something to support both K* and L releases.
@@ -177,9 +173,9 @@ struct MallocDebugL {
   uptr (*malloc_usable_size)(void *mem);
   void *(*memalign)(uptr alignment, uptr bytes);
   int (*posix_memalign)(void **memptr, uptr alignment, uptr size);
-  void* (*pvalloc)(uptr size);
+  void *(*pvalloc)(uptr size);
   void *(*realloc)(void *oldMem, uptr bytes);
-  void* (*valloc)(uptr size);
+  void *(*valloc)(uptr size);
 };
 
 alignas(32) const MallocDebugK asan_malloc_dispatch_k = {
@@ -187,9 +183,15 @@ alignas(32) const MallocDebugK asan_malloc_dispatch_k = {
     WRAP(realloc), WRAP(memalign), WRAP(malloc_usable_size)};
 
 alignas(32) const MallocDebugL asan_malloc_dispatch_l = {
-    WRAP(calloc),         WRAP(free),               WRAP(mallinfo),
-    WRAP(malloc),         WRAP(malloc_usable_size), WRAP(memalign),
-    WRAP(posix_memalign), WRAP(pvalloc),            WRAP(realloc),
+    WRAP(calloc),
+    WRAP(free),
+    WRAP(mallinfo),
+    WRAP(malloc),
+    WRAP(malloc_usable_size),
+    WRAP(memalign),
+    WRAP(posix_memalign),
+    WRAP(pvalloc),
+    WRAP(realloc),
     WRAP(valloc)};
 
 namespace __asan {
@@ -208,13 +210,12 @@ void ReplaceSystemMalloc() {
 }
 }  // namespace __asan
 
-#else  // SANITIZER_ANDROID
+#  else   // SANITIZER_ANDROID
 
 namespace __asan {
-void ReplaceSystemMalloc() {
-}
+void ReplaceSystemMalloc() {}
 }  // namespace __asan
-#endif  // SANITIZER_ANDROID
+#  endif  // SANITIZER_ANDROID
 
 #endif  // SANITIZER_FREEBSD || SANITIZER_FUCHSIA || SANITIZER_LINUX ||
         // SANITIZER_NETBSD || SANITIZER_SOLARIS
diff --git a/compiler-rt/lib/asan/asan_unix.cpp b/compiler-rt/lib/asan/asan_unix.cpp
index 527bb7e92c..9fc4a84bd1 100644
--- a/compiler-rt/lib/asan/asan_unix.cpp
+++ b/compiler-rt/lib/asan/asan_unix.cpp
@@ -112,7 +112,7 @@ void FlushUnneededASanShadowMemory(uptr p, uptr size) {
 }
 
 void ReExecWithoutASLR() {
-#    if SANITIZER_LINUX
+#  if SANITIZER_LINUX
   // ASLR personality check.
   // Caution: 'personality' is sometimes forbidden by sandboxes, so only call
   // this function as a last resort (when the memory mapping is incompatible
@@ -141,7 +141,7 @@ void ReExecWithoutASLR() {
 
     ReExec();
   }
-#    endif
+#  endif
 }
 
 #  if SANITIZER_ANDROID

``````````

</details>


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