X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FExecutionEngine%2FInterpreter%2FInterpreter.h;h=323885002ce989c8726cc2b9cb0693024a460e2d;hb=47992ea4be0b5a357178e7f734625e9d4a27492d;hp=974aea896479e92bcafb40ba94c98ce9f9705ed7;hpb=fea483d7c027c595101dce825bdf3f512bf9aaca;p=oota-llvm.git diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.h b/lib/ExecutionEngine/Interpreter/Interpreter.h index 974aea89647..323885002ce 100644 --- a/lib/ExecutionEngine/Interpreter/Interpreter.h +++ b/lib/ExecutionEngine/Interpreter/Interpreter.h @@ -1,10 +1,10 @@ //===-- Interpreter.h ------------------------------------------*- C++ -*--===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This header file defines the interpreter structure @@ -17,15 +17,23 @@ #include "llvm/Function.h" #include "llvm/ExecutionEngine/ExecutionEngine.h" #include "llvm/ExecutionEngine/GenericValue.h" +#include "llvm/ADT/APInt.h" #include "llvm/Support/InstVisitor.h" #include "llvm/Support/CallSite.h" #include "llvm/Target/TargetData.h" -#include "Support/DataTypes.h" +#include "llvm/Support/DataTypes.h" + +namespace llvm { + +class IntrinsicLowering; +struct FunctionInfo; +template class generic_gep_type_iterator; +class ConstantExpr; +typedef generic_gep_type_iterator gep_type_iterator; -struct FunctionInfo; // Defined in ExecutionAnnotations.h // AllocaHolder - Object to track all of the blocks of memory allocated by -// alloca. When the function returns, this object is poped off the execution +// alloca. When the function returns, this object is popped off the execution // stack, which causes the dtor to be run, which frees all the alloca'd memory. // class AllocaHolder { @@ -73,8 +81,9 @@ struct ExecutionContext { // Interpreter - This class represents the entirety of the interpreter. // class Interpreter : public ExecutionEngine, public InstVisitor { - int ExitCode; // The exit code to be returned by the lli util + GenericValue ExitValue; // The return value of the called function TargetData TD; + IntrinsicLowering *IL; // The runtime stack of executing code. The top of the stack is the current // function record. @@ -85,23 +94,37 @@ class Interpreter : public ExecutionEngine, public InstVisitor { std::vector AtExitHandlers; public: - Interpreter(Module *M, bool isLittleEndian, bool isLongPointer); - inline ~Interpreter() { } + Interpreter(Module *M); + ~Interpreter(); - /// runAtExitHandlers - Run any functions registered by the - /// program's calls to atexit(3), which we intercept and store in - /// AtExitHandlers. + /// runAtExitHandlers - Run any functions registered by the program's calls to + /// atexit(3), which we intercept and store in AtExitHandlers. /// - void runAtExitHandlers (); + void runAtExitHandlers(); + static void Register() { + InterpCtor = create; + } + /// create - Create an interpreter ExecutionEngine. This can never fail. /// - static ExecutionEngine *create(Module *M); + static ExecutionEngine *create(ModuleProvider *M, std::string *ErrorStr = 0); /// run - Start execution with the specified function and arguments. /// - virtual GenericValue run(Function *F, - const std::vector &ArgValues); + virtual GenericValue runFunction(Function *F, + const std::vector &ArgValues); + + /// recompileAndRelinkFunction - For the interpreter, functions are always + /// up-to-date. + /// + virtual void *recompileAndRelinkFunction(Function *F) { + return getPointerToFunction(F); + } + + /// freeMachineCodeForFunction - The interpreter does not generate any code. + /// + void freeMachineCodeForFunction(Function *F) { } // Methods used to execute code: // Place a call on the stack @@ -114,27 +137,46 @@ public: void visitSwitchInst(SwitchInst &I); void visitBinaryOperator(BinaryOperator &I); + void visitICmpInst(ICmpInst &I); + void visitFCmpInst(FCmpInst &I); void visitAllocationInst(AllocationInst &I); void visitFreeInst(FreeInst &I); void visitLoadInst(LoadInst &I); void visitStoreInst(StoreInst &I); void visitGetElementPtrInst(GetElementPtrInst &I); void visitPHINode(PHINode &PN) { assert(0 && "PHI nodes already handled!"); } - void visitCastInst(CastInst &I); + void visitTruncInst(TruncInst &I); + void visitZExtInst(ZExtInst &I); + void visitSExtInst(SExtInst &I); + void visitFPTruncInst(FPTruncInst &I); + void visitFPExtInst(FPExtInst &I); + void visitUIToFPInst(UIToFPInst &I); + void visitSIToFPInst(SIToFPInst &I); + void visitFPToUIInst(FPToUIInst &I); + void visitFPToSIInst(FPToSIInst &I); + void visitPtrToIntInst(PtrToIntInst &I); + void visitIntToPtrInst(IntToPtrInst &I); + void visitBitCastInst(BitCastInst &I); + void visitSelectInst(SelectInst &I); + void visitCallSite(CallSite CS); void visitCallInst(CallInst &I) { visitCallSite (CallSite (&I)); } void visitInvokeInst(InvokeInst &I) { visitCallSite (CallSite (&I)); } + void visitUnwindInst(UnwindInst &I); + void visitUnreachableInst(UnreachableInst &I); + + void visitShl(BinaryOperator &I); + void visitLShr(BinaryOperator &I); + void visitAShr(BinaryOperator &I); - void visitShl(ShiftInst &I); - void visitShr(ShiftInst &I); - void visitVANextInst(VANextInst &I); + void visitVAArgInst(VAArgInst &I); void visitInstruction(Instruction &I) { - std::cerr << I; + cerr << I; assert(0 && "Instruction not interpretable yet!"); } - GenericValue callExternalFunction(Function *F, + GenericValue callExternalFunction(Function *F, const std::vector &ArgVals); void exitCalled(GenericValue GV); @@ -142,26 +184,58 @@ public: AtExitHandlers.push_back(F); } + GenericValue *getFirstVarArg () { + return &(ECStack.back ().VarArgs[0]); + } + //FIXME: private: public: - GenericValue executeGEPOperation(Value *Ptr, User::op_iterator I, - User::op_iterator E, ExecutionContext &SF); + GenericValue executeGEPOperation(Value *Ptr, gep_type_iterator I, + gep_type_iterator E, ExecutionContext &SF); private: // Helper functions // SwitchToNewBasicBlock - Start execution in a new basic block and run any // PHI nodes in the top of the block. This is used for intraprocedural // control flow. - // + // void SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF); void *getPointerToFunction(Function *F) { return (void*)F; } void initializeExecutionEngine(); void initializeExternalFunctions(); + GenericValue getConstantExprValue(ConstantExpr *CE, ExecutionContext &SF); GenericValue getOperandValue(Value *V, ExecutionContext &SF); - GenericValue executeCastOperation(Value *SrcVal, const Type *Ty, - ExecutionContext &SF); + GenericValue executeTruncInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeSExtInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeZExtInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeFPTruncInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeFPExtInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeFPToUIInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeFPToSIInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeUIToFPInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeSIToFPInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executePtrToIntInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeIntToPtrInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeBitCastInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF); + GenericValue executeCastOperation(Instruction::CastOps opcode, Value *SrcVal, + const Type *Ty, ExecutionContext &SF); void popStackAndReturnValueToCaller(const Type *RetTy, GenericValue Result); + }; +} // End llvm namespace + #endif