[compiler-rt] [sanitizer] Add type __sanitizer::ssize (PR #116957)

via llvm-commits llvm-commits at lists.llvm.org
Thu Nov 21 01:01:33 PST 2024


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 0a1795f781163a8e7b72fee492f87ab27d5e3995 4fde02d3e71d3c7849d446c46336a12c53209a26 --extensions cpp,inc,h -- compiler-rt/lib/asan/asan_interceptors.cpp compiler-rt/lib/asan/asan_interceptors.h compiler-rt/lib/asan/asan_interceptors_memintrinsics.h compiler-rt/lib/interception/interception.h compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_memintrinsics.inc compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h
``````````

</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 c744d8d718..3d8c2ee70b 100644
--- a/compiler-rt/lib/asan/asan_interceptors.cpp
+++ b/compiler-rt/lib/asan/asan_interceptors.cpp
@@ -57,7 +57,7 @@ namespace __asan {
     ASAN_READ_STRING_OF_LEN((ctx), (s), internal_strlen(s), (n))
 
 static inline usize MaybeRealStrnlen(const char *s, usize maxlen) {
-#if SANITIZER_INTERCEPT_STRNLEN
+#  if SANITIZER_INTERCEPT_STRNLEN
   if (REAL(strnlen)) {
     return REAL(strnlen)(s, maxlen);
   }
@@ -529,24 +529,24 @@ DEFINE_REAL(char*, index, const char *string, int c)
     return REAL(strcat)(to, from);
   }
 
-INTERCEPTOR(char*, strncat, char *to, const char *from, usize size) {
-  void *ctx;
-  ASAN_INTERCEPTOR_ENTER(ctx, strncat);
-  AsanInitFromRtl();
-  if (flags()->replace_str) {
-    usize from_length = MaybeRealStrnlen(from, size);
-    usize copy_length = Min(size, from_length + 1);
-    ASAN_READ_RANGE(ctx, from, copy_length);
-    usize to_length = internal_strlen(to);
-    ASAN_READ_STRING_OF_LEN(ctx, to, to_length, to_length);
-    ASAN_WRITE_RANGE(ctx, to + to_length, from_length + 1);
-    if (from_length > 0) {
-      CHECK_RANGES_OVERLAP("strncat", to, to_length + copy_length + 1,
-                           from, copy_length);
+  INTERCEPTOR(char *, strncat, char *to, const char *from, usize size) {
+    void *ctx;
+    ASAN_INTERCEPTOR_ENTER(ctx, strncat);
+    AsanInitFromRtl();
+    if (flags()->replace_str) {
+      usize from_length = MaybeRealStrnlen(from, size);
+      usize copy_length = Min(size, from_length + 1);
+      ASAN_READ_RANGE(ctx, from, copy_length);
+      usize to_length = internal_strlen(to);
+      ASAN_READ_STRING_OF_LEN(ctx, to, to_length, to_length);
+      ASAN_WRITE_RANGE(ctx, to + to_length, from_length + 1);
+      if (from_length > 0) {
+        CHECK_RANGES_OVERLAP("strncat", to, to_length + copy_length + 1, from,
+                             copy_length);
+      }
     }
+    return REAL(strncat)(to, from, size);
   }
-  return REAL(strncat)(to, from, size);
-}
 
 INTERCEPTOR(char *, strcpy, char *to, const char *from) {
   void *ctx;
@@ -617,7 +617,7 @@ INTERCEPTOR(char*, __strdup, const char *s) {
 }
 #endif // ASAN_INTERCEPT___STRDUP
 
-INTERCEPTOR(char*, strncpy, char *to, const char *from, usize size) {
+INTERCEPTOR(char *, strncpy, char *to, const char *from, usize size) {
   void *ctx;
   ASAN_INTERCEPTOR_ENTER(ctx, strncpy);
   AsanInitFromRtl();
diff --git a/compiler-rt/lib/asan/asan_interceptors.h b/compiler-rt/lib/asan/asan_interceptors.h
index 3e2386eaf8..2203da9a6a 100644
--- a/compiler-rt/lib/asan/asan_interceptors.h
+++ b/compiler-rt/lib/asan/asan_interceptors.h
@@ -127,7 +127,7 @@ void InitializePlatformInterceptors();
 DECLARE_REAL(int, memcmp, const void *a1, const void *a2, SIZE_T size)
 DECLARE_REAL(char*, strchr, const char *str, int c)
 DECLARE_REAL(SIZE_T, strlen, const char *s)
-DECLARE_REAL(char*, strncpy, char *to, const char *from, SIZE_T size)
+DECLARE_REAL(char *, strncpy, char *to, const char *from, SIZE_T size)
 DECLARE_REAL(SIZE_T, strnlen, const char *s, SIZE_T maxlen)
 DECLARE_REAL(char*, strstr, const char *s1, const char *s2)
 
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc
index 3ed8af1675..08831da010 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc
@@ -342,19 +342,19 @@ extern const short *_tolower_tab_;
 #endif
 
 #ifndef COMMON_INTERCEPTOR_STRNDUP_IMPL
-#define COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size)                         \
-  COMMON_INTERCEPTOR_ENTER(ctx, strndup, s, size);                            \
-  usize copy_length = internal_strnlen(s, size);                              \
-  char *new_mem = (char *)WRAP(malloc)(copy_length + 1);                      \
-  if (common_flags()->intercept_strndup) {                                    \
-    COMMON_INTERCEPTOR_READ_STRING(ctx, s, Min(size, copy_length + 1));       \
-  }                                                                           \
-  if (new_mem) {                                                              \
-    COMMON_INTERCEPTOR_COPY_STRING(ctx, new_mem, s, copy_length);             \
-    internal_memcpy(new_mem, s, copy_length);                                 \
-    new_mem[copy_length] = '\0';                                              \
-  }                                                                           \
-  return new_mem;
+#  define COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size)                   \
+    COMMON_INTERCEPTOR_ENTER(ctx, strndup, s, size);                      \
+    usize copy_length = internal_strnlen(s, size);                        \
+    char *new_mem = (char *)WRAP(malloc)(copy_length + 1);                \
+    if (common_flags()->intercept_strndup) {                              \
+      COMMON_INTERCEPTOR_READ_STRING(ctx, s, Min(size, copy_length + 1)); \
+    }                                                                     \
+    if (new_mem) {                                                        \
+      COMMON_INTERCEPTOR_COPY_STRING(ctx, new_mem, s, copy_length);       \
+      internal_memcpy(new_mem, s, copy_length);                           \
+      new_mem[copy_length] = '\0';                                        \
+    }                                                                     \
+    return new_mem;
 #endif
 
 #ifndef COMMON_INTERCEPTOR_STRERROR
@@ -445,21 +445,21 @@ INTERCEPTOR(SIZE_T, strnlen, const char *s, SIZE_T maxlen) {
 #endif
 
 #if SANITIZER_INTERCEPT_STRNDUP
-INTERCEPTOR(char*, strndup, const char *s, usize size) {
+INTERCEPTOR(char *, strndup, const char *s, usize size) {
   void *ctx;
   COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size);
 }
-#define INIT_STRNDUP COMMON_INTERCEPT_FUNCTION(strndup)
+#  define INIT_STRNDUP COMMON_INTERCEPT_FUNCTION(strndup)
 #else
 #define INIT_STRNDUP
 #endif // SANITIZER_INTERCEPT_STRNDUP
 
 #if SANITIZER_INTERCEPT___STRNDUP
-INTERCEPTOR(char*, __strndup, const char *s, usize size) {
+INTERCEPTOR(char *, __strndup, const char *s, usize size) {
   void *ctx;
   COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size);
 }
-#define INIT___STRNDUP COMMON_INTERCEPT_FUNCTION(__strndup)
+#  define INIT___STRNDUP COMMON_INTERCEPT_FUNCTION(__strndup)
 #else
 #define INIT___STRNDUP
 #endif // SANITIZER_INTERCEPT___STRNDUP
@@ -540,8 +540,8 @@ INTERCEPTOR(int, strncmp, const char *s1, const char *s2, usize size) {
   return result;
 }
 
-#define INIT_STRCMP COMMON_INTERCEPT_FUNCTION(strcmp)
-#define INIT_STRNCMP COMMON_INTERCEPT_FUNCTION(strncmp)
+#  define INIT_STRCMP COMMON_INTERCEPT_FUNCTION(strcmp)
+#  define INIT_STRNCMP COMMON_INTERCEPT_FUNCTION(strncmp)
 #else
 #define INIT_STRCMP
 #define INIT_STRNCMP
@@ -613,10 +613,10 @@ INTERCEPTOR(int, strncasecmp, const char *s1, const char *s2, SIZE_T size) {
 #if SANITIZER_INTERCEPT_STRSTR || SANITIZER_INTERCEPT_STRCASESTR
 static inline void StrstrCheck(void *ctx, char *r, const char *s1,
                                const char *s2) {
-    usize len1 = internal_strlen(s1);
-    usize len2 = internal_strlen(s2);
-    COMMON_INTERCEPTOR_READ_STRING(ctx, s1, r ? r - s1 + len2 : len1 + 1);
-    COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, len2 + 1);
+  usize len1 = internal_strlen(s1);
+  usize len2 = internal_strlen(s2);
+  COMMON_INTERCEPTOR_READ_STRING(ctx, s1, r ? r - s1 + len2 : len1 + 1);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, len2 + 1);
 }
 #endif
 
@@ -879,7 +879,7 @@ INTERCEPTOR(int, memcmp, const void *a1, const void *a2, usize size) {
   return MemcmpInterceptorCommon(ctx, REAL(memcmp), a1, a2, size);
 }
 
-#define INIT_MEMCMP COMMON_INTERCEPT_FUNCTION(memcmp)
+#  define INIT_MEMCMP COMMON_INTERCEPT_FUNCTION(memcmp)
 #else
 #define INIT_MEMCMP
 #endif
@@ -893,7 +893,7 @@ INTERCEPTOR(int, bcmp, const void *a1, const void *a2, usize size) {
   return MemcmpInterceptorCommon(ctx, REAL(bcmp), a1, a2, size);
 }
 
-#define INIT_BCMP COMMON_INTERCEPT_FUNCTION(bcmp)
+#  define INIT_BCMP COMMON_INTERCEPT_FUNCTION(bcmp)
 #else
 #define INIT_BCMP
 #endif
@@ -1138,7 +1138,8 @@ INTERCEPTOR(SSIZE_T, write, int fd, void *ptr, SIZE_T count) {
 #endif
 
 #if SANITIZER_INTERCEPT_FWRITE
-INTERCEPTOR(SIZE_T, fwrite, const void *p, usize size, usize nmemb, void *file) {
+INTERCEPTOR(SIZE_T, fwrite, const void *p, usize size, usize nmemb,
+            void *file) {
   // libc file streams can call user-supplied functions, see fopencookie.
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, fwrite, p, size, nmemb, file);
@@ -1146,7 +1147,7 @@ INTERCEPTOR(SIZE_T, fwrite, const void *p, usize size, usize nmemb, void *file)
   if (res > 0) COMMON_INTERCEPTOR_READ_RANGE(ctx, p, res * size);
   return res;
 }
-#define INIT_FWRITE COMMON_INTERCEPT_FUNCTION(fwrite)
+#  define INIT_FWRITE COMMON_INTERCEPT_FUNCTION(fwrite)
 #else
 #define INIT_FWRITE
 #endif
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_memintrinsics.inc b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_memintrinsics.inc
index 1565a49414..8011c8517e 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_memintrinsics.inc
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_memintrinsics.inc
@@ -87,7 +87,7 @@ INTERCEPTOR(void *, memset, void *dst, int v, usize size) {
   COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, dst, v, size);
 }
 
-#define INIT_MEMSET COMMON_INTERCEPT_FUNCTION(memset)
+#  define INIT_MEMSET COMMON_INTERCEPT_FUNCTION(memset)
 #else
 #define INIT_MEMSET
 #endif
@@ -98,7 +98,7 @@ INTERCEPTOR(void *, memmove, void *dst, const void *src, usize size) {
   COMMON_INTERCEPTOR_MEMMOVE_IMPL(ctx, dst, src, size);
 }
 
-#define INIT_MEMMOVE COMMON_INTERCEPT_FUNCTION(memmove)
+#  define INIT_MEMMOVE COMMON_INTERCEPT_FUNCTION(memmove)
 #else
 #define INIT_MEMMOVE
 #endif
@@ -118,15 +118,15 @@ INTERCEPTOR(void *, memcpy, void *dst, const void *src, usize size) {
 #endif
 }
 
-#define INIT_MEMCPY                                  \
-  do {                                               \
-    if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) { \
-      COMMON_INTERCEPT_FUNCTION(memcpy);             \
-    } else {                                         \
-      ASSIGN_REAL(memcpy, memmove);                  \
-    }                                                \
-    CHECK(REAL(memcpy));                             \
-  } while (false)
+#  define INIT_MEMCPY                                  \
+    do {                                               \
+      if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) { \
+        COMMON_INTERCEPT_FUNCTION(memcpy);             \
+      } else {                                         \
+        ASSIGN_REAL(memcpy, memmove);                  \
+      }                                                \
+      CHECK(REAL(memcpy));                             \
+    } while (false)
 
 #else
 #define INIT_MEMCPY
@@ -194,19 +194,19 @@ INTERCEPTOR(void *, __aeabi_memclr8, void *block, usize size) {
   COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, block, 0, size);
 }
 
-#define INIT_AEABI_MEM                         \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memmove);  \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memmove4); \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memmove8); \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memcpy);   \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memcpy4);  \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memcpy8);  \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memset);   \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memset4);  \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memset8);  \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memclr);   \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memclr4);  \
-  COMMON_INTERCEPT_FUNCTION(__aeabi_memclr8);
+#  define INIT_AEABI_MEM                         \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memmove);  \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memmove4); \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memmove8); \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memcpy);   \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memcpy4);  \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memcpy8);  \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memset);   \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memset4);  \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memset8);  \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memclr);   \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memclr4);  \
+    COMMON_INTERCEPT_FUNCTION(__aeabi_memclr8);
 #else
 #define INIT_AEABI_MEM
 #endif  // SANITIZER_INTERCEPT_AEABI_MEM
@@ -216,7 +216,7 @@ INTERCEPTOR(void *, __bzero, void *block, usize size) {
   void *ctx;
   COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, block, 0, size);
 }
-#define INIT___BZERO COMMON_INTERCEPT_FUNCTION(__bzero);
+#  define INIT___BZERO COMMON_INTERCEPT_FUNCTION(__bzero);
 #else
 #define INIT___BZERO
 #endif  // SANITIZER_INTERCEPT___BZERO
@@ -226,7 +226,7 @@ INTERCEPTOR(void *, bzero, void *block, usize size) {
   void *ctx;
   COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, block, 0, size);
 }
-#define INIT_BZERO COMMON_INTERCEPT_FUNCTION(bzero);
+#  define INIT_BZERO COMMON_INTERCEPT_FUNCTION(bzero);
 #else
 #define INIT_BZERO
 #endif  // SANITIZER_INTERCEPT_BZERO

``````````

</details>


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


More information about the llvm-commits mailing list