Initial checkin of new LLI with JIT compiler

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@5126 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 126 insertions, 0 deletions

diff --git a/include/llvm/ExecutionEngine/ExecutionEngine.h b/include/llvm/ExecutionEngine/ExecutionEngine.h
new file mode 100644
index 0000000..57eee95
--- /dev/null
+++ b/include/llvm/ExecutionEngine/ExecutionEngine.h
@@ -0,0 +1,86 @@
+//===- ExecutionEngine.h - Abstract Execution Engine Interface --*- C++ -*-===//
+//
+// This file defines the abstract interface that implements execution support
+// for LLVM.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef EXECUTION_ENGINE_H
+#define EXECUTION_ENGINE_H
+
+#include <vector>
+#include <string>
+#include <map>
+class Constant;
+class Type;
+class GlobalValue;
+class Function;
+class Module;
+class TargetData;
+union GenericValue;
+
+class ExecutionEngine {
+  Module &CurMod;
+  const TargetData *TD;
+
+protected:
+  // GlobalAddress - A mapping between LLVM global values and their actualized
+  // version...
+  std::map<const GlobalValue*, void *> GlobalAddress;
+
+  void setTargetData(const TargetData &td) {
+    TD = &td;
+    emitGlobals();
+  }
+public:
+  ExecutionEngine(Module *M) : CurMod(*M) {
+    assert(M && "Module is null?");
+  }
+  virtual ~ExecutionEngine();
+  
+  Module &getModule() const { return CurMod; }
+  const TargetData &getTargetData() const { return *TD; }
+
+  /// run - Start execution with the specified function and arguments.
+  ///
+  virtual int run(const std::string &FnName,
+		  const std::vector<std::string> &Args) = 0;
+
+  /// createJIT - Create an return a new JIT compiler if there is one available
+  /// for the current target.  Otherwise it returns null.
+  ///
+  static ExecutionEngine *createJIT(Module *M, unsigned Config);
+
+  /// createInterpreter - Create a new interpreter object.  This can never fail.
+  ///
+  static ExecutionEngine *createInterpreter(Module *M, unsigned Config,
+					    bool DebugMode, bool TraceMode);
+
+  void addGlobalMapping(const Function *F, void *Addr) {
+    void *&CurVal = GlobalAddress[(const GlobalValue*)F];
+    assert(CurVal == 0 && "GlobalMapping already established!");
+    CurVal = Addr;
+  }
+
+  // getPointerToGlobal - This returns the address of the specified global
+  // value.  This may involve code generation if it's a function.
+  //
+  void *getPointerToGlobal(const GlobalValue *GV);
+
+  // getPointerToFunction - The different EE's represent function bodies in
+  // different ways.  They should each implement this to say what a function
+  // pointer should look like.
+  //
+  virtual void *getPointerToFunction(const Function *F) = 0;
+
+private:
+  void emitGlobals();
+
+public:   // FIXME: protected:   // API shared among subclasses
+  GenericValue getConstantValue(const Constant *C);
+  void StoreValueToMemory(GenericValue Val, GenericValue *Ptr, const Type *Ty);
+  void *CreateArgv(const std::vector<std::string> &InputArgv);
+  void InitializeMemory(const Constant *Init, void *Addr);
+};
+
+#endif
diff --git a/include/llvm/ExecutionEngine/GenericValue.h b/include/llvm/ExecutionEngine/GenericValue.h
new file mode 100644
index 0000000..f5e70e5
--- /dev/null
+++ b/include/llvm/ExecutionEngine/GenericValue.h
@@ -0,0 +1,40 @@
+//===-- GenericValue.h - Represent any type of LLVM value -------*- C++ -*-===//
+// 
+// The GenericValue class is used to represent an LLVM value of arbitrary type.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef GENERIC_VALUE_H
+#define GENERIC_VALUE_H
+
+#include "Support/DataTypes.h"
+
+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];
+
+  GenericValue() {}
+  GenericValue(void *V) {
+    PointerVal = (PointerTy)(intptr_t)V;
+  }
+};
+
+inline GenericValue PTOGV(void *P) { return GenericValue(P); }
+inline void* GVTOP(const GenericValue &GV) {
+  return (void*)(intptr_t)GV.PointerVal;
+}
+#endif