Subzero: Added address of bad instruction to error output

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 72 matching lines @@
   do {                                                                         \
     printf(args);                                                              \
   } while (false);
 #else // !DEBUG
 #define DUMP(args...)
 #endif // DEBUG
 
 static char *shadow_offset = NULL;
 
 static bool __asan_check(char *, int);
-static void __asan_error(char *, int, int);
+static void __asan_error(char *, int, int, void *);
 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, char);
 void __asan_unpoison(char *, int);
 
 struct quarantine_entry {
   struct quarantine_entry *next;
   size_t size;
 };
 
 mutex_t quarantine_lock = MUTEX_INITIALIZER;
 uint64_t quarantine_size = 0;
 struct quarantine_entry *quarantine_head = NULL;
 struct quarantine_entry *quarantine_tail = NULL;
 
-static void __asan_error(char *ptr, int size, int access) {
+static void __asan_error(char *ptr, int size, int access, void *ret_addr) {
   char *shadow_addr = MEM2SHADOW(ptr);
   char shadow_val = *shadow_addr;
   if (shadow_val > 0)
     shadow_val = *(shadow_addr + 1);
   assert(access == ACCESS_LOAD || access == ACCESS_STORE);
   const char *access_name = access_names[access];
   assert(shadow_val == STACK_POISON_VAL || shadow_val == HEAP_POISON_VAL ||
          shadow_val == GLOBAL_POISON_VAL || shadow_val == FREED_POISON_VAL);
   const char *memtype = memtype_names[MEMTYPE_INDEX(shadow_val)];
-  fprintf(stderr, "Illegal %d byte %s %s object at %p\n", size, access_name,
-          memtype, ptr);
+  fprintf(stderr, "%p: Illegal %d byte %s %s object at %p\n", ret_addr, size,
+          access_name, memtype, ptr);
+  fprintf(stderr, "(address of __asan_error symbol is %p)\n", __asan_error);
   abort();
 }
 
 // check only the first byte of each word unless strict
 static bool __asan_check(char *ptr, int size) {
   assert(size == 1 || size == 2 || size == 4 || size == 8);
   char *shadow_addr = (char *)MEM2SHADOW(ptr);
   char shadow_val = *shadow_addr;
   DUMP("check %d bytes at %p: %p + %d (%d)\n", size, ptr, shadow_addr,
        (uintptr_t)ptr % SHADOW_SCALE, shadow_val);
@@ skipping 11 matching lines @@
   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
   int check_size =
       (size == WORD_SIZE && (uintptr_t)ptr % WORD_SIZE == 0) ? 1 : size;
   if (!__asan_check(ptr, check_size))
-    __asan_error(ptr, size, ACCESS_LOAD);
+    __asan_error(ptr, size, ACCESS_LOAD, __builtin_return_address(0));
 }
 
 void __asan_check_store(char *ptr, int size) {
   // stores may never be partially out of bounds so use strict check
   if (!__asan_check(ptr, size))
-    __asan_error(ptr, size, ACCESS_STORE);
+    __asan_error(ptr, size, ACCESS_STORE, __builtin_return_address(0));
 }
 
 void __asan_init(int n_rzs, void **rzs, int *rz_sizes) {
   // ensure the redzones are large enough to hold metadata
   assert(RZ_SIZE >= sizeof(void *) && RZ_SIZE >= sizeof(size_t));
   assert(shadow_offset == NULL);
   size_t length = (IS_32_BIT) ? SHADOW_LENGTH_32 : SHADOW_LENGTH_64;
   int prot = PROT_READ | PROT_WRITE;
   int flags = MAP_PRIVATE | MAP_ANONYMOUS;
   int fd = -1;
@@ skipping 67 matching lines @@
   memcpy(new_alloc, ptr, copyable);
   __asan_free(ptr);
   return new_alloc;
 }
 
 void __asan_free(char *ptr) {
   DUMP("free() called on %p\n", ptr);
   if (ptr == NULL)
     return;
   if (*(char *)MEM2SHADOW(ptr) == FREED_POISON_VAL) {
-    fprintf(stderr, "Double free of object at %p\n", ptr);
+    fprintf(stderr, "%p: Double free of object at %p\n",
+            __builtin_return_address(0), ptr);
+    fprintf(stderr, "(address of __asan_error symbol is %p)\n", __asan_error);
     abort();
   }
   char *rz_left, *rz_right;
   __asan_get_redzones(ptr, &rz_left, &rz_right);
   size_t rz_right_size = *(size_t *)rz_right;
   size_t total_size = rz_right_size + (rz_right - rz_left);
   __asan_poison(rz_left, total_size, FREED_POISON_VAL);
 
   // place allocation in quarantine
   struct quarantine_entry *entry = (struct quarantine_entry *)rz_left;
@@ skipping 41 matching lines @@
 void __asan_unpoison(char *ptr, int size) {
   char *end = ptr + size;
   assert(IS_SHADOW_ALIGNED(end));
   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));
   memset(MEM2SHADOW(ptr), 0, (end - ptr) >> SHADOW_SCALE_LOG2);
 }