Interpreter.h revision d7916e988c544b2ab6af26b723b6bc340ecb78cc
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#include "../ExecutionEngine.h" 14#include "../GenericValue.h" 15#include "Support/DataTypes.h" 16#include "llvm/Assembly/CachedWriter.h" 17#include "llvm/Target/TargetData.h" 18#include "llvm/BasicBlock.h" 19#include "llvm/Support/InstVisitor.h" 20 21extern CachedWriter CW; // Object to accelerate printing of LLVM 22 23struct FunctionInfo; // Defined in ExecutionAnnotations.h 24 25// AllocaHolder - Object to track all of the blocks of memory allocated by 26// alloca. When the function returns, this object is poped off the execution 27// stack, which causes the dtor to be run, which frees all the alloca'd memory. 28// 29class AllocaHolder { 30 friend class AllocaHolderHandle; 31 std::vector<void*> Allocations; 32 unsigned RefCnt; 33public: 34 AllocaHolder() : RefCnt(0) {} 35 void add(void *mem) { Allocations.push_back(mem); } 36 ~AllocaHolder() { 37 for (unsigned i = 0; i < Allocations.size(); ++i) 38 free(Allocations[i]); 39 } 40}; 41 42// AllocaHolderHandle gives AllocaHolder value semantics so we can stick it into 43// a vector... 44// 45class AllocaHolderHandle { 46 AllocaHolder *H; 47public: 48 AllocaHolderHandle() : H(new AllocaHolder()) { H->RefCnt++; } 49 AllocaHolderHandle(const AllocaHolderHandle &AH) : H(AH.H) { H->RefCnt++; } 50 ~AllocaHolderHandle() { if (--H->RefCnt == 0) delete H; } 51 52 void add(void *mem) { H->add(mem); } 53}; 54 55typedef std::vector<GenericValue> ValuePlaneTy; 56 57// ExecutionContext struct - This struct represents one stack frame currently 58// executing. 59// 60struct ExecutionContext { 61 Function *CurFunction;// The currently executing function 62 BasicBlock *CurBB; // The currently executing BB 63 BasicBlock::iterator CurInst; // The next instruction to execute 64 FunctionInfo *FuncInfo; // The FuncInfo annotation for the function 65 std::vector<ValuePlaneTy> Values;// ValuePlanes for each type 66 std::vector<GenericValue> VarArgs; // Values passed through an ellipsis 67 68 CallInst *Caller; // Holds the call that called subframes. 69 // NULL if main func or debugger invoked fn 70 AllocaHolderHandle Allocas; // Track memory allocated by alloca 71}; 72 73// Interpreter - This class represents the entirety of the interpreter. 74// 75class Interpreter : public ExecutionEngine, public InstVisitor<Interpreter> { 76 int ExitCode; // The exit code to be returned by the lli util 77 bool Debug; // Debug mode enabled? 78 bool Profile; // Profiling enabled? 79 bool Trace; // Tracing enabled? 80 int CurFrame; // The current stack frame being inspected 81 TargetData TD; 82 83 // The runtime stack of executing code. The top of the stack is the current 84 // function record. 85 std::vector<ExecutionContext> ECStack; 86 87public: 88 Interpreter(Module *M, unsigned Config, bool DebugMode, bool TraceMode); 89 inline ~Interpreter() { CW.setModule(0); } 90 91 // getExitCode - return the code that should be the exit code for the lli 92 // utility. 93 inline int getExitCode() const { return ExitCode; } 94 95 /// run - Start execution with the specified function and arguments. 96 /// 97 virtual int run(const std::string &FnName, 98 const std::vector<std::string> &Args); 99 100 101 // enableProfiling() - Turn profiling on, clear stats? 102 void enableProfiling() { Profile = true; } 103 void enableTracing() { Trace = true; } 104 105 void handleUserInput(); 106 107 // User Interation Methods... 108 bool callFunction(const std::string &Name); // return true on failure 109 void setBreakpoint(const std::string &Name); 110 void infoValue(const std::string &Name); 111 void print(const std::string &Name); 112 static void print(const Type *Ty, GenericValue V); 113 static void printValue(const Type *Ty, GenericValue V); 114 115 bool callMainFunction(const std::string &MainName, 116 const std::vector<std::string> &InputFilename); 117 118 void list(); // Do the 'list' command 119 void printStackTrace(); // Do the 'backtrace' command 120 121 // Code execution methods... 122 void callFunction(Function *F, const std::vector<GenericValue> &ArgVals); 123 bool executeInstruction(); // Execute one instruction... 124 125 void stepInstruction(); // Do the 'step' command 126 void nextInstruction(); // Do the 'next' command 127 void run(); // Do the 'run' command 128 void finish(); // Do the 'finish' command 129 130 // Opcode Implementations 131 void visitReturnInst(ReturnInst &I); 132 void visitBranchInst(BranchInst &I); 133 void visitSwitchInst(SwitchInst &I); 134 135 void visitBinaryOperator(BinaryOperator &I); 136 void visitAllocationInst(AllocationInst &I); 137 void visitFreeInst(FreeInst &I); 138 void visitLoadInst(LoadInst &I); 139 void visitStoreInst(StoreInst &I); 140 void visitGetElementPtrInst(GetElementPtrInst &I); 141 142 void visitPHINode(PHINode &PN) { assert(0 && "PHI nodes already handled!"); } 143 void visitCastInst(CastInst &I); 144 void visitCallInst(CallInst &I); 145 void visitShl(ShiftInst &I); 146 void visitShr(ShiftInst &I); 147 void visitVarArgInst(VarArgInst &I); 148 void visitInstruction(Instruction &I) { 149 std::cerr << I; 150 assert(0 && "Instruction not interpretable yet!"); 151 } 152 153 GenericValue callExternalFunction(Function *F, 154 const std::vector<GenericValue> &ArgVals); 155 void exitCalled(GenericValue GV); 156 157 // getCurrentFunction - Return the currently executing function 158 inline Function *getCurrentFunction() const { 159 return CurFrame < 0 ? 0 : ECStack[CurFrame].CurFunction; 160 } 161 162 // isStopped - Return true if a program is stopped. Return false if no 163 // program is running. 164 // 165 inline bool isStopped() const { return !ECStack.empty(); } 166 167 //FIXME: private: 168public: 169 GenericValue executeGEPOperation(Value *Ptr, User::op_iterator I, 170 User::op_iterator E, ExecutionContext &SF); 171 172private: // Helper functions 173 // SwitchToNewBasicBlock - Start execution in a new basic block and run any 174 // PHI nodes in the top of the block. This is used for intraprocedural 175 // control flow. 176 // 177 void SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF); 178 179 void *getPointerToFunction(const Function *F) { return (void*)F; } 180 181 // getCurrentExecutablePath() - Return the directory that the lli executable 182 // lives in. 183 // 184 std::string getCurrentExecutablePath() const; 185 186 // printCurrentInstruction - Print out the instruction that the virtual PC is 187 // at, or fail silently if no program is running. 188 // 189 void printCurrentInstruction(); 190 191 // printStackFrame - Print information about the specified stack frame, or -1 192 // for the default one. 193 // 194 void printStackFrame(int FrameNo = -1); 195 196 // LookupMatchingNames - Search the current function namespace, then the 197 // global namespace looking for values that match the specified name. Return 198 // ALL matches to that name. This is obviously slow, and should only be used 199 // for user interaction. 200 // 201 std::vector<Value*> LookupMatchingNames(const std::string &Name); 202 203 // ChooseOneOption - Prompt the user to choose among the specified options to 204 // pick one value. If no options are provided, emit an error. If a single 205 // option is provided, just return that option. 206 // 207 Value *ChooseOneOption(const std::string &Name, 208 const std::vector<Value*> &Opts); 209 210 211 void initializeExecutionEngine(); 212 void initializeExternalFunctions(); 213}; 214 215#endif 216