[HWASAN/compiler-rt] Instrument globals

[evgeny777]

Summary

This is compiler-rt part of D56672
It also depends on D56603

[evgeny777]

Rebased

lib/hwasan/hwasan.cpp

 void __hwasan_tag_memory(uptr p, u8 tag, uptr sz) {
   TagMemoryAligned(p, sz, tag);
 }
 
 uptr __hwasan_tag_pointer(uptr p, u8 tag) {
   return AddTagToPointer(p, tag);
 }
 
+void __hwasan_init_globals(uptr beg, uptr end) {
+  struct GlobalInfo {
+    uptr addr, size;
+  };
+  CHECK((end - beg) % sizeof(GlobalInfo) == 0);
+
+  GlobalInfo *gi = reinterpret_cast<GlobalInfo *>(beg);
+  uptr count = (end - beg) / sizeof(*gi);
+
+  for (uptr i = 0; i < count; ++i)
+    TagMemoryAligned(UntagAddr(gi[i].addr), gi[i].size,
+                     GetTagFromPointer(gi[i].addr));
+}
+
 void __hwasan_handle_longjmp(const void *sp_dst) {
   uptr dst = (uptr)sp_dst;
   // HWASan does not support tagged SP.
   CHECK(GetTagFromPointer(dst) == 0);
 
   uptr sp = (uptr)__builtin_frame_address(0);
   static const uptr kMaxExpectedCleanupSize = 64 << 20;  // 64M
   if (dst < sp || dst - sp > kMaxExpectedCleanupSize) {

lib/hwasan/hwasan_allocator.cpp

 void *hwasan_calloc(uptr nmemb, uptr size, StackTrace *stack) {
   return SetErrnoOnNull(HwasanCalloc(stack, nmemb, size));
 }
 
 void *hwasan_realloc(void *ptr, uptr size, StackTrace *stack) {
   if (!ptr)
     return SetErrnoOnNull(HwasanAllocate(stack, size, sizeof(u64), false));
 
+  bool PointerIsMine = allocator.PointerIsMine(UntagPtr(ptr));
 #if HWASAN_WITH_INTERCEPTORS
-  // A tag of 0 means that this is a system allocator allocation, so we must use
-  // the system allocator to realloc it.
-  if (!flags()->disable_allocator_tagging && GetTagFromPointer((uptr)ptr) == 0)
+  if (GetTagFromPointer((uptr)ptr) == 0 && !PointerIsMine)
     return REAL(realloc)(ptr, size);
 #endif
 
+  CHECK(PointerIsMine);
   if (size == 0) {
     HwasanDeallocate(stack, ptr);
     return nullptr;
   }
   return SetErrnoOnNull(HwasanReallocate(stack, ptr, size, sizeof(u64)));
 }
 
 void *hwasan_valloc(uptr size, StackTrace *stack) {
if (UNLIKELY(!ptr))
     // OOM error is already taken care of by HwasanAllocate.
     return errno_ENOMEM;
   CHECK(IsAligned((uptr)ptr, alignment));
   *memptr = ptr;
   return 0;
 }
 
 void hwasan_free(void *ptr, StackTrace *stack) {
+  if (!ptr)
+    return;
+
+  bool PointerIsMine = allocator.PointerIsMine(UntagPtr(ptr));
 #if HWASAN_WITH_INTERCEPTORS
-  // A tag of 0 means that this is a system allocator allocation, so we must use
-  // the system allocator to free it.
-  if (!flags()->disable_allocator_tagging && GetTagFromPointer((uptr)ptr) == 0)
+  if (GetTagFromPointer((uptr)ptr) == 0 && !PointerIsMine)
     return REAL(free)(ptr);
 #endif
 
+  CHECK(PointerIsMine);
   return HwasanDeallocate(stack, ptr);
 }
 
 }  // namespace __hwasan
 
 using namespace __hwasan;
 
 void __hwasan_enable_allocator_tagging() {

lib/hwasan/hwasan_interface_internal.h

 void * __sanitizer_malloc(uptr size);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void *__hwasan_memcpy(void *dst, const void *src, uptr size);
 SANITIZER_INTERFACE_ATTRIBUTE
 void *__hwasan_memset(void *s, int c, uptr n);
 SANITIZER_INTERFACE_ATTRIBUTE
 void *__hwasan_memmove(void *dest, const void *src, uptr n);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __hwasan_init_globals(uptr, uptr);
 }  // extern "C"
 
 #endif  // HWASAN_INTERFACE_INTERNAL_H

test/hwasan/TestCases/globals.c

+// RUN: %clang_hwasan %s -DCHECK_STATIC -mllvm -hwasan-instrument-globals -o %t -Wl,--no-relax && not %run %t 2>&1 | FileCheck %s
+// RUN: %clang_hwasan %s -mllvm -hwasan-instrument-globals -o %t -Wl,--no-relax && not %run %t 2>&1 | FileCheck %s
+// REQUIRES: stable-runtime
+
+#include <string.h>
+#ifndef CHECK_STATIC
+long Q = 42;
+#else
+static long Q = 42;
+#endif
+
+int main() {
+  long *P = &Q;
+  memset(P, 0, 32);
+  // CHECK: ERROR: HWAddressSanitizer: tag-mismatch on address
+  // CHECK: WRITE of size 32 at {{.*}} tags: [[PTR_TAG:..]]/[[MEM_TAG:..]] (ptr/mem)
+  // CHECK: Invalid access starting at offset [16, 32)
+  // CHECK: Memory tags around the buggy address (one tag corresponds to 16 bytes):
+  // CHECK: =>{{.*}}[[PTR_TAG]]{{[[:space:]]\[}}[[MEM_TAG]]
+  return 0;
+}