[BOLT][NFC] Change IsReadOnly -> IsWritable in EFMM::allocateSection

[Amir]

Summary

Propagate IsReadOnly change to the calling context in
EFMM::allocateSection.

Follow-up to D141733.

Note that EFMM::allocate{Code,Data}Section have IsReadOnly parameter per
RuntimeDyld::MemoryManager interface.

bolt/include/bolt/Rewrite/ExecutableFileMemoryManager.h

 namespace bolt {
 class BinaryContext;
 
 /// Class responsible for allocating and managing code and data sections.
 class ExecutableFileMemoryManager : public RuntimeDyld::MemoryManager {
 private:
   uint8_t *allocateSection(uintptr_t Size, unsigned Alignment,
                            unsigned SectionID, StringRef SectionName,
-                           bool IsCode, bool IsReadOnly);
+                           bool IsCode, bool IsWritable);
   BinaryContext &BC;
   bool AllowStubs;
 
   struct AllocInfo {
     uint8_t *Address;
     size_t Size;
     size_t Alignment;
   };
ExecutableFileMemoryManager(BinaryContext &BC, bool AllowStubs)
       : BC(BC), AllowStubs(AllowStubs) {}
 
   ~ExecutableFileMemoryManager();
 
   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                unsigned SectionID,
                                StringRef SectionName) override {
     return allocateSection(Size, Alignment, SectionID, SectionName,
-                           /*IsCode=*/true, true);
+                           /*IsCode=*/true, false);
   }
 
   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
                                unsigned SectionID, StringRef SectionName,
                                bool IsReadOnly) override {
     return allocateSection(Size, Alignment, SectionID, SectionName,
-                           /*IsCode=*/false, IsReadOnly);
+                           /*IsCode=*/false, !IsReadOnly);
   }
 
   // Ignore TLS sections by treating them as a regular data section
   TLSSection allocateTLSSection(uintptr_t Size, unsigned Alignment,
                                 unsigned SectionID,
                                 StringRef SectionName) override {
     TLSSection Res;
     Res.Offset = 0;

bolt/lib/Rewrite/ExecutableFileMemoryManager.cpp

 using namespace bolt;
 
 namespace llvm {
 
 namespace bolt {
 
 uint8_t *ExecutableFileMemoryManager::allocateSection(
     uintptr_t Size, unsigned Alignment, unsigned SectionID,
-    StringRef SectionName, bool IsCode, bool IsReadOnly) {
+    StringRef SectionName, bool IsCode, bool IsWritable) {
   uint8_t *Ret = static_cast<uint8_t *>(llvm::allocate_buffer(Size, Alignment));
   AllocatedSections.push_back(AllocInfo{Ret, Size, Alignment});
 
   // Register a debug section as a note section.
   if (!ObjectsLoaded && RewriteInstance::isDebugSection(SectionName)) {
     BinarySection &Section =
         BC.registerOrUpdateNoteSection(SectionName, Ret, Size, Alignment);
     Section.setSectionID(SectionID);
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(IsWritable, IsCode, true), Ret, Size,
         Alignment);
     if (UsePrefix)
       NewSection.setOutputName(SectionName);
     Section = &NewSection;
   }
 
   LLVM_DEBUG({
     dbgs() << "BOLT: allocating "
-           << (IsCode ? "code" : (IsReadOnly ? "read-only data" : "data"))
+           << (IsCode ? "code" : (!IsWritable ? "read-only data" : "data"))
            << " section : " << Section->getOutputName() << " ("
            << Section->getName() << ")"
            << " with size " << Size << ", alignment " << Alignment << " at "
            << Ret << ", ID = " << SectionID << "\n";
   });
 
   Section->setSectionID(SectionID);