[hwasan] Provide __sanitizer_* aliases to allocator functions.

[eugenis]

Summary

Export __sanitizer_malloc, etc as aliases to malloc, etc.
This way users can wrap sanitizer malloc, even in fully static binaries.

Both jemalloc and tcmalloc provide similar aliases (je_* and tc_*).

compiler-rt/trunk/include/sanitizer/allocator_interface.h

int __sanitizer_install_malloc_and_free_hooks(
       void (*free_hook)(const volatile void *));
 
   /* Drains allocator quarantines (calling thread's and global ones), returns
      freed memory back to OS and releases other non-essential internal allocator
      resources in attempt to reduce process RSS.
      Currently available with ASan only.
   */
   void __sanitizer_purge_allocator(void);
-
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif

compiler-rt/trunk/include/sanitizer/hwasan_interface.h

#endif
 
   // This function may be optionally provided by user and should return
   // a string containing HWASan runtime options. See asan_flags.h for details.
   const char* __hwasan_default_options(void);
 
   void __hwasan_enable_allocator_tagging(void);
   void __hwasan_disable_allocator_tagging(void);
 
+  int __sanitizer_posix_memalign(void **memptr, size_t alignment, size_t size);
+  void * __sanitizer_memalign(size_t alignment, size_t size);
+  void * __sanitizer_aligned_alloc(size_t alignment, size_t size);
+  void * __sanitizer___libc_memalign(size_t alignment, size_t size);
+  void * __sanitizer_valloc(size_t size);
+  void * __sanitizer_pvalloc(size_t size);
+  void __sanitizer_free(void *ptr);
+  void __sanitizer_cfree(void *ptr);
+  size_t __sanitizer_malloc_usable_size(const void *ptr);
+  struct mallinfo __sanitizer_mallinfo();
+  int __sanitizer_mallopt(int cmd, int value);
+  void __sanitizer_malloc_stats(void);
+  void * __sanitizer_calloc(size_t nmemb, size_t size);
+  void * __sanitizer_realloc(void *ptr, size_t size);
+  void * __sanitizer_malloc(size_t size);
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // SANITIZER_HWASAN_INTERFACE_H

compiler-rt/trunk/lib/hwasan/hwasan_interceptors.cc

#define CHECK_UNPOISONED(x, n)                             \
   do {                                                     \
     if (!IsInInterceptorScope()) CHECK_UNPOISONED_0(x, n); \
   } while (0)
 
 #define CHECK_UNPOISONED_STRING_OF_LEN(x, len, n)               \
   CHECK_UNPOISONED((x),                                         \
     common_flags()->strict_string_checks ? (len) + 1 : (n) )
 
+#define SANITIZER_ALIAS(RET, FN, ARGS...)                                \
+  extern "C" SANITIZER_INTERFACE_ATTRIBUTE RET __sanitizer_##FN(ARGS) \
+      ALIAS(WRAPPER_NAME(FN));
+
+SANITIZER_ALIAS(int, posix_memalign, void **memptr, SIZE_T alignment, SIZE_T size);
+SANITIZER_ALIAS(void *, memalign, SIZE_T alignment, SIZE_T size);
+SANITIZER_ALIAS(void *, aligned_alloc, SIZE_T alignment, SIZE_T size);
+SANITIZER_ALIAS(void *, __libc_memalign, SIZE_T alignment, SIZE_T size);
+SANITIZER_ALIAS(void *, valloc, SIZE_T size);
+SANITIZER_ALIAS(void *, pvalloc, SIZE_T size);
+SANITIZER_ALIAS(void, free, void *ptr);
+SANITIZER_ALIAS(void, cfree, void *ptr);
+SANITIZER_ALIAS(uptr, malloc_usable_size, const void *ptr);
+SANITIZER_ALIAS(void, mallinfo, __sanitizer_struct_mallinfo *sret);
+SANITIZER_ALIAS(int, mallopt, int cmd, int value);
+SANITIZER_ALIAS(void, malloc_stats, void);
+SANITIZER_ALIAS(void *, calloc, SIZE_T nmemb, SIZE_T size);
+SANITIZER_ALIAS(void *, realloc, void *ptr, SIZE_T size);
+SANITIZER_ALIAS(void *, malloc, SIZE_T size);
 
 INTERCEPTOR(int, posix_memalign, void **memptr, SIZE_T alignment, SIZE_T size) {
   GET_MALLOC_STACK_TRACE;
   CHECK_NE(memptr, 0);
   int res = hwasan_posix_memalign(memptr, alignment, size, &stack);
   return res;
 }
 
INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
   return __sanitizer_get_allocated_size(ptr);
 }
 
 #if !SANITIZER_FREEBSD && !SANITIZER_NETBSD
 // This function actually returns a struct by value, but we can't unpoison a
 // temporary! The following is equivalent on all supported platforms but
 // aarch64 (which uses a different register for sret value).  We have a test
 // to confirm that.
-INTERCEPTOR(void, mallinfo, __sanitizer_mallinfo *sret) {
+INTERCEPTOR(void, mallinfo, __sanitizer_struct_mallinfo *sret) {
 #ifdef __aarch64__
   uptr r8;
   asm volatile("mov %0,x8" : "=r" (r8));
-  sret = reinterpret_cast<__sanitizer_mallinfo*>(r8);
+  sret = reinterpret_cast<__sanitizer_struct_mallinfo*>(r8);
 #endif
   REAL(memset)(sret, 0, sizeof(*sret));
 }
 #define HWASAN_MAYBE_INTERCEPT_MALLINFO INTERCEPT_FUNCTION(mallinfo)
 #else
 #define HWASAN_MAYBE_INTERCEPT_MALLINFO
 #endif
 

compiler-rt/trunk/lib/msan/msan_interceptors.cc

 #define MSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE
 #endif
 
 #if !SANITIZER_FREEBSD && !SANITIZER_NETBSD
 // This function actually returns a struct by value, but we can't unpoison a
 // temporary! The following is equivalent on all supported platforms but
 // aarch64 (which uses a different register for sret value).  We have a test
 // to confirm that.
-INTERCEPTOR(void, mallinfo, __sanitizer_mallinfo *sret) {
+INTERCEPTOR(void, mallinfo, __sanitizer_struct_mallinfo *sret) {
 #ifdef __aarch64__
   uptr r8;
   asm volatile("mov %0,x8" : "=r" (r8));
-  sret = reinterpret_cast<__sanitizer_mallinfo*>(r8);
+  sret = reinterpret_cast<__sanitizer_struct_mallinfo*>(r8);
 #endif
   REAL(memset)(sret, 0, sizeof(*sret));
   __msan_unpoison(sret, sizeof(*sret));
 }
 #define MSAN_MAYBE_INTERCEPT_MALLINFO INTERCEPT_FUNCTION(mallinfo)
 #else
 #define MSAN_MAYBE_INTERCEPT_MALLINFO
 #endif

compiler-rt/trunk/lib/sanitizer_common/sanitizer_platform_limits_posix.h

#elif SANITIZER_LINUX
     uptr data[4];
 #elif SANITIZER_FREEBSD
     u32 data[4];
 #endif
   };
 #endif // SANITIZER_LINUX || SANITIZER_FREEBSD
 
 #if SANITIZER_ANDROID
-  struct __sanitizer_mallinfo {
+  struct __sanitizer_struct_mallinfo {
     uptr v[10];
   };
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
-  struct __sanitizer_mallinfo {
+  struct __sanitizer_struct_mallinfo {
     int v[10];
   };
 
   extern unsigned struct_ustat_sz;
   extern unsigned struct_rlimit64_sz;
   extern unsigned struct_statvfs64_sz;
 
   struct __sanitizer_ipc_perm {

compiler-rt/trunk/lib/sanitizer_common/sanitizer_platform_limits_posix.cc

 # endif // SANITIZER_FREEBSD
 #else
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr);
 #endif // SANITIZER_LINUX
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_data);
 #endif
 
 #if SANITIZER_LINUX
-COMPILER_CHECK(sizeof(__sanitizer_mallinfo) == sizeof(struct mallinfo));
+COMPILER_CHECK(sizeof(__sanitizer_struct_mallinfo) == sizeof(struct mallinfo));
 #endif
 
 #if !SANITIZER_ANDROID
 CHECK_TYPE_SIZE(timeb);
 CHECK_SIZE_AND_OFFSET(timeb, time);
 CHECK_SIZE_AND_OFFSET(timeb, millitm);
 CHECK_SIZE_AND_OFFSET(timeb, timezone);
 CHECK_SIZE_AND_OFFSET(timeb, dstflag);

compiler-rt/trunk/test/hwasan/TestCases/sanitizer_malloc.cc

+// Test allocator aliases.
+//
+// RUN: %clangxx_hwasan -O0 %s -o %t && %run %t
+
+#include <sanitizer/hwasan_interface.h>
+
+int main() {
+  void *volatile sink;
+  sink = (void *)&__sanitizer_posix_memalign;
+  sink = (void *)&__sanitizer_memalign;
+  sink = (void *)&__sanitizer_aligned_alloc;
+  sink = (void *)&__sanitizer___libc_memalign;
+  sink = (void *)&__sanitizer_valloc;
+  sink = (void *)&__sanitizer_pvalloc;
+  sink = (void *)&__sanitizer_free;
+  sink = (void *)&__sanitizer_cfree;
+  sink = (void *)&__sanitizer_malloc_usable_size;
+  sink = (void *)&__sanitizer_mallinfo;
+  sink = (void *)&__sanitizer_mallopt;
+  sink = (void *)&__sanitizer_malloc_stats;
+  sink = (void *)&__sanitizer_calloc;
+  sink = (void *)&__sanitizer_realloc;
+  sink = (void *)&__sanitizer_malloc;
+
+  // sanity check
+  void *p = __sanitizer_malloc(100);
+  p = __sanitizer_realloc(p, 200);
+  __sanitizer_free(p);
+}