Interpreter.h revision 2cab55d7e1bde83cd5f5dccee9a331ada8c1a67c
1//===-- Interpreter.h ------------------------------------------*- C++ -*--===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This header file defines the interpreter structure 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLI_INTERPRETER_H 15#define LLI_INTERPRETER_H 16 17#include "llvm/Function.h" 18#include "llvm/ExecutionEngine/ExecutionEngine.h" 19#include "llvm/ExecutionEngine/GenericValue.h" 20#include "llvm/Support/InstVisitor.h" 21#include "llvm/Support/CallSite.h" 22#include "llvm/Target/TargetData.h" 23#include "Support/DataTypes.h" 24 25namespace llvm { 26 27struct FunctionInfo; // Defined in ExecutionAnnotations.h 28class gep_type_iterator; 29class ConstantExpr; 30 31// AllocaHolder - Object to track all of the blocks of memory allocated by 32// alloca. When the function returns, this object is popped off the execution 33// stack, which causes the dtor to be run, which frees all the alloca'd memory. 34// 35class AllocaHolder { 36 friend class AllocaHolderHandle; 37 std::vector<void*> Allocations; 38 unsigned RefCnt; 39public: 40 AllocaHolder() : RefCnt(0) {} 41 void add(void *mem) { Allocations.push_back(mem); } 42 ~AllocaHolder() { 43 for (unsigned i = 0; i < Allocations.size(); ++i) 44 free(Allocations[i]); 45 } 46}; 47 48// AllocaHolderHandle gives AllocaHolder value semantics so we can stick it into 49// a vector... 50// 51class AllocaHolderHandle { 52 AllocaHolder *H; 53public: 54 AllocaHolderHandle() : H(new AllocaHolder()) { H->RefCnt++; } 55 AllocaHolderHandle(const AllocaHolderHandle &AH) : H(AH.H) { H->RefCnt++; } 56 ~AllocaHolderHandle() { if (--H->RefCnt == 0) delete H; } 57 58 void add(void *mem) { H->add(mem); } 59}; 60 61typedef std::vector<GenericValue> ValuePlaneTy; 62 63// ExecutionContext struct - This struct represents one stack frame currently 64// executing. 65// 66struct ExecutionContext { 67 Function *CurFunction;// The currently executing function 68 BasicBlock *CurBB; // The currently executing BB 69 BasicBlock::iterator CurInst; // The next instruction to execute 70 std::map<Value *, GenericValue> Values; // LLVM values used in this invocation 71 std::vector<GenericValue> VarArgs; // Values passed through an ellipsis 72 CallSite Caller; // Holds the call that called subframes. 73 // NULL if main func or debugger invoked fn 74 AllocaHolderHandle Allocas; // Track memory allocated by alloca 75}; 76 77// Interpreter - This class represents the entirety of the interpreter. 78// 79class Interpreter : public ExecutionEngine, public InstVisitor<Interpreter> { 80 int ExitCode; // The exit code to be returned by the lli util 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 87 // AtExitHandlers - List of functions to call when the program exits, 88 // registered with the atexit() library function. 89 std::vector<Function*> AtExitHandlers; 90 91public: 92 Interpreter(Module *M, bool isLittleEndian, bool isLongPointer); 93 inline ~Interpreter() { } 94 95 /// runAtExitHandlers - Run any functions registered by the program's calls to 96 /// atexit(3), which we intercept and store in AtExitHandlers. 97 /// 98 void runAtExitHandlers(); 99 100 /// create - Create an interpreter ExecutionEngine. This can never fail. 101 /// 102 static ExecutionEngine *create(Module *M); 103 104 /// run - Start execution with the specified function and arguments. 105 /// 106 virtual GenericValue runFunction(Function *F, 107 const std::vector<GenericValue> &ArgValues); 108 109 /// recompileAndRelinkFunction - For the interpreter, functions are always 110 /// up-to-date. 111 /// 112 virtual void *recompileAndRelinkFunction(Function *F) { 113 return getPointerToFunction(F); 114 } 115 116 // Methods used to execute code: 117 // Place a call on the stack 118 void callFunction(Function *F, const std::vector<GenericValue> &ArgVals); 119 void run(); // Execute instructions until nothing left to do 120 121 // Opcode Implementations 122 void visitReturnInst(ReturnInst &I); 123 void visitBranchInst(BranchInst &I); 124 void visitSwitchInst(SwitchInst &I); 125 126 void visitBinaryOperator(BinaryOperator &I); 127 void visitAllocationInst(AllocationInst &I); 128 void visitFreeInst(FreeInst &I); 129 void visitLoadInst(LoadInst &I); 130 void visitStoreInst(StoreInst &I); 131 void visitGetElementPtrInst(GetElementPtrInst &I); 132 void visitPHINode(PHINode &PN) { assert(0 && "PHI nodes already handled!"); } 133 void visitCastInst(CastInst &I); 134 135 void visitCallSite(CallSite CS); 136 void visitCallInst(CallInst &I) { visitCallSite (CallSite (&I)); } 137 void visitInvokeInst(InvokeInst &I) { visitCallSite (CallSite (&I)); } 138 void visitUnwindInst(UnwindInst &I); 139 140 void visitShl(ShiftInst &I); 141 void visitShr(ShiftInst &I); 142 void visitVANextInst(VANextInst &I); 143 void visitVAArgInst(VAArgInst &I); 144 void visitInstruction(Instruction &I) { 145 std::cerr << I; 146 assert(0 && "Instruction not interpretable yet!"); 147 } 148 149 GenericValue callExternalFunction(Function *F, 150 const std::vector<GenericValue> &ArgVals); 151 void exitCalled(GenericValue GV); 152 153 void addAtExitHandler(Function *F) { 154 AtExitHandlers.push_back(F); 155 } 156 157 GenericValue *getFirstVarArg () { 158 return &(ECStack[ECStack.size () - 2].VarArgs[0]); 159 } 160 161 //FIXME: private: 162public: 163 GenericValue executeGEPOperation(Value *Ptr, gep_type_iterator I, 164 gep_type_iterator E, ExecutionContext &SF); 165 166private: // Helper functions 167 // SwitchToNewBasicBlock - Start execution in a new basic block and run any 168 // PHI nodes in the top of the block. This is used for intraprocedural 169 // control flow. 170 // 171 void SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF); 172 173 void *getPointerToFunction(Function *F) { return (void*)F; } 174 175 void initializeExecutionEngine(); 176 void initializeExternalFunctions(); 177 GenericValue getConstantExprValue(ConstantExpr *CE, ExecutionContext &SF); 178 GenericValue getOperandValue(Value *V, ExecutionContext &SF); 179 GenericValue executeCastOperation(Value *SrcVal, const Type *Ty, 180 ExecutionContext &SF); 181 void popStackAndReturnValueToCaller(const Type *RetTy, GenericValue Result); 182}; 183 184} // End llvm namespace 185 186#endif 187