From 34c9433004cabd4760987dce4804a91c84908219 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Thu, 6 Dec 2007 01:34:04 +0000
Subject: [PATCH] add a new ExecutionEngine::createJIT which can be used if you
 only want to create a JIT.  This lets you specify JIT-specific configuration
 items like the JITMemoryManager to use.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@44647 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../llvm/ExecutionEngine/ExecutionEngine.h    |  8 +++++++
 lib/ExecutionEngine/JIT/JIT.cpp               | 21 +++++++++++++++++--
 lib/ExecutionEngine/JIT/JIT.h                 | 11 ++++++++--
 lib/ExecutionEngine/JIT/TargetSelect.cpp      |  9 ++++----
 4 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/include/llvm/ExecutionEngine/ExecutionEngine.h b/include/llvm/ExecutionEngine/ExecutionEngine.h
index ad0a738426e..5b33e15d906 100644
--- a/include/llvm/ExecutionEngine/ExecutionEngine.h
+++ b/include/llvm/ExecutionEngine/ExecutionEngine.h
@@ -108,6 +108,14 @@ public:
   /// is appropriate for the current machine.  This takes ownership of the
   /// module.
   static ExecutionEngine *create(Module *M);
+
+  /// createJIT - This is the factory method for creating a JIT for the current
+  /// machine, it does not fall back to the interpreter.  This takes ownership
+  /// of the ModuleProvider and JITMemoryManager if successful.
+  static ExecutionEngine *createJIT(ModuleProvider *MP,
+                                    std::string *ErrorStr = 0,
+                                    JITMemoryManager *JMM = 0);
+  
   
   
   /// addModuleProvider - Add a ModuleProvider to the list of modules that we
diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index b5994975025..d6267d509ac 100644
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -61,12 +61,29 @@ namespace llvm {
   }
 }
 
-JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji)
+/// createJIT - This is the factory method for creating a JIT for the current
+/// machine, it does not fall back to the interpreter.  This takes ownership
+/// of the module provider.
+ExecutionEngine *ExecutionEngine::createJIT(ModuleProvider *MP,
+                                            std::string *ErrorStr,
+                                            JITMemoryManager *JMM) {
+  ExecutionEngine *EE = JIT::createJIT(MP, ErrorStr, JMM);
+  if (!EE) return 0;
+  
+  
+  // Make sure we can resolve symbols in the program as well. The zero arg
+  // to the function tells DynamicLibrary to load the program, not a library.
+  sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr);
+  return EE;
+}
+
+JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji,
+         JITMemoryManager *JMM)
   : ExecutionEngine(MP), TM(tm), TJI(tji), jitstate(MP) {
   setTargetData(TM.getTargetData());
 
   // Initialize MCE
-  MCE = createEmitter(*this, 0);
+  MCE = createEmitter(*this, JMM);
 
   // Add target data
   MutexGuard locked(lock);
diff --git a/lib/ExecutionEngine/JIT/JIT.h b/lib/ExecutionEngine/JIT/JIT.h
index 64537409170..789bbbb6629 100644
--- a/lib/ExecutionEngine/JIT/JIT.h
+++ b/lib/ExecutionEngine/JIT/JIT.h
@@ -56,7 +56,8 @@ class JIT : public ExecutionEngine {
 
   JITState jitstate;
 
-  JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji);
+  JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji, 
+      JITMemoryManager *JMM);
 public:
   ~JIT();
 
@@ -71,7 +72,9 @@ 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, std::string* = 0);
+  static ExecutionEngine *create(ModuleProvider *MP, std::string *Err) {
+    return createJIT(MP, Err, 0);
+  }
 
   /// run - Start execution with the specified function and arguments.
   ///
@@ -120,6 +123,10 @@ public:
 
   /// 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);
+  
 private:
   static MachineCodeEmitter *createEmitter(JIT &J, JITMemoryManager *JMM);
   void runJITOnFunction (Function *F);
diff --git a/lib/ExecutionEngine/JIT/TargetSelect.cpp b/lib/ExecutionEngine/JIT/TargetSelect.cpp
index 14e0a5f10e7..e6598504a26 100644
--- a/lib/ExecutionEngine/JIT/TargetSelect.cpp
+++ b/lib/ExecutionEngine/JIT/TargetSelect.cpp
@@ -36,10 +36,11 @@ MAttrs("mattr",
   cl::desc("Target specific attributes (-mattr=help for details)"),
   cl::value_desc("a1,+a2,-a3,..."));
 
-/// create - Create an return a new JIT compiler if there is one available
-/// for the current target.  Otherwise, return null.
+/// createInternal - Create an return a new JIT compiler if there is one
+/// available for the current target.  Otherwise, return null.
 ///
-ExecutionEngine *JIT::create(ModuleProvider *MP, std::string *ErrorStr) {
+ExecutionEngine *JIT::createJIT(ModuleProvider *MP, std::string *ErrorStr,
+                                JITMemoryManager *JMM) {
   const TargetMachineRegistry::entry *TheArch = MArch;
   if (TheArch == 0) {
     std::string Error;
@@ -71,7 +72,7 @@ ExecutionEngine *JIT::create(ModuleProvider *MP, std::string *ErrorStr) {
 
   // If the target supports JIT code generation, return a new JIT now.
   if (TargetJITInfo *TJ = Target->getJITInfo())
-    return new JIT(MP, *Target, *TJ);
+    return new JIT(MP, *Target, *TJ, JMM);
 
   if (ErrorStr)
     *ErrorStr = "target does not support JIT code generation";
-- 
2.34.1