LCOV - code coverage report
Current view: top level - lib/ExecutionEngine/Interpreter - Interpreter.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 12 20 60.0 %
Date: 2017-09-14 15:23:50 Functions: 4 6 66.7 %
Legend: Lines: hit not hit

          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         122 :   AllocaHolder() {}
      43             : 
      44             :   // Make this type move-only.
      45          14 :   AllocaHolder(AllocaHolder &&) = default;
      46             :   AllocaHolder &operator=(AllocaHolder &&RHS) = default;
      47             : 
      48         204 :   ~AllocaHolder() {
      49         303 :     for (void *Allocation : Allocations)
      50          31 :       free(Allocation);
      51          68 :   }
      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         164 : 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         366 :   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       72306 :     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             :   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          41 :   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          44 :   void *getPointerToFunction(Function *F) override { return (void*)F; }
     198             : 
     199             :   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

Generated by: LCOV version 1.13