Rebase: [NFC] Refactor sources to be buildable in shared mode

Summary:
Moves source files into separate components, and make explicit
component dependency on each other, so LLVM build system knows how to
build BOLT in BUILD_SHARED_LIBS=ON.

Please use the -c merge.renamelimit=230 git option when rebasing your
work on top of this change.

To achieve this, we create a new library to hold core IR files (most
classes beginning with Binary in their names), a new library to hold
Utils, some command line options shared across both RewriteInstance
and core IR files, a new library called Rewrite to hold most classes
concerned with running top-level functions coordinating the binary
rewriting process, and a new library called Profile to hold classes
dealing with profile reading and writing.

To remove the dependency from BinaryContext into X86-specific classes,
we do some refactoring on the BinaryContext constructor to receive a
reference to the specific backend directly from RewriteInstance. Then,
the dependency on X86 or AArch64-specific classes is transfered to the
Rewrite library. We can't have the Core library depend on targets
because targets depend on Core (which would create a cycle).

Files implementing the entry point of a tool are transferred to the
tools/ folder. All header files are transferred to the include/
folder. The src/ folder was renamed to lib/.

(cherry picked from FBD32746834)

1 files changed, 100 insertions, 0 deletions

diff --git a/bolt/lib/Rewrite/ExecutableFileMemoryManager.cpp b/bolt/lib/Rewrite/ExecutableFileMemoryManager.cpp
new file mode 100644
index 0000000..0343a87
--- /dev/null
+++ b/bolt/lib/Rewrite/ExecutableFileMemoryManager.cpp
@@ -0,0 +1,100 @@
+//===--- 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"
+
+#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) {
+  // 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);
+    Section.setSectionID(SectionID);
+    assert(!Section.isAllocatable() && "note sections cannot be allocatable");
+    return DataCopy;
+  }
+
+  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);
+  }
+
+  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" ||
+              SectionName == "__fini" || SectionName == "__setup" ||
+              SectionName == "__cstring" || SectionName == "__literal16") &&
+             "Unexpected section in the instrumentation library");
+      // Sections coming from the instrumentation runtime are prefixed with "I".
+      SectionName = ("I" + Twine(SectionName)).toStringRef(Buf);
+    }
+  }
+
+  BinarySection &Section = BC.registerOrUpdateSection(
+      SectionName, ELF::SHT_PROGBITS,
+      BinarySection::getFlags(IsReadOnly, IsCode, true), Ret, Size, Alignment);
+  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
+             << ", ID = " << SectionID << "\n");
+  return Ret;
+}
+
+bool ExecutableFileMemoryManager::finalizeMemory(std::string *ErrMsg) {
+  LLVM_DEBUG(dbgs() << "BOLT: finalizeMemory()\n");
+  ++ObjectsLoaded;
+  return SectionMemoryManager::finalizeMemory(ErrMsg);
+}
+
+ExecutableFileMemoryManager::~ExecutableFileMemoryManager() { }
+
+}
+
+}