lib/ExecutionEngine/Interpreter/Interpreter.h

   1 //===-- Interpreter.h ------------------------------------------*- C++ -*--===//
   2 //
   3 // This header file defines the interpreter structure
   4 //
   5 //===----------------------------------------------------------------------===//
   6
   7 #ifndef LLI_INTERPRETER_H
   8 #define LLI_INTERPRETER_H
   9
  10 // Uncomment this line to enable profiling of structure field accesses.
  11 #define PROFILE_STRUCTURE_FIELDS 1
  12
  13
  14 #include "llvm/Module.h"
  15 #include "llvm/Method.h"
  16 #include "llvm/BasicBlock.h"
  17 #include "Support/DataTypes.h"
  18 #include "llvm/Assembly/CachedWriter.h"
  19
  20 extern CachedWriter CW;     // Object to accellerate printing of LLVM
  21
  22 struct MethodInfo;          // Defined in ExecutionAnnotations.h
  23 class CallInst;
  24 class ReturnInst;
  25 class BranchInst;
  26 class AllocationInst;
  27
  28 typedef uint64_t PointerTy;
  29
  30 union GenericValue {
  31   bool            BoolVal;
  32   unsigned char   UByteVal;
  33   signed   char   SByteVal;
  34   unsigned short  UShortVal;
  35   signed   short  ShortVal;
  36   unsigned int    UIntVal;
  37   signed   int    IntVal;
  38   uint64_t        ULongVal;
  39   int64_t         LongVal;
  40   double          DoubleVal;
  41   float           FloatVal;
  42   PointerTy       PointerVal;
  43 };
  44
  45 typedef std::vector<GenericValue> ValuePlaneTy;
  46
  47 // ExecutionContext struct - This struct represents one stack frame currently
  48 // executing.
  49 //
  50 struct ExecutionContext {
  51   Method               *CurMethod;  // The currently executing method
  52   BasicBlock           *CurBB;      // The currently executing BB
  53   BasicBlock::iterator  CurInst;    // The next instruction to execute
  54   MethodInfo           *MethInfo;   // The MethInfo annotation for the method
  55   std::vector<ValuePlaneTy>  Values;// ValuePlanes for each type
  56
  57   BasicBlock           *PrevBB;     // The previous BB or null if in first BB
  58   CallInst             *Caller;     // Holds the call that called subframes.
  59                                     // NULL if main func or debugger invoked fn
  60 };
  61
  62 // Interpreter - This class represents the entirety of the interpreter.
  63 //
  64 class Interpreter {
  65   Module *CurMod;              // The current Module being executed (0 if none)
  66   int ExitCode;                // The exit code to be returned by the lli util
  67   bool Profile;                // Profiling enabled?
  68   bool Trace;                  // Tracing enabled?
  69   int CurFrame;                // The current stack frame being inspected
  70
  71   // The runtime stack of executing code.  The top of the stack is the current
  72   // method record.
  73   std::vector<ExecutionContext> ECStack;
  74
  75 public:
  76   Interpreter();
  77   inline ~Interpreter() { CW.setModule(0); delete CurMod; }
  78
  79   // getExitCode - return the code that should be the exit code for the lli
  80   // utility.
  81   inline int getExitCode() const { return ExitCode; }
  82
  83   // enableProfiling() - Turn profiling on, clear stats?
  84   void enableProfiling() { Profile = true; }
  85   void enableTracing() { Trace = true; }
  86
  87   void handleUserInput();
  88
  89   // User Interation Methods...
  90   void loadModule(const std::string &Filename);
  91   bool flushModule();
  92   bool callMethod(const std::string &Name);      // return true on failure
  93   void setBreakpoint(const std::string &Name);
  94   void infoValue(const std::string &Name);
  95   void print(const std::string &Name);
  96   static void print(const Type *Ty, GenericValue V);
  97   static void printValue(const Type *Ty, GenericValue V);
  98
  99   // Hack until we can parse command line args...
 100   bool callMainMethod(const std::string &MainName,
 101                       const std::vector<std::string> &InputFilename);
 102
 103   void list();             // Do the 'list' command
 104   void printStackTrace();  // Do the 'backtrace' command
 105
 106   // Code execution methods...
 107   void callMethod(Method *Meth, const std::vector<GenericValue> &ArgVals);
 108   bool executeInstruction(); // Execute one instruction...
 109
 110   void stepInstruction();  // Do the 'step' command
 111   void nextInstruction();  // Do the 'next' command
 112   void run();              // Do the 'run' command
 113   void finish();           // Do the 'finish' command
 114
 115   // Opcode Implementations
 116   void executeCallInst(CallInst *I, ExecutionContext &SF);
 117   void executeRetInst(ReturnInst *I, ExecutionContext &SF);
 118   void executeBrInst(BranchInst *I, ExecutionContext &SF);
 119   void executeAllocInst(AllocationInst *I, ExecutionContext &SF);
 120   GenericValue callExternalMethod(Method *Meth,
 121                                   const std::vector<GenericValue> &ArgVals);
 122   void exitCalled(GenericValue GV);
 123
 124   // getCurrentMethod - Return the currently executing method
 125   inline Method *getCurrentMethod() const {
 126     return CurFrame < 0 ? 0 : ECStack[CurFrame].CurMethod;
 127   }
 128
 129   // isStopped - Return true if a program is stopped.  Return false if no
 130   // program is running.
 131   //
 132   inline bool isStopped() const { return !ECStack.empty(); }
 133
 134 private:  // Helper functions
 135   // getCurrentExecutablePath() - Return the directory that the lli executable
 136   // lives in.
 137   //
 138   std::string getCurrentExecutablePath() const;
 139
 140   // printCurrentInstruction - Print out the instruction that the virtual PC is
 141   // at, or fail silently if no program is running.
 142   //
 143   void printCurrentInstruction();
 144
 145   // printStackFrame - Print information about the specified stack frame, or -1
 146   // for the default one.
 147   //
 148   void printStackFrame(int FrameNo = -1);
 149
 150   // LookupMatchingNames - Search the current method namespace, then the global
 151   // namespace looking for values that match the specified name.  Return ALL
 152   // matches to that name.  This is obviously slow, and should only be used for
 153   // user interaction.
 154   //
 155   std::vector<Value*> LookupMatchingNames(const std::string &Name);
 156
 157   // ChooseOneOption - Prompt the user to choose among the specified options to
 158   // pick one value.  If no options are provided, emit an error.  If a single
 159   // option is provided, just return that option.
 160   //
 161   Value *ChooseOneOption(const std::string &Name,
 162                          const std::vector<Value*> &Opts);
 163
 164
 165   void initializeExecutionEngine();
 166   void initializeExternalMethods();
 167 };
 168
 169 #endif