X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FExecutionEngine%2FInterpreter%2FInterpreter.h;h=0b01f8df58e009e72263c5f0ea63f4618b51df4e;hb=da82ed52ac02497d343b898cca0bb2cf303f062d;hp=5b123466aa6eebff34121cb131c7110a4d6bc1fd;hpb=204eec3f57aedd703fb73db78ac2b4087caf9f07;p=oota-llvm.git diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.h b/lib/ExecutionEngine/Interpreter/Interpreter.h index 5b123466aa6..0b01f8df58e 100644 --- a/lib/ExecutionEngine/Interpreter/Interpreter.h +++ b/lib/ExecutionEngine/Interpreter/Interpreter.h @@ -7,95 +7,125 @@ #ifndef LLI_INTERPRETER_H #define LLI_INTERPRETER_H -#include "llvm/Module.h" -#include "llvm/Method.h" -#include "llvm/Support/DataTypes.h" +// Uncomment this line to enable profiling of structure field accesses. +//#define PROFILE_STRUCTURE_FIELDS 1 -struct MethodInfo; // Defined in ExecutionAnnotations.h +#include "../ExecutionEngine.h" +#include "Support/DataTypes.h" +#include "llvm/Assembly/CachedWriter.h" +#include "llvm/Target/TargetData.h" +#include "llvm/BasicBlock.h" +#include "../GenericValue.h" + +extern CachedWriter CW; // Object to accelerate printing of LLVM + +struct FunctionInfo; // Defined in ExecutionAnnotations.h class CallInst; class ReturnInst; class BranchInst; +class LoadInst; +class StoreInst; class AllocationInst; -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; - GenericValue *PointerVal; +// AllocaHolder - Object to track all of the blocks of memory allocated by +// alloca. When the function returns, this object is poped off the execution +// stack, which causes the dtor to be run, which frees all the alloca'd memory. +// +class AllocaHolder { + friend class AllocaHolderHandle; + std::vector Allocations; + unsigned RefCnt; +public: + AllocaHolder() : RefCnt(0) {} + void add(void *mem) { Allocations.push_back(mem); } + ~AllocaHolder() { + for (unsigned i = 0; i < Allocations.size(); ++i) + free(Allocations[i]); + } }; -typedef vector ValuePlaneTy; +// AllocaHolderHandle gives AllocaHolder value semantics so we can stick it into +// a vector... +// +class AllocaHolderHandle { + AllocaHolder *H; +public: + AllocaHolderHandle() : H(new AllocaHolder()) { H->RefCnt++; } + AllocaHolderHandle(const AllocaHolderHandle &AH) : H(AH.H) { H->RefCnt++; } + ~AllocaHolderHandle() { if (--H->RefCnt == 0) delete H; } + + void add(void *mem) { H->add(mem); } +}; + +typedef std::vector ValuePlaneTy; // ExecutionContext struct - This struct represents one stack frame currently // executing. // struct ExecutionContext { - Method *CurMethod; // The currently executing method + 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 method - vector Values; // ValuePlanes for each type + 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 }; - // Interpreter - This class represents the entirety of the interpreter. // -class Interpreter { - Module *CurMod; // The current Module being executed (0 if none) +class Interpreter : public ExecutionEngine { 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; // The runtime stack of executing code. The top of the stack is the current - // method record. - vector ECStack; + // function record. + std::vector ECStack; public: - Interpreter(); - inline ~Interpreter() { delete CurMod; } + Interpreter(Module *M, unsigned Config, bool DebugMode, 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. + /// + virtual int run(const std::string &FnName, + const std::vector &Args); + + // enableProfiling() - Turn profiling on, clear stats? void enableProfiling() { Profile = true; } + void enableTracing() { Trace = true; } - void initializeExecutionEngine(); void handleUserInput(); // User Interation Methods... - void loadModule(const string &Filename); - bool flushModule(); - bool callMethod(const string &Name); // return true on failure - void setBreakpoint(const string &Name); - void infoValue(const string &Name); - void print(const string &Name); + bool callFunction(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 string &MainName, - const vector &InputFilename); + bool callMainFunction(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 (Method *Meth, const vector &ArgVals); - void callExternalMethod(Method *Meth, const vector &ArgVals); + void callFunction(Function *F, const std::vector &ArgVals); bool executeInstruction(); // Execute one instruction... void stepInstruction(); // Do the 'step' command @@ -104,15 +134,17 @@ public: void finish(); // Do the 'finish' command // 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); + 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 callExternalFunction(Function *F, + const std::vector &ArgVals); void exitCalled(GenericValue GV); - // getCurrentMethod - Return the currently executing method - inline Method *getCurrentMethod() const { - return CurFrame < 0 ? 0 : ECStack[CurFrame].CurMethod; + // getCurrentFunction - Return the currently executing function + inline Function *getCurrentFunction() const { + return CurFrame < 0 ? 0 : ECStack[CurFrame].CurFunction; } // isStopped - Return true if a program is stopped. Return false if no @@ -120,29 +152,49 @@ public: // 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. // - string getCurrentExecutablePath() const; + 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(); - // LookupMatchingNames - Search the current method 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. + // printStackFrame - Print information about the specified stack frame, or -1 + // for the default one. // - vector LookupMatchingNames(const string &Name); + 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 string &Name, const vector &Opts); + Value *ChooseOneOption(const std::string &Name, + const std::vector &Opts); + + + void initializeExecutionEngine(); + void initializeExternalFunctions(); }; #endif