LLVM  14.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 
47 
48  EPCIndirectionUtils &EPCIU;
49  unsigned TrampolineSize = 0;
50  unsigned TrampolinesPerPage = 0;
51  std::vector<std::unique_ptr<Allocation>> 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  Error Err = Error::success();
92  for (auto &Alloc : TrampolineBlocks)
93  Err = joinErrors(std::move(Err), Alloc->deallocate());
94  return Err;
95 }
96 
97 Error EPCTrampolinePool::grow() {
98  assert(AvailableTrampolines.empty() &&
99  "Grow called with trampolines still available");
100 
101  auto ResolverAddress = EPCIU.getResolverBlockAddress();
102  assert(ResolverAddress && "Resolver address can not be null");
103 
104  auto &EPC = EPCIU.getExecutorProcessControl();
105  constexpr auto TrampolinePagePermissions =
108  auto PageSize = EPC.getPageSize();
110  Request[TrampolinePagePermissions] = {PageSize, static_cast<size_t>(PageSize),
111  0};
112  auto Alloc = EPC.getMemMgr().allocate(nullptr, Request);
113 
114  if (!Alloc)
115  return Alloc.takeError();
116 
117  unsigned NumTrampolines = TrampolinesPerPage;
118 
119  auto WorkingMemory = (*Alloc)->getWorkingMemory(TrampolinePagePermissions);
120  auto TargetAddress = (*Alloc)->getTargetMemory(TrampolinePagePermissions);
121 
122  EPCIU.getABISupport().writeTrampolines(WorkingMemory.data(), TargetAddress,
123  ResolverAddress, NumTrampolines);
124 
125  auto TargetAddr = (*Alloc)->getTargetMemory(TrampolinePagePermissions);
126  for (unsigned I = 0; I < NumTrampolines; ++I)
127  AvailableTrampolines.push_back(TargetAddr + (I * TrampolineSize));
128 
129  if (auto Err = (*Alloc)->finalize())
130  return Err;
131 
132  TrampolineBlocks.push_back(std::move(*Alloc));
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({(*AvailableStubInfos)[ASIdx++].PointerAddress,
166  static_cast<uint32_t>(SI.second.first)});
167  return MemAccess.writeUInt32s(PtrUpdates);
168  }
169  case 8: {
170  unsigned ASIdx = 0;
171  std::vector<tpctypes::UInt64Write> PtrUpdates;
172  for (auto &SI : StubInits)
173  PtrUpdates.push_back({(*AvailableStubInfos)[ASIdx++].PointerAddress,
174  static_cast<uint64_t>(SI.second.first)});
175  return MemAccess.writeUInt64s(PtrUpdates);
176  }
177  default:
178  return make_error<StringError>("Unsupported pointer size",
180  }
181 }
182 
183 JITEvaluatedSymbol EPCIndirectStubsManager::findStub(StringRef Name,
184  bool ExportedStubsOnly) {
185  std::lock_guard<std::mutex> Lock(ISMMutex);
186  auto I = StubInfos.find(Name);
187  if (I == StubInfos.end())
188  return nullptr;
189  return {I->second.first.StubAddress, I->second.second};
190 }
191 
192 JITEvaluatedSymbol EPCIndirectStubsManager::findPointer(StringRef Name) {
193  std::lock_guard<std::mutex> Lock(ISMMutex);
194  auto I = StubInfos.find(Name);
195  if (I == StubInfos.end())
196  return nullptr;
197  return {I->second.first.PointerAddress, I->second.second};
198 }
199 
200 Error EPCIndirectStubsManager::updatePointer(StringRef Name,
201  JITTargetAddress NewAddr) {
202 
203  JITTargetAddress PtrAddr = 0;
204  {
205  std::lock_guard<std::mutex> Lock(ISMMutex);
206  auto I = StubInfos.find(Name);
207  if (I == StubInfos.end())
208  return make_error<StringError>("Unknown stub name",
210  PtrAddr = I->second.first.PointerAddress;
211  }
212 
213  auto &MemAccess = EPCIU.getExecutorProcessControl().getMemoryAccess();
214  switch (EPCIU.getABISupport().getPointerSize()) {
215  case 4: {
216  tpctypes::UInt32Write PUpdate(PtrAddr, NewAddr);
217  return MemAccess.writeUInt32s(PUpdate);
218  }
219  case 8: {
220  tpctypes::UInt64Write PUpdate(PtrAddr, NewAddr);
221  return MemAccess.writeUInt64s(PUpdate);
222  }
223  default:
224  return make_error<StringError>("Unsupported pointer size",
226  }
227 }
228 
229 } // end anonymous namespace.
230 
231 namespace llvm {
232 namespace orc {
233 
235 
238  const auto &TT = EPC.getTargetTriple();
239  switch (TT.getArch()) {
240  default:
241  return make_error<StringError>(
242  std::string("No EPCIndirectionUtils available for ") + TT.str(),
244  case Triple::aarch64:
245  case Triple::aarch64_32:
246  return CreateWithABI<OrcAArch64>(EPC);
247 
248  case Triple::x86:
249  return CreateWithABI<OrcI386>(EPC);
250 
251  case Triple::mips:
252  return CreateWithABI<OrcMips32Be>(EPC);
253 
254  case Triple::mipsel:
255  return CreateWithABI<OrcMips32Le>(EPC);
256 
257  case Triple::mips64:
258  case Triple::mips64el:
259  return CreateWithABI<OrcMips64>(EPC);
260 
261  case Triple::x86_64:
262  if (TT.getOS() == Triple::OSType::Win32)
263  return CreateWithABI<OrcX86_64_Win32>(EPC);
264  else
265  return CreateWithABI<OrcX86_64_SysV>(EPC);
266  }
267 }
268 
270  Error Err = Error::success();
271 
272  for (auto &A : IndirectStubAllocs)
273  Err = joinErrors(std::move(Err), A->deallocate());
274 
275  if (TP)
276  Err = joinErrors(std::move(Err),
277  static_cast<EPCTrampolinePool &>(*TP).deallocatePool());
278 
279  if (ResolverBlock)
280  Err = joinErrors(std::move(Err), ResolverBlock->deallocate());
281 
282  return Err;
283 }
284 
287  JITTargetAddress ReentryCtxAddr) {
288  assert(ABI && "ABI can not be null");
289  constexpr auto ResolverBlockPermissions =
292  auto ResolverSize = ABI->getResolverCodeSize();
293 
295  Request[ResolverBlockPermissions] = {EPC.getPageSize(),
296  static_cast<size_t>(ResolverSize), 0};
297  auto Alloc = EPC.getMemMgr().allocate(nullptr, Request);
298  if (!Alloc)
299  return Alloc.takeError();
300 
301  auto WorkingMemory = (*Alloc)->getWorkingMemory(ResolverBlockPermissions);
302  ResolverBlockAddr = (*Alloc)->getTargetMemory(ResolverBlockPermissions);
303  ABI->writeResolverCode(WorkingMemory.data(), ResolverBlockAddr, ReentryFnAddr,
304  ReentryCtxAddr);
305 
306  if (auto Err = (*Alloc)->finalize())
307  return std::move(Err);
308 
309  ResolverBlock = std::move(*Alloc);
310  return ResolverBlockAddr;
311 }
312 
313 std::unique_ptr<IndirectStubsManager>
315  return std::make_unique<EPCIndirectStubsManager>(*this);
316 }
317 
319  if (!TP)
320  TP = std::make_unique<EPCTrampolinePool>(*this);
321  return *TP;
322 }
323 
325  ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr) {
326  assert(!LCTM &&
327  "createLazyCallThroughManager can not have been called before");
328  LCTM = std::make_unique<LazyCallThroughManager>(ES, ErrorHandlerAddr,
329  &getTrampolinePool());
330  return *LCTM;
331 }
332 
333 EPCIndirectionUtils::EPCIndirectionUtils(ExecutorProcessControl &EPC,
334  std::unique_ptr<ABISupport> ABI)
335  : EPC(EPC), ABI(std::move(ABI)) {
336  assert(this->ABI && "ABI can not be null");
337 
338  assert(EPC.getPageSize() > getABISupport().getStubSize() &&
339  "Stubs larger than one page are not supported");
340 }
341 
343 EPCIndirectionUtils::getIndirectStubs(unsigned NumStubs) {
344 
345  std::lock_guard<std::mutex> Lock(EPCUIMutex);
346 
347  // If there aren't enough stubs available then allocate some more.
348  if (NumStubs > AvailableIndirectStubs.size()) {
349  auto NumStubsToAllocate = NumStubs;
350  auto PageSize = EPC.getPageSize();
351  auto StubBytes = alignTo(NumStubsToAllocate * ABI->getStubSize(), PageSize);
352  NumStubsToAllocate = StubBytes / ABI->getStubSize();
353  auto PointerBytes =
354  alignTo(NumStubsToAllocate * ABI->getPointerSize(), PageSize);
355 
356  constexpr auto StubPagePermissions =
359  constexpr auto PointerPagePermissions =
362 
364  Request[StubPagePermissions] = {PageSize, static_cast<size_t>(StubBytes),
365  0};
366  Request[PointerPagePermissions] = {PageSize, 0, PointerBytes};
367  auto Alloc = EPC.getMemMgr().allocate(nullptr, Request);
368  if (!Alloc)
369  return Alloc.takeError();
370 
371  auto StubTargetAddr = (*Alloc)->getTargetMemory(StubPagePermissions);
372  auto PointerTargetAddr = (*Alloc)->getTargetMemory(PointerPagePermissions);
373 
374  ABI->writeIndirectStubsBlock(
375  (*Alloc)->getWorkingMemory(StubPagePermissions).data(), StubTargetAddr,
376  PointerTargetAddr, NumStubsToAllocate);
377 
378  if (auto Err = (*Alloc)->finalize())
379  return std::move(Err);
380 
381  for (unsigned I = 0; I != NumStubsToAllocate; ++I) {
382  AvailableIndirectStubs.push_back(
383  IndirectStubInfo(StubTargetAddr, PointerTargetAddr));
384  StubTargetAddr += ABI->getStubSize();
385  PointerTargetAddr += ABI->getPointerSize();
386  }
387 
388  IndirectStubAllocs.push_back(std::move(*Alloc));
389  }
390 
391  assert(NumStubs <= AvailableIndirectStubs.size() &&
392  "Sufficient stubs should have been allocated above");
393 
394  IndirectStubInfoVector Result;
395  while (NumStubs--) {
396  Result.push_back(AvailableIndirectStubs.back());
397  AvailableIndirectStubs.pop_back();
398  }
399 
400  return std::move(Result);
401 }
402 
404  JITTargetAddress TrampolineAddr) {
405  auto &LCTM = *jitTargetAddressToPointer<LazyCallThroughManager *>(LCTMAddr);
406  std::promise<JITTargetAddress> LandingAddrP;
407  auto LandingAddrF = LandingAddrP.get_future();
408  LCTM.resolveTrampolineLandingAddress(
409  TrampolineAddr,
410  [&](JITTargetAddress Addr) { LandingAddrP.set_value(Addr); });
411  return LandingAddrF.get();
412 }
413 
415  auto &LCTM = EPCIU.getLazyCallThroughManager();
416  return EPCIU
419  .takeError();
420 }
421 
422 } // end namespace orc
423 } // end namespace llvm
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:148
llvm::orc::EPCIndirectionUtils::cleanup
Error cleanup()
Release memory for resources held by this instance.
Definition: EPCIndirectionUtils.cpp:269
ABI
Generic address nodes are lowered to some combination of target independent and machine specific ABI
Definition: Relocation.txt:34
llvm::sys::Memory::MF_READ
@ MF_READ
Definition: Memory.h:55
MathExtras.h
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::sys::Memory::MF_WRITE
@ MF_WRITE
Definition: Memory.h:56
llvm::orc::ExecutorProcessControl::getMemoryAccess
MemoryAccess & getMemoryAccess() const
Return a MemoryAccess object for the target process.
Definition: ExecutorProcessControl.h:150
llvm::Triple::x86
@ x86
Definition: Triple.h:83
llvm::orc::EPCIndirectionUtils::createIndirectStubsManager
std::unique_ptr< IndirectStubsManager > createIndirectStubsManager()
Create an IndirectStubsManager for the executor process.
Definition: EPCIndirectionUtils.cpp:314
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:414
llvm::orc::IndirectStubsManager
Base class for managing collections of named indirect stubs.
Definition: IndirectionUtils.h:275
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:331
llvm::orc::LazyCallThroughManager
Manages a set of 'lazy call-through' trampolines.
Definition: LazyReexports.h:38
llvm::Triple::x86_64
@ x86_64
Definition: Triple.h:84
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:42
llvm::Triple::aarch64_32
@ aarch64_32
Definition: Triple.h:54
llvm::Triple::mips64
@ mips64
Definition: Triple.h:64
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::Lock
static sys::Mutex Lock
Definition: NVPTXUtilities.cpp:39
llvm::orc::EPCIndirectionUtils::ABISupport::~ABISupport
virtual ~ABISupport()
Definition: EPCIndirectionUtils.cpp:234
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:156
Allocation
llvm::orc::reentry
static JITTargetAddress reentry(JITTargetAddress LCTMAddr, JITTargetAddress TrampolineAddr)
Definition: EPCIndirectionUtils.cpp:403
llvm::ARM_PROC::A
@ A
Definition: ARMBaseInfo.h:34
llvm::Triple::mips64el
@ mips64el
Definition: Triple.h:65
llvm::orc
Definition: CompileOnDemandLayer.h:57
llvm::sys::Memory::ProtectionFlags
ProtectionFlags
Definition: Memory.h:54
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
llvm::orc::TrampolinePool
Base class for pools of compiler re-entry trampolines.
Definition: IndirectionUtils.h:56
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:108
llvm::sys::Memory::MF_EXEC
@ MF_EXEC
Definition: Memory.h:57
uint64_t
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:80
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
llvm::DenseMap
Definition: DenseMap.h:714
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::orc::EPCIndirectionUtilsAccess::IndirectStubInfo
EPCIndirectionUtils::IndirectStubInfo IndirectStubInfo
Definition: EPCIndirectionUtils.cpp:24
llvm::joinErrors
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:428
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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:1609
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::orc::EPCIndirectionUtils::getTrampolinePool
TrampolinePool & getTrampolinePool()
Create a TrampolinePool for the executor process.
Definition: EPCIndirectionUtils.cpp:318
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:85
EPCIndirectionUtils.h
llvm::orc::tpctypes::UIntWrite
Definition: TargetProcessControlTypes.h:109
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
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:286
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:237
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
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:77
llvm::orc::ExecutorProcessControl::getTargetTriple
const Triple & getTargetTriple() const
Return the Triple for the target process.
Definition: ExecutorProcessControl.h:141
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::orc::ExecutionSession
An ExecutionSession represents a running JIT program.
Definition: Core.h:1275
llvm::Triple::mipsel
@ mipsel
Definition: Triple.h:63
llvm::orc::ExecutorProcessControl::getPageSize
unsigned getPageSize() const
Get the page size for the target process.
Definition: ExecutorProcessControl.h:144
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:324
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:62
llvm::Triple::aarch64
@ aarch64
Definition: Triple.h:52
llvm::RISCVABI::ABI
ABI
Definition: RISCVBaseInfo.h:290