Remove MipsAbiFlagsSection class and add createMipsAbiFlagsSection function instead.

[ruiu]

Summary

I was trying to remove a MIPS-specific class because it can just be
represented as InputSection. However, when I made this logically-equivalent
change, some tests started failing because section offsets were no longer
the same as before. Do you have any idea how this can happen?

[atanasyan]

I do not know what happens (did not have a time for a detailed investigation), but an immediate reason is appearing empty .bss.rel.ro section in the linked file.

lld/ELF/SyntheticSections.h

private:
   size_t Size;
 
   // String table contents
   constexpr static size_t NumShards = 32;
   std::vector<llvm::StringTableBuilder> Shards;
   size_t ShardOffsets[NumShards];
 };
 
-// .MIPS.abiflags section.
-template <class ELFT>
-class MipsAbiFlagsSection final : public SyntheticSection {
-  typedef llvm::object::Elf_Mips_ABIFlags<ELFT> Elf_Mips_ABIFlags;
-
-public:
-  static MipsAbiFlagsSection *create();
-
-  MipsAbiFlagsSection(Elf_Mips_ABIFlags Flags);
-  size_t getSize() const override { return sizeof(Elf_Mips_ABIFlags); }
-  void writeTo(uint8_t *Buf) override;
-
-private:
-  Elf_Mips_ABIFlags Flags;
-};
-
 // .MIPS.options section.
 template <class ELFT> class MipsOptionsSection final : public SyntheticSection {
   typedef llvm::object::Elf_Mips_Options<ELFT> Elf_Mips_Options;
   typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
 
 public:
   static MipsOptionsSection *create();
 

 private:
   std::vector<const Thunk *> Thunks;
   size_t Size = 0;
 };
 
 template <class ELFT> void createCommonSections();
 InputSection *createInterpSection();
 template <class ELFT> MergeInputSection *createCommentSection();
+template <class ELFT> InputSection *createMipsAbiFlagsSection();
 void decompressSections();
 void mergeSections();
 
 SymbolBody *addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
                               uint64_t Size, InputSectionBase *Section);
 
 // Linker generated sections which can be used as inputs.
 struct InX {

lld/ELF/SyntheticSections.cpp

template <class ELFT> MergeInputSection *elf::createCommentSection() {
 
   auto *Ret =
       make<MergeInputSection>((ObjFile<ELFT> *)nullptr, &Hdr, ".comment");
   Ret->Data = getVersion();
   return Ret;
 }
 
 // .MIPS.abiflags section.
-template <class ELFT>
-MipsAbiFlagsSection<ELFT>::MipsAbiFlagsSection(Elf_Mips_ABIFlags Flags)
-    : SyntheticSection(SHF_ALLOC, SHT_MIPS_ABIFLAGS, 8, ".MIPS.abiflags"),
-      Flags(Flags) {
-  this->Entsize = sizeof(Elf_Mips_ABIFlags);
-}
+template <class ELFT> InputSection *elf::createMipsAbiFlagsSection() {
+  typedef llvm::object::Elf_Mips_ABIFlags<ELFT> Elf_Mips_ABIFlags;
 
-template <class ELFT> void MipsAbiFlagsSection<ELFT>::writeTo(uint8_t *Buf) {
-  memcpy(Buf, &Flags, sizeof(Flags));
-}
-
-template <class ELFT>
-MipsAbiFlagsSection<ELFT> *MipsAbiFlagsSection<ELFT>::create() {
   Elf_Mips_ABIFlags Flags = {};
   bool Create = false;
 
   for (InputSectionBase *Sec : InputSections) {
     if (Sec->Type != SHT_MIPS_ABIFLAGS)
       continue;
     Sec->Live = false;
     Create = true;
for (InputSectionBase *Sec : InputSections) {
     Flags.cpr1_size = std::max(Flags.cpr1_size, S->cpr1_size);
     Flags.cpr2_size = std::max(Flags.cpr2_size, S->cpr2_size);
     Flags.ases |= S->ases;
     Flags.flags1 |= S->flags1;
     Flags.flags2 |= S->flags2;
     Flags.fp_abi = elf::getMipsFpAbiFlag(Flags.fp_abi, S->fp_abi, Filename);
   };
 
-  if (Create)
-    return make<MipsAbiFlagsSection<ELFT>>(Flags);
+  if (!Create)
     return nullptr;
+
+  auto *Buf = make<std::vector<uint8_t>>(sizeof(Flags));
+  memcpy(Buf->data(), &Flags, sizeof(Flags));
+
+  auto *Ret = make<InputSection>(SHF_ALLOC, SHT_MIPS_ABIFLAGS, 8, *Buf,
+                                 ".MIPS.abiflags");
+  Ret->Entsize = sizeof(Flags);
+  Ret->Live = true;
+  return Ret;
 }
 
 // .MIPS.options section.
 template <class ELFT>
 MipsOptionsSection<ELFT>::MipsOptionsSection(Elf_Mips_RegInfo Reginfo)
     : SyntheticSection(SHF_ALLOC, SHT_MIPS_OPTIONS, 8, ".MIPS.options"),
       Reginfo(Reginfo) {
   this->Entsize = sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);

 template void elf::createCommonSections<ELF64LE>();
 template void elf::createCommonSections<ELF64BE>();
 
 template MergeInputSection *elf::createCommentSection<ELF32LE>();
 template MergeInputSection *elf::createCommentSection<ELF32BE>();
 template MergeInputSection *elf::createCommentSection<ELF64LE>();
 template MergeInputSection *elf::createCommentSection<ELF64BE>();
 
-template class elf::MipsAbiFlagsSection<ELF32LE>;
-template class elf::MipsAbiFlagsSection<ELF32BE>;
-template class elf::MipsAbiFlagsSection<ELF64LE>;
-template class elf::MipsAbiFlagsSection<ELF64BE>;
+template InputSection *elf::createMipsAbiFlagsSection<ELF32LE>();
+template InputSection *elf::createMipsAbiFlagsSection<ELF32BE>();
+template InputSection *elf::createMipsAbiFlagsSection<ELF64LE>();
+template InputSection *elf::createMipsAbiFlagsSection<ELF64BE>();
 
 template class elf::MipsOptionsSection<ELF32LE>;
 template class elf::MipsOptionsSection<ELF32BE>;
 template class elf::MipsOptionsSection<ELF64LE>;
 template class elf::MipsOptionsSection<ELF64BE>;
 
 template class elf::MipsReginfoSection<ELF32LE>;
 template class elf::MipsReginfoSection<ELF32BE>;

lld/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::createSyntheticSections() {
   Add(InX::BssRelRo);
 
   // Add MIPS-specific sections.
   if (Config->EMachine == EM_MIPS) {
     if (!Config->Shared && Config->HasDynSymTab) {
       InX::MipsRldMap = make<MipsRldMapSection>();
       Add(InX::MipsRldMap);
     }
-    if (auto *Sec = MipsAbiFlagsSection<ELFT>::create())
+    if (auto *Sec = createMipsAbiFlagsSection<ELFT>())
       Add(Sec);
     if (auto *Sec = MipsOptionsSection<ELFT>::create())
       Add(Sec);
     if (auto *Sec = MipsReginfoSection<ELFT>::create())
       Add(Sec);
   }
 
   if (Config->HasDynSymTab) {