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 175