[RuntimeDyld] Don't allocate unnecessary stub buffer space

[sanjoy]

Summary

For relocation types that are known to not require stub functions, there
is no need to allocate extra space for the stub functions.

[maksfb]

Sanjoy, I'm not very familiar with all scenarios where stubs are used. Is it possible R_X86_64_PC32 relocation will need a stub?

[sanjoy]

In D14676#289725, @maksfb wrote:

Sanjoy, I'm not very familiar with all scenarios where stubs are used. Is it possible R_X86_64_PC32 relocation will need a stub?

I'm just going by reading the code (I'm not familiar with linkers in
general), but the relevant clause in
RuntimeDyldELF::processRelocationRef seems to be

} else if (RelType == ELF::R_X86_64_PC32) {
  Value.Addend += support::ulittle32_t::ref(computePlaceholderAddress(SectionID, Offset));
  processSimpleRelocation(SectionID, Offset, RelType, Value);

and it does not seem to require stub space. In fact, from reading the
code, pretty much the only relocation for x86_64/ELF that needs stub
space is ELF::R_X86_64_PLT32.

In any case, if I'm wrong, D14674 and D14675 should make it obvious an
obvious crash.

[sanjoy]

ping!

[lhames]

Hi Sanjoy,

Sorry for the delay in reviewing this - I'm still out on vacation for another week.

I think relocationNeedsStub should be a virtual function so that we don't need to check relocations for other formats/archs, but other than that this looks good to me. :)

Cheers,
Lang.

[maksfb]

Sorry, for some reason phabricator emails escaped my inbox. The diff looks great!

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

void RuntimeDyldImpl::computeTotalAllocSize(const ObjectFile &Obj,
   // allocated with the max alignment. Note that we cannot compute with the
   // individual alignments of the sections, because then the required size
   // depends on the order, in which the sections are allocated.
   CodeSize = computeAllocationSizeForSections(CodeSectionSizes, MaxAlignment);
   DataSizeRO = computeAllocationSizeForSections(ROSectionSizes, MaxAlignment);
   DataSizeRW = computeAllocationSizeForSections(RWSectionSizes, MaxAlignment);
 }
 
+bool RuntimeDyldImpl::relocationNeedsStub(const RelocationRef &R) {
+  if (Arch != Triple::x86_64)
+    return true;  // Conservative answer
+
+  switch (R.getType()) {
+  default:
+    return true;  // Conservative answer
+
+
+  case ELF::R_X86_64_GOTPCREL:
+  case ELF::R_X86_64_PC32:
+  case ELF::R_X86_64_PC64:
+  case ELF::R_X86_64_64:
+    // We know that these reloation types won't need a stub function.  This list
+    // can be extended as needed.
+    return false;
+  }
+}
+
 // compute stub buffer size for the given section
 unsigned RuntimeDyldImpl::computeSectionStubBufSize(const ObjectFile &Obj,
                                                     const SectionRef &Section) {
   unsigned StubSize = getMaxStubSize();
   if (StubSize == 0) {
     return 0;
   }
   // FIXME: this is an inefficient way to handle this. We should computed the
   // necessary section allocation size in loadObject by walking all the sections
   // once.
   unsigned StubBufSize = 0;
   for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
        SI != SE; ++SI) {
     section_iterator RelSecI = SI->getRelocatedSection();
     if (!(RelSecI == Section))
       continue;
 
-    for (const RelocationRef &Reloc : SI->relocations()) {
-      (void)Reloc;
+    for (const RelocationRef &Reloc : SI->relocations())
+      if (relocationNeedsStub(Reloc))
         StubBufSize += StubSize;
-    }
-  }
 
   // Get section data size and alignment
   uint64_t DataSize = Section.getSize();
   uint64_t Alignment64 = Section.getAlignment();
 
   // Add stubbuf size alignment
   unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
   unsigned StubAlignment = getStubAlignment();

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h

#define RTDYLD_INVALID_SECTION_ID ((RuntimeDyldImpl::SID)(-1))
 
   // \brief Compute the stub buffer size required for a section
   unsigned computeSectionStubBufSize(const ObjectFile &Obj,
                                      const SectionRef &Section);
 
   // \brief Implementation of the generic part of the loadObject algorithm.
   ObjSectionToIDMap loadObjectImpl(const object::ObjectFile &Obj);
 
+  // \brief Return true if the relocation R may require allocating a stub.
+  bool relocationNeedsStub(const RelocationRef &R);
+
 public:
   RuntimeDyldImpl(RuntimeDyld::MemoryManager &MemMgr,
                   RuntimeDyld::SymbolResolver &Resolver)
     : MemMgr(MemMgr), Resolver(Resolver), Checker(nullptr),
       ProcessAllSections(false), HasError(false) {
   }
 
   virtual ~RuntimeDyldImpl();

test/ExecutionEngine/RuntimeDyld/X86/ELF_x86_64_StubBuf.s

+# RUN: llvm-mc -triple=x86_64-apple-macosx10.10.0 -filetype=obj -o %T/test_ELF_x86_64_StubBuf.o %s
+# RUN: llvm-rtdyld -print-alloc-requests -triple=x86_64-pc-linux -dummy-extern _g=196608 -verify %T/test_ELF_x86_64_StubBuf.o
+
+# Compiled from Inputs/ELF/ELF_x86_64_StubBuf.ll
+
+# CHECK: allocateCodeSection(Size = 42, Alignment = 16, SectionName = __text)
+
+  .section  __TEXT,__text,regular,pure_instructions
+  .macosx_version_min 10, 10
+  .globl  _f
+  .align  4, 0x90
+_f:                                     ## @f
+  .cfi_startproc
+## BB#0:                                ## %entry
+  pushq %rax
+Ltmp0:
+  .cfi_def_cfa_offset 16
+  callq _g
+  callq _g
+  callq _g
+  popq  %rax
+  retq
+  .cfi_endproc
+
+
+.subsections_via_symbols

test/ExecutionEngine/RuntimeDyld/X86/Inputs/ELF_x86_64_StubBuf.ll

+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.10.0"
+
+declare void @g()
+
+define void @f() {
+ entry:
+  call void @g()
+  call void @g()
+  call void @g()
+  ret void
+}

tools/llvm-rtdyld/llvm-rtdyld.cpp

 
 static cl::list<std::string>
 DummySymbolMappings("dummy-extern",
                     cl::desc("For -verify only: Inject a symbol into the extern "
                              "symbol table."),
                     cl::ZeroOrMore,
                     cl::Hidden);
 
+static cl::opt<bool>
+PrintAllocationRequests("print-alloc-requests",
+                        cl::desc("Print allocation requests made to the memory "
+                                 "manager by RuntimeDyld"),
+                        cl::Hidden);
+
 /* *** */
 
 // A trivial memory manager that doesn't do anything fancy, just uses the
 // support library allocation routines directly.
 class TrivialMemoryManager : public RTDyldMemoryManager {
 public:
   SmallVector<sys::MemoryBlock, 16> FunctionMemory;
   SmallVector<sys::MemoryBlock, 16> DataMemory;
private:
   uintptr_t SlabSize = 0;
   uintptr_t CurrentSlabOffset = 0;
 };
 
 uint8_t *TrivialMemoryManager::allocateCodeSection(uintptr_t Size,
                                                    unsigned Alignment,
                                                    unsigned SectionID,
                                                    StringRef SectionName) {
+  if (PrintAllocationRequests)
+    outs() << "allocateCodeSection(Size = " << Size << ", Alignment = "
+           << Alignment << ", SectionName = " << SectionName << ")\n";
+
   if (UsePreallocation)
     return allocateFromSlab(Size, Alignment, true /* isCode */);
 
   std::string Err;
   sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, nullptr, &Err);
   if (!MB.base())
     report_fatal_error("MemoryManager allocation failed: " + Err);
   FunctionMemory.push_back(MB);
   return (uint8_t*)MB.base();
 }
 
 uint8_t *TrivialMemoryManager::allocateDataSection(uintptr_t Size,
                                                    unsigned Alignment,
                                                    unsigned SectionID,
                                                    StringRef SectionName,
                                                    bool IsReadOnly) {
+  if (PrintAllocationRequests)
+    outs() << "allocateDataSection(Size = " << Size << ", Alignment = "
+           << Alignment << ", SectionName = " << SectionName << ")\n";
+
   if (UsePreallocation)
     return allocateFromSlab(Size, Alignment, false /* isCode */);
 
   std::string Err;
   sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, nullptr, &Err);
   if (!MB.base())
     report_fatal_error("MemoryManager allocation failed: " + Err);
   DataMemory.push_back(MB);