[ELF] Change GnuPub{Names,Types}Section from StringRef to LLDDWARFSection

[MaskRay]

Summary

The debug_info_offset value may be relocated.

This is lld side change of D54375.

[ruiu]

lld/trunk/ELF/SyntheticSections.cpp

2517 ↗

(On Diff #173565)

Is the object you get with the following line

auto &Obj = static_cast<const LLDDwarfObj<ELFT> &>(Dwarf.getDWARFObj());

the same object as you create at this line? If so, I'd pass the object you are creating with make_unique to readPubNamesAndTypes instead of passing a Dwarf object.

ELF/DWARF.h

public:
   const llvm::DWARFSection &getRangeSection() const override {
     return RangeSection;
   }
 
   const llvm::DWARFSection &getLineSection() const override {
     return LineSection;
   }
 
-  StringRef getFileName() const override { return ""; }
-  StringRef getAbbrevSection() const override { return AbbrevSection; }
-  StringRef getStringSection() const override { return StrSection; }
-  StringRef getLineStringSection() const override { return LineStringSection; }
-
-  StringRef getGnuPubNamesSection() const override {
+  const llvm::DWARFSection &getGnuPubNamesSection() const override {
     return GnuPubNamesSection;
   }
 
-  StringRef getGnuPubTypesSection() const override {
+  const llvm::DWARFSection &getGnuPubTypesSection() const override {
     return GnuPubTypesSection;
   }
 
+  StringRef getFileName() const override { return ""; }
+  StringRef getAbbrevSection() const override { return AbbrevSection; }
+  StringRef getStringSection() const override { return StrSection; }
+  StringRef getLineStringSection() const override { return LineStringSection; }
+
   bool isLittleEndian() const override {
     return ELFT::TargetEndianness == llvm::support::little;
   }
 
   llvm::Optional<llvm::RelocAddrEntry> find(const llvm::DWARFSection &Sec,
                                             uint64_t Pos) const override;
 
 private:
   template <class RelTy>
   llvm::Optional<llvm::RelocAddrEntry> findAux(const InputSectionBase &Sec,
                                                uint64_t Pos,
                                                ArrayRef<RelTy> Rels) const;
 
+  LLDDWARFSection GnuPubNamesSection;
+  LLDDWARFSection GnuPubTypesSection;
   LLDDWARFSection InfoSection;
   LLDDWARFSection RangeSection;
   LLDDWARFSection LineSection;
 
   StringRef AbbrevSection;
-  StringRef GnuPubNamesSection;
-  StringRef GnuPubTypesSection;
   StringRef StrSection;
   StringRef LineStringSection;
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/DWARF.cpp

 using namespace lld;
 using namespace lld::elf;
 
 template <class ELFT> LLDDwarfObj<ELFT>::LLDDwarfObj(ObjFile<ELFT> *Obj) {
   for (InputSectionBase *Sec : Obj->getSections()) {
     if (!Sec)
       continue;
 
-    if (LLDDWARFSection *M = StringSwitch<LLDDWARFSection *>(Sec->Name)
-                                 .Case(".debug_info", &InfoSection)
-                                 .Case(".debug_ranges", &RangeSection)
-                                 .Case(".debug_line", &LineSection)
-                                 .Default(nullptr)) {
+    if (LLDDWARFSection *M =
+            StringSwitch<LLDDWARFSection *>(Sec->Name)
+                .Case(".debug_gnu_pubnames", &GnuPubNamesSection)
+                .Case(".debug_gnu_pubtypes", &GnuPubTypesSection)
       M->Data = toStringRef(Sec->data());
       M->Sec = Sec;
       continue;
     }
 
     if (Sec->Name == ".debug_abbrev")
       AbbrevSection = toStringRef(Sec->data());
-    else if (Sec->Name == ".debug_gnu_pubnames")
-      GnuPubNamesSection = toStringRef(Sec->data());
-    else if (Sec->Name == ".debug_gnu_pubtypes")
-      GnuPubTypesSection = toStringRef(Sec->data());
     else if (Sec->Name == ".debug_str")
       StrSection = toStringRef(Sec->data());
     else if (Sec->Name == ".debug_line_str")
       LineStringSection = toStringRef(Sec->data());
   }
 }
 
 // Find if there is a relocation at Pos in Sec.  The code is a bit

ELF/SyntheticSections.cpp

for (DWARFAddressRange &R : Ranges) {
       uint64_t Offset = IS->getOffsetInFile();
       Ret.push_back({IS, R.LowPC - Offset, R.HighPC - Offset, CuIdx});
     }
     ++CuIdx;
   }
   return Ret;
 }
 
+template <class ELFT>
 static std::vector<GdbIndexSection::NameTypeEntry>
 readPubNamesAndTypes(DWARFContext &Dwarf, uint32_t Idx) {
-  StringRef Sec1 = Dwarf.getDWARFObj().getGnuPubNamesSection();
-  StringRef Sec2 = Dwarf.getDWARFObj().getGnuPubTypesSection();
+  auto &Obj = static_cast<const LLDDwarfObj<ELFT> &>(Dwarf.getDWARFObj());
+  const DWARFSection &PubNames = Obj.getGnuPubNamesSection();
+  const DWARFSection &PubTypes = Obj.getGnuPubTypesSection();
 
   std::vector<GdbIndexSection::NameTypeEntry> Ret;
-  for (StringRef Sec : {Sec1, Sec2}) {
-    DWARFDebugPubTable Table(Sec, Config->IsLE, true);
+  for (const DWARFSection *Pub : {&PubNames, &PubTypes}) {
+    DWARFDebugPubTable Table(Obj, *Pub, Config->IsLE, true);
     for (const DWARFDebugPubTable::Set &Set : Table.getData())
       for (const DWARFDebugPubTable::Entry &Ent : Set.Entries)
         Ret.push_back({{Ent.Name, computeGdbHash(Ent.Name)},
                        (Ent.Descriptor.toBits() << 24) | Idx});
   }
   return Ret;
 }
 
template <class ELFT> GdbIndexSection *GdbIndexSection::create() {
 
   parallelForEachN(0, Sections.size(), [&](size_t I) {
     ObjFile<ELFT> *File = Sections[I]->getFile<ELFT>();
     DWARFContext Dwarf(make_unique<LLDDwarfObj<ELFT>>(File));
 
     Chunks[I].Sec = Sections[I];
     Chunks[I].CompilationUnits = readCuList(Dwarf);
     Chunks[I].AddressAreas = readAddressAreas(Dwarf, Sections[I]);
-    NameTypes[I] = readPubNamesAndTypes(Dwarf, I);
+    NameTypes[I] = readPubNamesAndTypes<ELFT>(Dwarf, I);
   });
 
   auto *Ret = make<GdbIndexSection>();
   Ret->Chunks = std::move(Chunks);
   Ret->Symbols = createSymbols(NameTypes);
   Ret->initOutputSize();
   return Ret;
 }