Line data Source code
1 : //===-- Interpreter.h ------------------------------------------*- C++ -*--===//
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 header file defines the interpreter structure
11 : //
12 : //===----------------------------------------------------------------------===//
13 :
14 : #ifndef LLVM_LIB_EXECUTIONENGINE_INTERPRETER_INTERPRETER_H
15 : #define LLVM_LIB_EXECUTIONENGINE_INTERPRETER_INTERPRETER_H
16 :
17 : #include "llvm/ExecutionEngine/ExecutionEngine.h"
18 : #include "llvm/ExecutionEngine/GenericValue.h"
19 : #include "llvm/IR/CallSite.h"
20 : #include "llvm/IR/DataLayout.h"
21 : #include "llvm/IR/Function.h"
22 : #include "llvm/IR/InstVisitor.h"
23 : #include "llvm/Support/DataTypes.h"
24 : #include "llvm/Support/ErrorHandling.h"
25 : #include "llvm/Support/raw_ostream.h"
26 : namespace llvm {
27 :
28 : class IntrinsicLowering;
29 : template<typename T> class generic_gep_type_iterator;
30 : class ConstantExpr;
31 : typedef generic_gep_type_iterator<User::const_op_iterator> gep_type_iterator;
32 :
33 :
34 : // AllocaHolder - Object to track all of the blocks of memory allocated by
35 : // alloca. When the function returns, this object is popped off the execution
36 : // stack, which causes the dtor to be run, which frees all the alloca'd memory.
37 : //
38 : class AllocaHolder {
39 : std::vector<void *> Allocations;
40 :
41 : public:
42 : AllocaHolder() {}
43 :
44 : // Make this type move-only.
45 : AllocaHolder(AllocaHolder &&) = default;
46 : AllocaHolder &operator=(AllocaHolder &&RHS) = default;
47 :
48 81 : ~AllocaHolder() {
49 112 : for (void *Allocation : Allocations)
50 31 : free(Allocation);
51 81 : }
52 :
53 31 : void add(void *Mem) { Allocations.push_back(Mem); }
54 : };
55 :
56 : typedef std::vector<GenericValue> ValuePlaneTy;
57 :
58 : // ExecutionContext struct - This struct represents one stack frame currently
59 : // executing.
60 : //
61 : struct ExecutionContext {
62 : Function *CurFunction;// The currently executing function
63 : BasicBlock *CurBB; // The currently executing BB
64 : BasicBlock::iterator CurInst; // The next instruction to execute
65 : CallSite Caller; // Holds the call that called subframes.
66 : // NULL if main func or debugger invoked fn
67 : std::map<Value *, GenericValue> Values; // LLVM values used in this invocation
68 : std::vector<GenericValue> VarArgs; // Values passed through an ellipsis
69 : AllocaHolder Allocas; // Track memory allocated by alloca
70 :
71 72 : ExecutionContext() : CurFunction(nullptr), CurBB(nullptr), CurInst(nullptr) {}
72 : };
73 :
74 : // Interpreter - This class represents the entirety of the interpreter.
75 : //
76 : class Interpreter : public ExecutionEngine, public InstVisitor<Interpreter> {
77 : GenericValue ExitValue; // The return value of the called function
78 : IntrinsicLowering *IL;
79 :
80 : // The runtime stack of executing code. The top of the stack is the current
81 : // function record.
82 : std::vector<ExecutionContext> ECStack;
83 :
84 : // AtExitHandlers - List of functions to call when the program exits,
85 : // registered with the atexit() library function.
86 : std::vector<Function*> AtExitHandlers;
87 :
88 : public:
89 : explicit Interpreter(std::unique_ptr<Module> M);
90 : ~Interpreter() override;
91 :
92 : /// runAtExitHandlers - Run any functions registered by the program's calls to
93 : /// atexit(3), which we intercept and store in AtExitHandlers.
94 : ///
95 : void runAtExitHandlers();
96 :
97 : static void Register() {
98 0 : InterpCtor = create;
99 : }
100 :
101 : /// Create an interpreter ExecutionEngine.
102 : ///
103 : static ExecutionEngine *create(std::unique_ptr<Module> M,
104 : std::string *ErrorStr = nullptr);
105 :
106 : /// run - Start execution with the specified function and arguments.
107 : ///
108 : GenericValue runFunction(Function *F,
109 : ArrayRef<GenericValue> ArgValues) override;
110 :
111 0 : void *getPointerToNamedFunction(StringRef Name,
112 : bool AbortOnFailure = true) override {
113 : // FIXME: not implemented.
114 0 : return nullptr;
115 : }
116 :
117 : // Methods used to execute code:
118 : // Place a call on the stack
119 : void callFunction(Function *F, ArrayRef<GenericValue> ArgVals);
120 : void run(); // Execute instructions until nothing left to do
121 :
122 : // Opcode Implementations
123 : void visitReturnInst(ReturnInst &I);
124 : void visitBranchInst(BranchInst &I);
125 : void visitSwitchInst(SwitchInst &I);
126 : void visitIndirectBrInst(IndirectBrInst &I);
127 :
128 : void visitBinaryOperator(BinaryOperator &I);
129 : void visitICmpInst(ICmpInst &I);
130 : void visitFCmpInst(FCmpInst &I);
131 : void visitAllocaInst(AllocaInst &I);
132 : void visitLoadInst(LoadInst &I);
133 : void visitStoreInst(StoreInst &I);
134 : void visitGetElementPtrInst(GetElementPtrInst &I);
135 0 : void visitPHINode(PHINode &PN) {
136 0 : llvm_unreachable("PHI nodes already handled!");
137 : }
138 : void visitTruncInst(TruncInst &I);
139 : void visitZExtInst(ZExtInst &I);
140 : void visitSExtInst(SExtInst &I);
141 : void visitFPTruncInst(FPTruncInst &I);
142 : void visitFPExtInst(FPExtInst &I);
143 : void visitUIToFPInst(UIToFPInst &I);
144 : void visitSIToFPInst(SIToFPInst &I);
145 : void visitFPToUIInst(FPToUIInst &I);
146 : void visitFPToSIInst(FPToSIInst &I);
147 : void visitPtrToIntInst(PtrToIntInst &I);
148 : void visitIntToPtrInst(IntToPtrInst &I);
149 : void visitBitCastInst(BitCastInst &I);
150 : void visitSelectInst(SelectInst &I);
151 :
152 :
153 : void visitCallSite(CallSite CS);
154 54 : void visitCallInst(CallInst &I) { visitCallSite (CallSite (&I)); }
155 0 : void visitInvokeInst(InvokeInst &I) { visitCallSite (CallSite (&I)); }
156 : void visitUnreachableInst(UnreachableInst &I);
157 :
158 : void visitShl(BinaryOperator &I);
159 : void visitLShr(BinaryOperator &I);
160 : void visitAShr(BinaryOperator &I);
161 :
162 : void visitVAArgInst(VAArgInst &I);
163 : void visitExtractElementInst(ExtractElementInst &I);
164 : void visitInsertElementInst(InsertElementInst &I);
165 : void visitShuffleVectorInst(ShuffleVectorInst &I);
166 :
167 : void visitExtractValueInst(ExtractValueInst &I);
168 : void visitInsertValueInst(InsertValueInst &I);
169 :
170 0 : void visitInstruction(Instruction &I) {
171 0 : errs() << I << "\n";
172 0 : llvm_unreachable("Instruction not interpretable yet!");
173 : }
174 :
175 : GenericValue callExternalFunction(Function *F,
176 : ArrayRef<GenericValue> ArgVals);
177 : void exitCalled(GenericValue GV);
178 :
179 : void addAtExitHandler(Function *F) {
180 0 : AtExitHandlers.push_back(F);
181 : }
182 :
183 : GenericValue *getFirstVarArg () {
184 : return &(ECStack.back ().VarArgs[0]);
185 : }
186 :
187 : private: // Helper functions
188 : GenericValue executeGEPOperation(Value *Ptr, gep_type_iterator I,
189 : gep_type_iterator E, ExecutionContext &SF);
190 :
191 : // SwitchToNewBasicBlock - Start execution in a new basic block and run any
192 : // PHI nodes in the top of the block. This is used for intraprocedural
193 : // control flow.
194 : //
195 : void SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF);
196 :
197 53 : void *getPointerToFunction(Function *F) override { return (void*)F; }
198 :
199 0 : void initializeExecutionEngine() { }
200 : void initializeExternalFunctions();
201 : GenericValue getConstantExprValue(ConstantExpr *CE, ExecutionContext &SF);
202 : GenericValue getOperandValue(Value *V, ExecutionContext &SF);
203 : GenericValue executeTruncInst(Value *SrcVal, Type *DstTy,
204 : ExecutionContext &SF);
205 : GenericValue executeSExtInst(Value *SrcVal, Type *DstTy,
206 : ExecutionContext &SF);
207 : GenericValue executeZExtInst(Value *SrcVal, Type *DstTy,
208 : ExecutionContext &SF);
209 : GenericValue executeFPTruncInst(Value *SrcVal, Type *DstTy,
210 : ExecutionContext &SF);
211 : GenericValue executeFPExtInst(Value *SrcVal, Type *DstTy,
212 : ExecutionContext &SF);
213 : GenericValue executeFPToUIInst(Value *SrcVal, Type *DstTy,
214 : ExecutionContext &SF);
215 : GenericValue executeFPToSIInst(Value *SrcVal, Type *DstTy,
216 : ExecutionContext &SF);
217 : GenericValue executeUIToFPInst(Value *SrcVal, Type *DstTy,
218 : ExecutionContext &SF);
219 : GenericValue executeSIToFPInst(Value *SrcVal, Type *DstTy,
220 : ExecutionContext &SF);
221 : GenericValue executePtrToIntInst(Value *SrcVal, Type *DstTy,
222 : ExecutionContext &SF);
223 : GenericValue executeIntToPtrInst(Value *SrcVal, Type *DstTy,
224 : ExecutionContext &SF);
225 : GenericValue executeBitCastInst(Value *SrcVal, Type *DstTy,
226 : ExecutionContext &SF);
227 : GenericValue executeCastOperation(Instruction::CastOps opcode, Value *SrcVal,
228 : Type *Ty, ExecutionContext &SF);
229 : void popStackAndReturnValueToCaller(Type *RetTy, GenericValue Result);
230 :
231 : };
232 :
233 : } // End llvm namespace
234 :
235 : #endif
|
