X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FExecutionEngine%2FInterpreter%2FInterpreter.h;h=a59ebade36fe124f743ad30c397e42f4a3952240;hb=29794cba810ec249a9ede5ea77333a71579fd182;hp=4dacf22c15fc7f389841a2de0df9459c050f71a5;hpb=cdf5178f8362b0b415a4e1c1378a5b76638826be;p=oota-llvm.git diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.h b/lib/ExecutionEngine/Interpreter/Interpreter.h index 4dacf22c15f..a59ebade36f 100644 --- a/lib/ExecutionEngine/Interpreter/Interpreter.h +++ b/lib/ExecutionEngine/Interpreter/Interpreter.h @@ -7,25 +7,17 @@ #ifndef LLI_INTERPRETER_H #define LLI_INTERPRETER_H -// Uncomment this line to enable profiling of structure field accesses. -//#define PROFILE_STRUCTURE_FIELDS 1 - #include "../ExecutionEngine.h" +#include "../GenericValue.h" #include "Support/DataTypes.h" #include "llvm/Assembly/CachedWriter.h" #include "llvm/Target/TargetData.h" #include "llvm/BasicBlock.h" -#include "../GenericValue.h" +#include "llvm/Support/InstVisitor.h" extern CachedWriter CW; // Object to accelerate printing of LLVM -struct MethodInfo; // Defined in ExecutionAnnotations.h -class CallInst; -class ReturnInst; -class BranchInst; -class LoadInst; -class StoreInst; -class AllocationInst; +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 @@ -63,14 +55,13 @@ 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 + FunctionInfo *FuncInfo; // The FuncInfo annotation for the function std::vector Values;// ValuePlanes for each type std::vector VarArgs; // Values passed through an ellipsis - 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 AllocaHolderHandle Allocas; // Track memory allocated by alloca @@ -78,10 +69,8 @@ struct ExecutionContext { // Interpreter - This class represents the entirety of the interpreter. // -class Interpreter : public ExecutionEngine { +class Interpreter : public ExecutionEngine, public InstVisitor { int ExitCode; // The exit code to be returned by the lli util - bool Debug; // Debug mode enabled? - bool Profile; // Profiling enabled? bool Trace; // Tracing enabled? int CurFrame; // The current stack frame being inspected TargetData TD; @@ -90,111 +79,89 @@ class Interpreter : public ExecutionEngine { // 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(Module *M, unsigned Config, bool DebugMode, bool TraceMode); + Interpreter(Module *M, bool isLittleEndian, bool isLongPointer, + bool TraceMode); inline ~Interpreter() { CW.setModule(0); } - // getExitCode - return the code that should be the exit code for the lli - // utility. - inline int getExitCode() const { return ExitCode; } - - /// run - Start execution with the specified function and arguments. + /// runAtExitHandlers - Run any functions registered by the + /// program's calls to atexit(3), which we intercept and store in + /// AtExitHandlers. /// - virtual int run(const std::string &FnName, - const std::vector &Args); - + void runAtExitHandlers (); - // enableProfiling() - Turn profiling on, clear stats? - void enableProfiling() { Profile = true; } - void enableTracing() { Trace = true; } + /// create - Create an interpreter ExecutionEngine. This can never fail. + /// + static ExecutionEngine *create(Module *M, bool TraceMode); - void handleUserInput(); + /// run - Start execution with the specified function and arguments. + /// + virtual GenericValue run(Function *F, + const std::vector &ArgValues); - // User Interation Methods... - 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); + // Methods used for debug printouts: static void print(const Type *Ty, GenericValue V); static void printValue(const Type *Ty, GenericValue V); - 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 + // Methods used to execute code: + // Place a call on the stack + void callFunction(Function *F, const std::vector &ArgVals); + void executeInstruction(); // Execute one instruction + void run(); // Execute instructions until nothing left to do // 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 visitReturnInst(ReturnInst &I); + void visitBranchInst(BranchInst &I); + void visitSwitchInst(SwitchInst &I); + + void visitBinaryOperator(BinaryOperator &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 visitCallInst(CallInst &I); + void visitShl(ShiftInst &I); + void visitShr(ShiftInst &I); + void visitVarArgInst(VarArgInst &I); + void visitInstruction(Instruction &I) { + std::cerr << I; + assert(0 && "Instruction not interpretable yet!"); + } + + GenericValue callExternalFunction(Function *F, + const std::vector &ArgVals); void exitCalled(GenericValue GV); - // getCurrentMethod - Return the currently executing method - inline Function *getCurrentMethod() const { - return CurFrame < 0 ? 0 : ECStack[CurFrame].CurMethod; + void addAtExitHandler(Function *F) { + AtExitHandlers.push_back(F); } - // isStopped - Return true if a program is stopped. Return false if no - // program is running. - // - inline bool isStopped() const { return !ECStack.empty(); } - //FIXME: private: public: GenericValue executeGEPOperation(Value *Ptr, User::op_iterator I, User::op_iterator E, ExecutionContext &SF); - void executeLoadInst(LoadInst &I, ExecutionContext &SF); - void executeStoreInst(StoreInst &I, ExecutionContext &SF); - private: // Helper functions - void *getPointerToFunction(const Function *F) { return (void*)F; } - - // getCurrentExecutablePath() - Return the directory that the lli executable - // lives in. - // - std::string getCurrentExecutablePath() const; - - // printCurrentInstruction - Print out the instruction that the virtual PC is - // at, or fail silently if no program is running. - // - void printCurrentInstruction(); - - // printStackFrame - Print information about the specified stack frame, or -1 - // for the default one. - // - void printStackFrame(int FrameNo = -1); - - // 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); - - // 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. - // - Value *ChooseOneOption(const std::string &Name, - const std::vector &Opts); + // 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 initializeExternalMethods(); + void initializeExternalFunctions(); + GenericValue getOperandValue(Value *V, ExecutionContext &SF); + GenericValue executeCastOperation(Value *SrcVal, const Type *Ty, + ExecutionContext &SF); }; #endif