| 1 |
//===-- sanitizer_win_defs.h ------------------------------------*- C++ -*-===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
// |
| 9 |
// Common definitions for Windows-specific code. |
| 10 |
// |
| 11 |
//===----------------------------------------------------------------------===// |
| 12 |
#ifndef SANITIZER_WIN_DEFS_H |
| 13 |
#define SANITIZER_WIN_DEFS_H |
| 14 |
|
| 15 |
#include "sanitizer_platform.h" |
| 16 |
#if SANITIZER_WINDOWS |
| 17 |
|
| 18 |
#ifndef WINAPI |
| 19 |
#if defined(_M_IX86) || defined(__i386__) |
| 20 |
#define WINAPI __stdcall |
| 21 |
#else |
| 22 |
#define WINAPI |
| 23 |
#endif |
| 24 |
#endif |
| 25 |
|
| 26 |
#if defined(_M_IX86) || defined(__i386__) |
| 27 |
#define WIN_SYM_PREFIX "_" |
| 28 |
#else |
| 29 |
#define WIN_SYM_PREFIX |
| 30 |
#endif |
| 31 |
|
| 32 |
// For MinGW, the /export: directives contain undecorated symbols, contrary to |
| 33 |
// link/lld-link. The GNU linker doesn't support /alternatename and /include |
| 34 |
// though, thus lld-link in MinGW mode interprets them in the same way as |
| 35 |
// in the default mode. |
| 36 |
#ifdef __MINGW32__ |
| 37 |
#define WIN_EXPORT_PREFIX |
| 38 |
#else |
| 39 |
#define WIN_EXPORT_PREFIX WIN_SYM_PREFIX |
| 40 |
#endif |
| 41 |
|
| 42 |
// Intermediate macro to ensure the parameter is expanded before stringified. |
| 43 |
#define STRINGIFY_(A) #A |
| 44 |
#define STRINGIFY(A) STRINGIFY_(A) |
| 45 |
|
| 46 |
#if !SANITIZER_GO |
| 47 |
|
| 48 |
// ----------------- A workaround for the absence of weak symbols -------------- |
| 49 |
// We don't have a direct equivalent of weak symbols when using MSVC, but we can |
| 50 |
// use the /alternatename directive to tell the linker to default a specific |
| 51 |
// symbol to a specific value. |
| 52 |
// Take into account that this is a pragma directive for the linker, so it will |
| 53 |
// be ignored by the compiler and the function will be marked as UNDEF in the |
| 54 |
// symbol table of the resulting object file. The linker won't find the default |
| 55 |
// implementation until it links with that object file. |
| 56 |
// So, suppose we provide a default implementation "fundef" for "fun", and this |
| 57 |
// is compiled into the object file "test.obj" including the pragma directive. |
| 58 |
// If we have some code with references to "fun" and we link that code with |
| 59 |
// "test.obj", it will work because the linker always link object files. |
| 60 |
// But, if "test.obj" is included in a static library, like "test.lib", then the |
| 61 |
// liker will only link to "test.obj" if necessary. If we only included the |
| 62 |
// definition of "fun", it won't link to "test.obj" (from test.lib) because |
| 63 |
// "fun" appears as UNDEF, so it doesn't resolve the symbol "fun", and will |
| 64 |
// result in a link error (the linker doesn't find the pragma directive). |
| 65 |
// So, a workaround is to force linkage with the modules that include weak |
| 66 |
// definitions, with the following macro: WIN_FORCE_LINK() |
| 67 |
|
| 68 |
#define WIN_WEAK_ALIAS(Name, Default) \ |
| 69 |
__pragma(comment(linker, "/alternatename:" WIN_SYM_PREFIX STRINGIFY(Name) "="\ |
| 70 |
WIN_SYM_PREFIX STRINGIFY(Default))) |
| 71 |
|
| 72 |
#define WIN_FORCE_LINK(Name) \ |
| 73 |
__pragma(comment(linker, "/include:" WIN_SYM_PREFIX STRINGIFY(Name))) |
| 74 |
|
| 75 |
#define WIN_EXPORT(ExportedName, Name) \ |
| 76 |
__pragma(comment(linker, "/export:" WIN_EXPORT_PREFIX STRINGIFY(ExportedName)\ |
| 77 |
"=" WIN_EXPORT_PREFIX STRINGIFY(Name))) |
| 78 |
|
| 79 |
// We cannot define weak functions on Windows, but we can use WIN_WEAK_ALIAS() |
| 80 |
// which defines an alias to a default implementation, and only works when |
| 81 |
// linking statically. |
| 82 |
// So, to define a weak function "fun", we define a default implementation with |
| 83 |
// a different name "fun__def" and we create a "weak alias" fun = fun__def. |
| 84 |
// Then, users can override it just defining "fun". |
| 85 |
// We impose "extern "C"" because otherwise WIN_WEAK_ALIAS() will fail because |
| 86 |
// of name mangling. |
| 87 |
|
| 88 |
// Dummy name for default implementation of weak function. |
| 89 |
# define WEAK_DEFAULT_NAME(Name) Name##__def |
| 90 |
// Name for exported implementation of weak function. |
| 91 |
# define WEAK_EXPORT_NAME(Name) Name##__dll |
| 92 |
|
| 93 |
// Use this macro when you need to define and export a weak function from a |
| 94 |
// library. For example: |
| 95 |
// WIN_WEAK_EXPORT_DEF(bool, compare, int a, int b) { return a > b; } |
| 96 |
# define WIN_WEAK_EXPORT_DEF(ReturnType, Name, ...) \ |
| 97 |
WIN_WEAK_ALIAS(Name, WEAK_DEFAULT_NAME(Name)) \ |
| 98 |
WIN_EXPORT(WEAK_EXPORT_NAME(Name), Name) \ |
| 99 |
extern "C" ReturnType Name(__VA_ARGS__); \ |
| 100 |
extern "C" ReturnType WEAK_DEFAULT_NAME(Name)(__VA_ARGS__) |
| 101 |
|
| 102 |
// Use this macro when you need to import a weak function from a library. It |
| 103 |
// defines a weak alias to the imported function from the dll. For example: |
| 104 |
// WIN_WEAK_IMPORT_DEF(compare) |
| 105 |
# define WIN_WEAK_IMPORT_DEF(Name) \ |
| 106 |
WIN_WEAK_ALIAS(Name, WEAK_EXPORT_NAME(Name)) |
| 107 |
|
| 108 |
// So, for Windows we provide something similar to weak symbols in Linux, with |
| 109 |
// some differences: |
| 110 |
// + A default implementation must always be provided. |
| 111 |
// |
| 112 |
// + When linking statically it works quite similarly. For example: |
| 113 |
// |
| 114 |
// // libExample.cc |
| 115 |
// WIN_WEAK_EXPORT_DEF(bool, compare, int a, int b) { return a > b; } |
| 116 |
// |
| 117 |
// // client.cc |
| 118 |
// // We can use the default implementation from the library: |
| 119 |
// compare(1, 2); |
| 120 |
// // Or we can override it: |
| 121 |
// extern "C" bool compare (int a, int b) { return a >= b; } |
| 122 |
// |
| 123 |
// And it will work fine. If we don't override the function, we need to ensure |
| 124 |
// that the linker includes the object file with the default implementation. |
| 125 |
// We can do so with the linker option "-wholearchive:". |
| 126 |
// |
| 127 |
// + When linking dynamically with a library (dll), weak functions are exported |
| 128 |
// with "__dll" suffix. Clients can use the macro WIN_WEAK_IMPORT_DEF(fun) |
| 129 |
// which defines a "weak alias" fun = fun__dll. |
| 130 |
// |
| 131 |
// // libExample.cc |
| 132 |
// WIN_WEAK_EXPORT_DEF(bool, compare, int a, int b) { return a > b; } |
| 133 |
// |
| 134 |
// // client.cc |
| 135 |
// WIN_WEAK_IMPORT_DEF(compare) |
| 136 |
// // We can use the default implementation from the library: |
| 137 |
// compare(1, 2); |
| 138 |
// // Or we can override it: |
| 139 |
// extern "C" bool compare (int a, int b) { return a >= b; } |
| 140 |
// |
| 141 |
// But if we override the function, the dlls don't have access to it (which |
| 142 |
// is different in linux). If that is desired, the strong definition must be |
| 143 |
// exported and interception can be used from the rest of the dlls. |
| 144 |
// |
| 145 |
// // libExample.cc |
| 146 |
// WIN_WEAK_EXPORT_DEF(bool, compare, int a, int b) { return a > b; } |
| 147 |
// // When initialized, check if the main executable defined "compare". |
| 148 |
// int libExample_init() { |
| 149 |
// uptr fnptr = __interception::InternalGetProcAddress( |
| 150 |
// (void *)GetModuleHandleA(0), "compare"); |
| 151 |
// if (fnptr && !__interception::OverrideFunction((uptr)compare, fnptr, 0)) |
| 152 |
// abort(); |
| 153 |
// return 0; |
| 154 |
// } |
| 155 |
// |
| 156 |
// // client.cc |
| 157 |
// WIN_WEAK_IMPORT_DEF(compare) |
| 158 |
// // We override and export compare: |
| 159 |
// extern "C" __declspec(dllexport) bool compare (int a, int b) { |
| 160 |
// return a >= b; |
| 161 |
// } |
| 162 |
// |
| 163 |
|
| 164 |
#else // SANITIZER_GO |
| 165 |
|
| 166 |
// Go neither needs nor wants weak references. |
| 167 |
// The shenanigans above don't work for gcc. |
| 168 |
# define WIN_WEAK_EXPORT_DEF(ReturnType, Name, ...) \ |
| 169 |
extern "C" ReturnType Name(__VA_ARGS__) |
| 170 |
|
| 171 |
#endif // SANITIZER_GO |
| 172 |
|
| 173 |
#endif // SANITIZER_WINDOWS |
| 174 |
#endif // SANITIZER_WIN_DEFS_H |