LLVM: lib/ExecutionEngine/Orc/SimpleRemoteMemoryMapper.cpp Source File (original) (raw)

1

2

3

4

5

6

7

8

10

13

15

18 : EPC(EPC), SAs(SAs) {}

19

23 SAs.Reserve,

24 [NumBytes, OnReserved = std::move(OnReserved)](

26 if (SerializationErr) {

28 return OnReserved(std::move(SerializationErr));

29 }

30

33 else

34 OnReserved(Result.takeError());

35 },

36 SAs.Instance, static_cast<uint64_t>(NumBytes));

37}

38

41 return G.allocateBuffer(ContentSize).data();

42}

43

46

48

51

54 Seg.ContentSize + Seg.ZeroFillSize,

56

58 SAs.Initialize,

59 [OnInitialized = std::move(OnInitialized)](

61 if (SerializationErr) {

63 return OnInitialized(std::move(SerializationErr));

64 }

65

66 OnInitialized(std::move(Result));

67 },

68 SAs.Instance, std::move(FR));

69}

70

75 SAs.Deinitialize,

76 [OnDeinitialized = std::move(OnDeinitialized)](Error SerializationErr,

78 if (SerializationErr) {

80 return OnDeinitialized(std::move(SerializationErr));

81 }

82

83 OnDeinitialized(std::move(Result));

84 },

85 SAs.Instance, Allocations);

86}

87

91 SAs.Release,

92 [OnReleased = std::move(OnReleased)](Error SerializationErr,

94 if (SerializationErr) {

96 return OnReleased(std::move(SerializationErr));

97 }

98

99 return OnReleased(std::move(Result));

100 },

101 SAs.Instance, Bases);

102}

103

104}

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Lightweight error class with error context and mandatory checking.

Tagged union holding either a T or a Error.

Represents an address in the executor process.

ExecutorProcessControl supports interaction with a JIT target process.

unique_function< void(Error)> OnReleasedFunction

unique_function< void(Expected< ExecutorAddr >)> OnInitializedFunction

unique_function< void(Expected< ExecutorAddrRange >)> OnReservedFunction

unique_function< void(Error)> OnDeinitializedFunction

void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override

Initializes memory within a previously reserved region (applying protections and running any finaliza...

Definition SimpleRemoteMemoryMapper.cpp:44

char * prepare(jitlink::LinkGraph &G, ExecutorAddr Addr, size_t ContentSize) override

Provides working memory The LinkGraph parameter is included to allow implementations to allocate work...

Definition SimpleRemoteMemoryMapper.cpp:39

void deinitialize(ArrayRef< ExecutorAddr > Allocations, OnDeinitializedFunction OnDeInitialized) override

Given a series of keys from previous initialize calls, deinitialize previously initialized memory reg...

Definition SimpleRemoteMemoryMapper.cpp:71

void release(ArrayRef< ExecutorAddr > Reservations, OnReleasedFunction OnRelease) override

Given a sequence of base addresses from previous reserve calls, release the underlying ranges (deinit...

Definition SimpleRemoteMemoryMapper.cpp:88

void reserve(size_t NumBytes, OnReservedFunction OnReserved) override

Reserves memory in the remote process by calling a remote SPS-wrapper-function with signature.

Definition SimpleRemoteMemoryMapper.cpp:20

SimpleRemoteMemoryMapper(ExecutorProcessControl &EPC, SymbolAddrs SAs)

Definition SimpleRemoteMemoryMapper.cpp:16

shared::SPSExpected< shared::SPSExecutorAddr >(shared::SPSExecutorAddr, shared::SPSFinalizeRequest) SPSSimpleRemoteMemoryMapInitializeSignature

shared::SPSError( shared::SPSExecutorAddr, shared::SPSSequence< shared::SPSExecutorAddr >) SPSSimpleRemoteMemoryMapReleaseSignature

shared::SPSExpected< shared::SPSExecutorAddr >(shared::SPSExecutorAddr, uint64_t) SPSSimpleRemoteMemoryMapReserveSignature

shared::SPSError( shared::SPSExecutorAddr, shared::SPSSequence< shared::SPSExecutorAddr >) SPSSimpleRemoteMemoryMapDeinitializeSignature

void cantFail(Error Err, const char *Msg=nullptr)

Report a fatal error if Err is a failure value.

void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)

Implement std::swap in terms of BitVector swap.

Represents an address range in the exceutor process.

Represents a single allocation containing multiple segments and initialization and deinitialization a...

std::vector< SegInfo > Segments

shared::AllocActions Actions

std::vector< SegFinalizeRequest > Segments

shared::AllocActions Actions