This is an archive of the discontinued LLVM Phabricator instance.

Differential D29154

[compiler-rt] Split dll_thunks into different sanitizers.
ClosedPublic

Authored by mpividori on Jan 25 2017, 3:40 PM.

Details

Reviewers
kcc
kubamracek
zturner
alekseyshl
aizatsky
rnk
Commits
rGbfdfaa11cab0: [sanitizer] Split dll_thunks into different sanitizers.
rCRT293951: [sanitizer] Split dll_thunks into different sanitizers.
rL293951: [sanitizer] Split dll_thunks into different sanitizers.
Summary

In Windows, when the sanitizer is implemented as a static library and is included in the main executable, we need an auxiliary static library dll_thunk that will be linked to the dlls that have instrumentation, so they can refer to the runtime in the main executable. Basically, it uses interception to get a pointer the function in the main executable and override its function with that pointer.

Before this diff, all of this implementation was included in asan. In this diff I split it into different sanitizers, so we can use other sanitizers regardless of whether we include asan or not.

All the sanitizers will include a file sanitizer_win_dll_thunk.cc that register functions to be intercepted in the binary section: DLLTH

When the dll including dll_thunk is initialized, it will execute __dll_thunk_init() implemented in: sanitizer_common/sanitizer_win_dll_thunk.cc, which will consider all the CB registered in the section DLLTH. So, all the functions registered will be intercepted, and redirected to the implementation in the main executable.

All the files "sanitizer_win_dll_thunk.cc" are independent, so we don't need to include a specific list of sanitizers.
To create a dll_thunk for sanitizers SanitizerA and SanitizerB, we only need to compile: sanitizera/sanitizera_win_dll_thunk.cc sanitizerb/sanitizerb_win_dll_thunk.cc and sanitizer_common/sanitizer_win_dll_thunk.cc.

So, now, we compile: asan_win_dll_thunk.cc ubsan_win_dll_thunk.cc, sanitizer_coverage_win_dll_thunk.cc and sanitizer_win_dll_thunk.cc , to generate asan_dll_thunk, because we include asan, ubsan and sanitizer coverage in the address sanitizer library.

But we could also compile: sanitizer_coverage_win_dll_thunk.cc and sanitizer_win_dll_thunk.cc , to generate a dll_thunk only for sanitizer_coverage.

In a new diff I will add code to intercept weak functions.

Diff Detail

Repository
rL LLVM

Event Timeline

mpividori created this revision.Jan 25 2017, 3:40 PM
Herald added subscribers: mgorny, dberris. · View Herald TranscriptJan 25 2017, 3:40 PM
mpividori added a reviewer: alekseyshl.Jan 25 2017, 4:33 PM
mpividori updated this revision to Diff 85860.Jan 25 2017, 8:47 PM
mpividori added a subscriber: llvm-commits.Jan 26 2017, 12:43 AM
mpividori updated this revision to Diff 85929.Jan 26 2017, 9:21 AM
mpividori updated this revision to Diff 86098.Jan 27 2017, 12:29 PM
rnk edited edge metadata.Jan 30 2017, 10:10 AM

This thunking code needs to be rewritten at some point. It's basically doing it's own lazy PLT resolution. There must be some way that we can get the loader to do our work for us. It will already create thunks for functions provided by import libraries.

mpividori added a comment.Jan 30 2017, 10:22 AM

@rnk I would like to simply generate an import library. I have been reading some documentation to see if there is a way to simplify this and generate all of this code automatically with the linker. But, according to what I have found. (I really spent some time reading about this, but I don't have previous experience on Windows environment, so maybe I am missing something) . To create an import library, you need to provide exactly the same object files, that will be used to the final linkage. From: https://msdn.microsoft.com/en-us/library/f0z8kac4.aspx

"Note that if you create your import library in a preliminary step, before creating your .dll, you must pass the same set of object files when building the .dll, as you passed when building the import library."

So, as the library will be statically linked to the main executable, and we don't have access to the code in the main executable, we can not generate an import library.

mpividori updated this revision to Diff 86518.Jan 31 2017, 4:19 PM
mpividori added a comment.Jan 31 2017, 5:23 PM

@alekseyshl Would you agree with this diff? Ready to land?

alekseyshl accepted this revision.Feb 1 2017, 6:51 PM

LGTM

This revision is now accepted and ready to land.Feb 1 2017, 6:51 PM
Closed by commit rL293951: [sanitizer] Split dll_thunks into different sanitizers. (authored by mpividori). · Explain WhyFeb 2 2017, 3:12 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 86890

compiler-rt/trunk/lib/asan/CMakeLists.txt

Show First 20 Lines • Show All 199 Lines • ▼ Show 20 Lines if (UNIX AND NOT ${arch} MATCHES "i386|i686")
add_dependencies(asan clang_rt.asan_cxx-${arch}-symbols) add_dependencies(asan clang_rt.asan_cxx-${arch}-symbols)
add_sanitizer_rt_symbols(clang_rt.asan add_sanitizer_rt_symbols(clang_rt.asan
ARCHS ${arch} ARCHS ${arch}
EXTRA asan.syms.extra) EXTRA asan.syms.extra)
add_dependencies(asan clang_rt.asan-${arch}-symbols) add_dependencies(asan clang_rt.asan-${arch}-symbols)
endif() endif()
if (WIN32) if (WIN32)
add_compiler_rt_object_libraries(AsanDllThunk
${SANITIZER_COMMON_SUPPORTED_OS}
ARCHS ${ASAN_SUPPORTED_ARCH}
SOURCES asan_globals_win.cc
asan_win_dll_thunk.cc
CFLAGS ${ASAN_CFLAGS} -DSANITIZER_DLL_THUNK
DEFS ${ASAN_COMMON_DEFINITIONS})
add_compiler_rt_runtime(clang_rt.asan_dll_thunk add_compiler_rt_runtime(clang_rt.asan_dll_thunk
STATIC STATIC
ARCHS ${arch} ARCHS ${arch}
SOURCES asan_win_dll_thunk.cc OBJECT_LIBS AsanDllThunk
asan_globals_win.cc UbsanDllThunk
$<TARGET_OBJECTS:RTInterception.${arch}> SancovDllThunk
CFLAGS ${ASAN_CFLAGS} -DASAN_DLL_THUNK SanitizerCommonDllThunk
DEFS ${ASAN_COMMON_DEFINITIONS} SOURCES $<TARGET_OBJECTS:RTInterception.${arch}>
PARENT_TARGET asan) PARENT_TARGET asan)
set(DYNAMIC_RUNTIME_THUNK_CFLAGS "-DASAN_DYNAMIC_RUNTIME_THUNK") set(DYNAMIC_RUNTIME_THUNK_CFLAGS "-DASAN_DYNAMIC_RUNTIME_THUNK")
if(MSVC) if(MSVC)
list(APPEND DYNAMIC_RUNTIME_THUNK_CFLAGS "-Zl") list(APPEND DYNAMIC_RUNTIME_THUNK_CFLAGS "-Zl")
elseif(CMAKE_C_COMPILER_ID MATCHES Clang) elseif(CMAKE_C_COMPILER_ID MATCHES Clang)
list(APPEND DYNAMIC_RUNTIME_THUNK_CFLAGS "-nodefaultlibs") list(APPEND DYNAMIC_RUNTIME_THUNK_CFLAGS "-nodefaultlibs")
endif() endif()
Show All 20 Lines

compiler-rt/trunk/lib/asan/asan_globals_win.cc

Show All 23 Lines
__asan_global __asan_globals_end = {}; __asan_global __asan_globals_end = {};
#pragma comment(linker, "/merge:.ASAN=.data") #pragma comment(linker, "/merge:.ASAN=.data")
static void call_on_globals(void (*hook)(__asan_global *, uptr)) { static void call_on_globals(void (*hook)(__asan_global *, uptr)) {
__asan_global *start = &__asan_globals_start + 1; __asan_global *start = &__asan_globals_start + 1;
__asan_global *end = &__asan_globals_end; __asan_global *end = &__asan_globals_end;
uptr bytediff = (uptr)end - (uptr)start; uptr bytediff = (uptr)end - (uptr)start;
if (bytediff % sizeof(__asan_global) != 0) { if (bytediff % sizeof(__asan_global) != 0) {
#ifdef ASAN_DLL_THUNK #ifdef SANITIZER_DLL_THUNK
__debugbreak(); __debugbreak();
#else #else
CHECK("corrupt asan global array"); CHECK("corrupt asan global array");
#endif #endif
} }
// We know end >= start because the linker sorts the portion after the dollar // We know end >= start because the linker sorts the portion after the dollar
// sign alphabetically. // sign alphabetically.
uptr n = end - start; uptr n = end - start;
Show All 22 Lines

compiler-rt/trunk/lib/asan/asan_win_dll_thunk.cc

Show All 9 Lines
// This file is a part of AddressSanitizer, an address sanity checker. // This file is a part of AddressSanitizer, an address sanity checker.
// //
// This file defines a family of thunks that should be statically linked into // This file defines a family of thunks that should be statically linked into
// the DLLs that have ASan instrumentation in order to delegate the calls to the // the DLLs that have ASan instrumentation in order to delegate the calls to the
// shared runtime that lives in the main binary. // shared runtime that lives in the main binary.
// See https://github.com/google/sanitizers/issues/209 for the details. // See https://github.com/google/sanitizers/issues/209 for the details.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Only compile this code when building asan_dll_thunk.lib #ifdef SANITIZER_DLL_THUNK
// Using #ifdef rather than relying on Makefiles etc.
// simplifies the build procedure.
#ifdef ASAN_DLL_THUNK
#include "asan_init_version.h" #include "asan_init_version.h"
#include "interception/interception.h" #include "interception/interception.h"
#include "sanitizer_common/sanitizer_platform_interceptors.h"
#include "sanitizer_common/sanitizer_win_defs.h" #include "sanitizer_common/sanitizer_win_defs.h"
#include "sanitizer_common/sanitizer_win_dll_thunk.h"
#include "sanitizer_common/sanitizer_platform_interceptors.h"
#ifdef _M_IX86 // ASan own interface functions.
#define WINAPI __stdcall #define INTERFACE_FUNCTION(Name) INTERCEPT_SANITIZER_FUNCTION(Name)
#else #define INTERFACE_WEAK_FUNCTION(Name)
#define WINAPI #include "asan_interface.inc"
#endif
// Memory allocation functions.
// ---------- Function interception helper functions and macros ----------- {{{1 INTERCEPT_WRAP_V_W(free)
extern "C" { INTERCEPT_WRAP_V_W(_free_base)
void *WINAPI GetModuleHandleA(const char *module_name); INTERCEPT_WRAP_V_WW(_free_dbg)
void *WINAPI GetProcAddress(void *module, const char *proc_name);
void abort(); INTERCEPT_WRAP_W_W(malloc)
} INTERCEPT_WRAP_W_W(_malloc_base)
INTERCEPT_WRAP_W_WWWW(_malloc_dbg)
using namespace __sanitizer;
INTERCEPT_WRAP_W_WW(calloc)
static uptr getRealProcAddressOrDie(const char *name) { INTERCEPT_WRAP_W_WW(_calloc_base)
uptr ret = INTERCEPT_WRAP_W_WWWWW(_calloc_dbg)
__interception::InternalGetProcAddress((void *)GetModuleHandleA(0), name); INTERCEPT_WRAP_W_WWW(_calloc_impl)
if (!ret)
abort(); INTERCEPT_WRAP_W_WW(realloc)
return ret; INTERCEPT_WRAP_W_WW(_realloc_base)
} INTERCEPT_WRAP_W_WWW(_realloc_dbg)
INTERCEPT_WRAP_W_WWW(_recalloc)
// We need to intercept some functions (e.g. ASan interface, memory allocator -- INTERCEPT_WRAP_W_WWW(_recalloc_base)
// let's call them "hooks") exported by the DLL thunk and forward the hooks to
// the runtime in the main module. INTERCEPT_WRAP_W_W(_msize)
// However, we don't want to keep two lists of these hooks. INTERCEPT_WRAP_W_W(_expand)
// To avoid that, the list of hooks should be defined using the INTERCEPT_WRAP_W_W(_expand_dbg)
// INTERCEPT_WHEN_POSSIBLE macro. Then, all these hooks can be intercepted
// at once by calling INTERCEPT_HOOKS().
// Use macro+template magic to automatically generate the list of hooks.
// Each hook at line LINE defines a template class with a static
// FunctionInterceptor<LINE>::Execute() method intercepting the hook.
// The default implementation of FunctionInterceptor<LINE> is to call
// the Execute() method corresponding to the previous line.
template<int LINE>
struct FunctionInterceptor {
static void Execute() { FunctionInterceptor<LINE-1>::Execute(); }
};
// There shouldn't be any hooks with negative definition line number.
template<>
struct FunctionInterceptor<0> {
static void Execute() {}
};
#define INTERCEPT_WHEN_POSSIBLE(main_function, dll_function) \
template <> struct FunctionInterceptor<__LINE__> { \
static void Execute() { \
uptr wrapper = getRealProcAddressOrDie(main_function); \
if (!__interception::OverrideFunction((uptr)dll_function, wrapper, 0)) \
abort(); \
FunctionInterceptor<__LINE__ - 1>::Execute(); \
} \
};
// Special case of hooks -- ASan own interface functions. Those are only called
// after __asan_init, thus an empty implementation is sufficient.
#define INTERFACE_FUNCTION(name) \
extern "C" __declspec(noinline) void name() { \
volatile int prevent_icf = (__LINE__ << 8); (void)prevent_icf; \
__debugbreak(); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name)
// INTERCEPT_HOOKS must be used after the last INTERCEPT_WHEN_POSSIBLE.
#define INTERCEPT_HOOKS FunctionInterceptor<__LINE__>::Execute
// We can't define our own version of strlen etc. because that would lead to
// link-time or even type mismatch errors. Instead, we can declare a function
// just to be able to get its address. Me may miss the first few calls to the
// functions since it can be called before __asan_init, but that would lead to
// false negatives in the startup code before user's global initializers, which
// isn't a big deal.
#define INTERCEPT_LIBRARY_FUNCTION(name) \
extern "C" void name(); \
INTERCEPT_WHEN_POSSIBLE(WRAPPER_NAME(name), name)
// Disable compiler warnings that show up if we declare our own version
// of a compiler intrinsic (e.g. strlen).
#pragma warning(disable: 4391)
#pragma warning(disable: 4392)
static void InterceptHooks();
// }}}
// ---------- Function wrapping helpers ----------------------------------- {{{1
#define WRAP_V_V(name) \
extern "C" void name() { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
fn(); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
#define WRAP_V_W(name) \
extern "C" void name(void *arg) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
fn(arg); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
#define WRAP_V_WW(name) \
extern "C" void name(void *arg1, void *arg2) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
fn(arg1, arg2); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
#define WRAP_V_WWW(name) \
extern "C" void name(void *arg1, void *arg2, void *arg3) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
fn(arg1, arg2, arg3); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
#define WRAP_W_V(name) \
extern "C" void *name() { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
return fn(); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
#define WRAP_W_W(name) \
extern "C" void *name(void *arg) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
return fn(arg); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
#define WRAP_W_WW(name) \
extern "C" void *name(void *arg1, void *arg2) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
return fn(arg1, arg2); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
#define WRAP_W_WWW(name) \
extern "C" void *name(void *arg1, void *arg2, void *arg3) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
return fn(arg1, arg2, arg3); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
#define WRAP_W_WWWW(name) \
extern "C" void *name(void *arg1, void *arg2, void *arg3, void *arg4) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
return fn(arg1, arg2, arg3, arg4); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
#define WRAP_W_WWWWW(name) \
extern "C" void *name(void *arg1, void *arg2, void *arg3, void *arg4, \
void *arg5) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
return fn(arg1, arg2, arg3, arg4, arg5); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
#define WRAP_W_WWWWWW(name) \
extern "C" void *name(void *arg1, void *arg2, void *arg3, void *arg4, \
void *arg5, void *arg6) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)getRealProcAddressOrDie(#name); \
return fn(arg1, arg2, arg3, arg4, arg5, arg6); \
} \
INTERCEPT_WHEN_POSSIBLE(#name, name);
// }}}
// ----------------- ASan own interface functions --------------------
// Don't use the INTERFACE_FUNCTION machinery for this function as we actually
// want to call it in the __asan_init interceptor.
WRAP_W_V(__asan_should_detect_stack_use_after_return)
WRAP_W_V(__asan_get_shadow_memory_dynamic_address)
extern "C" {
int __asan_option_detect_stack_use_after_return;
uptr __asan_shadow_memory_dynamic_address;
// Manually wrap __asan_init as we need to initialize
// __asan_option_detect_stack_use_after_return afterwards.
void __asan_init() {
typedef void (*fntype)();
static fntype fn = 0;
// __asan_init is expected to be called by only one thread.
if (fn) return;
fn = (fntype)getRealProcAddressOrDie("__asan_init");
fn();
__asan_option_detect_stack_use_after_return =
(__asan_should_detect_stack_use_after_return() != 0);
__asan_shadow_memory_dynamic_address =
(uptr)__asan_get_shadow_memory_dynamic_address();
InterceptHooks();
}
}
extern "C" void __asan_version_mismatch_check() {
// Do nothing.
}
INTERFACE_FUNCTION(__asan_handle_no_return)
INTERFACE_FUNCTION(__asan_unhandled_exception_filter)
INTERFACE_FUNCTION(__asan_report_store1)
INTERFACE_FUNCTION(__asan_report_store2)
INTERFACE_FUNCTION(__asan_report_store4)
INTERFACE_FUNCTION(__asan_report_store8)
INTERFACE_FUNCTION(__asan_report_store16)
INTERFACE_FUNCTION(__asan_report_store_n)
INTERFACE_FUNCTION(__asan_report_load1)
INTERFACE_FUNCTION(__asan_report_load2)
INTERFACE_FUNCTION(__asan_report_load4)
INTERFACE_FUNCTION(__asan_report_load8)
INTERFACE_FUNCTION(__asan_report_load16)
INTERFACE_FUNCTION(__asan_report_load_n)
INTERFACE_FUNCTION(__asan_store1)
INTERFACE_FUNCTION(__asan_store2)
INTERFACE_FUNCTION(__asan_store4)
INTERFACE_FUNCTION(__asan_store8)
INTERFACE_FUNCTION(__asan_store16)
INTERFACE_FUNCTION(__asan_storeN)
INTERFACE_FUNCTION(__asan_load1)
INTERFACE_FUNCTION(__asan_load2)
INTERFACE_FUNCTION(__asan_load4)
INTERFACE_FUNCTION(__asan_load8)
INTERFACE_FUNCTION(__asan_load16)
INTERFACE_FUNCTION(__asan_loadN)
INTERFACE_FUNCTION(__asan_memcpy);
INTERFACE_FUNCTION(__asan_memset);
INTERFACE_FUNCTION(__asan_memmove);
INTERFACE_FUNCTION(__asan_set_shadow_00);
INTERFACE_FUNCTION(__asan_set_shadow_f1);
INTERFACE_FUNCTION(__asan_set_shadow_f2);
INTERFACE_FUNCTION(__asan_set_shadow_f3);
INTERFACE_FUNCTION(__asan_set_shadow_f5);
INTERFACE_FUNCTION(__asan_set_shadow_f8);
INTERFACE_FUNCTION(__asan_alloca_poison);
INTERFACE_FUNCTION(__asan_allocas_unpoison);
INTERFACE_FUNCTION(__asan_register_globals)
INTERFACE_FUNCTION(__asan_unregister_globals)
INTERFACE_FUNCTION(__asan_before_dynamic_init)
INTERFACE_FUNCTION(__asan_after_dynamic_init)
INTERFACE_FUNCTION(__asan_poison_stack_memory)
INTERFACE_FUNCTION(__asan_unpoison_stack_memory)
INTERFACE_FUNCTION(__asan_poison_memory_region)
INTERFACE_FUNCTION(__asan_unpoison_memory_region)
INTERFACE_FUNCTION(__asan_address_is_poisoned)
INTERFACE_FUNCTION(__asan_region_is_poisoned)
INTERFACE_FUNCTION(__asan_get_current_fake_stack)
INTERFACE_FUNCTION(__asan_addr_is_in_fake_stack)
INTERFACE_FUNCTION(__asan_stack_malloc_0)
INTERFACE_FUNCTION(__asan_stack_malloc_1)
INTERFACE_FUNCTION(__asan_stack_malloc_2)
INTERFACE_FUNCTION(__asan_stack_malloc_3)
INTERFACE_FUNCTION(__asan_stack_malloc_4)
INTERFACE_FUNCTION(__asan_stack_malloc_5)
INTERFACE_FUNCTION(__asan_stack_malloc_6)
INTERFACE_FUNCTION(__asan_stack_malloc_7)
INTERFACE_FUNCTION(__asan_stack_malloc_8)
INTERFACE_FUNCTION(__asan_stack_malloc_9)
INTERFACE_FUNCTION(__asan_stack_malloc_10)
INTERFACE_FUNCTION(__asan_stack_free_0)
INTERFACE_FUNCTION(__asan_stack_free_1)
INTERFACE_FUNCTION(__asan_stack_free_2)
INTERFACE_FUNCTION(__asan_stack_free_4)
INTERFACE_FUNCTION(__asan_stack_free_5)
INTERFACE_FUNCTION(__asan_stack_free_6)
INTERFACE_FUNCTION(__asan_stack_free_7)
INTERFACE_FUNCTION(__asan_stack_free_8)
INTERFACE_FUNCTION(__asan_stack_free_9)
INTERFACE_FUNCTION(__asan_stack_free_10)
// FIXME: we might want to have a sanitizer_win_dll_thunk?
INTERFACE_FUNCTION(__sanitizer_annotate_contiguous_container)
INTERFACE_FUNCTION(__sanitizer_contiguous_container_find_bad_address)
INTERFACE_FUNCTION(__sanitizer_cov)
INTERFACE_FUNCTION(__sanitizer_cov_dump)
INTERFACE_FUNCTION(__sanitizer_dump_coverage)
INTERFACE_FUNCTION(__sanitizer_dump_trace_pc_guard_coverage)
INTERFACE_FUNCTION(__sanitizer_cov_indir_call16)
INTERFACE_FUNCTION(__sanitizer_cov_init)
INTERFACE_FUNCTION(__sanitizer_cov_module_init)
INTERFACE_FUNCTION(__sanitizer_cov_trace_basic_block)
INTERFACE_FUNCTION(__sanitizer_cov_trace_func_enter)
INTERFACE_FUNCTION(__sanitizer_cov_with_check)
INTERFACE_FUNCTION(__sanitizer_get_allocated_size)
INTERFACE_FUNCTION(__sanitizer_get_coverage_guards)
INTERFACE_FUNCTION(__sanitizer_get_current_allocated_bytes)
INTERFACE_FUNCTION(__sanitizer_get_estimated_allocated_size)
INTERFACE_FUNCTION(__sanitizer_get_free_bytes)
INTERFACE_FUNCTION(__sanitizer_get_heap_size)
INTERFACE_FUNCTION(__sanitizer_get_ownership)
INTERFACE_FUNCTION(__sanitizer_get_total_unique_caller_callee_pairs)
INTERFACE_FUNCTION(__sanitizer_get_total_unique_coverage)
INTERFACE_FUNCTION(__sanitizer_get_unmapped_bytes)
INTERFACE_FUNCTION(__sanitizer_maybe_open_cov_file)
INTERFACE_FUNCTION(__sanitizer_print_stack_trace)
INTERFACE_FUNCTION(__sanitizer_symbolize_pc)
INTERFACE_FUNCTION(__sanitizer_symbolize_global)
INTERFACE_FUNCTION(__sanitizer_ptr_cmp)
INTERFACE_FUNCTION(__sanitizer_ptr_sub)
INTERFACE_FUNCTION(__sanitizer_reset_coverage)
INTERFACE_FUNCTION(__sanitizer_get_number_of_counters)
INTERFACE_FUNCTION(__sanitizer_update_counter_bitset_and_clear_counters)
INTERFACE_FUNCTION(__sanitizer_set_death_callback)
INTERFACE_FUNCTION(__sanitizer_set_report_path)
INTERFACE_FUNCTION(__sanitizer_set_report_fd)
INTERFACE_FUNCTION(__sanitizer_unaligned_load16)
INTERFACE_FUNCTION(__sanitizer_unaligned_load32)
INTERFACE_FUNCTION(__sanitizer_unaligned_load64)
INTERFACE_FUNCTION(__sanitizer_unaligned_store16)
INTERFACE_FUNCTION(__sanitizer_unaligned_store32)
INTERFACE_FUNCTION(__sanitizer_unaligned_store64)
INTERFACE_FUNCTION(__sanitizer_verify_contiguous_container)
INTERFACE_FUNCTION(__sanitizer_install_malloc_and_free_hooks)
INTERFACE_FUNCTION(__sanitizer_start_switch_fiber)
INTERFACE_FUNCTION(__sanitizer_finish_switch_fiber)
INTERFACE_FUNCTION(__sanitizer_get_module_and_offset_for_pc)
// TODO(timurrrr): Add more interface functions on the as-needed basis.
// ----------------- Memory allocation functions ---------------------
WRAP_V_W(free)
WRAP_V_W(_free_base)
WRAP_V_WW(_free_dbg)
WRAP_W_W(malloc)
WRAP_W_W(_malloc_base)
WRAP_W_WWWW(_malloc_dbg)
WRAP_W_WW(calloc)
WRAP_W_WW(_calloc_base)
WRAP_W_WWWWW(_calloc_dbg)
WRAP_W_WWW(_calloc_impl)
WRAP_W_WW(realloc)
WRAP_W_WW(_realloc_base)
WRAP_W_WWW(_realloc_dbg)
WRAP_W_WWW(_recalloc)
WRAP_W_WWW(_recalloc_base)
WRAP_W_W(_msize)
WRAP_W_W(_expand)
WRAP_W_W(_expand_dbg)
// TODO(timurrrr): Might want to add support for _aligned_* allocation // TODO(timurrrr): Might want to add support for _aligned_* allocation
// functions to detect a bit more bugs. Those functions seem to wrap malloc(). // functions to detect a bit more bugs. Those functions seem to wrap malloc().
// TODO(timurrrr): Do we need to add _Crt* stuff here? (see asan_malloc_win.cc). // TODO(timurrrr): Do we need to add _Crt* stuff here? (see asan_malloc_win.cc).
INTERCEPT_LIBRARY_FUNCTION(atoi); INTERCEPT_LIBRARY_FUNCTION(atoi);
INTERCEPT_LIBRARY_FUNCTION(atol); INTERCEPT_LIBRARY_FUNCTION(atol);
#ifdef _WIN64
INTERCEPT_LIBRARY_FUNCTION(__C_specific_handler);
#else
INTERCEPT_LIBRARY_FUNCTION(_except_handler3);
// _except_handler4 checks -GS cookie which is different for each module, so we
// can't use INTERCEPT_LIBRARY_FUNCTION(_except_handler4).
INTERCEPTOR(int, _except_handler4, void *a, void *b, void *c, void *d) {
__asan_handle_no_return();
return REAL(_except_handler4)(a, b, c, d);
}
#endif
INTERCEPT_LIBRARY_FUNCTION(frexp); INTERCEPT_LIBRARY_FUNCTION(frexp);
INTERCEPT_LIBRARY_FUNCTION(longjmp); INTERCEPT_LIBRARY_FUNCTION(longjmp);
#if SANITIZER_INTERCEPT_MEMCHR #if SANITIZER_INTERCEPT_MEMCHR
INTERCEPT_LIBRARY_FUNCTION(memchr); INTERCEPT_LIBRARY_FUNCTION(memchr);
#endif #endif
INTERCEPT_LIBRARY_FUNCTION(memcmp); INTERCEPT_LIBRARY_FUNCTION(memcmp);
INTERCEPT_LIBRARY_FUNCTION(memcpy); INTERCEPT_LIBRARY_FUNCTION(memcpy);
INTERCEPT_LIBRARY_FUNCTION(memmove); INTERCEPT_LIBRARY_FUNCTION(memmove);
Show All 11 Lines
INTERCEPT_LIBRARY_FUNCTION(strnlen); INTERCEPT_LIBRARY_FUNCTION(strnlen);
INTERCEPT_LIBRARY_FUNCTION(strpbrk); INTERCEPT_LIBRARY_FUNCTION(strpbrk);
INTERCEPT_LIBRARY_FUNCTION(strrchr); INTERCEPT_LIBRARY_FUNCTION(strrchr);
INTERCEPT_LIBRARY_FUNCTION(strspn); INTERCEPT_LIBRARY_FUNCTION(strspn);
INTERCEPT_LIBRARY_FUNCTION(strstr); INTERCEPT_LIBRARY_FUNCTION(strstr);
INTERCEPT_LIBRARY_FUNCTION(strtol); INTERCEPT_LIBRARY_FUNCTION(strtol);
INTERCEPT_LIBRARY_FUNCTION(wcslen); INTERCEPT_LIBRARY_FUNCTION(wcslen);
// Must be after all the interceptor declarations due to the way INTERCEPT_HOOKS #ifdef _WIN64
// is defined. INTERCEPT_LIBRARY_FUNCTION(__C_specific_handler);
void InterceptHooks() { #else
INTERCEPT_HOOKS(); INTERCEPT_LIBRARY_FUNCTION(_except_handler3);
#ifndef _WIN64 // _except_handler4 checks -GS cookie which is different for each module, so we
INTERCEPT_FUNCTION(_except_handler4); // can't use INTERCEPT_LIBRARY_FUNCTION(_except_handler4).
#endif INTERCEPTOR(int, _except_handler4, void *a, void *b, void *c, void *d) {
__asan_handle_no_return();
return REAL(_except_handler4)(a, b, c, d);
} }
#endif
// We want to call __asan_init before C/C++ initializers/constructors are // Window specific functions not included in asan_interface.inc.
// executed, otherwise functions like memset might be invoked. INTERCEPT_WRAP_W_V(__asan_should_detect_stack_use_after_return)
// For some strange reason, merely linking in asan_preinit.cc doesn't work INTERCEPT_WRAP_W_V(__asan_get_shadow_memory_dynamic_address)
// as the callback is never called... Is link.exe doing something too smart?
using namespace __sanitizer;
extern "C" {
int __asan_option_detect_stack_use_after_return;
uptr __asan_shadow_memory_dynamic_address;
} // extern "C"
static int asan_dll_thunk_init() {
typedef void (*fntype)();
static fntype fn = 0;
// asan_dll_thunk_init is expected to be called by only one thread.
if (fn) return 0;
// Ensure all interception was executed.
__dll_thunk_init();
fn = (fntype) dllThunkGetRealAddrOrDie("__asan_init");
fn();
__asan_option_detect_stack_use_after_return =
(__asan_should_detect_stack_use_after_return() != 0);
__asan_shadow_memory_dynamic_address =
(uptr)__asan_get_shadow_memory_dynamic_address();
#ifndef _WIN64
INTERCEPT_FUNCTION(_except_handler4);
#endif
// In DLLs, the callbacks are expected to return 0, // In DLLs, the callbacks are expected to return 0,
// otherwise CRT initialization fails. // otherwise CRT initialization fails.
static int call_asan_init() {
__asan_init();
return 0; return 0;
} }
#pragma section(".CRT$XIB", long, read) // NOLINT #pragma section(".CRT$XIB", long, read) // NOLINT
__declspec(allocate(".CRT$XIB")) int (*__asan_preinit)() = call_asan_init; __declspec(allocate(".CRT$XIB")) int (*__asan_preinit)() = asan_dll_thunk_init;
static void WINAPI asan_thread_init(void *mod, unsigned long reason, static void WINAPI asan_thread_init(void *mod, unsigned long reason,
void *reserved) { void *reserved) {
if (reason == /*DLL_PROCESS_ATTACH=*/1) __asan_init(); if (reason == /*DLL_PROCESS_ATTACH=*/1) asan_dll_thunk_init();
} }
#pragma section(".CRT$XLAB", long, read) // NOLINT #pragma section(".CRT$XLAB", long, read) // NOLINT
__declspec(allocate(".CRT$XLAB")) void (WINAPI *__asan_tls_init)(void *, __declspec(allocate(".CRT$XLAB")) void (WINAPI *__asan_tls_init)(void *,
unsigned long, void *) = asan_thread_init; unsigned long, void *) = asan_thread_init;
WIN_FORCE_LINK(__asan_dso_reg_hook) WIN_FORCE_LINK(__asan_dso_reg_hook)
#endif // ASAN_DLL_THUNK #endif // SANITIZER_DLL_THUNK

compiler-rt/trunk/lib/sanitizer_common/CMakeLists.txt

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Linesset(SANITIZER_HEADERS
sanitizer_symbolizer_internal.h sanitizer_symbolizer_internal.h
sanitizer_symbolizer_libbacktrace.h sanitizer_symbolizer_libbacktrace.h
sanitizer_symbolizer_mac.h sanitizer_symbolizer_mac.h
sanitizer_syscall_generic.inc sanitizer_syscall_generic.inc
sanitizer_syscall_linux_x86_64.inc sanitizer_syscall_linux_x86_64.inc
sanitizer_syscall_linux_aarch64.inc sanitizer_syscall_linux_aarch64.inc
sanitizer_thread_registry.h) sanitizer_thread_registry.h)
include_directories(..)
set(SANITIZER_COMMON_DEFINITIONS) set(SANITIZER_COMMON_DEFINITIONS)
include(CheckIncludeFile) include(CheckIncludeFile)
append_have_file_definition(rpc/xdr.h HAVE_RPC_XDR_H SANITIZER_COMMON_DEFINITIONS) append_have_file_definition(rpc/xdr.h HAVE_RPC_XDR_H SANITIZER_COMMON_DEFINITIONS)
append_have_file_definition(tirpc/rpc/xdr.h HAVE_TIRPC_RPC_XDR_H SANITIZER_COMMON_DEFINITIONS) append_have_file_definition(tirpc/rpc/xdr.h HAVE_TIRPC_RPC_XDR_H SANITIZER_COMMON_DEFINITIONS)
set(SANITIZER_CFLAGS ${SANITIZER_COMMON_CFLAGS}) set(SANITIZER_CFLAGS ${SANITIZER_COMMON_CFLAGS})
append_rtti_flag(OFF SANITIZER_CFLAGS) append_rtti_flag(OFF SANITIZER_CFLAGS)
Show All 40 Linesadd_compiler_rt_object_libraries(RTSanitizerCommonNoLibc
DEFS ${SANITIZER_COMMON_DEFINITIONS}) DEFS ${SANITIZER_COMMON_DEFINITIONS})
add_compiler_rt_object_libraries(RTSanitizerCommonLibc add_compiler_rt_object_libraries(RTSanitizerCommonLibc
${OS_OPTION} ${OS_OPTION}
ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH} ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
SOURCES ${SANITIZER_LIBCDEP_SOURCES} SOURCES ${SANITIZER_LIBCDEP_SOURCES}
CFLAGS ${SANITIZER_CFLAGS} CFLAGS ${SANITIZER_CFLAGS}
DEFS ${SANITIZER_COMMON_DEFINITIONS}) DEFS ${SANITIZER_COMMON_DEFINITIONS})
if(MSVC)
add_compiler_rt_object_libraries(SanitizerCommonDllThunk
${SANITIZER_COMMON_SUPPORTED_OS}
ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
SOURCES sanitizer_win_dll_thunk.cc
CFLAGS ${SANITIZER_CFLAGS} -DSANITIZER_DLL_THUNK
DEFS ${SANITIZER_COMMON_DEFINITIONS})
add_compiler_rt_object_libraries(SancovDllThunk
${SANITIZER_COMMON_SUPPORTED_OS}
ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
SOURCES sanitizer_coverage_win_dll_thunk.cc
CFLAGS ${SANITIZER_CFLAGS} -DSANITIZER_DLL_THUNK
DEFS ${SANITIZER_COMMON_DEFINITIONS})
endif()
# Unit tests for common sanitizer runtime. # Unit tests for common sanitizer runtime.
if(COMPILER_RT_INCLUDE_TESTS) if(COMPILER_RT_INCLUDE_TESTS)
add_subdirectory(tests) add_subdirectory(tests)
endif() endif()

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

//===-- sanitizer_coverage_win_dll_thunk.cc -------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines a family of thunks that should be statically linked into
// the DLLs that have instrumentation in order to delegate the calls to the
// shared runtime that lives in the main binary.
// See https://github.com/google/sanitizers/issues/209 for the details.
//===----------------------------------------------------------------------===//
#ifdef SANITIZER_DLL_THUNK
#include "sanitizer_win_dll_thunk.h"
// Sanitizer Coverage interface functions.
#define INTERFACE_FUNCTION(Name) INTERCEPT_SANITIZER_FUNCTION(Name)
#define INTERFACE_WEAK_FUNCTION(Name)
#include "sanitizer_coverage_interface.inc"
#endif // SANITIZER_DLL_THUNK

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

Show All 10 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SANITIZER_WIN_DEFS_H #ifndef SANITIZER_WIN_DEFS_H
#define SANITIZER_WIN_DEFS_H #define SANITIZER_WIN_DEFS_H
#include "sanitizer_platform.h" #include "sanitizer_platform.h"
#if SANITIZER_WINDOWS #if SANITIZER_WINDOWS
#ifdef _M_IX86
#define WINAPI __stdcall
#else
#define WINAPI
#endif
#if defined(_WIN64) #if defined(_WIN64)
#define WIN_SYM_PREFIX #define WIN_SYM_PREFIX
#else #else
#define WIN_SYM_PREFIX "_" #define WIN_SYM_PREFIX "_"
#endif #endif
// Intermediate macro to ensure the parameter is expanded before stringified. // Intermediate macro to ensure the parameter is expanded before stringified.
#define STRINGIFY_(A) #A #define STRINGIFY_(A) #A
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

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

//===-- sanitizer_win_dll_thunk.h -----------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// This header provide helper macros to delegate calls to the shared runtime
// that lives in the main executable. It should be included to dll_thunks that
// will be linked to the dlls, when the sanitizer is a static library included
// in the main executable.
//===----------------------------------------------------------------------===//
#ifndef SANITIZER_WIN_DLL_THUNK_H
#define SANITIZER_WIN_DLL_THUNK_H
#include "sanitizer_internal_defs.h"
namespace __sanitizer {
uptr dllThunkGetRealAddrOrDie(const char *name);
int dllThunkIntercept(const char* main_function, uptr dll_function);
}
extern "C" int __dll_thunk_init();
// ----------------- Function interception helper macros -------------------- //
// Override dll_function with main_function from main executable.
#define INTERCEPT_OR_DIE(main_function, dll_function) \
static int intercept_##dll_function() { \
return __sanitizer::dllThunkIntercept(main_function, (__sanitizer::uptr) \
dll_function); \
} \
__pragma(section(".DLLTH$M", long, read)) \
__declspec(allocate(".DLLTH$M")) int (*__dll_thunk_##dll_function)() = \
intercept_##dll_function;
// -------------------- Function interception macros ------------------------ //
// Special case of hooks -- ASan own interface functions. Those are only called
// after __asan_init, thus an empty implementation is sufficient.
#define INTERCEPT_SANITIZER_FUNCTION(name) \
extern "C" __declspec(noinline) void name() { \
volatile int prevent_icf = (__LINE__ << 8); (void)prevent_icf; \
__debugbreak(); \
} \
INTERCEPT_OR_DIE(#name, name)
// We can't define our own version of strlen etc. because that would lead to
// link-time or even type mismatch errors. Instead, we can declare a function
// just to be able to get its address. Me may miss the first few calls to the
// functions since it can be called before __dll_thunk_init, but that would lead
// to false negatives in the startup code before user's global initializers,
// which isn't a big deal.
#define INTERCEPT_LIBRARY_FUNCTION(name) \
extern "C" void name(); \
INTERCEPT_OR_DIE(WRAPPER_NAME(name), name)
// Use these macros for functions that could be called before __dll_thunk_init()
// is executed and don't lead to errors if defined (free, malloc, etc).
#define INTERCEPT_WRAP_V_V(name) \
extern "C" void name() { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
fn(); \
} \
INTERCEPT_OR_DIE(#name, name);
#define INTERCEPT_WRAP_V_W(name) \
extern "C" void name(void *arg) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
fn(arg); \
} \
INTERCEPT_OR_DIE(#name, name);
#define INTERCEPT_WRAP_V_WW(name) \
extern "C" void name(void *arg1, void *arg2) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
fn(arg1, arg2); \
} \
INTERCEPT_OR_DIE(#name, name);
#define INTERCEPT_WRAP_V_WWW(name) \
extern "C" void name(void *arg1, void *arg2, void *arg3) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
fn(arg1, arg2, arg3); \
} \
INTERCEPT_OR_DIE(#name, name);
#define INTERCEPT_WRAP_W_V(name) \
extern "C" void *name() { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
return fn(); \
} \
INTERCEPT_OR_DIE(#name, name);
#define INTERCEPT_WRAP_W_W(name) \
extern "C" void *name(void *arg) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
return fn(arg); \
} \
INTERCEPT_OR_DIE(#name, name);
#define INTERCEPT_WRAP_W_WW(name) \
extern "C" void *name(void *arg1, void *arg2) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
return fn(arg1, arg2); \
} \
INTERCEPT_OR_DIE(#name, name);
#define INTERCEPT_WRAP_W_WWW(name) \
extern "C" void *name(void *arg1, void *arg2, void *arg3) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
return fn(arg1, arg2, arg3); \
} \
INTERCEPT_OR_DIE(#name, name);
#define INTERCEPT_WRAP_W_WWWW(name) \
extern "C" void *name(void *arg1, void *arg2, void *arg3, void *arg4) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
return fn(arg1, arg2, arg3, arg4); \
} \
INTERCEPT_OR_DIE(#name, name);
#define INTERCEPT_WRAP_W_WWWWW(name) \
extern "C" void *name(void *arg1, void *arg2, void *arg3, void *arg4, \
void *arg5) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
return fn(arg1, arg2, arg3, arg4, arg5); \
} \
INTERCEPT_OR_DIE(#name, name);
#define INTERCEPT_WRAP_W_WWWWWW(name) \
extern "C" void *name(void *arg1, void *arg2, void *arg3, void *arg4, \
void *arg5, void *arg6) { \
typedef decltype(name) *fntype; \
static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name); \
return fn(arg1, arg2, arg3, arg4, arg5, arg6); \
} \
INTERCEPT_OR_DIE(#name, name);
#endif // SANITIZER_WIN_DLL_THUNK_H

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

//===-- sanitizer_win_dll_thunk.cc ----------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// This file defines a family of thunks that should be statically linked into
// the DLLs that have instrumentation in order to delegate the calls to the
// shared runtime that lives in the main binary.
// See https://github.com/google/sanitizers/issues/209 for the details.
//===----------------------------------------------------------------------===//
#ifdef SANITIZER_DLL_THUNK
#include "sanitizer_win_defs.h"
#include "sanitizer_win_dll_thunk.h"
#include "interception/interception.h"
extern "C" {
void *WINAPI GetModuleHandleA(const char *module_name);
void abort();
}
namespace __sanitizer {
uptr dllThunkGetRealAddrOrDie(const char *name) {
uptr ret =
__interception::InternalGetProcAddress((void *)GetModuleHandleA(0), name);
if (!ret)
abort();
return ret;
}
int dllThunkIntercept(const char* main_function, uptr dll_function) {
uptr wrapper = dllThunkGetRealAddrOrDie(main_function);
if (!__interception::OverrideFunction(dll_function, wrapper, 0))
abort();
return 0;
}
} // namespace __sanitizer
// Include Sanitizer Common interface.
#define INTERFACE_FUNCTION(Name) INTERCEPT_SANITIZER_FUNCTION(Name)
#define INTERFACE_WEAK_FUNCTION(Name)
#include "sanitizer_common_interface.inc"
#pragma section(".DLLTH$A", read) // NOLINT
#pragma section(".DLLTH$Z", read) // NOLINT
typedef void (*DllThunkCB)();
extern "C" {
__declspec(allocate(".DLLTH$A")) DllThunkCB __start_dll_thunk;
__declspec(allocate(".DLLTH$Z")) DllThunkCB __stop_dll_thunk;
}
// Disable compiler warnings that show up if we declare our own version
// of a compiler intrinsic (e.g. strlen).
#pragma warning(disable: 4391)
#pragma warning(disable: 4392)
extern "C" int __dll_thunk_init() {
static bool flag = false;
// __dll_thunk_init is expected to be called by only one thread.
if (flag) return 0;
flag = true;
for (DllThunkCB *it = &__start_dll_thunk; it < &__stop_dll_thunk; ++it)
if (*it)
(*it)();
// In DLLs, the callbacks are expected to return 0,
// otherwise CRT initialization fails.
return 0;
}
// We want to call dll_thunk_init before C/C++ initializers / constructors are
// executed, otherwise functions like memset might be invoked.
#pragma section(".CRT$XIB", long, read) // NOLINT
__declspec(allocate(".CRT$XIB")) int (*__dll_thunk_preinit)() =
__dll_thunk_init;
static void WINAPI dll_thunk_thread_init(void *mod, unsigned long reason,
void *reserved) {
if (reason == /*DLL_PROCESS_ATTACH=*/1) __dll_thunk_init();
}
#pragma section(".CRT$XLAB", long, read) // NOLINT
__declspec(allocate(".CRT$XLAB")) void (WINAPI *__dll_thunk_tls_init)(void *,
unsigned long, void *) = dll_thunk_thread_init;
#endif // SANITIZER_DLL_THUNK

compiler-rt/trunk/lib/ubsan/CMakeLists.txt

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines else()
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/cxx_dummy.cc "") file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/cxx_dummy.cc "")
set(UBSAN_CXX_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/cxx_dummy.cc) set(UBSAN_CXX_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/cxx_dummy.cc)
endif() endif()
add_compiler_rt_object_libraries(RTUbsan_cxx add_compiler_rt_object_libraries(RTUbsan_cxx
ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH} ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
SOURCES ${UBSAN_CXX_SOURCES} CFLAGS ${UBSAN_CXXFLAGS}) SOURCES ${UBSAN_CXX_SOURCES} CFLAGS ${UBSAN_CXXFLAGS})
if (WIN32)
add_compiler_rt_object_libraries(UbsanDllThunk
${SANITIZER_COMMON_SUPPORTED_OS}
ARCHS ${UBSAN_SUPPORTED_ARCH}
SOURCES ubsan_win_dll_thunk.cc
CFLAGS ${UBSAN_CFLAGS} -DSANITIZER_DLL_THUNK
DEFS ${UBSAN_COMMON_DEFINITIONS})
endif()
if(COMPILER_RT_HAS_UBSAN) if(COMPILER_RT_HAS_UBSAN)
# Initializer of standalone UBSan runtime. # Initializer of standalone UBSan runtime.
add_compiler_rt_object_libraries(RTUbsan_standalone add_compiler_rt_object_libraries(RTUbsan_standalone
ARCHS ${UBSAN_SUPPORTED_ARCH} ARCHS ${UBSAN_SUPPORTED_ARCH}
SOURCES ${UBSAN_STANDALONE_SOURCES} CFLAGS ${UBSAN_STANDALONE_CFLAGS}) SOURCES ${UBSAN_STANDALONE_SOURCES} CFLAGS ${UBSAN_STANDALONE_CFLAGS})
# Standalone UBSan runtimes. # Standalone UBSan runtimes.
add_compiler_rt_runtime(clang_rt.ubsan_standalone add_compiler_rt_runtime(clang_rt.ubsan_standalone
Show All 30 Lines

compiler-rt/trunk/lib/ubsan/ubsan_win_dll_thunk.cc

//===-- ubsan_win_dll_thunk.cc --------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines a family of thunks that should be statically linked into
// the DLLs that have instrumentation in order to delegate the calls to the
// shared runtime that lives in the main binary.
// See https://github.com/google/sanitizers/issues/209 for the details.
//===----------------------------------------------------------------------===//
#ifdef SANITIZER_DLL_THUNK
#include "sanitizer_common/sanitizer_win_dll_thunk.h"
// Ubsan interface functions.
#define INTERFACE_FUNCTION(Name) INTERCEPT_SANITIZER_FUNCTION(Name)
#define INTERFACE_WEAK_FUNCTION(Name)
#include "ubsan_interface.inc"
#endif // SANITIZER_DLL_THUNK