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

1

2

3

4

5

6

7

8

10

15

16#define DEBUG_TYPE "orc"

17

19

20namespace llvm {

21namespace orc {

23

24template <typename WriteT, typename SPSWriteT>

28 ArgData, ArgSize,

29 [](std::vector Ws) {

30 for (auto &W : Ws)

31 *W.Addr.template toPtr<decltype(W.Value) *>() = W.Value;

32 })

34}

35

39 handle(ArgData, ArgSize,

40 [](std::vectortpctypes::PointerWrite Ws) {

41 for (auto &W : Ws)

42 *W.Addr.template toPtr<void **>() =

43 W.Value.template toPtr<void *>();

44 })

46}

47

51 ArgData, ArgSize,

52 [](std::vectortpctypes::BufferWrite Ws) {

53 for (auto &W : Ws)

54 memcpy(W.Addr.template toPtr<char *>(), W.Buffer.data(),

55 W.Buffer.size());

56 })

58}

59

60template

65 [](std::vector Rs) {

66 std::vector Result;

67 Result.reserve(Rs.size());

68 for (auto &R : Rs)

70 *R.toPtr<ReadT *>());

72 })

74}

75

80 ArgData, ArgSize,

81 [](std::vector Rs) {

82 std::vector Result;

83 Result.reserve(Rs.size());

84 for (auto &R : Rs)

87 })

89}

90

93 using SPSSig =

96 ArgData, ArgSize,

97 [](std::vector Rs) {

98 std::vector<std::vector<uint8_t>> Result;

99 Result.reserve(Rs.size());

100 for (auto &R : Rs) {

101 Result.push_back({});

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

103 memcpy(reinterpret_cast<char *>(Result.back().data()),

104 R.Start.toPtr<char *>(), R.size());

105 }

107 })

109}

110

115 [](std::vector Rs) {

116 std::vectorstd::string Result;

117 Result.reserve(Rs.size());

118 for (auto &R : Rs)

120 R.toPtr<char *>());

122 })

124}

125

129 ArgData, ArgSize,

131 std::vectorstd::string Args) -> int64_t {

132 return runAsMain(MainAddr.toPtr<int (*)(int, char *[])>(), Args);

133 })

135}

136

140 ArgData, ArgSize,

143 })

145}

146

150 ArgData, ArgSize,

151 [](ExecutorAddr MainAddr, int32_t Arg) -> int32_t {

153 Arg);

154 })

156}

157

195

196}

197}

198}

StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...

Represents an address in the executor process.

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

Create an ExecutorAddr from the given pointer.

std::enable_if_t< std::is_pointer< T >::value, T > toPtr(WrapFn &&Wrap=WrapFn()) const

Cast this ExecutorAddr to a pointer of the given type.

static llvm::orc::shared::CWrapperFunctionResult writeUIntsWrapper(const char *ArgData, size_t ArgSize)

Definition OrcRTBootstrap.cpp:26

static llvm::orc::shared::CWrapperFunctionResult readBuffersWrapper(const char *ArgData, size_t ArgSize)

Definition OrcRTBootstrap.cpp:92

static llvm::orc::shared::CWrapperFunctionResult runAsVoidFunctionWrapper(const char *ArgData, size_t ArgSize)

Definition OrcRTBootstrap.cpp:138

static llvm::orc::shared::CWrapperFunctionResult readStringsWrapper(const char *ArgData, size_t ArgSize)

Definition OrcRTBootstrap.cpp:112

void addTo(StringMap< ExecutorAddr > &M)

Definition OrcRTBootstrap.cpp:158

static llvm::orc::shared::CWrapperFunctionResult writePointersWrapper(const char *ArgData, size_t ArgSize)

Definition OrcRTBootstrap.cpp:37

static llvm::orc::shared::CWrapperFunctionResult runAsMainWrapper(const char *ArgData, size_t ArgSize)

Definition OrcRTBootstrap.cpp:127

static llvm::orc::shared::CWrapperFunctionResult readUIntsWrapper(const char *ArgData, size_t ArgSize)

Definition OrcRTBootstrap.cpp:62

static llvm::orc::shared::CWrapperFunctionResult writeBuffersWrapper(const char *ArgData, size_t ArgSize)

Definition OrcRTBootstrap.cpp:49

static llvm::orc::shared::CWrapperFunctionResult readPointersWrapper(const char *ArgData, size_t ArgSize)

Definition OrcRTBootstrap.cpp:77

static llvm::orc::shared::CWrapperFunctionResult runAsIntFunctionWrapper(const char *ArgData, size_t ArgSize)

Definition OrcRTBootstrap.cpp:148

LLVM_ABI const char * MemoryReadUInt64sWrapperName

LLVM_ABI const char * MemoryWriteUInt16sWrapperName

LLVM_ABI const char * MemoryReadStringsWrapperName

LLVM_ABI const char * MemoryReadUInt16sWrapperName

LLVM_ABI const char * RunAsIntFunctionWrapperName

LLVM_ABI const char * MemoryReadPointersWrapperName

LLVM_ABI const char * MemoryReadUInt32sWrapperName

LLVM_ABI const char * MemoryWriteUInt64sWrapperName

LLVM_ABI const char * MemoryWriteUInt8sWrapperName

LLVM_ABI const char * MemoryWritePointersWrapperName

LLVM_ABI const char * MemoryWriteUInt32sWrapperName

LLVM_ABI const char * RunAsVoidFunctionWrapperName

LLVM_ABI const char * MemoryWriteBuffersWrapperName

LLVM_ABI const char * MemoryReadBuffersWrapperName

LLVM_ABI const char * RunAsMainWrapperName

LLVM_ABI const char * MemoryReadUInt8sWrapperName

UIntWrite< uint64_t > UInt64Write

Describes a write to a uint64_t.

UIntWrite< uint8_t > UInt8Write

Describes a write to a uint8_t.

UIntWrite< uint32_t > UInt32Write

Describes a write to a uint32_t.

UIntWrite< uint16_t > UInt16Write

Describes a write to a uint16_t.

LLVM_ABI int runAsVoidFunction(int(*Func)(void))

LLVM_ABI int runAsIntFunction(int(*Func)(int), int Arg)

LLVM_ABI int runAsMain(int(*Main)(int, char *[]), ArrayRef< std::string > Args, std::optional< StringRef > ProgramName=std::nullopt)

Run a main function, returning the result.

This is an optimization pass for GlobalISel generic memory operations.