Make JIT::runFunction handle functions with non-C calling conventions.

[oota-llvm.git] / lib / ExecutionEngine / JIT / JIT.h

diff --git a/lib/ExecutionEngine/JIT/JIT.h b/lib/ExecutionEngine/JIT/JIT.h
index fbdcf2e636ac7e278800f1897d0abe999d204ec4..2eee2e980ce88112b369201cc7b68f5ef76df519 100644 (file)
--- a/lib/ExecutionEngine/JIT/JIT.h
+++ b/lib/ExecutionEngine/JIT/JIT.h
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -16,7 +16,6 @@
 
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/PassManager.h"
-#include <map>
 
 namespace llvm {
 
@@ -37,13 +36,13 @@ private:
   std::vector<const GlobalVariable*> PendingGlobals;
 
 public:
-  JITState(ModuleProvider *MP) : PM(MP) {}
+  explicit JITState(ModuleProvider *MP) : PM(MP) {}
 
-  FunctionPassManager& getPM(const MutexGuard& locked) {
+  FunctionPassManager &getPM(const MutexGuard &L) {
     return PM;
   }
 
-  std::vector<const GlobalVariable*>& getPendingGlobals(const MutexGuard& locked) {
+  std::vector<const GlobalVariable*> &getPendingGlobals(const MutexGuard &L) {
     return PendingGlobals;
   }
 };
@@ -54,9 +53,10 @@ class JIT : public ExecutionEngine {
   TargetJITInfo &TJI;      // The JITInfo for the target we are compiling to
   MachineCodeEmitter *MCE; // MCE object
 
-  JITState state;
+  JITState *jitstate;
 
-  JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji);
+  JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji, 
+      JITMemoryManager *JMM, bool Fast);
 public:
   ~JIT();
 
@@ -71,9 +71,16 @@ public:
   /// create - Create an return a new JIT compiler if there is one available
   /// for the current target.  Otherwise, return null.
   ///
-  static ExecutionEngine *create(ModuleProvider *MP);
+  static ExecutionEngine *create(ModuleProvider *MP, std::string *Err,
+                                 bool Fast = false) {
+    return createJIT(MP, Err, 0, Fast);
+  }
+
+  virtual void addModuleProvider(ModuleProvider *MP);
+  virtual Module *removeModuleProvider(ModuleProvider *MP,
+                                       std::string *ErrInfo = 0);
 
-  /// run - Start execution with the specified function and arguments.
+  /// runFunction - Start execution with the specified function and arguments.
   ///
   virtual GenericValue runFunction(Function *F,
                                    const std::vector<GenericValue> &ArgValues);
@@ -118,9 +125,21 @@ public:
   ///
   void freeMachineCodeForFunction(Function *F);
 
+  /// getCodeEmitter - Return the code emitter this JIT is emitting into.
+  MachineCodeEmitter *getCodeEmitter() const { return MCE; }
+  
+  static ExecutionEngine *createJIT(ModuleProvider *MP, std::string *Err,
+                                    JITMemoryManager *JMM, bool Fast);
+  
 private:
-  static MachineCodeEmitter *createEmitter(JIT &J);
+  static MachineCodeEmitter *createEmitter(JIT &J, JITMemoryManager *JMM);
   void runJITOnFunction (Function *F);
+  
+protected:
+
+  /// getMemoryforGV - Allocate memory for a global variable.
+  virtual char* getMemoryForGV(const GlobalVariable* GV);
+
 };
 
 } // End llvm namespace