[Sanitizers] intercept memset_pattern macOs api

[wrotki]

I wonder why the implementation is different from memset interceptor, looking at sanitizer_common_interceptors(868):

#if SANITIZER_INTERCEPT_MEMSET
INTERCEPTOR(void *, memset, void *dst, int v, uptr size) {

void *ctx;
COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, dst, v, size);

}

#define INIT_MEMSET COMMON_INTERCEPT_FUNCTION(memset)
#else
#define INIT_MEMSET

#endif

Common sense tells me that memset and memset_patternx should be handled in roughly the same way (the difference being one byte versus multibyte pattern). Also, perhaps the code for them should be colocated, i.e. code starting with '#if SANITIZER_INTERCEPT_MEMSET_PATTERN' should perhaps immediately follow the '#if SANITIZER_INTERCEPT_MEMSET' sequence.

[wrotki]

I am actually not very familiar with the memset_pattern API - is it available on every OS? What about various OS versions, when was is introduced? I see above that the diff build failed on Debian (not sure if that's reliable, but it's a hint).

[yln]

Can you give an explanation of the scenario (false positive, false negative?) which this patch fixes. Please put this information also in the commit message.

Was this scenario LLVM rewriting/specializing a vanilla memset_pattern() call to memset_patternXX() for optimization? Can we add such an "integration style" test? Maybe we can assert in a LIT RUN: nm <binary> | grep memset_pattern4 ... line that it was rewritten.

Thanks! :)

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

   COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, dst, v, size);
 }
 
 #define INIT_MEMSET COMMON_INTERCEPT_FUNCTION(memset)
 #else
 #define INIT_MEMSET
 #endif
 
+#if SANITIZER_INTERCEPT_MEMSET_PATTERN
+INTERCEPTOR(void, memset_pattern4, void *s, const void *p, SIZE_T n) {
+  void *ctx;
+  if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED) {
+    internal_memset_pattern4(s, p, n);
+    return;
+  }
+  COMMON_INTERCEPTOR_ENTER(ctx, memset_pattern4, s, p, n);
+  if (common_flags()->intercept_intrin)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, s, n);
+  REAL(memset_pattern4)(s, p, n);
+}
+
+INTERCEPTOR(void, memset_pattern8, void *s, const void *p, SIZE_T n) {
+  void *ctx;
+  if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED) {
+    internal_memset_pattern8(s, p, n);
+    return;
+  }
+  COMMON_INTERCEPTOR_ENTER(ctx, memset_pattern8, s, p, n);
+  if (common_flags()->intercept_intrin)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, s, n);
+  REAL(memset_pattern8)(s, p, n);
+}
+
+INTERCEPTOR(void, memset_pattern16, void *s, const void *p, SIZE_T n) {
+  void *ctx;
+  if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED) {
+    internal_memset_pattern16(s, p, n);
+    return;
+  }
+  COMMON_INTERCEPTOR_ENTER(ctx, memset_pattern16, s, p, n);
+  if (common_flags()->intercept_intrin)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, s, n);
+  REAL(memset_pattern16)(s, p, n);
+}
+
+#define INIT_MEMSET_PATTERN \
+  COMMON_INTERCEPT_FUNCTION(memset_pattern4) \
+  COMMON_INTERCEPT_FUNCTION(memset_pattern8) \
+  COMMON_INTERCEPT_FUNCTION(memset_pattern16)
+#else
+#define INIT_MEMSET_PATTERN
+#endif
+
 #if SANITIZER_INTERCEPT_MEMMOVE
 INTERCEPTOR(void *, memmove, void *dst, const void *src, uptr size) {
   void *ctx;
   COMMON_INTERCEPTOR_MEMMOVE_IMPL(ctx, dst, src, size);
 }
 
 #define INIT_MEMMOVE COMMON_INTERCEPT_FUNCTION(memmove)
 #else

   INIT_STRTOK;
   INIT_STRPBRK;
   INIT_STRXFRM;
   INIT___STRXFRM_L;
   INIT_MEMSET;
   INIT_MEMMOVE;
   INIT_MEMCPY;
   INIT_MEMCHR;
+  INIT_MEMSET_PATTERN;
   INIT_MEMCMP;
   INIT_BCMP;
   INIT_MEMRCHR;
   INIT_MEMMEM;
   INIT_READ;
   INIT_FREAD;
   INIT_PREAD;
   INIT_PREAD64;

compiler-rt/lib/sanitizer_common/sanitizer_libc.h

 s64 internal_atoll(const char *nptr);
 void *internal_memchr(const void *s, int c, uptr n);
 void *internal_memrchr(const void *s, int c, uptr n);
 int internal_memcmp(const void* s1, const void* s2, uptr n);
 void *internal_memcpy(void *dest, const void *src, uptr n);
 void *internal_memmove(void *dest, const void *src, uptr n);
 // Should not be used in performance-critical places.
 void *internal_memset(void *s, int c, uptr n);
+void internal_memset_pattern4(void *s, const void *p, uptr n);
+void internal_memset_pattern8(void *s, const void *p, uptr n);
+void internal_memset_pattern16(void *s, const void *p, uptr n);
 char* internal_strchr(const char *s, int c);
 char *internal_strchrnul(const char *s, int c);
 int internal_strcmp(const char *s1, const char *s2);
 uptr internal_strcspn(const char *s, const char *reject);
 char *internal_strdup(const char *s);
 uptr internal_strlen(const char *s);
 uptr internal_strlcat(char *dst, const char *src, uptr maxlen);
 char *internal_strncat(char *dst, const char *src, uptr n);

compiler-rt/lib/sanitizer_common/sanitizer_libc.cpp

void *internal_memset(void* s, int c, uptr n) {
   // there currently are linktime problems due to PR12396.
   char volatile *t = (char*)s;
   for (uptr i = 0; i < n; ++i, ++t) {
     *t = c;
   }
   return s;
 }
 
+// using internal_memmove, thus
+// using those in slow code paths
+template<int chunk>
+static void internal_memset_pattern(void *src, const void *pattern, uptr n) {
+  char *s = (char*)src;
+  char *end = s + n;
+  char *o = s;
+
+  while (end - o >= chunk) {
+    internal_memmove(o, pattern, chunk);
+    o += chunk;
+  }
+
+  if (end - o != 0)
+    internal_memmove(o, pattern, end - o);
+}
+
+void internal_memset_pattern4(void *s, const void *pattern, uptr n) {
+  internal_memset_pattern<4>(s, pattern, n);
+}
+
+void internal_memset_pattern8(void *s, const void *pattern, uptr n) {
+  internal_memset_pattern<8>(s, pattern, n);
+}
+
+void internal_memset_pattern16(void *s, const void *pattern, uptr n) {
+  internal_memset_pattern<16>(s, pattern, n);
+}
+
 uptr internal_strcspn(const char *s, const char *reject) {
   uptr i;
   for (i = 0; s[i]; i++) {
     if (internal_strchr(reject, s[i]))
       return i;
   }
   return i;
 }

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_STRCASECMP SI_POSIX
 #define SANITIZER_INTERCEPT_MEMSET 1
 #define SANITIZER_INTERCEPT_MEMMOVE 1
 #define SANITIZER_INTERCEPT_MEMCPY 1
 #define SANITIZER_INTERCEPT_MEMCMP SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_BCMP \
   SANITIZER_INTERCEPT_MEMCMP &&  \
       ((SI_POSIX && _GNU_SOURCE) || SI_NETBSD || SI_FREEBSD)
+#define SANITIZER_INTERCEPT_MEMSET_PATTERN SI_MAC
 #define SANITIZER_INTERCEPT_STRNDUP SI_POSIX
 #define SANITIZER_INTERCEPT___STRNDUP SI_GLIBC
 #if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && \
     __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1070
 #define SI_MAC_DEPLOYMENT_BELOW_10_7 1
 #else
 #define SI_MAC_DEPLOYMENT_BELOW_10_7 0
 #endif

compiler-rt/test/sanitizer_common/TestCases/Darwin/memset_pattern.cpp

+// RUN: %clangxx -g %s -o %t
+#include <stdlib.h>
+#include <string.h>
+
+int main(void) {
+  char s[16];
+  memset_pattern4(s, "abc", sizeof(s));
+
+  printf("%s\n", s);
+  memset_pattern4(s, "abcd", sizeof(s));
+  s[15] = 0;
+  printf("%s\n", s);
+// CHECK: abc
+// CHECK: abcdabcdabcdabcd
+  return 0;
+}
+
+