Avoid dangling reference when indexing sections

[serge-sans-paille]

Summary

Bug spotted by https://cookieplmonster.github.io/2020/02/01/emulator-bug-llvm-bug/

The blog post proposes a simple solution (using a std::deque instead of a smallvector to store section entries). They also propose an alternative, namely to avoid taking any section reference at all. This patch enforces the latter using a proxy class. I'm totally fine with the dequeue approach too, and will gladly update the patch if needed.

[nickdesaulniers]

Drive by code review, no comment on the bug or proposed solution.

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

83

How come SectionEntryProxy is sometimes passed by reference, but other times passed by value to different functions in this CL?

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

105

Every time I see Sections[] in RuntimeDyldELF.cpp, I think "This should be using getSection()."

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h

134

If this is the same between MachO and ELF (and I suspect all other derived classes), can it be a method on a shared base class?

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldELFMips.cpp

33

Why not a &? Won't this result in a copy-assignment?

[lhames]

Thanks very much for this Serge!

Is the std::deque fix a one-liner? This shouldn't be very performance sensitive, so I'd be inclined to go with that.

[serge-sans-paille]

In D75110#1891890, @lhames wrote:

Thanks very much for this Serge!

Is the std::deque fix a one-liner? This shouldn't be very performance sensitive, so I'd be inclined to go with that.

It is! Compared to this patch, which was a pleasure to write nonetheless, I'd go for the <dequeue> approach ;-)

[serge-sans-paille]

Use the <deque> approach

[serge-sans-paille]

Fix include order

[serge-sans-paille]

@lhames is that okay like this?

[lhames]

Looks good to me. Thanks Serge!

[grimar]

Nasty bug. LGTM too.

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h

339

LLVM code usually uses "std::" prefix before STL containers names and algorithms.
(See std::map below and other variables).

[serge-sans-paille]

@grimar ok, change added to the commit.

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

 
 void RuntimeDyldImpl::registerEHFrames() {}
 
 void RuntimeDyldImpl::deregisterEHFrames() {
   MemMgr.deregisterEHFrames();
 }
 
 #ifndef NDEBUG
-static void dumpSectionMemory(const SectionEntry &S, StringRef State) {
-  dbgs() << "----- Contents of section " << S.getName() << " " << State
+static void dumpSectionMemory(const SectionList::SectionEntryProxy &S,
+                              StringRef State) {
+  dbgs() << "----- Contents of section " << S->getName() << " " << State
          << " -----";
 
-  if (S.getAddress() == nullptr) {
+  if (S->getAddress() == nullptr) {
     dbgs() << "\n          <section not emitted>\n";
     return;
   }
 
   const unsigned ColsPerRow = 16;
 
-  uint8_t *DataAddr = S.getAddress();
-  uint64_t LoadAddr = S.getLoadAddress();
+  uint8_t *DataAddr = S->getAddress();
+  uint64_t LoadAddr = S->getLoadAddress();
 
   unsigned StartPadding = LoadAddr & (ColsPerRow - 1);
-  unsigned BytesRemaining = S.getSize();
+  unsigned BytesRemaining = S->getSize();
 
   if (StartPadding) {
     dbgs() << "\n" << format("0x%016" PRIx64,
                              LoadAddr & ~(uint64_t)(ColsPerRow - 1)) << ":";
     while (StartPadding--)
       dbgs() << "   ";
   }
 

 
 void RuntimeDyldImpl::resolveLocalRelocations() {
   // Iterate over all outstanding relocations
   for (auto it = Relocations.begin(), e = Relocations.end(); it != e; ++it) {
     // The Section here (Sections[i]) refers to the section in which the
     // symbol for the relocation is located.  The SectionID in the relocation
     // entry provides the section to which the relocation will be applied.
     int Idx = it->first;
-    uint64_t Addr = Sections[Idx].getLoadAddress();
+    uint64_t Addr = Sections[Idx]->getLoadAddress();
     LLVM_DEBUG(dbgs() << "Resolving relocations Section #" << Idx << "\t"
                       << format("%p", (uintptr_t)Addr) << "\n");
     resolveRelocationList(it->second, Addr);
   }
   Relocations.clear();
 }
 
 void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
                                         uint64_t TargetAddress) {
   std::lock_guard<sys::Mutex> locked(lock);
   for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
-    if (Sections[i].getAddress() == LocalAddress) {
+    if (Sections[i]->getAddress() == LocalAddress) {
       reassignSectionAddress(i, TargetAddress);
       return;
     }
   }
   llvm_unreachable("Attempting to remap address of unknown section!");
 }
 
 static Error getOffset(const SymbolRef &Sym, SectionRef Sec,
for (; I != E;)
         I = *IOrErr;
       else
         return IOrErr.takeError();
 
     // If there is a NotifyStubEmitted callback set, call it to register any
     // stubs created for this section.
     if (NotifyStubEmitted) {
       StringRef FileName = Obj.getFileName();
-      StringRef SectionName = Sections[SectionID].getName();
+      StringRef SectionName = Sections[SectionID]->getName();
       for (auto &KV : Stubs) {
 
         auto &VR = KV.first;
         uint64_t StubAddr = KV.second;
 
         // If this is a named stub, just call NotifyStubEmitted.
         if (VR.SymbolName) {
           NotifyStubEmitted(FileName, SectionName, VR.SymbolName, SectionID,
LLVM_DEBUG(
                << " Allocate: " << Allocate << "\n");
   }
 
   Sections.push_back(
       SectionEntry(Name, Addr, DataSize, Allocate, (uintptr_t)pData));
 
   // Debug info sections are linked as if their load address was zero
   if (!IsRequired)
-    Sections.back().setLoadAddress(0);
+    Sections.back()->setLoadAddress(0);
 
   return SectionID;
 }
 
 Expected<unsigned>
 RuntimeDyldImpl::findOrEmitSection(const ObjectFile &Obj,
                                    const SectionRef &Section,
                                    bool IsCode,
void RuntimeDyldImpl::reassignSectionAddress(unsigned SectionID,
   // trigger this with a call to MCJIT::finalize() or
   // RuntimeDyld::resolveRelocations().
   //
   // Addr is a uint64_t because we can't assume the pointer width
   // of the target is the same as that of the host. Just use a generic
   // "big enough" type.
   LLVM_DEBUG(
       dbgs() << "Reassigning address for section " << SectionID << " ("
-             << Sections[SectionID].getName() << "): "
-             << format("0x%016" PRIx64, Sections[SectionID].getLoadAddress())
+             << Sections[SectionID]->getName() << "): "
+             << format("0x%016" PRIx64, Sections[SectionID]->getLoadAddress())
              << " -> " << format("0x%016" PRIx64, Addr) << "\n");
-  Sections[SectionID].setLoadAddress(Addr);
+  Sections[SectionID]->setLoadAddress(Addr);
 }
 
 void RuntimeDyldImpl::resolveRelocationList(const RelocationList &Relocs,
                                             uint64_t Value) {
   for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
     const RelocationEntry &RE = Relocs[i];
     // Ignore relocations for sections that were not loaded
-    if (Sections[RE.SectionID].getAddress() == nullptr)
+    if (Sections[RE.SectionID]->getAddress() == nullptr)
       continue;
     resolveRelocation(RE, Value);
   }
 }
 
 void RuntimeDyldImpl::applyExternalSymbolRelocations(
     const StringMap<JITEvaluatedSymbol> ExternalSymbolMap) {
   while (!ExternalSymbolRelocations.empty()) {

 //===----------------------------------------------------------------------===//
 // RuntimeDyld class implementation
 
 uint64_t RuntimeDyld::LoadedObjectInfo::getSectionLoadAddress(
                                           const object::SectionRef &Sec) const {
 
   auto I = ObjSecToIDMap.find(Sec);
   if (I != ObjSecToIDMap.end())
-    return RTDyld.Sections[I->second].getLoadAddress();
+    return RTDyld.Sections[I->second]->getLoadAddress();
 
   return 0;
 }
 
 void RuntimeDyld::MemoryManager::anchor() {}
 void JITSymbolResolver::anchor() {}
 void LegacyJITSymbolResolver::anchor() {}
 

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

 
 namespace llvm {
 namespace object {
 class ELFObjectFileBase;
 }
 
 class RuntimeDyldELF : public RuntimeDyldImpl {
 
-  void resolveRelocation(const SectionEntry &Section, uint64_t Offset,
+  void resolveRelocation(const SectionEntryProxy Section, uint64_t Offset,
                          uint64_t Value, uint32_t Type, int64_t Addend,
                          uint64_t SymOffset = 0, SID SectionID = 0);
 
-  void resolveX86_64Relocation(const SectionEntry &Section, uint64_t Offset,
+  void resolveX86_64Relocation(const SectionEntryProxy Section, uint64_t Offset,
                                uint64_t Value, uint32_t Type, int64_t Addend,
                                uint64_t SymOffset);
 
-  void resolveX86Relocation(const SectionEntry &Section, uint64_t Offset,
+  void resolveX86Relocation(const SectionEntryProxy Section, uint64_t Offset,
                             uint32_t Value, uint32_t Type, int32_t Addend);
 
-  void resolveAArch64Relocation(const SectionEntry &Section, uint64_t Offset,
-                                uint64_t Value, uint32_t Type, int64_t Addend);
+  void resolveAArch64Relocation(const SectionEntryProxy Section,
+                                uint64_t Offset, uint64_t Value, uint32_t Type,
+                                int64_t Addend);
 
   bool resolveAArch64ShortBranch(unsigned SectionID, relocation_iterator RelI,
                                  const RelocationValueRef &Value);
 
   void resolveAArch64Branch(unsigned SectionID, const RelocationValueRef &Value,
                             relocation_iterator RelI, StubMap &Stubs);
 
-  void resolveARMRelocation(const SectionEntry &Section, uint64_t Offset,
+  void resolveARMRelocation(const SectionEntryProxy Section, uint64_t Offset,
                             uint32_t Value, uint32_t Type, int32_t Addend);
 
-  void resolvePPC32Relocation(const SectionEntry &Section, uint64_t Offset,
+  void resolvePPC32Relocation(const SectionEntryProxy Section, uint64_t Offset,
                               uint64_t Value, uint32_t Type, int64_t Addend);
 
-  void resolvePPC64Relocation(const SectionEntry &Section, uint64_t Offset,
+  void resolvePPC64Relocation(const SectionEntryProxy Section, uint64_t Offset,
                               uint64_t Value, uint32_t Type, int64_t Addend);
 
-  void resolveSystemZRelocation(const SectionEntry &Section, uint64_t Offset,
-                                uint64_t Value, uint32_t Type, int64_t Addend);
+  void resolveSystemZRelocation(const SectionEntryProxy Section,
+                                uint64_t Offset, uint64_t Value, uint32_t Type,
+                                int64_t Addend);
 
-  void resolveBPFRelocation(const SectionEntry &Section, uint64_t Offset,
+  void resolveBPFRelocation(const SectionEntryProxy Section, uint64_t Offset,
                             uint64_t Value, uint32_t Type, int64_t Addend);
 
   unsigned getMaxStubSize() const override {
     if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be)
       return 20; // movz; movk; movk; movk; br
     if (Arch == Triple::arm || Arch == Triple::thumb)
       return 8; // 32-bit instruction and 32-bit address
     else if (IsMipsO32ABI || IsMipsN32ABI)
Error findPPC64TOCSection(const ELFObjectFileBase &Obj,
                             RelocationValueRef &Rel);
   Error findOPDEntrySection(const ELFObjectFileBase &Obj,
                             ObjSectionToIDMap &LocalSections,
                             RelocationValueRef &Rel);
 protected:
   size_t getGOTEntrySize() override;
 
 private:
-  SectionEntry &getSection(unsigned SectionID) { return Sections[SectionID]; }
+  SectionEntryProxy getSection(unsigned SectionID) {
+    return Sections[SectionID];
+  }
 
   // Allocate no GOT entries for use in the given section.
   uint64_t allocateGOTEntries(unsigned no);
 
   // Find GOT entry corresponding to relocation or create new one.
   uint64_t findOrAllocGOTEntry(const RelocationValueRef &Value,
                                unsigned GOTRelType);
 

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

 RuntimeDyldELF::RuntimeDyldELF(RuntimeDyld::MemoryManager &MemMgr,
                                JITSymbolResolver &Resolver)
     : RuntimeDyldImpl(MemMgr, Resolver), GOTSectionID(0), CurrentGOTIndex(0) {}
 RuntimeDyldELF::~RuntimeDyldELF() {}
 
 void RuntimeDyldELF::registerEHFrames() {
   for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) {
     SID EHFrameSID = UnregisteredEHFrameSections[i];
-    uint8_t *EHFrameAddr = Sections[EHFrameSID].getAddress();
-    uint64_t EHFrameLoadAddr = Sections[EHFrameSID].getLoadAddress();
-    size_t EHFrameSize = Sections[EHFrameSID].getSize();
+    uint8_t *EHFrameAddr = Sections[EHFrameSID]->getAddress();
+    uint64_t EHFrameLoadAddr = Sections[EHFrameSID]->getLoadAddress();
+    size_t EHFrameSize = Sections[EHFrameSID]->getSize();
     MemMgr.registerEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize);
   }
   UnregisteredEHFrameSections.clear();
 }
 
 std::unique_ptr<RuntimeDyldELF>
 llvm::RuntimeDyldELF::create(Triple::ArchType Arch,
                              RuntimeDyld::MemoryManager &MemMgr,
RuntimeDyldELF::loadObject(const object::ObjectFile &O) {
   else {
     HasError = true;
     raw_string_ostream ErrStream(ErrorStr);
     logAllUnhandledErrors(ObjSectionToIDOrErr.takeError(), ErrStream);
     return nullptr;
   }
 }
 
-void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section,
+void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntryProxy Section,
                                              uint64_t Offset, uint64_t Value,
                                              uint32_t Type, int64_t Addend,
                                              uint64_t SymOffset) {
   switch (Type) {
   default:
     llvm_unreachable("Relocation type not implemented yet!");
     break;
   case ELF::R_X86_64_NONE:
     break;
   case ELF::R_X86_64_64: {
-    support::ulittle64_t::ref(Section.getAddressWithOffset(Offset)) =
+    support::ulittle64_t::ref(Section->getAddressWithOffset(Offset)) =
         Value + Addend;
     LLVM_DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
-                      << format("%p\n", Section.getAddressWithOffset(Offset)));
+                      << format("%p\n", Section->getAddressWithOffset(Offset)));
     break;
   }
   case ELF::R_X86_64_32:
   case ELF::R_X86_64_32S: {
     Value += Addend;
     assert((Type == ELF::R_X86_64_32 && (Value <= UINT32_MAX)) ||
            (Type == ELF::R_X86_64_32S &&
             ((int64_t)Value <= INT32_MAX && (int64_t)Value >= INT32_MIN)));
     uint32_t TruncatedAddr = (Value & 0xFFFFFFFF);
-    support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
+    support::ulittle32_t::ref(Section->getAddressWithOffset(Offset)) =
         TruncatedAddr;
     LLVM_DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr) << " at "
-                      << format("%p\n", Section.getAddressWithOffset(Offset)));
+                      << format("%p\n", Section->getAddressWithOffset(Offset)));
     break;
   }
   case ELF::R_X86_64_PC8: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     int64_t RealOffset = Value + Addend - FinalAddress;
     assert(isInt<8>(RealOffset));
     int8_t TruncOffset = (RealOffset & 0xFF);
-    Section.getAddress()[Offset] = TruncOffset;
+    Section->getAddress()[Offset] = TruncOffset;
     break;
   }
   case ELF::R_X86_64_PC32: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     int64_t RealOffset = Value + Addend - FinalAddress;
     assert(isInt<32>(RealOffset));
     int32_t TruncOffset = (RealOffset & 0xFFFFFFFF);
-    support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
+    support::ulittle32_t::ref(Section->getAddressWithOffset(Offset)) =
         TruncOffset;
     break;
   }
   case ELF::R_X86_64_PC64: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     int64_t RealOffset = Value + Addend - FinalAddress;
-    support::ulittle64_t::ref(Section.getAddressWithOffset(Offset)) =
+    support::ulittle64_t::ref(Section->getAddressWithOffset(Offset)) =
         RealOffset;
     LLVM_DEBUG(dbgs() << "Writing " << format("%p", RealOffset) << " at "
                       << format("%p\n", FinalAddress));
     break;
   }
   case ELF::R_X86_64_GOTOFF64: {
     // Compute Value - GOTBase.
     uint64_t GOTBase = 0;
-    for (const auto &Section : Sections) {
-      if (Section.getName() == ".got") {
-        GOTBase = Section.getLoadAddressWithOffset(0);
+    for (const auto Section : Sections) {
+      if (Section->getName() == ".got") {
+        GOTBase = Section->getLoadAddressWithOffset(0);
         break;
       }
     }
     assert(GOTBase != 0 && "missing GOT");
     int64_t GOTOffset = Value - GOTBase + Addend;
-    support::ulittle64_t::ref(Section.getAddressWithOffset(Offset)) = GOTOffset;
+    support::ulittle64_t::ref(Section->getAddressWithOffset(Offset)) =
+        GOTOffset;
     break;
   }
   }
 }
 
-void RuntimeDyldELF::resolveX86Relocation(const SectionEntry &Section,
+void RuntimeDyldELF::resolveX86Relocation(const SectionEntryProxy Section,
                                           uint64_t Offset, uint32_t Value,
                                           uint32_t Type, int32_t Addend) {
   switch (Type) {
   case ELF::R_386_32: {
-    support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
+    support::ulittle32_t::ref(Section->getAddressWithOffset(Offset)) =
         Value + Addend;
     break;
   }
   // Handle R_386_PLT32 like R_386_PC32 since it should be able to
   // reach any 32 bit address.
   case ELF::R_386_PLT32:
   case ELF::R_386_PC32: {
     uint32_t FinalAddress =
-        Section.getLoadAddressWithOffset(Offset) & 0xFFFFFFFF;
+        Section->getLoadAddressWithOffset(Offset) & 0xFFFFFFFF;
     uint32_t RealOffset = Value + Addend - FinalAddress;
-    support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
+    support::ulittle32_t::ref(Section->getAddressWithOffset(Offset)) =
         RealOffset;
     break;
   }
   default:
     // There are other relocation types, but it appears these are the
     // only ones currently used by the LLVM ELF object writer
     llvm_unreachable("Relocation type not implemented yet!");
     break;
   }
 }
 
-void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntry &Section,
+void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntryProxy Section,
                                               uint64_t Offset, uint64_t Value,
                                               uint32_t Type, int64_t Addend) {
   uint32_t *TargetPtr =
-      reinterpret_cast<uint32_t *>(Section.getAddressWithOffset(Offset));
-  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+      reinterpret_cast<uint32_t *>(Section->getAddressWithOffset(Offset));
+  uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
   // Data should use target endian. Code should always use little endian.
   bool isBE = Arch == Triple::aarch64_be;
 
   LLVM_DEBUG(dbgs() << "resolveAArch64Relocation, LocalAddress: 0x"
-                    << format("%llx", Section.getAddressWithOffset(Offset))
+                    << format("%llx", Section->getAddressWithOffset(Offset))
                     << " FinalAddress: 0x" << format("%llx", FinalAddress)
                     << " Value: 0x" << format("%llx", Value) << " Type: 0x"
                     << format("%x", Type) << " Addend: 0x"
                     << format("%llx", Addend) << "\n");
 
   switch (Type) {
   default:
     llvm_unreachable("Relocation type not implemented yet!");
case ELF::R_AARCH64_LDST128_ABS_LO12_NC:
     // Operation: S + A
     // Immediate goes in bits 21:10 of LD/ST instruction, taken
     // from bits 11:4 of X
     or32AArch64Imm(TargetPtr, getBits(Value + Addend, 4, 11));
     break;
   }
 }
 
-void RuntimeDyldELF::resolveARMRelocation(const SectionEntry &Section,
+void RuntimeDyldELF::resolveARMRelocation(const SectionEntryProxy Section,
                                           uint64_t Offset, uint32_t Value,
                                           uint32_t Type, int32_t Addend) {
   // TODO: Add Thumb relocations.
   uint32_t *TargetPtr =
-      reinterpret_cast<uint32_t *>(Section.getAddressWithOffset(Offset));
-  uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset) & 0xFFFFFFFF;
+      reinterpret_cast<uint32_t *>(Section->getAddressWithOffset(Offset));
+  uint32_t FinalAddress =
+      Section->getLoadAddressWithOffset(Offset) & 0xFFFFFFFF;
   Value += Addend;
 
   LLVM_DEBUG(dbgs() << "resolveARMRelocation, LocalAddress: "
-                    << Section.getAddressWithOffset(Offset)
+                    << Section->getAddressWithOffset(Offset)
                     << " FinalAddress: " << format("%p", FinalAddress)
                     << " Value: " << format("%x", Value)
                     << " Type: " << format("%x", Type)
                     << " Addend: " << format("%x", Addend) << "\n");
 
   switch (Type) {
   default:
     llvm_unreachable("Not implemented relocation type!");

 static inline uint16_t applyPPChighest(uint64_t value) {
   return (value >> 48) & 0xffff;
 }
 
 static inline uint16_t applyPPChighesta (uint64_t value) {
   return ((value + 0x8000) >> 48) & 0xffff;
 }
 
-void RuntimeDyldELF::resolvePPC32Relocation(const SectionEntry &Section,
+void RuntimeDyldELF::resolvePPC32Relocation(const SectionEntryProxy Section,
                                             uint64_t Offset, uint64_t Value,
                                             uint32_t Type, int64_t Addend) {
-  uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
+  uint8_t *LocalAddress = Section->getAddressWithOffset(Offset);
   switch (Type) {
   default:
     llvm_unreachable("Relocation type not implemented yet!");
     break;
   case ELF::R_PPC_ADDR16_LO:
     writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
     break;
   case ELF::R_PPC_ADDR16_HI:
     writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
     break;
   case ELF::R_PPC_ADDR16_HA:
     writeInt16BE(LocalAddress, applyPPCha(Value + Addend));
     break;
   }
 }
 
-void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section,
+void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntryProxy Section,
                                             uint64_t Offset, uint64_t Value,
                                             uint32_t Type, int64_t Addend) {
-  uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
+  uint8_t *LocalAddress = Section->getAddressWithOffset(Offset);
   switch (Type) {
   default:
     llvm_unreachable("Relocation type not implemented yet!");
     break;
   case ELF::R_PPC64_ADDR16:
     writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
     break;
   case ELF::R_PPC64_ADDR16_DS:
case ELF::R_PPC64_ADDR16_HIGHESTA:
     break;
   case ELF::R_PPC64_ADDR14: {
     assert(((Value + Addend) & 3) == 0);
     // Preserve the AA/LK bits in the branch instruction
     uint8_t aalk = *(LocalAddress + 3);
     writeInt16BE(LocalAddress + 2, (aalk & 3) | ((Value + Addend) & 0xfffc));
   } break;
   case ELF::R_PPC64_REL16_LO: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     uint64_t Delta = Value - FinalAddress + Addend;
     writeInt16BE(LocalAddress, applyPPClo(Delta));
   } break;
   case ELF::R_PPC64_REL16_HI: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     uint64_t Delta = Value - FinalAddress + Addend;
     writeInt16BE(LocalAddress, applyPPChi(Delta));
   } break;
   case ELF::R_PPC64_REL16_HA: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     uint64_t Delta = Value - FinalAddress + Addend;
     writeInt16BE(LocalAddress, applyPPCha(Delta));
   } break;
   case ELF::R_PPC64_ADDR32: {
     int64_t Result = static_cast<int64_t>(Value + Addend);
     if (SignExtend64<32>(Result) != Result)
       llvm_unreachable("Relocation R_PPC64_ADDR32 overflow");
     writeInt32BE(LocalAddress, Result);
   } break;
   case ELF::R_PPC64_REL24: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     int64_t delta = static_cast<int64_t>(Value - FinalAddress + Addend);
     if (SignExtend64<26>(delta) != delta)
       llvm_unreachable("Relocation R_PPC64_REL24 overflow");
     // We preserve bits other than LI field, i.e. PO and AA/LK fields.
     uint32_t Inst = readBytesUnaligned(LocalAddress, 4);
     writeInt32BE(LocalAddress, (Inst & 0xFC000003) | (delta & 0x03FFFFFC));
   } break;
   case ELF::R_PPC64_REL32: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     int64_t delta = static_cast<int64_t>(Value - FinalAddress + Addend);
     if (SignExtend64<32>(delta) != delta)
       llvm_unreachable("Relocation R_PPC64_REL32 overflow");
     writeInt32BE(LocalAddress, delta);
   } break;
   case ELF::R_PPC64_REL64: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     uint64_t Delta = Value - FinalAddress + Addend;
     writeInt64BE(LocalAddress, Delta);
   } break;
   case ELF::R_PPC64_ADDR64:
     writeInt64BE(LocalAddress, Value + Addend);
     break;
   }
 }
 
-void RuntimeDyldELF::resolveSystemZRelocation(const SectionEntry &Section,
+void RuntimeDyldELF::resolveSystemZRelocation(const SectionEntryProxy Section,
                                               uint64_t Offset, uint64_t Value,
                                               uint32_t Type, int64_t Addend) {
-  uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
+  uint8_t *LocalAddress = Section->getAddressWithOffset(Offset);
   switch (Type) {
   default:
     llvm_unreachable("Relocation type not implemented yet!");
     break;
   case ELF::R_390_PC16DBL:
   case ELF::R_390_PLT16DBL: {
-    int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
+    int64_t Delta =
+        (Value + Addend) - Section->getLoadAddressWithOffset(Offset);
     assert(int16_t(Delta / 2) * 2 == Delta && "R_390_PC16DBL overflow");
     writeInt16BE(LocalAddress, Delta / 2);
     break;
   }
   case ELF::R_390_PC32DBL:
   case ELF::R_390_PLT32DBL: {
-    int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
+    int64_t Delta =
+        (Value + Addend) - Section->getLoadAddressWithOffset(Offset);
     assert(int32_t(Delta / 2) * 2 == Delta && "R_390_PC32DBL overflow");
     writeInt32BE(LocalAddress, Delta / 2);
     break;
   }
   case ELF::R_390_PC16: {
-    int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
+    int64_t Delta =
+        (Value + Addend) - Section->getLoadAddressWithOffset(Offset);
     assert(int16_t(Delta) == Delta && "R_390_PC16 overflow");
     writeInt16BE(LocalAddress, Delta);
     break;
   }
   case ELF::R_390_PC32: {
-    int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
+    int64_t Delta =
+        (Value + Addend) - Section->getLoadAddressWithOffset(Offset);
     assert(int32_t(Delta) == Delta && "R_390_PC32 overflow");
     writeInt32BE(LocalAddress, Delta);
     break;
   }
   case ELF::R_390_PC64: {
-    int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
+    int64_t Delta =
+        (Value + Addend) - Section->getLoadAddressWithOffset(Offset);
     writeInt64BE(LocalAddress, Delta);
     break;
   }
   case ELF::R_390_8:
     *LocalAddress = (uint8_t)(Value + Addend);
     break;
   case ELF::R_390_16:
     writeInt16BE(LocalAddress, Value + Addend);
     break;
   case ELF::R_390_32:
     writeInt32BE(LocalAddress, Value + Addend);
     break;
   case ELF::R_390_64:
     writeInt64BE(LocalAddress, Value + Addend);
     break;
   }
 }
 
-void RuntimeDyldELF::resolveBPFRelocation(const SectionEntry &Section,
+void RuntimeDyldELF::resolveBPFRelocation(const SectionEntryProxy Section,
                                           uint64_t Offset, uint64_t Value,
                                           uint32_t Type, int64_t Addend) {
   bool isBE = Arch == Triple::bpfeb;
 
   switch (Type) {
   default:
     llvm_unreachable("Relocation type not implemented yet!");
     break;
   case ELF::R_BPF_NONE:
     break;
   case ELF::R_BPF_64_64: {
-    write(isBE, Section.getAddressWithOffset(Offset), Value + Addend);
+    write(isBE, Section->getAddressWithOffset(Offset), Value + Addend);
     LLVM_DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
-                      << format("%p\n", Section.getAddressWithOffset(Offset)));
+                      << format("%p\n", Section->getAddressWithOffset(Offset)));
     break;
   }
   case ELF::R_BPF_64_32: {
     Value += Addend;
     assert(Value <= UINT32_MAX);
-    write(isBE, Section.getAddressWithOffset(Offset), static_cast<uint32_t>(Value));
+    write(isBE, Section->getAddressWithOffset(Offset),
+          static_cast<uint32_t>(Value));
     LLVM_DEBUG(dbgs() << "Writing " << format("%p", Value) << " at "
-                      << format("%p\n", Section.getAddressWithOffset(Offset)));
+                      << format("%p\n", Section->getAddressWithOffset(Offset)));
     break;
   }
   }
 }
 
 // The target location for the relocation is described by RE.SectionID and
 // RE.Offset.  RE.SectionID can be used to find the SectionEntry.  Each
 // SectionEntry has three members describing its location.

 // The Value parameter here is the load address of the symbol for the
 // relocation to be applied.  For relocations which refer to symbols in the
 // current object Value will be the LoadAddress of the section in which
 // the symbol resides (RE.Addend provides additional information about the
 // symbol location).  For external symbols, Value will be the address of the
 // symbol in the target address space.
 void RuntimeDyldELF::resolveRelocation(const RelocationEntry &RE,
                                        uint64_t Value) {
-  const SectionEntry &Section = Sections[RE.SectionID];
+  const SectionEntryProxy Section = Sections[RE.SectionID];
   return resolveRelocation(Section, RE.Offset, Value, RE.RelType, RE.Addend,
                            RE.SymOffset, RE.SectionID);
 }
 
-void RuntimeDyldELF::resolveRelocation(const SectionEntry &Section,
+void RuntimeDyldELF::resolveRelocation(const SectionEntryProxy Section,
                                        uint64_t Offset, uint64_t Value,
                                        uint32_t Type, int64_t Addend,
                                        uint64_t SymOffset, SID SectionID) {
   switch (Arch) {
   case Triple::x86_64:
     resolveX86_64Relocation(Section, Offset, Value, Type, Addend, SymOffset);
     break;
   case Triple::x86:
case Triple::bpfeb:
     resolveBPFRelocation(Section, Offset, Value, Type, Addend);
     break;
   default:
     llvm_unreachable("Unsupported CPU type!");
   }
 }
 
 void *RuntimeDyldELF::computePlaceholderAddress(unsigned SectionID, uint64_t Offset) const {
-  return (void *)(Sections[SectionID].getObjAddress() + Offset);
+  return (void *)(Sections[SectionID]->getObjAddress() + Offset);
 }
 
 void RuntimeDyldELF::processSimpleRelocation(unsigned SectionID, uint64_t Offset, unsigned RelType, RelocationValueRef Value) {
   RelocationEntry RE(SectionID, Offset, RelType, Value.Addend, Value.Offset);
   if (Value.SymbolName)
     addRelocationForSymbol(RE, Value.SymbolName);
   else
     addRelocationForSection(RE, Value.SectionID);
if (Value.SymbolName) {
     auto Loc = GlobalSymbolTable.find(Value.SymbolName);
 
     // Don't create direct branch for external symbols.
     if (Loc == GlobalSymbolTable.end())
       return false;
 
     const auto &SymInfo = Loc->second;
     Address =
-        uint64_t(Sections[SymInfo.getSectionID()].getLoadAddressWithOffset(
+        uint64_t(Sections[SymInfo.getSectionID()]->getLoadAddressWithOffset(
             SymInfo.getOffset()));
   } else {
-    Address = uint64_t(Sections[Value.SectionID].getLoadAddress());
+    Address = uint64_t(Sections[Value.SectionID]->getLoadAddress());
   }
   uint64_t Offset = RelI->getOffset();
-  uint64_t SourceAddress = Sections[SectionID].getLoadAddressWithOffset(Offset);
+  uint64_t SourceAddress =
+      Sections[SectionID]->getLoadAddressWithOffset(Offset);
 
   // R_AARCH64_CALL26 requires immediate to be in range -2^27 <= imm < 2^27
   // If distance between source and target is out of range then we should
   // create thunk.
   if (!isInt<28>(Address + Value.Addend - SourceAddress))
     return false;
 
   resolveRelocation(Sections[SectionID], Offset, Address, RelI->getType(),
                     Value.Addend);
 
   return true;
 }
 
 void RuntimeDyldELF::resolveAArch64Branch(unsigned SectionID,
                                           const RelocationValueRef &Value,
                                           relocation_iterator RelI,
                                           StubMap &Stubs) {
 
   LLVM_DEBUG(dbgs() << "\t\tThis is an AArch64 branch relocation.");
-  SectionEntry &Section = Sections[SectionID];
+  SectionEntryProxy Section = Sections[SectionID];
 
   uint64_t Offset = RelI->getOffset();
   unsigned RelType = RelI->getType();
   // Look for an existing stub.
   StubMap::const_iterator i = Stubs.find(Value);
   if (i != Stubs.end()) {
     resolveRelocation(Section, Offset,
-                      (uint64_t)Section.getAddressWithOffset(i->second),
+                      (uint64_t)Section->getAddressWithOffset(i->second),
                       RelType, 0);
     LLVM_DEBUG(dbgs() << " Stub function found\n");
   } else if (!resolveAArch64ShortBranch(SectionID, RelI, Value)) {
     // Create a new stub function.
     LLVM_DEBUG(dbgs() << " Create a new stub function\n");
-    Stubs[Value] = Section.getStubOffset();
+    Stubs[Value] = Section->getStubOffset();
     uint8_t *StubTargetAddr = createStubFunction(
-        Section.getAddressWithOffset(Section.getStubOffset()));
+        Section->getAddressWithOffset(Section->getStubOffset()));
 
-    RelocationEntry REmovz_g3(SectionID, StubTargetAddr - Section.getAddress(),
+    RelocationEntry REmovz_g3(SectionID, StubTargetAddr - Section->getAddress(),
                               ELF::R_AARCH64_MOVW_UABS_G3, Value.Addend);
     RelocationEntry REmovk_g2(SectionID,
-                              StubTargetAddr - Section.getAddress() + 4,
+                              StubTargetAddr - Section->getAddress() + 4,
                               ELF::R_AARCH64_MOVW_UABS_G2_NC, Value.Addend);
     RelocationEntry REmovk_g1(SectionID,
-                              StubTargetAddr - Section.getAddress() + 8,
+                              StubTargetAddr - Section->getAddress() + 8,
                               ELF::R_AARCH64_MOVW_UABS_G1_NC, Value.Addend);
     RelocationEntry REmovk_g0(SectionID,
-                              StubTargetAddr - Section.getAddress() + 12,
+                              StubTargetAddr - Section->getAddress() + 12,
                               ELF::R_AARCH64_MOVW_UABS_G0_NC, Value.Addend);
 
     if (Value.SymbolName) {
       addRelocationForSymbol(REmovz_g3, Value.SymbolName);
       addRelocationForSymbol(REmovk_g2, Value.SymbolName);
       addRelocationForSymbol(REmovk_g1, Value.SymbolName);
       addRelocationForSymbol(REmovk_g0, Value.SymbolName);
     } else {
       addRelocationForSection(REmovz_g3, Value.SectionID);
       addRelocationForSection(REmovk_g2, Value.SectionID);
       addRelocationForSection(REmovk_g1, Value.SectionID);
       addRelocationForSection(REmovk_g0, Value.SectionID);
     }
     resolveRelocation(Section, Offset,
-                      reinterpret_cast<uint64_t>(Section.getAddressWithOffset(
-                          Section.getStubOffset())),
+                      reinterpret_cast<uint64_t>(Section->getAddressWithOffset(
+                          Section->getStubOffset())),
                       RelType, 0);
-    Section.advanceStubOffset(getMaxStubSize());
+    Section->advanceStubOffset(getMaxStubSize());
   }
 }
 
 Expected<relocation_iterator>
 RuntimeDyldELF::processRelocationRef(
     unsigned SectionID, relocation_iterator RelI, const ObjectFile &O,
     ObjSectionToIDMap &ObjSectionToID, StubMap &Stubs) {
   const auto &Obj = cast<ELFObjectFileBase>(O);
if ((Arch == Triple::aarch64 || Arch == Triple::aarch64_be)) {
     } else {
       processSimpleRelocation(SectionID, Offset, RelType, Value);
     }
   } else if (Arch == Triple::arm) {
     if (RelType == ELF::R_ARM_PC24 || RelType == ELF::R_ARM_CALL ||
       RelType == ELF::R_ARM_JUMP24) {
       // This is an ARM branch relocation, need to use a stub function.
       LLVM_DEBUG(dbgs() << "\t\tThis is an ARM branch relocation.\n");
-      SectionEntry &Section = Sections[SectionID];
+      SectionEntryProxy Section = Sections[SectionID];
 
       // Look for an existing stub.
       StubMap::const_iterator i = Stubs.find(Value);
       if (i != Stubs.end()) {
-        resolveRelocation(
-            Section, Offset,
-            reinterpret_cast<uint64_t>(Section.getAddressWithOffset(i->second)),
+        resolveRelocation(Section, Offset,
+                          reinterpret_cast<uint64_t>(
+                              Section->getAddressWithOffset(i->second)),
                           RelType, 0);
         LLVM_DEBUG(dbgs() << " Stub function found\n");
       } else {
         // Create a new stub function.
         LLVM_DEBUG(dbgs() << " Create a new stub function\n");
-        Stubs[Value] = Section.getStubOffset();
+        Stubs[Value] = Section->getStubOffset();
         uint8_t *StubTargetAddr = createStubFunction(
-            Section.getAddressWithOffset(Section.getStubOffset()));
-        RelocationEntry RE(SectionID, StubTargetAddr - Section.getAddress(),
+            Section->getAddressWithOffset(Section->getStubOffset()));
+        RelocationEntry RE(SectionID, StubTargetAddr - Section->getAddress(),
                            ELF::R_ARM_ABS32, Value.Addend);
         if (Value.SymbolName)
           addRelocationForSymbol(RE, Value.SymbolName);
         else
           addRelocationForSection(RE, Value.SectionID);
 
-        resolveRelocation(Section, Offset, reinterpret_cast<uint64_t>(
-                                               Section.getAddressWithOffset(
-                                                   Section.getStubOffset())),
-                          RelType, 0);
-        Section.advanceStubOffset(getMaxStubSize());
+        resolveRelocation(
+            Section, Offset,
+            reinterpret_cast<uint64_t>(
+                Section->getAddressWithOffset(Section->getStubOffset())),
+        Section->advanceStubOffset(getMaxStubSize());
       }
     } else {
       uint32_t *Placeholder =
         reinterpret_cast<uint32_t*>(computePlaceholderAddress(SectionID, Offset));
       if (RelType == ELF::R_ARM_PREL31 || RelType == ELF::R_ARM_TARGET1 ||
           RelType == ELF::R_ARM_ABS32) {
         Value.Addend += *Placeholder;
       } else if (RelType == ELF::R_ARM_MOVW_ABS_NC || RelType == ELF::R_ARM_MOVT_ABS) {
         // See ELF for ARM documentation
         Value.Addend += (int16_t)((*Placeholder & 0xFFF) | (((*Placeholder >> 16) & 0xF) << 12));
       }
       processSimpleRelocation(SectionID, Offset, RelType, Value);
     }
   } else if (IsMipsO32ABI) {
     uint8_t *Placeholder = reinterpret_cast<uint8_t *>(
         computePlaceholderAddress(SectionID, Offset));
     uint32_t Opcode = readBytesUnaligned(Placeholder, 4);
     if (RelType == ELF::R_MIPS_26) {
       // This is an Mips branch relocation, need to use a stub function.
       LLVM_DEBUG(dbgs() << "\t\tThis is a Mips branch relocation.");
-      SectionEntry &Section = Sections[SectionID];
+      SectionEntryProxy Section = Sections[SectionID];
 
       // Extract the addend from the instruction.
       // We shift up by two since the Value will be down shifted again
       // when applying the relocation.
       uint32_t Addend = (Opcode & 0x03ffffff) << 2;
 
       Value.Addend += Addend;
 
       //  Look up for existing stub.
       StubMap::const_iterator i = Stubs.find(Value);
       if (i != Stubs.end()) {
         RelocationEntry RE(SectionID, Offset, RelType, i->second);
         addRelocationForSection(RE, SectionID);
         LLVM_DEBUG(dbgs() << " Stub function found\n");
       } else {
         // Create a new stub function.
         LLVM_DEBUG(dbgs() << " Create a new stub function\n");
-        Stubs[Value] = Section.getStubOffset();
+        Stubs[Value] = Section->getStubOffset();
 
         unsigned AbiVariant = Obj.getPlatformFlags();
 
         uint8_t *StubTargetAddr = createStubFunction(
-            Section.getAddressWithOffset(Section.getStubOffset()), AbiVariant);
+            Section->getAddressWithOffset(Section->getStubOffset()),
+            AbiVariant);
 
         // Creating Hi and Lo relocations for the filled stub instructions.
-        RelocationEntry REHi(SectionID, StubTargetAddr - Section.getAddress(),
+        RelocationEntry REHi(SectionID, StubTargetAddr - Section->getAddress(),
                              ELF::R_MIPS_HI16, Value.Addend);
         RelocationEntry RELo(SectionID,
-                             StubTargetAddr - Section.getAddress() + 4,
+                             StubTargetAddr - Section->getAddress() + 4,
                              ELF::R_MIPS_LO16, Value.Addend);
 
         if (Value.SymbolName) {
           addRelocationForSymbol(REHi, Value.SymbolName);
           addRelocationForSymbol(RELo, Value.SymbolName);
         } else {
           addRelocationForSection(REHi, Value.SectionID);
           addRelocationForSection(RELo, Value.SectionID);
         }
 
-        RelocationEntry RE(SectionID, Offset, RelType, Section.getStubOffset());
+        RelocationEntry RE(SectionID, Offset, RelType,
+                           Section->getStubOffset());
         addRelocationForSection(RE, SectionID);
-        Section.advanceStubOffset(getMaxStubSize());
+        Section->advanceStubOffset(getMaxStubSize());
       }
     } else if (RelType == ELF::R_MIPS_HI16 || RelType == ELF::R_MIPS_PCHI16) {
       int64_t Addend = (Opcode & 0x0000ffff) << 16;
       RelocationEntry RE(SectionID, Offset, RelType, Addend);
       PendingRelocs.push_back(std::make_pair(Value, RE));
     } else if (RelType == ELF::R_MIPS_LO16 || RelType == ELF::R_MIPS_PCLO16) {
       int64_t Addend = Value.Addend + SignExtend32<16>(Opcode & 0x0000ffff);
       for (auto I = PendingRelocs.begin(); I != PendingRelocs.end();) {
if (r_type == ELF::R_MIPS_CALL16 || r_type == ELF::R_MIPS_GOT_PAGE
       }
       if (Value.SymbolName)
         addRelocationForSymbol(RE, Value.SymbolName);
       else
         addRelocationForSection(RE, Value.SectionID);
     } else if (RelType == ELF::R_MIPS_26) {
       // This is an Mips branch relocation, need to use a stub function.
       LLVM_DEBUG(dbgs() << "\t\tThis is a Mips branch relocation.");
-      SectionEntry &Section = Sections[SectionID];
+      SectionEntryProxy Section = Sections[SectionID];
 
       //  Look up for existing stub.
       StubMap::const_iterator i = Stubs.find(Value);
       if (i != Stubs.end()) {
         RelocationEntry RE(SectionID, Offset, RelType, i->second);
         addRelocationForSection(RE, SectionID);
         LLVM_DEBUG(dbgs() << " Stub function found\n");
       } else {
         // Create a new stub function.
         LLVM_DEBUG(dbgs() << " Create a new stub function\n");
-        Stubs[Value] = Section.getStubOffset();
+        Stubs[Value] = Section->getStubOffset();
 
         unsigned AbiVariant = Obj.getPlatformFlags();
 
         uint8_t *StubTargetAddr = createStubFunction(
-            Section.getAddressWithOffset(Section.getStubOffset()), AbiVariant);
+            Section->getAddressWithOffset(Section->getStubOffset()),
+            AbiVariant);
 
         if (IsMipsN32ABI) {
           // Creating Hi and Lo relocations for the filled stub instructions.
-          RelocationEntry REHi(SectionID, StubTargetAddr - Section.getAddress(),
+          RelocationEntry REHi(SectionID,
+                               StubTargetAddr - Section->getAddress(),
                                ELF::R_MIPS_HI16, Value.Addend);
           RelocationEntry RELo(SectionID,
-                               StubTargetAddr - Section.getAddress() + 4,
+                               StubTargetAddr - Section->getAddress() + 4,
                                ELF::R_MIPS_LO16, Value.Addend);
           if (Value.SymbolName) {
             addRelocationForSymbol(REHi, Value.SymbolName);
             addRelocationForSymbol(RELo, Value.SymbolName);
           } else {
             addRelocationForSection(REHi, Value.SectionID);
             addRelocationForSection(RELo, Value.SectionID);
           }
         } else {
           // Creating Highest, Higher, Hi and Lo relocations for the filled stub
           // instructions.
           RelocationEntry REHighest(SectionID,
-                                    StubTargetAddr - Section.getAddress(),
+                                    StubTargetAddr - Section->getAddress(),
                                     ELF::R_MIPS_HIGHEST, Value.Addend);
           RelocationEntry REHigher(SectionID,
-                                   StubTargetAddr - Section.getAddress() + 4,
+                                   StubTargetAddr - Section->getAddress() + 4,
                                    ELF::R_MIPS_HIGHER, Value.Addend);
           RelocationEntry REHi(SectionID,
-                               StubTargetAddr - Section.getAddress() + 12,
+                               StubTargetAddr - Section->getAddress() + 12,
                                ELF::R_MIPS_HI16, Value.Addend);
           RelocationEntry RELo(SectionID,
-                               StubTargetAddr - Section.getAddress() + 20,
+                               StubTargetAddr - Section->getAddress() + 20,
                                ELF::R_MIPS_LO16, Value.Addend);
           if (Value.SymbolName) {
             addRelocationForSymbol(REHighest, Value.SymbolName);
             addRelocationForSymbol(REHigher, Value.SymbolName);
             addRelocationForSymbol(REHi, Value.SymbolName);
             addRelocationForSymbol(RELo, Value.SymbolName);
           } else {
             addRelocationForSection(REHighest, Value.SectionID);
             addRelocationForSection(REHigher, Value.SectionID);
             addRelocationForSection(REHi, Value.SectionID);
             addRelocationForSection(RELo, Value.SectionID);
           }
         }
-        RelocationEntry RE(SectionID, Offset, RelType, Section.getStubOffset());
+        RelocationEntry RE(SectionID, Offset, RelType,
+                           Section->getStubOffset());
         addRelocationForSection(RE, SectionID);
-        Section.advanceStubOffset(getMaxStubSize());
+        Section->advanceStubOffset(getMaxStubSize());
       }
     } else {
       processSimpleRelocation(SectionID, Offset, RelType, Value);
     }
 
   } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
     if (RelType == ELF::R_PPC64_REL24) {
       // Determine ABI variant in use for this object.
       unsigned AbiVariant = Obj.getPlatformFlags();
       AbiVariant &= ELF::EF_PPC64_ABI;
       // A PPC branch relocation will need a stub function if the target is
       // an external symbol (either Value.SymbolName is set, or SymType is
       // Symbol::ST_Unknown) or if the target address is not within the
       // signed 24-bits branch address.
-      SectionEntry &Section = Sections[SectionID];
-      uint8_t *Target = Section.getAddressWithOffset(Offset);
+      SectionEntryProxy Section = Sections[SectionID];
+      uint8_t *Target = Section->getAddressWithOffset(Offset);
       bool RangeOverflow = false;
       bool IsExtern = Value.SymbolName || SymType == SymbolRef::ST_Unknown;
       if (!IsExtern) {
         if (AbiVariant != 2) {
           // In the ELFv1 ABI, a function call may point to the .opd entry,
           // so the final symbol value is calculated based on the relocation
           // values in the .opd section.
           if (auto Err = findOPDEntrySection(Obj, ObjSectionToID, Value))
             return std::move(Err);
         } else {
           // In the ELFv2 ABI, a function symbol may provide a local entry
           // point, which must be used for direct calls.
           if (Value.SectionID == SectionID){
             uint8_t SymOther = Symbol->getOther();
             Value.Addend += ELF::decodePPC64LocalEntryOffset(SymOther);
           }
         }
         uint8_t *RelocTarget =
-            Sections[Value.SectionID].getAddressWithOffset(Value.Addend);
+            Sections[Value.SectionID]->getAddressWithOffset(Value.Addend);
         int64_t delta = static_cast<int64_t>(Target - RelocTarget);
         // If it is within 26-bits branch range, just set the branch target
         if (SignExtend64<26>(delta) != delta) {
           RangeOverflow = true;
         } else if ((AbiVariant != 2) ||
                    (AbiVariant == 2  && Value.SectionID == SectionID)) {
           RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
           addRelocationForSection(RE, Value.SectionID);
         }
       }
       if (IsExtern || (AbiVariant == 2 && Value.SectionID != SectionID) ||
           RangeOverflow) {
         // It is an external symbol (either Value.SymbolName is set, or
         // SymType is SymbolRef::ST_Unknown) or out of range.
         StubMap::const_iterator i = Stubs.find(Value);
         if (i != Stubs.end()) {
           // Symbol function stub already created, just relocate to it
           resolveRelocation(Section, Offset,
                             reinterpret_cast<uint64_t>(
-                                Section.getAddressWithOffset(i->second)),
+                                Section->getAddressWithOffset(i->second)),
                             RelType, 0);
           LLVM_DEBUG(dbgs() << " Stub function found\n");
         } else {
           // Create a new stub function.
           LLVM_DEBUG(dbgs() << " Create a new stub function\n");
-          Stubs[Value] = Section.getStubOffset();
+          Stubs[Value] = Section->getStubOffset();
           uint8_t *StubTargetAddr = createStubFunction(
-              Section.getAddressWithOffset(Section.getStubOffset()),
+              Section->getAddressWithOffset(Section->getStubOffset()),
               AbiVariant);
-          RelocationEntry RE(SectionID, StubTargetAddr - Section.getAddress(),
+          RelocationEntry RE(SectionID, StubTargetAddr - Section->getAddress(),
                              ELF::R_PPC64_ADDR64, Value.Addend);
 
           // Generates the 64-bits address loads as exemplified in section
           // 4.5.1 in PPC64 ELF ABI.  Note that the relocations need to
           // apply to the low part of the instructions, so we have to update
           // the offset according to the target endianness.
-          uint64_t StubRelocOffset = StubTargetAddr - Section.getAddress();
+          uint64_t StubRelocOffset = StubTargetAddr - Section->getAddress();
           if (!IsTargetLittleEndian)
             StubRelocOffset += 2;
 
           RelocationEntry REhst(SectionID, StubRelocOffset + 0,
                                 ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend);
           RelocationEntry REhr(SectionID, StubRelocOffset + 4,
                                ELF::R_PPC64_ADDR16_HIGHER, Value.Addend);
           RelocationEntry REh(SectionID, StubRelocOffset + 12,
                               ELF::R_PPC64_ADDR16_HI, Value.Addend);
           RelocationEntry REl(SectionID, StubRelocOffset + 16,
                               ELF::R_PPC64_ADDR16_LO, Value.Addend);
 
           if (Value.SymbolName) {
             addRelocationForSymbol(REhst, Value.SymbolName);
             addRelocationForSymbol(REhr, Value.SymbolName);
             addRelocationForSymbol(REh, Value.SymbolName);
             addRelocationForSymbol(REl, Value.SymbolName);
           } else {
             addRelocationForSection(REhst, Value.SectionID);
             addRelocationForSection(REhr, Value.SectionID);
             addRelocationForSection(REh, Value.SectionID);
             addRelocationForSection(REl, Value.SectionID);
           }
 
-          resolveRelocation(Section, Offset, reinterpret_cast<uint64_t>(
-                                                 Section.getAddressWithOffset(
-                                                     Section.getStubOffset())),
-                            RelType, 0);
-          Section.advanceStubOffset(getMaxStubSize());
+          resolveRelocation(
+              Section, Offset,
+              reinterpret_cast<uint64_t>(
+                  Section->getAddressWithOffset(Section->getStubOffset())),
+          Section->advanceStubOffset(getMaxStubSize());
         }
         if (IsExtern || (AbiVariant == 2 && Value.SectionID != SectionID)) {
           // Restore the TOC for external calls
           if (AbiVariant == 2)
             writeInt32BE(Target + 4, 0xE8410018); // ld r2,24(r1)
           else
             writeInt32BE(Target + 4, 0xE8410028); // ld r2,40(r1)
         }
if ((Arch == Triple::aarch64 || Arch == Triple::aarch64_be)) {
     // full address of the symbol, as needed by GOT references, and the
     // executable part only adds an overhead of 8 bytes.
     //
     // We could try to conserve space by allocating the code and data
     // parts of the stub separately.  However, as things stand, we allocate
     // a stub for every relocation, so using a GOT in JIT code should be
     // no less space efficient than using an explicit constant pool.
     LLVM_DEBUG(dbgs() << "\t\tThis is a SystemZ indirect relocation.");
-    SectionEntry &Section = Sections[SectionID];
+    SectionEntryProxy Section = Sections[SectionID];
 
     // Look for an existing stub.
     StubMap::const_iterator i = Stubs.find(Value);
     uintptr_t StubAddress;
     if (i != Stubs.end()) {
-      StubAddress = uintptr_t(Section.getAddressWithOffset(i->second));
+      StubAddress = uintptr_t(Section->getAddressWithOffset(i->second));
       LLVM_DEBUG(dbgs() << " Stub function found\n");
     } else {
       // Create a new stub function.
       LLVM_DEBUG(dbgs() << " Create a new stub function\n");
 
-      uintptr_t BaseAddress = uintptr_t(Section.getAddress());
+      uintptr_t BaseAddress = uintptr_t(Section->getAddress());
       uintptr_t StubAlignment = getStubAlignment();
       StubAddress =
-          (BaseAddress + Section.getStubOffset() + StubAlignment - 1) &
+          (BaseAddress + Section->getStubOffset() + StubAlignment - 1) &
           -StubAlignment;
       unsigned StubOffset = StubAddress - BaseAddress;
 
       Stubs[Value] = StubOffset;
       createStubFunction((uint8_t *)StubAddress);
       RelocationEntry RE(SectionID, StubOffset + 8, ELF::R_390_64,
                          Value.Offset);
       if (Value.SymbolName)
         addRelocationForSymbol(RE, Value.SymbolName);
       else
         addRelocationForSection(RE, Value.SectionID);
-      Section.advanceStubOffset(getMaxStubSize());
+      Section->advanceStubOffset(getMaxStubSize());
     }
 
     if (RelType == ELF::R_390_GOTENT)
       resolveRelocation(Section, Offset, StubAddress + 8, ELF::R_390_PC32DBL,
                         Addend);
     else
       resolveRelocation(Section, Offset, StubAddress, RelType, Addend);
   } else if (Arch == Triple::x86_64) {
if (RelType == ELF::R_X86_64_PLT32) {
       // can't be sure the function will be within 2^32 bytes of the call site, so
       // we need to create a stub, which calls into the GOT.  This case is
       // equivalent to the usual PLT implementation except that we use the stub
       // mechanism in RuntimeDyld (which puts stubs at the end of the section)
       // rather than allocating a PLT section.
       if (Value.SymbolName) {
         // This is a call to an external function.
         // Look for an existing stub.
-        SectionEntry &Section = Sections[SectionID];
+        SectionEntryProxy Section = Sections[SectionID];
         StubMap::const_iterator i = Stubs.find(Value);
         uintptr_t StubAddress;
         if (i != Stubs.end()) {
-          StubAddress = uintptr_t(Section.getAddress()) + i->second;
+          StubAddress = uintptr_t(Section->getAddress()) + i->second;
           LLVM_DEBUG(dbgs() << " Stub function found\n");
         } else {
           // Create a new stub function (equivalent to a PLT entry).
           LLVM_DEBUG(dbgs() << " Create a new stub function\n");
 
-          uintptr_t BaseAddress = uintptr_t(Section.getAddress());
+          uintptr_t BaseAddress = uintptr_t(Section->getAddress());
           uintptr_t StubAlignment = getStubAlignment();
           StubAddress =
-              (BaseAddress + Section.getStubOffset() + StubAlignment - 1) &
+              (BaseAddress + Section->getStubOffset() + StubAlignment - 1) &
               -StubAlignment;
           unsigned StubOffset = StubAddress - BaseAddress;
           Stubs[Value] = StubOffset;
           createStubFunction((uint8_t *)StubAddress);
 
           // Bump our stub offset counter
-          Section.advanceStubOffset(getMaxStubSize());
+          Section->advanceStubOffset(getMaxStubSize());
 
           // Allocate a GOT Entry
           uint64_t GOTOffset = allocateGOTEntries(1);
 
           // The load of the GOT address has an addend of -4
           resolveGOTOffsetRelocation(SectionID, StubOffset + 2, GOTOffset - 4,
                                      ELF::R_X86_64_PC32);
 

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h

 private:
   uint64_t Offset = 0;
   unsigned SectionID = 0;
   JITSymbolFlags Flags = JITSymbolFlags::None;
 };
 
 typedef StringMap<SymbolTableEntry> RTDyldSymbolTable;
 
+class SectionList : SmallVector<SectionEntry, 64> {
+  typedef SmallVector<SectionEntry, 64> ListTy;
+
+public:
+  typedef unsigned SID; // Type for SectionIDs
+
+  class SectionEntryProxy {
+    ListTy &Sections;
+    SID const Sid;
+
+  public:
+    SectionEntryProxy(ListTy &Sections, SID Sid)
+        : Sections{Sections}, Sid(Sid) {}
+    SectionEntry const *operator->() const { return Sections.data() + Sid; }
+    SectionEntry *operator->() { return &Sections[Sid]; }
+    SectionEntryProxy &operator=(SectionEntry const &SE) {
+      Sections[Sid] = SE;
+      return *this;
+    }
+  };
+  class SectionEntryConstProxy {
+    ListTy const &Sections;
+    SID const Sid;
+
+  public:
+    SectionEntryConstProxy(ListTy const &Sections, SID Sid)
+        : Sections{Sections}, Sid(Sid) {}
+    SectionEntry const *operator->() const { return Sections.data() + Sid; }
+  };
+
+  struct iterator
+      : std::iterator<std::forward_iterator_tag, SectionEntryProxy> {
+    ListTy &Sections;
+    SID Sid;
+
+  public:
+    iterator(ListTy &Sections, SID Sid) : Sections(Sections), Sid(Sid) {}
+    value_type operator*() { return {Sections, Sid}; }
+    iterator operator++() {
+      ++Sid;
+      return *this;
+    }
+    iterator operator++(int) {
+      iterator other(*this);
+      ++Sid;
+      return other;
+    }
+
+    bool operator==(iterator const &other) { return Sid == other.Sid; }
+    bool operator!=(iterator const &other) { return Sid != other.Sid; }
+    bool operator<(iterator const &other) { return Sid < other.Sid; }
+    bool operator<=(iterator const &other) { return Sid <= other.Sid; }
+    bool operator>(iterator const &other) { return Sid > other.Sid; }
+    bool operator>=(iterator const &other) { return Sid >= other.Sid; }
+  };
+
+  SectionEntryProxy operator[](SID Index) {
+    return {*static_cast<ListTy *>(this), Index};
+  }
+  SectionEntryConstProxy operator[](SID Index) const {
+    return {*static_cast<ListTy const *>(this), Index};
+  }
+
+  using ListTy::ListTy;
+  using ListTy::push_back;
+  using ListTy::size;
+
+  SectionEntryProxy front() { return {*static_cast<ListTy *>(this), 0}; }
+
+  SectionEntryProxy back() {
+    return {*static_cast<ListTy *>(this), (SID)size() - 1};
+  }
+
+  iterator begin() { return {*static_cast<ListTy *>(this), 0}; }
+
+  iterator end() { return {*static_cast<ListTy *>(this), (SID)size()}; }
+};
+
 class RuntimeDyldImpl {
   friend class RuntimeDyld::LoadedObjectInfo;
 protected:
   static const unsigned AbsoluteSymbolSection = ~0U;
 
   // The MemoryManager to load objects into.
   RuntimeDyld::MemoryManager &MemMgr;
 
   // The symbol resolver to use for external symbols.
   JITSymbolResolver &Resolver;
 
+  using SID = SectionList::SID;
+  using SectionEntryProxy = SectionList::SectionEntryProxy;
+  using SectionEntryConstProxy = SectionList::SectionEntryConstProxy;
+
+  static constexpr SID RTDYLD_INVALID_SECTION_ID = (SID)(-1);
+
   // A list of all sections emitted by the dynamic linker.  These sections are
   // referenced in the code by means of their index in this list - SectionID.
-  typedef SmallVector<SectionEntry, 64> SectionList;
   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;
 
   // A global symbol table for symbols from all loaded modules.
   RTDyldSymbolTable GlobalSymbolTable;
 
   // Keep a map of common symbols to their info pairs
public:
   void setProcessAllSections(bool ProcessAllSections) {
     this->ProcessAllSections = ProcessAllSections;
   }
 
   virtual std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
   loadObject(const object::ObjectFile &Obj) = 0;
 
   uint64_t getSectionLoadAddress(unsigned SectionID) const {
-    return Sections[SectionID].getLoadAddress();
+    return Sections[SectionID]->getLoadAddress();
   }
 
   uint8_t *getSectionAddress(unsigned SectionID) const {
-    return Sections[SectionID].getAddress();
+    return Sections[SectionID]->getAddress();
   }
 
   StringRef getSectionContent(unsigned SectionID) const {
-    return StringRef(reinterpret_cast<char *>(Sections[SectionID].getAddress()),
-                     Sections[SectionID].getStubOffset() + getMaxStubSize());
+    return StringRef(
+        reinterpret_cast<char *>(Sections[SectionID]->getAddress()),
+        Sections[SectionID]->getStubOffset() + getMaxStubSize());
   }
 
   uint8_t* getSymbolLocalAddress(StringRef Name) const {
     // FIXME: Just look up as a function for now. Overly simple of course.
     // Work in progress.
     RTDyldSymbolTable::const_iterator pos = GlobalSymbolTable.find(Name);
     if (pos == GlobalSymbolTable.end())
       return nullptr;

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h

public:
   static std::unique_ptr<RuntimeDyldMachO>
   create(Triple::ArchType Arch,
          RuntimeDyld::MemoryManager &MemMgr,
          JITSymbolResolver &Resolver);
 
   std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
   loadObject(const object::ObjectFile &O) override;
 
-  SectionEntry &getSection(unsigned SectionID) { return Sections[SectionID]; }
+  SectionEntryProxy getSection(unsigned SectionID) {
+    return Sections[SectionID];
+  }
 
   bool isCompatibleFile(const object::ObjectFile &Obj) const override;
 };
 
 /// RuntimeDyldMachOTarget - Templated base class for generic MachO linker
 /// algorithms and data structures.
 ///
 /// Concrete, target specific sub-classes can be accessed via the impl()

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp

 };
 
 }
 
 namespace llvm {
 
 int64_t RuntimeDyldMachO::memcpyAddend(const RelocationEntry &RE) const {
   unsigned NumBytes = 1 << RE.Size;
-  uint8_t *Src = Sections[RE.SectionID].getAddress() + RE.Offset;
+  uint8_t *Src = Sections[RE.SectionID]->getAddress() + RE.Offset;
 
   return static_cast<int64_t>(readBytesUnaligned(Src, NumBytes));
 }
 
 Expected<relocation_iterator>
 RuntimeDyldMachO::processScatteredVANILLA(
                           unsigned SectionID, relocation_iterator RelI,
                           const ObjectFile &BaseObjT,
                           RuntimeDyldMachO::ObjSectionToIDMap &ObjSectionToID,
                           bool TargetIsLocalThumbFunc) {
   const MachOObjectFile &Obj =
     static_cast<const MachOObjectFile&>(BaseObjT);
   MachO::any_relocation_info RE =
     Obj.getRelocation(RelI->getRawDataRefImpl());
 
-  SectionEntry &Section = Sections[SectionID];
+  SectionEntryProxy Section = Sections[SectionID];
   uint32_t RelocType = Obj.getAnyRelocationType(RE);
   bool IsPCRel = Obj.getAnyRelocationPCRel(RE);
   unsigned Size = Obj.getAnyRelocationLength(RE);
   uint64_t Offset = RelI->getOffset();
-  uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
+  uint8_t *LocalAddress = Section->getAddressWithOffset(Offset);
   unsigned NumBytes = 1 << Size;
   int64_t Addend = readBytesUnaligned(LocalAddress, NumBytes);
 
   unsigned SymbolBaseAddr = Obj.getScatteredRelocationValue(RE);
   section_iterator TargetSI = getSectionByAddress(Obj, SymbolBaseAddr);
   assert(TargetSI != Obj.section_end() && "Can't find section for symbol");
   uint64_t SectionBaseAddr = TargetSI->getAddress();
   SectionRef TargetSection = *TargetSI;
void RuntimeDyldMachO::makeValueAddendPCRel(RelocationValueRef &Value,
                                             unsigned OffsetToNextPC) {
   auto &O = *cast<MachOObjectFile>(RI->getObject());
   section_iterator SecI = O.getRelocationRelocatedSection(RI);
   Value.Offset += RI->getOffset() + OffsetToNextPC + SecI->getAddress();
 }
 
 void RuntimeDyldMachO::dumpRelocationToResolve(const RelocationEntry &RE,
                                                uint64_t Value) const {
-  const SectionEntry &Section = Sections[RE.SectionID];
-  uint8_t *LocalAddress = Section.getAddress() + RE.Offset;
-  uint64_t FinalAddress = Section.getLoadAddress() + RE.Offset;
+  SectionEntryConstProxy Section = Sections[RE.SectionID];
+  uint8_t *LocalAddress = Section->getAddress() + RE.Offset;
+  uint64_t FinalAddress = Section->getLoadAddress() + RE.Offset;
 
   dbgs() << "resolveRelocation Section: " << RE.SectionID
          << " LocalAddress: " << format("%p", LocalAddress)
          << " FinalAddress: " << format("0x%016" PRIx64, FinalAddress)
          << " Value: " << format("0x%016" PRIx64, Value) << " Addend: " << RE.Addend
          << " isPCRel: " << RE.IsPCRel << " MachoType: " << RE.RelType
          << " Size: " << (1 << RE.Size) << "\n";
 }
Error RuntimeDyldMachO::populateIndirectSymbolPointersSection(
   const unsigned PTEntrySize = 4;
   unsigned NumPTEntries = PTSectionSize / PTEntrySize;
   unsigned PTEntryOffset = 0;
 
   assert((PTSectionSize % PTEntrySize) == 0 &&
          "Pointers section does not contain a whole number of stubs?");
 
   LLVM_DEBUG(dbgs() << "Populating pointer table section "
-                    << Sections[PTSectionID].getName() << ", Section ID "
+                    << Sections[PTSectionID]->getName() << ", Section ID "
                     << PTSectionID << ", " << NumPTEntries << " entries, "
                     << PTEntrySize << " bytes each:\n");
 
   for (unsigned i = 0; i < NumPTEntries; ++i) {
     unsigned SymbolIndex =
       Obj.getIndirectSymbolTableEntry(DySymTabCmd, FirstIndirectSymbol + i);
     symbol_iterator SI = Obj.getSymbolByIndex(SymbolIndex);
     StringRef IndirectSymbolName;
if (Augmentationsize != 0) {
     TargetPtrT LSDA = readBytesUnaligned(P, sizeof(TargetPtrT));
     TargetPtrT NewLSDA = LSDA - DeltaForEH;
     writeBytesUnaligned(NewLSDA, P, sizeof(TargetPtrT));
   }
 
   return Ret;
 }
 
-static int64_t computeDelta(SectionEntry *A, SectionEntry *B) {
+static int64_t computeDelta(SectionList::SectionEntryProxy A,
+                            SectionList::SectionEntryProxy B) {
   int64_t ObjDistance = static_cast<int64_t>(A->getObjAddress()) -
                         static_cast<int64_t>(B->getObjAddress());
   int64_t MemDistance = A->getLoadAddress() - B->getLoadAddress();
   return ObjDistance - MemDistance;
 }
 
 template <typename Impl>
 void RuntimeDyldMachOCRTPBase<Impl>::registerEHFrames() {
 
   for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) {
     EHFrameRelatedSections &SectionInfo = UnregisteredEHFrameSections[i];
     if (SectionInfo.EHFrameSID == RTDYLD_INVALID_SECTION_ID ||
         SectionInfo.TextSID == RTDYLD_INVALID_SECTION_ID)
       continue;
-    SectionEntry *Text = &Sections[SectionInfo.TextSID];
-    SectionEntry *EHFrame = &Sections[SectionInfo.EHFrameSID];
-    SectionEntry *ExceptTab = nullptr;
+    SectionEntryProxy Text = Sections[SectionInfo.TextSID];
+    SectionEntryProxy EHFrame = Sections[SectionInfo.EHFrameSID];
+    SID ExceptTabIndex = RTDYLD_INVALID_SECTION_ID;
     if (SectionInfo.ExceptTabSID != RTDYLD_INVALID_SECTION_ID)
-      ExceptTab = &Sections[SectionInfo.ExceptTabSID];
+      ExceptTabIndex = SectionInfo.ExceptTabSID;
 
     int64_t DeltaForText = computeDelta(Text, EHFrame);
     int64_t DeltaForEH = 0;
-    if (ExceptTab)
-      DeltaForEH = computeDelta(ExceptTab, EHFrame);
+    if (ExceptTabIndex != RTDYLD_INVALID_SECTION_ID)
+      DeltaForEH = computeDelta(Sections[ExceptTabIndex], EHFrame);
 
     uint8_t *P = EHFrame->getAddress();
     uint8_t *End = P + EHFrame->getSize();
     while (P != End) {
       P = processFDE(P, DeltaForText, DeltaForEH);
     }
 
     MemMgr.registerEHFrames(EHFrame->getAddress(), EHFrame->getLoadAddress(),

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFAArch64.h

private:
   SmallVector<SID, 2> UnregisteredEHFrameSections;
   SmallVector<SID, 2> RegisteredEHFrameSections;
   uint64_t ImageBase;
 
   // Fake an __ImageBase pointer by returning the section with the lowest adress
   uint64_t getImageBase() {
     if (!ImageBase) {
       ImageBase = std::numeric_limits<uint64_t>::max();
-      for (const SectionEntry &Section : Sections)
+      for (const SectionEntryProxy &Section : Sections)
         // The Sections list may contain sections that weren't loaded for
         // whatever reason: they may be debug sections, and ProcessAllSections
         // is false, or they may be sections that contain 0 bytes. If the
         // section isn't loaded, the load address will be 0, and it should not
         // be included in the ImageBase calculation.
-        if (Section.getLoadAddress() != 0)
-          ImageBase = std::min(ImageBase, Section.getLoadAddress());
+        if (Section->getLoadAddress() != 0)
+          ImageBase = std::min(ImageBase, Section->getLoadAddress());
     }
     return ImageBase;
   }
 
 public:
   RuntimeDyldCOFFAArch64(RuntimeDyld::MemoryManager &MM,
                          JITSymbolResolver &Resolver)
       : RuntimeDyldCOFF(MM, Resolver), ImageBase(0) {}
 
   unsigned getStubAlignment() override { return 8; }
 
   unsigned getMaxStubSize() const override { return 20; }
 
   std::tuple<uint64_t, uint64_t, uint64_t>
   generateRelocationStub(unsigned SectionID, StringRef TargetName,
                          uint64_t Offset, uint64_t RelType, uint64_t Addend,
                          StubMap &Stubs) {
     uintptr_t StubOffset;
-    SectionEntry &Section = Sections[SectionID];
+    SectionEntryProxy Section = Sections[SectionID];
 
     RelocationValueRef OriginalRelValueRef;
     OriginalRelValueRef.SectionID = SectionID;
     OriginalRelValueRef.Offset = Offset;
     OriginalRelValueRef.Addend = Addend;
     OriginalRelValueRef.SymbolName = TargetName.data();
 
     auto Stub = Stubs.find(OriginalRelValueRef);
     if (Stub == Stubs.end()) {
       LLVM_DEBUG(dbgs() << " Create a new stub function for "
                         << TargetName.data() << "\n");
 
-      StubOffset = Section.getStubOffset();
+      StubOffset = Section->getStubOffset();
       Stubs[OriginalRelValueRef] = StubOffset;
-      createStubFunction(Section.getAddressWithOffset(StubOffset));
-      Section.advanceStubOffset(getMaxStubSize());
+      createStubFunction(Section->getAddressWithOffset(StubOffset));
+      Section->advanceStubOffset(getMaxStubSize());
     } else {
       LLVM_DEBUG(dbgs() << " Stub function found for " << TargetName.data()
                         << "\n");
       StubOffset = Stub->second;
     }
 
     // Resolve original relocation to stub function.
     const RelocationEntry RE(SectionID, Offset, RelType, Addend);
-    resolveRelocation(RE, Section.getLoadAddressWithOffset(StubOffset));
+    resolveRelocation(RE, Section->getLoadAddressWithOffset(StubOffset));
 
     // adjust relocation info so resolution writes to the stub function
     // Here an internal relocation type is used for resolving long branch via
     // stub instruction.
     Addend = 0;
     Offset = StubOffset;
     RelType = INTERNAL_REL_ARM64_LONG_BRANCH26;
 
processRelocationRef(unsigned SectionID, object::relocation_iterator RelI,
     uint64_t RelType = RelI->getType();
     uint64_t Offset = RelI->getOffset();
 
     // If there is no section, this must be an external reference.
     const bool IsExtern = Section == Obj.section_end();
 
     // Determine the Addend used to adjust the relocation value.
     uint64_t Addend = 0;
-    SectionEntry &AddendSection = Sections[SectionID];
-    uintptr_t ObjTarget = AddendSection.getObjAddress() + Offset;
+    SectionEntryProxy AddendSection = Sections[SectionID];
+    uintptr_t ObjTarget = AddendSection->getObjAddress() + Offset;
     uint8_t *Displacement = (uint8_t *)ObjTarget;
 
     switch (RelType) {
     case COFF::IMAGE_REL_ARM64_ADDR32:
     case COFF::IMAGE_REL_ARM64_ADDR32NB:
     case COFF::IMAGE_REL_ARM64_REL32:
     case COFF::IMAGE_REL_ARM64_SECREL:
       Addend = read32le(Displacement);
if (IsExtern) {
       RelocationEntry RE(SectionID, Offset, RelType, TargetOffset + Addend);
       addRelocationForSection(RE, TargetSectionID);
     }
     return ++RelI;
   }
 
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
     const auto Section = Sections[RE.SectionID];
-    uint8_t *Target = Section.getAddressWithOffset(RE.Offset);
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
+    uint8_t *Target = Section->getAddressWithOffset(RE.Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(RE.Offset);
 
     switch (RE.RelType) {
     default:
       llvm_unreachable("unsupported relocation type");
     case COFF::IMAGE_REL_ARM64_ABSOLUTE: {
       // This relocation is ignored.
       break;
     }

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFI386.h

if (!SectionOrErr)
       return SectionOrErr.takeError();
     auto Section = *SectionOrErr;
 
     uint64_t RelType = RelI->getType();
     uint64_t Offset = RelI->getOffset();
 
     // Determine the Addend used to adjust the relocation value.
     uint64_t Addend = 0;
-    SectionEntry &AddendSection = Sections[SectionID];
-    uintptr_t ObjTarget = AddendSection.getObjAddress() + Offset;
+    SectionEntryProxy AddendSection = Sections[SectionID];
+    uintptr_t ObjTarget = AddendSection->getObjAddress() + Offset;
     uint8_t *Displacement = (uint8_t *)ObjTarget;
 
     switch (RelType) {
     case COFF::IMAGE_REL_I386_DIR32:
     case COFF::IMAGE_REL_I386_DIR32NB:
     case COFF::IMAGE_REL_I386_SECREL:
     case COFF::IMAGE_REL_I386_REL32: {
       Addend = readBytesUnaligned(Displacement, 4);
#endif
 
     }
 
     return ++RelI;
   }
 
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
     const auto Section = Sections[RE.SectionID];
-    uint8_t *Target = Section.getAddressWithOffset(RE.Offset);
+    uint8_t *Target = Section->getAddressWithOffset(RE.Offset);
 
     switch (RE.RelType) {
     case COFF::IMAGE_REL_I386_ABSOLUTE:
       // This relocation is ignored.
       break;
     case COFF::IMAGE_REL_I386_DIR32: {
       // The target's 32-bit VA.
       uint64_t Result =
           RE.Sections.SectionA == static_cast<uint32_t>(-1)
               ? Value
-              : Sections[RE.Sections.SectionA].getLoadAddressWithOffset(
+              : Sections[RE.Sections.SectionA]->getLoadAddressWithOffset(
                     RE.Addend);
       assert(Result <= UINT32_MAX && "relocation overflow");
       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
                         << " RelType: IMAGE_REL_I386_DIR32"
                         << " TargetSection: " << RE.Sections.SectionA
                         << " Value: " << format("0x%08" PRIx32, Result)
                         << '\n');
       writeBytesUnaligned(Result, Target, 4);
       break;
     }
     case COFF::IMAGE_REL_I386_DIR32NB: {
       // The target's 32-bit RVA.
       // NOTE: use Section[0].getLoadAddress() as an approximation of ImageBase
       uint64_t Result =
-          Sections[RE.Sections.SectionA].getLoadAddressWithOffset(RE.Addend) -
-          Sections[0].getLoadAddress();
+          Sections[RE.Sections.SectionA]->getLoadAddressWithOffset(RE.Addend) -
+          Sections[0]->getLoadAddress();
       assert(Result <= UINT32_MAX && "relocation overflow");
       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
                         << " RelType: IMAGE_REL_I386_DIR32NB"
                         << " TargetSection: " << RE.Sections.SectionA
                         << " Value: " << format("0x%08" PRIx32, Result)
                         << '\n');
       writeBytesUnaligned(Result, Target, 4);
       break;
     }
     case COFF::IMAGE_REL_I386_REL32: {
       // 32-bit relative displacement to the target.
       uint64_t Result = RE.Sections.SectionA == static_cast<uint32_t>(-1)
                             ? Value
-                            : Sections[RE.Sections.SectionA].getLoadAddress();
-      Result = Result - Section.getLoadAddress() + RE.Addend - 4 - RE.Offset;
+                            : Sections[RE.Sections.SectionA]->getLoadAddress();
+      Result = Result - Section->getLoadAddress() + RE.Addend - 4 - RE.Offset;
       assert(static_cast<int64_t>(Result) <= INT32_MAX &&
              "relocation overflow");
       assert(static_cast<int64_t>(Result) >= INT32_MIN &&
              "relocation underflow");
       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
                         << " RelType: IMAGE_REL_I386_REL32"
                         << " TargetSection: " << RE.Sections.SectionA
                         << " Value: " << format("0x%08" PRIx32, Result)

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFThumb.h

if (!SectionOrErr)
       return SectionOrErr.takeError();
     auto Section = *SectionOrErr;
 
     uint64_t RelType = RelI->getType();
     uint64_t Offset = RelI->getOffset();
 
     // Determine the Addend used to adjust the relocation value.
     uint64_t Addend = 0;
-    SectionEntry &AddendSection = Sections[SectionID];
-    uintptr_t ObjTarget = AddendSection.getObjAddress() + Offset;
+    SectionEntryProxy AddendSection = Sections[SectionID];
+    uintptr_t ObjTarget = AddendSection->getObjAddress() + Offset;
     uint8_t *Displacement = (uint8_t *)ObjTarget;
 
     switch (RelType) {
     case COFF::IMAGE_REL_ARM_ADDR32:
     case COFF::IMAGE_REL_ARM_ADDR32NB:
     case COFF::IMAGE_REL_ARM_SECREL:
       Addend = readBytesUnaligned(Displacement, 4);
       break;
if (Section == Obj.section_end()) {
       }
     }
 
     return ++RelI;
   }
 
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
     const auto Section = Sections[RE.SectionID];
-    uint8_t *Target = Section.getAddressWithOffset(RE.Offset);
+    uint8_t *Target = Section->getAddressWithOffset(RE.Offset);
     int ISASelectionBit = RE.IsTargetThumbFunc ? 1 : 0;
 
     switch (RE.RelType) {
     default: llvm_unreachable("unsupported relocation type");
     case COFF::IMAGE_REL_ARM_ABSOLUTE:
       // This relocation is ignored.
       break;
     case COFF::IMAGE_REL_ARM_ADDR32: {
       // The target's 32-bit VA.
       uint64_t Result =
           RE.Sections.SectionA == static_cast<uint32_t>(-1)
               ? Value
-              : Sections[RE.Sections.SectionA].getLoadAddressWithOffset(RE.Addend);
+              : Sections[RE.Sections.SectionA]->getLoadAddressWithOffset(
+                    RE.Addend);
       Result |= ISASelectionBit;
       assert(Result <= UINT32_MAX && "relocation overflow");
       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
                         << " RelType: IMAGE_REL_ARM_ADDR32"
                         << " TargetSection: " << RE.Sections.SectionA
                         << " Value: " << format("0x%08" PRIx32, Result)
                         << '\n');
       writeBytesUnaligned(Result, Target, 4);
       break;
     }
     case COFF::IMAGE_REL_ARM_ADDR32NB: {
       // The target's 32-bit RVA.
       // NOTE: use Section[0].getLoadAddress() as an approximation of ImageBase
-      uint64_t Result = Sections[RE.Sections.SectionA].getLoadAddress() -
-                        Sections[0].getLoadAddress() + RE.Addend;
+      uint64_t Result = Sections[RE.Sections.SectionA]->getLoadAddress() -
+                        Sections[0]->getLoadAddress() + RE.Addend;
       assert(Result <= UINT32_MAX && "relocation overflow");
       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
                         << " RelType: IMAGE_REL_ARM_ADDR32NB"
                         << " TargetSection: " << RE.Sections.SectionA
                         << " Value: " << format("0x%08" PRIx32, Result)
                         << '\n');
       Result |= ISASelectionBit;
       writeBytesUnaligned(Result, Target, 4);
case COFF::IMAGE_REL_ARM_SECREL:
       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
                         << " RelType: IMAGE_REL_ARM_SECREL Value: " << RE.Addend
                         << '\n');
       writeBytesUnaligned(RE.Addend, Target, 2);
       break;
     case COFF::IMAGE_REL_ARM_MOV32T: {
       // 32-bit VA of the target applied to a contiguous MOVW+MOVT pair.
       uint64_t Result =
-          Sections[RE.Sections.SectionA].getLoadAddressWithOffset(RE.Addend);
+          Sections[RE.Sections.SectionA]->getLoadAddressWithOffset(RE.Addend);
       assert(Result <= UINT32_MAX && "relocation overflow");
       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
                         << " RelType: IMAGE_REL_ARM_MOV32T"
                         << " TargetSection: " << RE.Sections.SectionA
                         << " Value: " << format("0x%08" PRIx32, Result)
                         << '\n');
 
       // MOVW(T3): |11110|i|10|0|1|0|0|imm4|0|imm3|Rd|imm8|
case COFF::IMAGE_REL_ARM_MOV32T: {
       EncodeImmediate(&Target[0],
                       (static_cast<uint32_t>(Result) >> 00) | ISASelectionBit);
       EncodeImmediate(&Target[4], static_cast<uint32_t>(Result) >> 16);
 
       break;
     }
     case COFF::IMAGE_REL_ARM_BRANCH20T: {
       // The most significant 20-bits of the signed 21-bit relative displacement
-      uint64_t Value =
-          RE.Addend - (Sections[RE.SectionID].getLoadAddress() + RE.Offset) - 4;
+      uint64_t Value = RE.Addend -
+                       (Sections[RE.SectionID]->getLoadAddress() + RE.Offset) -
+                       4;
       assert(static_cast<int64_t>(RE.Addend) <= INT32_MAX &&
              "relocation overflow");
       assert(static_cast<int64_t>(RE.Addend) >= INT32_MIN &&
              "relocation underflow");
       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
                         << " RelType: IMAGE_REL_ARM_BRANCH20T"
                         << " Value: " << static_cast<int32_t>(Value) << '\n');
       static_cast<void>(Value);
       llvm_unreachable("unimplemented relocation");
       break;
     }
     case COFF::IMAGE_REL_ARM_BRANCH24T: {
       // The most significant 24-bits of the signed 25-bit relative displacement
-      uint64_t Value =
-          RE.Addend - (Sections[RE.SectionID].getLoadAddress() + RE.Offset) - 4;
+      uint64_t Value = RE.Addend -
+                       (Sections[RE.SectionID]->getLoadAddress() + RE.Offset) -
+                       4;
       assert(static_cast<int64_t>(RE.Addend) <= INT32_MAX &&
              "relocation overflow");
       assert(static_cast<int64_t>(RE.Addend) >= INT32_MIN &&
              "relocation underflow");
       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
                         << " RelType: IMAGE_REL_ARM_BRANCH24T"
                         << " Value: " << static_cast<int32_t>(Value) << '\n');
       static_cast<void>(Value);
       llvm_unreachable("unimplemented relocation");
       break;
     }
     case COFF::IMAGE_REL_ARM_BLX23T: {
       // The most significant 24-bits of the signed 25-bit relative displacement
-      uint64_t Value =
-          RE.Addend - (Sections[RE.SectionID].getLoadAddress() + RE.Offset) - 4;
+      uint64_t Value = RE.Addend -
+                       (Sections[RE.SectionID]->getLoadAddress() + RE.Offset) -
+                       4;
       assert(static_cast<int64_t>(RE.Addend) <= INT32_MAX &&
              "relocation overflow");
       assert(static_cast<int64_t>(RE.Addend) >= INT32_MIN &&
              "relocation underflow");
       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
                         << " RelType: IMAGE_REL_ARM_BLX23T"
                         << " Value: " << static_cast<int32_t>(Value) << '\n');
       static_cast<void>(Value);

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFX86_64.h

private:
   SmallVector<SID, 2> UnregisteredEHFrameSections;
   SmallVector<SID, 2> RegisteredEHFrameSections;
   uint64_t ImageBase;
 
   // Fake an __ImageBase pointer by returning the section with the lowest adress
   uint64_t getImageBase() {
     if (!ImageBase) {
       ImageBase = std::numeric_limits<uint64_t>::max();
-      for (const SectionEntry &Section : Sections)
+      for (const SectionEntryProxy Section : Sections)
         // The Sections list may contain sections that weren't loaded for
         // whatever reason: they may be debug sections, and ProcessAllSections
         // is false, or they may be sections that contain 0 bytes. If the
         // section isn't loaded, the load address will be 0, and it should not
         // be included in the ImageBase calculation.
-        if (Section.getLoadAddress() != 0)
-          ImageBase = std::min(ImageBase, Section.getLoadAddress());
+        if (Section->getLoadAddress() != 0)
+          ImageBase = std::min(ImageBase, Section->getLoadAddress());
     }
     return ImageBase;
   }
 
   void write32BitOffset(uint8_t *Target, int64_t Addend, uint64_t Delta) {
     uint64_t Result = Addend + Delta;
     assert(Result <= UINT32_MAX && "Relocation overflow");
     writeBytesUnaligned(Result, Target, 4);
public:
   //
   // The Value parameter here is the load address of the symbol for the
   // relocation to be applied.  For relocations which refer to symbols in the
   // current object Value will be the LoadAddress of the section in which
   // the symbol resides (RE.Addend provides additional information about the
   // symbol location).  For external symbols, Value will be the address of the
   // symbol in the target address space.
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
-    const SectionEntry &Section = Sections[RE.SectionID];
-    uint8_t *Target = Section.getAddressWithOffset(RE.Offset);
+    const SectionEntryProxy Section = Sections[RE.SectionID];
+    uint8_t *Target = Section->getAddressWithOffset(RE.Offset);
 
     switch (RE.RelType) {
 
     case COFF::IMAGE_REL_AMD64_REL32:
     case COFF::IMAGE_REL_AMD64_REL32_1:
     case COFF::IMAGE_REL_AMD64_REL32_2:
     case COFF::IMAGE_REL_AMD64_REL32_3:
     case COFF::IMAGE_REL_AMD64_REL32_4:
     case COFF::IMAGE_REL_AMD64_REL32_5: {
-      uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
+      uint64_t FinalAddress = Section->getLoadAddressWithOffset(RE.Offset);
       // Delta is the distance from the start of the reloc to the end of the
       // instruction with the reloc.
       uint64_t Delta = 4 + (RE.RelType - COFF::IMAGE_REL_AMD64_REL32);
       Value -= FinalAddress + Delta;
       uint64_t Result = Value + RE.Addend;
       assert(((int64_t)Result <= INT32_MAX) && "Relocation overflow");
       assert(((int64_t)Result >= INT32_MIN) && "Relocation underflow");
       writeBytesUnaligned(Result, Target, 4);
void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
     }
   }
 
   std::tuple<uint64_t, uint64_t, uint64_t>
   generateRelocationStub(unsigned SectionID, StringRef TargetName,
                          uint64_t Offset, uint64_t RelType, uint64_t Addend,
                          StubMap &Stubs) {
     uintptr_t StubOffset;
-    SectionEntry &Section = Sections[SectionID];
+    SectionEntryProxy Section = Sections[SectionID];
 
     RelocationValueRef OriginalRelValueRef;
     OriginalRelValueRef.SectionID = SectionID;
     OriginalRelValueRef.Offset = Offset;
     OriginalRelValueRef.Addend = Addend;
     OriginalRelValueRef.SymbolName = TargetName.data();
 
     auto Stub = Stubs.find(OriginalRelValueRef);
     if (Stub == Stubs.end()) {
       LLVM_DEBUG(dbgs() << " Create a new stub function for "
                         << TargetName.data() << "\n");
 
-      StubOffset = Section.getStubOffset();
+      StubOffset = Section->getStubOffset();
       Stubs[OriginalRelValueRef] = StubOffset;
-      createStubFunction(Section.getAddressWithOffset(StubOffset));
-      Section.advanceStubOffset(getMaxStubSize());
+      createStubFunction(Section->getAddressWithOffset(StubOffset));
+      Section->advanceStubOffset(getMaxStubSize());
     } else {
       LLVM_DEBUG(dbgs() << " Stub function found for " << TargetName.data()
                         << "\n");
       StubOffset = Stub->second;
     }
 
     // FIXME: If RelType == COFF::IMAGE_REL_AMD64_ADDR32NB we should be able
     // to ignore the __ImageBase requirement and just forward to the stub
     // directly as an offset of this section:
-    // write32BitOffset(Section.getAddressWithOffset(Offset), 0, StubOffset);
+    // write32BitOffset(Section->getAddressWithOffset(Offset), 0, StubOffset);
     // .xdata exception handler's aren't having this though.
 
     // Resolve original relocation to stub function.
     const RelocationEntry RE(SectionID, Offset, RelType, Addend);
-    resolveRelocation(RE, Section.getLoadAddressWithOffset(StubOffset));
+    resolveRelocation(RE, Section->getLoadAddressWithOffset(StubOffset));
 
     // adjust relocation info so resolution writes to the stub function
     Addend = 0;
     Offset = StubOffset + 6;
     RelType = COFF::IMAGE_REL_AMD64_ADDR64;
 
     return std::make_tuple(Offset, RelType, Addend);
   }
processRelocationRef(unsigned SectionID,
     object::section_iterator SecI = *SectionOrError;
     // If there is no section, this must be an external reference.
     const bool IsExtern = SecI == Obj.section_end();
 
     // Determine the Addend used to adjust the relocation value.
     uint64_t RelType = RelI->getType();
     uint64_t Offset = RelI->getOffset();
     uint64_t Addend = 0;
-    SectionEntry &Section = Sections[SectionID];
-    uintptr_t ObjTarget = Section.getObjAddress() + Offset;
+    SectionEntryProxy Section = Sections[SectionID];
+    uintptr_t ObjTarget = Section->getObjAddress() + Offset;
 
     Expected<StringRef> TargetNameOrErr = Symbol->getName();
     if (!TargetNameOrErr)
       return TargetNameOrErr.takeError();
     StringRef TargetName = *TargetNameOrErr;
 
     switch (RelType) {
 
if (IsExtern) {
       addRelocationForSection(RE, TargetSectionID);
     }
 
     return ++RelI;
   }
 
   void registerEHFrames() override {
     for (auto const &EHFrameSID : UnregisteredEHFrameSections) {
-      uint8_t *EHFrameAddr = Sections[EHFrameSID].getAddress();
-      uint64_t EHFrameLoadAddr = Sections[EHFrameSID].getLoadAddress();
-      size_t EHFrameSize = Sections[EHFrameSID].getSize();
+      uint8_t *EHFrameAddr = Sections[EHFrameSID]->getAddress();
+      uint64_t EHFrameLoadAddr = Sections[EHFrameSID]->getLoadAddress();
+      size_t EHFrameSize = Sections[EHFrameSID]->getSize();
       MemMgr.registerEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize);
       RegisteredEHFrameSections.push_back(EHFrameSID);
     }
     UnregisteredEHFrameSections.clear();
   }
 
   Error finalizeLoad(const object::ObjectFile &Obj,
                      ObjSectionToIDMap &SectionMap) override {

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldELFMips.h

public:
 
   RuntimeDyldELFMips(RuntimeDyld::MemoryManager &MM,
                      JITSymbolResolver &Resolver)
       : RuntimeDyldELF(MM, Resolver) {}
 
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override;
 
 protected:
-  void resolveMIPSO32Relocation(const SectionEntry &Section, uint64_t Offset,
-                                uint32_t Value, uint32_t Type, int32_t Addend);
-  void resolveMIPSN32Relocation(const SectionEntry &Section, uint64_t Offset,
-                                uint64_t Value, uint32_t Type, int64_t Addend,
-                                uint64_t SymOffset, SID SectionID);
-  void resolveMIPSN64Relocation(const SectionEntry &Section, uint64_t Offset,
-                                uint64_t Value, uint32_t Type, int64_t Addend,
-                                uint64_t SymOffset, SID SectionID);
+  void resolveMIPSO32Relocation(const SectionEntryProxy Section,
+                                uint64_t Offset, uint32_t Value, uint32_t Type,
+                                int32_t Addend);
+  void resolveMIPSN32Relocation(const SectionEntryProxy Section,
+                                uint64_t Offset, uint64_t Value, uint32_t Type,
+                                int64_t Addend, uint64_t SymOffset,
+                                SID SectionID);
+  void resolveMIPSN64Relocation(const SectionEntryProxy Section,
+                                uint64_t Offset, uint64_t Value, uint32_t Type,
+                                int64_t Addend, uint64_t SymOffset,
+                                SID SectionID);
 
 private:
   /// A object file specific relocation resolver
   /// \param RE The relocation to be resolved
   /// \param Value Target symbol address to apply the relocation action
   uint64_t evaluateRelocation(const RelocationEntry &RE, uint64_t Value,
                               uint64_t Addend);
 
   /// A object file specific relocation resolver
   /// \param RE The relocation to be resolved
   /// \param Value Target symbol address to apply the relocation action
   void applyRelocation(const RelocationEntry &RE, uint64_t Value);
 
-  int64_t evaluateMIPS32Relocation(const SectionEntry &Section, uint64_t Offset,
-                                   uint64_t Value, uint32_t Type);
-  int64_t evaluateMIPS64Relocation(const SectionEntry &Section,
+  int64_t evaluateMIPS32Relocation(const SectionEntryProxy Section,
+                                   uint64_t Offset, uint64_t Value,
+                                   uint32_t Type);
+  int64_t evaluateMIPS64Relocation(const SectionEntryProxy Section,
                                    uint64_t Offset, uint64_t Value,
-                                   uint32_t Type,  int64_t Addend,
+                                   uint32_t Type, int64_t Addend,
                                    uint64_t SymOffset, SID SectionID);
 
   void applyMIPSRelocation(uint8_t *TargetPtr, int64_t CalculatedValue,
                            uint32_t Type);
 
 };
 }
 
 #undef DEBUG_TYPE
 
 #endif

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldELFMips.cpp

 //===-- RuntimeDyldELFMips.cpp ---- ELF/Mips specific code. -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "RuntimeDyldELFMips.h"
 #include "llvm/BinaryFormat/ELF.h"
 
 #define DEBUG_TYPE "dyld"
 
 void RuntimeDyldELFMips::resolveRelocation(const RelocationEntry &RE,
                                            uint64_t Value) {
-  const SectionEntry &Section = Sections[RE.SectionID];
+  const SectionEntryProxy Section = Sections[RE.SectionID];
   if (IsMipsO32ABI)
     resolveMIPSO32Relocation(Section, RE.Offset, Value, RE.RelType, RE.Addend);
   else if (IsMipsN32ABI) {
     resolveMIPSN32Relocation(Section, RE.Offset, Value, RE.RelType, RE.Addend,
                              RE.SymOffset, RE.SectionID);
   } else if (IsMipsN64ABI)
     resolveMIPSN64Relocation(Section, RE.Offset, Value, RE.RelType, RE.Addend,
                              RE.SymOffset, RE.SectionID);
   else
     llvm_unreachable("Mips ABI not handled");
 }
 
 uint64_t RuntimeDyldELFMips::evaluateRelocation(const RelocationEntry &RE,
                                                 uint64_t Value,
                                                 uint64_t Addend) {
   if (IsMipsN32ABI) {
-    const SectionEntry &Section = Sections[RE.SectionID];
+    const SectionEntryProxy Section = Sections[RE.SectionID];
     Value = evaluateMIPS64Relocation(Section, RE.Offset, Value, RE.RelType,
                                      Addend, RE.SymOffset, RE.SectionID);
     return Value;
   }
   llvm_unreachable("Not reachable");
 }
 
 void RuntimeDyldELFMips::applyRelocation(const RelocationEntry &RE,
                                          uint64_t Value) {
   if (IsMipsN32ABI) {
-    const SectionEntry &Section = Sections[RE.SectionID];
-    applyMIPSRelocation(Section.getAddressWithOffset(RE.Offset), Value,
+    const SectionEntryProxy Section = Sections[RE.SectionID];
+    applyMIPSRelocation(Section->getAddressWithOffset(RE.Offset), Value,
                         RE.RelType);
     return;
   }
   llvm_unreachable("Not reachable");
 }
 
 int64_t
-RuntimeDyldELFMips::evaluateMIPS32Relocation(const SectionEntry &Section,
+RuntimeDyldELFMips::evaluateMIPS32Relocation(const SectionEntryProxy Section,
                                              uint64_t Offset, uint64_t Value,
                                              uint32_t Type) {
 
   LLVM_DEBUG(dbgs() << "evaluateMIPS32Relocation, LocalAddress: 0x"
-                    << format("%llx", Section.getAddressWithOffset(Offset))
+                    << format("%llx", Section->getAddressWithOffset(Offset))
                     << " FinalAddress: 0x"
-                    << format("%llx", Section.getLoadAddressWithOffset(Offset))
+                    << format("%llx", Section->getLoadAddressWithOffset(Offset))
                     << " Value: 0x" << format("%llx", Value) << " Type: 0x"
                     << format("%x", Type) << "\n");
 
   switch (Type) {
   default:
     llvm_unreachable("Unknown relocation type!");
     return Value;
   case ELF::R_MIPS_32:
     return Value;
   case ELF::R_MIPS_26:
     return Value >> 2;
   case ELF::R_MIPS_HI16:
     // Get the higher 16-bits. Also add 1 if bit 15 is 1.
     return (Value + 0x8000) >> 16;
   case ELF::R_MIPS_LO16:
     return Value;
   case ELF::R_MIPS_PC32: {
-    uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint32_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return Value - FinalAddress;
   }
   case ELF::R_MIPS_PC16: {
-    uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint32_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return (Value - FinalAddress) >> 2;
   }
   case ELF::R_MIPS_PC19_S2: {
-    uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint32_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return (Value - (FinalAddress & ~0x3)) >> 2;
   }
   case ELF::R_MIPS_PC21_S2: {
-    uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint32_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return (Value - FinalAddress) >> 2;
   }
   case ELF::R_MIPS_PC26_S2: {
-    uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint32_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return (Value - FinalAddress) >> 2;
   }
   case ELF::R_MIPS_PCHI16: {
-    uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint32_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return (Value - FinalAddress + 0x8000) >> 16;
   }
   case ELF::R_MIPS_PCLO16: {
-    uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint32_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return Value - FinalAddress;
   }
   }
 }
 
 int64_t RuntimeDyldELFMips::evaluateMIPS64Relocation(
-    const SectionEntry &Section, uint64_t Offset, uint64_t Value, uint32_t Type,
-    int64_t Addend, uint64_t SymOffset, SID SectionID) {
+    const SectionEntryProxy Section, uint64_t Offset, uint64_t Value,
+    uint32_t Type, int64_t Addend, uint64_t SymOffset, SID SectionID) {
 
   LLVM_DEBUG(dbgs() << "evaluateMIPS64Relocation, LocalAddress: 0x"
-                    << format("%llx", Section.getAddressWithOffset(Offset))
+                    << format("%llx", Section->getAddressWithOffset(Offset))
                     << " FinalAddress: 0x"
-                    << format("%llx", Section.getLoadAddressWithOffset(Offset))
+                    << format("%llx", Section->getLoadAddressWithOffset(Offset))
                     << " Value: 0x" << format("%llx", Value) << " Type: 0x"
                     << format("%x", Type) << " Addend: 0x"
                     << format("%llx", Addend)
                     << " Offset: " << format("%llx" PRIx64, Offset)
                     << " SID: " << format("%d", SectionID)
                     << " SymOffset: " << format("%x", SymOffset) << "\n");
 
   switch (Type) {
case ELF::R_MIPS_GOT_OFST: {
     int64_t page = (Value + Addend + 0x8000) & ~0xffff;
     return (Value + Addend - page) & 0xffff;
   }
   case ELF::R_MIPS_GPREL32: {
     uint64_t GOTAddr = getSectionLoadAddress(SectionToGOTMap[SectionID]);
     return Value + Addend - (GOTAddr + 0x7ff0);
   }
   case ELF::R_MIPS_PC16: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return ((Value + Addend - FinalAddress) >> 2) & 0xffff;
   }
   case ELF::R_MIPS_PC32: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return Value + Addend - FinalAddress;
   }
   case ELF::R_MIPS_PC18_S3: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return ((Value + Addend - (FinalAddress & ~0x7)) >> 3) & 0x3ffff;
   }
   case ELF::R_MIPS_PC19_S2: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return ((Value + Addend - (FinalAddress & ~0x3)) >> 2) & 0x7ffff;
   }
   case ELF::R_MIPS_PC21_S2: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return ((Value + Addend - FinalAddress) >> 2) & 0x1fffff;
   }
   case ELF::R_MIPS_PC26_S2: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return ((Value + Addend - FinalAddress) >> 2) & 0x3ffffff;
   }
   case ELF::R_MIPS_PCHI16: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return ((Value + Addend - FinalAddress + 0x8000) >> 16) & 0xffff;
   }
   case ELF::R_MIPS_PCLO16: {
-    uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
+    uint64_t FinalAddress = Section->getLoadAddressWithOffset(Offset);
     return (Value + Addend - FinalAddress) & 0xffff;
   }
   }
   return 0;
 }
 
 void RuntimeDyldELFMips::applyMIPSRelocation(uint8_t *TargetPtr, int64_t Value,
                                              uint32_t Type) {
void RuntimeDyldELFMips::applyMIPSRelocation(uint8_t *TargetPtr, int64_t Value,
   case ELF::R_MIPS_64:
   case ELF::R_MIPS_SUB:
     writeBytesUnaligned(Value, TargetPtr, 8);
     break;
   }
 }
 
 void RuntimeDyldELFMips::resolveMIPSN32Relocation(
-    const SectionEntry &Section, uint64_t Offset, uint64_t Value, uint32_t Type,
-    int64_t Addend, uint64_t SymOffset, SID SectionID) {
+    const SectionEntryProxy Section, uint64_t Offset, uint64_t Value,
+    uint32_t Type, int64_t Addend, uint64_t SymOffset, SID SectionID) {
   int64_t CalculatedValue = evaluateMIPS64Relocation(
       Section, Offset, Value, Type, Addend, SymOffset, SectionID);
-  applyMIPSRelocation(Section.getAddressWithOffset(Offset), CalculatedValue,
+  applyMIPSRelocation(Section->getAddressWithOffset(Offset), CalculatedValue,
                       Type);
 }
 
 void RuntimeDyldELFMips::resolveMIPSN64Relocation(
-    const SectionEntry &Section, uint64_t Offset, uint64_t Value, uint32_t Type,
-    int64_t Addend, uint64_t SymOffset, SID SectionID) {
+    const SectionEntryProxy Section, uint64_t Offset, uint64_t Value,
+    uint32_t Type, int64_t Addend, uint64_t SymOffset, SID SectionID) {
   uint32_t r_type = Type & 0xff;
   uint32_t r_type2 = (Type >> 8) & 0xff;
   uint32_t r_type3 = (Type >> 16) & 0xff;
 
   // RelType is used to keep information for which relocation type we are
   // applying relocation.
   uint32_t RelType = r_type;
   int64_t CalculatedValue = evaluateMIPS64Relocation(Section, Offset, Value,
                                                      RelType, Addend,
                                                      SymOffset, SectionID);
   if (r_type2 != ELF::R_MIPS_NONE) {
     RelType = r_type2;
     CalculatedValue = evaluateMIPS64Relocation(Section, Offset, 0, RelType,
                                                CalculatedValue, SymOffset,
                                                SectionID);
   }
   if (r_type3 != ELF::R_MIPS_NONE) {
     RelType = r_type3;
     CalculatedValue = evaluateMIPS64Relocation(Section, Offset, 0, RelType,
                                                CalculatedValue, SymOffset,
                                                SectionID);
   }
-  applyMIPSRelocation(Section.getAddressWithOffset(Offset), CalculatedValue,
+  applyMIPSRelocation(Section->getAddressWithOffset(Offset), CalculatedValue,
                       RelType);
 }
 
-void RuntimeDyldELFMips::resolveMIPSO32Relocation(const SectionEntry &Section,
-                                                  uint64_t Offset,
-                                                  uint32_t Value, uint32_t Type,
-                                                  int32_t Addend) {
-  uint8_t *TargetPtr = Section.getAddressWithOffset(Offset);
+void RuntimeDyldELFMips::resolveMIPSO32Relocation(
+    const SectionEntryProxy Section, uint64_t Offset, uint32_t Value,
+    uint32_t Type, int32_t Addend) {
+  uint8_t *TargetPtr = Section->getAddressWithOffset(Offset);
   Value += Addend;
 
   LLVM_DEBUG(dbgs() << "resolveMIPSO32Relocation, LocalAddress: "
-                    << Section.getAddressWithOffset(Offset) << " FinalAddress: "
-                    << format("%p", Section.getLoadAddressWithOffset(Offset))
+                    << Section->getAddressWithOffset(Offset)
+                    << " FinalAddress: "
+                    << format("%p", Section->getLoadAddressWithOffset(Offset))
                     << " Value: " << format("%x", Value) << " Type: "
                     << format("%x", Type) << " Addend: " << format("%x", Addend)
                     << " SymOffset: " << format("%x", Offset) << "\n");
 
   Value = evaluateMIPS32Relocation(Section, Offset, Value, Type);
 
   applyMIPSRelocation(TargetPtr, Value, Type);
 }

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h

RuntimeDyldMachOAArch64(RuntimeDyld::MemoryManager &MM,
       : RuntimeDyldMachOCRTPBase(MM, Resolver) {}
 
   unsigned getMaxStubSize() const override { return 8; }
 
   unsigned getStubAlignment() override { return 8; }
 
   /// Extract the addend encoded in the instruction / memory location.
   Expected<int64_t> decodeAddend(const RelocationEntry &RE) const {
-    const SectionEntry &Section = Sections[RE.SectionID];
-    uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
+    SectionEntryConstProxy Section = Sections[RE.SectionID];
+    uint8_t *LocalAddress = Section->getAddressWithOffset(RE.Offset);
     unsigned NumBytes = 1 << RE.Size;
     int64_t Addend = 0;
     // Verify that the relocation has the correct size and alignment.
     switch (RE.RelType) {
     default: {
       std::string ErrMsg;
       {
         raw_string_ostream ErrStream(ErrMsg);
processRelocationRef(unsigned SectionID, relocation_iterator RelI,
     }
 
     return ++RelI;
   }
 
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
     LLVM_DEBUG(dumpRelocationToResolve(RE, Value));
 
-    const SectionEntry &Section = Sections[RE.SectionID];
-    uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
+    const SectionEntryProxy Section = Sections[RE.SectionID];
+    uint8_t *LocalAddress = Section->getAddressWithOffset(RE.Offset);
     MachO::RelocationInfoType RelType =
       static_cast<MachO::RelocationInfoType>(RE.RelType);
 
     switch (RelType) {
     default:
       llvm_unreachable("Invalid relocation type!");
     case MachO::ARM64_RELOC_UNSIGNED: {
       assert(!RE.IsPCRel && "PCRel and ARM64_RELOC_UNSIGNED not supported");
case MachO::ARM64_RELOC_POINTER_TO_GOT: {
           RE.IsPCRel ? (RE.Addend - RE.Offset) : (Value + RE.Addend);
       encodeAddend(LocalAddress, 1 << RE.Size, RelType, Result);
       break;
     }
 
     case MachO::ARM64_RELOC_BRANCH26: {
       assert(RE.IsPCRel && "not PCRel and ARM64_RELOC_BRANCH26 not supported");
       // Check if branch is in range.
-      uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
+      uint64_t FinalAddress = Section->getLoadAddressWithOffset(RE.Offset);
       int64_t PCRelVal = Value - FinalAddress + RE.Addend;
       encodeAddend(LocalAddress, /*Size=*/4, RelType, PCRelVal);
       break;
     }
     case MachO::ARM64_RELOC_GOT_LOAD_PAGE21:
     case MachO::ARM64_RELOC_PAGE21: {
       assert(RE.IsPCRel && "not PCRel and ARM64_RELOC_PAGE21 not supported");
       // Adjust for PC-relative relocation and offset.
-      uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
+      uint64_t FinalAddress = Section->getLoadAddressWithOffset(RE.Offset);
       int64_t PCRelVal =
         ((Value + RE.Addend) & (-4096)) - (FinalAddress & (-4096));
       encodeAddend(LocalAddress, /*Size=*/4, RelType, PCRelVal);
       break;
     }
     case MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12:
     case MachO::ARM64_RELOC_PAGEOFF12: {
       assert(!RE.IsPCRel && "PCRel and ARM64_RELOC_PAGEOFF21 not supported");
       // Add the offset from the symbol.
       Value += RE.Addend;
       // Mask out the page address and only use the lower 12 bits.
       Value &= 0xFFF;
       encodeAddend(LocalAddress, /*Size=*/4, RelType, Value);
       break;
     }
     case MachO::ARM64_RELOC_SUBTRACTOR: {
-      uint64_t SectionABase = Sections[RE.Sections.SectionA].getLoadAddress();
-      uint64_t SectionBBase = Sections[RE.Sections.SectionB].getLoadAddress();
+      uint64_t SectionABase = Sections[RE.Sections.SectionA]->getLoadAddress();
+      uint64_t SectionBBase = Sections[RE.Sections.SectionB]->getLoadAddress();
       assert((Value == SectionABase || Value == SectionBBase) &&
              "Unexpected SUBTRACTOR relocation value.");
       Value = SectionABase - SectionBBase + RE.Addend;
       writeBytesUnaligned(Value, LocalAddress, 1 << RE.Size);
       break;
     }
 
     case MachO::ARM64_RELOC_TLVP_LOAD_PAGE21:
public:
   }
 
 private:
   void processGOTRelocation(const RelocationEntry &RE,
                             RelocationValueRef &Value, StubMap &Stubs) {
     assert((RE.RelType == MachO::ARM64_RELOC_POINTER_TO_GOT &&
             (RE.Size == 2 || RE.Size == 3)) ||
            RE.Size == 2);
-    SectionEntry &Section = Sections[RE.SectionID];
+    SectionEntryProxy Section = Sections[RE.SectionID];
     StubMap::const_iterator i = Stubs.find(Value);
     int64_t Offset;
     if (i != Stubs.end())
       Offset = static_cast<int64_t>(i->second);
     else {
       // FIXME: There must be a better way to do this then to check and fix the
       // alignment every time!!!
-      uintptr_t BaseAddress = uintptr_t(Section.getAddress());
+      uintptr_t BaseAddress = uintptr_t(Section->getAddress());
       uintptr_t StubAlignment = getStubAlignment();
       uintptr_t StubAddress =
-          (BaseAddress + Section.getStubOffset() + StubAlignment - 1) &
+          (BaseAddress + Section->getStubOffset() + StubAlignment - 1) &
           -StubAlignment;
       unsigned StubOffset = StubAddress - BaseAddress;
       Stubs[Value] = StubOffset;
       assert(((StubAddress % getStubAlignment()) == 0) &&
              "GOT entry not aligned");
       RelocationEntry GOTRE(RE.SectionID, StubOffset,
                             MachO::ARM64_RELOC_UNSIGNED, Value.Offset,
                             /*IsPCRel=*/false, /*Size=*/3);
       if (Value.SymbolName)
         addRelocationForSymbol(GOTRE, Value.SymbolName);
       else
         addRelocationForSection(GOTRE, Value.SectionID);
-      Section.advanceStubOffset(getMaxStubSize());
+      Section->advanceStubOffset(getMaxStubSize());
       Offset = static_cast<int64_t>(StubOffset);
     }
     RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, Offset,
                              RE.IsPCRel, RE.Size);
     addRelocationForSection(TargetRE, RE.SectionID);
   }
 
   Expected<relocation_iterator>
   processSubtractRelocation(unsigned SectionID, relocation_iterator RelI,
                             const ObjectFile &BaseObjT,
                             ObjSectionToIDMap &ObjSectionToID) {
     const MachOObjectFile &Obj =
         static_cast<const MachOObjectFile&>(BaseObjT);
     MachO::any_relocation_info RE =
         Obj.getRelocation(RelI->getRawDataRefImpl());
 
     unsigned Size = Obj.getAnyRelocationLength(RE);
     uint64_t Offset = RelI->getOffset();
-    uint8_t *LocalAddress = Sections[SectionID].getAddressWithOffset(Offset);
+    uint8_t *LocalAddress = Sections[SectionID]->getAddressWithOffset(Offset);
     unsigned NumBytes = 1 << Size;
 
     Expected<StringRef> SubtrahendNameOrErr = RelI->getSymbol()->getName();
     if (!SubtrahendNameOrErr)
       return SubtrahendNameOrErr.takeError();
     auto SubtrahendI = GlobalSymbolTable.find(*SubtrahendNameOrErr);
     unsigned SectionBID = SubtrahendI->second.getSectionID();
     uint64_t SectionBOffset = SubtrahendI->second.getOffset();

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h

public:
   uint64_t modifyAddressBasedOnFlags(uint64_t Addr,
                                      JITSymbolFlags Flags) const override {
     if (Flags.getTargetFlags() & ARMJITSymbolFlags::Thumb)
       Addr |= 0x1;
     return Addr;
   }
 
   bool isAddrTargetThumb(unsigned SectionID, uint64_t Offset) {
-    auto TargetObjAddr = Sections[SectionID].getObjAddress() + Offset;
+    auto TargetObjAddr = Sections[SectionID]->getObjAddress() + Offset;
     for (auto &KV : GlobalSymbolTable) {
       auto &Entry = KV.second;
       auto SymbolObjAddr =
-          Sections[Entry.getSectionID()].getObjAddress() + Entry.getOffset();
+          Sections[Entry.getSectionID()]->getObjAddress() + Entry.getOffset();
       if (TargetObjAddr == SymbolObjAddr)
         return (Entry.getFlags().getTargetFlags() & ARMJITSymbolFlags::Thumb);
     }
     return false;
   }
 
   Expected<int64_t> decodeAddend(const RelocationEntry &RE) const {
-    const SectionEntry &Section = Sections[RE.SectionID];
-    uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
+    SectionEntryConstProxy Section = Sections[RE.SectionID];
+    uint8_t *LocalAddress = Section->getAddressWithOffset(RE.Offset);
 
     switch (RE.RelType) {
       default:
         return memcpyAddend(RE);
       case MachO::ARM_RELOC_BR24: {
         uint32_t Temp = readBytesUnaligned(LocalAddress, 4);
         Temp &= 0x00ffffff; // Mask out the opcode.
         // Now we've got the shifted immediate, shift by 2, sign extend and ret.
else {
         addRelocationForSection(RE, Value.SectionID);
     }
 
     return ++RelI;
   }
 
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
     LLVM_DEBUG(dumpRelocationToResolve(RE, Value));
-    const SectionEntry &Section = Sections[RE.SectionID];
-    uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
+    const SectionEntryProxy Section = Sections[RE.SectionID];
+    uint8_t *LocalAddress = Section->getAddressWithOffset(RE.Offset);
 
     // If the relocation is PC-relative, the value to be encoded is the
     // pointer difference.
     if (RE.IsPCRel) {
-      uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
+      uint64_t FinalAddress = Section->getLoadAddressWithOffset(RE.Offset);
       Value -= FinalAddress;
       // ARM PCRel relocations have an effective-PC offset of two instructions
       // (four bytes in Thumb mode, 8 bytes in ARM mode).
       Value -= (RE.RelType == MachO::ARM_THUMB_RELOC_BR22) ? 4 : 8;
     }
 
     switch (RE.RelType) {
     case MachO::ARM_THUMB_RELOC_BR22: {
case MachO::ARM_RELOC_BR24: {
 
       // Insert the value into the instruction.
       uint32_t Temp = readBytesUnaligned(LocalAddress, 4);
       writeBytesUnaligned((Temp & ~0xffffff) | FinalValue, LocalAddress, 4);
 
       break;
     }
     case MachO::ARM_RELOC_HALF_SECTDIFF: {
-      uint64_t SectionABase = Sections[RE.Sections.SectionA].getLoadAddress();
-      uint64_t SectionBBase = Sections[RE.Sections.SectionB].getLoadAddress();
+      uint64_t SectionABase = Sections[RE.Sections.SectionA]->getLoadAddress();
+      uint64_t SectionBBase = Sections[RE.Sections.SectionB]->getLoadAddress();
       assert((Value == SectionABase || Value == SectionBBase) &&
              "Unexpected HALFSECTDIFF relocation value.");
       Value = SectionABase - SectionBBase + RE.Addend;
       if (RE.Size & 0x1) // :upper16:
         Value = (Value >> 16);
 
       bool IsThumb = RE.Size & 0x2;
 

 
 private:
 
   void processBranchRelocation(const RelocationEntry &RE,
                                const RelocationValueRef &Value,
                                StubMap &Stubs) {
     // This is an ARM branch relocation, need to use a stub function.
     // Look up for existing stub.
-    SectionEntry &Section = Sections[RE.SectionID];
+    SectionEntryProxy Section = Sections[RE.SectionID];
     RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value);
     uint8_t *Addr;
     if (i != Stubs.end()) {
-      Addr = Section.getAddressWithOffset(i->second);
+      Addr = Section->getAddressWithOffset(i->second);
     } else {
       // Create a new stub function.
-      assert(Section.getStubOffset() % 4 == 0 && "Misaligned stub");
-      Stubs[Value] = Section.getStubOffset();
+      assert(Section->getStubOffset() % 4 == 0 && "Misaligned stub");
+      Stubs[Value] = Section->getStubOffset();
       uint32_t StubOpcode = 0;
       if (RE.RelType == MachO::ARM_RELOC_BR24)
         StubOpcode = 0xe51ff004; // ldr pc, [pc, #-4]
       else if (RE.RelType == MachO::ARM_THUMB_RELOC_BR22)
         StubOpcode = 0xf000f8df; // ldr pc, [pc]
       else
         llvm_unreachable("Unrecognized relocation");
-      Addr = Section.getAddressWithOffset(Section.getStubOffset());
+      Addr = Section->getAddressWithOffset(Section->getStubOffset());
       writeBytesUnaligned(StubOpcode, Addr, 4);
       uint8_t *StubTargetAddr = Addr + 4;
       RelocationEntry StubRE(
-          RE.SectionID, StubTargetAddr - Section.getAddress(),
+          RE.SectionID, StubTargetAddr - Section->getAddress(),
           MachO::GENERIC_RELOC_VANILLA, Value.Offset, false, 2);
       StubRE.IsTargetThumbFunc = RE.IsTargetThumbFunc;
       if (Value.SymbolName)
         addRelocationForSymbol(StubRE, Value.SymbolName);
       else
         addRelocationForSection(StubRE, Value.SectionID);
-      Section.advanceStubOffset(getMaxStubSize());
+      Section->advanceStubOffset(getMaxStubSize());
     }
     RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0,
                              RE.IsPCRel, RE.Size);
     resolveRelocation(TargetRE, (uint64_t)Addr);
   }
 
   Expected<relocation_iterator>
   processHALFSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
                                 const ObjectFile &BaseTObj,
                                 ObjSectionToIDMap &ObjSectionToID) {
     const MachOObjectFile &MachO =
         static_cast<const MachOObjectFile&>(BaseTObj);
     MachO::any_relocation_info RE =
         MachO.getRelocation(RelI->getRawDataRefImpl());
 
     // For a half-diff relocation the length bits actually record whether this
     // is a movw/movt, and whether this is arm or thumb.
     // Bit 0 indicates movw (b0 == 0) or movt (b0 == 1).
     // Bit 1 indicates arm (b1 == 0) or thumb (b1 == 1).
     unsigned HalfDiffKindBits = MachO.getAnyRelocationLength(RE);
     bool IsThumb = HalfDiffKindBits & 0x2;
 
-    SectionEntry &Section = Sections[SectionID];
+    SectionEntryProxy Section = Sections[SectionID];
     uint32_t RelocType = MachO.getAnyRelocationType(RE);
     bool IsPCRel = MachO.getAnyRelocationPCRel(RE);
     uint64_t Offset = RelI->getOffset();
-    uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
+    uint8_t *LocalAddress = Section->getAddressWithOffset(Offset);
     int64_t Immediate = readBytesUnaligned(LocalAddress, 4); // Copy the whole instruction out.
 
     if (IsThumb)
       Immediate = ((Immediate & 0x0000000f) << 12) |
                   ((Immediate & 0x00000400) << 1) |
                   ((Immediate & 0x70000000) >> 20) |
                   ((Immediate & 0x00ff0000) >> 16);
     else

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOI386.h

else
       addRelocationForSection(RE, Value.SectionID);
 
     return ++RelI;
   }
 
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
     LLVM_DEBUG(dumpRelocationToResolve(RE, Value));
 
-    const SectionEntry &Section = Sections[RE.SectionID];
-    uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
+    const SectionEntryProxy Section = Sections[RE.SectionID];
+    uint8_t *LocalAddress = Section->getAddressWithOffset(RE.Offset);
 
     if (RE.IsPCRel) {
-      uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
+      uint64_t FinalAddress = Section->getLoadAddressWithOffset(RE.Offset);
       Value -= FinalAddress + 4; // see MachOX86_64::resolveRelocation.
     }
 
     switch (RE.RelType) {
     case MachO::GENERIC_RELOC_VANILLA:
       writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
       break;
     case MachO::GENERIC_RELOC_SECTDIFF:
     case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: {
-      uint64_t SectionABase = Sections[RE.Sections.SectionA].getLoadAddress();
-      uint64_t SectionBBase = Sections[RE.Sections.SectionB].getLoadAddress();
+      uint64_t SectionABase = Sections[RE.Sections.SectionA]->getLoadAddress();
+      uint64_t SectionBBase = Sections[RE.Sections.SectionB]->getLoadAddress();
       assert((Value == SectionABase || Value == SectionBBase) &&
              "Unexpected SECTDIFF relocation value.");
       Value = SectionABase - SectionBBase + RE.Addend;
       writeBytesUnaligned(Value, LocalAddress, 1 << RE.Size);
       break;
     }
     default:
       llvm_unreachable("Invalid relocation type!");
private:
   processSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
                             const ObjectFile &BaseObjT,
                             ObjSectionToIDMap &ObjSectionToID) {
     const MachOObjectFile &Obj =
         static_cast<const MachOObjectFile&>(BaseObjT);
     MachO::any_relocation_info RE =
         Obj.getRelocation(RelI->getRawDataRefImpl());
 
-    SectionEntry &Section = Sections[SectionID];
+    SectionEntryProxy Section = Sections[SectionID];
     uint32_t RelocType = Obj.getAnyRelocationType(RE);
     bool IsPCRel = Obj.getAnyRelocationPCRel(RE);
     unsigned Size = Obj.getAnyRelocationLength(RE);
     uint64_t Offset = RelI->getOffset();
-    uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
+    uint8_t *LocalAddress = Section->getAddressWithOffset(Offset);
     unsigned NumBytes = 1 << Size;
     uint64_t Addend = readBytesUnaligned(LocalAddress, NumBytes);
 
     ++RelI;
     MachO::any_relocation_info RE2 =
         Obj.getRelocation(RelI->getRawDataRefImpl());
 
     uint32_t AddrA = Obj.getScatteredRelocationValue(RE);

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOX86_64.h

else {
         addRelocationForSection(RE, Value.SectionID);
     }
 
     return ++RelI;
   }
 
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
     LLVM_DEBUG(dumpRelocationToResolve(RE, Value));
-    const SectionEntry &Section = Sections[RE.SectionID];
-    uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
+    const SectionEntryProxy Section = Sections[RE.SectionID];
+    uint8_t *LocalAddress = Section->getAddressWithOffset(RE.Offset);
 
     // If the relocation is PC-relative, the value to be encoded is the
     // pointer difference.
     if (RE.IsPCRel) {
       // FIXME: It seems this value needs to be adjusted by 4 for an effective
       // PC address. Is that expected? Only for branches, perhaps?
-      uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
+      uint64_t FinalAddress = Section->getLoadAddressWithOffset(RE.Offset);
       Value -= FinalAddress + 4;
     }
 
     switch (RE.RelType) {
     default:
       llvm_unreachable("Invalid relocation type!");
     case MachO::X86_64_RELOC_SIGNED_1:
     case MachO::X86_64_RELOC_SIGNED_2:
     case MachO::X86_64_RELOC_SIGNED_4:
     case MachO::X86_64_RELOC_SIGNED:
     case MachO::X86_64_RELOC_UNSIGNED:
     case MachO::X86_64_RELOC_BRANCH:
       writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
       break;
     case MachO::X86_64_RELOC_SUBTRACTOR: {
-      uint64_t SectionABase = Sections[RE.Sections.SectionA].getLoadAddress();
-      uint64_t SectionBBase = Sections[RE.Sections.SectionB].getLoadAddress();
+      uint64_t SectionABase = Sections[RE.Sections.SectionA]->getLoadAddress();
+      uint64_t SectionBBase = Sections[RE.Sections.SectionB]->getLoadAddress();
       assert((Value == SectionABase || Value == SectionBBase) &&
              "Unexpected SUBTRACTOR relocation value.");
       Value = SectionABase - SectionBBase + RE.Addend;
       writeBytesUnaligned(Value, LocalAddress, 1 << RE.Size);
       break;
     }
     }
   }
 
   Error finalizeSection(const ObjectFile &Obj, unsigned SectionID,
                         const SectionRef &Section) {
     return Error::success();
   }
 
 private:
   void processGOTRelocation(const RelocationEntry &RE,
                             RelocationValueRef &Value, StubMap &Stubs) {
-    SectionEntry &Section = Sections[RE.SectionID];
+    SectionEntryProxy Section = Sections[RE.SectionID];
     assert(RE.IsPCRel);
     assert(RE.Size == 2);
     Value.Offset -= RE.Addend;
     RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value);
     uint8_t *Addr;
     if (i != Stubs.end()) {
-      Addr = Section.getAddressWithOffset(i->second);
+      Addr = Section->getAddressWithOffset(i->second);
     } else {
-      Stubs[Value] = Section.getStubOffset();
-      uint8_t *GOTEntry = Section.getAddressWithOffset(Section.getStubOffset());
-      RelocationEntry GOTRE(RE.SectionID, Section.getStubOffset(),
+      Stubs[Value] = Section->getStubOffset();
+      uint8_t *GOTEntry =
+          Section->getAddressWithOffset(Section->getStubOffset());
+      RelocationEntry GOTRE(RE.SectionID, Section->getStubOffset(),
                             MachO::X86_64_RELOC_UNSIGNED, Value.Offset, false,
                             3);
       if (Value.SymbolName)
         addRelocationForSymbol(GOTRE, Value.SymbolName);
       else
         addRelocationForSection(GOTRE, Value.SectionID);
-      Section.advanceStubOffset(8);
+      Section->advanceStubOffset(8);
       Addr = GOTEntry;
     }
     RelocationEntry TargetRE(RE.SectionID, RE.Offset,
                              MachO::X86_64_RELOC_UNSIGNED, RE.Addend, true, 2);
     resolveRelocation(TargetRE, (uint64_t)Addr);
   }
 
   Expected<relocation_iterator>
   processSubtractRelocation(unsigned SectionID, relocation_iterator RelI,
                             const MachOObjectFile &BaseObj,
                             ObjSectionToIDMap &ObjSectionToID) {
     const MachOObjectFile &Obj =
         static_cast<const MachOObjectFile&>(BaseObj);
     MachO::any_relocation_info RE =
         Obj.getRelocation(RelI->getRawDataRefImpl());
 
     unsigned Size = Obj.getAnyRelocationLength(RE);
     uint64_t Offset = RelI->getOffset();
-    uint8_t *LocalAddress = Sections[SectionID].getAddressWithOffset(Offset);
+    uint8_t *LocalAddress = Sections[SectionID]->getAddressWithOffset(Offset);
     unsigned NumBytes = 1 << Size;
     int64_t Addend =
       SignExtend64(readBytesUnaligned(LocalAddress, NumBytes), NumBytes * 8);
 
     unsigned SectionBID = ~0U;
     uint64_t SectionBOffset = 0;
 
     MachO::any_relocation_info RelInfo =