1 //===------------- JITLink.cpp - Core Run-time JIT linker APIs ------------===//
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 "llvm/ExecutionEngine/JITLink/JITLink.h"
10 
11 #include "llvm/BinaryFormat/Magic.h"
12 #include "llvm/ExecutionEngine/JITLink/ELF.h"
13 #include "llvm/ExecutionEngine/JITLink/MachO.h"
14 #include "llvm/Support/Format.h"
15 #include "llvm/Support/ManagedStatic.h"
16 #include "llvm/Support/MemoryBuffer.h"
17 #include "llvm/Support/raw_ostream.h"
18 
19 using namespace llvm;
20 using namespace llvm::object;
21 
22 #define DEBUG_TYPE "jitlink"
23 
24 namespace {
25 
26 enum JITLinkErrorCode { GenericJITLinkError = 1 };
27 
28 // FIXME: This class is only here to support the transition to llvm::Error. It
29 // will be removed once this transition is complete. Clients should prefer to
30 // deal with the Error value directly, rather than converting to error_code.
31 class JITLinkerErrorCategory : public std::error_category {
32 public:
33   const char *name() const noexcept override { return "runtimedyld"; }
34 
35   std::string message(int Condition) const override {
36     switch (static_cast<JITLinkErrorCode>(Condition)) {
37     case GenericJITLinkError:
38       return "Generic JITLink error";
39     }
40     llvm_unreachable("Unrecognized JITLinkErrorCode");
41   }
42 };
43 
44 static ManagedStatic<JITLinkerErrorCategory> JITLinkerErrorCategory;
45 
46 } // namespace
47 
48 namespace llvm {
49 namespace jitlink {
50 
51 char JITLinkError::ID = 0;
52 
53 void JITLinkError::log(raw_ostream &OS) const { OS << ErrMsg; }
54 
55 std::error_code JITLinkError::convertToErrorCode() const {
56   return std::error_code(GenericJITLinkError, *JITLinkerErrorCategory);
57 }
58 
59 const char *getGenericEdgeKindName(Edge::Kind K) {
60   switch (K) {
61   case Edge::Invalid:
62     return "INVALID RELOCATION";
63   case Edge::KeepAlive:
64     return "Keep-Alive";
65   default:
66     return "<Unrecognized edge kind>";
67   }
68 }
69 
70 const char *getLinkageName(Linkage L) {
71   switch (L) {
72   case Linkage::Strong:
73     return "strong";
74   case Linkage::Weak:
75     return "weak";
76   }
77   llvm_unreachable("Unrecognized llvm.jitlink.Linkage enum");
78 }
79 
80 const char *getScopeName(Scope S) {
81   switch (S) {
82   case Scope::Default:
83     return "default";
84   case Scope::Hidden:
85     return "hidden";
86   case Scope::Local:
87     return "local";
88   }
89   llvm_unreachable("Unrecognized llvm.jitlink.Scope enum");
90 }
91 
92 raw_ostream &operator<<(raw_ostream &OS, const Block &B) {
93   return OS << formatv("{0:x16}", B.getAddress()) << " -- "
94             << formatv("{0:x8}", B.getAddress() + B.getSize()) << ": "
95             << "size = " << formatv("{0:x8}", B.getSize()) << ", "
96             << (B.isZeroFill() ? "zero-fill" : "content")
97             << ", align = " << B.getAlignment()
98             << ", align-ofs = " << B.getAlignmentOffset()
99             << ", section = " << B.getSection().getName();
100 }
101 
102 raw_ostream &operator<<(raw_ostream &OS, const Symbol &Sym) {
103   OS << formatv("{0:x16}", Sym.getAddress()) << " ("
104      << (Sym.isDefined() ? "block" : "addressable") << " + "
105      << formatv("{0:x8}", Sym.getOffset())
106      << "): size: " << formatv("{0:x8}", Sym.getSize())
107      << ", linkage: " << formatv("{0:6}", getLinkageName(Sym.getLinkage()))
108      << ", scope: " << formatv("{0:8}", getScopeName(Sym.getScope())) << ", "
109      << (Sym.isLive() ? "live" : "dead") << "  -   "
110      << (Sym.hasName() ? Sym.getName() : "<anonymous symbol>");
111   return OS;
112 }
113 
114 void printEdge(raw_ostream &OS, const Block &B, const Edge &E,
115                StringRef EdgeKindName) {
116   OS << "edge@" << formatv("{0:x16}", B.getAddress() + E.getOffset()) << ": "
117      << formatv("{0:x16}", B.getAddress()) << " + "
118      << formatv("{0:x}", E.getOffset()) << " -- " << EdgeKindName << " -> ";
119 
120   auto &TargetSym = E.getTarget();
121   if (TargetSym.hasName())
122     OS << TargetSym.getName();
123   else {
124     auto &TargetBlock = TargetSym.getBlock();
125     auto &TargetSec = TargetBlock.getSection();
126     JITTargetAddress SecAddress = ~JITTargetAddress(0);
127     for (auto *B : TargetSec.blocks())
128       if (B->getAddress() < SecAddress)
129         SecAddress = B->getAddress();
130 
131     JITTargetAddress SecDelta = TargetSym.getAddress() - SecAddress;
132     OS << formatv("{0:x16}", TargetSym.getAddress()) << " (section "
133        << TargetSec.getName();
134     if (SecDelta)
135       OS << " + " << formatv("{0:x}", SecDelta);
136     OS << " / block " << formatv("{0:x16}", TargetBlock.getAddress());
137     if (TargetSym.getOffset())
138       OS << " + " << formatv("{0:x}", TargetSym.getOffset());
139     OS << ")";
140   }
141 
142   if (E.getAddend() != 0)
143     OS << " + " << E.getAddend();
144 }
145 
146 Section::~Section() {
147   for (auto *Sym : Symbols)
148     Sym->~Symbol();
149   for (auto *B : Blocks)
150     B->~Block();
151 }
152 
153 Block &LinkGraph::splitBlock(Block &B, size_t SplitIndex,
154                              SplitBlockCache *Cache) {
155 
156   assert(SplitIndex > 0 && "splitBlock can not be called with SplitIndex == 0");
157 
158   // If the split point covers all of B then just return B.
159   if (SplitIndex == B.getSize())
160     return B;
161 
162   assert(SplitIndex < B.getSize() && "SplitIndex out of range");
163 
164   // Create the new block covering [ 0, SplitIndex ).
165   auto &NewBlock =
166       B.isZeroFill()
167           ? createZeroFillBlock(B.getSection(), SplitIndex, B.getAddress(),
168                                 B.getAlignment(), B.getAlignmentOffset())
169           : createContentBlock(
170                 B.getSection(), B.getContent().slice(0, SplitIndex),
171                 B.getAddress(), B.getAlignment(), B.getAlignmentOffset());
172 
173   // Modify B to cover [ SplitIndex, B.size() ).
174   B.setAddress(B.getAddress() + SplitIndex);
175   B.setContent(B.getContent().slice(SplitIndex));
176   B.setAlignmentOffset((B.getAlignmentOffset() + SplitIndex) %
177                        B.getAlignment());
178 
179   // Handle edge transfer/update.
180   {
181     // Copy edges to NewBlock (recording their iterators so that we can remove
182     // them from B), and update of Edges remaining on B.
183     std::vector<Block::edge_iterator> EdgesToRemove;
184     for (auto I = B.edges().begin(); I != B.edges().end();) {
185       if (I->getOffset() < SplitIndex) {
186         NewBlock.addEdge(*I);
187         I = B.removeEdge(I);
188       } else {
189         I->setOffset(I->getOffset() - SplitIndex);
190         ++I;
191       }
192     }
193   }
194 
195   // Handle symbol transfer/update.
196   {
197     // Initialize the symbols cache if necessary.
198     SplitBlockCache LocalBlockSymbolsCache;
199     if (!Cache)
200       Cache = &LocalBlockSymbolsCache;
201     if (*Cache == None) {
202       *Cache = SplitBlockCache::value_type();
203       for (auto *Sym : B.getSection().symbols())
204         if (&Sym->getBlock() == &B)
205           (*Cache)->push_back(Sym);
206 
207       llvm::sort(**Cache, [](const Symbol *LHS, const Symbol *RHS) {
208         return LHS->getOffset() > RHS->getOffset();
209       });
210     }
211     auto &BlockSymbols = **Cache;
212 
213     // Transfer all symbols with offset less than SplitIndex to NewBlock.
214     while (!BlockSymbols.empty() &&
215            BlockSymbols.back()->getOffset() < SplitIndex) {
216       BlockSymbols.back()->setBlock(NewBlock);
217       BlockSymbols.pop_back();
218     }
219 
220     // Update offsets for all remaining symbols in B.
221     for (auto *Sym : BlockSymbols)
222       Sym->setOffset(Sym->getOffset() - SplitIndex);
223   }
224 
225   return NewBlock;
226 }
227 
228 void LinkGraph::dump(raw_ostream &OS) {
229   DenseMap<Block *, std::vector<Symbol *>> BlockSymbols;
230 
231   // Map from blocks to the symbols pointing at them.
232   for (auto *Sym : defined_symbols())
233     BlockSymbols[&Sym->getBlock()].push_back(Sym);
234 
235   // For each block, sort its symbols by something approximating
236   // relevance.
237   for (auto &KV : BlockSymbols)
238     llvm::sort(KV.second, [](const Symbol *LHS, const Symbol *RHS) {
239       if (LHS->getOffset() != RHS->getOffset())
240         return LHS->getOffset() < RHS->getOffset();
241       if (LHS->getLinkage() != RHS->getLinkage())
242         return LHS->getLinkage() < RHS->getLinkage();
243       if (LHS->getScope() != RHS->getScope())
244         return LHS->getScope() < RHS->getScope();
245       if (LHS->hasName()) {
246         if (!RHS->hasName())
247           return true;
248         return LHS->getName() < RHS->getName();
249       }
250       return false;
251     });
252 
253   for (auto &Sec : sections()) {
254     OS << "section " << Sec.getName() << ":\n\n";
255 
256     std::vector<Block *> SortedBlocks;
257     llvm::copy(Sec.blocks(), std::back_inserter(SortedBlocks));
258     llvm::sort(SortedBlocks, [](const Block *LHS, const Block *RHS) {
259       return LHS->getAddress() < RHS->getAddress();
260     });
261 
262     for (auto *B : SortedBlocks) {
263       OS << "  block " << formatv("{0:x16}", B->getAddress())
264          << " size = " << formatv("{0:x8}", B->getSize())
265          << ", align = " << B->getAlignment()
266          << ", alignment-offset = " << B->getAlignmentOffset();
267       if (B->isZeroFill())
268         OS << ", zero-fill";
269       OS << "\n";
270 
271       auto BlockSymsI = BlockSymbols.find(B);
272       if (BlockSymsI != BlockSymbols.end()) {
273         OS << "    symbols:\n";
274         auto &Syms = BlockSymsI->second;
275         for (auto *Sym : Syms)
276           OS << "      " << *Sym << "\n";
277       } else
278         OS << "    no symbols\n";
279 
280       if (!B->edges_empty()) {
281         OS << "    edges:\n";
282         std::vector<Edge> SortedEdges;
283         llvm::copy(B->edges(), std::back_inserter(SortedEdges));
284         llvm::sort(SortedEdges, [](const Edge &LHS, const Edge &RHS) {
285           return LHS.getOffset() < RHS.getOffset();
286         });
287         for (auto &E : SortedEdges) {
288           OS << "      " << formatv("{0:x16}", B->getFixupAddress(E))
289              << " (block + " << formatv("{0:x8}", E.getOffset())
290              << "), addend = ";
291           if (E.getAddend() >= 0)
292             OS << formatv("+{0:x8}", E.getAddend());
293           else
294             OS << formatv("-{0:x8}", -E.getAddend());
295           OS << ", kind = " << getEdgeKindName(E.getKind()) << ", target = ";
296           if (E.getTarget().hasName())
297             OS << E.getTarget().getName();
298           else
299             OS << "addressable@"
300                << formatv("{0:x16}", E.getTarget().getAddress()) << "+"
301                << formatv("{0:x8}", E.getTarget().getOffset());
302           OS << "\n";
303         }
304       } else
305         OS << "    no edges\n";
306       OS << "\n";
307     }
308   }
309 
310   OS << "Absolute symbols:\n";
311   if (!llvm::empty(absolute_symbols())) {
312     for (auto *Sym : absolute_symbols())
313       OS << "  " << format("0x%016" PRIx64, Sym->getAddress()) << ": " << *Sym
314          << "\n";
315   } else
316     OS << "  none\n";
317 
318   OS << "\nExternal symbols:\n";
319   if (!llvm::empty(external_symbols())) {
320     for (auto *Sym : external_symbols())
321       OS << "  " << format("0x%016" PRIx64, Sym->getAddress()) << ": " << *Sym
322          << "\n";
323   } else
324     OS << "  none\n";
325 }
326 
327 raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LF) {
328   switch (LF) {
329   case SymbolLookupFlags::RequiredSymbol:
330     return OS << "RequiredSymbol";
331   case SymbolLookupFlags::WeaklyReferencedSymbol:
332     return OS << "WeaklyReferencedSymbol";
333   }
334   llvm_unreachable("Unrecognized lookup flags");
335 }
336 
337 void JITLinkAsyncLookupContinuation::anchor() {}
338 
339 JITLinkContext::~JITLinkContext() {}
340 
341 bool JITLinkContext::shouldAddDefaultTargetPasses(const Triple &TT) const {
342   return true;
343 }
344 
345 LinkGraphPassFunction JITLinkContext::getMarkLivePass(const Triple &TT) const {
346   return LinkGraphPassFunction();
347 }
348 
349 Error JITLinkContext::modifyPassConfig(LinkGraph &G,
350                                        PassConfiguration &Config) {
351   return Error::success();
352 }
353 
354 Error markAllSymbolsLive(LinkGraph &G) {
355   for (auto *Sym : G.defined_symbols())
356     Sym->setLive(true);
357   return Error::success();
358 }
359 
360 Error makeTargetOutOfRangeError(const LinkGraph &G, const Block &B,
361                                 const Edge &E) {
362   std::string ErrMsg;
363   {
364     raw_string_ostream ErrStream(ErrMsg);
365     Section &Sec = B.getSection();
366     ErrStream << "In graph " << G.getName() << ", section " << Sec.getName()
367               << ": relocation target ";
368     if (E.getTarget().hasName())
369       ErrStream << "\"" << E.getTarget().getName() << "\" ";
370     ErrStream << "at address " << formatv("{0:x}", E.getTarget().getAddress());
371     ErrStream << " is out of range of " << G.getEdgeKindName(E.getKind())
372               << " fixup at " << formatv("{0:x}", B.getFixupAddress(E)) << " (";
373 
374     Symbol *BestSymbolForBlock = nullptr;
375     for (auto *Sym : Sec.symbols())
376       if (&Sym->getBlock() == &B && Sym->hasName() && Sym->getOffset() == 0 &&
377           (!BestSymbolForBlock ||
378            Sym->getScope() < BestSymbolForBlock->getScope() ||
379            Sym->getLinkage() < BestSymbolForBlock->getLinkage()))
380         BestSymbolForBlock = Sym;
381 
382     if (BestSymbolForBlock)
383       ErrStream << BestSymbolForBlock->getName() << ", ";
384     else
385       ErrStream << "<anonymous block> @ ";
386 
387     ErrStream << formatv("{0:x}", B.getAddress()) << " + "
388               << formatv("{0:x}", E.getOffset()) << ")";
389   }
390   return make_error<JITLinkError>(std::move(ErrMsg));
391 }
392 
393 Expected<std::unique_ptr<LinkGraph>>
394 createLinkGraphFromObject(MemoryBufferRef ObjectBuffer) {
395   auto Magic = identify_magic(ObjectBuffer.getBuffer());
396   switch (Magic) {
397   case file_magic::macho_object:
398     return createLinkGraphFromMachOObject(ObjectBuffer);
399   case file_magic::elf_relocatable:
400     return createLinkGraphFromELFObject(ObjectBuffer);
401   default:
402     return make_error<JITLinkError>("Unsupported file format");
403   };
404 }
405 
406 void link(std::unique_ptr<LinkGraph> G, std::unique_ptr<JITLinkContext> Ctx) {
407   switch (G->getTargetTriple().getObjectFormat()) {
408   case Triple::MachO:
409     return link_MachO(std::move(G), std::move(Ctx));
410   case Triple::ELF:
411     return link_ELF(std::move(G), std::move(Ctx));
412   default:
413     Ctx->notifyFailed(make_error<JITLinkError>("Unsupported object format"));
414   };
415 }
416 
417 } // end namespace jitlink
418 } // end namespace llvm
419