/// deleteModuleProvider - Remove a ModuleProvider from the list of modules, /// and deletes the ModuleProvider and owned Module. Avoids materializing /// the underlying module. void ExecutionEngine::deleteModuleProvider(ModuleProvider *P, std::string *ErrInfo) { for(SmallVector<ModuleProvider *, 1>::iterator I = Modules.begin(), E = Modules.end(); I != E; ++I) { ModuleProvider *MP = *I; if (MP == P) { Modules.erase(I); clearGlobalMappingsFromModule(MP->getModule()); delete MP; return; } } }
/// removeModuleProvider - Remove a ModuleProvider from the list of modules. /// Relases the Module from the ModuleProvider, materializing it in the /// process, and returns the materialized Module. Module* ExecutionEngine::removeModuleProvider(ModuleProvider *P, std::string *ErrInfo) { for(SmallVector<ModuleProvider *, 1>::iterator I = Modules.begin(), E = Modules.end(); I != E; ++I) { ModuleProvider *MP = *I; if (MP == P) { Modules.erase(I); clearGlobalMappingsFromModule(MP->getModule()); return MP->releaseModule(ErrInfo); } } return NULL; }
/// getPointerToFunction - This method is used to get the address of the /// specified function, compiling it if neccesary. /// void *JIT::getPointerToFunction(Function *F) { if (void *Addr = getPointerToGlobalIfAvailable(F)) return Addr; // Check if function already code gen'd MutexGuard locked(lock); // Now that this thread owns the lock, check if another thread has already // code gen'd the function. if (void *Addr = getPointerToGlobalIfAvailable(F)) return Addr; // Make sure we read in the function if it exists in this Module. if (F->hasNotBeenReadFromBitcode()) { // Determine the module provider this function is provided by. Module *M = F->getParent(); ModuleProvider *MP = 0; for (unsigned i = 0, e = Modules.size(); i != e; ++i) { if (Modules[i]->getModule() == M) { MP = Modules[i]; break; } } assert(MP && "Function isn't in a module we know about!"); std::string ErrorMsg; if (MP->materializeFunction(F, &ErrorMsg)) { llvm_report_error("Error reading function '" + F->getName()+ "' from bitcode file: " + ErrorMsg); } // Now retry to get the address. if (void *Addr = getPointerToGlobalIfAvailable(F)) return Addr; } if (F->isDeclaration() || F->hasAvailableExternallyLinkage()) { bool AbortOnFailure = !F->hasExternalWeakLinkage(); void *Addr = getPointerToNamedFunction(F->getName(), AbortOnFailure); addGlobalMapping(F, Addr); return Addr; } runJITOnFunctionUnlocked(F, locked); void *Addr = getPointerToGlobalIfAvailable(F); assert(Addr && "Code generation didn't add function to GlobalAddress table!"); return Addr; }
/** * Find the module provider for a given filename or return NULL if * no module provider can be found. */ ModuleProvider* Host::FindModuleProvider(std::string& filename) { Poco::Mutex::ScopedLock lock(moduleMutex); std::vector<ModuleProvider*>::iterator iter; for (iter = moduleProviders.begin(); iter != moduleProviders.end(); iter++) { ModuleProvider *provider = (*iter); if (provider && provider->IsModule(filename)) { return provider; } } return 0; }
/// getPointerToFunction - This method is used to get the address of the /// specified function, compiling it if neccesary. /// void *JIT::getPointerToFunction(Function *F) { if (void *Addr = getPointerToGlobalIfAvailable(F)) return Addr; // Check if function already code gen'd // Make sure we read in the function if it exists in this Module. if (F->hasNotBeenReadFromBitcode()) { // Determine the module provider this function is provided by. Module *M = F->getParent(); ModuleProvider *MP = 0; for (unsigned i = 0, e = Modules.size(); i != e; ++i) { if (Modules[i]->getModule() == M) { MP = Modules[i]; break; } } assert(MP && "Function isn't in a module we know about!"); std::string ErrorMsg; if (MP->materializeFunction(F, &ErrorMsg)) { cerr << "Error reading function '" << F->getName() << "' from bitcode file: " << ErrorMsg << "\n"; abort(); } } if (void *Addr = getPointerToGlobalIfAvailable(F)) { return Addr; } MutexGuard locked(lock); if (F->isDeclaration()) { void *Addr = getPointerToNamedFunction(F->getName()); addGlobalMapping(F, Addr); return Addr; } runJITOnFunction(F); void *Addr = getPointerToGlobalIfAvailable(F); assert(Addr && "Code generation didn't add function to GlobalAddress table!"); return Addr; }
//===----------------------------------------------------------------------===// // main Driver function // int main(int argc, char **argv, char * const *envp) { sys::PrintStackTraceOnErrorSignal(); PrettyStackTraceProgram X(argc, argv); atexit(do_shutdown); // Call llvm_shutdown() on exit. cl::ParseCommandLineOptions(argc, argv, "llvm interpreter & dynamic compiler\n"); // If the user doesn't want core files, disable them. if (DisableCoreFiles) sys::Process::PreventCoreFiles(); // Load the bitcode... std::string ErrorMsg; ModuleProvider *MP = NULL; if (MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(InputFile,&ErrorMsg)) { MP = getBitcodeModuleProvider(Buffer, &ErrorMsg); if (!MP) delete Buffer; } if (!MP) { std::cerr << argv[0] << ": error loading program '" << InputFile << "': " << ErrorMsg << "\n"; exit(1); } // Get the module as the MP could go away once EE takes over. Module *Mod = NoLazyCompilation ? MP->materializeModule(&ErrorMsg) : MP->getModule(); if (!Mod) { std::cerr << argv[0] << ": bitcode didn't read correctly.\n"; std::cerr << "Reason: " << ErrorMsg << "\n"; exit(1); } // If we are supposed to override the target triple, do so now. if (!TargetTriple.empty()) Mod->setTargetTriple(TargetTriple); EE = ExecutionEngine::create(MP, ForceInterpreter, &ErrorMsg, Fast); if (!EE && !ErrorMsg.empty()) { std::cerr << argv[0] << ":error creating EE: " << ErrorMsg << "\n"; exit(1); } if (NoLazyCompilation) EE->DisableLazyCompilation(); // If the user specifically requested an argv[0] to pass into the program, // do it now. if (!FakeArgv0.empty()) { InputFile = FakeArgv0; } else { // Otherwise, if there is a .bc suffix on the executable strip it off, it // might confuse the program. if (InputFile.rfind(".bc") == InputFile.length() - 3) InputFile.erase(InputFile.length() - 3); } // Add the module's name to the start of the vector of arguments to main(). InputArgv.insert(InputArgv.begin(), InputFile); // Call the main function from M as if its signature were: // int main (int argc, char **argv, const char **envp) // using the contents of Args to determine argc & argv, and the contents of // EnvVars to determine envp. // Function *EntryFn = Mod->getFunction(EntryFunc); if (!EntryFn) { std::cerr << '\'' << EntryFunc << "\' function not found in module.\n"; return -1; } // If the program doesn't explicitly call exit, we will need the Exit // function later on to make an explicit call, so get the function now. Constant *Exit = Mod->getOrInsertFunction("exit", Type::VoidTy, Type::Int32Ty, NULL); // Reset errno to zero on entry to main. errno = 0; // Run static constructors. EE->runStaticConstructorsDestructors(false); if (NoLazyCompilation) { for (Module::iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) { Function *Fn = &*I; if (Fn != EntryFn && !Fn->isDeclaration()) EE->getPointerToFunction(Fn); } } // 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); std::cerr << "ERROR: exit(" << Result << ") returned!\n"; abort(); } else { std::cerr << "ERROR: exit defined with wrong prototype!\n"; abort(); } }