1 //===- lli.cpp - LLVM Interpreter / Dynamic compiler ----------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This utility provides a simple wrapper around the LLVM Execution Engines, 11 // which allow the direct execution of LLVM programs through a Just-In-Time 12 // compiler, or through an interpreter if no JIT is available for this platform. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "llvm/LLVMContext.h" 17 #include "llvm/Module.h" 18 #include "llvm/Type.h" 19 #include "llvm/ADT/Triple.h" 20 #include "llvm/Bitcode/ReaderWriter.h" 21 #include "llvm/CodeGen/LinkAllCodegenComponents.h" 22 #include "llvm/ExecutionEngine/GenericValue.h" 23 #include "llvm/ExecutionEngine/Interpreter.h" 24 #include "llvm/ExecutionEngine/JIT.h" 25 #include "llvm/ExecutionEngine/JITEventListener.h" 26 #include "llvm/ExecutionEngine/JITMemoryManager.h" 27 #include "llvm/ExecutionEngine/MCJIT.h" 28 #include "llvm/Support/CommandLine.h" 29 #include "llvm/Support/IRReader.h" 30 #include "llvm/Support/ManagedStatic.h" 31 #include "llvm/Support/MemoryBuffer.h" 32 #include "llvm/Support/PluginLoader.h" 33 #include "llvm/Support/PrettyStackTrace.h" 34 #include "llvm/Support/raw_ostream.h" 35 #include "llvm/Support/Process.h" 36 #include "llvm/Support/Signals.h" 37 #include "llvm/Support/TargetSelect.h" 38 #include <cerrno> 39 40 #ifdef __CYGWIN__ 41 #include <cygwin/version.h> 42 #if defined(CYGWIN_VERSION_DLL_MAJOR) && CYGWIN_VERSION_DLL_MAJOR<1007 43 #define DO_NOTHING_ATEXIT 1 44 #endif 45 #endif 46 47 using namespace llvm; 48 49 namespace { 50 cl::opt<std::string> 51 InputFile(cl::desc("<input bitcode>"), cl::Positional, cl::init("-")); 52 53 cl::list<std::string> 54 InputArgv(cl::ConsumeAfter, cl::desc("<program arguments>...")); 55 56 cl::opt<bool> ForceInterpreter("force-interpreter", 57 cl::desc("Force interpretation: disable JIT"), 58 cl::init(false)); 59 60 cl::opt<bool> UseMCJIT( 61 "use-mcjit", cl::desc("Enable use of the MC-based JIT (if available)"), 62 cl::init(false)); 63 64 // Determine optimization level. 65 cl::opt<char> 66 OptLevel("O", 67 cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] " 68 "(default = '-O2')"), 69 cl::Prefix, 70 cl::ZeroOrMore, 71 cl::init(' ')); 72 73 cl::opt<std::string> 74 TargetTriple("mtriple", cl::desc("Override target triple for module")); 75 76 cl::opt<std::string> 77 MArch("march", 78 cl::desc("Architecture to generate assembly for (see --version)")); 79 80 cl::opt<std::string> 81 MCPU("mcpu", 82 cl::desc("Target a specific cpu type (-mcpu=help for details)"), 83 cl::value_desc("cpu-name"), 84 cl::init("")); 85 86 cl::list<std::string> 87 MAttrs("mattr", 88 cl::CommaSeparated, 89 cl::desc("Target specific attributes (-mattr=help for details)"), 90 cl::value_desc("a1,+a2,-a3,...")); 91 92 cl::opt<std::string> 93 EntryFunc("entry-function", 94 cl::desc("Specify the entry function (default = 'main') " 95 "of the executable"), 96 cl::value_desc("function"), 97 cl::init("main")); 98 99 cl::opt<std::string> 100 FakeArgv0("fake-argv0", 101 cl::desc("Override the 'argv[0]' value passed into the executing" 102 " program"), cl::value_desc("executable")); 103 104 cl::opt<bool> 105 DisableCoreFiles("disable-core-files", cl::Hidden, 106 cl::desc("Disable emission of core files if possible")); 107 108 cl::opt<bool> 109 NoLazyCompilation("disable-lazy-compilation", 110 cl::desc("Disable JIT lazy compilation"), 111 cl::init(false)); 112 113 cl::opt<Reloc::Model> 114 RelocModel("relocation-model", 115 cl::desc("Choose relocation model"), 116 cl::init(Reloc::Default), 117 cl::values( 118 clEnumValN(Reloc::Default, "default", 119 "Target default relocation model"), 120 clEnumValN(Reloc::Static, "static", 121 "Non-relocatable code"), 122 clEnumValN(Reloc::PIC_, "pic", 123 "Fully relocatable, position independent code"), 124 clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic", 125 "Relocatable external references, non-relocatable code"), 126 clEnumValEnd)); 127 128 cl::opt<llvm::CodeModel::Model> 129 CMModel("code-model", 130 cl::desc("Choose code model"), 131 cl::init(CodeModel::JITDefault), 132 cl::values(clEnumValN(CodeModel::JITDefault, "default", 133 "Target default JIT code model"), 134 clEnumValN(CodeModel::Small, "small", 135 "Small code model"), 136 clEnumValN(CodeModel::Kernel, "kernel", 137 "Kernel code model"), 138 clEnumValN(CodeModel::Medium, "medium", 139 "Medium code model"), 140 clEnumValN(CodeModel::Large, "large", 141 "Large code model"), 142 clEnumValEnd)); 143 144 cl::opt<bool> 145 EnableJITExceptionHandling("jit-enable-eh", 146 cl::desc("Emit exception handling information"), 147 cl::init(false)); 148 149 cl::opt<bool> 150 // In debug builds, make this default to true. 151 #ifdef NDEBUG 152 #define EMIT_DEBUG false 153 #else 154 #define EMIT_DEBUG true 155 #endif 156 EmitJitDebugInfo("jit-emit-debug", 157 cl::desc("Emit debug information to debugger"), 158 cl::init(EMIT_DEBUG)); 159 #undef EMIT_DEBUG 160 161 static cl::opt<bool> 162 EmitJitDebugInfoToDisk("jit-emit-debug-to-disk", 163 cl::Hidden, 164 cl::desc("Emit debug info objfiles to disk"), 165 cl::init(false)); 166 } 167 168 static ExecutionEngine *EE = 0; 169 170 static void do_shutdown() { 171 // Cygwin-1.5 invokes DLL's dtors before atexit handler. 172 #ifndef DO_NOTHING_ATEXIT 173 delete EE; 174 llvm_shutdown(); 175 #endif 176 } 177 178 //===----------------------------------------------------------------------===// 179 // main Driver function 180 // 181 int main(int argc, char **argv, char * const *envp) { 182 sys::PrintStackTraceOnErrorSignal(); 183 PrettyStackTraceProgram X(argc, argv); 184 185 LLVMContext &Context = getGlobalContext(); 186 atexit(do_shutdown); // Call llvm_shutdown() on exit. 187 188 // If we have a native target, initialize it to ensure it is linked in and 189 // usable by the JIT. 190 InitializeNativeTarget(); 191 InitializeNativeTargetAsmPrinter(); 192 193 cl::ParseCommandLineOptions(argc, argv, 194 "llvm interpreter & dynamic compiler\n"); 195 196 // If the user doesn't want core files, disable them. 197 if (DisableCoreFiles) 198 sys::Process::PreventCoreFiles(); 199 200 // Load the bitcode... 201 SMDiagnostic Err; 202 Module *Mod = ParseIRFile(InputFile, Err, Context); 203 if (!Mod) { 204 Err.print(argv[0], errs()); 205 return 1; 206 } 207 208 // If not jitting lazily, load the whole bitcode file eagerly too. 209 std::string ErrorMsg; 210 if (NoLazyCompilation) { 211 if (Mod->MaterializeAllPermanently(&ErrorMsg)) { 212 errs() << argv[0] << ": bitcode didn't read correctly.\n"; 213 errs() << "Reason: " << ErrorMsg << "\n"; 214 exit(1); 215 } 216 } 217 218 EngineBuilder builder(Mod); 219 builder.setMArch(MArch); 220 builder.setMCPU(MCPU); 221 builder.setMAttrs(MAttrs); 222 builder.setRelocationModel(RelocModel); 223 builder.setCodeModel(CMModel); 224 builder.setErrorStr(&ErrorMsg); 225 builder.setJITMemoryManager(ForceInterpreter ? 0 : 226 JITMemoryManager::CreateDefaultMemManager()); 227 builder.setEngineKind(ForceInterpreter 228 ? EngineKind::Interpreter 229 : EngineKind::JIT); 230 231 // If we are supposed to override the target triple, do so now. 232 if (!TargetTriple.empty()) 233 Mod->setTargetTriple(Triple::normalize(TargetTriple)); 234 235 // Enable MCJIT if desired. 236 if (UseMCJIT && !ForceInterpreter) { 237 builder.setUseMCJIT(true); 238 builder.setJITMemoryManager(JITMemoryManager::CreateDefaultMemManager()); 239 } 240 241 CodeGenOpt::Level OLvl = CodeGenOpt::Default; 242 switch (OptLevel) { 243 default: 244 errs() << argv[0] << ": invalid optimization level.\n"; 245 return 1; 246 case ' ': break; 247 case '0': OLvl = CodeGenOpt::None; break; 248 case '1': OLvl = CodeGenOpt::Less; break; 249 case '2': OLvl = CodeGenOpt::Default; break; 250 case '3': OLvl = CodeGenOpt::Aggressive; break; 251 } 252 builder.setOptLevel(OLvl); 253 254 TargetOptions Options; 255 Options.JITExceptionHandling = EnableJITExceptionHandling; 256 Options.JITEmitDebugInfo = EmitJitDebugInfo; 257 Options.JITEmitDebugInfoToDisk = EmitJitDebugInfoToDisk; 258 builder.setTargetOptions(Options); 259 260 EE = builder.create(); 261 if (!EE) { 262 if (!ErrorMsg.empty()) 263 errs() << argv[0] << ": error creating EE: " << ErrorMsg << "\n"; 264 else 265 errs() << argv[0] << ": unknown error creating EE!\n"; 266 exit(1); 267 } 268 269 // The following functions have no effect if their respective profiling 270 // support wasn't enabled in the build configuration. 271 EE->RegisterJITEventListener( 272 JITEventListener::createOProfileJITEventListener()); 273 EE->RegisterJITEventListener( 274 JITEventListener::createIntelJITEventListener()); 275 276 EE->DisableLazyCompilation(NoLazyCompilation); 277 278 // If the user specifically requested an argv[0] to pass into the program, 279 // do it now. 280 if (!FakeArgv0.empty()) { 281 InputFile = FakeArgv0; 282 } else { 283 // Otherwise, if there is a .bc suffix on the executable strip it off, it 284 // might confuse the program. 285 if (StringRef(InputFile).endswith(".bc")) 286 InputFile.erase(InputFile.length() - 3); 287 } 288 289 // Add the module's name to the start of the vector of arguments to main(). 290 InputArgv.insert(InputArgv.begin(), InputFile); 291 292 // Call the main function from M as if its signature were: 293 // int main (int argc, char **argv, const char **envp) 294 // using the contents of Args to determine argc & argv, and the contents of 295 // EnvVars to determine envp. 296 // 297 Function *EntryFn = Mod->getFunction(EntryFunc); 298 if (!EntryFn) { 299 errs() << '\'' << EntryFunc << "\' function not found in module.\n"; 300 return -1; 301 } 302 303 // If the program doesn't explicitly call exit, we will need the Exit 304 // function later on to make an explicit call, so get the function now. 305 Constant *Exit = Mod->getOrInsertFunction("exit", Type::getVoidTy(Context), 306 Type::getInt32Ty(Context), 307 NULL); 308 309 // Reset errno to zero on entry to main. 310 errno = 0; 311 312 // Run static constructors. 313 EE->runStaticConstructorsDestructors(false); 314 315 if (NoLazyCompilation) { 316 for (Module::iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) { 317 Function *Fn = &*I; 318 if (Fn != EntryFn && !Fn->isDeclaration()) 319 EE->getPointerToFunction(Fn); 320 } 321 } 322 323 // Run main. 324 int Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp); 325 326 // Run static destructors. 327 EE->runStaticConstructorsDestructors(true); 328 329 // If the program didn't call exit explicitly, we should call it now. 330 // This ensures that any atexit handlers get called correctly. 331 if (Function *ExitF = dyn_cast<Function>(Exit)) { 332 std::vector<GenericValue> Args; 333 GenericValue ResultGV; 334 ResultGV.IntVal = APInt(32, Result); 335 Args.push_back(ResultGV); 336 EE->runFunction(ExitF, Args); 337 errs() << "ERROR: exit(" << Result << ") returned!\n"; 338 abort(); 339 } else { 340 errs() << "ERROR: exit defined with wrong prototype!\n"; 341 abort(); 342 } 343 } 344
