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

1

2

3

4

5

6

7

8

10

11#define DEBUG_TYPE "orc"

12

14

16

19 for (auto &W : Ws)

20 *W.Addr.toPtr<uint8_t *>() = W.Value;

22}

23

26 for (auto &W : Ws)

27 *W.Addr.toPtr<uint16_t *>() = W.Value;

29}

30

33 for (auto &W : Ws)

34 *W.Addr.toPtr<uint32_t *>() = W.Value;

36}

37

40 for (auto &W : Ws)

41 *W.Addr.toPtr<uint64_t *>() = W.Value;

43}

44

47 if (IsArch64Bit) {

48 for (auto &W : Ws)

49 *W.Addr.toPtr<uint64_t *>() = W.Value.getValue();

50 } else {

51 for (auto &W : Ws)

52 *W.Addr.toPtr<uint32_t *>() = static_cast<uint32_t>(W.Value.getValue());

53 }

54

56}

57

60 for (auto &W : Ws)

61 memcpy(W.Addr.toPtr<char *>(), W.Buffer.data(), W.Buffer.size());

63}

64

69 for (auto &R : Rs)

71 OnComplete(std::move(Result));

72}

73

78 for (auto &R : Rs)

80 OnComplete(std::move(Result));

81}

82

87 for (auto &R : Rs)

89 OnComplete(std::move(Result));

90}

91

96 for (auto &R : Rs)

98 OnComplete(std::move(Result));

99}

100

105 for (auto &R : Rs)

107 OnComplete(std::move(Result));

108}

109

114 for (auto &R : Rs) {

115 Result.push_back({});

116 Result.back().resize(R.size());

117 memcpy(Result.back().data(), R.Start.toPtr<char *>(), R.size());

118 }

119 OnComplete(std::move(Result));

120}

121

126 for (auto &R : Rs) {

127 Result.push_back({});

128 for (auto *P = R.toPtr<char *>(); *P; ++P)

129 Result.back().push_back(*P);

130 }

131 OnComplete(std::move(Result));

132}

133

134}

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

size_t size() const

size - Get the array size.

static ErrorSuccess success()

Create a success value.

static ExecutorAddr fromPtr(T *Ptr, UnwrapFn &&Unwrap=UnwrapFn())

Create an ExecutorAddr from the given pointer.

void writePointersAsync(ArrayRef< tpctypes::PointerWrite > Ws, WriteResultFn OnWriteComplete) override

Definition InProcessMemoryAccess.cpp:45

void readStringsAsync(ArrayRef< ExecutorAddr > Rs, OnReadStringsCompleteFn OnComplete) override

Definition InProcessMemoryAccess.cpp:122

void writeUInt32sAsync(ArrayRef< tpctypes::UInt32Write > Ws, WriteResultFn OnWriteComplete) override

Definition InProcessMemoryAccess.cpp:31

void writeUInt8sAsync(ArrayRef< tpctypes::UInt8Write > Ws, WriteResultFn OnWriteComplete) override

Definition InProcessMemoryAccess.cpp:17

void readUInt64sAsync(ArrayRef< ExecutorAddr > Rs, OnReadUIntsCompleteFn< uint64_t > OnComplete) override

Definition InProcessMemoryAccess.cpp:92

void writeUInt16sAsync(ArrayRef< tpctypes::UInt16Write > Ws, WriteResultFn OnWriteComplete) override

Definition InProcessMemoryAccess.cpp:24

void readUInt16sAsync(ArrayRef< ExecutorAddr > Rs, OnReadUIntsCompleteFn< uint16_t > OnComplete) override

Definition InProcessMemoryAccess.cpp:74

void readUInt8sAsync(ArrayRef< ExecutorAddr > Rs, OnReadUIntsCompleteFn< uint8_t > OnComplete) override

Definition InProcessMemoryAccess.cpp:65

void readPointersAsync(ArrayRef< ExecutorAddr > Rs, OnReadPointersCompleteFn OnComplete) override

Definition InProcessMemoryAccess.cpp:101

void readUInt32sAsync(ArrayRef< ExecutorAddr > Rs, OnReadUIntsCompleteFn< uint32_t > OnComplete) override

Definition InProcessMemoryAccess.cpp:83

void writeBuffersAsync(ArrayRef< tpctypes::BufferWrite > Ws, WriteResultFn OnWriteComplete) override

Definition InProcessMemoryAccess.cpp:58

void readBuffersAsync(ArrayRef< ExecutorAddrRange > Rs, OnReadBuffersCompleteFn OnComplete) override

Definition InProcessMemoryAccess.cpp:110

void writeUInt64sAsync(ArrayRef< tpctypes::UInt64Write > Ws, WriteResultFn OnWriteComplete) override

Definition InProcessMemoryAccess.cpp:38

unique_function< void(Expected< ReadStringsResult >)> OnReadStringsCompleteFn

unique_function< void(Expected< ReadBuffersResult >)> OnReadBuffersCompleteFn

unique_function< void(Expected< ReadPointersResult >)> OnReadPointersCompleteFn

std::vector< std::vector< uint8_t > > ReadBuffersResult

unique_function< void(Error)> WriteResultFn

Callback function for asynchronous writes.

std::vector< std::string > ReadStringsResult

unique_function< void(Expected< ReadUIntsResult< T > >)> OnReadUIntsCompleteFn

std::vector< ExecutorAddr > ReadPointersResult

std::vector< T > ReadUIntsResult