[BOLT] Change base class of ExecutableFileMemoryManager

[maksfb]

Summary

When we derive EFMM from SectionMemoryManager, it brings into EFMM extra
functionality, such as the registry of exception handling sections,
page permission management, etc. Such functionality is of no use to
llvm-bolt and can even be detrimental (see
https://github.com/llvm/llvm-project/issues/56726).

Change the base class of ExecutableFileMemoryManager to MemoryManager,
avoid registering EH sections, and skip memory finalization.

Fixes #56726

[maksfb]

Don't free memory allocated by EFMM.

[yota9]

bolt/include/bolt/Rewrite/ExecutableFileMemoryManager.h

36

It seems to me that 4 is not suitable number and might be increased significantly, maybe like 32 or even 64, what do you think?

[maksfb]

bolt/include/bolt/Rewrite/ExecutableFileMemoryManager.h

36

In relocation mode, there are not that many sections emitted. I can bump it to 8.

[maksfb]

Change SmallVector size for AllocatedSections.

[yota9]

bolt/include/bolt/Rewrite/ExecutableFileMemoryManager.h

36

You're right it is too much, I was also thinking about debug sections, that might be around ~8 as I understand. But I don't insist here, thanks for bumping anyway :)

[maksfb]

bolt/include/bolt/Rewrite/ExecutableFileMemoryManager.h

36

For now it’s only .debug_line come get from EFMM.

[maksfb]

bolt/include/bolt/Rewrite/ExecutableFileMemoryManager.h

36

Sorry, sent that from my phone. Most debug sections we emit directly. For now, only .debug_line is emitted via MC and gets allocated by EFMM. Thanks for the review.

[yota9]

bolt/include/bolt/Rewrite/ExecutableFileMemoryManager.h

36

Thanks for clarifying and this change :)

bolt/include/bolt/Rewrite/ExecutableFileMemoryManager.h

 //===- bolt/Rewrite/ExecutableFileMemoryManager.h ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BOLT_REWRITE_EXECUTABLE_FILE_MEMORY_MANAGER_H
 #define BOLT_REWRITE_EXECUTABLE_FILE_MEMORY_MANAGER_H
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ExecutionEngine/SectionMemoryManager.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include <cstdint>
 #include <string>
 
 namespace llvm {
 
 namespace bolt {
 class BinaryContext;
 
 /// Class responsible for allocating and managing code and data sections.
-class ExecutableFileMemoryManager : public SectionMemoryManager {
+class ExecutableFileMemoryManager : public RuntimeDyld::MemoryManager {
 private:
-  uint8_t *allocateSection(intptr_t Size, unsigned Alignment,
+  uint8_t *allocateSection(uintptr_t Size, unsigned Alignment,
                            unsigned SectionID, StringRef SectionName,
                            bool IsCode, bool IsReadOnly);
   BinaryContext &BC;
   bool AllowStubs;
 
+  struct AllocInfo {
+    uint8_t *Address;
+    size_t Size;
+    size_t Alignment;
+  };
+  SmallVector<AllocInfo, 8> AllocatedSections;
+
 public:
   // Our linker's main purpose is to handle a single object file, created
   // by RewriteInstance after reading the input binary and reordering it.
   // After objects finish loading, we increment this. Therefore, whenever
   // this is greater than zero, we are dealing with additional objects that
   // will not be managed by BinaryContext but only exist to support linking
   // user-supplied objects into the main input executable.
   uint32_t ObjectsLoaded{0};
TLSSection allocateTLSSection(uintptr_t Size, unsigned Alignment,
     Res.Offset = 0;
     Res.InitializationImage = allocateDataSection(
         Size, Alignment, SectionID, SectionName, /*IsReadOnly=*/false);
     return Res;
   }
 
   bool allowStubAllocation() const override { return AllowStubs; }
 
-  bool finalizeMemory(std::string *ErrMsg = nullptr) override;
+  /// Count processed objects and skip memory finalization.
+  bool finalizeMemory(std::string *ErrMsg) override {
+    ++ObjectsLoaded;
+    return false;
+  }
+
+  /// Ignore EH frames.
+  void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
+                        size_t Size) override {}
+  void deregisterEHFrames() override {}
 };
 
 } // namespace bolt
 } // namespace llvm
 
 #endif

bolt/lib/Core/BinarySection.cpp

 }
 
 BinarySection::~BinarySection() {
   if (isReordered()) {
     delete[] getData();
     return;
   }
 
-  if (!isAllocatable() &&
+  if (!isAllocatable() && !hasValidSectionID() &&
       (!hasSectionRef() ||
        OutputContents.data() != getContents(Section).data())) {
     delete[] getOutputData();
   }
 }
 
 void BinarySection::clearRelocations() { clearList(Relocations); }
 

bolt/lib/Rewrite/ExecutableFileMemoryManager.cpp

 //===- bolt/Rewrite/ExecutableFileMemoryManager.cpp -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Rewrite/ExecutableFileMemoryManager.h"
 #include "bolt/Rewrite/RewriteInstance.h"
+#include "llvm/Support/MemAlloc.h"
 
 #undef  DEBUG_TYPE
 #define DEBUG_TYPE "efmm"
 
 using namespace llvm;
 using namespace object;
 using namespace bolt;
 
 namespace llvm {
 
 namespace bolt {
 
-uint8_t *ExecutableFileMemoryManager::allocateSection(intptr_t Size,
-                                                      unsigned Alignment,
-                                                      unsigned SectionID,
-                                                      StringRef SectionName,
-                                                      bool IsCode,
-                                                      bool IsReadOnly) {
+uint8_t *ExecutableFileMemoryManager::allocateSection(
+    uintptr_t Size, unsigned Alignment, unsigned SectionID,
+    StringRef SectionName, bool IsCode, bool IsReadOnly) {
+  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)) {
-    uint8_t *DataCopy = new uint8_t[Size];
     BinarySection &Section =
-        BC.registerOrUpdateNoteSection(SectionName, DataCopy, Size, Alignment);
+        BC.registerOrUpdateNoteSection(SectionName, Ret, Size, Alignment);
     Section.setSectionID(SectionID);
     assert(!Section.isAllocatable() && "note sections cannot be allocatable");
-    return DataCopy;
+    return Ret;
   }
 
   if (!IsCode && (SectionName == ".strtab" || SectionName == ".symtab" ||
                   SectionName == "" || SectionName.startswith(".rela.")))
-    return SectionMemoryManager::allocateDataSection(Size, Alignment, SectionID,
-                                                     SectionName, IsReadOnly);
-
-  uint8_t *Ret;
-  if (IsCode)
-    Ret = SectionMemoryManager::allocateCodeSection(Size, Alignment, SectionID,
-                                                    SectionName);
-  else
-    Ret = SectionMemoryManager::allocateDataSection(Size, Alignment, SectionID,
-                                                    SectionName, IsReadOnly);
+    return Ret;
 
   SmallVector<char, 256> Buf;
   if (ObjectsLoaded > 0) {
     if (BC.isELF()) {
       SectionName = (Twine(SectionName) + ".bolt.extra." + Twine(ObjectsLoaded))
                         .toStringRef(Buf);
     } else if (BC.isMachO()) {
       assert((SectionName == "__text" || SectionName == "__data" ||
uint8_t *ExecutableFileMemoryManager::allocateSection(
   Section.setSectionID(SectionID);
   assert(Section.isAllocatable() &&
          "verify that allocatable is marked as allocatable");
 
   LLVM_DEBUG(
       dbgs() << "BOLT: allocating "
              << (IsCode ? "code" : (IsReadOnly ? "read-only data" : "data"))
              << " section : " << SectionName << " with size " << Size
-             << ", alignment " << Alignment << " at 0x" << Ret
+             << ", alignment " << Alignment << " at " << Ret
              << ", ID = " << SectionID << "\n");
   return Ret;
 }
 
-bool ExecutableFileMemoryManager::finalizeMemory(std::string *ErrMsg) {
-  LLVM_DEBUG(dbgs() << "BOLT: finalizeMemory()\n");
-  ++ObjectsLoaded;
-  return SectionMemoryManager::finalizeMemory(ErrMsg);
+ExecutableFileMemoryManager::~ExecutableFileMemoryManager() {
+  for (const AllocInfo &AI : AllocatedSections)
+    llvm::deallocate_buffer(AI.Address, AI.Size, AI.Alignment);
 }
 
-ExecutableFileMemoryManager::~ExecutableFileMemoryManager() {}
-
 } // namespace bolt
 
 } // namespace llvm