X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FExecutionEngine%2FInterpreter%2FInterpreter.h;h=323885002ce989c8726cc2b9cb0693024a460e2d;hb=47992ea4be0b5a357178e7f734625e9d4a27492d;hp=a02a0abd05c08bf4f9fd94c778571be02e2599ec;hpb=fddc755a6f6042457b04d1c070e2a032add56b39;p=oota-llvm.git diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.h b/lib/ExecutionEngine/Interpreter/Interpreter.h index a02a0abd05c..323885002ce 100644 --- a/lib/ExecutionEngine/Interpreter/Interpreter.h +++ b/lib/ExecutionEngine/Interpreter/Interpreter.h @@ -1,5 +1,12 @@ //===-- 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 // //===----------------------------------------------------------------------===// @@ -7,41 +14,26 @@ #ifndef LLI_INTERPRETER_H #define LLI_INTERPRETER_H -// Uncomment this line to enable profiling of structure field accesses. -//#define PROFILE_STRUCTURE_FIELDS 1 - -#include "llvm/Module.h" -#include "Support/DataTypes.h" -#include "llvm/Assembly/CachedWriter.h" - -extern CachedWriter CW; // Object to accellerate printing of LLVM - -struct MethodInfo; // Defined in ExecutionAnnotations.h -class CallInst; -class ReturnInst; -class BranchInst; -class AllocationInst; - -typedef uint64_t PointerTy; - -union GenericValue { - bool BoolVal; - unsigned char UByteVal; - signed char SByteVal; - unsigned short UShortVal; - signed short ShortVal; - unsigned int UIntVal; - signed int IntVal; - uint64_t ULongVal; - int64_t LongVal; - double DoubleVal; - float FloatVal; - PointerTy PointerVal; - unsigned char Untyped[8]; -}; +#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 "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; + // 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 { @@ -76,124 +68,174 @@ typedef std::vector ValuePlaneTy; // executing. // struct ExecutionContext { - Function *CurMethod; // The currently executing function + Function *CurFunction;// The currently executing function BasicBlock *CurBB; // The currently executing BB BasicBlock::iterator CurInst; // The next instruction to execute - MethodInfo *MethInfo; // The MethInfo annotation for the function - std::vector Values;// ValuePlanes for each type - - BasicBlock *PrevBB; // The previous BB or null if in first BB - CallInst *Caller; // Holds the call that called subframes. - // NULL if main func or debugger invoked fn + std::map Values; // LLVM values used in this invocation + std::vector VarArgs; // Values passed through an ellipsis + CallSite Caller; // Holds the call that called subframes. + // NULL if main func or debugger invoked fn AllocaHolderHandle Allocas; // Track memory allocated by alloca }; // Interpreter - This class represents the entirety of the interpreter. // -class Interpreter { - Module *CurMod; // The current Module being executed (0 if none) - int ExitCode; // The exit code to be returned by the lli util - bool Profile; // Profiling enabled? - bool Trace; // Tracing enabled? - int CurFrame; // The current stack frame being inspected +class Interpreter : public ExecutionEngine, public InstVisitor { + 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. std::vector ECStack; + // AtExitHandlers - List of functions to call when the program exits, + // registered with the atexit() library function. + std::vector AtExitHandlers; + public: - Interpreter(); - inline ~Interpreter() { CW.setModule(0); delete CurMod; } - - // getExitCode - return the code that should be the exit code for the lli - // utility. - inline int getExitCode() const { return ExitCode; } - inline Module *getModule() const { return CurMod; } - - // enableProfiling() - Turn profiling on, clear stats? - void enableProfiling() { Profile = true; } - void enableTracing() { Trace = true; } - - void handleUserInput(); - - // User Interation Methods... - void loadModule(const std::string &Filename); - bool flushModule(); - bool callMethod(const std::string &Name); // return true on failure - void setBreakpoint(const std::string &Name); - void infoValue(const std::string &Name); - void print(const std::string &Name); - static void print(const Type *Ty, GenericValue V); - static void printValue(const Type *Ty, GenericValue V); - - // Hack until we can parse command line args... - bool callMainMethod(const std::string &MainName, - const std::vector &InputFilename); - - void list(); // Do the 'list' command - void printStackTrace(); // Do the 'backtrace' command - - // Code execution methods... - void callMethod(Function *F, const std::vector &ArgVals); - bool executeInstruction(); // Execute one instruction... - - void stepInstruction(); // Do the 'step' command - void nextInstruction(); // Do the 'next' command - void run(); // Do the 'run' command - void finish(); // Do the 'finish' command + Interpreter(Module *M); + ~Interpreter(); - // Opcode Implementations - void executeCallInst(CallInst &I, ExecutionContext &SF); - void executeRetInst(ReturnInst &I, ExecutionContext &SF); - void executeBrInst(BranchInst &I, ExecutionContext &SF); - void executeAllocInst(AllocationInst &I, ExecutionContext &SF); - GenericValue callExternalMethod(Function *F, - const std::vector &ArgVals); - void exitCalled(GenericValue GV); + /// runAtExitHandlers - Run any functions registered by the program's calls to + /// atexit(3), which we intercept and store in AtExitHandlers. + /// + void runAtExitHandlers(); - // getCurrentMethod - Return the currently executing method - inline Function *getCurrentMethod() const { - return CurFrame < 0 ? 0 : ECStack[CurFrame].CurMethod; + static void Register() { + InterpCtor = create; + } + + /// create - Create an interpreter ExecutionEngine. This can never fail. + /// + static ExecutionEngine *create(ModuleProvider *M, std::string *ErrorStr = 0); + + /// run - Start execution with the specified function and arguments. + /// + 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); } - // isStopped - Return true if a program is stopped. Return false if no - // program is running. - // - inline bool isStopped() const { return !ECStack.empty(); } + /// freeMachineCodeForFunction - The interpreter does not generate any code. + /// + void freeMachineCodeForFunction(Function *F) { } -private: // Helper functions - // getCurrentExecutablePath() - Return the directory that the lli executable - // lives in. - // - std::string getCurrentExecutablePath() const; + // Methods used to execute code: + // Place a call on the stack + void callFunction(Function *F, const std::vector &ArgVals); + void run(); // Execute instructions until nothing left to do - // printCurrentInstruction - Print out the instruction that the virtual PC is - // at, or fail silently if no program is running. - // - void printCurrentInstruction(); + // Opcode Implementations + void visitReturnInst(ReturnInst &I); + void visitBranchInst(BranchInst &I); + 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 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 visitVAArgInst(VAArgInst &I); + void visitInstruction(Instruction &I) { + cerr << I; + assert(0 && "Instruction not interpretable yet!"); + } - // printStackFrame - Print information about the specified stack frame, or -1 - // for the default one. - // - void printStackFrame(int FrameNo = -1); + GenericValue callExternalFunction(Function *F, + const std::vector &ArgVals); + void exitCalled(GenericValue GV); - // LookupMatchingNames - Search the current function namespace, then the - // global namespace looking for values that match the specified name. Return - // ALL matches to that name. This is obviously slow, and should only be used - // for user interaction. - // - std::vector LookupMatchingNames(const std::string &Name); + void addAtExitHandler(Function *F) { + AtExitHandlers.push_back(F); + } - // ChooseOneOption - Prompt the user to choose among the specified options to - // pick one value. If no options are provided, emit an error. If a single - // option is provided, just return that option. + GenericValue *getFirstVarArg () { + return &(ECStack.back ().VarArgs[0]); + } + + //FIXME: private: +public: + 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. // - Value *ChooseOneOption(const std::string &Name, - const std::vector &Opts); + void SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF); + void *getPointerToFunction(Function *F) { return (void*)F; } void initializeExecutionEngine(); - void initializeExternalMethods(); + void initializeExternalFunctions(); + GenericValue getConstantExprValue(ConstantExpr *CE, ExecutionContext &SF); + GenericValue getOperandValue(Value *V, 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