ExecutionEngine interface to re-map addresses for engines that support it.

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

diff --git a/include/llvm/ExecutionEngine/ExecutionEngine.h b/include/llvm/ExecutionEngine/ExecutionEngine.h
index 9f77ebeb9e666b2b2c506e22c021461d4188ea36..62adb5546cc63240300c21a03f7b8d6d1c7689ce 100644 (file)
--- a/include/llvm/ExecutionEngine/ExecutionEngine.h
+++ b/include/llvm/ExecutionEngine/ExecutionEngine.h
@@ -239,6 +239,14 @@ public:
   virtual void *getPointerToNamedFunction(const std::string &Name,
                                           bool AbortOnFailure = true) = 0;
 
+  /// mapSectionAddress - map a section to its target address space value.
+  /// Map the address of a JIT section as returned from the memory manager
+  /// to the address in the target process as the running code will see it.
+  /// This is the address which will be used for relocation resolution.
+  virtual void mapSectionAddress(void *LocalAddress, uint64_t TargetAddress) {
+    assert(0 && "Re-mapping of section addresses not supported with this EE!");
+  }
+
   /// runStaticConstructorsDestructors - This method is used to execute all of
   /// the static constructors or destructors for a program.
   ///

diff --git a/include/llvm/ExecutionEngine/RuntimeDyld.h b/include/llvm/ExecutionEngine/RuntimeDyld.h
index d937ab49f4e832afc30f8d107799787d487ab590..8ad316bc3f95b2a8fd1450bddda3e595d975206e 100644 (file)
--- a/include/llvm/ExecutionEngine/RuntimeDyld.h
+++ b/include/llvm/ExecutionEngine/RuntimeDyld.h
@@ -64,6 +64,10 @@ class RuntimeDyld {
   // interface.
   RuntimeDyldImpl *Dyld;
   RTDyldMemoryManager *MM;
+protected:
+  // Change the address associated with a section when resolving relocations.
+  // Any relocations already associated with the symbol will be re-resolved.
+  void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
 public:
   RuntimeDyld(RTDyldMemoryManager*);
   ~RuntimeDyld();
@@ -75,9 +79,13 @@ public:
   void *getSymbolAddress(StringRef Name);
   // Resolve the relocations for all symbols we currently know about.
   void resolveRelocations();
-  // Change the address associated with a section when resolving relocations.
-  // Any relocations already associated with the symbol will be re-resolved.
-  void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
+
+  /// mapSectionAddress - map a section to its target address space value.
+  /// Map the address of a JIT section as returned from the memory manager
+  /// to the address in the target process as the running code will see it.
+  /// This is the address which will be used for relocation resolution.
+  void mapSectionAddress(void *LocalAddress, uint64_t TargetAddress);
+
   StringRef getErrorString();
 };
 

diff --git a/lib/ExecutionEngine/MCJIT/MCJIT.h b/lib/ExecutionEngine/MCJIT/MCJIT.h
index 51e63d96e45bd92b12d713198fa8ded22e27d0cf..7f4ae77343dfc0ee89a3d7bdd564a0c8422019ce 100644 (file)
--- a/lib/ExecutionEngine/MCJIT/MCJIT.h
+++ b/lib/ExecutionEngine/MCJIT/MCJIT.h
@@ -67,6 +67,14 @@ public:
   ///
   virtual void *getPointerToNamedFunction(const std::string &Name,
                                           bool AbortOnFailure = true);
+  /// mapSectionAddress - map a section to its target address space value.
+  /// Map the address of a JIT section as returned from the memory manager
+  /// to the address in the target process as the running code will see it.
+  /// This is the address which will be used for relocation resolution.
+  virtual void mapSectionAddress(void *LocalAddress, uint64_t TargetAddress) {
+    Dyld.mapSectionAddress(LocalAddress, TargetAddress);
+  }
+
   /// @}
   /// @name (Private) Registration Interfaces
   /// @{

diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
index 18827978d9a33948c0f5d70ec07cd6645fc2ff53..99524a3b0025ab964eb9ff59783fc05f33f739c8 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
@@ -54,6 +54,14 @@ void RuntimeDyldImpl::resolveRelocations() {
   }
 }
 
+void RuntimeDyldImpl::mapSectionAddress(void *LocalAddress,
+                                        uint64_t TargetAddress) {
+  assert(SectionLocalMemToID.count(LocalAddress) &&
+         "Attempting to remap address of unknown section!");
+  unsigned SectionID = SectionLocalMemToID[LocalAddress];
+  reassignSectionAddress(SectionID, TargetAddress);
+}
+
 //===----------------------------------------------------------------------===//
 // RuntimeDyld class implementation
 RuntimeDyld::RuntimeDyld(RTDyldMemoryManager *mm) {
@@ -116,6 +124,11 @@ void RuntimeDyld::reassignSectionAddress(unsigned SectionID,
   Dyld->reassignSectionAddress(SectionID, Addr);
 }
 
+void RuntimeDyld::mapSectionAddress(void *LocalAddress,
+                                    uint64_t TargetAddress) {
+  Dyld->mapSectionAddress(LocalAddress, TargetAddress);
+}
+
 StringRef RuntimeDyld::getErrorString() {
   return Dyld->getErrorString();
 }

diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
index bbfef768c4cd902352f3a7bfad1e3572e6ed9c81..59c863679efebd5198fbdfd664e7d9789ad7b259 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
@@ -16,6 +16,7 @@
 
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/Object/MachOObject.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Twine.h"
@@ -45,10 +46,14 @@ protected:
   // Indexed by SectionID.
   SmallVector<sys::MemoryBlock, 32> Sections;
   // For each section, the address it will be considered to live at for
-  // relocations. The same as the pointer the above memory block for hosted
+  // relocations. The same as the pointer to the above memory block for hosted
   // JITs. Indexed by SectionID.
   SmallVector<uint64_t, 32> SectionLoadAddress;
 
+  // Keep a map of starting local address to the SectionID which references it.
+  // Lookup function for when we assign virtual addresses.
+  DenseMap<void *, unsigned> SectionLocalMemToID;
+
   // Master symbol table. As modules are loaded and external symbols are
   // resolved, their addresses are stored here as a SectionID/Offset pair.
   typedef std::pair<unsigned, uint64_t> SymbolLoc;
@@ -90,6 +95,8 @@ public:
 
   virtual void reassignSectionAddress(unsigned SectionID, uint64_t Addr) = 0;
 
+  void mapSectionAddress(void *LocalAddress, uint64_t TargetAddress);
+
   // Is the linker in an error state?
   bool hasError() { return HasError; }
 

diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
index a3b4919f68b17e7c284a437b5de2b5676fc64c5a..1cc021ade51ec57c61b502aed0e6ceab2d413864 100644 (file)
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
@@ -172,6 +172,7 @@ loadSegment32(const MachOObject *Obj,
 
     // Remember what got allocated for this SectionID.
     Sections.push_back(sys::MemoryBlock(Buffer, Sect->Size));
+    SectionLocalMemToID[Buffer] = SectionID;
 
     // By default, the load address of a section is its memory buffer.
     SectionLoadAddress.push_back((uint64_t)Buffer);
@@ -291,6 +292,7 @@ loadSegment64(const MachOObject *Obj,
 
     // Remember what got allocated for this SectionID.
     Sections.push_back(sys::MemoryBlock(Buffer, Sect->Size));
+    SectionLocalMemToID[Buffer] = SectionID;
 
     // By default, the load address of a section is its memory buffer.
     SectionLoadAddress.push_back((uint64_t)Buffer);