/// 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; }
//===----------------------------------------------------------------------===// // 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(); } }