diff options
Diffstat (limited to 'contrib/llvm/tools/lli/lli.cpp')
| -rw-r--r-- | contrib/llvm/tools/lli/lli.cpp | 258 |
1 files changed, 226 insertions, 32 deletions
diff --git a/contrib/llvm/tools/lli/lli.cpp b/contrib/llvm/tools/lli/lli.cpp index b6c9299..d41a595 100644 --- a/contrib/llvm/tools/lli/lli.cpp +++ b/contrib/llvm/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,11 +35,14 @@ #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 "llvm/Support/MathExtras.h" #include <cerrno> #ifdef __linux__ @@ -73,6 +79,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<bool> RemoteMCJIT("remote-mcjit", + cl::desc("Execute MCJIT'ed code in a separate process."), + cl::init(false)); + // Determine optimization level. cl::opt<char> OptLevel("O", @@ -159,6 +172,23 @@ namespace { cl::init(false)); cl::opt<bool> + GenerateSoftFloatCalls("soft-float", + cl::desc("Generate software floating point library calls"), + cl::init(false)); + + cl::opt<llvm::FloatABI::ABIType> + FloatABIForCalls("float-abi", + cl::desc("Choose float ABI type"), + cl::init(FloatABI::Default), + cl::values( + clEnumValN(FloatABI::Default, "default", + "Target default float ABI type"), + clEnumValN(FloatABI::Soft, "soft", + "Soft float ABI (implied by -soft-float)"), + clEnumValN(FloatABI::Hard, "hard", + "Hard float ABI (uses FP registers)"), + clEnumValEnd)); + cl::opt<bool> // In debug builds, make this default to true. #ifdef NDEBUG #define EMIT_DEBUG false @@ -212,7 +242,7 @@ public: // the data cache but not to the instruction cache. virtual void invalidateInstructionCache(); - // The MCJITMemoryManager doesn't use the following functions, so we don't + // The RTDyldMemoryManager doesn't use the following functions, so we don't // need implement them. virtual void setMemoryWritable() { llvm_unreachable("Unexpected call!"); @@ -274,9 +304,16 @@ uint8_t *LLIMCJITMemoryManager::allocateDataSection(uintptr_t Size, unsigned SectionID) { if (!Alignment) Alignment = 16; - uint8_t *Addr = (uint8_t*)calloc((Size + Alignment - 1)/Alignment, Alignment); - AllocatedDataMem.push_back(sys::MemoryBlock(Addr, Size)); - return Addr; + // Ensure that enough memory is requested to allow aligning. + size_t NumElementsAligned = 1 + (Size + Alignment - 1)/Alignment; + uint8_t *Addr = (uint8_t*)calloc(NumElementsAligned, Alignment); + + // Honour the alignment requirement. + uint8_t *AlignedAddr = (uint8_t*)RoundUpToAlignment((uint64_t)Addr, Alignment); + + // Store the original address from calloc so we can free it later. + AllocatedDataMem.push_back(sys::MemoryBlock(Addr, NumElementsAligned*Alignment)); + return AlignedAddr; } uint8_t *LLIMCJITMemoryManager::allocateCodeSection(uintptr_t Size, @@ -326,6 +363,10 @@ void LLIMCJITMemoryManager::invalidateInstructionCache() { AllocatedCodeMem[i].size()); } +static int jit_noop() { + return 0; +} + void *LLIMCJITMemoryManager::getPointerToNamedFunction(const std::string &Name, bool AbortOnFailure) { #if defined(__linux__) @@ -348,6 +389,14 @@ void *LLIMCJITMemoryManager::getPointerToNamedFunction(const std::string &Name, if (Name == "mknod") return (void*)(intptr_t)&mknod; #endif // __linux__ + // We should not invoke parent's ctors/dtors from generated main()! + // On Mingw and Cygwin, the symbol __main is resolved to + // callee's(eg. tools/lli) one, to invoke wrong duplicated ctors + // (and register wrong callee's dtors with atexit(3)). + // We expect ExecutionEngine::runStaticConstructorsDestructors() + // is called before ExecutionEngine::runFunctionAsMain() is called. + if (Name == "__main") return (void*)(intptr_t)&jit_noop; + const char *NameStr = Name.c_str(); void *Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(NameStr); if (Ptr) return Ptr; @@ -372,6 +421,83 @@ 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<std::pair<const void*, uint64_t>, 16> Offsets; + SmallVector<unsigned, 16> 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<const void*,uint64_t>(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<const void*,uint64_t>(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<void*>(Offsets[i].first), Addr); + + DEBUG(dbgs() << " Mapping local: " << Offsets[i].first + << " to remote: " << format("%p", Addr) << "\n"); + + } + + // Trigger application of relocations + EE->finalizeObject(); + + // 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("%p", Addr) << "\n"); + } else { + T->loadData(Addr, Offsets[i].first, Sizes[i]); + + DEBUG(dbgs() << " loading data: " << Offsets[i].first + << " to remote: " << format("%p", Addr) << "\n"); + } + + } +} + //===----------------------------------------------------------------------===// // main Driver function // @@ -386,6 +512,7 @@ int main(int argc, char **argv, char * const *envp) { // usable by the JIT. InitializeNativeTarget(); InitializeNativeTargetAsmPrinter(); + InitializeNativeTargetAsmParser(); cl::ParseCommandLineOptions(argc, argv, "llvm interpreter & dynamic compiler\n"); @@ -428,12 +555,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()); } @@ -452,9 +586,19 @@ int main(int argc, char **argv, char * const *envp) { builder.setOptLevel(OLvl); TargetOptions Options; - Options.JITExceptionHandling = EnableJITExceptionHandling; - Options.JITEmitDebugInfo = EmitJitDebugInfo; - Options.JITEmitDebugInfoToDisk = EmitJitDebugInfoToDisk; + Options.UseSoftFloat = GenerateSoftFloatCalls; + if (FloatABIForCalls != FloatABI::Default) + Options.FloatABIType = FloatABIForCalls; + if (GenerateSoftFloatCalls) + FloatABIForCalls = FloatABI::Soft; + + // Remote target execution doesn't handle EH or debug registration. + if (!RemoteMCJIT) { + Options.JITExceptionHandling = EnableJITExceptionHandling; + Options.JITEmitDebugInfo = EmitJitDebugInfo; + Options.JITEmitDebugInfoToDisk = EmitJitDebugInfoToDisk; + } + builder.setTargetOptions(Options); EE = builder.create(); @@ -466,10 +610,6 @@ int main(int argc, char **argv, char * const *envp) { exit(1); } - // Clear instruction cache before code will be executed. - if (JMM) - JMM->invalidateInstructionCache(); - // The following functions have no effect if their respective profiling // support wasn't enabled in the build configuration. EE->RegisterJITEventListener( @@ -477,6 +617,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, @@ -513,8 +657,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) { @@ -524,24 +673,69 @@ int main(int argc, char **argv, char * const *envp) { } } - // Run main. - int Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp); - - // 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<Function>(Exit)) { - std::vector<GenericValue> Args; - GenericValue ResultGV; - ResultGV.IntVal = APInt(32, Result); - Args.push_back(ResultGV); - EE->runFunction(ExitF, Args); - errs() << "ERROR: exit(" << Result << ") returned!\n"; - abort(); + int Result; + if (RemoteMCJIT) { + RecordingMemoryManager *MM = static_cast<RecordingMemoryManager*>(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("%p", Entry) << "\n"); + + if (Target.executeCode(Entry, Result)) + errs() << "ERROR: " << Target.getErrorMsg() << "\n"; + + Target.stop(); } else { - errs() << "ERROR: exit defined with wrong prototype!\n"; - abort(); + // Trigger compilation separately so code regions that need to be + // invalidated will be known. + (void)EE->getPointerToFunction(EntryFn); + // Clear instruction cache before code will be executed. + if (JMM) + static_cast<LLIMCJITMemoryManager*>(JMM)->invalidateInstructionCache(); + + // Run main. + Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp); + } + + // 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<Function>(Exit)) { + std::vector<GenericValue> 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; } |
