1//===- MinGW.cpp ----------------------------------------------------------===//
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#include "MinGW.h"
10#include "COFFLinkerContext.h"
11#include "Driver.h"
12#include "InputFiles.h"
13#include "SymbolTable.h"
14#include "llvm/ADT/DenseMap.h"
15#include "llvm/ADT/DenseSet.h"
16#include "llvm/Object/COFF.h"
17#include "llvm/Support/Parallel.h"
18#include "llvm/Support/Path.h"
19#include "llvm/Support/TimeProfiler.h"
20#include "llvm/Support/raw_ostream.h"
21
22using namespace llvm;
23using namespace llvm::COFF;
24using namespace lld;
25using namespace lld::coff;
26
27AutoExporter::AutoExporter(
28 COFFLinkerContext &ctx,
29 const llvm::DenseSet<StringRef> &manualExcludeSymbols)
30 : manualExcludeSymbols(manualExcludeSymbols), ctx(ctx) {
31 excludeLibs = {
32 "libgcc",
33 "libgcc_s",
34 "libstdc++",
35 "libmingw32",
36 "libmingwex",
37 "libg2c",
38 "libsupc++",
39 "libobjc",
40 "libgcj",
41 "libclang_rt.builtins",
42 "libclang_rt.builtins-aarch64",
43 "libclang_rt.builtins-arm",
44 "libclang_rt.builtins-i386",
45 "libclang_rt.builtins-x86_64",
46 "libclang_rt.profile",
47 "libclang_rt.profile-aarch64",
48 "libclang_rt.profile-arm",
49 "libclang_rt.profile-i386",
50 "libclang_rt.profile-x86_64",
51 "libc++",
52 "libc++abi",
53 "libFortranRuntime",
54 "libFortranDecimal",
55 "libunwind",
56 "libmsvcrt",
57 "libucrtbase",
58 };
59
60 excludeObjects = {
61 "crt0.o", "crt1.o", "crt1u.o", "crt2.o", "crt2u.o", "dllcrt1.o",
62 "dllcrt2.o", "gcrt0.o", "gcrt1.o", "gcrt2.o", "crtbegin.o", "crtend.o",
63 };
64
65 excludeSymbolPrefixes = {
66 // Import symbols
67 "__imp_",
68 "__IMPORT_DESCRIPTOR_",
69 // Extra import symbols from GNU import libraries
70 "__nm_",
71 // C++ symbols
72 "__rtti_",
73 "__builtin_",
74 // Artificial symbols such as .refptr
75 ".",
76 // profile generate symbols
77 "__profc_",
78 "__profd_",
79 "__profvp_",
80 };
81
82 excludeSymbolSuffixes = {
83 "_iname",
84 "_NULL_THUNK_DATA",
85 };
86
87 if (ctx.config.machine == I386) {
88 excludeSymbols = {
89 "__NULL_IMPORT_DESCRIPTOR",
90 "__pei386_runtime_relocator",
91 "_do_pseudo_reloc",
92 "_impure_ptr",
93 "__impure_ptr",
94 "__fmode",
95 "_environ",
96 "___dso_handle",
97 // These are the MinGW names that differ from the standard
98 // ones (lacking an extra underscore).
99 "_DllMain@12",
100 "_DllEntryPoint@12",
101 "_DllMainCRTStartup@12",
102 };
103 excludeSymbolPrefixes.insert(key: "__head_");
104 } else {
105 excludeSymbols = {
106 "__NULL_IMPORT_DESCRIPTOR",
107 "_pei386_runtime_relocator",
108 "do_pseudo_reloc",
109 "impure_ptr",
110 "_impure_ptr",
111 "_fmode",
112 "environ",
113 "__dso_handle",
114 // These are the MinGW names that differ from the standard
115 // ones (lacking an extra underscore).
116 "DllMain",
117 "DllEntryPoint",
118 "DllMainCRTStartup",
119 };
120 excludeSymbolPrefixes.insert(key: "_head_");
121 }
122}
123
124void AutoExporter::addWholeArchive(StringRef path) {
125 StringRef libName = sys::path::filename(path);
126 // Drop the file extension, to match the processing below.
127 libName = libName.substr(Start: 0, N: libName.rfind(C: '.'));
128 excludeLibs.erase(Key: libName);
129}
130
131void AutoExporter::addExcludedSymbol(StringRef symbol) {
132 excludeSymbols.insert(key: symbol);
133}
134
135bool AutoExporter::shouldExport(Defined *sym) const {
136 if (!sym || !sym->getChunk())
137 return false;
138
139 // Only allow the symbol kinds that make sense to export; in particular,
140 // disallow import symbols.
141 if (!isa<DefinedRegular>(Val: sym) && !isa<DefinedCommon>(Val: sym))
142 return false;
143 if (excludeSymbols.count(Key: sym->getName()) || manualExcludeSymbols.count(V: sym->getName()))
144 return false;
145
146 for (StringRef prefix : excludeSymbolPrefixes.keys())
147 if (sym->getName().starts_with(Prefix: prefix))
148 return false;
149 for (StringRef suffix : excludeSymbolSuffixes.keys())
150 if (sym->getName().ends_with(Suffix: suffix))
151 return false;
152
153 // If a corresponding __imp_ symbol exists and is defined, don't export it.
154 if (ctx.symtab.find(name: ("__imp_" + sym->getName()).str()))
155 return false;
156
157 // Check that file is non-null before dereferencing it, symbols not
158 // originating in regular object files probably shouldn't be exported.
159 if (!sym->getFile())
160 return false;
161
162 StringRef libName = sys::path::filename(path: sym->getFile()->parentName);
163
164 // Drop the file extension.
165 libName = libName.substr(Start: 0, N: libName.rfind(C: '.'));
166 if (!libName.empty())
167 return !excludeLibs.count(Key: libName);
168
169 StringRef fileName = sys::path::filename(path: sym->getFile()->getName());
170 return !excludeObjects.count(Key: fileName);
171}
172
173void lld::coff::writeDefFile(StringRef name,
174 const std::vector<Export> &exports) {
175 llvm::TimeTraceScope timeScope("Write .def file");
176 std::error_code ec;
177 raw_fd_ostream os(name, ec, sys::fs::OF_None);
178 if (ec)
179 fatal(msg: "cannot open " + name + ": " + ec.message());
180
181 os << "EXPORTS\n";
182 for (const Export &e : exports) {
183 os << " " << e.exportName << " "
184 << "@" << e.ordinal;
185 if (auto *def = dyn_cast_or_null<Defined>(Val: e.sym)) {
186 if (def && def->getChunk() &&
187 !(def->getChunk()->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
188 os << " DATA";
189 }
190 os << "\n";
191 }
192}
193
194static StringRef mangle(Twine sym, MachineTypes machine) {
195 assert(machine != IMAGE_FILE_MACHINE_UNKNOWN);
196 if (machine == I386)
197 return saver().save(S: "_" + sym);
198 return saver().save(S: sym);
199}
200
201// Handles -wrap option.
202//
203// This function instantiates wrapper symbols. At this point, they seem
204// like they are not being used at all, so we explicitly set some flags so
205// that LTO won't eliminate them.
206std::vector<WrappedSymbol>
207lld::coff::addWrappedSymbols(COFFLinkerContext &ctx, opt::InputArgList &args) {
208 std::vector<WrappedSymbol> v;
209 DenseSet<StringRef> seen;
210
211 for (auto *arg : args.filtered(Ids: OPT_wrap)) {
212 StringRef name = arg->getValue();
213 if (!seen.insert(V: name).second)
214 continue;
215
216 Symbol *sym = ctx.symtab.findUnderscore(name);
217 if (!sym)
218 continue;
219
220 Symbol *real =
221 ctx.symtab.addUndefined(name: mangle(sym: "__real_" + name, machine: ctx.config.machine));
222 Symbol *wrap =
223 ctx.symtab.addUndefined(name: mangle(sym: "__wrap_" + name, machine: ctx.config.machine));
224 v.push_back(x: {.sym: sym, .real: real, .wrap: wrap});
225
226 // These symbols may seem undefined initially, but don't bail out
227 // at symtab.reportUnresolvable() due to them, but let wrapSymbols
228 // below sort things out before checking finally with
229 // symtab.resolveRemainingUndefines().
230 sym->deferUndefined = true;
231 real->deferUndefined = true;
232 // We want to tell LTO not to inline symbols to be overwritten
233 // because LTO doesn't know the final symbol contents after renaming.
234 real->canInline = false;
235 sym->canInline = false;
236
237 // Tell LTO not to eliminate these symbols.
238 sym->isUsedInRegularObj = true;
239 if (!isa<Undefined>(Val: wrap))
240 wrap->isUsedInRegularObj = true;
241 }
242 return v;
243}
244
245// Do renaming for -wrap by updating pointers to symbols.
246//
247// When this function is executed, only InputFiles and symbol table
248// contain pointers to symbol objects. We visit them to replace pointers,
249// so that wrapped symbols are swapped as instructed by the command line.
250void lld::coff::wrapSymbols(COFFLinkerContext &ctx,
251 ArrayRef<WrappedSymbol> wrapped) {
252 DenseMap<Symbol *, Symbol *> map;
253 for (const WrappedSymbol &w : wrapped) {
254 map[w.sym] = w.wrap;
255 map[w.real] = w.sym;
256 if (Defined *d = dyn_cast<Defined>(Val: w.wrap)) {
257 Symbol *imp = ctx.symtab.find(name: ("__imp_" + w.sym->getName()).str());
258 // Create a new defined local import for the wrap symbol. If
259 // no imp prefixed symbol existed, there's no need for it.
260 // (We can't easily distinguish whether any object file actually
261 // referenced it or not, though.)
262 if (imp) {
263 DefinedLocalImport *wrapimp = make<DefinedLocalImport>(
264 args&: ctx, args: saver().save(S: "__imp_" + w.wrap->getName()), args&: d);
265 ctx.symtab.localImportChunks.push_back(x: wrapimp->getChunk());
266 map[imp] = wrapimp;
267 }
268 }
269 }
270
271 // Update pointers in input files.
272 parallelForEach(R&: ctx.objFileInstances, Fn: [&](ObjFile *file) {
273 MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
274 for (auto &sym : syms)
275 if (Symbol *s = map.lookup(Val: sym))
276 sym = s;
277 });
278}
279