[RuntimeDyldELF] Make GOT allocation use the stub mechanism.

[loladiro]

Summary

This is the follow-on commit to D8813, which switches the GOT from a separate section to use the stub mechanism. The primary disadvantage of this approach is that the code section will have RX permissions, while the GOT usually has RW permissions. However, until the memory manager has the capability to allocate sections sufficiently close to each other, there is not much else we can do. The other concern, both for this approach and the separate GOT section is that we need to know ahead of time how much memory will be needed, even though we only discover this information upon actually processing the relocations. The current approach is to provide an upper bound for the amount of space (both Stub and GOT) needed, though it would be good to revisit this in the future.

[lhames]

It looks like this diff (or at least part of it) made it in in r234839. Does this still need review?

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

void resolveMIPSRelocation(const SectionEntry &Section, uint64_t Offset,
                              uint32_t Value, uint32_t Type, int32_t Addend);
 
   void resolvePPC64Relocation(const SectionEntry &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);
 
+  // Get the maximum necessary stub space needed for one relocation
   unsigned getMaxStubSize() 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 (Arch == Triple::mipsel || Arch == Triple::mips)
       return 16;
     else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le)
       return 44;
     else if (Arch == Triple::x86_64)
-      return 6; // 2-byte jmp instruction + 32-bit relative address
+      return 16; // but we may need to allocate up to two GOT entries (=16).
     else if (Arch == Triple::systemz)
       return 16;
     else
       return 0;
   }
 
+  // Get the size of just the function itself.
+  // This is in general smaller than getMaxStubSize if the stub
+  // function also needs a GOT entry.
+  unsigned getMaxStubFunctionSize() {
+    if (Arch == Triple::x86_64)
+      return 6; // 2-byte jmp instruction + 32-bit relative address
+    else
+      return getMaxStubSize();
+  }
+
   unsigned getStubAlignment() override {
     if (Arch == Triple::systemz)
       return 8;
     else
       return 1;
   }
 
   void findPPC64TOCSection(const ObjectFile &Obj,

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

if (Value.SymbolName) {
         uintptr_t StubAlignment = getStubAlignment();
         StubAddress = (BaseAddress + Section.StubOffset + StubAlignment - 1) &
                       -StubAlignment;
         unsigned StubOffset = StubAddress - BaseAddress;
         Stubs[Value] = StubOffset;
         createStubFunction((uint8_t *)StubAddress);
 
         // Bump our stub offset counter
-        Section.StubOffset = StubOffset + getMaxStubSize();
+        Section.StubOffset = StubOffset + getMaxStubFunctionSize();
 
         // Allocate a GOT Entry
         uint64_t GOTOffset = allocateGOTEntries(SectionID, 1);
 
         // The load of the GOT address has an addend of -4
         resolveGOTOffsetRelocation(SectionID, StubOffset + 2, GOTOffset - 4);
 
         // Fill in the value of the symbol we're targeting into the GOT
size_t RuntimeDyldELF::getGOTEntrySize() {
   default:
     llvm_unreachable("Unsupported CPU type!");
   }
   return Result;
 }
 
 uint64_t RuntimeDyldELF::allocateGOTEntries(unsigned SectionID, unsigned no)
 {
-  (void)SectionID; // The GOT Section is the same for all section in the object file
-  if (GOTSectionID == 0) {
-    GOTSectionID = Sections.size();
-    // Reserve a section id. We'll allocate the section later
-    // once we know the total size
-    Sections.push_back(SectionEntry(".got", 0, 0, 0));
-  }
-  uint64_t StartOffset = CurrentGOTIndex * getGOTEntrySize();
-  CurrentGOTIndex += no;
-  return StartOffset;
+    SectionEntry &Section = getSection(SectionID);
+    uint64_t Offset = Section.StubOffset;
+    Section.StubOffset += 8*no;
+    return Offset;
 }
 
 void RuntimeDyldELF::resolveGOTOffsetRelocation(unsigned SectionID, uint64_t Offset, uint64_t GOTOffset)
 {
-  // Fill in the relative address of the GOT Entry into the stub
-  RelocationEntry GOTRE(SectionID, Offset, ELF::R_X86_64_PC32, GOTOffset);
-  addRelocationForSection(GOTRE, GOTSectionID);
+    SectionEntry &Section = getSection(SectionID);
+    resolveRelocation(Section, Offset,
+                      (uint64_t)Section.Address + GOTOffset, ELF::R_X86_64_PC32,
+                      0);
 }
 
 RelocationEntry RuntimeDyldELF::computeGOTOffsetRE(unsigned SectionID, uint64_t GOTOffset, uint64_t SymbolOffset,
                                                    uint32_t Type)
 {
-  (void)SectionID; // The GOT Section is the same for all section in the object file
-  return RelocationEntry(GOTSectionID, GOTOffset, Type, SymbolOffset);
+  return RelocationEntry(SectionID, GOTOffset, Type, SymbolOffset);
 }
 
 void RuntimeDyldELF::finalizeLoad(const ObjectFile &Obj,
                                   ObjSectionToIDMap &SectionMap) {
-  // If necessary, allocate the global offset table
-  if (GOTSectionID != 0) {
-    // Allocate memory for the section
-    size_t TotalSize = CurrentGOTIndex * getGOTEntrySize();
-    uint8_t *Addr = MemMgr.allocateDataSection(TotalSize, getGOTEntrySize(),
-                                                GOTSectionID, ".got", false);
-    if (!Addr)
-      report_fatal_error("Unable to allocate memory for GOT!");
-
-    Sections[GOTSectionID] = SectionEntry(".got", Addr, TotalSize, 0);
-
-    if (Checker)
-      Checker->registerSection(Obj.getFileName(), GOTSectionID);
-
-    // For now, initialize all GOT entries to zero.  We'll fill them in as
-    // needed when GOT-based relocations are applied.
-    memset(Addr, 0, TotalSize);
-  }
-
   // Look for and record the EH frame section.
   ObjSectionToIDMap::iterator i, e;
   for (i = SectionMap.begin(), e = SectionMap.end(); i != e; ++i) {
     const SectionRef &Section = i->first;
     StringRef Name;
     Section.getName(Name);
     if (Name == ".eh_frame") {
       UnregisteredEHFrameSections.push_back(i->second);