[BOLT][NFC] Use IsWritable instead of IsReadOnly in BinarySection::getFlags

[Amir]

Summary

BinarySection::getFlags operates with ELF flags => replace IsReadOnly with
IsWritable.

Follow-up to D141733.

bolt/include/bolt/Core/BinaryContext.h

public:
   /// with the given /p Name.  If the section already exists, the
   /// information in the section will be updated with the new data.
   BinarySection &
   registerOrUpdateNoteSection(const Twine &Name, uint8_t *Data = nullptr,
                               uint64_t Size = 0, unsigned Alignment = 1,
                               bool IsReadOnly = true,
                               unsigned ELFType = ELF::SHT_PROGBITS) {
     return registerOrUpdateSection(Name, ELFType,
-                                   BinarySection::getFlags(IsReadOnly), Data,
+                                   BinarySection::getFlags(!IsReadOnly), Data,
                                    Size, Alignment);
   }
 
   /// Remove sections that were preregistered but never used.
   void deregisterUnusedSections();
 
   /// Remove the given /p Section from the set of all sections.  Return
   /// true if the section was removed (and deleted), otherwise false.

bolt/include/bolt/Core/BinarySection.h

BinarySection(BinaryContext &BC, const Twine &Name, uint8_t *Data,
         ELFFlags(ELFFlags), IsFinalized(true), OutputName(Name.str()),
         OutputSize(Size), OutputContents(Contents), SectionNumber(++Count) {
     assert(Alignment > 0 && "section alignment must be > 0");
   }
 
   ~BinarySection();
 
   /// Helper function to generate the proper ELF flags from section properties.
-  static unsigned getFlags(bool IsReadOnly = true, bool IsText = false,
+  static unsigned getFlags(bool IsWritable = false, bool IsText = false,
                            bool IsAllocatable = false) {
     unsigned Flags = 0;
     if (IsAllocatable)
       Flags |= ELF::SHF_ALLOC;
-    if (!IsReadOnly)
+    if (IsWritable)
       Flags |= ELF::SHF_WRITE;
     if (IsText)
       Flags |= ELF::SHF_EXECINSTR;
     return Flags;
   }
 
   operator bool() const { return ELFType != ELF::SHT_NULL; }
 

bolt/lib/Passes/Instrumentation.cpp

void Instrumentation::instrumentFunction(BinaryFunction &Function,
   // Unused now
   FuncDesc->EdgesSet.clear();
 }
 
 void Instrumentation::runOnFunctions(BinaryContext &BC) {
   if (!BC.isX86())
     return;
 
-  const unsigned Flags = BinarySection::getFlags(/*IsReadOnly=*/false,
+  const unsigned Flags = BinarySection::getFlags(/*IsWritable=*/true,
                                                  /*IsText=*/false,
                                                  /*IsAllocatable=*/true);
   BC.registerOrUpdateSection(".bolt.instr.counters", ELF::SHT_PROGBITS, Flags,
                              nullptr, 0, 1);
 
   BC.registerOrUpdateNoteSection(".bolt.instr.tables", nullptr, 0,
                                  /*Alignment=*/1,
                                  /*IsReadOnly=*/true, ELF::SHT_NOTE);

bolt/lib/Rewrite/ExecutableFileMemoryManager.cpp

if (OrgSection && OrgSection->hasSectionRef()) {
       OrgSection->setOutputName(OrgSecPrefix + SectionName);
       UsePrefix = true;
     }
 
     // Register the new section under a unique name to avoid name collision with
     // sections in the input file.
     BinarySection &NewSection = BC.registerOrUpdateSection(
         UsePrefix ? NewSecPrefix + SectionName : SectionName, ELF::SHT_PROGBITS,
-        BinarySection::getFlags(IsReadOnly, IsCode, true), Ret, Size,
+        BinarySection::getFlags(!IsReadOnly, IsCode, true), Ret, Size,
         Alignment);
     if (UsePrefix)
       NewSection.setOutputName(SectionName);
     Section = &NewSection;
   }
 
   LLVM_DEBUG({
     dbgs() << "BOLT: allocating "

bolt/lib/Rewrite/RewriteInstance.cpp

void lookup(const LookupSet &Symbols,
     OnResolved(std::move(AllResults));
   }
 };
 
 } // anonymous namespace
 
 void RewriteInstance::preregisterSections() {
   // Preregister sections before emission to set their order in the output.
-  const unsigned ROFlags = BinarySection::getFlags(/*IsReadOnly*/ true,
+  const unsigned ROFlags = BinarySection::getFlags(/*IsWritable*/ false,
                                                    /*IsText*/ false,
                                                    /*IsAllocatable*/ true);
   if (BinarySection *EHFrameSection = getSection(getEHFrameSectionName())) {
     // New .eh_frame.
     BC->registerOrUpdateSection(getNewSecPrefix() + getEHFrameSectionName(),
                                 ELF::SHT_PROGBITS, ROFlags);
     // Fully register a relocatable copy of the original .eh_frame.
     BC->registerSection(".relocated.eh_frame", *EHFrameSection);
void RewriteInstance::mapCodeSections(RuntimeDyld &RTDyld) {
   }
 
   // Add the new text section aggregating all existing code sections.
   // This is pseudo-section that serves a purpose of creating a corresponding
   // entry in section header table.
   int64_t NewTextSectionSize =
       NextAvailableAddress - NewTextSectionStartAddress;
   if (NewTextSectionSize) {
-    const unsigned Flags = BinarySection::getFlags(/*IsReadOnly=*/true,
+    const unsigned Flags = BinarySection::getFlags(/*IsWritable=*/false,
                                                    /*IsText=*/true,
                                                    /*IsAllocatable=*/true);
     BinarySection &Section =
       BC->registerOrUpdateSection(getBOLTTextSectionName(),
                                   ELF::SHT_PROGBITS,
                                   Flags,
                                   /*Data=*/nullptr,
                                   NewTextSectionSize,
const uint64_t EHFrameHdrFileOffset =
       getFileOffsetForAddress(NextAvailableAddress);
 
   std::vector<char> NewEHFrameHdr = CFIRdWrt->generateEHFrameHeader(
       RelocatedEHFrame, NewEHFrame, EHFrameHdrOutputAddress, FailedAddresses);
 
   assert(Out->os().tell() == EHFrameHdrFileOffset && "offset mismatch");
   Out->os().write(NewEHFrameHdr.data(), NewEHFrameHdr.size());
 
-  const unsigned Flags = BinarySection::getFlags(/*IsReadOnly=*/true,
+  const unsigned Flags = BinarySection::getFlags(/*IsWritable=*/false,
                                                  /*IsText=*/false,
                                                  /*IsAllocatable=*/true);
   BinarySection *OldEHFrameHdrSection = getSection(".eh_frame_hdr");
   if (OldEHFrameHdrSection)
     OldEHFrameHdrSection->setOutputName(getOrgSecPrefix() + ".eh_frame_hdr");
 
   BinarySection &EHFrameHdrSec = BC->registerOrUpdateSection(
       getNewSecPrefix() + ".eh_frame_hdr", ELF::SHT_PROGBITS, Flags, nullptr,

bolt/lib/RuntimeLibs/InstrumentationRuntimeLibrary.cpp

void InstrumentationRuntimeLibrary::adjustCommandLineOptions(
   }
 }
 
 void InstrumentationRuntimeLibrary::emitBinary(BinaryContext &BC,
                                                MCStreamer &Streamer) {
   MCSection *Section = BC.isELF()
                            ? static_cast<MCSection *>(BC.Ctx->getELFSection(
                                  ".bolt.instr.counters", ELF::SHT_PROGBITS,
-                                 BinarySection::getFlags(/*IsReadOnly=*/false,
+                                 BinarySection::getFlags(/*IsWritable=*/true,
                                                          /*IsText=*/false,
                                                          /*IsAllocatable=*/true)
 
                                      ))
                            : static_cast<MCSection *>(BC.Ctx->getMachOSection(
                                  "__BOLT", "__counters", MachO::S_REGULAR,
                                  SectionKind::getData()));