llvm-6502/tools/lli/RemoteTargetExternal.cpp
Matt Arsenault c5019a3d87 Fix gcc warnings.
Unused variable and unused typedef in release build.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@196947 91177308-0d34-0410-b5e6-96231b3b80d8
2013-12-10 18:55:37 +00:00

169 lines
4.7 KiB
C++

//===---- RemoteTargetExternal.cpp - LLVM out-of-process JIT execution ----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Implementation of the RemoteTargetExternal class which executes JITed code
// in a separate process from where it was built.
//
//===----------------------------------------------------------------------===//
#include "llvm/Config/config.h"
#include "RemoteTarget.h"
#include "RemoteTargetExternal.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Memory.h"
#include "llvm/Support/Program.h"
#include "llvm/Support/raw_ostream.h"
#include <string>
using namespace llvm;
bool RemoteTargetExternal::allocateSpace(size_t Size, unsigned Alignment,
uint64_t &Address) {
SendAllocateSpace(Alignment, Size);
Receive(LLI_AllocationResult, Address);
return false;
}
bool RemoteTargetExternal::loadData(uint64_t Address, const void *Data, size_t Size) {
SendLoadSection(Address, Data, (uint32_t)Size, false);
Receive(LLI_LoadComplete);
return false;
}
bool RemoteTargetExternal::loadCode(uint64_t Address, const void *Data, size_t Size) {
SendLoadSection(Address, Data, (uint32_t)Size, true);
Receive(LLI_LoadComplete);
return false;
}
bool RemoteTargetExternal::executeCode(uint64_t Address, int &RetVal) {
SendExecute(Address);
Receive(LLI_ExecutionResult, RetVal);
return false;
}
void RemoteTargetExternal::stop() {
SendTerminate();
Wait();
}
void RemoteTargetExternal::SendAllocateSpace(uint32_t Alignment, uint32_t Size) {
int rc;
(void)rc;
uint32_t MsgType = (uint32_t)LLI_AllocateSpace;
rc = WriteBytes(&MsgType, 4);
assert(rc == 4 && "Error writing message type.");
uint32_t DataSize = 8;
rc = WriteBytes(&DataSize, 4);
assert(rc == 4 && "Error writing data size.");
rc = WriteBytes(&Alignment, 4);
assert(rc == 4 && "Error writing alignment data.");
rc = WriteBytes(&Size, 4);
assert(rc == 4 && "Error writing size data.");
}
void RemoteTargetExternal::SendLoadSection(uint64_t Addr,
const void *Data,
uint32_t Size,
bool IsCode) {
int rc;
(void)rc;
uint32_t MsgType = IsCode ? LLI_LoadCodeSection : LLI_LoadDataSection;
rc = WriteBytes(&MsgType, 4);
assert(rc == 4 && "Error writing message type.");
uint32_t DataSize = Size + 8;
rc = WriteBytes(&DataSize, 4);
assert(rc == 4 && "Error writing data size.");
rc = WriteBytes(&Addr, 8);
assert(rc == 8 && "Error writing data.");
rc = WriteBytes(Data, Size);
assert(rc == (int)Size && "Error writing data.");
}
void RemoteTargetExternal::SendExecute(uint64_t Addr) {
int rc;
(void)rc;
uint32_t MsgType = (uint32_t)LLI_Execute;
rc = WriteBytes(&MsgType, 4);
assert(rc == 4 && "Error writing message type.");
uint32_t DataSize = 8;
rc = WriteBytes(&DataSize, 4);
assert(rc == 4 && "Error writing data size.");
rc = WriteBytes(&Addr, 8);
assert(rc == 8 && "Error writing data.");
}
void RemoteTargetExternal::SendTerminate() {
int rc;
(void)rc;
uint32_t MsgType = (uint32_t)LLI_Terminate;
rc = WriteBytes(&MsgType, 4);
assert(rc == 4 && "Error writing message type.");
// No data or data size is sent with Terminate
}
void RemoteTargetExternal::Receive(LLIMessageType ExpectedMsgType) {
int rc;
(void)rc;
uint32_t MsgType;
rc = ReadBytes(&MsgType, 4);
assert(rc == 4 && "Error reading message type.");
assert(MsgType == (uint32_t)ExpectedMsgType && "Error: received unexpected message type.");
uint32_t DataSize;
rc = ReadBytes(&DataSize, 4);
assert(rc == 4 && "Error reading data size.");
assert(DataSize == 0 && "Error: unexpected data size.");
}
void RemoteTargetExternal::Receive(LLIMessageType ExpectedMsgType, int &Data) {
uint64_t Temp;
Receive(ExpectedMsgType, Temp);
Data = (int)(int64_t)Temp;
}
void RemoteTargetExternal::Receive(LLIMessageType ExpectedMsgType, uint64_t &Data) {
int rc;
(void)rc;
uint32_t MsgType;
rc = ReadBytes(&MsgType, 4);
assert(rc == 4 && "Error reading message type.");
assert(MsgType == (uint32_t)ExpectedMsgType && "Error: received unexpected message type.");
uint32_t DataSize;
rc = ReadBytes(&DataSize, 4);
assert(rc == 4 && "Error reading data size.");
assert(DataSize == 8 && "Error: unexpected data size.");
rc = ReadBytes(&Data, 8);
assert(DataSize == 8 && "Error: unexpected data.");
}
#ifdef LLVM_ON_UNIX
#include "Unix/RemoteTargetExternal.inc"
#endif
#ifdef LLVM_ON_WIN32
#include "Windows/RemoteTargetExternal.inc"
#endif