lib/lsan/lsan_interceptors.cpp - llvm-project/compiler-rt - Git at Google

 //=-- lsan_interceptors.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of LeakSanitizer.
 // Interceptors for standalone LSan.
 //
 //===----------------------------------------------------------------------===//

 #include "interception/interception.h"
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_allocator_dlsym.h"
 #include "sanitizer_common/sanitizer_allocator_report.h"
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_linux.h"
 #include "sanitizer_common/sanitizer_platform_interceptors.h"
 #include "sanitizer_common/sanitizer_platform_limits_netbsd.h"
 #include "sanitizer_common/sanitizer_platform_limits_posix.h"
 #if SANITIZER_POSIX
 #include "sanitizer_common/sanitizer_posix.h"
 #endif
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
 #include "lsan.h"
 #include "lsan_allocator.h"
 #include "lsan_common.h"
 #include "lsan_thread.h"

 #include <stddef.h>

 using namespace __lsan;

 extern "C" {
 int pthread_attr_init(void *attr);
 int pthread_attr_destroy(void *attr);
 int pthread_attr_getdetachstate(void *attr, int *v);
 int pthread_key_create(unsigned *key, void (*destructor)(void* v));
 int pthread_setspecific(unsigned key, const void *v);
 }

 struct DlsymAlloc : DlSymAllocator<DlsymAlloc> {
   static bool UseImpl() { return lsan_init_is_running; }
   static void OnAllocate(const void *ptr, uptr size) {
 #if CAN_SANITIZE_LEAKS
     // Suppress leaks from dlerror(). Previously dlsym hack on global array was
     // used by leak sanitizer as a root region.
     __lsan_register_root_region(ptr, size);
 #endif
   }
   static void OnFree(const void *ptr, uptr size) {
 #if CAN_SANITIZE_LEAKS
     __lsan_unregister_root_region(ptr, size);
 #endif
   }
 };

 ///// Malloc/free interceptors. /////

 namespace std {
   struct nothrow_t;
   enum class align_val_t: size_t;
 }

 #if !SANITIZER_APPLE
 INTERCEPTOR(void*, malloc, uptr size) {
   if (DlsymAlloc::Use())
     return DlsymAlloc::Allocate(size);
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_malloc(size, stack);
 }

 INTERCEPTOR(void, free, void *p) {
   if (DlsymAlloc::PointerIsMine(p))
     return DlsymAlloc::Free(p);
   ENSURE_LSAN_INITED;
   lsan_free(p);
 }

 INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
   if (DlsymAlloc::Use())
     return DlsymAlloc::Callocate(nmemb, size);
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_calloc(nmemb, size, stack);
 }

 INTERCEPTOR(void *, realloc, void *ptr, uptr size) {
   if (DlsymAlloc::Use() || DlsymAlloc::PointerIsMine(ptr))
     return DlsymAlloc::Realloc(ptr, size);
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_realloc(ptr, size, stack);
 }

 INTERCEPTOR(void*, reallocarray, void *q, uptr nmemb, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_reallocarray(q, nmemb, size, stack);
 }

 INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_posix_memalign(memptr, alignment, size, stack);
 }

 INTERCEPTOR(void*, valloc, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_valloc(size, stack);
 }
 #endif  // !SANITIZER_APPLE

 #if SANITIZER_INTERCEPT_MEMALIGN
 INTERCEPTOR(void*, memalign, uptr alignment, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_memalign(alignment, size, stack);
 }
 #define LSAN_MAYBE_INTERCEPT_MEMALIGN INTERCEPT_FUNCTION(memalign)
 #else
 #define LSAN_MAYBE_INTERCEPT_MEMALIGN
 #endif  // SANITIZER_INTERCEPT_MEMALIGN

 #if SANITIZER_INTERCEPT___LIBC_MEMALIGN
 INTERCEPTOR(void *, __libc_memalign, uptr alignment, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   void *res = lsan_memalign(alignment, size, stack);
   DTLS_on_libc_memalign(res, size);
   return res;
 }
 #define LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN INTERCEPT_FUNCTION(__libc_memalign)
 #else
 #define LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN
 #endif  // SANITIZER_INTERCEPT___LIBC_MEMALIGN

 #if SANITIZER_INTERCEPT_ALIGNED_ALLOC
 INTERCEPTOR(void*, aligned_alloc, uptr alignment, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_aligned_alloc(alignment, size, stack);
 }
 #define LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC INTERCEPT_FUNCTION(aligned_alloc)
 #else
 #define LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC
 #endif

 #if SANITIZER_INTERCEPT_MALLOC_USABLE_SIZE
 INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
   ENSURE_LSAN_INITED;
   return GetMallocUsableSize(ptr);
 }
 #define LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE \
         INTERCEPT_FUNCTION(malloc_usable_size)
 #else
 #define LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE
 #endif

 #if SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 struct fake_mallinfo {
   int x[10];
 };

 INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
   struct fake_mallinfo res;
   internal_memset(&res, 0, sizeof(res));
   return res;
 }
 #define LSAN_MAYBE_INTERCEPT_MALLINFO INTERCEPT_FUNCTION(mallinfo)

 INTERCEPTOR(int, mallopt, int cmd, int value) {
   return 0;
 }
 #define LSAN_MAYBE_INTERCEPT_MALLOPT INTERCEPT_FUNCTION(mallopt)
 #else
 #define LSAN_MAYBE_INTERCEPT_MALLINFO
 #define LSAN_MAYBE_INTERCEPT_MALLOPT
 #endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO

 #if SANITIZER_INTERCEPT_PVALLOC
 INTERCEPTOR(void*, pvalloc, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return lsan_pvalloc(size, stack);
 }
 #define LSAN_MAYBE_INTERCEPT_PVALLOC INTERCEPT_FUNCTION(pvalloc)
 #else
 #define LSAN_MAYBE_INTERCEPT_PVALLOC
 #endif // SANITIZER_INTERCEPT_PVALLOC

 #if SANITIZER_INTERCEPT_CFREE
 INTERCEPTOR(void, cfree, void *p) ALIAS(WRAP(free));
 #define LSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree)
 #else
 #define LSAN_MAYBE_INTERCEPT_CFREE
 #endif // SANITIZER_INTERCEPT_CFREE

 #if SANITIZER_INTERCEPT_MCHECK_MPROBE
 INTERCEPTOR(int, mcheck, void (*abortfunc)(int mstatus)) {
   return 0;
 }

 INTERCEPTOR(int, mcheck_pedantic, void (*abortfunc)(int mstatus)) {
   return 0;
 }

 INTERCEPTOR(int, mprobe, void *ptr) {
   return 0;
 }
 #endif // SANITIZER_INTERCEPT_MCHECK_MPROBE


 // TODO(alekseys): throw std::bad_alloc instead of dying on OOM.
 #define OPERATOR_NEW_BODY(nothrow)\
   ENSURE_LSAN_INITED;\
   GET_STACK_TRACE_MALLOC;\
   void *res = lsan_malloc(size, stack);\
   if (!nothrow && UNLIKELY(!res)) ReportOutOfMemory(size, &stack);\
   return res;
 #define OPERATOR_NEW_BODY_ALIGN(nothrow)\
   ENSURE_LSAN_INITED;\
   GET_STACK_TRACE_MALLOC;\
   void *res = lsan_memalign((uptr)align, size, stack);\
   if (!nothrow && UNLIKELY(!res)) ReportOutOfMemory(size, &stack);\
   return res;

 #define OPERATOR_DELETE_BODY\
   ENSURE_LSAN_INITED;\
   lsan_free(ptr);

 // On OS X it's not enough to just provide our own 'operator new' and
 // 'operator delete' implementations, because they're going to be in the runtime
 // dylib, and the main executable will depend on both the runtime dylib and
 // libstdc++, each of has its implementation of new and delete.
 // To make sure that C++ allocation/deallocation operators are overridden on
 // OS X we need to intercept them using their mangled names.
 #if !SANITIZER_APPLE

 INTERCEPTOR_ATTRIBUTE
 void *operator new(size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/); }
 INTERCEPTOR_ATTRIBUTE
 void *operator new[](size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/); }
 INTERCEPTOR_ATTRIBUTE
 void *operator new(size_t size, std::nothrow_t const&)
 { OPERATOR_NEW_BODY(true /*nothrow*/); }
 INTERCEPTOR_ATTRIBUTE
 void *operator new[](size_t size, std::nothrow_t const&)
 { OPERATOR_NEW_BODY(true /*nothrow*/); }
 INTERCEPTOR_ATTRIBUTE
 void *operator new(size_t size, std::align_val_t align)
 { OPERATOR_NEW_BODY_ALIGN(false /*nothrow*/); }
 INTERCEPTOR_ATTRIBUTE
 void *operator new[](size_t size, std::align_val_t align)
 { OPERATOR_NEW_BODY_ALIGN(false /*nothrow*/); }
 INTERCEPTOR_ATTRIBUTE
 void *operator new(size_t size, std::align_val_t align, std::nothrow_t const&)
 { OPERATOR_NEW_BODY_ALIGN(true /*nothrow*/); }
 INTERCEPTOR_ATTRIBUTE
 void *operator new[](size_t size, std::align_val_t align, std::nothrow_t const&)
 { OPERATOR_NEW_BODY_ALIGN(true /*nothrow*/); }

 INTERCEPTOR_ATTRIBUTE
 void operator delete(void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete[](void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete(void *ptr, std::nothrow_t const&) { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete[](void *ptr, std::nothrow_t const &)
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete(void *ptr, size_t size) NOEXCEPT
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete[](void *ptr, size_t size) NOEXCEPT
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete(void *ptr, std::align_val_t) NOEXCEPT
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete[](void *ptr, std::align_val_t) NOEXCEPT
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete(void *ptr, std::align_val_t, std::nothrow_t const&)
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete[](void *ptr, std::align_val_t, std::nothrow_t const&)
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete(void *ptr, size_t size, std::align_val_t) NOEXCEPT
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE
 void operator delete[](void *ptr, size_t size, std::align_val_t) NOEXCEPT
 { OPERATOR_DELETE_BODY; }

 #else  // SANITIZER_APPLE

 INTERCEPTOR(void *, _Znwm, size_t size)
 { OPERATOR_NEW_BODY(false /*nothrow*/); }
 INTERCEPTOR(void *, _Znam, size_t size)
 { OPERATOR_NEW_BODY(false /*nothrow*/); }
 INTERCEPTOR(void *, _ZnwmRKSt9nothrow_t, size_t size, std::nothrow_t const&)
 { OPERATOR_NEW_BODY(true /*nothrow*/); }
 INTERCEPTOR(void *, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&)
 { OPERATOR_NEW_BODY(true /*nothrow*/); }

 INTERCEPTOR(void, _ZdlPv, void *ptr)
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR(void, _ZdaPv, void *ptr)
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR(void, _ZdlPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&)
 { OPERATOR_DELETE_BODY; }
 INTERCEPTOR(void, _ZdaPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&)
 { OPERATOR_DELETE_BODY; }

 #endif  // !SANITIZER_APPLE


 ///// Thread initialization and finalization. /////

 #if !SANITIZER_NETBSD && !SANITIZER_FREEBSD && !SANITIZER_FUCHSIA
 static unsigned g_thread_finalize_key;

 static void thread_finalize(void *v) {
   uptr iter = (uptr)v;
   if (iter > 1) {
     if (pthread_setspecific(g_thread_finalize_key, (void*)(iter - 1))) {
       Report("LeakSanitizer: failed to set thread key.\n");
       Die();
     }
     return;
   }
   ThreadFinish();
 }
 #endif

 #if SANITIZER_NETBSD
 INTERCEPTOR(void, _lwp_exit) {
   ENSURE_LSAN_INITED;
   ThreadFinish();
   REAL(_lwp_exit)();
 }
 #define LSAN_MAYBE_INTERCEPT__LWP_EXIT INTERCEPT_FUNCTION(_lwp_exit)
 #else
 #define LSAN_MAYBE_INTERCEPT__LWP_EXIT
 #endif

 #if SANITIZER_INTERCEPT_THR_EXIT
 INTERCEPTOR(void, thr_exit, tid_t *state) {
   ENSURE_LSAN_INITED;
   ThreadFinish();
   REAL(thr_exit)(state);
 }
 #define LSAN_MAYBE_INTERCEPT_THR_EXIT INTERCEPT_FUNCTION(thr_exit)
 #else
 #define LSAN_MAYBE_INTERCEPT_THR_EXIT
 #endif

 #if SANITIZER_INTERCEPT___CXA_ATEXIT
 INTERCEPTOR(int, __cxa_atexit, void (*func)(void *), void *arg,
             void *dso_handle) {
   __lsan::ScopedInterceptorDisabler disabler;
   return REAL(__cxa_atexit)(func, arg, dso_handle);
 }
 #define LSAN_MAYBE_INTERCEPT___CXA_ATEXIT INTERCEPT_FUNCTION(__cxa_atexit)
 #else
 #define LSAN_MAYBE_INTERCEPT___CXA_ATEXIT
 #endif

 #if SANITIZER_INTERCEPT_ATEXIT
 INTERCEPTOR(int, atexit, void (*f)()) {
   __lsan::ScopedInterceptorDisabler disabler;
   return REAL(__cxa_atexit)((void (*)(void *a))f, 0, 0);
 }
 #define LSAN_MAYBE_INTERCEPT_ATEXIT INTERCEPT_FUNCTION(atexit)
 #else
 #define LSAN_MAYBE_INTERCEPT_ATEXIT
 #endif

 #if SANITIZER_INTERCEPT_PTHREAD_ATFORK
 extern "C" {
 extern int _pthread_atfork(void (*prepare)(), void (*parent)(),
                            void (*child)());
 };

 INTERCEPTOR(int, pthread_atfork, void (*prepare)(), void (*parent)(),
             void (*child)()) {
   __lsan::ScopedInterceptorDisabler disabler;
   // REAL(pthread_atfork) cannot be called due to symbol indirections at least
   // on NetBSD
   return _pthread_atfork(prepare, parent, child);
 }
 #define LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK INTERCEPT_FUNCTION(pthread_atfork)
 #else
 #define LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK
 #endif

 #if SANITIZER_INTERCEPT_STRERROR
 INTERCEPTOR(char *, strerror, int errnum) {
   __lsan::ScopedInterceptorDisabler disabler;
   return REAL(strerror)(errnum);
 }
 #define LSAN_MAYBE_INTERCEPT_STRERROR INTERCEPT_FUNCTION(strerror)
 #else
 #define LSAN_MAYBE_INTERCEPT_STRERROR
 #endif

 #if SANITIZER_POSIX

 template <bool Detached>
 static void *ThreadStartFunc(void *arg) {
   u32 parent_tid = (uptr)arg;
   uptr tid = ThreadCreate(parent_tid, Detached);
   // Wait until the last iteration to maximize the chance that we are the last
   // destructor to run.
 #if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
   if (pthread_setspecific(g_thread_finalize_key,
                           (void*)GetPthreadDestructorIterations())) {
     Report("LeakSanitizer: failed to set thread key.\n");
     Die();
   }
 #  endif
   ThreadStart(tid, GetTid());
   auto self = GetThreadSelf();
   auto args = GetThreadArgRetval().GetArgs(self);
   void *retval = (*args.routine)(args.arg_retval);
   GetThreadArgRetval().Finish(self, retval);
   return retval;
 }

 INTERCEPTOR(int, pthread_create, void *th, void *attr,
             void *(*callback)(void *), void *param) {
   ENSURE_LSAN_INITED;
   EnsureMainThreadIDIsCorrect();

   bool detached = [attr]() {
     int d = 0;
     return attr && !pthread_attr_getdetachstate(attr, &d) && IsStateDetached(d);
   }();

   __sanitizer_pthread_attr_t myattr;
   if (!attr) {
     pthread_attr_init(&myattr);
     attr = &myattr;
   }
   AdjustStackSize(attr);
   uptr this_tid = GetCurrentThreadId();
   int result;
   {
     // Ignore all allocations made by pthread_create: thread stack/TLS may be
     // stored by pthread for future reuse even after thread destruction, and
     // the linked list it's stored in doesn't even hold valid pointers to the
     // objects, the latter are calculated by obscure pointer arithmetic.
     ScopedInterceptorDisabler disabler;
     GetThreadArgRetval().Create(detached, {callback, param}, [&]() -> uptr {
       result = REAL(pthread_create)(
           th, attr, detached ? ThreadStartFunc<true> : ThreadStartFunc<false>,
           (void *)this_tid);
       return result ? 0 : *(uptr *)(th);
     });
   }
   if (attr == &myattr)
     pthread_attr_destroy(&myattr);
   return result;
 }

 INTERCEPTOR(int, pthread_join, void *thread, void **retval) {
   int result;
   GetThreadArgRetval().Join((uptr)thread, [&]() {
     result = REAL(pthread_join)(thread, retval);
     return !result;
   });
   return result;
 }

 INTERCEPTOR(int, pthread_detach, void *thread) {
   int result;
   GetThreadArgRetval().Detach((uptr)thread, [&]() {
     result = REAL(pthread_detach)(thread);
     return !result;
   });
   return result;
 }

 INTERCEPTOR(void, pthread_exit, void *retval) {
   GetThreadArgRetval().Finish(GetThreadSelf(), retval);
   REAL(pthread_exit)(retval);
 }

 #  if SANITIZER_INTERCEPT_TRYJOIN
 INTERCEPTOR(int, pthread_tryjoin_np, void *thread, void **ret) {
   int result;
   GetThreadArgRetval().Join((uptr)thread, [&]() {
     result = REAL(pthread_tryjoin_np)(thread, ret);
     return !result;
   });
   return result;
 }
 #    define LSAN_MAYBE_INTERCEPT_TRYJOIN INTERCEPT_FUNCTION(pthread_tryjoin_np)
 #  else
 #    define LSAN_MAYBE_INTERCEPT_TRYJOIN
 #  endif  // SANITIZER_INTERCEPT_TRYJOIN

 #  if SANITIZER_INTERCEPT_TIMEDJOIN
 INTERCEPTOR(int, pthread_timedjoin_np, void *thread, void **ret,
             const struct timespec *abstime) {
   int result;
   GetThreadArgRetval().Join((uptr)thread, [&]() {
     result = REAL(pthread_timedjoin_np)(thread, ret, abstime);
     return !result;
   });
   return result;
 }
 #    define LSAN_MAYBE_INTERCEPT_TIMEDJOIN \
       INTERCEPT_FUNCTION(pthread_timedjoin_np)
 #  else
 #    define LSAN_MAYBE_INTERCEPT_TIMEDJOIN
 #  endif  // SANITIZER_INTERCEPT_TIMEDJOIN

 DEFINE_REAL_PTHREAD_FUNCTIONS

 INTERCEPTOR(void, _exit, int status) {
   if (status == 0 && HasReportedLeaks()) status = common_flags()->exitcode;
   REAL(_exit)(status);
 }

 #define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name)
 #define SIGNAL_INTERCEPTOR_ENTER() ENSURE_LSAN_INITED
 #include "sanitizer_common/sanitizer_signal_interceptors.inc"

 #endif  // SANITIZER_POSIX

 namespace __lsan {

 void InitializeInterceptors() {
   // Fuchsia doesn't use interceptors that require any setup.
 #if !SANITIZER_FUCHSIA
   __interception::DoesNotSupportStaticLinking();
   InitializeSignalInterceptors();

   INTERCEPT_FUNCTION(malloc);
   INTERCEPT_FUNCTION(free);
   LSAN_MAYBE_INTERCEPT_CFREE;
   INTERCEPT_FUNCTION(calloc);
   INTERCEPT_FUNCTION(realloc);
   LSAN_MAYBE_INTERCEPT_MEMALIGN;
   LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN;
   LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC;
   INTERCEPT_FUNCTION(posix_memalign);
   INTERCEPT_FUNCTION(valloc);
   LSAN_MAYBE_INTERCEPT_PVALLOC;
   LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE;
   LSAN_MAYBE_INTERCEPT_MALLINFO;
   LSAN_MAYBE_INTERCEPT_MALLOPT;
   INTERCEPT_FUNCTION(pthread_create);
   INTERCEPT_FUNCTION(pthread_join);
   INTERCEPT_FUNCTION(pthread_detach);
   INTERCEPT_FUNCTION(pthread_exit);
   LSAN_MAYBE_INTERCEPT_TIMEDJOIN;
   LSAN_MAYBE_INTERCEPT_TRYJOIN;
   INTERCEPT_FUNCTION(_exit);

   LSAN_MAYBE_INTERCEPT__LWP_EXIT;
   LSAN_MAYBE_INTERCEPT_THR_EXIT;

   LSAN_MAYBE_INTERCEPT___CXA_ATEXIT;
   LSAN_MAYBE_INTERCEPT_ATEXIT;
   LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK;

   LSAN_MAYBE_INTERCEPT_STRERROR;

 #if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
   if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
     Report("LeakSanitizer: failed to create thread key.\n");
     Die();
   }
 #endif

 #endif  // !SANITIZER_FUCHSIA
 }

 } // namespace __lsan
	//=-- lsan_interceptors.cpp -----------------------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file is a part of LeakSanitizer.
	// Interceptors for standalone LSan.
	//
	//===----------------------------------------------------------------------===//

	#include "interception/interception.h"
	#include "sanitizer_common/sanitizer_allocator.h"
	#include "sanitizer_common/sanitizer_allocator_dlsym.h"
	#include "sanitizer_common/sanitizer_allocator_report.h"
	#include "sanitizer_common/sanitizer_atomic.h"
	#include "sanitizer_common/sanitizer_common.h"
	#include "sanitizer_common/sanitizer_flags.h"
	#include "sanitizer_common/sanitizer_internal_defs.h"
	#include "sanitizer_common/sanitizer_linux.h"
	#include "sanitizer_common/sanitizer_platform_interceptors.h"
	#include "sanitizer_common/sanitizer_platform_limits_netbsd.h"
	#include "sanitizer_common/sanitizer_platform_limits_posix.h"
	#if SANITIZER_POSIX
	#include "sanitizer_common/sanitizer_posix.h"
	#endif
	#include "sanitizer_common/sanitizer_tls_get_addr.h"
	#include "lsan.h"
	#include "lsan_allocator.h"
	#include "lsan_common.h"
	#include "lsan_thread.h"

	#include <stddef.h>

	using namespace __lsan;

	extern "C" {
	int pthread_attr_init(void *attr);
	int pthread_attr_destroy(void *attr);
	int pthread_attr_getdetachstate(void attr, int v);
	int pthread_key_create(unsigned key, void (destructor)(void* v));
	int pthread_setspecific(unsigned key, const void *v);
	}

	struct DlsymAlloc : DlSymAllocator<DlsymAlloc> {
	static bool UseImpl() { return lsan_init_is_running; }
	static void OnAllocate(const void *ptr, uptr size) {
	#if CAN_SANITIZE_LEAKS
	// Suppress leaks from dlerror(). Previously dlsym hack on global array was
	// used by leak sanitizer as a root region.
	__lsan_register_root_region(ptr, size);
	#endif
	}
	static void OnFree(const void *ptr, uptr size) {
	#if CAN_SANITIZE_LEAKS
	__lsan_unregister_root_region(ptr, size);
	#endif
	}
	};

	///// Malloc/free interceptors. /////

	namespace std {
	struct nothrow_t;
	enum class align_val_t: size_t;
	}

	#if !SANITIZER_APPLE
	INTERCEPTOR(void*, malloc, uptr size) {
	if (DlsymAlloc::Use())
	return DlsymAlloc::Allocate(size);
	ENSURE_LSAN_INITED;
	GET_STACK_TRACE_MALLOC;
	return lsan_malloc(size, stack);
	}

	INTERCEPTOR(void, free, void *p) {
	if (DlsymAlloc::PointerIsMine(p))
	return DlsymAlloc::Free(p);
	ENSURE_LSAN_INITED;
	lsan_free(p);
	}

	INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
	if (DlsymAlloc::Use())
	return DlsymAlloc::Callocate(nmemb, size);
	ENSURE_LSAN_INITED;
	GET_STACK_TRACE_MALLOC;
	return lsan_calloc(nmemb, size, stack);
	}

	INTERCEPTOR(void , realloc, void ptr, uptr size) {
	if (DlsymAlloc::Use() \|\| DlsymAlloc::PointerIsMine(ptr))
	return DlsymAlloc::Realloc(ptr, size);
	ENSURE_LSAN_INITED;
	GET_STACK_TRACE_MALLOC;
	return lsan_realloc(ptr, size, stack);
	}

	INTERCEPTOR(void, reallocarray, void q, uptr nmemb, uptr size) {
	ENSURE_LSAN_INITED;
	GET_STACK_TRACE_MALLOC;
	return lsan_reallocarray(q, nmemb, size, stack);
	}

	INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
	ENSURE_LSAN_INITED;
	GET_STACK_TRACE_MALLOC;
	return lsan_posix_memalign(memptr, alignment, size, stack);
	}

	INTERCEPTOR(void*, valloc, uptr size) {
	ENSURE_LSAN_INITED;
	GET_STACK_TRACE_MALLOC;
	return lsan_valloc(size, stack);
	}
	#endif // !SANITIZER_APPLE

	#if SANITIZER_INTERCEPT_MEMALIGN
	INTERCEPTOR(void*, memalign, uptr alignment, uptr size) {
	ENSURE_LSAN_INITED;
	GET_STACK_TRACE_MALLOC;
	return lsan_memalign(alignment, size, stack);
	}
	#define LSAN_MAYBE_INTERCEPT_MEMALIGN INTERCEPT_FUNCTION(memalign)
	#else
	#define LSAN_MAYBE_INTERCEPT_MEMALIGN
	#endif // SANITIZER_INTERCEPT_MEMALIGN

	#if SANITIZER_INTERCEPT___LIBC_MEMALIGN
	INTERCEPTOR(void *, __libc_memalign, uptr alignment, uptr size) {
	ENSURE_LSAN_INITED;
	GET_STACK_TRACE_MALLOC;
	void *res = lsan_memalign(alignment, size, stack);
	DTLS_on_libc_memalign(res, size);
	return res;
	}
	#define LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN INTERCEPT_FUNCTION(__libc_memalign)
	#else
	#define LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN
	#endif // SANITIZER_INTERCEPT___LIBC_MEMALIGN

	#if SANITIZER_INTERCEPT_ALIGNED_ALLOC
	INTERCEPTOR(void*, aligned_alloc, uptr alignment, uptr size) {
	ENSURE_LSAN_INITED;
	GET_STACK_TRACE_MALLOC;
	return lsan_aligned_alloc(alignment, size, stack);
	}
	#define LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC INTERCEPT_FUNCTION(aligned_alloc)
	#else
	#define LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC
	#endif

	#if SANITIZER_INTERCEPT_MALLOC_USABLE_SIZE
	INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
	ENSURE_LSAN_INITED;
	return GetMallocUsableSize(ptr);
	}
	#define LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE \
	INTERCEPT_FUNCTION(malloc_usable_size)
	#else
	#define LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE
	#endif

	#if SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
	struct fake_mallinfo {
	int x[10];
	};

	INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
	struct fake_mallinfo res;
	internal_memset(&res, 0, sizeof(res));
	return res;
	}
	#define LSAN_MAYBE_INTERCEPT_MALLINFO INTERCEPT_FUNCTION(mallinfo)

	INTERCEPTOR(int, mallopt, int cmd, int value) {
	return 0;
	}
	#define LSAN_MAYBE_INTERCEPT_MALLOPT INTERCEPT_FUNCTION(mallopt)
	#else
	#define LSAN_MAYBE_INTERCEPT_MALLINFO
	#define LSAN_MAYBE_INTERCEPT_MALLOPT
	#endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO

	#if SANITIZER_INTERCEPT_PVALLOC
	INTERCEPTOR(void*, pvalloc, uptr size) {
	ENSURE_LSAN_INITED;
	GET_STACK_TRACE_MALLOC;
	return lsan_pvalloc(size, stack);
	}
	#define LSAN_MAYBE_INTERCEPT_PVALLOC INTERCEPT_FUNCTION(pvalloc)
	#else
	#define LSAN_MAYBE_INTERCEPT_PVALLOC
	#endif // SANITIZER_INTERCEPT_PVALLOC

	#if SANITIZER_INTERCEPT_CFREE
	INTERCEPTOR(void, cfree, void *p) ALIAS(WRAP(free));
	#define LSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree)
	#else
	#define LSAN_MAYBE_INTERCEPT_CFREE
	#endif // SANITIZER_INTERCEPT_CFREE

	#if SANITIZER_INTERCEPT_MCHECK_MPROBE
	INTERCEPTOR(int, mcheck, void (*abortfunc)(int mstatus)) {
	return 0;
	}

	INTERCEPTOR(int, mcheck_pedantic, void (*abortfunc)(int mstatus)) {
	return 0;
	}

	INTERCEPTOR(int, mprobe, void *ptr) {
	return 0;
	}
	#endif // SANITIZER_INTERCEPT_MCHECK_MPROBE


	// TODO(alekseys): throw std::bad_alloc instead of dying on OOM.
	#define OPERATOR_NEW_BODY(nothrow)\
	ENSURE_LSAN_INITED;\
	GET_STACK_TRACE_MALLOC;\
	void *res = lsan_malloc(size, stack);\
	if (!nothrow && UNLIKELY(!res)) ReportOutOfMemory(size, &stack);\
	return res;
	#define OPERATOR_NEW_BODY_ALIGN(nothrow)\
	ENSURE_LSAN_INITED;\
	GET_STACK_TRACE_MALLOC;\
	void *res = lsan_memalign((uptr)align, size, stack);\
	if (!nothrow && UNLIKELY(!res)) ReportOutOfMemory(size, &stack);\
	return res;

	#define OPERATOR_DELETE_BODY\
	ENSURE_LSAN_INITED;\
	lsan_free(ptr);

	// On OS X it's not enough to just provide our own 'operator new' and
	// 'operator delete' implementations, because they're going to be in the runtime
	// dylib, and the main executable will depend on both the runtime dylib and
	// libstdc++, each of has its implementation of new and delete.
	// To make sure that C++ allocation/deallocation operators are overridden on
	// OS X we need to intercept them using their mangled names.
	#if !SANITIZER_APPLE

	INTERCEPTOR_ATTRIBUTE
	void operator new(size_t size) { OPERATOR_NEW_BODY(false /nothrow*/); }
	INTERCEPTOR_ATTRIBUTE
	void operator new[](size_t size) { OPERATOR_NEW_BODY(false /nothrow*/); }
	INTERCEPTOR_ATTRIBUTE
	void *operator new(size_t size, std::nothrow_t const&)
	{ OPERATOR_NEW_BODY(true /nothrow/); }
	INTERCEPTOR_ATTRIBUTE
	void *operator new[](size_t size, std::nothrow_t const&)
	{ OPERATOR_NEW_BODY(true /nothrow/); }
	INTERCEPTOR_ATTRIBUTE
	void *operator new(size_t size, std::align_val_t align)
	{ OPERATOR_NEW_BODY_ALIGN(false /nothrow/); }
	INTERCEPTOR_ATTRIBUTE
	void *operator new[](size_t size, std::align_val_t align)
	{ OPERATOR_NEW_BODY_ALIGN(false /nothrow/); }
	INTERCEPTOR_ATTRIBUTE
	void *operator new(size_t size, std::align_val_t align, std::nothrow_t const&)
	{ OPERATOR_NEW_BODY_ALIGN(true /nothrow/); }
	INTERCEPTOR_ATTRIBUTE
	void *operator new[](size_t size, std::align_val_t align, std::nothrow_t const&)
	{ OPERATOR_NEW_BODY_ALIGN(true /nothrow/); }

	INTERCEPTOR_ATTRIBUTE
	void operator delete(void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete[](void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete(void *ptr, std::nothrow_t const&) { OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete[](void *ptr, std::nothrow_t const &)
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete(void *ptr, size_t size) NOEXCEPT
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete[](void *ptr, size_t size) NOEXCEPT
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete(void *ptr, std::align_val_t) NOEXCEPT
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete[](void *ptr, std::align_val_t) NOEXCEPT
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete(void *ptr, std::align_val_t, std::nothrow_t const&)
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete[](void *ptr, std::align_val_t, std::nothrow_t const&)
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete(void *ptr, size_t size, std::align_val_t) NOEXCEPT
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR_ATTRIBUTE
	void operator delete[](void *ptr, size_t size, std::align_val_t) NOEXCEPT
	{ OPERATOR_DELETE_BODY; }

	#else // SANITIZER_APPLE

	INTERCEPTOR(void *, _Znwm, size_t size)
	{ OPERATOR_NEW_BODY(false /nothrow/); }
	INTERCEPTOR(void *, _Znam, size_t size)
	{ OPERATOR_NEW_BODY(false /nothrow/); }
	INTERCEPTOR(void *, _ZnwmRKSt9nothrow_t, size_t size, std::nothrow_t const&)
	{ OPERATOR_NEW_BODY(true /nothrow/); }
	INTERCEPTOR(void *, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&)
	{ OPERATOR_NEW_BODY(true /nothrow/); }

	INTERCEPTOR(void, _ZdlPv, void *ptr)
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR(void, _ZdaPv, void *ptr)
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR(void, _ZdlPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&)
	{ OPERATOR_DELETE_BODY; }
	INTERCEPTOR(void, _ZdaPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&)
	{ OPERATOR_DELETE_BODY; }

	#endif // !SANITIZER_APPLE


	///// Thread initialization and finalization. /////

	#if !SANITIZER_NETBSD && !SANITIZER_FREEBSD && !SANITIZER_FUCHSIA
	static unsigned g_thread_finalize_key;

	static void thread_finalize(void *v) {
	uptr iter = (uptr)v;
	if (iter > 1) {
	if (pthread_setspecific(g_thread_finalize_key, (void*)(iter - 1))) {
	Report("LeakSanitizer: failed to set thread key.\n");
	Die();
	}
	return;
	}
	ThreadFinish();
	}
	#endif

	#if SANITIZER_NETBSD
	INTERCEPTOR(void, _lwp_exit) {
	ENSURE_LSAN_INITED;
	ThreadFinish();
	REAL(_lwp_exit)();
	}
	#define LSAN_MAYBE_INTERCEPT__LWP_EXIT INTERCEPT_FUNCTION(_lwp_exit)
	#else
	#define LSAN_MAYBE_INTERCEPT__LWP_EXIT
	#endif

	#if SANITIZER_INTERCEPT_THR_EXIT
	INTERCEPTOR(void, thr_exit, tid_t *state) {
	ENSURE_LSAN_INITED;
	ThreadFinish();
	REAL(thr_exit)(state);
	}
	#define LSAN_MAYBE_INTERCEPT_THR_EXIT INTERCEPT_FUNCTION(thr_exit)
	#else
	#define LSAN_MAYBE_INTERCEPT_THR_EXIT
	#endif

	#if SANITIZER_INTERCEPT___CXA_ATEXIT
	INTERCEPTOR(int, __cxa_atexit, void (func)(void ), void *arg,
	void *dso_handle) {
	__lsan::ScopedInterceptorDisabler disabler;
	return REAL(__cxa_atexit)(func, arg, dso_handle);
	}
	#define LSAN_MAYBE_INTERCEPT___CXA_ATEXIT INTERCEPT_FUNCTION(__cxa_atexit)
	#else
	#define LSAN_MAYBE_INTERCEPT___CXA_ATEXIT
	#endif

	#if SANITIZER_INTERCEPT_ATEXIT
	INTERCEPTOR(int, atexit, void (*f)()) {
	__lsan::ScopedInterceptorDisabler disabler;
	return REAL(__cxa_atexit)((void ()(void a))f, 0, 0);
	}
	#define LSAN_MAYBE_INTERCEPT_ATEXIT INTERCEPT_FUNCTION(atexit)
	#else
	#define LSAN_MAYBE_INTERCEPT_ATEXIT
	#endif

	#if SANITIZER_INTERCEPT_PTHREAD_ATFORK
	extern "C" {
	extern int _pthread_atfork(void (prepare)(), void (parent)(),
	void (*child)());
	};

	INTERCEPTOR(int, pthread_atfork, void (prepare)(), void (parent)(),
	void (*child)()) {
	__lsan::ScopedInterceptorDisabler disabler;
	// REAL(pthread_atfork) cannot be called due to symbol indirections at least
	// on NetBSD
	return _pthread_atfork(prepare, parent, child);
	}
	#define LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK INTERCEPT_FUNCTION(pthread_atfork)
	#else
	#define LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK
	#endif

	#if SANITIZER_INTERCEPT_STRERROR
	INTERCEPTOR(char *, strerror, int errnum) {
	__lsan::ScopedInterceptorDisabler disabler;
	return REAL(strerror)(errnum);
	}
	#define LSAN_MAYBE_INTERCEPT_STRERROR INTERCEPT_FUNCTION(strerror)
	#else
	#define LSAN_MAYBE_INTERCEPT_STRERROR
	#endif

	#if SANITIZER_POSIX

	template <bool Detached>
	static void ThreadStartFunc(void arg) {
	u32 parent_tid = (uptr)arg;
	uptr tid = ThreadCreate(parent_tid, Detached);
	// Wait until the last iteration to maximize the chance that we are the last
	// destructor to run.
	#if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
	if (pthread_setspecific(g_thread_finalize_key,
	(void*)GetPthreadDestructorIterations())) {
	Report("LeakSanitizer: failed to set thread key.\n");
	Die();
	}
	# endif
	ThreadStart(tid, GetTid());
	auto self = GetThreadSelf();
	auto args = GetThreadArgRetval().GetArgs(self);
	void retval = (args.routine)(args.arg_retval);
	GetThreadArgRetval().Finish(self, retval);
	return retval;
	}

	INTERCEPTOR(int, pthread_create, void th, void attr,
	void (callback)(void ), void param) {
	ENSURE_LSAN_INITED;
	EnsureMainThreadIDIsCorrect();

	bool detached = [attr]() {
	int d = 0;
	return attr && !pthread_attr_getdetachstate(attr, &d) && IsStateDetached(d);
	}();

	__sanitizer_pthread_attr_t myattr;
	if (!attr) {
	pthread_attr_init(&myattr);
	attr = &myattr;
	}
	AdjustStackSize(attr);
	uptr this_tid = GetCurrentThreadId();
	int result;
	{
	// Ignore all allocations made by pthread_create: thread stack/TLS may be
	// stored by pthread for future reuse even after thread destruction, and
	// the linked list it's stored in doesn't even hold valid pointers to the
	// objects, the latter are calculated by obscure pointer arithmetic.
	ScopedInterceptorDisabler disabler;
	GetThreadArgRetval().Create(detached, {callback, param}, [&]() -> uptr {
	result = REAL(pthread_create)(
	th, attr, detached ? ThreadStartFunc<true> : ThreadStartFunc<false>,
	(void *)this_tid);
	return result ? 0 : (uptr )(th);
	});
	}
	if (attr == &myattr)
	pthread_attr_destroy(&myattr);
	return result;
	}

	INTERCEPTOR(int, pthread_join, void thread, void *retval) {
	int result;
	GetThreadArgRetval().Join((uptr)thread, [&]() {
	result = REAL(pthread_join)(thread, retval);
	return !result;
	});
	return result;
	}

	INTERCEPTOR(int, pthread_detach, void *thread) {
	int result;
	GetThreadArgRetval().Detach((uptr)thread, [&]() {
	result = REAL(pthread_detach)(thread);
	return !result;
	});
	return result;
	}

	INTERCEPTOR(void, pthread_exit, void *retval) {
	GetThreadArgRetval().Finish(GetThreadSelf(), retval);
	REAL(pthread_exit)(retval);
	}

	# if SANITIZER_INTERCEPT_TRYJOIN
	INTERCEPTOR(int, pthread_tryjoin_np, void thread, void *ret) {
	int result;
	GetThreadArgRetval().Join((uptr)thread, [&]() {
	result = REAL(pthread_tryjoin_np)(thread, ret);
	return !result;
	});
	return result;
	}
	# define LSAN_MAYBE_INTERCEPT_TRYJOIN INTERCEPT_FUNCTION(pthread_tryjoin_np)
	# else
	# define LSAN_MAYBE_INTERCEPT_TRYJOIN
	# endif // SANITIZER_INTERCEPT_TRYJOIN

	# if SANITIZER_INTERCEPT_TIMEDJOIN
	INTERCEPTOR(int, pthread_timedjoin_np, void thread, void *ret,
	const struct timespec *abstime) {
	int result;
	GetThreadArgRetval().Join((uptr)thread, [&]() {
	result = REAL(pthread_timedjoin_np)(thread, ret, abstime);
	return !result;
	});
	return result;
	}
	# define LSAN_MAYBE_INTERCEPT_TIMEDJOIN \
	INTERCEPT_FUNCTION(pthread_timedjoin_np)
	# else
	# define LSAN_MAYBE_INTERCEPT_TIMEDJOIN
	# endif // SANITIZER_INTERCEPT_TIMEDJOIN

	DEFINE_REAL_PTHREAD_FUNCTIONS

	INTERCEPTOR(void, _exit, int status) {
	if (status == 0 && HasReportedLeaks()) status = common_flags()->exitcode;
	REAL(_exit)(status);
	}

	#define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name)
	#define SIGNAL_INTERCEPTOR_ENTER() ENSURE_LSAN_INITED
	#include "sanitizer_common/sanitizer_signal_interceptors.inc"

	#endif // SANITIZER_POSIX

	namespace __lsan {

	void InitializeInterceptors() {
	// Fuchsia doesn't use interceptors that require any setup.
	#if !SANITIZER_FUCHSIA
	__interception::DoesNotSupportStaticLinking();
	InitializeSignalInterceptors();

	INTERCEPT_FUNCTION(malloc);
	INTERCEPT_FUNCTION(free);
	LSAN_MAYBE_INTERCEPT_CFREE;
	INTERCEPT_FUNCTION(calloc);
	INTERCEPT_FUNCTION(realloc);
	LSAN_MAYBE_INTERCEPT_MEMALIGN;
	LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN;
	LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC;
	INTERCEPT_FUNCTION(posix_memalign);
	INTERCEPT_FUNCTION(valloc);
	LSAN_MAYBE_INTERCEPT_PVALLOC;
	LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE;
	LSAN_MAYBE_INTERCEPT_MALLINFO;
	LSAN_MAYBE_INTERCEPT_MALLOPT;
	INTERCEPT_FUNCTION(pthread_create);
	INTERCEPT_FUNCTION(pthread_join);
	INTERCEPT_FUNCTION(pthread_detach);
	INTERCEPT_FUNCTION(pthread_exit);
	LSAN_MAYBE_INTERCEPT_TIMEDJOIN;
	LSAN_MAYBE_INTERCEPT_TRYJOIN;
	INTERCEPT_FUNCTION(_exit);

	LSAN_MAYBE_INTERCEPT__LWP_EXIT;
	LSAN_MAYBE_INTERCEPT_THR_EXIT;

	LSAN_MAYBE_INTERCEPT___CXA_ATEXIT;
	LSAN_MAYBE_INTERCEPT_ATEXIT;
	LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK;

	LSAN_MAYBE_INTERCEPT_STRERROR;

	#if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
	if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
	Report("LeakSanitizer: failed to create thread key.\n");
	Die();
	}
	#endif

	#endif // !SANITIZER_FUCHSIA
	}

	} // namespace __lsan