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