Interpreter.h revision 4af6de8f0a767a3892ff7682954cbd2ae2ca3de8 
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;
29
30// AllocaHolder - Object to track all of the blocks of memory allocated by
31// alloca.  When the function returns, this object is poped off the execution
32// stack, which causes the dtor to be run, which frees all the alloca'd memory.
33//
34class AllocaHolder {
35  friend class AllocaHolderHandle;
36  std::vector<void*> Allocations;
37  unsigned RefCnt;
38public:
39  AllocaHolder() : RefCnt(0) {}
40  void add(void *mem) { Allocations.push_back(mem); }
41  ~AllocaHolder() {
42    for (unsigned i = 0; i < Allocations.size(); ++i)
43      free(Allocations[i]);
44  }
45};
46
47// AllocaHolderHandle gives AllocaHolder value semantics so we can stick it into
48// a vector...
49//
50class AllocaHolderHandle {
51  AllocaHolder *H;
52public:
53  AllocaHolderHandle() : H(new AllocaHolder()) { H->RefCnt++; }
54  AllocaHolderHandle(const AllocaHolderHandle &AH) : H(AH.H) { H->RefCnt++; }
55  ~AllocaHolderHandle() { if (--H->RefCnt == 0) delete H; }
56
57  void add(void *mem) { H->add(mem); }
58};
59
60typedef std::vector<GenericValue> ValuePlaneTy;
61
62// ExecutionContext struct - This struct represents one stack frame currently
63// executing.
64//
65struct ExecutionContext {
66  Function             *CurFunction;// The currently executing function
67  BasicBlock           *CurBB;      // The currently executing BB
68  BasicBlock::iterator  CurInst;    // The next instruction to execute
69  std::map<Value *, GenericValue> Values; // LLVM values used in this invocation
70  std::vector<GenericValue>  VarArgs; // Values passed through an ellipsis
71  CallSite             Caller;     // Holds the call that called subframes.
72                                   // NULL if main func or debugger invoked fn
73  AllocaHolderHandle    Allocas;    // Track memory allocated by alloca
74};
75
76// Interpreter - This class represents the entirety of the interpreter.
77//
78class Interpreter : public ExecutionEngine, public InstVisitor<Interpreter> {
79  int ExitCode;                // The exit code to be returned by the lli util
80  TargetData TD;
81
82  // The runtime stack of executing code.  The top of the stack is the current
83  // function record.
84  std::vector<ExecutionContext> ECStack;
85
86  // AtExitHandlers - List of functions to call when the program exits,
87  // registered with the atexit() library function.
88  std::vector<Function*> AtExitHandlers;
89
90public:
91  Interpreter(Module *M, bool isLittleEndian, bool isLongPointer);
92  inline ~Interpreter() { }
93
94  /// runAtExitHandlers - Run any functions registered by the
95  /// program's calls to atexit(3), which we intercept and store in
96  /// 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 run(Function *F,
107			   const std::vector<GenericValue> &ArgValues);
108
109  // Methods used to execute code:
110  // Place a call on the stack
111  void callFunction(Function *F, const std::vector<GenericValue> &ArgVals);
112  void run();                // Execute instructions until nothing left to do
113
114  // Opcode Implementations
115  void visitReturnInst(ReturnInst &I);
116  void visitBranchInst(BranchInst &I);
117  void visitSwitchInst(SwitchInst &I);
118
119  void visitBinaryOperator(BinaryOperator &I);
120  void visitAllocationInst(AllocationInst &I);
121  void visitFreeInst(FreeInst &I);
122  void visitLoadInst(LoadInst &I);
123  void visitStoreInst(StoreInst &I);
124  void visitGetElementPtrInst(GetElementPtrInst &I);
125  void visitPHINode(PHINode &PN) { assert(0 && "PHI nodes already handled!"); }
126  void visitCastInst(CastInst &I);
127
128  void visitCallSite(CallSite CS);
129  void visitCallInst(CallInst &I) { visitCallSite (CallSite (&I)); }
130  void visitInvokeInst(InvokeInst &I) { visitCallSite (CallSite (&I)); }
131  void visitUnwindInst(UnwindInst &I);
132
133  void visitShl(ShiftInst &I);
134  void visitShr(ShiftInst &I);
135  void visitVANextInst(VANextInst &I);
136  void visitVAArgInst(VAArgInst &I);
137  void visitInstruction(Instruction &I) {
138    std::cerr << I;
139    assert(0 && "Instruction not interpretable yet!");
140  }
141
142  GenericValue callExternalFunction(Function *F,
143                                    const std::vector<GenericValue> &ArgVals);
144  void exitCalled(GenericValue GV);
145
146  void addAtExitHandler(Function *F) {
147    AtExitHandlers.push_back(F);
148  }
149
150  GenericValue *getFirstVarArg () {
151    return &(ECStack[ECStack.size () - 2].VarArgs[0]);
152  }
153
154  //FIXME: private:
155public:
156  GenericValue executeGEPOperation(Value *Ptr, gep_type_iterator I,
157				   gep_type_iterator E, ExecutionContext &SF);
158
159private:  // Helper functions
160  // SwitchToNewBasicBlock - Start execution in a new basic block and run any
161  // PHI nodes in the top of the block.  This is used for intraprocedural
162  // control flow.
163  //
164  void SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF);
165
166  void *getPointerToFunction(Function *F) { return (void*)F; }
167
168  void initializeExecutionEngine();
169  void initializeExternalFunctions();
170  GenericValue getOperandValue(Value *V, ExecutionContext &SF);
171  GenericValue executeCastOperation(Value *SrcVal, const Type *Ty,
172				    ExecutionContext &SF);
173  void popStackAndReturnValueToCaller(const Type *RetTy, GenericValue Result);
174};
175
176} // End llvm namespace
177
178#endif
179