[ELF][MIPS] MIPS .reginfo sections handling

[atanasyan]

Summary

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. This section contains a union of used registers masks taken from input .reginfo sections and final value of the _gp symbol.

For details see the "Register Information" section in Chapter 4 in the following document:
ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf

The patch implements .reginfo sections handling with a couple missed features: a) it does not put output .reginfo section into the separate REGINFO segment; b) it does not merge ri_cprmask masks from input section. These features will be implemented later.

[ruiu]

ELF/InputSection.cpp

335 ↗

(On Diff #43309)

error() is a _NoReturn function, so you don't need this return 0.

ELF/InputSection.h

164 ↗

(On Diff #43309)

I think this is a good place to write about MIPS Reginfo as you wrote in the patch description.

170 ↗

(On Diff #43309)

Can you move this just below the above typedef?

[atanasyan]

• Remove return after NoReturn function
• Keep typedefs in a single code block
• Rewrite comment for the MipsReginfoInputSection class

[ruiu]

LGTM

lld/trunk/ELF/InputFiles.cpp

for (const Elf_Shdr &Sec : Obj.sections()) {
     default:
       ErrorOr<StringRef> NameOrErr = this->ELFObj.getSectionName(&Sec);
       error(NameOrErr);
       StringRef Name = *NameOrErr;
       if (Name == ".note.GNU-stack")
         Sections[I] = &InputSection<ELFT>::Discarded;
       else if (Name == ".eh_frame")
         Sections[I] = new (this->Alloc) EHInputSection<ELFT>(this, &Sec);
+      else if (Name == ".reginfo")
+        Sections[I] =
+            new (this->Alloc) MipsReginfoInputSection<ELFT>(this, &Sec);
       else if (shouldMerge<ELFT>(Sec))
         Sections[I] = new (this->Alloc) MergeInputSection<ELFT>(this, &Sec);
       else
         Sections[I] = new (this->Alloc) InputSection<ELFT>(this, &Sec);
       break;
     }
   }
 }

lld/trunk/ELF/InputSection.h

protected:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   const Elf_Shdr *Header;
 
   // The file this section is from.
   ObjectFile<ELFT> *File;
 
 public:
-  enum Kind { Regular, EHFrame, Merge };
+  enum Kind { Regular, EHFrame, Merge, MipsReginfo };
   Kind SectionKind;
 
   InputSectionBase(ObjectFile<ELFT> *File, const Elf_Shdr *Header,
                    Kind SectionKind);
   OutputSectionBase<ELFT> *OutSec = nullptr;
 
   // Used for garbage collection.
   // Live bit makes sense only when Config->GcSections is true.
public:
 
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
   uint64_t OutSecOff = 0;
 
   static bool classof(const InputSectionBase<ELFT> *S);
 };
 
+// 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 llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
+  typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
+
+public:
+  MipsReginfoInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
+
+  uint32_t getGeneralMask() const;
+
+  static bool classof(const InputSectionBase<ELFT> *S);
+};
+
 } // namespace elf2
 } // namespace lld
 
 #endif

lld/trunk/ELF/InputSection.cpp

 InputSectionBase<ELFT>::getOffset(uintX_t Offset) {
   switch (SectionKind) {
   case Regular:
     return cast<InputSection<ELFT>>(this)->OutSecOff + Offset;
   case EHFrame:
     return cast<EHInputSection<ELFT>>(this)->getOffset(Offset);
   case Merge:
     return cast<MergeInputSection<ELFT>>(this)->getOffset(Offset);
+  case MipsReginfo:
+    return cast<MipsReginfoInputSection<ELFT>>(this)->getOffset(Offset);
   }
   llvm_unreachable("Invalid section kind");
 }
 
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t
 InputSectionBase<ELFT>::getOffset(const Elf_Sym &Sym) {
   return getOffset(Sym.st_value);
MergeInputSection<ELFT>::getOffset(uintX_t Offset) {
   ArrayRef<uint8_t> D = this->getSectionData();
   StringRef Data((const char *)D.data(), D.size());
   StringRef Entry = Data.substr(Start, End - Start);
   Base =
       static_cast<MergeOutputSection<ELFT> *>(this->OutSec)->getOffset(Entry);
   return Base + Addend;
 }
 
+template <class ELFT>
+MipsReginfoInputSection<ELFT>::MipsReginfoInputSection(ObjectFile<ELFT> *F,
+                                                       const Elf_Shdr *Header)
+    : InputSectionBase<ELFT>(F, Header, InputSectionBase<ELFT>::MipsReginfo) {}
+
+template <class ELFT>
+uint32_t MipsReginfoInputSection<ELFT>::getGeneralMask() const {
+  ArrayRef<uint8_t> D = this->getSectionData();
+  if (D.size() != sizeof(Elf_Mips_RegInfo))
+    error("Invalid size of .reginfo section");
+  return reinterpret_cast<const Elf_Mips_RegInfo *>(D.data())->ri_gprmask;
+}
+
+template <class ELFT>
+bool MipsReginfoInputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
+  return S->SectionKind == InputSectionBase<ELFT>::MipsReginfo;
+}
+
 namespace lld {
 namespace elf2 {
 template class InputSectionBase<object::ELF32LE>;
 template class InputSectionBase<object::ELF32BE>;
 template class InputSectionBase<object::ELF64LE>;
 template class InputSectionBase<object::ELF64BE>;
 
 template class InputSection<object::ELF32LE>;
 template class InputSection<object::ELF32BE>;
 template class InputSection<object::ELF64LE>;
 template class InputSection<object::ELF64BE>;
 
 template class EHInputSection<object::ELF32LE>;
 template class EHInputSection<object::ELF32BE>;
 template class EHInputSection<object::ELF64LE>;
 template class EHInputSection<object::ELF64BE>;
 
 template class MergeInputSection<object::ELF32LE>;
 template class MergeInputSection<object::ELF32BE>;
 template class MergeInputSection<object::ELF64LE>;
 template class MergeInputSection<object::ELF64BE>;
+
+template class MipsReginfoInputSection<object::ELF32LE>;
+template class MipsReginfoInputSection<object::ELF32BE>;
+template class MipsReginfoInputSection<object::ELF64LE>;
+template class MipsReginfoInputSection<object::ELF64BE>;
 }
 }

lld/trunk/ELF/OutputSections.h

 class SymbolBody;
 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 DefinedRegular;
 template <class ELFT> class ELFSymbolBody;
 
 template <class ELFT>
 static inline typename llvm::object::ELFFile<ELFT>::uintX_t
 getAddend(const typename llvm::object::ELFFile<ELFT>::Elf_Rel &Rel) {

 private:
   SymbolTable<ELFT> &SymTab;
   const ELFSymbolBody<ELFT> *InitSym = nullptr;
   const ELFSymbolBody<ELFT> *FiniSym = nullptr;
   uint32_t DtFlags = 0;
   uint32_t DtFlags1 = 0;
 };
 
+template <class ELFT>
+class MipsReginfoOutputSection final : public OutputSectionBase<ELFT> {
+  typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
+
+public:
+  MipsReginfoOutputSection();
+  void writeTo(uint8_t *Buf) override;
+
+  void addSection(MipsReginfoInputSection<ELFT> *S);
+
+private:
+  uint32_t GeneralMask = 0;
+};
+
 // All output sections that are hadnled by the linker specially are
 // globally accessible. Writer initializes them, so don't use them
 // until Writer is initialized.
 template <class ELFT> struct Out {
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
   static DynamicSection<ELFT> *Dynamic;
   static GnuHashTableSection<ELFT> *GnuHashTab;

lld/trunk/ELF/OutputSections.cpp

uint8_t SymbolTableSection<ELFT>::getSymbolBinding(SymbolBody *Body) {
   uint8_t Visibility = Body->getVisibility();
   if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return STB_LOCAL;
   if (const auto *EBody = dyn_cast<ELFSymbolBody<ELFT>>(Body))
     return EBody->Sym.getBinding();
   return Body->isWeak() ? STB_WEAK : STB_GLOBAL;
 }
 
+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);
+  R->ri_gp_value = getMipsGpAddr<ELFT>();
+  R->ri_gprmask = GeneralMask;
+}
+
+template <class ELFT>
+void MipsReginfoOutputSection<ELFT>::addSection(
+    MipsReginfoInputSection<ELFT> *S) {
+  GeneralMask |= S->getGeneralMask();
+}
+
 namespace lld {
 namespace elf2 {
 template class OutputSectionBase<ELF32LE>;
 template class OutputSectionBase<ELF32BE>;
 template class OutputSectionBase<ELF64LE>;
 template class OutputSectionBase<ELF64BE>;
 
 template class GotPltSection<ELF32LE>;

 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 MergeOutputSection<ELF32LE>;
 template class MergeOutputSection<ELF32BE>;
 template class MergeOutputSection<ELF64LE>;
 template class MergeOutputSection<ELF64BE>;
 
 template class StringTableSection<ELF32LE>;
 template class StringTableSection<ELF32BE>;
 template class StringTableSection<ELF64LE>;

lld/trunk/ELF/Writer.cpp

private:
   void addCommonSymbols(std::vector<DefinedCommon<ELFT> *> &Syms);
   void addSharedCopySymbols(std::vector<SharedSymbol<ELFT> *> &Syms);
 
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
 
   SpecificBumpPtrAllocator<OutputSection<ELFT>> SecAlloc;
   SpecificBumpPtrAllocator<MergeOutputSection<ELFT>> MSecAlloc;
   SpecificBumpPtrAllocator<EHOutputSection<ELFT>> EHSecAlloc;
+  SpecificBumpPtrAllocator<MipsReginfoOutputSection<ELFT>> MReginfoSecAlloc;
   BumpPtrAllocator Alloc;
   std::vector<OutputSectionBase<ELFT> *> OutputSections;
   unsigned getNumSections() const { return OutputSections.size() + 1; }
 
   void addStartStopSymbols(OutputSectionBase<ELFT> *Sec);
   void setPhdr(Elf_Phdr *PH, uint32_t Type, uint32_t Flags, uintX_t FileOff,
                uintX_t VA, uintX_t Size, uintX_t Align);
   void copyPhdr(Elf_Phdr *PH, OutputSectionBase<ELFT> *From);
for (InputSectionBase<ELFT> *C : F->getSections()) {
         case InputSectionBase<ELFT>::EHFrame:
           Sec = new (EHSecAlloc.Allocate())
               EHOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
           break;
         case InputSectionBase<ELFT>::Merge:
           Sec = new (MSecAlloc.Allocate())
               MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
           break;
+        case InputSectionBase<ELFT>::MipsReginfo:
+          Sec = new (MReginfoSecAlloc.Allocate())
+              MipsReginfoOutputSection<ELFT>();
+          break;
         }
         OutputSections.push_back(Sec);
         RegularSections.push_back(Sec);
       }
       switch (K) {
       case InputSectionBase<ELFT>::Regular:
         static_cast<OutputSection<ELFT> *>(Sec)
             ->addSection(cast<InputSection<ELFT>>(C));
         break;
       case InputSectionBase<ELFT>::EHFrame:
         static_cast<EHOutputSection<ELFT> *>(Sec)
             ->addSection(cast<EHInputSection<ELFT>>(C));
         break;
       case InputSectionBase<ELFT>::Merge:
         static_cast<MergeOutputSection<ELFT> *>(Sec)
             ->addSection(cast<MergeInputSection<ELFT>>(C));
         break;
+      case InputSectionBase<ELFT>::MipsReginfo:
+        static_cast<MipsReginfoOutputSection<ELFT> *>(Sec)
+            ->addSection(cast<MipsReginfoInputSection<ELFT>>(C));
+        break;
       }
     }
   }
 
   Out<ELFT>::Bss = static_cast<OutputSection<ELFT> *>(
       Map[{".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE, 0}]);
 
   Out<ELFT>::Dynamic->PreInitArraySec = Map.lookup(

lld/trunk/test/ELF/basic-mips.s

 # CHECK-NEXT:       SHF_ALLOC (0x2)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x100D4
 # CHECK-NEXT:     Offset: 0xD4
 # CHECK-NEXT:     Size: 24
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 4
-# CHECK-NEXT:     EntrySize: 0
+# 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:     Flags [ (0x2)
 # CHECK-NEXT:       SHF_ALLOC (0x2)
 # CHECK-NEXT:     ]

lld/trunk/test/ELF/mips-reginfo.s

+# Check MIPS .reginfo section generation.
+
+# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
+# RUN:         %S/Inputs/mips-dynamic.s -o %t2.o
+# RUN: ld.lld %t1.o %t2.o -shared -o %t.so
+# RUN: llvm-readobj -symbols -mips-reginfo %t.so | FileCheck %s
+
+# REQUIRES: mips
+
+  .text
+  .globl  __start
+__start:
+    lw   $t0,%call16(g1)($gp)
+
+# CHECK:      Name: _gp
+# CHECK-NEXT: Value: 0x[[GP:[0-9A-F]+]]
+
+# CHECK:      MIPS RegInfo {
+# CHECK-NEXT:   GP: 0x[[GP]]
+# CHECK-NEXT:   General Mask: 0x10000101
+# CHECK-NEXT:   Co-Proc Mask0: 0x0
+# CHECK-NEXT:   Co-Proc Mask1: 0x0
+# CHECK-NEXT:   Co-Proc Mask2: 0x0
+# CHECK-NEXT:   Co-Proc Mask3: 0x0
+# CHECK-NEXT: }