1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
| //===----- MachOLinkGraphBuilder.h - MachO LinkGraph builder ----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Generic MachO LinkGraph building code.
//
//===----------------------------------------------------------------------===//
#ifndef LIB_EXECUTIONENGINE_JITLINK_MACHOLINKGRAPHBUILDER_H
#define LIB_EXECUTIONENGINE_JITLINK_MACHOLINKGRAPHBUILDER_H
#include "llvm/ExecutionEngine/JITLink/JITLink.h"
#include "EHFrameSupportImpl.h"
#include "JITLinkGeneric.h"
#include "llvm/Object/MachO.h"
#include <list>
namespace llvm {
namespace jitlink {
class MachOLinkGraphBuilder {
public:
virtual ~MachOLinkGraphBuilder();
Expected<std::unique_ptr<LinkGraph>> buildGraph();
protected:
class MachOEHFrameBinaryParser : public EHFrameBinaryParser {
public:
MachOEHFrameBinaryParser(MachOLinkGraphBuilder &Builder,
JITTargetAddress EHFrameAddress,
StringRef EHFrameContent, Section &EHFrameSection,
uint64_t CIEAlignment, uint64_t FDEAlignment,
Edge::Kind FDEToCIERelocKind,
Edge::Kind FDEToTargetRelocKind)
: EHFrameBinaryParser(EHFrameAddress, EHFrameContent,
Builder.getGraph().getPointerSize(),
Builder.getGraph().getEndianness()),
Builder(Builder), EHFrameSection(EHFrameSection),
CIEAlignment(CIEAlignment), FDEAlignment(FDEAlignment),
FDEToCIERelocKind(FDEToCIERelocKind),
FDEToTargetRelocKind(FDEToTargetRelocKind) {}
Symbol *getSymbolAtAddress(JITTargetAddress Address) override {
if (auto *Sym = Builder.getSymbolByAddress(Address))
if (Sym->getAddress() == Address)
return Sym;
return nullptr;
}
Symbol &createCIERecord(JITTargetAddress RecordAddr,
StringRef RecordContent) override {
auto &G = Builder.getGraph();
auto &B = G.createContentBlock(EHFrameSection, RecordContent, RecordAddr,
CIEAlignment, 0);
auto &CIESymbol =
G.addAnonymousSymbol(B, 0, RecordContent.size(), false, false);
Builder.setCanonicalSymbol(CIESymbol);
return CIESymbol;
}
Expected<Symbol &> createFDERecord(JITTargetAddress RecordAddr,
StringRef RecordContent, Symbol &CIE,
size_t CIEOffset, Symbol &Func,
size_t FuncOffset, Symbol *LSDA,
size_t LSDAOffset) override {
auto &G = Builder.getGraph();
auto &B = G.createContentBlock(EHFrameSection, RecordContent, RecordAddr,
FDEAlignment, 0);
// Add edges to CIE, Func, and (conditionally) LSDA.
B.addEdge(FDEToCIERelocKind, CIEOffset, CIE, 0);
B.addEdge(FDEToTargetRelocKind, FuncOffset, Func, 0);
if (LSDA)
B.addEdge(FDEToTargetRelocKind, LSDAOffset, *LSDA, 0);
auto &FDESymbol =
G.addAnonymousSymbol(B, 0, RecordContent.size(), false, false);
// Add a keep-alive relocation from the function to the FDE to ensure it
// is not dead stripped.
Func.getBlock().addEdge(Edge::KeepAlive, 0, FDESymbol, 0);
return FDESymbol;
}
private:
MachOLinkGraphBuilder &Builder;
Section &EHFrameSection;
uint64_t CIEAlignment;
uint64_t FDEAlignment;
Edge::Kind FDEToCIERelocKind;
Edge::Kind FDEToTargetRelocKind;
};
struct NormalizedSymbol {
friend class MachOLinkGraphBuilder;
private:
NormalizedSymbol(Optional<StringRef> Name, uint64_t Value, uint8_t Type,
uint8_t Sect, uint16_t Desc, Linkage L, Scope S)
: Name(Name), Value(Value), Type(Type), Sect(Sect), Desc(Desc), L(L),
S(S) {
assert((!Name || !Name->empty()) && "Name must be none or non-empty");
}
public:
NormalizedSymbol(const NormalizedSymbol &) = delete;
NormalizedSymbol &operator=(const NormalizedSymbol &) = delete;
NormalizedSymbol(NormalizedSymbol &&) = delete;
NormalizedSymbol &operator=(NormalizedSymbol &&) = delete;
Optional<StringRef> Name;
uint64_t Value = 0;
uint8_t Type = 0;
uint8_t Sect = 0;
uint16_t Desc = 0;
Linkage L = Linkage::Strong;
Scope S = Scope::Default;
Symbol *GraphSymbol = nullptr;
};
class NormalizedSection {
friend class MachOLinkGraphBuilder;
private:
NormalizedSection() = default;
public:
Section *GraphSection = nullptr;
uint64_t Address = 0;
uint64_t Size = 0;
uint64_t Alignment = 0;
uint32_t Flags = 0;
const char *Data = nullptr;
};
using SectionParserFunction = std::function<Error(NormalizedSection &S)>;
MachOLinkGraphBuilder(const object::MachOObjectFile &Obj);
LinkGraph &getGraph() const { return *G; }
const object::MachOObjectFile &getObject() const { return Obj; }
void addCustomSectionParser(StringRef SectionName,
SectionParserFunction Parse);
virtual Error addRelocations() = 0;
/// Create a symbol.
template <typename... ArgTs>
NormalizedSymbol &createNormalizedSymbol(ArgTs &&... Args) {
NormalizedSymbol *Sym = reinterpret_cast<NormalizedSymbol *>(
Allocator.Allocate<NormalizedSymbol>());
new (Sym) NormalizedSymbol(std::forward<ArgTs>(Args)...);
return *Sym;
}
/// Index is zero-based (MachO section indexes are usually one-based) and
/// assumed to be in-range. Client is responsible for checking.
NormalizedSection &getSectionByIndex(unsigned Index) {
auto I = IndexToSection.find(Index);
assert(I != IndexToSection.end() && "No section recorded at index");
return I->second;
}
/// Try to get the section at the given index. Will return an error if the
/// given index is out of range, or if no section has been added for the given
/// index.
Expected<NormalizedSection &> findSectionByIndex(unsigned Index) {
auto I = IndexToSection.find(Index);
if (I == IndexToSection.end())
return make_error<JITLinkError>("No section recorded for index " +
formatv("{0:u}", Index));
return I->second;
}
/// Try to get the symbol at the given index. Will return an error if the
/// given index is out of range, or if no symbol has been added for the given
/// index.
Expected<NormalizedSymbol &> findSymbolByIndex(uint64_t Index) {
if (Index >= IndexToSymbol.size())
return make_error<JITLinkError>("Symbol index out of range");
auto *Sym = IndexToSymbol[Index];
if (!Sym)
return make_error<JITLinkError>("No symbol at index " +
formatv("{0:u}", Index));
return *Sym;
}
/// Returns the symbol with the highest address not greater than the search
/// address, or null if no such symbol exists.
Symbol *getSymbolByAddress(JITTargetAddress Address) {
auto I = AddrToCanonicalSymbol.upper_bound(Address);
if (I == AddrToCanonicalSymbol.begin())
return nullptr;
return std::prev(I)->second;
}
/// Returns the symbol with the highest address not greater than the search
/// address, or an error if no such symbol exists.
Expected<Symbol &> findSymbolByAddress(JITTargetAddress Address) {
auto *Sym = getSymbolByAddress(Address);
if (Sym)
if (Address < Sym->getAddress() + Sym->getSize())
return *Sym;
return make_error<JITLinkError>("No symbol covering address " +
formatv("{0:x16}", Address));
}
static Linkage getLinkage(uint16_t Desc);
static Scope getScope(StringRef Name, uint8_t Type);
static bool isAltEntry(const NormalizedSymbol &NSym);
private:
static unsigned getPointerSize(const object::MachOObjectFile &Obj);
static support::endianness getEndianness(const object::MachOObjectFile &Obj);
void setCanonicalSymbol(Symbol &Sym) {
auto *&CanonicalSymEntry = AddrToCanonicalSymbol[Sym.getAddress()];
// There should be no symbol at this address, or, if there is,
// it should be a zero-sized symbol from an empty section (which
// we can safely override).
assert((!CanonicalSymEntry || CanonicalSymEntry->getSize() == 0) &&
"Duplicate canonical symbol at address");
CanonicalSymEntry = &Sym;
}
Section &getCommonSection();
void addSectionStartSymAndBlock(Section &GraphSec, uint64_t Address,
const char *Data, uint64_t Size,
uint32_t Alignment, bool IsLive);
Error createNormalizedSections();
Error createNormalizedSymbols();
/// Create graph blocks and symbols for externals, absolutes, commons and
/// all defined symbols in sections without custom parsers.
Error graphifyRegularSymbols();
/// Create graph blocks and symbols for all sections.
Error graphifySectionsWithCustomParsers();
// Put the BumpPtrAllocator first so that we don't free any of the underlying
// memory until the Symbol/Addressable destructors have been run.
BumpPtrAllocator Allocator;
const object::MachOObjectFile &Obj;
std::unique_ptr<LinkGraph> G;
DenseMap<unsigned, NormalizedSection> IndexToSection;
Section *CommonSection = nullptr;
DenseMap<uint32_t, NormalizedSymbol *> IndexToSymbol;
std::map<JITTargetAddress, Symbol *> AddrToCanonicalSymbol;
StringMap<SectionParserFunction> CustomSectionParserFunctions;
};
} // end namespace jitlink
} // end namespace llvm
#endif // LIB_EXECUTIONENGINE_JITLINK_MACHOLINKGRAPHBUILDER_H
|