From 706f03a35db7029b2dbd2925552eb0d0472dcbb4 Mon Sep 17 00:00:00 2001 From: Jim Grosbach Date: Wed, 5 Sep 2012 16:50:34 +0000 Subject: MCJIT: Add faux remote target execution to lli for the MCJIT. Simulate a remote target address space by allocating a seperate chunk of memory for the target and re-mapping section addresses to that prior to execution. Later we'll want to have a truly remote process, but for now this gets us closer to being able to test the remote target functionality outside LLDB. rdar://12157052 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@163216 91177308-0d34-0410-b5e6-96231b3b80d8 --- tools/lli/RecordingMemoryManager.cpp | 87 +++++++++++++++ tools/lli/RecordingMemoryManager.h | 78 ++++++++++++++ tools/lli/RemoteTarget.cpp | 61 +++++++++++ tools/lli/RemoteTarget.h | 101 ++++++++++++++++++ tools/lli/lli.cpp | 200 ++++++++++++++++++++++++++++++----- 5 files changed, 498 insertions(+), 29 deletions(-) create mode 100644 tools/lli/RecordingMemoryManager.cpp create mode 100644 tools/lli/RecordingMemoryManager.h create mode 100644 tools/lli/RemoteTarget.cpp create mode 100644 tools/lli/RemoteTarget.h (limited to 'tools') diff --git a/tools/lli/RecordingMemoryManager.cpp b/tools/lli/RecordingMemoryManager.cpp new file mode 100644 index 0000000000..9e1cff5527 --- /dev/null +++ b/tools/lli/RecordingMemoryManager.cpp @@ -0,0 +1,87 @@ +//===- RecordingMemoryManager.cpp - Recording memory manager --------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This memory manager allocates local storage and keeps a record of each +// allocation. Iterators are provided for all data and code allocations. +// +//===----------------------------------------------------------------------===// + +#include "RecordingMemoryManager.h" +using namespace llvm; + +uint8_t *RecordingMemoryManager:: +allocateCodeSection(uintptr_t Size, unsigned Alignment, unsigned SectionID) { + // The recording memory manager is just a local copy of the remote target. + // The alignment requirement is just stored here for later use. Regular + // heap storage is sufficient here. + void *Addr = malloc(Size); + assert(Addr && "malloc() failure!"); + sys::MemoryBlock Block(Addr, Size); + AllocatedCodeMem.push_back(Allocation(Block, Alignment)); + return (uint8_t*)Addr; +} + +uint8_t *RecordingMemoryManager:: +allocateDataSection(uintptr_t Size, unsigned Alignment, unsigned SectionID) { + // The recording memory manager is just a local copy of the remote target. + // The alignment requirement is just stored here for later use. Regular + // heap storage is sufficient here. + void *Addr = malloc(Size); + assert(Addr && "malloc() failure!"); + sys::MemoryBlock Block(Addr, Size); + AllocatedDataMem.push_back(Allocation(Block, Alignment)); + return (uint8_t*)Addr; +} +void RecordingMemoryManager::setMemoryWritable() { llvm_unreachable("Unexpected!"); } +void RecordingMemoryManager::setMemoryExecutable() { llvm_unreachable("Unexpected!"); } +void RecordingMemoryManager::setPoisonMemory(bool poison) { llvm_unreachable("Unexpected!"); } +void RecordingMemoryManager::AllocateGOT() { llvm_unreachable("Unexpected!"); } +uint8_t *RecordingMemoryManager::getGOTBase() const { + llvm_unreachable("Unexpected!"); + return 0; +} +uint8_t *RecordingMemoryManager::startFunctionBody(const Function *F, uintptr_t &ActualSize){ + llvm_unreachable("Unexpected!"); + return 0; +} +uint8_t *RecordingMemoryManager::allocateStub(const GlobalValue* F, unsigned StubSize, + unsigned Alignment) { + llvm_unreachable("Unexpected!"); + return 0; +} +void RecordingMemoryManager::endFunctionBody(const Function *F, uint8_t *FunctionStart, + uint8_t *FunctionEnd) { + llvm_unreachable("Unexpected!"); +} +uint8_t *RecordingMemoryManager::allocateSpace(intptr_t Size, unsigned Alignment) { + llvm_unreachable("Unexpected!"); + return 0; +} +uint8_t *RecordingMemoryManager::allocateGlobal(uintptr_t Size, unsigned Alignment) { + llvm_unreachable("Unexpected!"); + return 0; +} +void RecordingMemoryManager::deallocateFunctionBody(void *Body) { + llvm_unreachable("Unexpected!"); +} +uint8_t* RecordingMemoryManager::startExceptionTable(const Function* F, uintptr_t &ActualSize) { + llvm_unreachable("Unexpected!"); + return 0; +} +void RecordingMemoryManager::endExceptionTable(const Function *F, uint8_t *TableStart, + uint8_t *TableEnd, uint8_t* FrameRegister) { + llvm_unreachable("Unexpected!"); +} +void RecordingMemoryManager::deallocateExceptionTable(void *ET) { + llvm_unreachable("Unexpected!"); +} +void *RecordingMemoryManager::getPointerToNamedFunction(const std::string &Name, + bool AbortOnFailure) { + return NULL; +} diff --git a/tools/lli/RecordingMemoryManager.h b/tools/lli/RecordingMemoryManager.h new file mode 100644 index 0000000000..1590235a79 --- /dev/null +++ b/tools/lli/RecordingMemoryManager.h @@ -0,0 +1,78 @@ +//===- RecordingMemoryManager.h - LLI MCJIT recording memory manager ------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This memory manager allocates local storage and keeps a record of each +// allocation. Iterators are provided for all data and code allocations. +// +//===----------------------------------------------------------------------===// + +#ifndef RECORDINGMEMORYMANAGER_H +#define RECORDINGMEMORYMANAGER_H + +#include "llvm/ADT/SmallVector.h" +#include "llvm/ExecutionEngine/JITMemoryManager.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/Memory.h" +#include + +namespace llvm { + +class RecordingMemoryManager : public JITMemoryManager { +public: + typedef std::pair Allocation; + +private: + SmallVector AllocatedDataMem; + SmallVector AllocatedCodeMem; + +public: + RecordingMemoryManager() {} + virtual ~RecordingMemoryManager() {} + + typedef SmallVectorImpl::const_iterator const_data_iterator; + typedef SmallVectorImpl::const_iterator const_code_iterator; + + const_data_iterator data_begin() const { return AllocatedDataMem.begin(); } + const_data_iterator data_end() const { return AllocatedDataMem.end(); } + const_code_iterator code_begin() const { return AllocatedCodeMem.begin(); } + const_code_iterator code_end() const { return AllocatedCodeMem.end(); } + + uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment, + unsigned SectionID); + + uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment, + unsigned SectionID); + + void *getPointerToNamedFunction(const std::string &Name, + bool AbortOnFailure = true); + // The following obsolete JITMemoryManager calls are stubbed out for + // this model. + void setMemoryWritable(); + void setMemoryExecutable(); + void setPoisonMemory(bool poison); + void AllocateGOT(); + uint8_t *getGOTBase() const; + uint8_t *startFunctionBody(const Function *F, uintptr_t &ActualSize); + uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize, + unsigned Alignment); + void endFunctionBody(const Function *F, uint8_t *FunctionStart, + uint8_t *FunctionEnd); + uint8_t *allocateSpace(intptr_t Size, unsigned Alignment); + uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment); + void deallocateFunctionBody(void *Body); + uint8_t* startExceptionTable(const Function* F, uintptr_t &ActualSize); + void endExceptionTable(const Function *F, uint8_t *TableStart, + uint8_t *TableEnd, uint8_t* FrameRegister); + void deallocateExceptionTable(void *ET); + +}; + +} // end namespace llvm + +#endif diff --git a/tools/lli/RemoteTarget.cpp b/tools/lli/RemoteTarget.cpp new file mode 100644 index 0000000000..2ab098b2ef --- /dev/null +++ b/tools/lli/RemoteTarget.cpp @@ -0,0 +1,61 @@ +//===- RemoteTarget.cpp - LLVM Remote 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 RemoteTarget class which executes JITed code in a +// separate address range from where it was built. +// +//===----------------------------------------------------------------------===// + +#include "RemoteTarget.h" +#include +#include +#include +#include +#include +using namespace llvm; + +bool RemoteTarget::allocateSpace(size_t Size, unsigned Alignment, + uint64_t &Address) { + sys::MemoryBlock *Prev = Allocations.size() ? &Allocations.back() : NULL; + sys::MemoryBlock Mem = sys::Memory::AllocateRWX(Size, Prev, &ErrorMsg); + if (Mem.base() == NULL) + return true; + if ((uintptr_t)Mem.base() % Alignment) { + ErrorMsg = "unable to allocate sufficiently aligned memory"; + return true; + } + Address = reinterpret_cast(Mem.base()); + return false; +} + +bool RemoteTarget::loadData(uint64_t Address, const void *Data, size_t Size) { + memcpy ((void*)Address, Data, Size); + sys::MemoryBlock Mem((void*)Address, Size); + sys::Memory::setExecutable(Mem, &ErrorMsg); + return false; +} + +bool RemoteTarget::loadCode(uint64_t Address, const void *Data, size_t Size) { + memcpy ((void*)Address, Data, Size); + return false; +} + +bool RemoteTarget::executeCode(uint64_t Address, int &RetVal) { + int (*fn)(void) = (int(*)(void))Address; + RetVal = fn(); + return false; +} + +void RemoteTarget::create() { +} + +void RemoteTarget::stop() { + for (unsigned i = 0, e = Allocations.size(); i != e; ++i) + sys::Memory::ReleaseRWX(Allocations[i]); +} diff --git a/tools/lli/RemoteTarget.h b/tools/lli/RemoteTarget.h new file mode 100644 index 0000000000..f4dcf42ebe --- /dev/null +++ b/tools/lli/RemoteTarget.h @@ -0,0 +1,101 @@ +//===- RemoteTarget.h - LLVM Remote process JIT execution ----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// Definition of the RemoteTarget class which executes JITed code in a +// separate address range from where it was built. +// +//===----------------------------------------------------------------------===// + +#ifndef REMOTEPROCESS_H +#define REMOTEPROCESS_H + +#include +#include +#include +#include +#include +#include + +namespace llvm { + +class RemoteTarget { + std::string ErrorMsg; + bool IsRunning; + + SmallVector Allocations; + +public: + StringRef getErrorMsg() const { return ErrorMsg; } + + /// Allocate space in the remote target address space. + /// + /// @param Size Amount of space, in bytes, to allocate. + /// @param Alignment Required minimum alignment for allocated space. + /// @param[out] Address Remote address of the allocated memory. + /// + /// @returns False on success. On failure, ErrorMsg is updated with + /// descriptive text of the encountered error. + bool allocateSpace(size_t Size, unsigned Alignment, uint64_t &Address); + + /// Load data into the target address space. + /// + /// @param Address Destination address in the target process. + /// @param Data Source address in the host process. + /// @param Size Number of bytes to copy. + /// + /// @returns False on success. On failure, ErrorMsg is updated with + /// descriptive text of the encountered error. + bool loadData(uint64_t Address, const void *Data, size_t Size); + + /// Load code into the target address space and prepare it for execution. + /// + /// @param Address Destination address in the target process. + /// @param Data Source address in the host process. + /// @param Size Number of bytes to copy. + /// + /// @returns False on success. On failure, ErrorMsg is updated with + /// descriptive text of the encountered error. + bool loadCode(uint64_t Address, const void *Data, size_t Size); + + /// Execute code in the target process. The called function is required + /// to be of signature int "(*)(void)". + /// + /// @param Address Address of the loaded function in the target + /// process. + /// @param[out] RetVal The integer return value of the called function. + /// + /// @returns False on success. On failure, ErrorMsg is updated with + /// descriptive text of the encountered error. + bool executeCode(uint64_t Address, int &RetVal); + + /// Minimum alignment for memory permissions. Used to seperate code and + /// data regions to make sure data doesn't get marked as code or vice + /// versa. + /// + /// @returns Page alignment return value. Default of 4k. + unsigned getPageAlignment() { return 4096; } + + /// Start the remote process. + void create(); + + /// Terminate the remote process. + void stop(); + + RemoteTarget() : ErrorMsg(""), IsRunning(false) {} + ~RemoteTarget() { if (IsRunning) stop(); } + +private: + // Main processing function for the remote target process. Command messages + // are received on file descriptor CmdFD and responses come back on OutFD. + static void doRemoteTargeting(int CmdFD, int OutFD); +}; + +} // end namespace llvm + +#endif diff --git a/tools/lli/lli.cpp b/tools/lli/lli.cpp index 3a3f4c7cdd..4004b6c4d4 100644 --- a/tools/lli/lli.cpp +++ b/tools/lli/lli.cpp @@ -13,6 +13,9 @@ // //===----------------------------------------------------------------------===// +#define DEBUG_TYPE "lli" +#include "RecordingMemoryManager.h" +#include "RemoteTarget.h" #include "llvm/LLVMContext.h" #include "llvm/Module.h" #include "llvm/Type.h" @@ -32,9 +35,11 @@ #include "llvm/Support/PluginLoader.h" #include "llvm/Support/PrettyStackTrace.h" #include "llvm/Support/raw_ostream.h" +#include "llvm/Support/Format.h" #include "llvm/Support/Process.h" #include "llvm/Support/Signals.h" #include "llvm/Support/TargetSelect.h" +#include "llvm/Support/Debug.h" #include "llvm/Support/DynamicLibrary.h" #include "llvm/Support/Memory.h" #include @@ -73,6 +78,13 @@ namespace { "use-mcjit", cl::desc("Enable use of the MC-based JIT (if available)"), cl::init(false)); + // The MCJIT supports building for a target address space separate from + // the JIT compilation process. Use a forked process and a copying + // memory manager with IPC to execute using this functionality. + cl::opt RemoteMCJIT("remote-mcjit", + cl::desc("Execute MCJIT'ed code in a separate process."), + cl::init(false)); + // Determine optimization level. cl::opt OptLevel("O", @@ -372,6 +384,79 @@ LLIMCJITMemoryManager::~LLIMCJITMemoryManager() { free(AllocatedDataMem[i].base()); } + +void layoutRemoteTargetMemory(RemoteTarget *T, RecordingMemoryManager *JMM) { + // Lay out our sections in order, with all the code sections first, then + // all the data sections. + uint64_t CurOffset = 0; + unsigned MaxAlign = T->getPageAlignment(); + SmallVector, 16> Offsets; + SmallVector Sizes; + for (RecordingMemoryManager::const_code_iterator I = JMM->code_begin(), + E = JMM->code_end(); + I != E; ++I) { + DEBUG(dbgs() << "code region: size " << I->first.size() + << ", alignment " << I->second << "\n"); + // Align the current offset up to whatever is needed for the next + // section. + unsigned Align = I->second; + CurOffset = (CurOffset + Align - 1) / Align * Align; + // Save off the address of the new section and allocate its space. + Offsets.push_back(std::pair(I->first.base(), CurOffset)); + Sizes.push_back(I->first.size()); + CurOffset += I->first.size(); + } + // Adjust to keep code and data aligned on seperate pages. + CurOffset = (CurOffset + MaxAlign - 1) / MaxAlign * MaxAlign; + unsigned FirstDataIndex = Offsets.size(); + for (RecordingMemoryManager::const_data_iterator I = JMM->data_begin(), + E = JMM->data_end(); + I != E; ++I) { + DEBUG(dbgs() << "data region: size " << I->first.size() + << ", alignment " << I->second << "\n"); + // Align the current offset up to whatever is needed for the next + // section. + unsigned Align = I->second; + CurOffset = (CurOffset + Align - 1) / Align * Align; + // Save off the address of the new section and allocate its space. + Offsets.push_back(std::pair(I->first.base(), CurOffset)); + Sizes.push_back(I->first.size()); + CurOffset += I->first.size(); + } + + // Allocate space in the remote target. + uint64_t RemoteAddr; + if (T->allocateSpace(CurOffset, MaxAlign, RemoteAddr)) + report_fatal_error(T->getErrorMsg()); + // Map the section addresses so relocations will get updated in the local + // copies of the sections. + for (unsigned i = 0, e = Offsets.size(); i != e; ++i) { + uint64_t Addr = RemoteAddr + Offsets[i].second; + EE->mapSectionAddress(const_cast(Offsets[i].first), Addr); + + DEBUG(dbgs() << " Mapping local: " << Offsets[i].first + << " to remote: " << format("%#018x", Addr) << "\n"); + + } + // Now load it all to the target. + for (unsigned i = 0, e = Offsets.size(); i != e; ++i) { + uint64_t Addr = RemoteAddr + Offsets[i].second; + + if (i < FirstDataIndex) { + T->loadCode(Addr, Offsets[i].first, Sizes[i]); + + DEBUG(dbgs() << " loading code: " << Offsets[i].first + << " to remote: " << format("%#018x", Addr) << "\n"); + } else { + T->loadData(Addr, Offsets[i].first, Sizes[i]); + + DEBUG(dbgs() << " loading data: " << Offsets[i].first + << " to remote: " << format("%#018x", Addr) << "\n"); + } + + } +} + //===----------------------------------------------------------------------===// // main Driver function // @@ -428,12 +513,19 @@ int main(int argc, char **argv, char * const *envp) { Mod->setTargetTriple(Triple::normalize(TargetTriple)); // Enable MCJIT if desired. - LLIMCJITMemoryManager *JMM = 0; + JITMemoryManager *JMM = 0; if (UseMCJIT && !ForceInterpreter) { builder.setUseMCJIT(true); - JMM = new LLIMCJITMemoryManager(); + if (RemoteMCJIT) + JMM = new RecordingMemoryManager(); + else + JMM = new LLIMCJITMemoryManager(); builder.setJITMemoryManager(JMM); } else { + if (RemoteMCJIT) { + errs() << "error: Remote process execution requires -use-mcjit\n"; + exit(1); + } builder.setJITMemoryManager(ForceInterpreter ? 0 : JITMemoryManager::CreateDefaultMemManager()); } @@ -451,11 +543,14 @@ int main(int argc, char **argv, char * const *envp) { } builder.setOptLevel(OLvl); - TargetOptions Options; - Options.JITExceptionHandling = EnableJITExceptionHandling; - Options.JITEmitDebugInfo = EmitJitDebugInfo; - Options.JITEmitDebugInfoToDisk = EmitJitDebugInfoToDisk; - builder.setTargetOptions(Options); + // Remote target execution doesn't handle EH or debug registration. + if (!RemoteMCJIT) { + TargetOptions Options; + Options.JITExceptionHandling = EnableJITExceptionHandling; + Options.JITEmitDebugInfo = EmitJitDebugInfo; + Options.JITEmitDebugInfoToDisk = EmitJitDebugInfoToDisk; + builder.setTargetOptions(Options); + } EE = builder.create(); if (!EE) { @@ -473,6 +568,10 @@ int main(int argc, char **argv, char * const *envp) { EE->RegisterJITEventListener( JITEventListener::createIntelJITEventListener()); + if (!NoLazyCompilation && RemoteMCJIT) { + errs() << "warning: remote mcjit does not support lazy compilation\n"; + NoLazyCompilation = true; + } EE->DisableLazyCompilation(NoLazyCompilation); // If the user specifically requested an argv[0] to pass into the program, @@ -509,8 +608,13 @@ int main(int argc, char **argv, char * const *envp) { // Reset errno to zero on entry to main. errno = 0; + // Remote target MCJIT doesn't (yet) support static constructors. No reason + // it couldn't. This is a limitation of the LLI implemantation, not the + // MCJIT itself. FIXME. + // // Run static constructors. - EE->runStaticConstructorsDestructors(false); + if (!RemoteMCJIT) + EE->runStaticConstructorsDestructors(false); if (NoLazyCompilation) { for (Module::iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) { @@ -520,28 +624,66 @@ int main(int argc, char **argv, char * const *envp) { } } - // Clear instruction cache before code will be executed. - if (JMM) - JMM->invalidateInstructionCache(); - - // Run main. - int Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp); + int Result; + if (RemoteMCJIT) { + RecordingMemoryManager *MM = static_cast(JMM); + // Everything is prepared now, so lay out our program for the target + // address space, assign the section addresses to resolve any relocations, + // and send it to the target. + RemoteTarget Target; + Target.create(); + + // Ask for a pointer to the entry function. This triggers the actual + // compilation. + (void)EE->getPointerToFunction(EntryFn); + + // Enough has been compiled to execute the entry function now, so + // layout the target memory. + layoutRemoteTargetMemory(&Target, MM); + + // Since we're executing in a (at least simulated) remote address space, + // we can't use the ExecutionEngine::runFunctionAsMain(). We have to + // grab the function address directly here and tell the remote target + // to execute the function. + // FIXME: argv and envp handling. + uint64_t Entry = (uint64_t)EE->getPointerToFunction(EntryFn); + + DEBUG(dbgs() << "Executing '" << EntryFn->getName() << "' at " + << format("%#18x", Entry) << "\n"); + + if (Target.executeCode(Entry, Result)) + errs() << "ERROR: " << Target.getErrorMsg() << "\n"; + + Target.stop(); + } else { + // Clear instruction cache before code will be executed. + if (JMM) + static_cast(JMM)->invalidateInstructionCache(); - // Run static destructors. - EE->runStaticConstructorsDestructors(true); + // Run main. + Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp); + } - // If the program didn't call exit explicitly, we should call it now. - // This ensures that any atexit handlers get called correctly. - if (Function *ExitF = dyn_cast(Exit)) { - std::vector Args; - GenericValue ResultGV; - ResultGV.IntVal = APInt(32, Result); - Args.push_back(ResultGV); - EE->runFunction(ExitF, Args); - errs() << "ERROR: exit(" << Result << ") returned!\n"; - abort(); - } else { - errs() << "ERROR: exit defined with wrong prototype!\n"; - abort(); + // Like static constructors, the remote target MCJIT support doesn't handle + // this yet. It could. FIXME. + if (!RemoteMCJIT) { + // Run static destructors. + EE->runStaticConstructorsDestructors(true); + + // If the program didn't call exit explicitly, we should call it now. + // This ensures that any atexit handlers get called correctly. + if (Function *ExitF = dyn_cast(Exit)) { + std::vector Args; + GenericValue ResultGV; + ResultGV.IntVal = APInt(32, Result); + Args.push_back(ResultGV); + EE->runFunction(ExitF, Args); + errs() << "ERROR: exit(" << Result << ") returned!\n"; + abort(); + } else { + errs() << "ERROR: exit defined with wrong prototype!\n"; + abort(); + } } + return Result; } -- cgit v1.2.3