[ELF][MIPS] Convert .reginfo and .MIPS.options sections to synthetic input sections

[atanasyan]

Summary

Previously, we have both input and output sections for .reginfo and .MIPS.options. Now for each such sections we have one synthetic input sections: MipsReginfoSection and MipsOptionsSection respectively.

Both sections are handled as regular sections until the control reaches Writer. Writer then aggregates all sections whose type is SHT_MIPS_REGINFO or SHT_MIPS_OPTIONS to create a single synthesized input section. In that moment Writer also save GP0 value to the MipsGp0 field of the corresponding ObjectFile. This value required for R_MIPS_GPREL16 and R_MIPS_GPREL32 relocations calculation.

This patch supersedes D26327.

[ruiu]

LGTM. Thanks!

ELF/InputSection.h

42

I expect MipsAbiFlags will be converted in future, correct?

ELF/InputFiles.h

SymbolBody &getRelocTargetSym(const RelT &Rel) const {
     uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);
     return getSymbolBody(SymIndex);
   }
 
   // Returns source line information for a given offset.
   // If no information is available, returns "".
   std::string getLineInfo(InputSectionBase<ELFT> *S, uintX_t Offset);
 
-  // Get MIPS GP0 value defined by this file. This value represents the gp value
+  // MIPS GP0 value defined by this file. This value represents the gp value
   // used to create the relocatable object and required to support
   // R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations.
-  uint32_t getMipsGp0() const;
+  uint32_t MipsGp0 = 0;
 
   // The number is the offset in the string table. It will be used as the
   // st_name of the symbol.
   std::vector<std::pair<const DefinedRegular<ELFT> *, unsigned>> KeptLocalSyms;
 
   // Name of source file obtained from STT_FILE symbol value,
   // or empty string if there is no such symbol in object file
   // symbol table.
private:
   SymbolBody *createSymbolBody(const Elf_Sym *Sym);
 
   // List of all sections defined by this file.
   std::vector<InputSectionBase<ELFT> *> Sections;
 
   // List of all symbols referenced or defined by this file.
   std::vector<SymbolBody *> SymbolBodies;
 
-  // MIPS .reginfo section defined by this file.
-  std::unique_ptr<MipsReginfoInputSection<ELFT>> MipsReginfo;
-  // MIPS .MIPS.options section defined by this file.
-  std::unique_ptr<MipsOptionsInputSection<ELFT>> MipsOptions;
   // MIPS .MIPS.abiflags section defined by this file.
   std::unique_ptr<MipsAbiFlagsInputSection<ELFT>> MipsAbiFlags;
 
   // Debugging information to retrieve source file and line for error
   // reporting. Linker may find reasonable number of errors in a
   // single object file, so we cache debugging information in order to
   // parse it only once for each object file we link.
   std::unique_ptr<llvm::DWARFDebugLine> DwarfLine;

ELF/InputFiles.cpp

 
 template <class ELFT>
 ArrayRef<SymbolBody *> elf::ObjectFile<ELFT>::getSymbols() {
   if (this->SymbolBodies.empty())
     return this->SymbolBodies;
   return makeArrayRef(this->SymbolBodies).slice(1);
 }
 
-template <class ELFT> uint32_t elf::ObjectFile<ELFT>::getMipsGp0() const {
-  if (ELFT::Is64Bits && MipsOptions && MipsOptions->Reginfo)
-    return MipsOptions->Reginfo->ri_gp_value;
-  if (!ELFT::Is64Bits && MipsReginfo && MipsReginfo->Reginfo)
-    return MipsReginfo->Reginfo->ri_gp_value;
-  return 0;
-}
-
 template <class ELFT>
 void elf::ObjectFile<ELFT>::parse(DenseSet<CachedHashStringRef> &ComdatGroups) {
   // Read section and symbol tables.
   initializeSections(ComdatGroups);
   initializeSymbols();
 }
 
 // Sections with SHT_GROUP and comdat bits define comdat section groups.
elf::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec,
   StringRef Name =
       check(this->getObj().getSectionName(&Sec, SectionStringTable));
 
   switch (Sec.sh_type) {
   case SHT_ARM_ATTRIBUTES:
     // FIXME: ARM meta-data section. At present attributes are ignored,
     // they can be used to reason about object compatibility.
     return &InputSection<ELFT>::Discarded;
-  case SHT_MIPS_REGINFO:
-    if (MipsReginfo)
-      fatal(getFilename(this) +
-            ": multiple SHT_MIPS_REGINFO sections are not allowed");
-    MipsReginfo.reset(new MipsReginfoInputSection<ELFT>(this, &Sec, Name));
-    return MipsReginfo.get();
-  case SHT_MIPS_OPTIONS:
-    if (MipsOptions)
-      fatal(getFilename(this) +
-            ": multiple SHT_MIPS_OPTIONS sections are not allowed");
-    MipsOptions.reset(new MipsOptionsInputSection<ELFT>(this, &Sec, Name));
-    return MipsOptions.get();
   case SHT_MIPS_ABIFLAGS:
     if (MipsAbiFlags)
       fatal(getFilename(this) +
             ": multiple SHT_MIPS_ABIFLAGS sections are not allowed");
     MipsAbiFlags.reset(new MipsAbiFlagsInputSection<ELFT>(this, &Sec, Name));
     return MipsAbiFlags.get();
   case SHT_RELA:
   case SHT_REL: {

ELF/InputSection.h

 // We need non-template input section class to store symbol layout
 // in linker script parser structures, where we do not have ELFT
 // template parameter. For each scripted output section symbol we
 // store pointer to preceding InputSectionData object or nullptr,
 // if symbol should be placed at the very beginning of the output
 // section
 class InputSectionData {
 public:
-  enum Kind { Regular, EHFrame, Merge, MipsReginfo, MipsOptions, MipsAbiFlags };
+  enum Kind { Regular, EHFrame, Merge, MipsAbiFlags };
 
   // The garbage collector sets sections' Live bits.
   // If GC is disabled, all sections are considered live by default.
   InputSectionData(Kind SectionKind, StringRef Name, ArrayRef<uint8_t> Data,
                    bool Compressed, bool Live)
       : SectionKind(SectionKind), Live(Live), Compressed(Compressed),
         Name(Name), Data(Data) {}
 
private:
   void replace(InputSection<ELFT> *Other);
 
   // Used by ICF.
   uint64_t GroupId = 0;
 
   llvm::TinyPtrVector<const Thunk<ELFT> *> Thunks;
 };
 
-// MIPS .reginfo section provides information on the registers used by the code
-// in the object file. Linker should collect this information and write a single
-// .reginfo section in the output file. The output section contains a union of
-// used registers masks taken from input .reginfo sections and final value
-// of the `_gp` symbol.  For details: Chapter 4 / "Register Information" at
-// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
-template <class ELFT>
-class MipsReginfoInputSection : public InputSectionBase<ELFT> {
-  typedef typename ELFT::Shdr Elf_Shdr;
-
-public:
-  MipsReginfoInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Hdr,
-                          StringRef Name);
-  static bool classof(const InputSectionData *S);
-
-  const llvm::object::Elf_Mips_RegInfo<ELFT> *Reginfo = nullptr;
-};
-
-template <class ELFT>
-class MipsOptionsInputSection : public InputSectionBase<ELFT> {
-  typedef typename ELFT::Shdr Elf_Shdr;
-
-public:
-  MipsOptionsInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Hdr,
-                          StringRef Name);
-  static bool classof(const InputSectionData *S);
-
-  const llvm::object::Elf_Mips_RegInfo<ELFT> *Reginfo = nullptr;
-};
-
 template <class ELFT>
 class MipsAbiFlagsInputSection : public InputSectionBase<ELFT> {
   typedef typename ELFT::Shdr Elf_Shdr;
 
 public:
   MipsAbiFlagsInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Hdr,
                            StringRef Name);
   static bool classof(const InputSectionData *S);
 
   const llvm::object::Elf_Mips_ABIFlags<ELFT> *Flags = nullptr;
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/InputSection.cpp

case Regular:
     return cast<InputSection<ELFT>>(this)->OutSecOff + Offset;
   case EHFrame:
     // The file crtbeginT.o has relocations pointing to the start of an empty
     // .eh_frame that is known to be the first in the link. It does that to
     // identify the start of the output .eh_frame.
     return Offset;
   case Merge:
     return cast<MergeInputSection<ELFT>>(this)->getOffset(Offset);
-  case MipsReginfo:
-  case MipsOptions:
   case MipsAbiFlags:
-    // MIPS .reginfo, .MIPS.options, and .MIPS.abiflags sections are consumed
+    // .MIPS.abiflags sections is consumed
     // by the linker, and the linker produces a single output section. It is
     // possible that input files contain section symbol points to the
     // corresponding input section. Redirect it to the produced output section.
     if (Offset != 0)
       fatal(getName(this) + ": unsupported reference to the middle of '" +
             Name + "' section");
     return this->OutSec->Addr;
   }
if (Piece.OutputOff == -1) {
       CachedHashStringRef V(S, Hash);
       Piece.OutputOff = OutSec->getOffset(V);
     }
     OffsetMap[Piece.InputOff] = Piece.OutputOff;
   }
 }
 
 template <class ELFT>
-MipsReginfoInputSection<ELFT>::MipsReginfoInputSection(elf::ObjectFile<ELFT> *F,
-                                                       const Elf_Shdr *Hdr,
-                                                       StringRef Name)
-    : InputSectionBase<ELFT>(F, Hdr, Name,
-                             InputSectionBase<ELFT>::MipsReginfo) {
-  ArrayRef<uint8_t> Data = this->Data;
-  // Initialize this->Reginfo.
-  if (Data.size() != sizeof(Elf_Mips_RegInfo<ELFT>)) {
-    error(getName(this) + ": invalid size of .reginfo section");
-    return;
-  }
-  Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Data.data());
-  if (Config->Relocatable && Reginfo->ri_gp_value)
-    error(getName(this) + ": unsupported non-zero ri_gp_value");
-}
-
-template <class ELFT>
-bool MipsReginfoInputSection<ELFT>::classof(const InputSectionData *S) {
-  return S->kind() == InputSectionBase<ELFT>::MipsReginfo;
-}
-
-template <class ELFT>
-MipsOptionsInputSection<ELFT>::MipsOptionsInputSection(elf::ObjectFile<ELFT> *F,
-                                                       const Elf_Shdr *Hdr,
-                                                       StringRef Name)
-    : InputSectionBase<ELFT>(F, Hdr, Name,
-                             InputSectionBase<ELFT>::MipsOptions) {
-  // Find ODK_REGINFO option in the section's content.
-  ArrayRef<uint8_t> D = this->Data;
-  while (!D.empty()) {
-    if (D.size() < sizeof(Elf_Mips_Options<ELFT>)) {
-      error(getName(this) + ": invalid size of .MIPS.options section");
-      break;
-    }
-    auto *O = reinterpret_cast<const Elf_Mips_Options<ELFT> *>(D.data());
-    if (O->kind == ODK_REGINFO) {
-      Reginfo = &O->getRegInfo();
-      if (Config->Relocatable && Reginfo->ri_gp_value)
-        error(getName(this) + ": unsupported non-zero ri_gp_value");
-      break;
-    }
-    if (!O->size)
-      fatal(getName(this) + ": zero option descriptor size");
-    D = D.slice(O->size);
-  }
-}
-
-template <class ELFT>
-bool MipsOptionsInputSection<ELFT>::classof(const InputSectionData *S) {
-  return S->kind() == InputSectionBase<ELFT>::MipsOptions;
-}
-
-template <class ELFT>
 MipsAbiFlagsInputSection<ELFT>::MipsAbiFlagsInputSection(
     elf::ObjectFile<ELFT> *F, const Elf_Shdr *Hdr, StringRef Name)
     : InputSectionBase<ELFT>(F, Hdr, Name,
                              InputSectionBase<ELFT>::MipsAbiFlags) {
   // Initialize this->Flags.
   ArrayRef<uint8_t> Data = this->Data;
   if (Data.size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
     error("invalid size of .MIPS.abiflags section");

 template class elf::EhInputSection<ELF64LE>;
 template class elf::EhInputSection<ELF64BE>;
 
 template class elf::MergeInputSection<ELF32LE>;
 template class elf::MergeInputSection<ELF32BE>;
 template class elf::MergeInputSection<ELF64LE>;
 template class elf::MergeInputSection<ELF64BE>;
 
-template class elf::MipsReginfoInputSection<ELF32LE>;
-template class elf::MipsReginfoInputSection<ELF32BE>;
-template class elf::MipsReginfoInputSection<ELF64LE>;
-template class elf::MipsReginfoInputSection<ELF64BE>;
-
-template class elf::MipsOptionsInputSection<ELF32LE>;
-template class elf::MipsOptionsInputSection<ELF32BE>;
-template class elf::MipsOptionsInputSection<ELF64LE>;
-template class elf::MipsOptionsInputSection<ELF64BE>;
-
 template class elf::MipsAbiFlagsInputSection<ELF32LE>;
 template class elf::MipsAbiFlagsInputSection<ELF32BE>;
 template class elf::MipsAbiFlagsInputSection<ELF64LE>;
 template class elf::MipsAbiFlagsInputSection<ELF64BE>;

ELF/OutputSections.h

 struct EhSectionPiece;
 template <class ELFT> class SymbolTable;
 template <class ELFT> class SymbolTableSection;
 template <class ELFT> class StringTableSection;
 template <class ELFT> class EhInputSection;
 template <class ELFT> class InputSection;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class MergeInputSection;
-template <class ELFT> class MipsReginfoInputSection;
 template <class ELFT> class OutputSection;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class SharedFile;
 template <class ELFT> class SharedSymbol;
 template <class ELFT> class DefinedRegular;
 
 // This represents a section in an output file.
 // Different sub classes represent different types of sections. Some contain
enum Kind {
     Dynamic,
     EHFrame,
     EHFrameHdr,
     GnuHashTable,
     Got,
     GotPlt,
     HashTable,
     Merge,
-    MipsReginfo,
-    MipsOptions,
     MipsAbiFlags,
     Plt,
     Regular,
     Reloc,
     StrTable,
     SymTable,
     VersDef,
     VersNeed,
public:
   static bool classof(const Base *B) { return B->getKind() == Base::Dynamic; }
 
 private:
   void addEntries();
   void Add(Entry E) { Entries.push_back(E); }
 };
 
 template <class ELFT>
-class MipsReginfoOutputSection final : public OutputSectionBase<ELFT> {
-  typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
-  typedef OutputSectionBase<ELFT> Base;
-
-public:
-  MipsReginfoOutputSection();
-  void writeTo(uint8_t *Buf) override;
-  void addSection(InputSectionBase<ELFT> *S) override;
-  typename Base::Kind getKind() const override { return Base::MipsReginfo; }
-  static bool classof(const Base *B) {
-    return B->getKind() == Base::MipsReginfo;
-  }
-
-private:
-  uint32_t GprMask = 0;
-};
-
-template <class ELFT>
-class MipsOptionsOutputSection final : public OutputSectionBase<ELFT> {
-  typedef llvm::object::Elf_Mips_Options<ELFT> Elf_Mips_Options;
-  typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
-  typedef OutputSectionBase<ELFT> Base;
-
-public:
-  MipsOptionsOutputSection();
-  void writeTo(uint8_t *Buf) override;
-  void addSection(InputSectionBase<ELFT> *S) override;
-  typename Base::Kind getKind() const override { return Base::MipsOptions; }
-  static bool classof(const Base *B) {
-    return B->getKind() == Base::MipsOptions;
-  }
-
-private:
-  uint32_t GprMask = 0;
-};
-
-template <class ELFT>
 class MipsAbiFlagsOutputSection final : public OutputSectionBase<ELFT> {
   typedef llvm::object::Elf_Mips_ABIFlags<ELFT> Elf_Mips_ABIFlags;
   typedef OutputSectionBase<ELFT> Base;
 
 public:
   MipsAbiFlagsOutputSection();
   void writeTo(uint8_t *Buf) override;
   void addSection(InputSectionBase<ELFT> *S) override;

ELF/OutputSections.cpp

 
 template <class ELFT>
 OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t Type, uintX_t Flags)
     : OutputSectionBase<ELFT>(Name, Type, Flags) {
   if (Type == SHT_RELA)
     this->Entsize = sizeof(Elf_Rela);
   else if (Type == SHT_REL)
     this->Entsize = sizeof(Elf_Rel);
+  else if (Type == SHT_MIPS_REGINFO)
+    this->Entsize = sizeof(Elf_Mips_RegInfo<ELFT>);
+  else if (Type == SHT_MIPS_OPTIONS)
+    this->Entsize =
+        sizeof(Elf_Mips_Options<ELFT>) + sizeof(Elf_Mips_RegInfo<ELFT>);
 }
 
 template <class ELFT> void OutputSection<ELFT>::finalize() {
   uint32_t Type = this->Type;
   if (this->Flags & SHF_LINK_ORDER) {
     if (!Config->Relocatable) {
       // SHF_LINK_ORDER only has meaning in relocatable objects
       this->Flags &= ~SHF_LINK_ORDER;
template <class ELFT> void VersionNeedSection<ELFT>::finalize() {
   this->Info = Needed.size();
   unsigned Size = Needed.size() * sizeof(Elf_Verneed);
   for (std::pair<SharedFile<ELFT> *, size_t> &P : Needed)
     Size += P.first->VerdefMap.size() * sizeof(Elf_Vernaux);
   this->Size = Size;
 }
 
 template <class ELFT>
-MipsReginfoOutputSection<ELFT>::MipsReginfoOutputSection()
-    : OutputSectionBase<ELFT>(".reginfo", SHT_MIPS_REGINFO, SHF_ALLOC) {
-  this->Addralign = 4;
-  this->Entsize = sizeof(Elf_Mips_RegInfo);
-  this->Size = sizeof(Elf_Mips_RegInfo);
-}
-
-template <class ELFT>
-void MipsReginfoOutputSection<ELFT>::writeTo(uint8_t *Buf) {
-  auto *R = reinterpret_cast<Elf_Mips_RegInfo *>(Buf);
-  if (Config->Relocatable)
-    R->ri_gp_value = 0;
-  else
-    R->ri_gp_value = Out<ELFT>::Got->Addr + MipsGPOffset;
-  R->ri_gprmask = GprMask;
-}
-
-template <class ELFT>
-void MipsReginfoOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
-  // Copy input object file's .reginfo gprmask to output.
-  auto *S = cast<MipsReginfoInputSection<ELFT>>(C);
-  GprMask |= S->Reginfo->ri_gprmask;
-  S->OutSec = this;
-}
-
-template <class ELFT>
-MipsOptionsOutputSection<ELFT>::MipsOptionsOutputSection()
-    : OutputSectionBase<ELFT>(".MIPS.options", SHT_MIPS_OPTIONS,
-                              SHF_ALLOC | SHF_MIPS_NOSTRIP) {
-  this->Addralign = 8;
-  this->Entsize = 1;
-  this->Size = sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);
-}
-
-template <class ELFT>
-void MipsOptionsOutputSection<ELFT>::writeTo(uint8_t *Buf) {
-  auto *Opt = reinterpret_cast<Elf_Mips_Options *>(Buf);
-  Opt->kind = ODK_REGINFO;
-  Opt->size = this->Size;
-  Opt->section = 0;
-  Opt->info = 0;
-  auto *Reg = reinterpret_cast<Elf_Mips_RegInfo *>(Buf + sizeof(*Opt));
-  if (Config->Relocatable)
-    Reg->ri_gp_value = 0;
-  else
-    Reg->ri_gp_value = Out<ELFT>::Got->Addr + MipsGPOffset;
-  Reg->ri_gprmask = GprMask;
-}
-
-template <class ELFT>
-void MipsOptionsOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
-  auto *S = cast<MipsOptionsInputSection<ELFT>>(C);
-  if (S->Reginfo)
-    GprMask |= S->Reginfo->ri_gprmask;
-  S->OutSec = this;
-}
-
-template <class ELFT>
 MipsAbiFlagsOutputSection<ELFT>::MipsAbiFlagsOutputSection()
     : OutputSectionBase<ELFT>(".MIPS.abiflags", SHT_MIPS_ABIFLAGS, SHF_ALLOC) {
   this->Addralign = 8;
   this->Entsize = sizeof(Elf_Mips_ABIFlags);
   this->Size = sizeof(Elf_Mips_ABIFlags);
   memset(&Flags, 0, sizeof(Flags));
 }
 
OutputSectionFactory<ELFT>::create(const SectionKey<ELFT::Is64Bits> &Key,
   case InputSectionBase<ELFT>::Regular:
     Sec = make<OutputSection<ELFT>>(Key.Name, Type, Flags);
     break;
   case InputSectionBase<ELFT>::EHFrame:
     return {Out<ELFT>::EhFrame, false};
   case InputSectionBase<ELFT>::Merge:
     Sec = make<MergeOutputSection<ELFT>>(Key.Name, Type, Flags, Key.Alignment);
     break;
-  case InputSectionBase<ELFT>::MipsReginfo:
-    Sec = make<MipsReginfoOutputSection<ELFT>>();
-    break;
-  case InputSectionBase<ELFT>::MipsOptions:
-    Sec = make<MipsOptionsOutputSection<ELFT>>();
-    break;
   case InputSectionBase<ELFT>::MipsAbiFlags:
     Sec = make<MipsAbiFlagsOutputSection<ELFT>>();
     break;
   }
   return {Sec, true};
 }
 
 template <bool Is64Bits>

 template class OutputSection<ELF64LE>;
 template class OutputSection<ELF64BE>;
 
 template class EhOutputSection<ELF32LE>;
 template class EhOutputSection<ELF32BE>;
 template class EhOutputSection<ELF64LE>;
 template class EhOutputSection<ELF64BE>;
 
-template class MipsReginfoOutputSection<ELF32LE>;
-template class MipsReginfoOutputSection<ELF32BE>;
-template class MipsReginfoOutputSection<ELF64LE>;
-template class MipsReginfoOutputSection<ELF64BE>;
-
-template class MipsOptionsOutputSection<ELF32LE>;
-template class MipsOptionsOutputSection<ELF32BE>;
-template class MipsOptionsOutputSection<ELF64LE>;
-template class MipsOptionsOutputSection<ELF64BE>;
-
 template class MipsAbiFlagsOutputSection<ELF32LE>;
 template class MipsAbiFlagsOutputSection<ELF32BE>;
 template class MipsAbiFlagsOutputSection<ELF64LE>;
 template class MipsAbiFlagsOutputSection<ELF64BE>;
 
 template class MergeOutputSection<ELF32LE>;
 template class MergeOutputSection<ELF32BE>;
 template class MergeOutputSection<ELF64LE>;

ELF/Relocations.cpp

if (Type == R_MIPS_LO16 && Expr == R_PC)
       // symbol. In that case we should use the following formula for
       // calculation "AHL + GP - P + 4". Let's add 4 right here.
       // For details see p. 4-19 at
       // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
       Addend += 4;
     if (Expr == R_GOTREL) {
       Addend -= MipsGPOffset;
       if (Body.isLocal())
-        Addend += File.getMipsGp0();
+        Addend += File.MipsGp0;
     }
   }
   if (Config->Pic && Config->EMachine == EM_PPC64 && Type == R_PPC64_TOC)
     Addend += getPPC64TocBase();
   return Addend;
 }
 
 // Find symbol that encloses given offset. Used for error reporting.

ELF/SyntheticSections.h

 #ifndef LLD_ELF_SYNTHETIC_SECTION_H
 #define LLD_ELF_SYNTHETIC_SECTION_H
 
 #include "InputSection.h"
 
 namespace lld {
 namespace elf {
 
+// .MIPS.options section.
+template <class ELFT>
+class MipsOptionsSection final : public InputSection<ELFT> {
+  typedef llvm::object::Elf_Mips_Options<ELFT> Elf_Mips_Options;
+  typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
+
+public:
+  MipsOptionsSection();
+  void finalize();
+
+private:
+  std::vector<uint8_t> Buf;
+
+  Elf_Mips_Options *getOptions() {
+    return reinterpret_cast<Elf_Mips_Options *>(Buf.data());
+  }
+};
+
+// MIPS .reginfo section.
+template <class ELFT>
+class MipsReginfoSection final : public InputSection<ELFT> {
+  typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
+
+public:
+  MipsReginfoSection();
+  void finalize();
+
+private:
+  Elf_Mips_RegInfo Reginfo = {};
+};
+
 // .note.gnu.build-id section.
 template <class ELFT> class BuildIdSection : public InputSection<ELFT> {
 public:
   virtual void writeBuildId(llvm::MutableArrayRef<uint8_t> Buf) = 0;
   virtual ~BuildIdSection() = default;
 
   uint8_t *getOutputLoc(uint8_t *Start) const;
 

 template <class ELFT> InputSection<ELFT> *createCommonSection();
 template <class ELFT> InputSection<ELFT> *createInterpSection();
 
 // Linker generated sections which can be used as inputs.
 template <class ELFT> struct In {
   static BuildIdSection<ELFT> *BuildId;
   static InputSection<ELFT> *Common;
   static InputSection<ELFT> *Interp;
+  static MipsOptionsSection<ELFT> *MipsOptions;
+  static MipsReginfoSection<ELFT> *MipsReginfo;
 };
 
 template <class ELFT> BuildIdSection<ELFT> *In<ELFT>::BuildId;
 template <class ELFT> InputSection<ELFT> *In<ELFT>::Common;
 template <class ELFT> InputSection<ELFT> *In<ELFT>::Interp;
+template <class ELFT> MipsOptionsSection<ELFT> *In<ELFT>::MipsOptions;
+template <class ELFT> MipsReginfoSection<ELFT> *In<ELFT>::MipsReginfo;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/SyntheticSections.cpp

 #include "SyntheticSections.h"
 #include "Config.h"
 #include "Error.h"
 #include "InputFiles.h"
 #include "Memory.h"
 #include "OutputSections.h"
 #include "Strings.h"
 #include "SymbolTable.h"
+#include "Target.h"
 
 #include "lld/Core/Parallel.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/xxhash.h"
 
for (DefinedCommon *Sym : Syms) {
     Sym->Offset = Size;
     Size += Sym->Size;
   }
   Ret->Alignment = Alignment;
   Ret->Data = makeArrayRef<uint8_t>(nullptr, Size);
   return Ret;
 }
 
+// Iterate over sections of the specified type. For each section call
+// provided function. After that "kill" the section by turning off
+// "Live" flag, so that they won't be included in the final output.
+template <class ELFT>
+static void iterateSectionContents(
+    uint32_t Type,
+    std::function<void(ObjectFile<ELFT> *, ArrayRef<uint8_t>)> F) {
+  for (InputSectionBase<ELFT> *Sec : Symtab<ELFT>::X->Sections) {
+    if (Sec && Sec->Live && Sec->Type == Type) {
+      Sec->Live = false;
+      F(Sec->getFile(), Sec->Data);
+    }
+  }
+}
+
+// .MIPS.options section.
+template <class ELFT>
+MipsOptionsSection<ELFT>::MipsOptionsSection()
+    : InputSection<ELFT>(SHF_ALLOC, SHT_MIPS_OPTIONS, 8, ArrayRef<uint8_t>(),
+                         ".MIPS.options") {
+  Buf.resize(sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo));
+  getOptions()->kind = ODK_REGINFO;
+  getOptions()->size = Buf.size();
+  auto Func = [this](ObjectFile<ELFT> *F, ArrayRef<uint8_t> D) {
+    while (!D.empty()) {
+      if (D.size() < sizeof(Elf_Mips_Options)) {
+        error(getFilename(F) + ": invalid size of .MIPS.options section");
+        break;
+      }
+      auto *O = reinterpret_cast<const Elf_Mips_Options *>(D.data());
+      if (O->kind == ODK_REGINFO) {
+        if (Config->Relocatable && O->getRegInfo().ri_gp_value)
+          error(getFilename(F) + ": unsupported non-zero ri_gp_value");
+        getOptions()->getRegInfo().ri_gprmask |= O->getRegInfo().ri_gprmask;
+        F->MipsGp0 = O->getRegInfo().ri_gp_value;
+        break;
+      }
+      if (!O->size)
+        fatal(getFilename(F) + ": zero option descriptor size");
+      D = D.slice(O->size);
+    }
+  };
+  iterateSectionContents<ELFT>(SHT_MIPS_OPTIONS, Func);
+
+  this->Data = ArrayRef<uint8_t>(Buf);
+  // Section should be alive for N64 ABI only.
+  this->Live = ELFT::Is64Bits;
+}
+
+template <class ELFT> void MipsOptionsSection<ELFT>::finalize() {
+  if (!Config->Relocatable)
+    getOptions()->getRegInfo().ri_gp_value =
+        Out<ELFT>::Got->Addr + MipsGPOffset;
+}
+
+// MIPS .reginfo section.
+template <class ELFT>
+MipsReginfoSection<ELFT>::MipsReginfoSection()
+    : InputSection<ELFT>(SHF_ALLOC, SHT_MIPS_REGINFO, 4, ArrayRef<uint8_t>(),
+                         ".reginfo") {
+  auto Func = [this](ObjectFile<ELFT> *F, ArrayRef<uint8_t> D) {
+    if (D.size() != sizeof(Elf_Mips_RegInfo)) {
+      error(getFilename(F) + ": invalid size of .reginfo section");
+      return;
+    }
+    auto *R = reinterpret_cast<const Elf_Mips_RegInfo *>(D.data());
+    if (Config->Relocatable && R->ri_gp_value)
+      error(getFilename(F) + ": unsupported non-zero ri_gp_value");
+    Reginfo.ri_gprmask |= R->ri_gprmask;
+    F->MipsGp0 = R->ri_gp_value;
+  };
+  iterateSectionContents<ELFT>(SHT_MIPS_REGINFO, Func);
+
+  this->Data = ArrayRef<uint8_t>((const uint8_t *)&Reginfo, sizeof(Reginfo));
+  // Section should be alive for O32 and N32 ABIs only.
+  this->Live = !ELFT::Is64Bits;
+}
+
+template <class ELFT> void MipsReginfoSection<ELFT>::finalize() {
+  if (!Config->Relocatable)
+    Reginfo.ri_gp_value = Out<ELFT>::Got->Addr + MipsGPOffset;
+}
+
 static ArrayRef<uint8_t> createInterp() {
   // StringSaver guarantees that the returned string ends with '\0'.
   StringRef S = Saver.save(Config->DynamicLinker);
   return {(const uint8_t *)S.data(), S.size() + 1};
 }
 
 template <class ELFT> InputSection<ELFT> *elf::createInterpSection() {
   auto *Ret = make<InputSection<ELFT>>(SHF_ALLOC, SHT_PROGBITS, 1,

 template InputSection<ELF64LE> *elf::createCommonSection();
 template InputSection<ELF64BE> *elf::createCommonSection();
 
 template InputSection<ELF32LE> *elf::createInterpSection();
 template InputSection<ELF32BE> *elf::createInterpSection();
 template InputSection<ELF64LE> *elf::createInterpSection();
 template InputSection<ELF64BE> *elf::createInterpSection();
 
+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>;
+template class elf::MipsReginfoSection<ELF64LE>;
+template class elf::MipsReginfoSection<ELF64BE>;
+
 template class elf::BuildIdSection<ELF32LE>;
 template class elf::BuildIdSection<ELF32BE>;
 template class elf::BuildIdSection<ELF64LE>;
 template class elf::BuildIdSection<ELF64BE>;
 
 template class elf::BuildIdFastHash<ELF32LE>;
 template class elf::BuildIdFastHash<ELF32BE>;
 template class elf::BuildIdFastHash<ELF64LE>;

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::createSyntheticSections() {
   if (In<ELFT>::BuildId)
     Symtab<ELFT>::X->Sections.push_back(In<ELFT>::BuildId);
 
   InputSection<ELFT> *Common = createCommonSection<ELFT>();
   if (!Common->Data.empty()) {
     In<ELFT>::Common = Common;
     Symtab<ELFT>::X->Sections.push_back(Common);
   }
+
+  if (Config->EMachine == EM_MIPS) {
+    // .MIPS.options
+    auto *OptSec = make<MipsOptionsSection<ELFT>>();
+    if (OptSec->Live) {
+      In<ELFT>::MipsOptions = OptSec;
+      Symtab<ELFT>::X->Sections.push_back(OptSec);
+    }
+    // MIPS .reginfo
+    auto *RegSec = make<MipsReginfoSection<ELFT>>();
+    if (RegSec->Live) {
+      In<ELFT>::MipsReginfo = RegSec;
+      Symtab<ELFT>::X->Sections.push_back(RegSec);
+    }
+  }
 }
 
 template <class ELFT>
 static bool shouldKeepInSymtab(InputSectionBase<ELFT> *Sec, StringRef SymName,
                                const SymbolBody &B) {
   if (B.isFile())
     return false;
 
static void sortARMExidx(uint8_t *Buf, uint64_t OutSecVA, uint64_t Size) {
   for (uint64_t Off = 0; Off < Size; Off += 8)
     ARMExidxEntryAbsToPrel(Buf + Off, OutSecVA + Off);
 }
 
 // Write section contents to a mmap'ed file.
 template <class ELFT> void Writer<ELFT>::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
 
+  // Finalize MIPS .reginfo and .MIPS.options sections
+  // because they contain offsets to .got and _gp.
+  if (In<ELFT>::MipsReginfo)
+    In<ELFT>::MipsReginfo->finalize();
+  if (In<ELFT>::MipsOptions)
+    In<ELFT>::MipsOptions->finalize();
+
   // PPC64 needs to process relocations in the .opd section
   // before processing relocations in code-containing sections.
   Out<ELFT>::Opd = findSection(".opd");
   if (Out<ELFT>::Opd) {
     Out<ELFT>::OpdBuf = Buf + Out<ELFT>::Opd->Offset;
     Out<ELFT>::Opd->writeTo(Buf + Out<ELFT>::Opd->Offset);
   }
 

test/ELF/basic-mips.s

 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 0
 # CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 1
-# CHECK-NEXT:     Name: .reginfo
-# CHECK-NEXT:     Type: SHT_MIPS_REGINFO (0x70000006)
+# CHECK-NEXT:     Name: .MIPS.abiflags
+# CHECK-NEXT:     Type: SHT_MIPS_ABIFLAGS (0x7000002A)
 # CHECK-NEXT:     Flags [ (0x2)
 # CHECK-NEXT:       SHF_ALLOC (0x2)
 # CHECK-NEXT:     ]
-# CHECK-NEXT:     Address: 0x100F4
-# CHECK-NEXT:     Offset: 0xF4
+# CHECK-NEXT:     Address: 0x100F8
+# CHECK-NEXT:     Offset: 0xF8
 # CHECK-NEXT:     Size: 24
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
-# CHECK-NEXT:     AddressAlignment: 4
+# CHECK-NEXT:     AddressAlignment: 8
 # CHECK-NEXT:     EntrySize: 24
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 2
-# CHECK-NEXT:     Name: .MIPS.abiflags
-# CHECK-NEXT:     Type: SHT_MIPS_ABIFLAGS (0x7000002A)
+# CHECK-NEXT:     Name: .reginfo
+# CHECK-NEXT:     Type: SHT_MIPS_REGINFO (0x70000006)
 # CHECK-NEXT:     Flags [ (0x2)
 # CHECK-NEXT:       SHF_ALLOC (0x2)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x10110
 # CHECK-NEXT:     Offset: 0x110
 # CHECK-NEXT:     Size: 24
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
-# CHECK-NEXT:     AddressAlignment: 8
+# CHECK-NEXT:     AddressAlignment: 4
 # CHECK-NEXT:     EntrySize: 24
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 3
 # CHECK-NEXT:     Name: .text
 # CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
 # CHECK-NEXT:     Flags [ (0x6)
 # CHECK-NEXT:       SHF_ALLOC (0x2)

test/ELF/invalid/mips-invalid-options-descriptor.s

 ## mips-invalid-options-descriptor.elf has option descriptor in
 ## .MIPS.options with size of zero.
 # RUN: not ld.lld %p/Inputs/mips-invalid-options-descriptor.elf -o %t2 2>&1 | \
 # RUN:   FileCheck %s
-# CHECK: zero option descriptor size
+# CHECK: error: Invalid data was encountered while parsing the file

test/ELF/invalid/mips-multiple-options.test

-# RUN: yaml2obj %s -o %t
-# RUN: not ld.lld %t -o %tout 2>&1 | FileCheck %s
-
---- !ELF
-FileHeader:
-  Class:    ELFCLASS32
-  Data:     ELFDATA2LSB
-  Type:     ET_REL
-  Machine:  EM_MIPS
-  Flags:    [EF_MIPS_PIC, EF_MIPS_CPIC, EF_MIPS_ABI_O32, EF_MIPS_ARCH_32]
-
-Sections:
-  - Name:          .o1
-    Type:          SHT_MIPS_OPTIONS
-    Flags:         [ SHF_ALLOC, SHF_EXECINSTR ]
-    AddressAlign:  16
-    Content:       "010000000000000000000000"
-
-  - Name:          .o2
-    Type:          SHT_MIPS_OPTIONS
-    Flags:         [ SHF_ALLOC, SHF_EXECINSTR ]
-    AddressAlign:  16
-    Content:       "010000000000000000000000"
-
-# CHECK: multiple SHT_MIPS_OPTIONS sections are not allowed

test/ELF/invalid/mips-multiple-reginfo.test

-# RUN: yaml2obj %s -o %t
-# RUN: not ld.lld %t -o %tout 2>&1 | FileCheck %s
-
---- !ELF
-FileHeader:
-  Class:    ELFCLASS32
-  Data:     ELFDATA2LSB
-  Type:     ET_REL
-  Machine:  EM_MIPS
-  Flags:    [EF_MIPS_PIC, EF_MIPS_CPIC, EF_MIPS_ABI_O32, EF_MIPS_ARCH_32]
-
-Sections:
-  - Name:          .foo1
-    Type:          SHT_MIPS_REGINFO
-    Flags:         [ SHF_ALLOC, SHF_EXECINSTR ]
-    AddressAlign:  16
-    Content:       "000000000000000000000000000000000000000000000000"
-
-  - Name:          .foo2
-    Type:          SHT_MIPS_REGINFO
-    Flags:         [ SHF_ALLOC, SHF_EXECINSTR ]
-    AddressAlign:  16
-    Content:       "000000000000000000000000000000000000000000000000"
-
-# CHECK: multiple SHT_MIPS_REGINFO sections are not allowed

test/ELF/mips-gprel32-relocs-gp0.s

 #             ^ 0x10004 + 0x7ff0 - 0x27ff0
 #                      ^ 0x10008 + 0x7ff0 - 0x27ff0
 
 # DUMP: SYMBOL TABLE:
 # DUMP: 00010008         .text          00000000 bar
 # DUMP: 00010004         .text          00000000 foo
 # DUMP: 00027ff0         .got           00000000 .hidden _gp
 
-# ERR: {{.*}}mips-gp0-non-zero.o(.reginfo): unsupported non-zero ri_gp_value
+# ERR: error: {{.*}}mips-gp0-non-zero.o: unsupported non-zero ri_gp_value
 
   .text
   .global  __start
 __start:
   lw      $t0,%call16(__start)($gp)
 foo:
   nop
 bar:
   nop
 
   .section .rodata, "a"
 v:
   .gpword foo
   .gpword bar

test/ELF/mips-n32-rels.s

 #                                                  ^-- %hi(0x17ff0)
 # CHECK:      loc:
 # CHECK-NEXT:    20004:  67 9c 7f f0  daddiu  $gp, $gp, 32752
 #                                                       ^-- 0x20000 - 0x37ff0
 #                                                       ^-- 0 - 0xfffe8010
 #                                                       ^-- %lo(0x17ff0)
 
 # CHECK:      Contents of section .rodata:
-# CHECK-NEXT:  10128 00020004
+# CHECK-NEXT:  10110 00020004
 #                    ^-- loc
 
 # CHECK: 00020004      .text   00000000 loc
 # CHECK: 00037ff0      .got    00000000 .hidden _gp
 # CHECK: 00020000 g  F .text   00000000 __start
 
 # ELF:      Format: ELF32-mips
 # ELF-NEXT: Arch: mips

test/ELF/mips-options-r.test

 # Check that if input file contains .MIPS.options section and symbol
 # points to the section and the linker generates a relocatable output,
-# LLD does not crash and write section symbols point to the output
-# .MIPS.options section.
+# LLD does not crash.
 #
 # PR 27878
 #
 # Input object file created using the following script:
 # % cat t.s
 #   .text
 #   nop
 # % as -mabi=64 -mips64r2 t.s
 
 # RUN: ld.lld -r %p/Inputs/mips-options.o -o %t.o
-# RUN: llvm-readobj -t %t.o | FileCheck %s
+# RUN: llvm-readobj -s %t.o | FileCheck %s
 
 # REQUIRES: mips
 
-# CHECK: Section: .MIPS.options
+# CHECK: Name: .MIPS.options