[Object] Add IsSectionReadOnly section interface

[Amir]

Summary

The interface is implemented for ELF and checks if ALLOC and PROGBITS attributes
are set and WRITE is not set. Not implemented for the rest of formats.

[jhenderson]

What's the motivation for this? Why did you decide that anything other than SHF_WRITE has implication on whether a section is read-only or not?

[djtodoro]

What's the motivation for this?

+1

This needs test anyway.

[rafauler]

Hi folks, this patch is part of an effort to bring BOLT to the LLVM repo, so the use case comes from BOLT.

The main use case for this is here:
https://github.com/facebookincubator/BOLT/blob/rebased/bolt/src/Passes/BinaryPasses.cpp#L1100

This is a pass that checks for a memory load instruction that is accessing a read-only section, and converts it into "load immediate" to save a data memory access.

[MaskRay]

Most binary formats have a concept of writable, but not a concept of readonly.
In ELF, you refine readonly to mean something SHF_ALLOC & SHT_PROGBITS which is probably really BOLT specific.
Having the interface in lib/Object will just cause confusion to lib/Object users.

[Amir]

Thank you for the comments. Indeed this "read-only" is not well-defined. What we actually want to test is if the section is writable or not. Abandoning this diff.

llvm/include/llvm/Object/COFF.h

protected:
   Expected<ArrayRef<uint8_t>>
   getSectionContents(DataRefImpl Sec) const override;
   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
   bool isSectionCompressed(DataRefImpl Sec) const override;
   bool isSectionText(DataRefImpl Sec) const override;
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;
   bool isSectionVirtual(DataRefImpl Sec) const override;
+  bool isSectionReadOnly(DataRefImpl Sec) const override;
   bool isDebugSection(StringRef SectionName) const override;
   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 
   void moveRelocationNext(DataRefImpl &Rel) const override;
   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
   uint64_t getRelocationType(DataRefImpl Rel) const override;

llvm/include/llvm/Object/ELFObjectFile.h

protected:
   Expected<ArrayRef<uint8_t>>
   getSectionContents(DataRefImpl Sec) const override;
   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
   bool isSectionCompressed(DataRefImpl Sec) const override;
   bool isSectionText(DataRefImpl Sec) const override;
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;
   bool isSectionVirtual(DataRefImpl Sec) const override;
+  bool isSectionReadOnly(DataRefImpl Sec) const override;
   bool isBerkeleyText(DataRefImpl Sec) const override;
   bool isBerkeleyData(DataRefImpl Sec) const override;
   bool isDebugSection(StringRef SectionName) const override;
   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
   std::vector<SectionRef> dynamic_relocation_sections() const override;
   Expected<section_iterator>
   getRelocatedSection(DataRefImpl Sec) const override;

 
 template <class ELFT>
 bool ELFObjectFile<ELFT>::isDebugSection(StringRef SectionName) const {
   return SectionName.startswith(".debug") ||
          SectionName.startswith(".zdebug") || SectionName == ".gdb_index";
 }
 
 template <class ELFT>
+bool ELFObjectFile<ELFT>::isSectionReadOnly(DataRefImpl Sec) const {
+  const Elf_Shdr *EShdr = getSection(Sec);
+  return EShdr->sh_flags & ELF::SHF_ALLOC &&
+         !(EShdr->sh_flags & ELF::SHF_WRITE) &&
+         EShdr->sh_type == ELF::SHT_PROGBITS;
+}
+
+template <class ELFT>
 relocation_iterator
 ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const {
   DataRefImpl RelData;
   auto SectionsOrErr = EF.sections();
   if (!SectionsOrErr)
     return relocation_iterator(RelocationRef());
   uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
   RelData.d.a = (Sec.p - SHT) / EF.getHeader().e_shentsize;

llvm/include/llvm/Object/MachO.h

public:
   /// When dsymutil generates the companion file, it strips all unnecessary
   /// sections (e.g. everything in the _TEXT segment) by omitting their body
   /// and setting the offset in their corresponding load command to zero.
   ///
   /// While the load command itself is valid, reading the section corresponds
   /// to reading the number of bytes specified in the load command, starting
   /// from offset 0 (i.e. the Mach-O header at the beginning of the file).
   bool isSectionStripped(DataRefImpl Sec) const override;
+  bool isSectionReadOnly(DataRefImpl Sec) const override;
 
   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 
   relocation_iterator extrel_begin() const;
   relocation_iterator extrel_end() const;
   iterator_range<relocation_iterator> external_relocations() const {
     return make_range(extrel_begin(), extrel_end());

llvm/include/llvm/Object/ObjectFile.h

public:
   bool isText() const;
   /// Whether this section contains data, not instructions.
   bool isData() const;
   /// Whether this section contains BSS uninitialized data.
   bool isBSS() const;
   bool isVirtual() const;
   bool isBitcode() const;
   bool isStripped() const;
+  bool isReadOnly() const;
 
   /// Whether this section will be placed in the text segment, according to the
   /// Berkeley size format. This is true if the section is allocatable, and
   /// contains either code or readonly data.
   bool isBerkeleyText() const;
   /// Whether this section will be placed in the data segment, according to the
   /// Berkeley size format. This is true if the section is allocatable and
   /// contains data (e.g. PROGBITS), but is not text.
protected:
   virtual bool isSectionCompressed(DataRefImpl Sec) const = 0;
   virtual bool isSectionText(DataRefImpl Sec) const = 0;
   virtual bool isSectionData(DataRefImpl Sec) const = 0;
   virtual bool isSectionBSS(DataRefImpl Sec) const = 0;
   // A section is 'virtual' if its contents aren't present in the object image.
   virtual bool isSectionVirtual(DataRefImpl Sec) const = 0;
   virtual bool isSectionBitcode(DataRefImpl Sec) const;
   virtual bool isSectionStripped(DataRefImpl Sec) const;
+  virtual bool isSectionReadOnly(DataRefImpl Sec) const = 0;
   virtual bool isBerkeleyText(DataRefImpl Sec) const;
   virtual bool isBerkeleyData(DataRefImpl Sec) const;
   virtual bool isDebugSection(StringRef SectionName) const;
   virtual relocation_iterator section_rel_begin(DataRefImpl Sec) const = 0;
   virtual relocation_iterator section_rel_end(DataRefImpl Sec) const = 0;
   virtual Expected<section_iterator> getRelocatedSection(DataRefImpl Sec) const;
 
   // Same as above for RelocationRef.

 inline bool SectionRef::isBerkeleyData() const {
   return OwningObject->isBerkeleyData(SectionPimpl);
 }
 
 inline bool SectionRef::isDebugSection(StringRef SectionName) const {
   return OwningObject->isDebugSection(SectionName);
 }
 
+inline bool SectionRef::isReadOnly() const {
+  return OwningObject->isSectionReadOnly(SectionPimpl);
+}
+
 inline relocation_iterator SectionRef::relocation_begin() const {
   return OwningObject->section_rel_begin(SectionPimpl);
 }
 
 inline relocation_iterator SectionRef::relocation_end() const {
   return OwningObject->section_rel_end(SectionPimpl);
 }
 

llvm/include/llvm/Object/Wasm.h

public:
   Expected<ArrayRef<uint8_t>>
   getSectionContents(DataRefImpl Sec) const override;
   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
   bool isSectionCompressed(DataRefImpl Sec) const override;
   bool isSectionText(DataRefImpl Sec) const override;
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;
   bool isSectionVirtual(DataRefImpl Sec) const override;
+  bool isSectionReadOnly(DataRefImpl Sec) const override;
   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 
   // Overrides from RelocationRef.
   void moveRelocationNext(DataRefImpl &Rel) const override;
   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
   uint64_t getRelocationType(DataRefImpl Rel) const override;

llvm/include/llvm/Object/XCOFFObjectFile.h

public:
   getSectionContents(DataRefImpl Sec) const override;
   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
   bool isSectionCompressed(DataRefImpl Sec) const override;
   bool isSectionText(DataRefImpl Sec) const override;
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;
 
   bool isSectionVirtual(DataRefImpl Sec) const override;
+  bool isSectionReadOnly(DataRefImpl Sec) const override;
   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 
   void moveRelocationNext(DataRefImpl &Rel) const override;
 
   /// \returns the relocation offset with the base address of the containing
   /// section as zero, or InvalidRelocOffset on errors (such as a relocation
   /// that does not refer to an address in any section).

llvm/lib/Object/COFFObjectFile.cpp

 
 bool COFFObjectFile::isSectionVirtual(DataRefImpl Ref) const {
   const coff_section *Sec = toSec(Ref);
   // In COFF, a virtual section won't have any in-file
   // content, so the file pointer to the content will be zero.
   return Sec->PointerToRawData == 0;
 }
 
+bool COFFObjectFile::isSectionReadOnly(DataRefImpl Ref) const {
+  llvm_unreachable("not implemented");
+  return false;
+}
+
 static uint32_t getNumberOfRelocations(const coff_section *Sec,
                                        MemoryBufferRef M, const uint8_t *base) {
   // The field for the number of relocations in COFF section table is only
   // 16-bit wide. If a section has more than 65535 relocations, 0xFFFF is set to
   // NumberOfRelocations field, and the actual relocation count is stored in the
   // VirtualAddress field in the first relocation entry.
   if (Sec->hasExtendedRelocations()) {
     const coff_relocation *FirstReloc;

llvm/lib/Object/MachOObjectFile.cpp

 }
 
 bool MachOObjectFile::isSectionStripped(DataRefImpl Sec) const {
   if (is64Bit())
     return getSection64(Sec).offset == 0;
   return getSection(Sec).offset == 0;
 }
 
+bool MachOObjectFile::isSectionReadOnly(DataRefImpl Sec) const {
+  llvm_unreachable("not implemented");
+  return false;
+}
+
 relocation_iterator MachOObjectFile::section_rel_begin(DataRefImpl Sec) const {
   DataRefImpl Ret;
   Ret.d.a = Sec.d.a;
   Ret.d.b = 0;
   return relocation_iterator(RelocationRef(Ret, this));
 }
 
 relocation_iterator

llvm/lib/Object/WasmObjectFile.cpp

 bool WasmObjectFile::isSectionData(DataRefImpl Sec) const {
   return getWasmSection(Sec).Type == wasm::WASM_SEC_DATA;
 }
 
 bool WasmObjectFile::isSectionBSS(DataRefImpl Sec) const { return false; }
 
 bool WasmObjectFile::isSectionVirtual(DataRefImpl Sec) const { return false; }
 
+bool WasmObjectFile::isSectionReadOnly(DataRefImpl Sec) const { return false; }
+
 relocation_iterator WasmObjectFile::section_rel_begin(DataRefImpl Ref) const {
   DataRefImpl RelocRef;
   RelocRef.d.a = Ref.d.a;
   RelocRef.d.b = 0;
   return relocation_iterator(RelocationRef(RelocRef, this));
 }
 
 relocation_iterator WasmObjectFile::section_rel_end(DataRefImpl Ref) const {

llvm/lib/Object/XCOFFObjectFile.cpp

bool XCOFFObjectFile::isSectionBSS(DataRefImpl Sec) const {
   return Flags & (XCOFF::STYP_BSS | XCOFF::STYP_TBSS);
 }
 
 bool XCOFFObjectFile::isSectionVirtual(DataRefImpl Sec) const {
   return is64Bit() ? toSection64(Sec)->FileOffsetToRawData == 0
                    : toSection32(Sec)->FileOffsetToRawData == 0;
 }
 
+bool XCOFFObjectFile::isSectionReadOnly(DataRefImpl Sec) const {
+  report_fatal_error("isSectionReadOnly not implemented yet");
+}
+
 relocation_iterator XCOFFObjectFile::section_rel_begin(DataRefImpl Sec) const {
   if (is64Bit())
     report_fatal_error("64-bit support not implemented yet");
   const XCOFFSectionHeader32 *SectionEntPtr = toSection32(Sec);
   auto RelocationsOrErr = relocations(*SectionEntPtr);
   if (Error E = RelocationsOrErr.takeError())
     return relocation_iterator(RelocationRef());
   DataRefImpl Ret;