lli.cpp revision d6840ac046715061d42e4dd5375cd9ed6dd3dca4 
1//===- lli.cpp - LLVM Interpreter / Dynamic compiler ----------------------===//
2//
3// This utility provides a way to execute LLVM bytecode without static
4// compilation.  This consists of a very simple and slow (but portable)
5// interpreter, along with capability for system specific dynamic compilers.  At
6// runtime, the fastest (stable) execution engine is selected to run the
7// program.  This means the JIT compiler for the current platform if it's
8// available.
9//
10//===----------------------------------------------------------------------===//
11
12#include "ExecutionEngine.h"
13#include "Support/CommandLine.h"
14#include "llvm/Bytecode/Reader.h"
15#include "llvm/Module.h"
16#include "llvm/Target/TargetMachineImpls.h"
17
18namespace {
19  cl::opt<std::string>
20  InputFile(cl::desc("<input bytecode>"), cl::Positional, cl::init("-"));
21
22  cl::list<std::string>
23  InputArgv(cl::ConsumeAfter, cl::desc("<program arguments>..."));
24
25  cl::opt<std::string>
26  MainFunction ("f", cl::desc("Function to execute"), cl::init("main"),
27		cl::value_desc("function name"));
28
29  cl::opt<bool> DebugMode("d", cl::desc("Start program in debugger"));
30
31  cl::opt<bool> TraceMode("trace", cl::desc("Enable Tracing"));
32
33  cl::opt<bool> ForceInterpreter("force-interpreter",
34				 cl::desc("Force interpretation: disable JIT"),
35				 cl::init(true));
36}
37
38//===----------------------------------------------------------------------===//
39// ExecutionEngine Class Implementation
40//
41
42ExecutionEngine::~ExecutionEngine() {
43  delete &CurMod;
44}
45
46//===----------------------------------------------------------------------===//
47// main Driver function
48//
49int main(int argc, char** argv) {
50  cl::ParseCommandLineOptions(argc, argv,
51			      " llvm interpreter & dynamic compiler\n");
52
53  // Load the bytecode...
54  std::string ErrorMsg;
55  Module *M = ParseBytecodeFile(InputFile, &ErrorMsg);
56  if (M == 0) {
57    std::cout << "Error parsing '" << InputFile << "': "
58              << ErrorMsg << "\n";
59    exit(1);
60  }
61
62#if 0
63  // Link in the runtime library for LLI...
64  std::string RuntimeLib = getCurrentExecutablePath();
65  if (!RuntimeLib.empty()) RuntimeLib += "/";
66  RuntimeLib += "RuntimeLib.bc";
67
68  if (Module *SupportLib = ParseBytecodeFile(RuntimeLib, &ErrorMsg)) {
69    if (LinkModules(M, SupportLib, &ErrorMsg))
70      std::cerr << "Error Linking runtime library into current module: "
71                << ErrorMsg << "\n";
72  } else {
73    std::cerr << "Error loading runtime library '"+RuntimeLib+"': "
74              << ErrorMsg << "\n";
75  }
76#endif
77
78  // FIXME: This should look at the PointerSize and endianness of the bytecode
79  // file to determine the endianness and pointer size of target machine to use.
80  unsigned Config = TM::PtrSize64 | TM::BigEndian;
81
82  ExecutionEngine *EE = 0;
83
84  // If there is nothing that is forcing us to use the interpreter, make a JIT.
85  if (!ForceInterpreter && !DebugMode && !TraceMode)
86    EE = ExecutionEngine::createJIT(M, Config);
87
88  // If we can't make a JIT, make an interpreter instead.
89  if (EE == 0)
90    EE = ExecutionEngine::createInterpreter(M, Config, DebugMode, TraceMode);
91
92  // Add the module name to the start of the argv vector...
93  InputArgv.insert(InputArgv.begin(), InputFile);
94
95  // Run the main function!
96  int ExitCode = EE->run(MainFunction, InputArgv);
97
98  // Now that we are done executing the program, shut down the execution engine
99  delete EE;
100  return ExitCode;
101}
102