[ELF] - Do not apply relocations to .debug_ranges when building -gdb-index

[grimar]

Summary

Looks we do not really need to apply relocations to .debug_ranges section
when building .gdb_index.

What we need is to scan relocations and take target section indices use addends
as begin/end addresses.
That allows to skip actual relocations computations and speedups building .gdb_index.

When linking llc binary with -gdb-index numbers I got (from 25 runs) were:

• Without this patch: 5,724493319 seconds time elapsed ( +- 0,13% )
• With this path: 5,352222105 seconds time elapsed ( +- 0,10% )

It is about 6.5% speedup.

[grimar]

• Removed unrelative change.

[dblaikie]

ELF/SyntheticSections.cpp

1821–1822

Any particular reason this would only be done for ranges sections and not for other sections?

1851

This function always returns true, so may be better off having void return instead. The return value doesn't seem to be communicating anything.

[grimar]

ELF/SyntheticSections.cpp

1821–1822

I tried to focus on feature itself and keep patch as short as possible for initial review.
I think that can be done for all sections required for building .gdb_index (though I did not check by myself yet).
At least I do not know any reason why it should not work atm.

[ruiu]

Looks like this patch does a tricky thing only to gain 6.5% speedup. If we are behind gold by 6.5%, this might be worth adding, but the performance gap is much more than that, no? If so, it seems a premature optimization to me.

[grimar]

In D35005#805855, @ruiu wrote:

Looks like this patch does a tricky thing only to gain 6.5% speedup. If we are behind gold by 6.5%, this might be worth adding, but the performance gap is much more than that, no? If so, it seems a premature optimization to me.

This patch was placed on hold recently.
Rafael mentioned (D35004 + D35236 threads) a different patch for parsers he working on, which perfomance results sounds much better.

[grimar]

I assume D35386 will be landed instead.

ELF/SyntheticSections.cpp

for (NameTypeEntry &NameType : D.NamesAndTypes) {
 
       CuVectors[Sym->CuVectorIndex].insert(CuId | (NameType.Type << 24));
     }
 
     CuId += D.CompilationUnits.size();
   }
 }
 
+namespace {
+template <class ELFT> class ObjectInfo final : public LoadedObjectInfo {
+public:
+  uint64_t getSectionLoadAddress(const object::SectionRef &Sec) const override {
+    return 0;
+  }
+  std::unique_ptr<LoadedObjectInfo> clone() const override { return {}; }
+
+  ObjectInfo(const object::ObjectFile &Obj)
+      : ElfObj(cast<ELFObjectFile<ELFT>>(Obj)) {}
+
+  bool relocate(const object::SectionRef &RelSec,
+                RelocAddrMap *Map) const override {
+    StringRef S;
+    if (std::error_code EC = RelSec.getName(S))
+      return false;
+    if (S == ".rela.debug_ranges" || S == ".rel.debug_ranges")
+      return relocateDebugRanges(RelSec, Map);
+    return false;
+  }
+
+private:
+  typedef typename ELFT::Shdr Elf_Shdr;
+  typedef typename ELFT::Sym Elf_Sym;
+
+  const ELFObjectFile<ELFT> &ElfObj;
+
+  bool relocateDebugRanges(const object::SectionRef &RelSec,
+                           RelocAddrMap *Map) const {
+    const ELFFile<ELFT> *ElfFile = ElfObj.getELFFile();
+    const Elf_Shdr *RelSecShdr = ElfObj.getSection(RelSec.getRawDataRefImpl());
+    const Elf_Shdr *SymTabShdr =
+        check(ElfFile->getSection(RelSecShdr->sh_link));
+
+    if (RelSecShdr->sh_type == SHT_RELA) {
+      ArrayRef<typename ELFT::Rela> Entries = check(
+          ElfFile->template getSectionContentsAsArray<typename ELFT::Rela>(
+              RelSecShdr));
+      scanDebugRangesRelocations(SymTabShdr, Entries, Map);
+    } else {
+      ArrayRef<typename ELFT::Rel> Entries =
+          check(ElfFile->template getSectionContentsAsArray<typename ELFT::Rel>(
+              RelSecShdr));
+      scanDebugRangesRelocations(SymTabShdr, Entries, Map);
+    }
+
+    return true;
+  }
+
+  uint64_t getAddend(const Elf_Shdr *Sec, const typename ELFT::Rel &Rel) const {
+    const ELFFile<ELFT> *ElfFile = ElfObj.getELFFile();
+    ArrayRef<uint8_t> Data =
+        check(ElfFile->template getSectionContentsAsArray<uint8_t>(Sec));
+    return Target->getImplicitAddend(Data.begin() + Rel.r_offset,
+                                     Rel.getType(Config->IsMips64EL));
+  }
+
+  uint64_t getAddend(const Elf_Shdr *Sec,
+                     const typename ELFT::Rela &Rel) const {
+    return Rel.r_addend;
+  }
+
+  template <class RelTy>
+  void scanDebugRangesRelocations(const Elf_Shdr *SymTab, ArrayRef<RelTy> Rels,
+                                  RelocAddrMap *Map) const {
+    const ELFFile<ELFT> *ElfFile = ElfObj.getELFFile();
+
+    ArrayRef<Elf_Sym> Symbols = check(ElfFile->symbols(SymTab));
+    ArrayRef<Elf_Shdr> Sections = check(ElfFile->sections());
+
+    for (const RelTy &Rel : Rels) {
+      uint32_t SymId = Rel.getSymbol(Config->IsMips64EL);
+      uint64_t SecIndex = Symbols[SymId].st_shndx;
+      uint64_t A = getAddend(&Sections[SecIndex], Rel);
+      RelocAddrEntry RelEntry = {SecIndex, A};
+      Map->insert({Rel.r_offset, RelEntry});
+    }
+  }
+};
+
+std::unique_ptr<LoadedObjectInfo>
+createObjectInfo(const object::ObjectFile &Obj) {
+  switch (Config->EKind) {
+  case ELF32LEKind:
+    return llvm::make_unique<ObjectInfo<ELF32LE>>(Obj);
+  case ELF32BEKind:
+    return llvm::make_unique<ObjectInfo<ELF32BE>>(Obj);
+  case ELF64LEKind:
+    return llvm::make_unique<ObjectInfo<ELF64LE>>(Obj);
+  case ELF64BEKind:
+    return llvm::make_unique<ObjectInfo<ELF64BE>>(Obj);
+  default:
+    llvm_unreachable("unknown Config->EKind");
+  }
+}
+
+} // namespace
+
 GdbIndexChunk GdbIndexSection::readDwarf(InputSection *Sec) {
   Expected<std::unique_ptr<object::ObjectFile>> Obj =
       object::ObjectFile::createObjectFile(Sec->File->MB);
   if (!Obj) {
     error(toString(Sec->File) + ": error creating DWARF context");
     return {};
   }
 
-  DWARFContextInMemory Dwarf(*Obj.get());
+  std::unique_ptr<LoadedObjectInfo> ObjInfo = createObjectInfo(*Obj.get());
+  DWARFContextInMemory Dwarf(*Obj.get(), ObjInfo.get());
 
   GdbIndexChunk Ret;
   Ret.CompilationUnits = readCuList(Dwarf, Sec);
   Ret.AddressArea = readAddressArea(Dwarf, Sec);
   Ret.NamesAndTypes = readPubNamesAndTypes(Dwarf, Config->IsLE);
   return Ret;
 }
 
for (GdbIndexChunk &D : Chunks) {
     }
   }
 
   // Write the address area.
   for (GdbIndexChunk &D : Chunks) {
     for (AddressEntry &E : D.AddressArea) {
       uint64_t BaseAddr =
           E.Section->getParent()->Addr + E.Section->getOffset(0);
-      write64le(Buf, BaseAddr + E.LowAddress);
-      write64le(Buf + 8, BaseAddr + E.HighAddress);
+      write64le(Buf, BaseAddr/* + E.Section->*/);
+      write64le(Buf + 8, BaseAddr +E.Section->getSize() /* + E.HighAddress*/);
       write32le(Buf + 16, E.CuIndex);
       Buf += 20;
     }
   }
 
   // Write the symbol table.
   for (size_t I = 0; I < SymbolTable.getCapacity(); ++I) {
     GdbSymbol *Sym = SymbolTable.getSymbol(I);