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