[BOLT][NFC] Replace ambiguous BinarySection::isReadOnly with isWritable

[Amir]

Summary

Address feedback in https://reviews.llvm.org/D102284#2755060

[Amir]

Typo

[yota9]

Nice, thank you!

bolt/include/bolt/Core/BinarySection.h

bool operator<(const BinarySection &Other) const {
     if (hasSectionRef() && getAddress() && getSize() != Other.getSize())
       return getSize() < Other.getSize();
 
     // Code before data.
     if (isText() != Other.isText())
       return isText() > Other.isText();
 
     // Read-only before writable.
-    if (isReadOnly() != Other.isReadOnly())
-      return isReadOnly() > Other.isReadOnly();
+    if (isWritable() != Other.isWritable())
+      return isWritable() < Other.isWritable();
 
     // BSS at the end.
     if (isBSS() != Other.isBSS())
       return isBSS() < Other.isBSS();
 
     // Otherwise, preserve the order of creation.
     return SectionNumber < Other.SectionNumber;
   }
public:
   bool isBSS() const {
     return (ELFType == ELF::SHT_NOBITS &&
             (ELFFlags & (ELF::SHF_ALLOC | ELF::SHF_WRITE)));
   }
   bool isTLS() const { return (ELFFlags & ELF::SHF_TLS); }
   bool isTBSS() const { return isBSS() && isTLS(); }
   bool isVirtual() const { return ELFType == ELF::SHT_NOBITS; }
   bool isRela() const { return ELFType == ELF::SHT_RELA; }
-  bool isReadOnly() const {
-    return ((ELFFlags & ELF::SHF_ALLOC) && !(ELFFlags & ELF::SHF_WRITE) &&
-            ELFType == ELF::SHT_PROGBITS);
-  }
+  bool isWritable() const { return (ELFFlags & ELF::SHF_WRITE); }
   bool isAllocatable() const {
     if (isELF()) {
       return (ELFFlags & ELF::SHF_ALLOC) && !isTBSS();
     } else {
       // On non-ELF assume all sections are allocatable.
       return true;
     }
   }

bolt/lib/Core/BinaryFunction.cpp

if (Section->isVirtual()) {
     return IndirectBranchType::POSSIBLE_TAIL_CALL;
   }
 
   if (BranchType == IndirectBranchType::POSSIBLE_FIXED_BRANCH) {
     ErrorOr<uint64_t> Value = BC.getPointerAtAddress(ArrayStart);
     if (!Value)
       return IndirectBranchType::UNKNOWN;
 
-    if (!BC.getSectionForAddress(ArrayStart)->isReadOnly())
+    if (BC.getSectionForAddress(ArrayStart)->isWritable())
       return IndirectBranchType::UNKNOWN;
 
     outs() << "BOLT-INFO: fixed indirect branch detected in " << *this
            << " at 0x" << Twine::utohexstr(getAddress() + Offset)
            << " referencing data at 0x" << Twine::utohexstr(ArrayStart)
            << " the destination value is 0x" << Twine::utohexstr(*Value)
            << '\n';
 

bolt/lib/Passes/BinaryPasses.cpp

for (MCInst &Inst : *BB) {
       } else if (!MIB->evaluateMemOperandTarget(Inst, TargetAddress)) {
         continue;
       }
 
       // Get the contents of the section containing the target address of the
       // memory operand. We are only interested in read-only sections.
       ErrorOr<BinarySection &> DataSection =
           BC.getSectionForAddress(TargetAddress);
-      if (!DataSection || !DataSection->isReadOnly())
+      if (!DataSection || DataSection->isWritable())
         continue;
 
       if (BC.getRelocationAt(TargetAddress) ||
           BC.getDynamicRelocationAt(TargetAddress))
         continue;
 
       uint32_t Offset = TargetAddress - DataSection->getAddress();
       StringRef ConstantData = DataSection->getContents();

bolt/lib/Rewrite/RewriteInstance.cpp

if (ReferencedBF->containsAddress(Address, /*UseMaxSize = */ true)) {
               ReferencedBF->addEntryPointAtOffset(RefFunctionOffset);
         } else {
           ReferencedSymbol =
               ReferencedBF->getOrCreateLocalLabel(Address,
                                                   /*CreatePastEnd =*/true);
           ReferencedBF->registerReferencedOffset(RefFunctionOffset);
         }
         if (opts::Verbosity > 1 &&
-            !BinarySection(*BC, RelocatedSection).isReadOnly())
+            BinarySection(*BC, RelocatedSection).isWritable())
           errs() << "BOLT-WARNING: writable reference into the middle of the "
                  << formatv("function {0} detected at address {1:x}\n",
                             *ReferencedBF, Rel.getOffset());
       }
       SymbolAddress = Address;
       Addend = 0;
     }
     LLVM_DEBUG({

 void RewriteInstance::mapAllocatableSections(RuntimeDyld &RTDyld) {
   // Allocate read-only sections first, then writable sections.
   enum : uint8_t { ST_READONLY, ST_READWRITE };
   for (uint8_t SType = ST_READONLY; SType <= ST_READWRITE; ++SType) {
     for (BinarySection &Section : BC->allocatableSections()) {
       if (!Section.hasValidSectionID())
         continue;
 
-      if (Section.isReadOnly() != (SType == ST_READONLY))
+      if (Section.isWritable() == (SType == ST_READONLY))
         continue;
 
       if (Section.getOutputAddress()) {
         LLVM_DEBUG({
           dbgs() << "BOLT-DEBUG: section " << Section.getName()
                  << " is already mapped at 0x"
                  << Twine::utohexstr(Section.getOutputAddress()) << '\n';
         });
for (const ELF64LE::Shdr &Section : cantFail(Obj.sections())) {
     BSec->setOutputFileOffset(NextAvailableOffset);
     BSec->flushPendingRelocations(OS, [this](const MCSymbol *S) {
       return getNewValueForSymbol(S->getName());
     });
 
     // Set/modify section info.
     BinarySection &NewSection = BC->registerOrUpdateNoteSection(
         SectionName, SectionData, Size, Section.sh_addralign,
-        BSec->isReadOnly(), BSec->getELFType());
+        !BSec->isWritable(), BSec->getELFType());
     NewSection.setOutputAddress(0);
     NewSection.setOutputFileOffset(NextAvailableOffset);
 
     NextAvailableOffset += Size;
   }
 
   // Write new note sections.
   for (BinarySection &Section : BC->nonAllocatableSections()) {