Use sanitizer internal allocator during rtsan init

Author: davidtrevelyan

compiler-rt/lib/rtsan/rtsan_interceptors.cpp

@@ -10,6 +10,7 @@
 
 #include "rtsan/rtsan_interceptors.h"
 
+#include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_platform.h"
 #include "sanitizer_common/sanitizer_platform_interceptors.h"
 
@@ -39,26 +40,6 @@ using namespace __sanitizer;
 using __rtsan::rtsan_init_is_running;
 using __rtsan::rtsan_initialized;
 
-constexpr uptr kEarlyAllocBufSize = 16384;
-static uptr allocated_bytes;
-static char early_alloc_buf[kEarlyAllocBufSize];
-
-static bool IsInEarlyAllocBuf(const void *ptr) {
-  return ((uptr)ptr >= (uptr)early_alloc_buf &&
-          ((uptr)ptr - (uptr)early_alloc_buf) < sizeof(early_alloc_buf));
-}
-
-template <typename T> T min(T a, T b) { return a < b ? a : b; }
-
-// Handle allocation requests early (before all interceptors are setup). dlsym,
-// for example, calls calloc.
-static void *HandleEarlyAlloc(uptr size) {
-  void *Mem = (void *)&early_alloc_buf[allocated_bytes];
-  allocated_bytes += size;
-  CHECK_LT(allocated_bytes, kEarlyAllocBufSize);
-  return Mem;
-}
-
 void ExpectNotRealtime(const char *intercepted_function_name) {
   __rtsan::GetContextForThisThread().ExpectNotRealtime(
       intercepted_function_name);
@@ -262,18 +243,16 @@ INTERCEPTOR(int, nanosleep, const struct timespec *rqtp,
 // Memory
 
 INTERCEPTOR(void *, calloc, SIZE_T num, SIZE_T size) {
-  if (rtsan_init_is_running && REAL(calloc) == nullptr) {
-    // Note: EarlyAllocBuf is initialized with zeros.
-    return HandleEarlyAlloc(num * size);
-  }
+  if (rtsan_init_is_running && REAL(calloc) == nullptr)
+    return __sanitizer::InternalCalloc(num, size);
 
   ExpectNotRealtime("calloc");
   return REAL(calloc)(num, size);
 }
 
 INTERCEPTOR(void, free, void *ptr) {
-  if (IsInEarlyAllocBuf(ptr))
-    return;
+  if (__sanitizer::internal_allocator()->PointerIsMine(ptr))
+    return __sanitizer::InternalFree(ptr);
 
   if (ptr != NULL) {
     ExpectNotRealtime("free");
@@ -282,15 +261,17 @@ INTERCEPTOR(void, free, void *ptr) {
 }
 
 INTERCEPTOR(void *, malloc, SIZE_T size) {
-  if (rtsan_init_is_running && REAL(malloc) == nullptr) {
-    return HandleEarlyAlloc(size);
-  }
+  if (rtsan_init_is_running && REAL(malloc) == nullptr)
+    return __sanitizer::InternalAlloc(size);
 
   ExpectNotRealtime("malloc");
   return REAL(malloc)(size);
 }
 
 INTERCEPTOR(void *, realloc, void *ptr, SIZE_T size) {
+  if (rtsan_init_is_running && REAL(realloc) == nullptr)
+    return __sanitizer::InternalRealloc(ptr, size);
+
   ExpectNotRealtime("realloc");
   return REAL(realloc)(ptr, size);
 }