//===-- sanitizer_win_thunk_interception.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 defines things that need to be present in the application modules
// to interact with sanitizer DLL correctly and cannot be implemented using the
// default "import library" generated when linking the DLL.
//
// This includes the common infrastructure required to intercept local functions
// that must be replaced with sanitizer-aware versions, as well as the
// registration of weak functions with the sanitizer DLL. With this in-place,
// other sanitizer components can simply write to the .INTR and .WEAK sections.
//
//===----------------------------------------------------------------------===//
#if defined(SANITIZER_STATIC_RUNTIME_THUNK) || \
defined(SANITIZER_DYNAMIC_RUNTIME_THUNK)
# include "sanitizer_win_thunk_interception.h"
extern "C" void abort();
namespace __sanitizer {
int override_function(const char *export_name, const uptr user_function) {
if (!__sanitizer_override_function(export_name, user_function)) {
abort();
}
return 0;
}
int register_weak(const char *export_name, const uptr user_function) {
if (!__sanitizer_register_weak_function(export_name, user_function)) {
abort();
}
return 0;
}
void initialize_thunks(const sanitizer_thunk *first,
const sanitizer_thunk *last) {
for (const sanitizer_thunk *it = first; it < last; ++it) {
if (*it) {
(*it)();
}
}
}
} // namespace __sanitizer
# define INTERFACE_FUNCTION(Name)
# define INTERFACE_WEAK_FUNCTION(Name) REGISTER_WEAK_FUNCTION(Name)
# include "sanitizer_common_interface.inc"
# pragma section(".INTR$A", read) // intercept begin
# pragma section(".INTR$Z", read) // intercept end
# pragma section(".WEAK$A", read) // weak begin
# pragma section(".WEAK$Z", read) // weak end
extern "C" {
__declspec(allocate(
".INTR$A")) sanitizer_thunk __sanitizer_intercept_thunk_begin;
__declspec(allocate(".INTR$Z")) sanitizer_thunk __sanitizer_intercept_thunk_end;
__declspec(allocate(
".WEAK$A")) sanitizer_thunk __sanitizer_register_weak_thunk_begin;
__declspec(allocate(
".WEAK$Z")) sanitizer_thunk __sanitizer_register_weak_thunk_end;
}
extern "C" int __sanitizer_thunk_init() {
// __sanitizer_static_thunk_init is expected to be called by only one thread.
static bool flag = false;
if (flag) {
return 0;
}
flag = true;
__sanitizer::initialize_thunks(&__sanitizer_intercept_thunk_begin,
&__sanitizer_intercept_thunk_end);
__sanitizer::initialize_thunks(&__sanitizer_register_weak_thunk_begin,
&__sanitizer_register_weak_thunk_end);
// 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)
__declspec(allocate(".CRT$XIB")) int (*__sanitizer_thunk_init_ptr)() =
__sanitizer_thunk_init;
static void WINAPI sanitizer_thunk_thread_init(void *mod, unsigned long reason,
void *reserved) {
if (reason == /*DLL_PROCESS_ATTACH=*/1)
__sanitizer_thunk_init();
}
# pragma section(".CRT$XLAB", long, read)
__declspec(allocate(".CRT$XLAB")) void(
WINAPI *__sanitizer_thunk_thread_init_ptr)(void *, unsigned long, void *) =
sanitizer_thunk_thread_init;
#endif // defined(SANITIZER_STATIC_RUNTIME_THUNK) ||
// defined(SANITIZER_DYNAMIC_RUNTIME_THUNK)