Interpreter.h revision 360e17eaf1a2abda82b02235dc57d26d8f83c937 
1//===-- Interpreter.h ------------------------------------------*- C++ -*--===//
2//
3// This header file defines the interpreter structure
4//
5//===----------------------------------------------------------------------===//
6
7#ifndef LLI_INTERPRETER_H
8#define LLI_INTERPRETER_H
9
10// Uncomment this line to enable profiling of structure field accesses.
11#define PROFILE_STRUCTURE_FIELDS 1
12
13
14#include "llvm/Module.h"
15#include "llvm/Method.h"
16#include "Support/DataTypes.h"
17#include "llvm/Assembly/CachedWriter.h"
18
19extern CachedWriter CW;     // Object to accellerate printing of LLVM
20
21struct MethodInfo;          // Defined in ExecutionAnnotations.h
22class CallInst;
23class ReturnInst;
24class BranchInst;
25class AllocationInst;
26
27typedef uint64_t PointerTy;
28
29union GenericValue {
30  bool            BoolVal;
31  unsigned char   UByteVal;
32  signed   char   SByteVal;
33  unsigned short  UShortVal;
34  signed   short  ShortVal;
35  unsigned int    UIntVal;
36  signed   int    IntVal;
37  uint64_t        ULongVal;
38  int64_t         LongVal;
39  double          DoubleVal;
40  float           FloatVal;
41  PointerTy       PointerVal;
42};
43
44typedef vector<GenericValue> ValuePlaneTy;
45
46// ExecutionContext struct - This struct represents one stack frame currently
47// executing.
48//
49struct ExecutionContext {
50  Method               *CurMethod;  // The currently executing method
51  BasicBlock           *CurBB;      // The currently executing BB
52  BasicBlock::iterator  CurInst;    // The next instruction to execute
53  MethodInfo           *MethInfo;   // The MethInfo annotation for the method
54  vector<ValuePlaneTy>  Values;     // ValuePlanes for each type
55
56  BasicBlock           *PrevBB;     // The previous BB or null if in first BB
57  CallInst             *Caller;     // Holds the call that called subframes.
58                                    // NULL if main func or debugger invoked fn
59};
60
61// Interpreter - This class represents the entirety of the interpreter.
62//
63class Interpreter {
64  Module *CurMod;              // The current Module being executed (0 if none)
65  int ExitCode;                // The exit code to be returned by the lli util
66  bool Profile;                // Profiling enabled?
67  bool Trace;                  // Tracing enabled?
68  int CurFrame;                // The current stack frame being inspected
69
70  // The runtime stack of executing code.  The top of the stack is the current
71  // method record.
72  vector<ExecutionContext> ECStack;
73
74public:
75  Interpreter();
76  inline ~Interpreter() { CW.setModule(0); delete CurMod; }
77
78  // getExitCode - return the code that should be the exit code for the lli
79  // utility.
80  inline int getExitCode() const { return ExitCode; }
81
82  // enableProfiling() - Turn profiling on, clear stats?
83  void enableProfiling() { Profile = true; }
84  void enableTracing() { Trace = true; }
85
86  void handleUserInput();
87
88  // User Interation Methods...
89  void loadModule(const string &Filename);
90  bool flushModule();
91  bool callMethod(const string &Name);      // return true on failure
92  void setBreakpoint(const string &Name);
93  void infoValue(const string &Name);
94  void print(const string &Name);
95  static void print(const Type *Ty, GenericValue V);
96  static void printValue(const Type *Ty, GenericValue V);
97
98  // Hack until we can parse command line args...
99  bool callMainMethod(const string &MainName,
100                      const vector<string> &InputFilename);
101
102  void list();             // Do the 'list' command
103  void printStackTrace();  // Do the 'backtrace' command
104
105  // Code execution methods...
106  void callMethod        (Method *Meth, const vector<GenericValue> &ArgVals);
107  bool executeInstruction(); // Execute one instruction...
108
109  void stepInstruction();  // Do the 'step' command
110  void nextInstruction();  // Do the 'next' command
111  void run();              // Do the 'run' command
112  void finish();           // Do the 'finish' command
113
114  // Opcode Implementations
115  void executeCallInst(CallInst *I, ExecutionContext &SF);
116  void executeRetInst(ReturnInst *I, ExecutionContext &SF);
117  void executeBrInst(BranchInst *I, ExecutionContext &SF);
118  void executeAllocInst(AllocationInst *I, ExecutionContext &SF);
119  GenericValue callExternalMethod(Method *Meth,
120                                  const vector<GenericValue> &ArgVals);
121  void exitCalled(GenericValue GV);
122
123  // getCurrentMethod - Return the currently executing method
124  inline Method *getCurrentMethod() const {
125    return CurFrame < 0 ? 0 : ECStack[CurFrame].CurMethod;
126  }
127
128  // isStopped - Return true if a program is stopped.  Return false if no
129  // program is running.
130  //
131  inline bool isStopped() const { return !ECStack.empty(); }
132
133private:  // Helper functions
134  // getCurrentExecutablePath() - Return the directory that the lli executable
135  // lives in.
136  //
137  string getCurrentExecutablePath() const;
138
139  // printCurrentInstruction - Print out the instruction that the virtual PC is
140  // at, or fail silently if no program is running.
141  //
142  void printCurrentInstruction();
143
144  // printStackFrame - Print information about the specified stack frame, or -1
145  // for the default one.
146  //
147  void printStackFrame(int FrameNo = -1);
148
149  // LookupMatchingNames - Search the current method namespace, then the global
150  // namespace looking for values that match the specified name.  Return ALL
151  // matches to that name.  This is obviously slow, and should only be used for
152  // user interaction.
153  //
154  vector<Value*> LookupMatchingNames(const string &Name);
155
156  // ChooseOneOption - Prompt the user to choose among the specified options to
157  // pick one value.  If no options are provided, emit an error.  If a single
158  // option is provided, just return that option.
159  //
160  Value *ChooseOneOption(const string &Name, const vector<Value*> &Opts);
161
162
163  void initializeExecutionEngine();
164  void initializeExternalMethods();
165};
166
167#endif
168