contrib/compiler-rt/lib/asan/asan_new_delete.cc

   1 //===-- asan_interceptors.cc ----------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is a part of AddressSanitizer, an address sanity checker.
  11 //
  12 // Interceptors for operators new and delete.
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "asan_allocator.h"
  16 #include "asan_internal.h"
  17 #include "asan_stack.h"
  18
  19 #include "interception/interception.h"
  20
  21 #include <stddef.h>
  22
  23 // C++ operators can't have dllexport attributes on Windows. We export them
  24 // anyway by passing extra -export flags to the linker, which is exactly that
  25 // dllexport would normally do. We need to export them in order to make the
  26 // VS2015 dynamic CRT (MD) work.
  27 #if SANITIZER_WINDOWS
  28 # define CXX_OPERATOR_ATTRIBUTE
  29 # ifdef _WIN64
  30 #  pragma comment(linker, "/export:??2@YAPEAX_K@Z")   // operator new
  31 #  pragma comment(linker, "/export:??3@YAXPEAX@Z")    // operator delete
  32 #  pragma comment(linker, "/export:??3@YAXPEAX_K@Z")  // sized operator delete
  33 #  pragma comment(linker, "/export:??_U@YAPEAX_K@Z")  // operator new[]
  34 #  pragma comment(linker, "/export:??_V@YAXPEAX@Z")   // operator delete[]
  35 # else
  36 #  pragma comment(linker, "/export:??2@YAPAXI@Z")   // operator new
  37 #  pragma comment(linker, "/export:??3@YAXPAX@Z")   // operator delete
  38 #  pragma comment(linker, "/export:??3@YAXPAXI@Z")  // sized operator delete
  39 #  pragma comment(linker, "/export:??_U@YAPAXI@Z")  // operator new[]
  40 #  pragma comment(linker, "/export:??_V@YAXPAX@Z")  // operator delete[]
  41 # endif
  42 #else
  43 # define CXX_OPERATOR_ATTRIBUTE INTERCEPTOR_ATTRIBUTE
  44 #endif
  45
  46 using namespace __asan;  // NOLINT
  47
  48 // FreeBSD prior v9.2 have wrong definition of 'size_t'.
  49 // http://svnweb.freebsd.org/base?view=revision&revision=232261
  50 #if SANITIZER_FREEBSD && SANITIZER_WORDSIZE == 32
  51 #include <sys/param.h>
  52 #if __FreeBSD_version <= 902001  // v9.2
  53 #define size_t unsigned
  54 #endif  // __FreeBSD_version
  55 #endif  // SANITIZER_FREEBSD && SANITIZER_WORDSIZE == 32
  56
  57 // This code has issues on OSX.
  58 // See https://github.com/google/sanitizers/issues/131.
  59
  60 // Fake std::nothrow_t and std::align_val_t to avoid including <new>.
  61 namespace std {
  62 struct nothrow_t {};
  63 enum class align_val_t: size_t {};
  64 }  // namespace std
  65
  66 #define OPERATOR_NEW_BODY(type) \
  67   GET_STACK_TRACE_MALLOC;\
  68   return asan_memalign(0, size, &stack, type);
  69 #define OPERATOR_NEW_BODY_ALIGN(type) \
  70   GET_STACK_TRACE_MALLOC;\
  71   return asan_memalign((uptr)align, size, &stack, type);
  72
  73 // On OS X it's not enough to just provide our own 'operator new' and
  74 // 'operator delete' implementations, because they're going to be in the
  75 // runtime dylib, and the main executable will depend on both the runtime
  76 // dylib and libstdc++, each of those'll have its implementation of new and
  77 // delete.
  78 // To make sure that C++ allocation/deallocation operators are overridden on
  79 // OS X we need to intercept them using their mangled names.
  80 #if !SANITIZER_MAC
  81 CXX_OPERATOR_ATTRIBUTE
  82 void *operator new(size_t size) { OPERATOR_NEW_BODY(FROM_NEW); }
  83 CXX_OPERATOR_ATTRIBUTE
  84 void *operator new[](size_t size) { OPERATOR_NEW_BODY(FROM_NEW_BR); }
  85 CXX_OPERATOR_ATTRIBUTE
  86 void *operator new(size_t size, std::nothrow_t const&)
  87 { OPERATOR_NEW_BODY(FROM_NEW); }
  88 CXX_OPERATOR_ATTRIBUTE
  89 void *operator new[](size_t size, std::nothrow_t const&)
  90 { OPERATOR_NEW_BODY(FROM_NEW_BR); }
  91 CXX_OPERATOR_ATTRIBUTE
  92 void *operator new(size_t size, std::align_val_t align)
  93 { OPERATOR_NEW_BODY_ALIGN(FROM_NEW); }
  94 CXX_OPERATOR_ATTRIBUTE
  95 void *operator new[](size_t size, std::align_val_t align)
  96 { OPERATOR_NEW_BODY_ALIGN(FROM_NEW_BR); }
  97 CXX_OPERATOR_ATTRIBUTE
  98 void *operator new(size_t size, std::align_val_t align, std::nothrow_t const&)
  99 { OPERATOR_NEW_BODY_ALIGN(FROM_NEW); }
 100 CXX_OPERATOR_ATTRIBUTE
 101 void *operator new[](size_t size, std::align_val_t align, std::nothrow_t const&)
 102 { OPERATOR_NEW_BODY_ALIGN(FROM_NEW_BR); }
 103
 104 #else  // SANITIZER_MAC
 105 INTERCEPTOR(void *, _Znwm, size_t size) {
 106   OPERATOR_NEW_BODY(FROM_NEW);
 107 }
 108 INTERCEPTOR(void *, _Znam, size_t size) {
 109   OPERATOR_NEW_BODY(FROM_NEW_BR);
 110 }
 111 INTERCEPTOR(void *, _ZnwmRKSt9nothrow_t, size_t size, std::nothrow_t const&) {
 112   OPERATOR_NEW_BODY(FROM_NEW);
 113 }
 114 INTERCEPTOR(void *, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&) {
 115   OPERATOR_NEW_BODY(FROM_NEW_BR);
 116 }
 117 #endif
 118
 119 #define OPERATOR_DELETE_BODY(type) \
 120   GET_STACK_TRACE_FREE;\
 121   asan_free(ptr, &stack, type);
 122
 123 #if !SANITIZER_MAC
 124 CXX_OPERATOR_ATTRIBUTE
 125 void operator delete(void *ptr) NOEXCEPT {
 126   OPERATOR_DELETE_BODY(FROM_NEW);
 127 }
 128 CXX_OPERATOR_ATTRIBUTE
 129 void operator delete[](void *ptr) NOEXCEPT {
 130   OPERATOR_DELETE_BODY(FROM_NEW_BR);
 131 }
 132 CXX_OPERATOR_ATTRIBUTE
 133 void operator delete(void *ptr, std::nothrow_t const&) {
 134   OPERATOR_DELETE_BODY(FROM_NEW);
 135 }
 136 CXX_OPERATOR_ATTRIBUTE
 137 void operator delete[](void *ptr, std::nothrow_t const&) {
 138   OPERATOR_DELETE_BODY(FROM_NEW_BR);
 139 }
 140 CXX_OPERATOR_ATTRIBUTE
 141 void operator delete(void *ptr, size_t size) NOEXCEPT {
 142   GET_STACK_TRACE_FREE;
 143   asan_sized_free(ptr, size, &stack, FROM_NEW);
 144 }
 145 CXX_OPERATOR_ATTRIBUTE
 146 void operator delete[](void *ptr, size_t size) NOEXCEPT {
 147   GET_STACK_TRACE_FREE;
 148   asan_sized_free(ptr, size, &stack, FROM_NEW_BR);
 149 }
 150 CXX_OPERATOR_ATTRIBUTE
 151 void operator delete(void *ptr, std::align_val_t) NOEXCEPT {
 152   OPERATOR_DELETE_BODY(FROM_NEW);
 153 }
 154 CXX_OPERATOR_ATTRIBUTE
 155 void operator delete[](void *ptr, std::align_val_t) NOEXCEPT {
 156   OPERATOR_DELETE_BODY(FROM_NEW_BR);
 157 }
 158 CXX_OPERATOR_ATTRIBUTE
 159 void operator delete(void *ptr, std::align_val_t, std::nothrow_t const&) {
 160   OPERATOR_DELETE_BODY(FROM_NEW);
 161 }
 162 CXX_OPERATOR_ATTRIBUTE
 163 void operator delete[](void *ptr, std::align_val_t, std::nothrow_t const&) {
 164   OPERATOR_DELETE_BODY(FROM_NEW_BR);
 165 }
 166 CXX_OPERATOR_ATTRIBUTE
 167 void operator delete(void *ptr, size_t size, std::align_val_t) NOEXCEPT {
 168   GET_STACK_TRACE_FREE;
 169   asan_sized_free(ptr, size, &stack, FROM_NEW);
 170 }
 171 CXX_OPERATOR_ATTRIBUTE
 172 void operator delete[](void *ptr, size_t size, std::align_val_t) NOEXCEPT {
 173   GET_STACK_TRACE_FREE;
 174   asan_sized_free(ptr, size, &stack, FROM_NEW_BR);
 175 }
 176
 177 #else  // SANITIZER_MAC
 178 INTERCEPTOR(void, _ZdlPv, void *ptr) {
 179   OPERATOR_DELETE_BODY(FROM_NEW);
 180 }
 181 INTERCEPTOR(void, _ZdaPv, void *ptr) {
 182   OPERATOR_DELETE_BODY(FROM_NEW_BR);
 183 }
 184 INTERCEPTOR(void, _ZdlPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&) {
 185   OPERATOR_DELETE_BODY(FROM_NEW);
 186 }
 187 INTERCEPTOR(void, _ZdaPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&) {
 188   OPERATOR_DELETE_BODY(FROM_NEW_BR);
 189 }
 190 #endif