LLVM  16.0.0git
EPCIndirectionUtils.cpp
Go to the documentation of this file.
1 //===------- EPCIndirectionUtils.cpp -- EPC based indirection 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 
10 
13 
14 #include <future>
15 
16 using namespace llvm;
17 using namespace llvm::orc;
18 
19 namespace llvm {
20 namespace orc {
21 
23 public:
24  using IndirectStubInfo = EPCIndirectionUtils::IndirectStubInfo;
25  using IndirectStubInfoVector = EPCIndirectionUtils::IndirectStubInfoVector;
26 
28  getIndirectStubs(EPCIndirectionUtils &EPCIU, unsigned NumStubs) {
29  return EPCIU.getIndirectStubs(NumStubs);
30  };
31 };
32 
33 } // end namespace orc
34 } // end namespace llvm
35 
36 namespace {
37 
38 class EPCTrampolinePool : public TrampolinePool {
39 public:
40  EPCTrampolinePool(EPCIndirectionUtils &EPCIU);
41  Error deallocatePool();
42 
43 protected:
44  Error grow() override;
45 
46  using FinalizedAlloc = jitlink::JITLinkMemoryManager::FinalizedAlloc;
47 
48  EPCIndirectionUtils &EPCIU;
49  unsigned TrampolineSize = 0;
50  unsigned TrampolinesPerPage = 0;
51  std::vector<FinalizedAlloc> TrampolineBlocks;
52 };
53 
54 class EPCIndirectStubsManager : public IndirectStubsManager,
56 public:
57  EPCIndirectStubsManager(EPCIndirectionUtils &EPCIU) : EPCIU(EPCIU) {}
58 
59  Error deallocateStubs();
60 
61  Error createStub(StringRef StubName, JITTargetAddress StubAddr,
62  JITSymbolFlags StubFlags) override;
63 
64  Error createStubs(const StubInitsMap &StubInits) override;
65 
66  JITEvaluatedSymbol findStub(StringRef Name, bool ExportedStubsOnly) override;
67 
68  JITEvaluatedSymbol findPointer(StringRef Name) override;
69 
70  Error updatePointer(StringRef Name, JITTargetAddress NewAddr) override;
71 
72 private:
73  using StubInfo = std::pair<IndirectStubInfo, JITSymbolFlags>;
74 
75  std::mutex ISMMutex;
76  EPCIndirectionUtils &EPCIU;
77  StringMap<StubInfo> StubInfos;
78 };
79 
80 EPCTrampolinePool::EPCTrampolinePool(EPCIndirectionUtils &EPCIU)
81  : EPCIU(EPCIU) {
82  auto &EPC = EPCIU.getExecutorProcessControl();
83  auto &ABI = EPCIU.getABISupport();
84 
85  TrampolineSize = ABI.getTrampolineSize();
86  TrampolinesPerPage =
87  (EPC.getPageSize() - ABI.getPointerSize()) / TrampolineSize;
88 }
89 
90 Error EPCTrampolinePool::deallocatePool() {
91  std::promise<MSVCPError> DeallocResultP;
92  auto DeallocResultF = DeallocResultP.get_future();
93 
95  std::move(TrampolineBlocks),
96  [&](Error Err) { DeallocResultP.set_value(std::move(Err)); });
97 
98  return DeallocResultF.get();
99 }
100 
101 Error EPCTrampolinePool::grow() {
102  using namespace jitlink;
103 
104  assert(AvailableTrampolines.empty() &&
105  "Grow called with trampolines still available");
106 
107  auto ResolverAddress = EPCIU.getResolverBlockAddress();
108  assert(ResolverAddress && "Resolver address can not be null");
109 
110  auto &EPC = EPCIU.getExecutorProcessControl();
111  auto PageSize = EPC.getPageSize();
112  auto Alloc = SimpleSegmentAlloc::Create(
113  EPC.getMemMgr(), nullptr,
114  {{MemProt::Read | MemProt::Exec, {PageSize, Align(PageSize)}}});
115  if (!Alloc)
116  return Alloc.takeError();
117 
118  unsigned NumTrampolines = TrampolinesPerPage;
119 
120  auto SegInfo = Alloc->getSegInfo(MemProt::Read | MemProt::Exec);
121  EPCIU.getABISupport().writeTrampolines(SegInfo.WorkingMem.data(),
122  SegInfo.Addr.getValue(),
123  ResolverAddress, NumTrampolines);
124  for (unsigned I = 0; I < NumTrampolines; ++I)
125  AvailableTrampolines.push_back(SegInfo.Addr.getValue() +
126  (I * TrampolineSize));
127 
128  auto FA = Alloc->finalize();
129  if (!FA)
130  return FA.takeError();
131 
132  TrampolineBlocks.push_back(std::move(*FA));
133 
134  return Error::success();
135 }
136 
137 Error EPCIndirectStubsManager::createStub(StringRef StubName,
138  JITTargetAddress StubAddr,
139  JITSymbolFlags StubFlags) {
140  StubInitsMap SIM;
141  SIM[StubName] = std::make_pair(StubAddr, StubFlags);
142  return createStubs(SIM);
143 }
144 
145 Error EPCIndirectStubsManager::createStubs(const StubInitsMap &StubInits) {
146  auto AvailableStubInfos = getIndirectStubs(EPCIU, StubInits.size());
147  if (!AvailableStubInfos)
148  return AvailableStubInfos.takeError();
149 
150  {
151  std::lock_guard<std::mutex> Lock(ISMMutex);
152  unsigned ASIdx = 0;
153  for (auto &SI : StubInits) {
154  auto &A = (*AvailableStubInfos)[ASIdx++];
155  StubInfos[SI.first()] = std::make_pair(A, SI.second.second);
156  }
157  }
158 
159  auto &MemAccess = EPCIU.getExecutorProcessControl().getMemoryAccess();
160  switch (EPCIU.getABISupport().getPointerSize()) {
161  case 4: {
162  unsigned ASIdx = 0;
163  std::vector<tpctypes::UInt32Write> PtrUpdates;
164  for (auto &SI : StubInits)
165  PtrUpdates.push_back(
166  {ExecutorAddr((*AvailableStubInfos)[ASIdx++].PointerAddress),
167  static_cast<uint32_t>(SI.second.first)});
168  return MemAccess.writeUInt32s(PtrUpdates);
169  }
170  case 8: {
171  unsigned ASIdx = 0;
172  std::vector<tpctypes::UInt64Write> PtrUpdates;
173  for (auto &SI : StubInits)
174  PtrUpdates.push_back(
175  {ExecutorAddr((*AvailableStubInfos)[ASIdx++].PointerAddress),
176  static_cast<uint64_t>(SI.second.first)});
177  return MemAccess.writeUInt64s(PtrUpdates);
178  }
179  default:
180  return make_error<StringError>("Unsupported pointer size",
182  }
183 }
184 
185 JITEvaluatedSymbol EPCIndirectStubsManager::findStub(StringRef Name,
186  bool ExportedStubsOnly) {
187  std::lock_guard<std::mutex> Lock(ISMMutex);
188  auto I = StubInfos.find(Name);
189  if (I == StubInfos.end())
190  return nullptr;
191  return {I->second.first.StubAddress, I->second.second};
192 }
193 
194 JITEvaluatedSymbol EPCIndirectStubsManager::findPointer(StringRef Name) {
195  std::lock_guard<std::mutex> Lock(ISMMutex);
196  auto I = StubInfos.find(Name);
197  if (I == StubInfos.end())
198  return nullptr;
199  return {I->second.first.PointerAddress, I->second.second};
200 }
201 
202 Error EPCIndirectStubsManager::updatePointer(StringRef Name,
203  JITTargetAddress NewAddr) {
204 
205  JITTargetAddress PtrAddr = 0;
206  {
207  std::lock_guard<std::mutex> Lock(ISMMutex);
208  auto I = StubInfos.find(Name);
209  if (I == StubInfos.end())
210  return make_error<StringError>("Unknown stub name",
212  PtrAddr = I->second.first.PointerAddress;
213  }
214 
215  auto &MemAccess = EPCIU.getExecutorProcessControl().getMemoryAccess();
216  switch (EPCIU.getABISupport().getPointerSize()) {
217  case 4: {
218  tpctypes::UInt32Write PUpdate(ExecutorAddr(PtrAddr), NewAddr);
219  return MemAccess.writeUInt32s(PUpdate);
220  }
221  case 8: {
222  tpctypes::UInt64Write PUpdate(ExecutorAddr(PtrAddr), NewAddr);
223  return MemAccess.writeUInt64s(PUpdate);
224  }
225  default:
226  return make_error<StringError>("Unsupported pointer size",
228  }
229 }
230 
231 } // end anonymous namespace.
232 
233 namespace llvm {
234 namespace orc {
235 
237 
240  const auto &TT = EPC.getTargetTriple();
241  switch (TT.getArch()) {
242  default:
243  return make_error<StringError>(
244  std::string("No EPCIndirectionUtils available for ") + TT.str(),
246  case Triple::aarch64:
247  case Triple::aarch64_32:
248  return CreateWithABI<OrcAArch64>(EPC);
249 
250  case Triple::x86:
251  return CreateWithABI<OrcI386>(EPC);
252 
253  case Triple::mips:
254  return CreateWithABI<OrcMips32Be>(EPC);
255 
256  case Triple::mipsel:
257  return CreateWithABI<OrcMips32Le>(EPC);
258 
259  case Triple::mips64:
260  case Triple::mips64el:
261  return CreateWithABI<OrcMips64>(EPC);
262 
263  case Triple::riscv64:
264  return CreateWithABI<OrcRiscv64>(EPC);
265 
266  case Triple::x86_64:
267  if (TT.getOS() == Triple::OSType::Win32)
268  return CreateWithABI<OrcX86_64_Win32>(EPC);
269  else
270  return CreateWithABI<OrcX86_64_SysV>(EPC);
271  }
272 }
273 
275 
276  auto &MemMgr = EPC.getMemMgr();
277  auto Err = MemMgr.deallocate(std::move(IndirectStubAllocs));
278 
279  if (TP)
280  Err = joinErrors(std::move(Err),
281  static_cast<EPCTrampolinePool &>(*TP).deallocatePool());
282 
283  if (ResolverBlock)
284  Err =
285  joinErrors(std::move(Err), MemMgr.deallocate(std::move(ResolverBlock)));
286 
287  return Err;
288 }
289 
292  JITTargetAddress ReentryCtxAddr) {
293  using namespace jitlink;
294 
295  assert(ABI && "ABI can not be null");
296  auto ResolverSize = ABI->getResolverCodeSize();
297 
298  auto Alloc =
299  SimpleSegmentAlloc::Create(EPC.getMemMgr(), nullptr,
300  {{MemProt::Read | MemProt::Exec,
301  {ResolverSize, Align(EPC.getPageSize())}}});
302 
303  if (!Alloc)
304  return Alloc.takeError();
305 
306  auto SegInfo = Alloc->getSegInfo(MemProt::Read | MemProt::Exec);
307  ResolverBlockAddr = SegInfo.Addr.getValue();
308  ABI->writeResolverCode(SegInfo.WorkingMem.data(), ResolverBlockAddr,
309  ReentryFnAddr, ReentryCtxAddr);
310 
311  auto FA = Alloc->finalize();
312  if (!FA)
313  return FA.takeError();
314 
315  ResolverBlock = std::move(*FA);
316  return ResolverBlockAddr;
317 }
318 
319 std::unique_ptr<IndirectStubsManager>
321  return std::make_unique<EPCIndirectStubsManager>(*this);
322 }
323 
325  if (!TP)
326  TP = std::make_unique<EPCTrampolinePool>(*this);
327  return *TP;
328 }
329 
331  ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr) {
332  assert(!LCTM &&
333  "createLazyCallThroughManager can not have been called before");
334  LCTM = std::make_unique<LazyCallThroughManager>(ES, ErrorHandlerAddr,
335  &getTrampolinePool());
336  return *LCTM;
337 }
338 
339 EPCIndirectionUtils::EPCIndirectionUtils(ExecutorProcessControl &EPC,
340  std::unique_ptr<ABISupport> ABI)
341  : EPC(EPC), ABI(std::move(ABI)) {
342  assert(this->ABI && "ABI can not be null");
343 
344  assert(EPC.getPageSize() > getABISupport().getStubSize() &&
345  "Stubs larger than one page are not supported");
346 }
347 
349 EPCIndirectionUtils::getIndirectStubs(unsigned NumStubs) {
350  using namespace jitlink;
351 
352  std::lock_guard<std::mutex> Lock(EPCUIMutex);
353 
354  // If there aren't enough stubs available then allocate some more.
355  if (NumStubs > AvailableIndirectStubs.size()) {
356  auto NumStubsToAllocate = NumStubs;
357  auto PageSize = EPC.getPageSize();
358  auto StubBytes = alignTo(NumStubsToAllocate * ABI->getStubSize(), PageSize);
359  NumStubsToAllocate = StubBytes / ABI->getStubSize();
360  auto PtrBytes =
361  alignTo(NumStubsToAllocate * ABI->getPointerSize(), PageSize);
362 
363  auto StubProt = MemProt::Read | MemProt::Exec;
364  auto PtrProt = MemProt::Read | MemProt::Write;
365 
366  auto Alloc = SimpleSegmentAlloc::Create(
367  EPC.getMemMgr(), nullptr,
368  {{StubProt, {static_cast<size_t>(StubBytes), Align(PageSize)}},
369  {PtrProt, {static_cast<size_t>(PtrBytes), Align(PageSize)}}});
370 
371  if (!Alloc)
372  return Alloc.takeError();
373 
374  auto StubSeg = Alloc->getSegInfo(StubProt);
375  auto PtrSeg = Alloc->getSegInfo(PtrProt);
376 
377  ABI->writeIndirectStubsBlock(StubSeg.WorkingMem.data(),
378  StubSeg.Addr.getValue(),
379  PtrSeg.Addr.getValue(), NumStubsToAllocate);
380 
381  auto FA = Alloc->finalize();
382  if (!FA)
383  return FA.takeError();
384 
385  IndirectStubAllocs.push_back(std::move(*FA));
386 
387  auto StubExecutorAddr = StubSeg.Addr;
388  auto PtrExecutorAddr = PtrSeg.Addr;
389  for (unsigned I = 0; I != NumStubsToAllocate; ++I) {
390  AvailableIndirectStubs.push_back(IndirectStubInfo(
391  StubExecutorAddr.getValue(), PtrExecutorAddr.getValue()));
392  StubExecutorAddr += ABI->getStubSize();
393  PtrExecutorAddr += ABI->getPointerSize();
394  }
395  }
396 
397  assert(NumStubs <= AvailableIndirectStubs.size() &&
398  "Sufficient stubs should have been allocated above");
399 
400  IndirectStubInfoVector Result;
401  while (NumStubs--) {
402  Result.push_back(AvailableIndirectStubs.back());
403  AvailableIndirectStubs.pop_back();
404  }
405 
406  return std::move(Result);
407 }
408 
410  JITTargetAddress TrampolineAddr) {
411  auto &LCTM = *jitTargetAddressToPointer<LazyCallThroughManager *>(LCTMAddr);
412  std::promise<JITTargetAddress> LandingAddrP;
413  auto LandingAddrF = LandingAddrP.get_future();
414  LCTM.resolveTrampolineLandingAddress(
415  TrampolineAddr,
416  [&](JITTargetAddress Addr) { LandingAddrP.set_value(Addr); });
417  return LandingAddrF.get();
418 }
419 
421  auto &LCTM = EPCIU.getLazyCallThroughManager();
422  return EPCIU
425  .takeError();
426 }
427 
428 } // end namespace orc
429 } // end namespace llvm
llvm::orc::ExecutorAddr
Represents an address in the executor process.
Definition: ExecutorAddress.h:30
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:156
llvm::Triple::riscv64
@ riscv64
Definition: Triple.h:76
llvm::orc::EPCIndirectionUtils::cleanup
Error cleanup()
Release memory for resources held by this instance.
Definition: EPCIndirectionUtils.cpp:274
ABI
Generic address nodes are lowered to some combination of target independent and machine specific ABI
Definition: Relocation.txt:34
MathExtras.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::orc::ExecutorProcessControl::getMemoryAccess
MemoryAccess & getMemoryAccess() const
Return a MemoryAccess object for the target process.
Definition: ExecutorProcessControl.h:210
llvm::Triple::x86
@ x86
Definition: Triple.h:85
llvm::orc::EPCIndirectionUtils::createIndirectStubsManager
std::unique_ptr< IndirectStubsManager > createIndirectStubsManager()
Create an IndirectStubsManager for the executor process.
Definition: EPCIndirectionUtils.cpp:320
llvm::orc::setUpInProcessLCTMReentryViaEPCIU
Error setUpInProcessLCTMReentryViaEPCIU(EPCIndirectionUtils &EPCIU)
This will call writeResolver on the given EPCIndirectionUtils instance to set up re-entry via a funct...
Definition: EPCIndirectionUtils.cpp:420
llvm::orc::IndirectStubsManager
Base class for managing collections of named indirect stubs.
Definition: IndirectionUtils.h:282
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
llvm::orc::LazyCallThroughManager
Manages a set of 'lazy call-through' trampolines.
Definition: LazyReexports.h:38
llvm::Triple::x86_64
@ x86_64
Definition: Triple.h:86
llvm::orc::ExecutorProcessControl
ExecutorProcessControl supports interaction with a JIT target process.
Definition: ExecutorProcessControl.h:38
llvm::orc::EPCIndirectionUtilsAccess::IndirectStubInfoVector
EPCIndirectionUtils::IndirectStubInfoVector IndirectStubInfoVector
Definition: EPCIndirectionUtils.cpp:25
llvm::orc::EPCIndirectionUtils::getLazyCallThroughManager
LazyCallThroughManager & getLazyCallThroughManager()
Create a LazyCallThroughManager for the executor process.
Definition: EPCIndirectionUtils.h:123
llvm::orc::EPCIndirectionUtilsAccess
Definition: EPCIndirectionUtils.cpp:22
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
llvm::Triple::aarch64_32
@ aarch64_32
Definition: Triple.h:53
llvm::Triple::mips64
@ mips64
Definition: Triple.h:66
llvm::JITSymbolFlags
Flags for symbols in the JIT.
Definition: JITSymbol.h:74
llvm::JITEvaluatedSymbol
Represents a symbol that has been evaluated to an address already.
Definition: JITSymbol.h:229
llvm::orc::EPCIndirectionUtils::getExecutorProcessControl
ExecutorProcessControl & getExecutorProcessControl() const
Return a reference to the ExecutorProcessControl object.
Definition: EPCIndirectionUtils.h:90
llvm::orc::EPCIndirectionUtils::ABISupport::~ABISupport
virtual ~ABISupport()
PageSize
static cl::opt< int > PageSize("imp-null-check-page-size", cl::desc("The page size of the target in bytes"), cl::init(4096), cl::Hidden)
llvm::orc::ExecutorProcessControl::getMemMgr
jitlink::JITLinkMemoryManager & getMemMgr() const
Return a JITLinkMemoryManager for the target process.
Definition: ExecutorProcessControl.h:216
llvm::orc::reentry
static JITTargetAddress reentry(JITTargetAddress LCTMAddr, JITTargetAddress TrampolineAddr)
Definition: EPCIndirectionUtils.cpp:409
llvm::ARM_PROC::A
@ A
Definition: ARMBaseInfo.h:34
llvm::Triple::mips64el
@ mips64el
Definition: Triple.h:67
llvm::orc
Definition: COFFPlatform.h:30
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
llvm::orc::TrampolinePool
Base class for pools of compiler re-entry trampolines.
Definition: IndirectionUtils.h:63
llvm::orc::EPCIndirectionUtils::ABISupport::writeTrampolines
virtual void writeTrampolines(char *TrampolineBlockWorkingMem, JITTargetAddress TrampolineBlockTragetAddr, JITTargetAddress ResolverAddr, unsigned NumTrampolines) const =0
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:110
Alloc
uint64_t
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:78
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::orc::EPCIndirectionUtilsAccess::IndirectStubInfo
EPCIndirectionUtils::IndirectStubInfo IndirectStubInfo
Definition: EPCIndirectionUtils.cpp:24
llvm::joinErrors
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:426
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::LoongArchABI::ABI
ABI
Definition: LoongArchBaseInfo.h:26
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1676
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::orc::EPCIndirectionUtils::getTrampolinePool
TrampolinePool & getTrampolinePool()
Create a TrampolinePool for the executor process.
Definition: EPCIndirectionUtils.cpp:324
llvm::orc::EPCIndirectionUtils::getABISupport
ABISupport & getABISupport() const
Return a reference to the ABISupport object for this instance.
Definition: EPCIndirectionUtils.h:93
llvm::orc::ExecutorProcessControl::MemoryAccess::writeUInt32s
Error writeUInt32s(ArrayRef< tpctypes::UInt32Write > Ws)
Definition: ExecutorProcessControl.h:139
EPCIndirectionUtils.h
llvm::orc::tpctypes::UIntWrite
Definition: TargetProcessControlTypes.h:96
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm::orc::EPCIndirectionUtils::writeResolverBlock
Expected< JITTargetAddress > writeResolverBlock(JITTargetAddress ReentryFnAddr, JITTargetAddress ReentryCtxAddr)
Write resolver code to the executor process and return its address.
Definition: EPCIndirectionUtils.cpp:291
uint32_t
llvm::orc::EPCIndirectionUtils::getResolverBlockAddress
JITTargetAddress getResolverBlockAddress() const
Returns the address of the Resolver block.
Definition: EPCIndirectionUtils.h:108
llvm::pointerToJITTargetAddress
JITTargetAddress pointerToJITTargetAddress(T *Ptr)
Convert a pointer to a JITTargetAddress.
Definition: JITSymbol.h:69
llvm::orc::EPCIndirectionUtils::Create
static Expected< std::unique_ptr< EPCIndirectionUtils > > Create(ExecutorProcessControl &EPC)
Create based on the ExecutorProcessControl triple.
Definition: EPCIndirectionUtils.cpp:239
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
std
Definition: BitVector.h:851
llvm::inconvertibleErrorCode
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:79
llvm::orc::ExecutorProcessControl::getTargetTriple
const Triple & getTargetTriple() const
Return the Triple for the target process.
Definition: ExecutorProcessControl.h:201
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::orc::ExecutionSession
An ExecutionSession represents a running JIT program.
Definition: Core.h:1358
llvm::Triple::mipsel
@ mipsel
Definition: Triple.h:65
llvm::orc::ExecutorProcessControl::getPageSize
unsigned getPageSize() const
Get the page size for the target process.
Definition: ExecutorProcessControl.h:204
llvm::orc::EPCIndirectionUtilsAccess::getIndirectStubs
static Expected< IndirectStubInfoVector > getIndirectStubs(EPCIndirectionUtils &EPCIU, unsigned NumStubs)
Definition: EPCIndirectionUtils.cpp:28
llvm::JITTargetAddress
uint64_t JITTargetAddress
Represents an address in the target process's address space.
Definition: JITSymbol.h:42
llvm::orc::EPCIndirectionUtils::createLazyCallThroughManager
LazyCallThroughManager & createLazyCallThroughManager(ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr)
Create a LazyCallThroughManager.
Definition: EPCIndirectionUtils.cpp:330
ExecutorProcessControl.h
llvm::orc::EPCIndirectionUtils
Provides ExecutorProcessControl based indirect stubs, trampoline pool and lazy call through manager.
Definition: EPCIndirectionUtils.h:30
llvm::orc::EPCIndirectionUtils::ABISupport::getPointerSize
unsigned getPointerSize() const
Definition: EPCIndirectionUtils.h:48
llvm::Triple::mips
@ mips
Definition: Triple.h:64
llvm::Triple::aarch64
@ aarch64
Definition: Triple.h:51