[compiler-rt] [msan] Add interceptors for fortified memory functions (__memcpy_chk, etc.) (PR #206702)

[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/test/msan/Linux/fortify.cpp compiler-rt/lib/msan/msan_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/msan/msan_interceptors.cpp b/compiler-rt/lib/msan/msan_interceptors.cpp
index 862ecd60a..6a5565564 100644
--- a/compiler-rt/lib/msan/msan_interceptors.cpp
+++ b/compiler-rt/lib/msan/msan_interceptors.cpp
@@ -64,13 +64,12 @@ DECLARE_REAL(void *, memcpy, void *dest, const void *src, SIZE_T n)
 DECLARE_REAL(void *, memset, void *dest, int c, SIZE_T n)
 
 #if SANITIZER_GLIBC
-DECLARE_REAL(void *, __memcpy_chk, void *dest, const void *src, SIZE_T n,
+DECLARE_REAL(void*, __memcpy_chk, void* dest, const void* src, SIZE_T n,
              SIZE_T dest_size)
-DECLARE_REAL(void *, __memmove_chk, void *dest, const void *src, SIZE_T n,
+DECLARE_REAL(void*, __memmove_chk, void* dest, const void* src, SIZE_T n,
              SIZE_T dest_size)
-DECLARE_REAL(void *, __memset_chk, void *dest, int c, SIZE_T n,
-             SIZE_T dest_size)
-DECLARE_REAL(void *, __mempcpy_chk, void *dest, const void *src, SIZE_T n,
+DECLARE_REAL(void*, __memset_chk, void* dest, int c, SIZE_T n, SIZE_T dest_size)
+DECLARE_REAL(void*, __mempcpy_chk, void* dest, const void* src, SIZE_T n,
              SIZE_T dest_size)
 #endif
 
@@ -170,7 +169,7 @@ INTERCEPTOR(void *, bcopy, const void *src, void *dest, SIZE_T n) {
 }
 
 #if SANITIZER_GLIBC
-INTERCEPTOR(void *, __memcpy_chk, void *dest, const void *src, SIZE_T n,
+INTERCEPTOR(void*, __memcpy_chk, void* dest, const void* src, SIZE_T n,
             SIZE_T dest_size) {
   if (!msan_inited)
     return internal_memcpy(dest, src, n);
@@ -178,17 +177,17 @@ INTERCEPTOR(void *, __memcpy_chk, void *dest, const void *src, SIZE_T n,
     return REAL(__memcpy_chk)(dest, src, n, dest_size);
   ENSURE_MSAN_INITED();
   GET_STORE_STACK_TRACE;
-  void *res = REAL(__memcpy_chk)(dest, src, n, dest_size);
+  void* res = REAL(__memcpy_chk)(dest, src, n, dest_size);
   CopyShadowAndOrigin(dest, src, n, &stack);
   return res;
 }
-#define MSAN_MAYBE_INTERCEPT___MEMCPY_CHK INTERCEPT_FUNCTION(__memcpy_chk)
+#  define MSAN_MAYBE_INTERCEPT___MEMCPY_CHK INTERCEPT_FUNCTION(__memcpy_chk)
 #else
-#define MSAN_MAYBE_INTERCEPT___MEMCPY_CHK
+#  define MSAN_MAYBE_INTERCEPT___MEMCPY_CHK
 #endif
 
 #if SANITIZER_GLIBC
-INTERCEPTOR(void *, __memmove_chk, void *dest, const void *src, SIZE_T n,
+INTERCEPTOR(void*, __memmove_chk, void* dest, const void* src, SIZE_T n,
             SIZE_T dest_size) {
   if (!msan_inited)
     return internal_memmove(dest, src, n);
@@ -196,50 +195,50 @@ INTERCEPTOR(void *, __memmove_chk, void *dest, const void *src, SIZE_T n,
     return REAL(__memmove_chk)(dest, src, n, dest_size);
   ENSURE_MSAN_INITED();
   GET_STORE_STACK_TRACE;
-  void *res = REAL(__memmove_chk)(dest, src, n, dest_size);
+  void* res = REAL(__memmove_chk)(dest, src, n, dest_size);
   MoveShadowAndOrigin(dest, src, n, &stack);
   return res;
 }
-#define MSAN_MAYBE_INTERCEPT___MEMMOVE_CHK INTERCEPT_FUNCTION(__memmove_chk)
+#  define MSAN_MAYBE_INTERCEPT___MEMMOVE_CHK INTERCEPT_FUNCTION(__memmove_chk)
 #else
-#define MSAN_MAYBE_INTERCEPT___MEMMOVE_CHK
+#  define MSAN_MAYBE_INTERCEPT___MEMMOVE_CHK
 #endif
 
 #if SANITIZER_GLIBC
-INTERCEPTOR(void *, __memset_chk, void *dest, int c, SIZE_T n,
+INTERCEPTOR(void*, __memset_chk, void* dest, int c, SIZE_T n,
             SIZE_T dest_size) {
   if (!msan_inited)
     return internal_memset(dest, c, n);
   if (msan_init_is_running || __msan::IsInSymbolizerOrUnwider())
     return REAL(__memset_chk)(dest, c, n, dest_size);
   ENSURE_MSAN_INITED();
-  void *res = REAL(__memset_chk)(dest, c, n, dest_size);
+  void* res = REAL(__memset_chk)(dest, c, n, dest_size);
   __msan_unpoison(dest, n);
   return res;
 }
-#define MSAN_MAYBE_INTERCEPT___MEMSET_CHK INTERCEPT_FUNCTION(__memset_chk)
+#  define MSAN_MAYBE_INTERCEPT___MEMSET_CHK INTERCEPT_FUNCTION(__memset_chk)
 #else
-#define MSAN_MAYBE_INTERCEPT___MEMSET_CHK
+#  define MSAN_MAYBE_INTERCEPT___MEMSET_CHK
 #endif
 
 #if SANITIZER_GLIBC
-INTERCEPTOR(void *, __mempcpy_chk, void *dest, const void *src, SIZE_T n,
+INTERCEPTOR(void*, __mempcpy_chk, void* dest, const void* src, SIZE_T n,
             SIZE_T dest_size) {
   if (!msan_inited) {
     internal_memcpy(dest, src, n);
-    return (char *)dest + n;
+    return (char*)dest + n;
   }
   if (msan_init_is_running || __msan::IsInSymbolizerOrUnwider())
     return REAL(__mempcpy_chk)(dest, src, n, dest_size);
   ENSURE_MSAN_INITED();
   GET_STORE_STACK_TRACE;
-  void *res = REAL(__mempcpy_chk)(dest, src, n, dest_size);
+  void* res = REAL(__mempcpy_chk)(dest, src, n, dest_size);
   CopyShadowAndOrigin(dest, src, n, &stack);
   return res;
 }
-#define MSAN_MAYBE_INTERCEPT___MEMPCPY_CHK INTERCEPT_FUNCTION(__mempcpy_chk)
+#  define MSAN_MAYBE_INTERCEPT___MEMPCPY_CHK INTERCEPT_FUNCTION(__mempcpy_chk)
 #else
-#define MSAN_MAYBE_INTERCEPT___MEMPCPY_CHK
+#  define MSAN_MAYBE_INTERCEPT___MEMPCPY_CHK
 #endif
 
 INTERCEPTOR(int, posix_memalign, void **memptr, SIZE_T alignment, SIZE_T size) {
diff --git a/compiler-rt/test/msan/Linux/fortify.cpp b/compiler-rt/test/msan/Linux/fortify.cpp
index 4568aa182..d20559635 100644
--- a/compiler-rt/test/msan/Linux/fortify.cpp
+++ b/compiler-rt/test/msan/Linux/fortify.cpp
@@ -4,13 +4,16 @@
 // REQUIRES: glibc
 
 #include <assert.h>
-#include <string.h>
 #include <sanitizer/msan_interface.h>
+#include <string.h>
 
-extern "C" void *__memcpy_chk(void *dest, const void *src, size_t len, size_t destlen);
-extern "C" void *__memmove_chk(void *dest, const void *src, size_t len, size_t destlen);
+extern "C" void *__memcpy_chk(void *dest, const void *src, size_t len,
+                              size_t destlen);
+extern "C" void *__memmove_chk(void *dest, const void *src, size_t len,
+                               size_t destlen);
 extern "C" void *__memset_chk(void *dest, int c, size_t len, size_t destlen);
-extern "C" void *__mempcpy_chk(void *dest, const void *src, size_t len, size_t destlen);
+extern "C" void *__mempcpy_chk(void *dest, const void *src, size_t len,
+                               size_t destlen);
 
 int main(int argc, char *argv[]) {
   // Test __memcpy_chk shadow propagation
@@ -23,8 +26,10 @@ int main(int argc, char *argv[]) {
     src[2] = 2;
     __memcpy_chk(dest, src, 5, sizeof(dest));
     assert(__msan_test_shadow(dest, 5) == 0); // dest[0] is uninitialized
-    assert(__msan_test_shadow(dest + 1, 4) == 2); // dest[1], dest[2] are initialized, dest[3..4] are uninitialized
-    assert(__msan_test_shadow(dest + 5, 5) == -1); // dest[5..9] remain initialized
+    assert(__msan_test_shadow(dest + 1, 4) ==
+           2); // dest[1], dest[2] are initialized, dest[3..4] are uninitialized
+    assert(__msan_test_shadow(dest + 5, 5) ==
+           -1); // dest[5..9] remain initialized
   }
 
   // Test __memmove_chk shadow propagation
@@ -46,7 +51,8 @@ int main(int argc, char *argv[]) {
     char dest[10];
     __msan_poison(dest, sizeof(dest));
     __memset_chk(dest, 42, 5, sizeof(dest));
-    assert(__msan_test_shadow(dest, 10) == 5); // first 5 bytes are initialized, remaining 5 are uninitialized
+    assert(__msan_test_shadow(dest, 10) ==
+           5); // first 5 bytes are initialized, remaining 5 are uninitialized
   }
 
   // Test __mempcpy_chk shadow propagation

``````````

</details>


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