Subzero: Instrumented realloc

runtime/szrt_asan.c

 //===- subzero/runtime/szrt_asan.c - AddressSanitizer Runtime -----*- C -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 41 matching lines @@
     printf(args);                                                              \
   } while (false);
 #else // !DEBUG
 #define DUMP(args...)
 #endif // DEBUG
 
 static char *shadow_offset = NULL;
 
 static void __asan_error(char *, int);
 static void __asan_check(char *, int, bool);
+static void __asan_get_redzones(char *, char **, char **);
 
 void __asan_init(int, void **, int *);
 void __asan_check_load(char *, int);
 void __asan_check_store(char *, int);
 void *__asan_malloc(size_t);
+void *__asan_calloc(size_t, size_t);
+void *__asan_realloc(char *, size_t);
 void __asan_free(char *);
 void __asan_poison(char *, int);
 void __asan_unpoison(char *, int);
 
 static void __asan_error(char *ptr, int size) {
   fprintf(stderr, "Illegal access of %d bytes at %p\n", size, ptr);
   abort();
 }
 
 // check only the first byte of each word unless strict
 static void __asan_check(char *ptr, int size, bool strict) {
   assert(strict || (uintptr_t)ptr % WORD_SIZE == 0);
   DUMP("%s check %d bytes at %p\n", (strict) ? "strict" : "loose", size, ptr);
   char *end = ptr + size;
   int step = (strict) ? 1 : WORD_SIZE;
   for (char *cur = ptr; cur < end; cur += step) {
     char shadow = *(char *)MEM2SHADOW(cur);
     DUMP("checking %p against %p with shadow %d\n", cur, MEM2SHADOW(cur),
          shadow);
     if (shadow != 0 && (shadow < 0 || SHADOW_OFFSET(cur) >= shadow)) {
       __asan_error(ptr, size);
     }
   }
 }
 
+static void __asan_get_redzones(char *ptr, char **left, char **right) {
+  char *rz_left = ptr - RZ_SIZE;
+  char *rz_right = *(char **)rz_left;
+  if (left != NULL)
+    *left = rz_left;
+  if (right != NULL)
+    *right = rz_right;
+}
+
 void __asan_check_load(char *ptr, int size) {
   // aligned single word accesses may be widened single byte accesses, but for
   // all else use strict check
   bool strict = !((uintptr_t)ptr % WORD_SIZE == 0 && size == WORD_SIZE);
   __asan_check(ptr, size, strict);
 }
 
 void __asan_check_store(char *ptr, int size) {
   // stores may never be partially out of bounds so use strict check
   bool strict = true;
@@ skipping 52 matching lines @@
   return ret;
 }
 
 void *__asan_calloc(size_t nmemb, size_t size) {
   size_t alloc_size = nmemb * size;
   void *ret = __asan_malloc(alloc_size);
   memset(ret, 0, alloc_size);
   return ret;
 }
 
+void *__asan_realloc(char *ptr, size_t size) {
+  if (ptr == NULL)
+    return __asan_malloc(size);
+  if (size == 0) {
+    __asan_free(ptr);
+    return NULL;
+  }
+  char *rz_right;
+  __asan_get_redzones(ptr, NULL, &rz_right);
+  size_t old_size = rz_right - ptr;
+  if (size == old_size)
+    return ptr;
+  char *new_alloc = __asan_malloc(size);
+  if (new_alloc == NULL)
+    return NULL;
+  size_t copyable = (size < old_size) ? size : old_size;
+  memcpy(new_alloc, ptr, copyable);
+  __asan_free(ptr);
+  return new_alloc;
+}
+
 void __asan_free(char *ptr) {
   DUMP("free() called on %p\n", ptr);
-  void *rz_left = ptr - RZ_SIZE;
-  void *rz_right = *(void **)rz_left;
+  void *rz_left, *rz_right;
+  __asan_get_redzones(ptr, &rz_left, &rz_right);
   size_t rz_right_size = *(size_t *)rz_right;
   __asan_unpoison(rz_left, RZ_SIZE);
   __asan_unpoison(rz_right, rz_right_size);
   free(rz_left);
 }
 
 void __asan_poison(char *ptr, int size) {
   char *end = ptr + size;
   assert(IS_SHADOW_ALIGNED(end));
   // redzones should be no greater than RZ_SIZE + RZ_SIZE-1 for alignment
@@ skipping 15 matching lines @@
   assert(size < 2 * RZ_SIZE);
   DUMP("unpoison %d bytes at %p: %p - %p\n", size, ptr, MEM2SHADOW(ptr),
        MEM2SHADOW(end));
   *(char *)MEM2SHADOW(ptr) = 0;
   ptr += SHADOW_OFFSET(size);
   assert(IS_SHADOW_ALIGNED(ptr));
   for (; ptr != end; ptr += SHADOW_SCALE) {
     *(char *)MEM2SHADOW(ptr) = 0;
   }
 }