LLVM  16.0.0git
EPCGenericRTDyldMemoryManager.cpp
Go to the documentation of this file.
1 //===----- EPCGenericRTDyldMemoryManager.cpp - EPC-bbasde MemMgr -----===//
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 
12 #include "llvm/Support/Alignment.h"
14 
15 #define DEBUG_TYPE "orc"
16 
17 using namespace llvm::orc::shared;
18 
19 namespace llvm {
20 namespace orc {
21 
22 Expected<std::unique_ptr<EPCGenericRTDyldMemoryManager>>
25  SymbolAddrs SAs;
26  if (auto Err = EPC.getBootstrapSymbols(
27  {{SAs.Instance, rt::SimpleExecutorMemoryManagerInstanceName},
28  {SAs.Reserve, rt::SimpleExecutorMemoryManagerReserveWrapperName},
29  {SAs.Finalize, rt::SimpleExecutorMemoryManagerFinalizeWrapperName},
30  {SAs.Deallocate,
31  rt::SimpleExecutorMemoryManagerDeallocateWrapperName},
32  {SAs.RegisterEHFrame, rt::RegisterEHFrameSectionWrapperName},
33  {SAs.DeregisterEHFrame, rt::DeregisterEHFrameSectionWrapperName}}))
34  return std::move(Err);
35  return std::make_unique<EPCGenericRTDyldMemoryManager>(EPC, std::move(SAs));
36 }
37 
40  : EPC(EPC), SAs(std::move(SAs)) {
41  LLVM_DEBUG(dbgs() << "Created remote allocator " << (void *)this << "\n");
42 }
43 
45  LLVM_DEBUG(dbgs() << "Destroyed remote allocator " << (void *)this << "\n");
46  if (!ErrMsg.empty())
47  errs() << "Destroying with existing errors:\n" << ErrMsg << "\n";
48 
49  Error Err = Error::success();
50  if (auto Err2 = EPC.callSPSWrapper<
52  SAs.Reserve, Err, SAs.Instance, FinalizedAllocs)) {
53  // FIXME: Report errors through EPC once that functionality is available.
54  logAllUnhandledErrors(std::move(Err2), errs(), "");
55  return;
56  }
57 
58  if (Err)
60 }
61 
63  uintptr_t Size, unsigned Alignment, unsigned SectionID,
65  std::lock_guard<std::mutex> Lock(M);
66  LLVM_DEBUG({
67  dbgs() << "Allocator " << (void *)this << " allocating code section "
68  << SectionName << ": size = " << formatv("{0:x}", Size)
69  << " bytes, alignment = " << Alignment << "\n";
70  });
71  auto &Seg = Unmapped.back().CodeAllocs;
72  Seg.emplace_back(Size, Alignment);
73  return reinterpret_cast<uint8_t *>(
74  alignAddr(Seg.back().Contents.get(), Align(Alignment)));
75 }
76 
78  uintptr_t Size, unsigned Alignment, unsigned SectionID,
79  StringRef SectionName, bool IsReadOnly) {
80  std::lock_guard<std::mutex> Lock(M);
81  LLVM_DEBUG({
82  dbgs() << "Allocator " << (void *)this << " allocating "
83  << (IsReadOnly ? "ro" : "rw") << "-data section " << SectionName
84  << ": size = " << formatv("{0:x}", Size) << " bytes, alignment "
85  << Alignment << ")\n";
86  });
87 
88  auto &Seg =
89  IsReadOnly ? Unmapped.back().RODataAllocs : Unmapped.back().RWDataAllocs;
90 
91  Seg.emplace_back(Size, Alignment);
92  return reinterpret_cast<uint8_t *>(
93  alignAddr(Seg.back().Contents.get(), Align(Alignment)));
94 }
95 
97  uintptr_t CodeSize, uint32_t CodeAlign, uintptr_t RODataSize,
98  uint32_t RODataAlign, uintptr_t RWDataSize, uint32_t RWDataAlign) {
99 
100  {
101  std::lock_guard<std::mutex> Lock(M);
102  // If there's already an error then bail out.
103  if (!ErrMsg.empty())
104  return;
105 
106  if (!isPowerOf2_32(CodeAlign) || CodeAlign > EPC.getPageSize()) {
107  ErrMsg = "Invalid code alignment in reserveAllocationSpace";
108  return;
109  }
110  if (!isPowerOf2_32(RODataAlign) || RODataAlign > EPC.getPageSize()) {
111  ErrMsg = "Invalid ro-data alignment in reserveAllocationSpace";
112  return;
113  }
114  if (!isPowerOf2_32(RWDataAlign) || RWDataAlign > EPC.getPageSize()) {
115  ErrMsg = "Invalid rw-data alignment in reserveAllocationSpace";
116  return;
117  }
118  }
119 
120  uint64_t TotalSize = 0;
121  TotalSize += alignTo(CodeSize, EPC.getPageSize());
122  TotalSize += alignTo(RODataSize, EPC.getPageSize());
123  TotalSize += alignTo(RWDataSize, EPC.getPageSize());
124 
125  LLVM_DEBUG({
126  dbgs() << "Allocator " << (void *)this << " reserving "
127  << formatv("{0:x}", TotalSize) << " bytes.\n";
128  });
129 
130  Expected<ExecutorAddr> TargetAllocAddr((ExecutorAddr()));
131  if (auto Err = EPC.callSPSWrapper<
133  SAs.Reserve, TargetAllocAddr, SAs.Instance, TotalSize)) {
134  std::lock_guard<std::mutex> Lock(M);
135  ErrMsg = toString(std::move(Err));
136  return;
137  }
138  if (!TargetAllocAddr) {
139  std::lock_guard<std::mutex> Lock(M);
140  ErrMsg = toString(TargetAllocAddr.takeError());
141  return;
142  }
143 
144  std::lock_guard<std::mutex> Lock(M);
145  Unmapped.push_back(SectionAllocGroup());
146  Unmapped.back().RemoteCode = {
147  *TargetAllocAddr, ExecutorAddrDiff(alignTo(CodeSize, EPC.getPageSize()))};
148  Unmapped.back().RemoteROData = {
149  Unmapped.back().RemoteCode.End,
150  ExecutorAddrDiff(alignTo(RODataSize, EPC.getPageSize()))};
151  Unmapped.back().RemoteRWData = {
152  Unmapped.back().RemoteROData.End,
153  ExecutorAddrDiff(alignTo(RWDataSize, EPC.getPageSize()))};
154 }
155 
157  return true;
158 }
159 
161  uint64_t LoadAddr,
162  size_t Size) {
163  LLVM_DEBUG({
164  dbgs() << "Allocator " << (void *)this << " added unfinalized eh-frame "
165  << formatv("[ {0:x} {1:x} ]", LoadAddr, LoadAddr + Size) << "\n";
166  });
167  std::lock_guard<std::mutex> Lock(M);
168  // Bail out early if there's already an error.
169  if (!ErrMsg.empty())
170  return;
171 
172  ExecutorAddr LA(LoadAddr);
173  for (auto &SecAllocGroup : llvm::reverse(Unfinalized)) {
174  if (SecAllocGroup.RemoteCode.contains(LA) ||
175  SecAllocGroup.RemoteROData.contains(LA) ||
176  SecAllocGroup.RemoteRWData.contains(LA)) {
177  SecAllocGroup.UnfinalizedEHFrames.push_back({LA, Size});
178  return;
179  }
180  }
181  ErrMsg = "eh-frame does not lie inside unfinalized alloc";
182 }
183 
185  // This is a no-op for us: We've registered a deallocation action for it.
186 }
187 
189  RuntimeDyld &Dyld, const object::ObjectFile &Obj) {
190  std::lock_guard<std::mutex> Lock(M);
191  LLVM_DEBUG(dbgs() << "Allocator " << (void *)this << " applied mappings:\n");
192  for (auto &ObjAllocs : Unmapped) {
193  mapAllocsToRemoteAddrs(Dyld, ObjAllocs.CodeAllocs,
194  ObjAllocs.RemoteCode.Start);
195  mapAllocsToRemoteAddrs(Dyld, ObjAllocs.RODataAllocs,
196  ObjAllocs.RemoteROData.Start);
197  mapAllocsToRemoteAddrs(Dyld, ObjAllocs.RWDataAllocs,
198  ObjAllocs.RemoteRWData.Start);
199  Unfinalized.push_back(std::move(ObjAllocs));
200  }
201  Unmapped.clear();
202 }
203 
205  LLVM_DEBUG(dbgs() << "Allocator " << (void *)this << " finalizing:\n");
206 
207  // If there's an error then bail out here.
208  std::vector<SectionAllocGroup> SecAllocGroups;
209  {
210  std::lock_guard<std::mutex> Lock(M);
211  if (ErrMsg && !this->ErrMsg.empty()) {
212  *ErrMsg = std::move(this->ErrMsg);
213  return true;
214  }
215  std::swap(SecAllocGroups, Unfinalized);
216  }
217 
218  // Loop over unfinalized objects to make finalization requests.
219  for (auto &SecAllocGroup : SecAllocGroups) {
220 
221  MemProt SegMemProts[3] = {MemProt::Read | MemProt::Exec, MemProt::Read,
223 
224  ExecutorAddrRange *RemoteAddrs[3] = {&SecAllocGroup.RemoteCode,
225  &SecAllocGroup.RemoteROData,
226  &SecAllocGroup.RemoteRWData};
227 
228  std::vector<SectionAlloc> *SegSections[3] = {&SecAllocGroup.CodeAllocs,
229  &SecAllocGroup.RODataAllocs,
230  &SecAllocGroup.RWDataAllocs};
231 
233  std::unique_ptr<char[]> AggregateContents[3];
234 
235  for (unsigned I = 0; I != 3; ++I) {
236  FR.Segments.push_back({});
237  auto &Seg = FR.Segments.back();
238  Seg.AG = SegMemProts[I];
239  Seg.Addr = RemoteAddrs[I]->Start;
240  for (auto &SecAlloc : *SegSections[I]) {
241  Seg.Size = alignTo(Seg.Size, SecAlloc.Align);
242  Seg.Size += SecAlloc.Size;
243  }
244  AggregateContents[I] = std::make_unique<char[]>(Seg.Size);
245  size_t SecOffset = 0;
246  for (auto &SecAlloc : *SegSections[I]) {
247  SecOffset = alignTo(SecOffset, SecAlloc.Align);
248  memcpy(&AggregateContents[I][SecOffset],
249  reinterpret_cast<const char *>(
250  alignAddr(SecAlloc.Contents.get(), Align(SecAlloc.Align))),
251  SecAlloc.Size);
252  SecOffset += SecAlloc.Size;
253  // FIXME: Can we reset SecAlloc.Content here, now that it's copied into
254  // the aggregated content?
255  }
256  Seg.Content = {AggregateContents[I].get(), SecOffset};
257  }
258 
259  for (auto &Frame : SecAllocGroup.UnfinalizedEHFrames)
260  FR.Actions.push_back(
261  {cantFail(
262  WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddrRange>>(
263  SAs.RegisterEHFrame, Frame)),
264  cantFail(
265  WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddrRange>>(
266  SAs.DeregisterEHFrame, Frame))});
267 
268  // We'll also need to make an extra allocation for the eh-frame wrapper call
269  // arguments.
270  Error FinalizeErr = Error::success();
271  if (auto Err = EPC.callSPSWrapper<
273  SAs.Finalize, FinalizeErr, SAs.Instance, std::move(FR))) {
274  std::lock_guard<std::mutex> Lock(M);
275  this->ErrMsg = toString(std::move(Err));
276  dbgs() << "Serialization error: " << this->ErrMsg << "\n";
277  if (ErrMsg)
278  *ErrMsg = this->ErrMsg;
279  return true;
280  }
281  if (FinalizeErr) {
282  std::lock_guard<std::mutex> Lock(M);
283  this->ErrMsg = toString(std::move(FinalizeErr));
284  dbgs() << "Finalization error: " << this->ErrMsg << "\n";
285  if (ErrMsg)
286  *ErrMsg = this->ErrMsg;
287  return true;
288  }
289  }
290 
291  return false;
292 }
293 
294 void EPCGenericRTDyldMemoryManager::mapAllocsToRemoteAddrs(
295  RuntimeDyld &Dyld, std::vector<SectionAlloc> &Allocs,
296  ExecutorAddr NextAddr) {
297  for (auto &Alloc : Allocs) {
298  NextAddr.setValue(alignTo(NextAddr.getValue(), Alloc.Align));
299  LLVM_DEBUG({
300  dbgs() << " " << static_cast<void *>(Alloc.Contents.get()) << " -> "
301  << format("0x%016" PRIx64, NextAddr.getValue()) << "\n";
302  });
303  Dyld.mapSectionAddress(reinterpret_cast<const void *>(alignAddr(
304  Alloc.Contents.get(), Align(Alloc.Align))),
305  NextAddr.getValue());
306  Alloc.RemoteAddr = NextAddr;
307  // Only advance NextAddr if it was non-null to begin with,
308  // otherwise leave it as null.
309  if (NextAddr)
310  NextAddr += ExecutorAddrDiff(Alloc.Size);
311  }
312 }
313 
314 } // end namespace orc
315 } // end namespace llvm
llvm::orc::ExecutorAddr
Represents an address in the executor process.
Definition: ExecutorAddress.h:31
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::orc::EPCGenericRTDyldMemoryManager::deregisterEHFrames
void deregisterEHFrames() override
Definition: EPCGenericRTDyldMemoryManager.cpp:184
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::orc::EPCGenericRTDyldMemoryManager::SymbolAddrs::DeregisterEHFrame
ExecutorAddr DeregisterEHFrame
Definition: EPCGenericRTDyldMemoryManager.h:35
llvm::orc::ExecutorProcessControl::getBootstrapSymbols
Error getBootstrapSymbols(ArrayRef< std::pair< ExecutorAddr &, StringRef >> Pairs) const
For each (ExecutorAddr&, StringRef) pair, looks up the string in the bootstrap symbols map and writes...
Definition: ExecutorProcessControl.h:229
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
llvm::orc::EPCGenericRTDyldMemoryManager::reserveAllocationSpace
void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign, uintptr_t RODataSize, uint32_t RODataAlign, uintptr_t RWDataSize, uint32_t RWDataAlign) override
Inform the memory manager about the total amount of memory required to allocate all sections to be lo...
Definition: EPCGenericRTDyldMemoryManager.cpp:96
llvm::orc::EPCGenericRTDyldMemoryManager::SymbolAddrs::Finalize
ExecutorAddr Finalize
Definition: EPCGenericRTDyldMemoryManager.h:32
llvm::alignAddr
uintptr_t alignAddr(const void *Addr, Align Alignment)
Aligns Addr to Alignment bytes, rounding up.
Definition: Alignment.h:188
llvm::orc::ExecutorAddr::getValue
uint64_t getValue() const
Definition: ExecutorAddress.h:105
llvm::orc::EPCGenericRTDyldMemoryManager::allocateCodeSection
uint8_t * allocateCodeSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName) override
Allocate a memory block of (at least) the given size suitable for executable code.
Definition: EPCGenericRTDyldMemoryManager.cpp:62
llvm::orc::shared
Definition: ELFNixPlatform.h:245
llvm::orc::ExecutorProcessControl
ExecutorProcessControl supports interaction with a JIT target process.
Definition: ExecutorProcessControl.h:38
llvm::orc::rt::SPSSimpleExecutorMemoryManagerFinalizeSignature
shared::SPSError(shared::SPSExecutorAddr, shared::SPSFinalizeRequest) SPSSimpleExecutorMemoryManagerFinalizeSignature
Definition: OrcRTBridge.h:66
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:891
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
llvm::orc::EPCGenericRTDyldMemoryManager::notifyObjectLoaded
void notifyObjectLoaded(RuntimeDyld &Dyld, const object::ObjectFile &Obj) override
This method is called after an object has been loaded into memory but before relocations are applied ...
Definition: EPCGenericRTDyldMemoryManager.cpp:188
llvm::isPowerOf2_32
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
Definition: MathExtras.h:458
llvm::orc::tpctypes::FinalizeRequest::Actions
shared::AllocActions Actions
Definition: TargetProcessControlTypes.h:42
llvm::objcopy::SecAlloc
@ SecAlloc
Definition: CommonConfig.h:59
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
llvm::orc::EPCGenericRTDyldMemoryManager::CreateWithDefaultBootstrapSymbols
static Expected< std::unique_ptr< EPCGenericRTDyldMemoryManager > > CreateWithDefaultBootstrapSymbols(ExecutorProcessControl &EPC)
Create an EPCGenericRTDyldMemoryManager using the given EPC, looking up the default symbol names in t...
Definition: EPCGenericRTDyldMemoryManager.cpp:23
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::formatv
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
Definition: FormatVariadic.h:251
llvm::orc::tpctypes::FinalizeRequest
Definition: TargetProcessControlTypes.h:40
llvm::orc::EPCGenericRTDyldMemoryManager::SymbolAddrs
Symbol addresses for memory access.
Definition: EPCGenericRTDyldMemoryManager.h:29
llvm::orc::MemProt::Read
@ Read
llvm::orc::rt::SPSSimpleExecutorMemoryManagerReserveSignature
shared::SPSExpected< shared::SPSExecutorAddr >(shared::SPSExecutorAddr, uint64_t) SPSSimpleExecutorMemoryManagerReserveSignature
Definition: OrcRTBridge.h:64
llvm::orc::EPCGenericRTDyldMemoryManager::allocateDataSection
uint8_t * allocateDataSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName, bool IsReadOnly) override
Allocate a memory block of (at least) the given size suitable for data.
Definition: EPCGenericRTDyldMemoryManager.cpp:77
EPCGenericMemoryAccess.h
llvm::orc::EPCGenericRTDyldMemoryManager::registerEHFrames
void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override
Register the EH frames with the runtime so that c++ exceptions work.
Definition: EPCGenericRTDyldMemoryManager.cpp:160
llvm::orc::ExecutorAddrDiff
uint64_t ExecutorAddrDiff
Definition: ExecutorAddress.h:28
llvm::orc::ExecutorAddrRange
Represents an address range in the exceutor process.
Definition: ExecutorAddress.h:191
llvm::orc::ExecutorAddr::setValue
void setValue(uint64_t Addr)
Definition: ExecutorAddress.h:106
llvm::orc::EPCGenericRTDyldMemoryManager::needsToReserveAllocationSpace
bool needsToReserveAllocationSpace() override
Override to return true to enable the reserveAllocationSpace callback.
Definition: EPCGenericRTDyldMemoryManager.cpp:156
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::orc::EPCGenericRTDyldMemoryManager::SymbolAddrs::Reserve
ExecutorAddr Reserve
Definition: EPCGenericRTDyldMemoryManager.h:31
FormatVariadic.h
llvm::orc::MemProt
MemProt
Describes Read/Write/Exec permissions for memory.
Definition: MemoryFlags.h:27
uint64_t
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:79
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::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:1836
std::swap
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:853
memcpy
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint cast struct s *agg result to sbyte *< sbyte * > sbyte uint cast struct s *memtmp to sbyte *< sbyte * > sbyte uint ret void llc ends up issuing two memcpy or custom lower memcpy(of small size) to be ldmia/stmia. I think option 2 is better but the current register allocator cannot allocate a chunk of registers at a time. A feasible temporary solution is to use specific physical registers at the lowering time for small(<
llvm::orc::tpctypes::FinalizeRequest::Segments
std::vector< SegFinalizeRequest > Segments
Definition: TargetProcessControlTypes.h:41
llvm::orc::ExecutorAddrRange::Start
ExecutorAddr Start
Definition: ExecutorAddress.h:214
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm::object::ObjectFile
This class is the base class for all object file types.
Definition: ObjectFile.h:228
llvm::cantFail
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:744
uint32_t
llvm::orc::EPCGenericRTDyldMemoryManager::EPCGenericRTDyldMemoryManager
EPCGenericRTDyldMemoryManager(ExecutorProcessControl &EPC, SymbolAddrs SAs)
Create an EPCGenericRTDyldMemoryManager using the given EPC and symbol addrs.
Definition: EPCGenericRTDyldMemoryManager.cpp:38
llvm::orc::ExecutorProcessControl::callSPSWrapper
Error callSPSWrapper(ExecutorAddr WrapperFnAddr, WrapperCallArgTs &&...WrapperCallArgs)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
Definition: ExecutorProcessControl.h:351
llvm::format
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
llvm::RISCVISD::LA
@ LA
Definition: RISCVISelLowering.h:329
llvm::logAllUnhandledErrors
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})
Log all errors (if any) in E to OS.
Definition: Error.cpp:63
llvm::orc::EPCGenericRTDyldMemoryManager::SymbolAddrs::Instance
ExecutorAddr Instance
Definition: EPCGenericRTDyldMemoryManager.h:30
Alignment.h
std
Definition: BitVector.h:851
llvm::toString
const char * toString(DWARFSectionKind Kind)
Definition: DWARFUnitIndex.h:67
llvm::SectionName
Definition: DWARFSection.h:21
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::orc::ExecutorProcessControl::getPageSize
unsigned getPageSize() const
Get the page size for the target process.
Definition: ExecutorProcessControl.h:204
llvm::orc::EPCGenericRTDyldMemoryManager::SymbolAddrs::RegisterEHFrame
ExecutorAddr RegisterEHFrame
Definition: EPCGenericRTDyldMemoryManager.h:34
EPCGenericRTDyldMemoryManager.h
llvm::reverse
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:485
llvm::RuntimeDyld
Definition: RuntimeDyld.h:58
llvm::orc::EPCGenericRTDyldMemoryManager::~EPCGenericRTDyldMemoryManager
~EPCGenericRTDyldMemoryManager()
Definition: EPCGenericRTDyldMemoryManager.cpp:44
llvm::orc::MemProt::Exec
@ Exec
llvm::orc::EPCGenericRTDyldMemoryManager::finalizeMemory
bool finalizeMemory(std::string *ErrMsg=nullptr) override
This method is called when object loading is complete and section page permissions can be applied.
Definition: EPCGenericRTDyldMemoryManager.cpp:204
OrcRTBridge.h
llvm::RuntimeDyld::mapSectionAddress
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
Map a section to its target address space value.
Definition: RuntimeDyld.cpp:1418
llvm::orc::rt::SPSSimpleExecutorMemoryManagerDeallocateSignature
shared::SPSError(shared::SPSExecutorAddr, shared::SPSSequence< shared::SPSExecutorAddr >) SPSSimpleExecutorMemoryManagerDeallocateSignature
Definition: OrcRTBridge.h:68
llvm::orc::shared::SPSArgList
A utility class for serializing to a blob from a variadic list.
Definition: SimplePackedSerialization.h:108
llvm::orc::MemProt::Write
@ Write