LLVM  10.0.0svn
JITLinkGeneric.h
Go to the documentation of this file.
1 //===------ JITLinkGeneric.h - Generic JIT linker utilities -----*- C++ -*-===//
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 // Generic JITLinker utilities. E.g. graph pruning, eh-frame parsing.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LIB_EXECUTIONENGINE_JITLINK_JITLINKGENERIC_H
14 #define LIB_EXECUTIONENGINE_JITLINK_JITLINKGENERIC_H
15 
16 #include "llvm/ADT/DenseSet.h"
18 
19 #define DEBUG_TYPE "jitlink"
20 
21 namespace llvm {
22 
23 class MemoryBufferRef;
24 
25 namespace jitlink {
26 
27 /// Base class for a JIT linker.
28 ///
29 /// A JITLinkerBase instance links one object file into an ongoing JIT
30 /// session. Symbol resolution and finalization operations are pluggable,
31 /// and called using continuation passing (passing a continuation for the
32 /// remaining linker work) to allow them to be performed asynchronously.
34 public:
35  JITLinkerBase(std::unique_ptr<JITLinkContext> Ctx, PassConfiguration Passes)
36  : Ctx(std::move(Ctx)), Passes(std::move(Passes)) {
37  assert(this->Ctx && "Ctx can not be null");
38  }
39 
40  virtual ~JITLinkerBase();
41 
42 protected:
43  struct SegmentLayout {
44  using SectionAtomsList = std::vector<DefinedAtom *>;
45  struct SectionLayout {
46  SectionLayout(Section &S) : S(&S) {}
47 
50  };
51 
52  using SectionLayoutList = std::vector<SectionLayout>;
53 
56  };
57 
59 
60  // Phase 1:
61  // 1.1: Build atom graph
62  // 1.2: Run pre-prune passes
63  // 1.2: Prune graph
64  // 1.3: Run post-prune passes
65  // 1.4: Sort atoms into segments
66  // 1.5: Allocate segment memory
67  // 1.6: Identify externals and make an async call to resolve function
68  void linkPhase1(std::unique_ptr<JITLinkerBase> Self);
69 
70  // Phase 2:
71  // 2.1: Apply resolution results
72  // 2.2: Fix up atom contents
73  // 2.3: Call OnResolved callback
74  // 2.3: Make an async call to transfer and finalize memory.
75  void linkPhase2(std::unique_ptr<JITLinkerBase> Self,
76  Expected<AsyncLookupResult> LookupResult);
77 
78  // Phase 3:
79  // 3.1: Call OnFinalized callback, handing off allocation.
80  void linkPhase3(std::unique_ptr<JITLinkerBase> Self, Error Err);
81 
82  // Build a graph from the given object buffer.
83  // To be implemented by the client.
85  buildGraph(MemoryBufferRef ObjBuffer) = 0;
86 
87  // For debug dumping of the atom graph.
88  virtual StringRef getEdgeKindName(Edge::Kind K) const = 0;
89 
90 private:
91  // Run all passes in the given pass list, bailing out immediately if any pass
92  // returns an error.
93  Error runPasses(AtomGraphPassList &Passes, AtomGraph &G);
94 
95  // Copy atom contents and apply relocations.
96  // Implemented in JITLinker.
97  virtual Error
98  copyAndFixUpAllAtoms(const SegmentLayoutMap &Layout,
99  JITLinkMemoryManager::Allocation &Alloc) const = 0;
100 
101  void layOutAtoms();
102  Error allocateSegments(const SegmentLayoutMap &Layout);
103  DenseSet<StringRef> getExternalSymbolNames() const;
104  void applyLookupResult(AsyncLookupResult LR);
105  void deallocateAndBailOut(Error Err);
106 
107  void dumpGraph(raw_ostream &OS);
108 
109  std::unique_ptr<JITLinkContext> Ctx;
110  PassConfiguration Passes;
111  std::unique_ptr<AtomGraph> G;
112  SegmentLayoutMap Layout;
113  std::unique_ptr<JITLinkMemoryManager::Allocation> Alloc;
114 };
115 
116 template <typename LinkerImpl> class JITLinker : public JITLinkerBase {
117 public:
119 
120  /// Link constructs a LinkerImpl instance and calls linkPhase1.
121  /// Link should be called with the constructor arguments for LinkerImpl, which
122  /// will be forwarded to the constructor.
123  template <typename... ArgTs> static void link(ArgTs &&... Args) {
124  auto L = std::make_unique<LinkerImpl>(std::forward<ArgTs>(Args)...);
125 
126  // Ownership of the linker is passed into the linker's doLink function to
127  // allow it to be passed on to async continuations.
128  //
129  // FIXME: Remove LTmp once we have c++17.
130  // C++17 sequencing rules guarantee that function name expressions are
131  // sequenced before arguments, so L->linkPhase1(std::move(L), ...) will be
132  // well formed.
133  auto &LTmp = *L;
134  LTmp.linkPhase1(std::move(L));
135  }
136 
137 private:
138  const LinkerImpl &impl() const {
139  return static_cast<const LinkerImpl &>(*this);
140  }
141 
142  Error
143  copyAndFixUpAllAtoms(const SegmentLayoutMap &Layout,
144  JITLinkMemoryManager::Allocation &Alloc) const override {
145  LLVM_DEBUG(dbgs() << "Copying and fixing up atoms:\n");
146  for (auto &KV : Layout) {
147  auto &Prot = KV.first;
148  auto &SegLayout = KV.second;
149 
150  auto SegMem = Alloc.getWorkingMemory(
151  static_cast<sys::Memory::ProtectionFlags>(Prot));
152  char *LastAtomEnd = SegMem.data();
153  char *AtomDataPtr = LastAtomEnd;
154 
155  LLVM_DEBUG({
156  dbgs() << " Processing segment "
157  << static_cast<sys::Memory::ProtectionFlags>(Prot) << " [ "
158  << (const void *)SegMem.data() << " .. "
159  << (const void *)((char *)SegMem.data() + SegMem.size())
160  << " ]\n Processing content sections:\n";
161  });
162 
163  for (auto &SI : SegLayout.ContentSections) {
164  LLVM_DEBUG(dbgs() << " " << SI.S->getName() << ":\n");
165 
166  AtomDataPtr += alignmentAdjustment(AtomDataPtr, SI.S->getAlignment());
167 
168  LLVM_DEBUG({
169  dbgs() << " Bumped atom pointer to " << (const void *)AtomDataPtr
170  << " to meet section alignment "
171  << " of " << SI.S->getAlignment() << "\n";
172  });
173 
174  for (auto *DA : SI.Atoms) {
175 
176  // Align.
177  AtomDataPtr += alignmentAdjustment(AtomDataPtr, DA->getAlignment());
178  LLVM_DEBUG({
179  dbgs() << " Bumped atom pointer to "
180  << (const void *)AtomDataPtr << " to meet alignment of "
181  << DA->getAlignment() << "\n";
182  });
183 
184  // Zero pad up to alignment.
185  LLVM_DEBUG({
186  if (LastAtomEnd != AtomDataPtr)
187  dbgs() << " Zero padding from " << (const void *)LastAtomEnd
188  << " to " << (const void *)AtomDataPtr << "\n";
189  });
190  while (LastAtomEnd != AtomDataPtr)
191  *LastAtomEnd++ = 0;
192 
193  // Copy initial atom content.
194  LLVM_DEBUG({
195  dbgs() << " Copying atom " << *DA << " content, "
196  << DA->getContent().size() << " bytes, from "
197  << (const void *)DA->getContent().data() << " to "
198  << (const void *)AtomDataPtr << "\n";
199  });
200  memcpy(AtomDataPtr, DA->getContent().data(), DA->getContent().size());
201 
202  // Copy atom data and apply fixups.
203  LLVM_DEBUG(dbgs() << " Applying fixups.\n");
204  for (auto &E : DA->edges()) {
205 
206  // Skip non-relocation edges.
207  if (!E.isRelocation())
208  continue;
209 
210  // Dispatch to LinkerImpl for fixup.
211  if (auto Err = impl().applyFixup(*DA, E, AtomDataPtr))
212  return Err;
213  }
214 
215  // Point the atom's content to the fixed up buffer.
216  DA->setContent(StringRef(AtomDataPtr, DA->getContent().size()));
217 
218  // Update atom end pointer.
219  LastAtomEnd = AtomDataPtr + DA->getContent().size();
220  AtomDataPtr = LastAtomEnd;
221  }
222  }
223 
224  // Zero pad the rest of the segment.
225  LLVM_DEBUG({
226  dbgs() << " Zero padding end of segment from "
227  << (const void *)LastAtomEnd << " to "
228  << (const void *)((char *)SegMem.data() + SegMem.size()) << "\n";
229  });
230  while (LastAtomEnd != SegMem.data() + SegMem.size())
231  *LastAtomEnd++ = 0;
232  }
233 
234  return Error::success();
235  }
236 };
237 
238 /// Dead strips and replaces discarded definitions with external atoms.
239 ///
240 /// Finds the set of nodes reachable from any node initially marked live
241 /// (nodes marked should-discard are treated as not live, even if they are
242 /// reachable). All nodes not marked as live at the end of this process,
243 /// are deleted. Nodes that are live, but marked should-discard are replaced
244 /// with external atoms and all edges to them are re-written.
245 void prune(AtomGraph &G);
246 
247 Error addEHFrame(AtomGraph &G, Section &EHFrameSection,
248  StringRef EHFrameContent, JITTargetAddress EHFrameAddress,
249  Edge::Kind FDEToCIERelocKind, Edge::Kind FDEToTargetRelocKind);
250 
251 } // end namespace jitlink
252 } // end namespace llvm
253 
254 #undef DEBUG_TYPE // "jitlink"
255 
256 #endif // LLVM_EXECUTIONENGINE_JITLINK_JITLINKGENERIC_H
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Implements a dense probed hash-table based set.
Definition: DenseSet.h:249
Definition: BitVector.h:937
Tagged union holding either a T or a Error.
Definition: yaml2obj.h:21
#define G(x, y, z)
Definition: MD5.cpp:56
place backedge safepoints impl
uint64_t JITTargetAddress
Represents an address in the target process&#39;s address space.
Definition: JITSymbol.h:40
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
size_t alignmentAdjustment(const void *Ptr, size_t Alignment)
Returns the necessary adjustment for aligning Ptr to Alignment bytes, rounding up.
Definition: MathExtras.h:638
static ErrorSuccess success()
Create a success value.
Definition: Error.h:326
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
#define LLVM_DEBUG(X)
Definition: Debug.h:122
constexpr char Args[]
Key for Kernel::Metadata::mArgs.