1 #include "llvm/Config/config.h" 2 #include "../RPCChannel.h" 3 #include "../RemoteTarget.h" 4 #include "../RemoteTargetMessage.h" 5 #include "llvm/Support/Memory.h" 6 #include <assert.h> 7 #include <map> 8 #include <stdint.h> 9 #include <string> 10 #include <vector> 11 12 using namespace llvm; 13 14 class LLIChildTarget { 15 public: 16 void initialize(); 17 LLIMessageType waitForIncomingMessage(); 18 void handleMessage(LLIMessageType messageType); 19 RemoteTarget *RT; 20 RPCChannel RPC; 21 22 private: 23 // Incoming message handlers 24 void handleAllocateSpace(); 25 void handleLoadSection(bool IsCode); 26 void handleExecute(); 27 28 // Outgoing message handlers 29 void sendChildActive(); 30 void sendAllocationResult(uint64_t Addr); 31 void sendLoadStatus(uint32_t Status); 32 void sendExecutionComplete(int Result); 33 34 // OS-specific functions 35 void initializeConnection(); 36 int WriteBytes(const void *Data, size_t Size) { 37 return RPC.WriteBytes(Data, Size) ? Size : -1; 38 } 39 int ReadBytes(void *Data, size_t Size) { 40 return RPC.ReadBytes(Data, Size) ? Size : -1; 41 } 42 43 // Communication handles (OS-specific) 44 void *ConnectionData; 45 }; 46 47 int main() { 48 LLIChildTarget ThisChild; 49 ThisChild.RT = new RemoteTarget(); 50 ThisChild.initialize(); 51 LLIMessageType MsgType; 52 do { 53 MsgType = ThisChild.waitForIncomingMessage(); 54 ThisChild.handleMessage(MsgType); 55 } while (MsgType != LLI_Terminate && 56 MsgType != LLI_Error); 57 delete ThisChild.RT; 58 return 0; 59 } 60 61 // Public methods 62 void LLIChildTarget::initialize() { 63 RPC.createClient(); 64 sendChildActive(); 65 } 66 67 LLIMessageType LLIChildTarget::waitForIncomingMessage() { 68 int32_t MsgType = -1; 69 if (ReadBytes(&MsgType, 4) > 0) 70 return (LLIMessageType)MsgType; 71 return LLI_Error; 72 } 73 74 void LLIChildTarget::handleMessage(LLIMessageType messageType) { 75 switch (messageType) { 76 case LLI_AllocateSpace: 77 handleAllocateSpace(); 78 break; 79 case LLI_LoadCodeSection: 80 handleLoadSection(true); 81 break; 82 case LLI_LoadDataSection: 83 handleLoadSection(false); 84 break; 85 case LLI_Execute: 86 handleExecute(); 87 break; 88 case LLI_Terminate: 89 RT->stop(); 90 break; 91 default: 92 // FIXME: Handle error! 93 break; 94 } 95 } 96 97 // Incoming message handlers 98 void LLIChildTarget::handleAllocateSpace() { 99 // Read and verify the message data size. 100 uint32_t DataSize = 0; 101 int rc = ReadBytes(&DataSize, 4); 102 (void)rc; 103 assert(rc == 4); 104 assert(DataSize == 8); 105 106 // Read the message arguments. 107 uint32_t Alignment = 0; 108 uint32_t AllocSize = 0; 109 rc = ReadBytes(&Alignment, 4); 110 assert(rc == 4); 111 rc = ReadBytes(&AllocSize, 4); 112 assert(rc == 4); 113 114 // Allocate the memory. 115 uint64_t Addr; 116 RT->allocateSpace(AllocSize, Alignment, Addr); 117 118 // Send AllocationResult message. 119 sendAllocationResult(Addr); 120 } 121 122 void LLIChildTarget::handleLoadSection(bool IsCode) { 123 // Read the message data size. 124 uint32_t DataSize = 0; 125 int rc = ReadBytes(&DataSize, 4); 126 (void)rc; 127 assert(rc == 4); 128 129 // Read the target load address. 130 uint64_t Addr = 0; 131 rc = ReadBytes(&Addr, 8); 132 assert(rc == 8); 133 size_t BufferSize = DataSize - 8; 134 135 if (!RT->isAllocatedMemory(Addr, BufferSize)) 136 return sendLoadStatus(LLI_Status_NotAllocated); 137 138 // Read section data into previously allocated buffer 139 rc = ReadBytes((void*)Addr, BufferSize); 140 if (rc != (int)(BufferSize)) 141 return sendLoadStatus(LLI_Status_IncompleteMsg); 142 143 // If IsCode, mark memory executable 144 if (IsCode) 145 sys::Memory::InvalidateInstructionCache((void *)Addr, BufferSize); 146 147 // Send MarkLoadComplete message. 148 sendLoadStatus(LLI_Status_Success); 149 } 150 151 void LLIChildTarget::handleExecute() { 152 // Read the message data size. 153 uint32_t DataSize = 0; 154 int rc = ReadBytes(&DataSize, 4); 155 (void)rc; 156 assert(rc == 4); 157 assert(DataSize == 8); 158 159 // Read the target address. 160 uint64_t Addr = 0; 161 rc = ReadBytes(&Addr, 8); 162 assert(rc == 8); 163 164 // Call function 165 int32_t Result = -1; 166 RT->executeCode(Addr, Result); 167 168 // Send ExecutionResult message. 169 sendExecutionComplete(Result); 170 } 171 172 // Outgoing message handlers 173 void LLIChildTarget::sendChildActive() { 174 // Write the message type. 175 uint32_t MsgType = (uint32_t)LLI_ChildActive; 176 int rc = WriteBytes(&MsgType, 4); 177 (void)rc; 178 assert(rc == 4); 179 180 // Write the data size. 181 uint32_t DataSize = 0; 182 rc = WriteBytes(&DataSize, 4); 183 assert(rc == 4); 184 } 185 186 void LLIChildTarget::sendAllocationResult(uint64_t Addr) { 187 // Write the message type. 188 uint32_t MsgType = (uint32_t)LLI_AllocationResult; 189 int rc = WriteBytes(&MsgType, 4); 190 (void)rc; 191 assert(rc == 4); 192 193 // Write the data size. 194 uint32_t DataSize = 8; 195 rc = WriteBytes(&DataSize, 4); 196 assert(rc == 4); 197 198 // Write the allocated address. 199 rc = WriteBytes(&Addr, 8); 200 assert(rc == 8); 201 } 202 203 void LLIChildTarget::sendLoadStatus(uint32_t Status) { 204 // Write the message type. 205 uint32_t MsgType = (uint32_t)LLI_LoadResult; 206 int rc = WriteBytes(&MsgType, 4); 207 (void)rc; 208 assert(rc == 4); 209 210 // Write the data size. 211 uint32_t DataSize = 4; 212 rc = WriteBytes(&DataSize, 4); 213 assert(rc == 4); 214 215 // Write the result. 216 rc = WriteBytes(&Status, 4); 217 assert(rc == 4); 218 } 219 220 void LLIChildTarget::sendExecutionComplete(int Result) { 221 // Write the message type. 222 uint32_t MsgType = (uint32_t)LLI_ExecutionResult; 223 int rc = WriteBytes(&MsgType, 4); 224 (void)rc; 225 assert(rc == 4); 226 227 228 // Write the data size. 229 uint32_t DataSize = 4; 230 rc = WriteBytes(&DataSize, 4); 231 assert(rc == 4); 232 233 // Write the result. 234 rc = WriteBytes(&Result, 4); 235 assert(rc == 4); 236 } 237 238 #ifdef LLVM_ON_UNIX 239 #include "../Unix/RPCChannel.inc" 240 #endif 241 242 #ifdef LLVM_ON_WIN32 243 #include "../Windows/RPCChannel.inc" 244 #endif 245
