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