Add support to the JIT for true non-lazy operation. When a call to a function

that has not been JIT'd yet, the callee is put on a list of pending functions
to JIT.  The call is directed through a stub, which is updated with the address
of the function after it has been JIT'd.  A new interface for allocating and
updating empty stubs is provided.

Add support for removing the ModuleProvider the JIT was created with, which
would otherwise invalidate the JIT's PassManager, which is initialized with the
ModuleProvider's Module.

Add support under a new ExecutionEngine flag for emitting the infomration 
necessary to update Function and GlobalVariable stubs after JITing them, by
recording the address of the stub and the name of the GlobalValue.  This allows
code to be copied from one address space to another, where libraries may live
at different virtual addresses, and have the stubs updated with their new
correct target addresses.


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

4 files changed, 34 insertions, 0 deletions

diff --git a/include/llvm/CodeGen/MachineCodeEmitter.h b/include/llvm/CodeGen/MachineCodeEmitter.h
index 1161704490..226c4c2ad8 100644
--- a/include/llvm/CodeGen/MachineCodeEmitter.h
+++ b/include/llvm/CodeGen/MachineCodeEmitter.h
@@ -82,6 +82,13 @@ public:
   virtual void startGVStub(const GlobalValue* GV, unsigned StubSize,
                            unsigned Alignment = 1) = 0;
 
+  /// startGVStub - This callback is invoked when the JIT needs the address of a 
+  /// GV (e.g. function) that has not been code generated yet.  Buffer points to
+  /// memory already allocated for this stub.
+  ///
+  virtual void startGVStub(const GlobalValue* GV, void *Buffer,
+                           unsigned StubSize) = 0;
+  
   /// finishGVStub - This callback is invoked to terminate a GV stub.
   ///
   virtual void *finishGVStub(const GlobalValue* F) = 0;
diff --git a/include/llvm/ExecutionEngine/ExecutionEngine.h b/include/llvm/ExecutionEngine/ExecutionEngine.h
index 3559ede31c..0c53a53e75 100644
--- a/include/llvm/ExecutionEngine/ExecutionEngine.h
+++ b/include/llvm/ExecutionEngine/ExecutionEngine.h
@@ -66,6 +66,7 @@ class ExecutionEngine {
   bool LazyCompilationDisabled;
   bool GVCompilationDisabled;
   bool SymbolSearchingDisabled;
+  bool DlsymStubsEnabled;
 
 protected:
   /// Modules - This is a list of ModuleProvider's that we are JIT'ing from.  We
@@ -288,6 +289,13 @@ public:
     return SymbolSearchingDisabled;
   }
   
+  /// EnableDlsymStubs - 
+  void EnableDlsymStubs(bool Enabled = true) {
+    DlsymStubsEnabled = Enabled;
+  }
+  bool areDlsymStubsEnabled() const {
+    return DlsymStubsEnabled;
+  }
   
   /// InstallLazyFunctionCreator - If an unknown function is needed, the
   /// specified function pointer is invoked to create it.  If it returns null,
diff --git a/include/llvm/ExecutionEngine/JITMemoryManager.h b/include/llvm/ExecutionEngine/JITMemoryManager.h
index 61c34434c2..581300e6e3 100644
--- a/include/llvm/ExecutionEngine/JITMemoryManager.h
+++ b/include/llvm/ExecutionEngine/JITMemoryManager.h
@@ -62,6 +62,17 @@ public:
   /// return a pointer to its base.
   virtual unsigned char *getGOTBase() const = 0;
   
+  /// SetDlsymTable - If the JIT must be able to relocate stubs after they have
+  /// been emitted, potentially because they are being copied to a process
+  /// where external symbols live at different addresses than in the JITing
+  ///  process, allocate a table with sufficient information to do so.
+  virtual void SetDlsymTable(void *ptr) = 0;
+  
+  /// getDlsymTable - If this is managing a table of entries so that stubs to
+  /// external symbols can be later relocated, this method should return a
+  /// pointer to it.
+  virtual void *getDlsymTable() const = 0;
+  
   /// NeedsExactSize - If the memory manager requires to know the size of the
   /// objects to be emitted
   bool NeedsExactSize() const {
diff --git a/include/llvm/Target/TargetJITInfo.h b/include/llvm/Target/TargetJITInfo.h
index 1d06cd790d..ff7dc0bcf7 100644
--- a/include/llvm/Target/TargetJITInfo.h
+++ b/include/llvm/Target/TargetJITInfo.h
@@ -56,6 +56,14 @@ namespace llvm {
       assert(0 && "This target doesn't implement emitFunctionStub!");
       return 0;
     }
+    
+    /// emitFunctionStubAtAddr - Use the specified MachineCodeEmitter object to
+    /// emit a small native function that simply calls Fn. Emit the stub into
+    /// the supplied buffer.
+    virtual void emitFunctionStubAtAddr(const Function* F, void *Fn,
+                                        void *Buffer, MachineCodeEmitter &MCE) {
+      assert(0 && "This target doesn't implement emitFunctionStubAtAddr!");
+    }
 
     /// getPICJumpTableEntry - Returns the value of the jumptable entry for the
     /// specific basic block.