Initial checkin of interpreter
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@361 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.h b/lib/ExecutionEngine/Interpreter/Interpreter.h
new file mode 100644
index 0000000..9ff8336
--- /dev/null
+++ b/lib/ExecutionEngine/Interpreter/Interpreter.h
@@ -0,0 +1,129 @@
+//===-- Interpreter.h ------------------------------------------*- C++ -*--===//
+//
+// This header file defines the interpreter structure
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLI_INTERPRETER_H
+#define LLI_INTERPRETER_H
+
+#include "llvm/Module.h"
+#include "llvm/Method.h"
+
+struct MethodInfo; // Defined in ExecutionAnnotations.h
+class CallInst;
+class ReturnInst;
+class BranchInst;
+
+union GenericValue {
+ bool BoolVal;
+ unsigned char UByteVal;
+ signed char SByteVal;
+ unsigned short UShortVal;
+ signed short ShortVal;
+ unsigned int UIntVal;
+ signed int IntVal;
+ double DoubleVal;
+ float FloatVal;
+ GenericValue *PointerVal;
+};
+
+typedef vector<GenericValue> ValuePlaneTy;
+
+// ExecutionContext struct - This struct represents one stack frame currently
+// executing.
+//
+struct ExecutionContext {
+ Method *CurMethod; // The currently executing method
+ BasicBlock *CurBB; // The currently executing BB
+ BasicBlock::iterator CurInst; // The next instruction to execute
+ MethodInfo *MethInfo; // The MethInfo annotation for the method
+ vector<ValuePlaneTy> 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
+};
+
+
+// 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?
+ int CurFrame; // The current stack frame being inspected
+
+ // The runtime stack of executing code. The top of the stack is the current
+ // method record.
+ vector<ExecutionContext> ECStack;
+
+public:
+ Interpreter();
+ inline ~Interpreter() { delete CurMod; }
+
+ // getExitCode - return the code that should be the exit code for the lli
+ // utility.
+ inline int getExitCode() const { return ExitCode; }
+
+ // enableProfiling() - Turn profiling on, clear stats?
+ void enableProfiling() { Profile = true; }
+
+ void initializeExecutionEngine();
+ void handleUserInput();
+
+ // User Interation Methods...
+ bool callMethod(const string &Name); // return true on failure
+ void setBreakpoint(const string &Name);
+ void printValue(const string &Name);
+ void printValue(const Type *Ty, GenericValue V);
+
+
+ void list(); // Do the 'list' command
+ void printStackTrace(); // Do the 'backtrace' command
+
+ // Code execution methods...
+ void callMethod(Method *Meth, ExecutionContext *SF = 0);
+ 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
+
+ // Opcode Implementations
+ void executeCallInst(CallInst *I, ExecutionContext &SF);
+ void executeRetInst(ReturnInst *I, ExecutionContext &SF);
+ void executeBrInst(BranchInst *I, ExecutionContext &SF);
+
+ // getCurrentMethod - Return the currently executing method
+ inline Method *getCurrentMethod() const {
+ return CurFrame < 0 ? 0 : ECStack[CurFrame].CurMethod;
+ }
+
+ // isStopped - Return true if a program is stopped. Return false if no
+ // program is running.
+ //
+ inline bool isStopped() const { return !ECStack.empty(); }
+
+private: // Helper functions
+ // 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.
+ //
+ vector<Value*> LookupMatchingNames(const 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<Value*> &Opts);
+};
+
+#endif