[asan] Optimize strchr for strict_string_checks=false

[vitalybuka]

Summary

strchr interceptor does not need to call strlen if strict_string_checks is not
enabled. Unnecessary strlen calls affect python parser performance.

[vitalybuka]

comment

[vitalybuka]

nicer code

[eugenis]

test/asan/TestCases/strchr_strict.c

51

Returning a PROT_NONE page to the allocator sounds dangerous. Switch to mmap?

[vitalybuka]

malloc to mmap

[vitalybuka]

allocate less memory in the test

[eugenis]

LGTM

test/asan/TestCases/Posix/strchr.c

18 ↗

(On Diff #96009)

MAP_ANONYMOUS

[vitalybuka]

MAP_ANONYMOUS

[kubamracek]

There's some Darwin failures: http://green.lab.llvm.org/green/job/clang-stage1-cmake-RA-expensive/5975/

[vitalybuka]

Simplify test

lib/sanitizer_common/sanitizer_common_interceptors.inc

 #define COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED (0)
 #endif
 
 #define COMMON_INTERCEPTOR_READ_STRING_OF_LEN(ctx, s, len, n)       \
     COMMON_INTERCEPTOR_READ_RANGE((ctx), (s),                       \
       common_flags()->strict_string_checks ? (len) + 1 : (n) )
 
 #define COMMON_INTERCEPTOR_READ_STRING(ctx, s, n)                   \
-    COMMON_INTERCEPTOR_READ_STRING_OF_LEN((ctx), (s), REAL(strlen)(s), (n))
+    COMMON_INTERCEPTOR_READ_RANGE((ctx), (s),                       \
+      common_flags()->strict_string_checks ? (REAL(strlen)(s)) + 1 : (n) )
 
 #ifndef COMMON_INTERCEPTOR_ON_DLOPEN
 #define COMMON_INTERCEPTOR_ON_DLOPEN(filename, flag) \
   CheckNoDeepBind(filename, flag);
 #endif
 
 #ifndef COMMON_INTERCEPTOR_GET_TLS_RANGE
 #define COMMON_INTERCEPTOR_GET_TLS_RANGE(begin, end) *begin = *end = 0;

 #define INIT_STRNCASECMP
 #endif
 
 #if SANITIZER_INTERCEPT_STRSTR || SANITIZER_INTERCEPT_STRCASESTR
 static inline void StrstrCheck(void *ctx, char *r, const char *s1,
                                const char *s2) {
     uptr len1 = REAL(strlen)(s1);
     uptr len2 = REAL(strlen)(s2);
-    COMMON_INTERCEPTOR_READ_STRING_OF_LEN(ctx, s1, len1,
-                                          r ? r - s1 + len2 : len1 + 1);
+    COMMON_INTERCEPTOR_READ_STRING(ctx, s1, r ? r - s1 + len2 : len1 + 1);
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, len2 + 1);
 }
 #endif
 
 #if SANITIZER_INTERCEPT_STRSTR
 
 DECLARE_WEAK_INTERCEPTOR_HOOK(__sanitizer_weak_hook_strstr, uptr called_pc,
                               const char *s1, const char *s2, char *result)

 
 #if SANITIZER_INTERCEPT_STRCHR
 INTERCEPTOR(char*, strchr, const char *s, int c) {
   void *ctx;
   if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
     return internal_strchr(s, c);
   COMMON_INTERCEPTOR_ENTER(ctx, strchr, s, c);
   char *result = REAL(strchr)(s, c);
-  uptr len = internal_strlen(s);
-  uptr n = result ? result - s + 1 : len + 1;
-  if (common_flags()->intercept_strchr)
-    COMMON_INTERCEPTOR_READ_STRING_OF_LEN(ctx, s, len, n);
+  if (common_flags()->intercept_strchr) {
+    // Keep strlen as macro argument, as macro may ignore it.
+    COMMON_INTERCEPTOR_READ_STRING(ctx, s,
+      (result ? result - s : REAL(strlen)(s)) + 1);
+  }
   return result;
 }
 #define INIT_STRCHR COMMON_INTERCEPT_FUNCTION(strchr)
 #else
 #define INIT_STRCHR
 #endif
 
 #if SANITIZER_INTERCEPT_STRCHRNUL

 #endif
 
 #if SANITIZER_INTERCEPT_STRRCHR
 INTERCEPTOR(char*, strrchr, const char *s, int c) {
   void *ctx;
   if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
     return internal_strrchr(s, c);
   COMMON_INTERCEPTOR_ENTER(ctx, strrchr, s, c);
-  uptr len = internal_strlen(s);
-  if (common_flags()->intercept_strchr)
-    COMMON_INTERCEPTOR_READ_STRING_OF_LEN(ctx, s, len, len + 1);
+  if (common_flags()->intercept_strchr) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, s, REAL(strlen)(s) + 1);
+  }
   return REAL(strrchr)(s, c);
 }
 #define INIT_STRRCHR COMMON_INTERCEPT_FUNCTION(strrchr)
 #else
 #define INIT_STRRCHR
 #endif
 
 #if SANITIZER_INTERCEPT_STRSPN

test/asan/TestCases/strchr_strict.c

 // Test strict_string_checks option in strchr function
 // RUN: %clang_asan %s -o %t && %run %t 2>&1
 // RUN: %env_asan_opts=strict_string_checks=false %run %t 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 #include <assert.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
+#if defined(_WIN32)
+
+#include <windows.h>
+
+static uintptr_t get_page_size() {
+  SYSTEM_INFO si;
+  GetSystemInfo(&si);
+  return si.dwPageSize;
+}
+
+static void protect(void *addr, size_t len) {
+  DWORD p = 0;
+  VirtualProtect(addr, len, PAGE_NOACCESS, &p);
+}
+
+#else // _WIN32
+
+#include <sys/mman.h>
+#include <unistd.h>
+
+static size_t get_page_size() { return sysconf(_SC_PAGE_SIZE); }
+static void protect(void *addr, size_t len) { mprotect(addr, len, PROT_NONE); }
+
+#endif // _WIN32
+
 int main(int argc, char **argv) {
-  size_t size = 100;
+  size_t page_size = get_page_size();
+  size_t size = 100 * page_size;
   char fill = 'o';
   char *s = (char*)malloc(size);
+  char *p = (char *)((uintptr_t)s & (-page_size)) + 3 * page_size;
+  --p;
   memset(s, fill, size);
-  char c = 'o';
-  char* r = strchr(s, c);
+  *p = 'x';
+  char *r = strchr(s, 'x');
   // CHECK: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
-  // CHECK: READ of size 101
-  assert(r == s);
+  // CHECK: READ of size
+  assert(r == p);
+
+  //strict_string_checks=false must not look beyond requested char.
+  protect(p + 1, page_size);
+  r = strchr(s, 'x');
+
   free(s);
   return 0;
 }