[BOLT][NFC] Change IsReadOnly -> IsWritable in registerOrUpdateNoteSection

[Amir]

Summary

Propagate IsReadOnly change to the calling context in
registerOrUpdateNoteSection.

Follow-up to D141733.

bolt/include/bolt/Core/BinaryContext.h

BinarySection &registerOrUpdateSection(const Twine &Name, unsigned ELFType,
                                          unsigned Alignment = 1);
 
   /// Register the information for the note (non-allocatable) section
   /// 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,
+                              bool IsWritable = false,
                               unsigned ELFType = ELF::SHT_PROGBITS) {
     return registerOrUpdateSection(Name, ELFType,
-                                   BinarySection::getFlags(!IsReadOnly), Data,
+                                   BinarySection::getFlags(IsWritable), 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/lib/Passes/Instrumentation.cpp

void Instrumentation::runOnFunctions(BinaryContext &BC) {
   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);
+                                 /*IsWritable=*/false, ELF::SHT_NOTE);
 
   Summary->IndCallCounterFuncPtr =
       BC.Ctx->getOrCreateSymbol("__bolt_ind_call_counter_func_pointer");
   Summary->IndTailCallCounterFuncPtr =
       BC.Ctx->getOrCreateSymbol("__bolt_ind_tailcall_counter_func_pointer");
 
   createAuxiliaryFunctions(BC);
 

bolt/lib/Rewrite/RewriteInstance.cpp

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->isWritable(), BSec->getELFType());
+        BSec->isWritable(), BSec->getELFType());
     NewSection.setOutputAddress(0);
     NewSection.setOutputFileOffset(NextAvailableOffset);
 
     NextAvailableOffset += Size;
   }
 
   // Write new note sections.
   for (BinarySection &Section : BC->nonAllocatableSections()) {
void RewriteInstance::finalizeSectionStringTable(ELFObjectFile<ELFT> *File) {
   const size_t SHStrTabSize = SHStrTab.getSize();
   uint8_t *DataCopy = new uint8_t[SHStrTabSize];
   memset(DataCopy, 0, SHStrTabSize);
   SHStrTab.write(DataCopy);
   BC->registerOrUpdateNoteSection(".shstrtab",
                                   DataCopy,
                                   SHStrTabSize,
                                   /*Alignment=*/1,
-                                  /*IsReadOnly=*/true,
+                                  /*IsWritable=*/false,
                                   ELF::SHT_STRTAB);
 }
 
 void RewriteInstance::addBoltInfoSection() {
   std::string DescStr;
   raw_string_ostream DescOS(DescStr);
 
   DescOS << "BOLT revision: " << BoltRevision << ", "
          << "command line:";
   for (int I = 0; I < Argc; ++I)
     DescOS << " " << Argv[I];
   DescOS.flush();
 
   // Encode as GNU GOLD VERSION so it is easily printable by 'readelf -n'
   const std::string BoltInfo =
       BinarySection::encodeELFNote("GNU", DescStr, 4 /*NT_GNU_GOLD_VERSION*/);
   BC->registerOrUpdateNoteSection(".note.bolt_info", copyByteArray(BoltInfo),
                                   BoltInfo.size(),
                                   /*Alignment=*/1,
-                                  /*IsReadOnly=*/true, ELF::SHT_NOTE);
+                                  /*IsWritable=*/false, ELF::SHT_NOTE);
 }
 
 void RewriteInstance::addBATSection() {
   BC->registerOrUpdateNoteSection(BoltAddressTranslation::SECTION_NAME, nullptr,
                                   0,
                                   /*Alignment=*/1,
-                                  /*IsReadOnly=*/true, ELF::SHT_NOTE);
+                                  /*IsWritable=*/false, ELF::SHT_NOTE);
 }
 
 void RewriteInstance::encodeBATSection() {
   std::string DescStr;
   raw_string_ostream DescOS(DescStr);
 
   BAT->write(*BC, DescOS);
   DescOS.flush();
 
   const std::string BoltInfo =
       BinarySection::encodeELFNote("BOLT", DescStr, BinarySection::NT_BOLT_BAT);
   BC->registerOrUpdateNoteSection(BoltAddressTranslation::SECTION_NAME,
                                   copyByteArray(BoltInfo), BoltInfo.size(),
                                   /*Alignment=*/1,
-                                  /*IsReadOnly=*/true, ELF::SHT_NOTE);
+                                  /*IsWritable=*/false, ELF::SHT_NOTE);
 }
 
 template <typename ELFShdrTy>
 bool RewriteInstance::shouldStrip(const ELFShdrTy &Section,
                                   StringRef SectionName) {
   // Strip non-allocatable relocation sections.
   if (!(Section.sh_flags & ELF::SHF_ALLOC) && Section.sh_type == ELF::SHT_RELA)
     return true;
updateELFSymbolTable(
         NewStrTab.append(1, '\0');
         return Idx;
       });
 
   BC->registerOrUpdateNoteSection(SecName,
                                   copyByteArray(NewContents),
                                   NewContents.size(),
                                   /*Alignment=*/1,
-                                  /*IsReadOnly=*/true,
+                                  /*IsWritable=*/false,
                                   ELF::SHT_SYMTAB);
 
   BC->registerOrUpdateNoteSection(StrSecName,
                                   copyByteArray(NewStrTab),
                                   NewStrTab.size(),
                                   /*Alignment=*/1,
-                                  /*IsReadOnly=*/true,
+                                  /*IsWritable=*/false,
                                   ELF::SHT_STRTAB);
 }
 
 template <typename ELFT>
 void RewriteInstance::patchELFAllocatableRelrSection(
     ELFObjectFile<ELFT> *File) {
   if (!DynamicRelrAddress)
     return;

bolt/lib/RuntimeLibs/InstrumentationRuntimeLibrary.cpp

 
 void InstrumentationRuntimeLibrary::emitTablesAsELFNote(BinaryContext &BC) {
   std::string TablesStr = buildTables(BC);
   const std::string BoltInfo = BinarySection::encodeELFNote(
       "BOLT", TablesStr, BinarySection::NT_BOLT_INSTRUMENTATION_TABLES);
   BC.registerOrUpdateNoteSection(".bolt.instr.tables", copyByteArray(BoltInfo),
                                  BoltInfo.size(),
                                  /*Alignment=*/1,
-                                 /*IsReadOnly=*/true, ELF::SHT_NOTE);
+                                 /*IsWritable=*/false, ELF::SHT_NOTE);
 }