Updates in preparation of wrapper script

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
 /// \brief Provides the AddressSanitizer runtime.
 ///
 /// Exposes functions for initializing the shadow memory region and managing it
 /// on loads, stores, and allocations.
 ///
 //===----------------------------------------------------------------------===//
 
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/mman.h>
 
 #define RZ_SIZE (32)
 #define SHADOW_SCALE_LOG2 (3)
 #define SHADOW_SCALE ((size_t)1 << SHADOW_SCALE_LOG2)
 #define DEBUG (0)
 
 // Assuming 48 bit address space on 64 bit systems
 #define SHADOW_LENGTH_64 (1u << (48 - SHADOW_SCALE_LOG2))
 #define SHADOW_LENGTH_32 (1u << (32 - SHADOW_SCALE_LOG2))
@@ skipping 110 matching lines @@
   void *rz_right = ret + size;
   __asan_poison(rz_left, rz_left_size);
   __asan_poison(rz_right, rz_right_size);
   // record size and location data so we can find it again
   *(void **)rz_left = rz_right;
   *(size_t *)rz_right = rz_right_size;
   assert((uintptr_t)ret % 8 == 0);
   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_free(char *ptr) {
   DUMP("free() called on %p\n", ptr);
   void *rz_left = ptr - RZ_SIZE;
   void *rz_right = *(void **)rz_left;
   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);
 }
 
@@ skipping 19 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;
   }
 }