Add an overload of LoadedObjectInfo::getSectionLoadAddress.

[erozenfeld]

Summary

This overload can be used to support cases when there are multiple sections with the same name.
In that case searching by section name doesn't work.

[lhames]

Hi Eugene,

Thanks for re-submitting this via Phab.

The direction is good, but this highlights a deficiency in the current code that will require a bit more work to fix: The LocalSections map should really be attached to the LoadedObjectInfo instance, rather than the RuntimeDyldImpl class, as SectionRefs are not globally unique. (Clashes will be rare in practice, but probably very confusing when they crop up).

I'm working on a fix for this right now - I hope to have something for you today or tomorrow.

Cheers,
Lang.

include/llvm/ExecutionEngine/RuntimeDyld.h

LoadedObjectInfo(RuntimeDyldImpl &RTDyld, unsigned BeginIdx,
                      unsigned EndIdx)
       : RTDyld(RTDyld), BeginIdx(BeginIdx), EndIdx(EndIdx) { }
 
     virtual object::OwningBinary<object::ObjectFile>
     getObjectForDebug(const object::ObjectFile &Obj) const = 0;
 
     uint64_t getSectionLoadAddress(StringRef Name) const;
 
+    uint64_t getSectionLoadAddress(const object::SectionRef &Section) const;
+
   protected:
     virtual void anchor();
 
     RuntimeDyldImpl &RTDyld;
     unsigned BeginIdx, EndIdx;
   };
 
   template <typename Derived> struct LoadedObjectInfoHelper : LoadedObjectInfo {

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

RuntimeDyldImpl::loadObjectImpl(const object::ObjectFile &Obj) {
   // Compute the memory size required to load all sections to be loaded
   // and pass this information to the memory manager
   if (MemMgr.needsToReserveAllocationSpace()) {
     uint64_t CodeSize = 0, DataSizeRO = 0, DataSizeRW = 0;
     computeTotalAllocSize(Obj, CodeSize, DataSizeRO, DataSizeRW);
     MemMgr.reserveAllocationSpace(CodeSize, DataSizeRO, DataSizeRW);
   }
 
-  // Used sections from the object file
-  ObjSectionToIDMap LocalSections;
-
   // Common symbols requiring allocation, with their sizes and alignments
   CommonSymbolList CommonSymbols;
 
   // Parse symbols
   DEBUG(dbgs() << "Parse symbols:\n");
   for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
        ++I) {
     uint32_t Flags = I->getFlags();
uint64_t RuntimeDyld::LoadedObjectInfo::getSectionLoadAddress(
                                                   StringRef SectionName) const {
   for (unsigned I = BeginIdx; I != EndIdx; ++I)
     if (RTDyld.Sections[I].Name == SectionName)
       return RTDyld.Sections[I].LoadAddress;
 
   return 0;
 }
 
+uint64_t RuntimeDyld::LoadedObjectInfo::getSectionLoadAddress(
+  const SectionRef &Section) const {
+  unsigned SectionId = RTDyld.LocalSections[Section];
+  return RTDyld.Sections[SectionId].LoadAddress;
+}
+
 void RuntimeDyld::MemoryManager::anchor() {}
 void RuntimeDyld::SymbolResolver::anchor() {}
 
 RuntimeDyld::RuntimeDyld(RuntimeDyld::MemoryManager &MemMgr,
                          RuntimeDyld::SymbolResolver &Resolver)
     : MemMgr(MemMgr), Resolver(Resolver) {
   // FIXME: There's a potential issue lurking here if a single instance of
   // RuntimeDyld is used to load multiple objects.  The current implementation

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h

protected:
   SectionList Sections;
 
   typedef unsigned SID; // Type for SectionIDs
 #define RTDYLD_INVALID_SECTION_ID ((RuntimeDyldImpl::SID)(-1))
 
   // Keep a map of sections from object file to the SectionID which
   // references it.
   typedef std::map<SectionRef, unsigned> ObjSectionToIDMap;
+  ObjSectionToIDMap LocalSections;
 
   // A global symbol table for symbols from all loaded modules.
   RTDyldSymbolTable GlobalSymbolTable;
 
   // Keep a map of common symbols to their info pairs
   typedef std::vector<SymbolRef> CommonSymbolList;
 
   // For each symbol, keep a list of relocations based on it. Anytime