lli.cpp revision 234982 
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
47using namespace llvm;
48
49namespace {
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
168static ExecutionEngine *EE = 0;
169
170static 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//
181int 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