Convert MIPS .reginfo section to synthetic input section.

[ruiu]

Summary

Previously, we have an input section and an output section
for MIPS .reginfo. This patch reorganizes the code structure.
Now we have only one class for .reginfo, which is MipsReginfoSection.
MipsReginfoSection is a synthetic input section.

.reginfo sections are handled as regular sections until the
control reaches Writer. Writer then aggregates all sections whose
type is SHT_MIPS_REGINFO to create a single synthesized input section.
The synthesized section is then processed normally as if it came
from an input file.

[atanasyan]

ELF/InputFiles.cpp

166

When we calculate R_MIPS_GPREL16/32 relocations we need to know GP0 value stored in the .MIPS.options or .reginfo sections (take a look at the computeAddend routine). Each file might have it's own value. Usually GP0 is equal to zero but it is not always true. After this change getMipsGp0() does not take in account GP0 value stored in the .reginfo section and the mips-gprel32-relocs-gp0.s test case starts to fail.

To solve the problem we can add MipsGp0 field to the ObjectFile class and retrieve and save GP0 value to this field in the say ObjectFile::initializeSections function.

If you want I can work on that and convert MipsOptionsInputSection to synthetic input section too. It looks like it is better to convert .reginfo and .MIPS.options sections in a single patch.

ELF/SyntheticSections.cpp

110

• s/supported/unsupported/
• it is not very important, but it would be nice to continue to show a file's name in this error message. maybe add an argument to the getSectionContents routine to be able to pass a validate function.

[atanasyan]

Rui, could you abandon/close this revision because it's superseded by the D26444?

ELF/InputFiles.h

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

ELF/InputFiles.cpp

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.
   ArrayRef<Elf_Shdr> ObjSections = check(this->getObj().sections());
   initializeSections(ComdatGroups, ObjSections);
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)

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, MipsOptions, 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) {}
 

 
 // 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);
 

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.options, and .MIPS.abiflags sections are 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->getVA();
   }
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()) {

 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,
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;

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->Header.sh_entsize = sizeof(Elf_Rela);
   else if (Type == SHT_REL)
     this->Header.sh_entsize = sizeof(Elf_Rel);
+  else if (Type == SHT_MIPS_REGINFO)
+    this->Header.sh_entsize = sizeof(llvm::object::Elf_Mips_RegInfo<ELFT>);
 }
 
 template <class ELFT> void OutputSection<ELFT>::finalize() {
   uint32_t Type = this->Header.sh_type;
   if (this->Header.sh_flags & SHF_LINK_ORDER) {
     if (!Config->Relocatable) {
       // SHF_LINK_ORDER only has meaning in relocatable objects
       this->Header.sh_flags &= ~SHF_LINK_ORDER;
template <class ELFT> void VersionNeedSection<ELFT>::finalize() {
   this->Header.sh_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->Header.sh_size = Size;
 }
 
 template <class ELFT>
-MipsReginfoOutputSection<ELFT>::MipsReginfoOutputSection()
-    : OutputSectionBase<ELFT>(".reginfo", SHT_MIPS_REGINFO, SHF_ALLOC) {
-  this->Header.sh_addralign = 4;
-  this->Header.sh_entsize = sizeof(Elf_Mips_RegInfo);
-  this->Header.sh_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->getVA() + 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->Header.sh_addralign = 8;
   this->Header.sh_entsize = 1;
   this->Header.sh_size = sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);
 }
 
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 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>;

ELF/SyntheticSections.h

 };
 
 // .interp section.
 template <class ELFT> class InterpSection final : public InputSection<ELFT> {
 public:
   InterpSection();
 };
 
+// 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;
 
public:
   BuildIdHexstring();
   void writeBuildId(llvm::MutableArrayRef<uint8_t>) override;
 };
 
 // Linker generated sections which can be used as inputs.
 template <class ELFT> struct In {
   static BuildIdSection<ELFT> *BuildId;
   static CommonSection<ELFT> *Common;
+  static MipsReginfoSection<ELFT> *MipsReginfo;
   static InterpSection<ELFT> *Interp;
 };
 
 template <class ELFT> BuildIdSection<ELFT> *In<ELFT>::BuildId;
 template <class ELFT> CommonSection<ELFT> *In<ELFT>::Common;
 template <class ELFT> InterpSection<ELFT> *In<ELFT>::Interp;
+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 "llvm/Support/Endian.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/xxhash.h"
 
 using namespace llvm;
for (DefinedCommon *Sym : Syms) {
     // Compute symbol offset relative to beginning of input section.
     Sym->Offset = Size;
     Size += Sym->Size;
   }
   this->Alignment = Alignment;
   this->Data = makeArrayRef<uint8_t>(nullptr, Size);
 }
 
+// Returns a vector of section contents that matches a given section type.
+// Returned sections are "killed" by turning off "Live" flag, so that they
+// won't be included in the final output.
+template <class ELFT, class T>
+static std::vector<const T *> getSectionContents(uint32_t Type) {
+  std::vector<const T *> V;
+  for (InputSectionBase<ELFT> *Sec : Symtab<ELFT>::X->Sections) {
+    if (!Sec || !Sec->Live || Sec->Type != Type)
+      continue;
+    if (Sec->Data.size() != sizeof(T)) {
+      error(getFilename(Sec->getFile()) + ": " + Sec->Name + ": invalid size");
+      return V;
+    }
+    Sec->Live = false;
+    V.push_back(reinterpret_cast<const T *>(Sec->Data.data()));
+  }
+  return V;
+}
+
+// MIPS .reginfo section.
+template <class ELFT>
+MipsReginfoSection<ELFT>::MipsReginfoSection()
+    : InputSection<ELFT>(SHF_ALLOC, SHT_MIPS_REGINFO, 4, ArrayRef<uint8_t>(),
+                         ".reginfo") {
+  std::vector<const Elf_Mips_RegInfo *> Inputs =
+      getSectionContents<ELFT, Elf_Mips_RegInfo>(SHT_MIPS_REGINFO);
+  if (Inputs.empty())
+    return;
+
+  for (const Elf_Mips_RegInfo *RI : Inputs) {
+    if (Config->Relocatable && RI->ri_gp_value)
+      error("supported non-zero ri_gp_value");
+    Reginfo.ri_gprmask |= RI->ri_gprmask;
+  }
+
+  this->Data = ArrayRef<uint8_t>((const uint8_t *)&Reginfo, sizeof(Reginfo));
+  this->Live = true;
+}
+
+template <class ELFT> void MipsReginfoSection<ELFT>::finalize() {
+  if (!Config->Relocatable)
+    Reginfo.ri_gp_value = Out<ELFT>::Got->getVA() + 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>
 InterpSection<ELFT>::InterpSection()

 template class elf::CommonSection<ELF64LE>;
 template class elf::CommonSection<ELF64BE>;
 
 template class elf::InterpSection<ELF32LE>;
 template class elf::InterpSection<ELF32BE>;
 template class elf::InterpSection<ELF64LE>;
 template class elf::InterpSection<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

if (Config->EMachine == EM_MIPS && !Config->Shared) {
     Out<ELFT>::MipsRldMap = make<OutputSection<ELFT>>(".rld_map", SHT_PROGBITS,
                                                       SHF_ALLOC | SHF_WRITE);
     Out<ELFT>::MipsRldMap->setSize(sizeof(uintX_t));
     Out<ELFT>::MipsRldMap->updateAlignment(sizeof(uintX_t));
   }
   if (!Config->VersionDefinitions.empty())
     Out<ELFT>::VerDef = make<VersionDefinitionSection<ELFT>>();
 
-  // Initialize linker generated sections
+  // .note.gnu.build-id
   if (Config->BuildId == BuildIdKind::Fast)
     In<ELFT>::BuildId = make<BuildIdFastHash<ELFT>>();
   else if (Config->BuildId == BuildIdKind::Md5)
     In<ELFT>::BuildId = make<BuildIdMd5<ELFT>>();
   else if (Config->BuildId == BuildIdKind::Sha1)
     In<ELFT>::BuildId = make<BuildIdSha1<ELFT>>();
   else if (Config->BuildId == BuildIdKind::Uuid)
     In<ELFT>::BuildId = make<BuildIdUuid<ELFT>>();
   else if (Config->BuildId == BuildIdKind::Hexstring)
     In<ELFT>::BuildId = make<BuildIdHexstring<ELFT>>();
   else
     In<ELFT>::BuildId = nullptr;
 
   if (In<ELFT>::BuildId)
     Symtab<ELFT>::X->Sections.push_back(In<ELFT>::BuildId);
 
+  // .common
   CommonSection<ELFT> *Common = make<CommonSection<ELFT>>();
   if (!Common->Data.empty()) {
     In<ELFT>::Common = Common;
     Symtab<ELFT>::X->Sections.push_back(Common);
   }
+
+  // MIPS .reginfo
+  if (Config->EMachine == EM_MIPS) {
+    auto *Sec = make<MipsReginfoSection<ELFT>>();
+    if (Sec->Live) {
+      In<ELFT>::MipsReginfo = Sec;
+      Symtab<ELFT>::X->Sections.push_back(Sec);
+    }
+  }
 }
 
 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 because it contains offsets to .got and _gp.
+  if (In<ELFT>::MipsReginfo)
+    In<ELFT>::MipsReginfo->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->getFileOff();
     Out<ELFT>::Opd->writeTo(Buf + Out<ELFT>::Opd->getFileOff());
   }
 

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-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-64.s

v2:
   .quad v1   # R_MIPS_64 target v1 addend 0
 
 
 # SYM: SYMBOL TABLE:
 # SYM: 00030000 l       .data           00000004 v1
 # SYM: 00030008 g       .data           00000008 v2
 
 # CHECK:      Relocations [
-# CHECK-NEXT:   Section (7) .rela.dyn {
+# CHECK-NEXT:   Section (8) .rela.dyn {
 # CHECK-NEXT:     0x30010 R_MIPS_REL32/R_MIPS_64/R_MIPS_NONE - 0x30000
 #                                                             ^-- v1
 # CHECK-NEXT:     0x30008 R_MIPS_REL32/R_MIPS_64/R_MIPS_NONE v2 0x8
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 # CHECK: DynamicSection [
 # CHECK:   Tag        Type     Name/Value

test/ELF/mips-tls-64.s

 # DIS-NEXT:  30048 ffffffff ffff8004 ffffffff ffff9004
 
 # DIS: 0000000000030000 l       .tdata          00000000 .tdata
 # DIS: 0000000000030000 l       .tdata          00000000 loc
 # DIS: 0000000000000004 g       .tdata          00000000 bar
 # DIS: 0000000000000000 g       *UND*           00000000 foo
 
 # CHECK:      Relocations [
-# CHECK-NEXT:   Section (7) .rela.dyn {
+# CHECK-NEXT:   Section (8) .rela.dyn {
 # CHECK-NEXT:     0x30018 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # CHECK-NEXT:     0x30020 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # CHECK-NEXT:     0x30028 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK-NEXT: Primary GOT {
 # CHECK-NEXT:   Canonical gp value: 0x37FF8
 # CHECK-NEXT:   Reserved entries [

 # DIS-SO:      Contents of section .got:
 # DIS-SO-NEXT:  20008 00000000 00000000 80000000 00000000
 # DIS-SO-NEXT:  20018 00000000 00000000 00000000 00000000
 # DIS-SO-NEXT:  20028 00000000 00000000 00000000 00000000
 # DIS-SO-NEXT:  20038 00000000 00000000 00000000 00000000
 # DIS-SO-NEXT:  20048 00000000 00000000 00000000 00000000
 
 # SO:      Relocations [
-# SO-NEXT:   Section (7) .rela.dyn {
+# SO-NEXT:   Section (8) .rela.dyn {
 # SO-NEXT:     0x20030 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE - 0x0
 # SO-NEXT:     0x20040 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
 # SO-NEXT:     0x20048 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
 # SO-NEXT:     0x20050 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
 # SO-NEXT:     0x20018 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # SO-NEXT:     0x20020 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # SO-NEXT:     0x20028 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # SO-NEXT:   }