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/raw_ostream.h"
20 
21 using namespace llvm;
22 using namespace llvm::COFF;
23 using namespace lld;
24 using namespace lld::coff;
25 
26 AutoExporter::AutoExporter(
27     COFFLinkerContext &ctx,
28     const llvm::DenseSet<StringRef> &manualExcludeSymbols)
29     : manualExcludeSymbols(manualExcludeSymbols), ctx(ctx) {
30   excludeLibs = {
31       "libgcc",
32       "libgcc_s",
33       "libstdc++",
34       "libmingw32",
35       "libmingwex",
36       "libg2c",
37       "libsupc++",
38       "libobjc",
39       "libgcj",
40       "libclang_rt.builtins",
41       "libclang_rt.builtins-aarch64",
42       "libclang_rt.builtins-arm",
43       "libclang_rt.builtins-i386",
44       "libclang_rt.builtins-x86_64",
45       "libclang_rt.profile",
46       "libclang_rt.profile-aarch64",
47       "libclang_rt.profile-arm",
48       "libclang_rt.profile-i386",
49       "libclang_rt.profile-x86_64",
50       "libc++",
51       "libc++abi",
52       "libFortran_main",
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("__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("_head_");
121   }
122 }
123 
124 void 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(0, libName.rfind('.'));
128   excludeLibs.erase(libName);
129 }
130 
131 void AutoExporter::addExcludedSymbol(StringRef symbol) {
132   excludeSymbols.insert(symbol);
133 }
134 
135 bool 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>(sym) && !isa<DefinedCommon>(sym))
142     return false;
143   if (excludeSymbols.count(sym->getName()) || manualExcludeSymbols.count(sym->getName()))
144     return false;
145 
146   for (StringRef prefix : excludeSymbolPrefixes.keys())
147     if (sym->getName().startswith(prefix))
148       return false;
149   for (StringRef suffix : excludeSymbolSuffixes.keys())
150     if (sym->getName().endswith(suffix))
151       return false;
152 
153   // If a corresponding __imp_ symbol exists and is defined, don't export it.
154   if (ctx.symtab.find(("__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(sym->getFile()->parentName);
163 
164   // Drop the file extension.
165   libName = libName.substr(0, libName.rfind('.'));
166   if (!libName.empty())
167     return !excludeLibs.count(libName);
168 
169   StringRef fileName = sys::path::filename(sym->getFile()->getName());
170   return !excludeObjects.count(fileName);
171 }
172 
173 void lld::coff::writeDefFile(StringRef name,
174                              const std::vector<Export> &exports) {
175   std::error_code ec;
176   raw_fd_ostream os(name, ec, sys::fs::OF_None);
177   if (ec)
178     fatal("cannot open " + name + ": " + ec.message());
179 
180   os << "EXPORTS\n";
181   for (const Export &e : exports) {
182     os << "    " << e.exportName << " "
183        << "@" << e.ordinal;
184     if (auto *def = dyn_cast_or_null<Defined>(e.sym)) {
185       if (def && def->getChunk() &&
186           !(def->getChunk()->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
187         os << " DATA";
188     }
189     os << "\n";
190   }
191 }
192 
193 static StringRef mangle(Twine sym, MachineTypes machine) {
194   assert(machine != IMAGE_FILE_MACHINE_UNKNOWN);
195   if (machine == I386)
196     return saver().save("_" + sym);
197   return saver().save(sym);
198 }
199 
200 // Handles -wrap option.
201 //
202 // This function instantiates wrapper symbols. At this point, they seem
203 // like they are not being used at all, so we explicitly set some flags so
204 // that LTO won't eliminate them.
205 std::vector<WrappedSymbol>
206 lld::coff::addWrappedSymbols(COFFLinkerContext &ctx, opt::InputArgList &args) {
207   std::vector<WrappedSymbol> v;
208   DenseSet<StringRef> seen;
209 
210   for (auto *arg : args.filtered(OPT_wrap)) {
211     StringRef name = arg->getValue();
212     if (!seen.insert(name).second)
213       continue;
214 
215     Symbol *sym = ctx.symtab.findUnderscore(name);
216     if (!sym)
217       continue;
218 
219     Symbol *real =
220         ctx.symtab.addUndefined(mangle("__real_" + name, ctx.config.machine));
221     Symbol *wrap =
222         ctx.symtab.addUndefined(mangle("__wrap_" + name, ctx.config.machine));
223     v.push_back({sym, real, wrap});
224 
225     // These symbols may seem undefined initially, but don't bail out
226     // at symtab.reportUnresolvable() due to them, but let wrapSymbols
227     // below sort things out before checking finally with
228     // symtab.resolveRemainingUndefines().
229     sym->deferUndefined = true;
230     real->deferUndefined = true;
231     // We want to tell LTO not to inline symbols to be overwritten
232     // because LTO doesn't know the final symbol contents after renaming.
233     real->canInline = false;
234     sym->canInline = false;
235 
236     // Tell LTO not to eliminate these symbols.
237     sym->isUsedInRegularObj = true;
238     if (!isa<Undefined>(wrap))
239       wrap->isUsedInRegularObj = true;
240   }
241   return v;
242 }
243 
244 // Do renaming for -wrap by updating pointers to symbols.
245 //
246 // When this function is executed, only InputFiles and symbol table
247 // contain pointers to symbol objects. We visit them to replace pointers,
248 // so that wrapped symbols are swapped as instructed by the command line.
249 void lld::coff::wrapSymbols(COFFLinkerContext &ctx,
250                             ArrayRef<WrappedSymbol> wrapped) {
251   DenseMap<Symbol *, Symbol *> map;
252   for (const WrappedSymbol &w : wrapped) {
253     map[w.sym] = w.wrap;
254     map[w.real] = w.sym;
255     if (Defined *d = dyn_cast<Defined>(w.wrap)) {
256       Symbol *imp = ctx.symtab.find(("__imp_" + w.sym->getName()).str());
257       // Create a new defined local import for the wrap symbol. If
258       // no imp prefixed symbol existed, there's no need for it.
259       // (We can't easily distinguish whether any object file actually
260       // referenced it or not, though.)
261       if (imp) {
262         DefinedLocalImport *wrapimp = make<DefinedLocalImport>(
263             ctx, saver().save("__imp_" + w.wrap->getName()), d);
264         ctx.symtab.localImportChunks.push_back(wrapimp->getChunk());
265         map[imp] = wrapimp;
266       }
267     }
268   }
269 
270   // Update pointers in input files.
271   parallelForEach(ctx.objFileInstances, [&](ObjFile *file) {
272     MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
273     for (size_t i = 0, e = syms.size(); i != e; ++i)
274       if (Symbol *s = map.lookup(syms[i]))
275         syms[i] = s;
276   });
277 }
278