1 //===- Symbols.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 "Symbols.h" 10 #include "COFFLinkerContext.h" 11 #include "InputFiles.h" 12 #include "lld/Common/ErrorHandler.h" 13 #include "lld/Common/Memory.h" 14 #include "lld/Common/Strings.h" 15 #include "llvm/ADT/STLExtras.h" 16 #include "llvm/Demangle/Demangle.h" 17 #include "llvm/Support/Debug.h" 18 #include "llvm/Support/raw_ostream.h" 19 20 using namespace llvm; 21 using namespace llvm::object; 22 23 using namespace lld::coff; 24 25 namespace lld { 26 27 static_assert(sizeof(SymbolUnion) <= 48, 28 "symbols should be optimized for memory usage"); 29 30 // Returns a symbol name for an error message. 31 static std::string maybeDemangleSymbol(const COFFLinkerContext &ctx, 32 StringRef symName) { 33 if (ctx.config.demangle) { 34 std::string prefix; 35 StringRef prefixless = symName; 36 if (prefixless.consume_front("__imp_")) 37 prefix = "__declspec(dllimport) "; 38 StringRef demangleInput = prefixless; 39 if (ctx.config.machine == I386) 40 demangleInput.consume_front("_"); 41 std::string demangled = demangle(demangleInput); 42 if (demangled != demangleInput) 43 return prefix + demangled; 44 return (prefix + prefixless).str(); 45 } 46 return std::string(symName); 47 } 48 std::string toString(const COFFLinkerContext &ctx, coff::Symbol &b) { 49 return maybeDemangleSymbol(ctx, b.getName()); 50 } 51 std::string toCOFFString(const COFFLinkerContext &ctx, 52 const Archive::Symbol &b) { 53 return maybeDemangleSymbol(ctx, b.getName()); 54 } 55 56 namespace coff { 57 58 void Symbol::computeName() { 59 assert(nameData == nullptr && 60 "should only compute the name once for DefinedCOFF symbols"); 61 auto *d = cast<DefinedCOFF>(this); 62 StringRef nameStr = 63 check(cast<ObjFile>(d->file)->getCOFFObj()->getSymbolName(d->sym)); 64 nameData = nameStr.data(); 65 nameSize = nameStr.size(); 66 assert(nameSize == nameStr.size() && "name length truncated"); 67 } 68 69 InputFile *Symbol::getFile() { 70 if (auto *sym = dyn_cast<DefinedCOFF>(this)) 71 return sym->file; 72 if (auto *sym = dyn_cast<LazyArchive>(this)) 73 return sym->file; 74 if (auto *sym = dyn_cast<LazyObject>(this)) 75 return sym->file; 76 if (auto *sym = dyn_cast<LazyDLLSymbol>(this)) 77 return sym->file; 78 return nullptr; 79 } 80 81 bool Symbol::isLive() const { 82 if (auto *r = dyn_cast<DefinedRegular>(this)) 83 return r->getChunk()->live; 84 if (auto *imp = dyn_cast<DefinedImportData>(this)) 85 return imp->file->live; 86 if (auto *imp = dyn_cast<DefinedImportThunk>(this)) 87 return imp->wrappedSym->file->thunkLive; 88 // Assume any other kind of symbol is live. 89 return true; 90 } 91 92 // MinGW specific. 93 void Symbol::replaceKeepingName(Symbol *other, size_t size) { 94 StringRef origName = getName(); 95 memcpy(this, other, size); 96 nameData = origName.data(); 97 nameSize = origName.size(); 98 } 99 100 COFFSymbolRef DefinedCOFF::getCOFFSymbol() { 101 size_t symSize = cast<ObjFile>(file)->getCOFFObj()->getSymbolTableEntrySize(); 102 if (symSize == sizeof(coff_symbol16)) 103 return COFFSymbolRef(reinterpret_cast<const coff_symbol16 *>(sym)); 104 assert(symSize == sizeof(coff_symbol32)); 105 return COFFSymbolRef(reinterpret_cast<const coff_symbol32 *>(sym)); 106 } 107 108 uint64_t DefinedAbsolute::getRVA() { return va - ctx.config.imageBase; } 109 110 static Chunk *makeImportThunk(COFFLinkerContext &ctx, DefinedImportData *s, 111 uint16_t machine) { 112 if (machine == AMD64) 113 return make<ImportThunkChunkX64>(ctx, s); 114 if (machine == I386) 115 return make<ImportThunkChunkX86>(ctx, s); 116 if (machine == ARM64) 117 return make<ImportThunkChunkARM64>(ctx, s); 118 assert(machine == ARMNT); 119 return make<ImportThunkChunkARM>(ctx, s); 120 } 121 122 DefinedImportThunk::DefinedImportThunk(COFFLinkerContext &ctx, StringRef name, 123 DefinedImportData *s, uint16_t machine) 124 : Defined(DefinedImportThunkKind, name), wrappedSym(s), 125 data(makeImportThunk(ctx, s, machine)) {} 126 127 Defined *Undefined::getWeakAlias() { 128 // A weak alias may be a weak alias to another symbol, so check recursively. 129 for (Symbol *a = weakAlias; a; a = cast<Undefined>(a)->weakAlias) 130 if (auto *d = dyn_cast<Defined>(a)) 131 return d; 132 return nullptr; 133 } 134 135 MemoryBufferRef LazyArchive::getMemberBuffer() { 136 Archive::Child c = 137 CHECK(sym.getMember(), "could not get the member for symbol " + 138 toCOFFString(file->ctx, sym)); 139 return CHECK(c.getMemoryBufferRef(), 140 "could not get the buffer for the member defining symbol " + 141 toCOFFString(file->ctx, sym)); 142 } 143 } // namespace coff 144 } // namespace lld 145