[BOLT] Calculate output values using BOLTLinker

[jobnoorman]

Summary

BOLT uses MCAsmLayout to calculate the output values of functions and
basic blocks. This means output values are calculated based on a
pre-linking state and any changes to symbol values during linking will
cause incorrect values to be used.

This issue can be triggered by enabling linker relaxation on RISC-V.
Since linker relaxation can remove instructions, symbol values may
change. This causes, among other things, the symbol table created by
BOLT in the output executable to be incorrect.

This patch solves this issue by using BOLTLinker to get symbol values
instead of MCAsmLayout. This way, output values are calculated based
on a post-linking state. To make sure the linker can update all
necessary symbols, this patch also makes sure all these symbols are not
marked as temporary so that they end-up in the object file's symbol
table.

Note that this patch only deals with symbols of binary functions
(BinaryFunction::updateOutputValues). The technique described above
turned out to be too expensive for basic block symbols so those are
handled differently in D155604.

Depends on D155604

[jobnoorman]

Rebase

[jobnoorman]

Fix warning after rebase

[jobnoorman]

Rebase

[jobnoorman]

Rebase and ping

[maksfb]

The change looks good to me overall. Should we expect any overhead associated with making symbols non-temporary (Ctx->setAllowTemporaryLabels(false))?

[maksfb]

bolt/lib/Core/BinaryContext.cpp

192 ↗

(On Diff #538964)

Background: we've discussed offline that this change causes a noticeable BOLT runtime regression.

The alternative approach for mapping input to output addresses used for address translation, will be to generate a map in a section that we can read and discard later (i.e. skip writing to a file). The map/section contents will be an ordered list of pairs <InputAddress, OutputAddress>. For output address we will emit the temporary symbol to the section. I believe BOLTLinker should be able to process it.

With the approach above, we can continue to emit all internal symbols as temps and avoid the regression.

[jobnoorman]

bolt/lib/Core/BinaryContext.cpp

192 ↗

(On Diff #538964)

The alternative approach for mapping input to output addresses used for address translation, will be to generate a map in a section that we can read and discard later (i.e. skip writing to a file). The map/section contents will be an ordered list of pairs <InputAddress, OutputAddress>. For output address we will emit the temporary symbol to the section. I believe BOLTLinker should be able to process it.

Interesting idea! I made a PoC implementation and have the following preliminary performance results:

• With --enable-bat --update-debug-sections: +4% total runtime
• Without: negligible overhead.

So the overhead is much smaller than for this patch (11%), but it's still non-zero. Would you still agree that the preferred approach (as discussed during our call) is to use this patch but only emit the temp symbols for the targets that need it (i.e., RISC-V)?

One thing I noticed is that the format you proposed for the map section is quite similar to the BAT section BOLT emits with --enable-bat. I wonder if it could be worth trying to emit the BAT section directly instead of the intermediary map you proposed. That way, we might get rid of having to manually update BB output values. However, I guess it would mean that we'd have to generate the BAT section in some cases even without --enable-bat (e.g., to update debug info).

[maksfb]

bolt/lib/Core/BinaryContext.cpp

192 ↗

(On Diff #538964)

In your PoC, did you get rid of LocSyms and InputOffsetToAddressMap? I expect the generation of the map section will have a similar overhead to the one when populating those structures, so hopefully there will be no overhead at all when those structures are gone.

It should be possible to generate BAT directly and then maybe perform some post-processing (if required). At the moment, there are other types of metadata that rely on the address translation, e.g. SDT and pseudo probes. It will take some time to get rid of AT completely. I'm trying to avoid this mechanism while adding new rewriters for the kernel. Once the new replacement process is streamlined, we can refactor the legacy code.

[jobnoorman]

Rebase on D155604.

Use map section of <Input address, Output address> pairs as suggested by
@maksfb. This replaces OffsetTranslationTable and InputOffsetToAddressMap
but not LocSyms as the latter is used to build the map section.

The only extra symbols that need to be added to the symbol table now are those
used for constant island labels. All others are kept temporary and are only used
for the relocations in the map section. Since section-relative references are
used there, these symbols do not end up in the symbol table.

Updating the line table offsets is reverted to using MCAsmLayout as I don't
think linker relaxation can have an influence here. I didn't find an easy way to
do this via the linker without having to insert a large amount of symbols.

Here are some performance results. I've ran this on a clang binary following the
instructions
here.

tl;dr:

• Without debug info: +0%
• --update-debug-sections: +1%
• --update-debug-sections --enable-bat: +2%
• Without optimizations: +4%

Note: ARGS=-o /tmp/clang.bolt clang-17 -b clang.yaml -reorder-blocks=ext-tsp -reorder-functions=hfsort+ -split-functions -split-all-cold -dyno-stats -icf=1 -use-gnu-stack

No debug info:

hyperfine --parameter-list which main,iomap --runs 10 './llvm-bolt.{which} $ARGS'
Benchmark 1: ./llvm-bolt.main $ARGS
  Time (mean ± σ):     28.853 s ±  0.098 s    [User: 63.374 s, System: 6.353 s]
  Range (min … max):   28.681 s … 29.004 s    10 runs

Benchmark 2: ./llvm-bolt.iomap $ARGS
  Time (mean ± σ):     28.746 s ±  0.092 s    [User: 63.389 s, System: 6.289 s]
  Range (min … max):   28.627 s … 28.942 s    10 runs

Summary
  ./llvm-bolt.iomap -o $ARGS ran
    1.00 ± 0.00 times faster than ./llvm-bolt.main $ARGS

--update-debug-sections:

hyperfine --parameter-list which main,iomap --runs 10 './llvm-bolt.{which} $ARGS --update-debug-sections'
Benchmark 1: ./llvm-bolt.main $ARGS --update-debug-sections
  Time (mean ± σ):     28.945 s ±  0.065 s    [User: 63.544 s, System: 6.329 s]
  Range (min … max):   28.867 s … 29.085 s    10 runs

Benchmark 2: ./llvm-bolt.iomap $ARGS --update-debug-sections
  Time (mean ± σ):     29.334 s ±  0.137 s    [User: 63.966 s, System: 6.258 s]
  Range (min … max):   29.115 s … 29.501 s    10 runs

Summary
  ./llvm-bolt.main $ARGS --update-debug-sections ran
    1.01 ± 0.01 times faster than ./llvm-bolt.iomap $ARGS --update-debug-sections

--update-debug-sections --enable-bat:

hyperfine --parameter-list which main,iomap --runs 10 './llvm-bolt.{which} $ARGS --update-debug-sections --enable-bat'
Benchmark 1: ./llvm-bolt.main $ARGS --update-debug-sections --enable-bat
  Time (mean ± σ):     29.984 s ±  0.070 s    [User: 64.657 s, System: 6.280 s]
  Range (min … max):   29.885 s … 30.117 s    10 runs

Benchmark 2: ./llvm-bolt.iomap $ARGS --update-debug-sections --enable-bat
  Time (mean ± σ):     30.520 s ±  0.079 s    [User: 65.149 s, System: 6.404 s]
  Range (min … max):   30.422 s … 30.675 s    10 runs

Summary
  ./llvm-bolt.main $ARGS --update-debug-sections --enable-bat ran
    1.02 ± 0.00 times faster than ./llvm-bolt.iomap $ARGS --update-debug-sections --enable-bat

Without optimizations (a bit confused about why the performance here is worse for both cases):

hyperfine --parameter-list which main,iomap --runs 10 './llvm-bolt.{which} -o /tmp/clang.bolt clang-17 --update-debug-sections --enable-bat'
Benchmark 1: ./llvm-bolt.main -o /tmp/clang.bolt clang-17 --update-debug-sections --enable-bat
  Time (mean ± σ):     58.988 s ±  0.362 s    [User: 93.203 s, System: 20.905 s]
  Range (min … max):   58.657 s … 59.897 s    10 runs

Benchmark 2: ./llvm-bolt.iomap -o /tmp/clang.bolt clang-17 --update-debug-sections --enable-bat
  Time (mean ± σ):     61.540 s ±  0.331 s    [User: 95.545 s, System: 21.182 s]
  Range (min … max):   61.012 s … 62.160 s    10 runs

Summary
  ./llvm-bolt.main -o /tmp/clang.bolt clang-17 --update-debug-sections --enable-bat ran
    1.04 ± 0.01 times faster than ./llvm-bolt.iomap -o /tmp/clang.bolt clang-17 --update-debug-sections --enable-bat

[jobnoorman]

Ping

[jobnoorman]

Ping

[maksfb]

Will get back to you in a couple of days once I’m back in the office.

[maksfb]

LGTM. Could you please add a test case using .space/.skip asm directive to trigger the linker relaxation on RISC-V?

Also, the summary might use an update after the rebase on D155604.

bolt/include/bolt/Rewrite/JITLinkLinker.h

37

Use ADT's StringMap instead.

[jobnoorman]

Use StringMap instead of std::map, update description.

[jobnoorman]

In D154604#4611404, @maksfb wrote:

LGTM. Could you please add a test case using .space/.skip asm directive to trigger the linker relaxation on RISC-V?

In the current state, I think it's impossible to trigger linker relaxation because 1) we don't pass the correct features yet when creating MCSubtargetInfo, and 2) BOLT will never output any relaxable instructions. Do you think it's ok to wait with this test case until I submit a patch for linker relaxation support in BOLT?

[maksfb]

Sounds good. Please add a test case with the linker relaxation patch.

bolt/include/bolt/Core/BinaryFunction.h

public:
   /// Return a label used to identify where the constant island was emitted
   /// (AArch only). This is used to update the symbol table accordingly,
   /// emitting data marker symbols as required by the ABI.
   MCSymbol *getFunctionConstantIslandLabel() const {
     assert(Islands && "function expected to have constant islands");
 
     if (!Islands->FunctionConstantIslandLabel) {
       Islands->FunctionConstantIslandLabel =
-          BC.Ctx->createNamedTempSymbol("func_const_island");
+          BC.Ctx->getOrCreateSymbol("func_const_island@" + getOneName());
     }
     return Islands->FunctionConstantIslandLabel;
   }
 
   MCSymbol *getFunctionColdConstantIslandLabel() const {
     assert(Islands && "function expected to have constant islands");
 
     if (!Islands->FunctionColdConstantIslandLabel) {
       Islands->FunctionColdConstantIslandLabel =
-          BC.Ctx->createNamedTempSymbol("func_cold_const_island");
+          BC.Ctx->getOrCreateSymbol("func_cold_const_island@" + getOneName());
     }
     return Islands->FunctionColdConstantIslandLabel;
   }
 
   /// Return true if this is a function representing a PLT entry.
   bool isPLTFunction() const { return PLTSymbol != nullptr; }
 
   /// Return PLT function reference symbol for PLT functions and nullptr for
   /// non-PLT functions.
   const MCSymbol *getPLTSymbol() const { return PLTSymbol; }
 
   /// Set function PLT reference symbol for PLT functions.
   void setPLTSymbol(const MCSymbol *Symbol) {
     assert(Size == 0 && "function size should be 0 for PLT functions");
     PLTSymbol = Symbol;
     IsPseudo = true;
   }
 
   /// Update output values of the function based on the final \p Layout.
-  void updateOutputValues(const MCAsmLayout &Layout);
+  void updateOutputValues(const BOLTLinker &Linker);
 
   /// Register relocation type \p RelType at a given \p Address in the function
   /// against \p Symbol.
   /// Assert if the \p Address is not inside this function.
   void addRelocation(uint64_t Address, MCSymbol *Symbol, uint64_t RelType,
                      uint64_t Addend, uint64_t Value);
 
   /// Return the name of the section this function originated from.

bolt/include/bolt/Core/Linker.h

 class BinarySection;
 
 class BOLTLinker {
 public:
   using SectionMapper =
       std::function<void(const BinarySection &Section, uint64_t Address)>;
   using SectionsMapper = std::function<void(SectionMapper)>;
 
+  struct SymbolInfo {
+    uint64_t Address;
+    uint64_t Size;
+  };
+
   virtual ~BOLTLinker() = default;
 
   /// Load and link \p Obj. \p MapSections will be called before the object is
   /// linked to allow section addresses to be remapped. When called, the address
   /// of a section can be changed by calling the passed SectionMapper.
   virtual void loadObject(MemoryBufferRef Obj, SectionsMapper MapSections) = 0;
 
+  /// Return the address and size of a symbol or std::nullopt if it cannot be
+  /// found.
+  virtual std::optional<SymbolInfo> lookupSymbolInfo(StringRef Name) const = 0;
+
   /// Return the address of a symbol or std::nullopt if it cannot be found.
-  virtual std::optional<uint64_t> lookupSymbol(StringRef Name) const = 0;
+  std::optional<uint64_t> lookupSymbol(StringRef Name) const {
+    if (const auto Info = lookupSymbolInfo(Name))
+      return Info->Address;
+    return std::nullopt;
+  }
 };
 
 } // namespace bolt
 } // namespace llvm
 
 #endif // BOLT_CORE_LINKER_H

bolt/include/bolt/Rewrite/JITLinkLinker.h

 
 #ifndef BOLT_REWRITE_JITLINK_LINKER_H
 #define BOLT_REWRITE_JITLINK_LINKER_H
 
 #include "bolt/Core/Linker.h"
 #include "bolt/Rewrite/ExecutableFileMemoryManager.h"
 #include "llvm/ExecutionEngine/JITLink/JITLinkDylib.h"
 
-#include <map>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace bolt {
 
 class BinaryContext;
 
 class JITLinkLinker : public BOLTLinker {
 private:
   struct Context;
   friend struct Context;
 
   BinaryContext &BC;
   std::unique_ptr<ExecutableFileMemoryManager> MM;
   jitlink::JITLinkDylib Dylib{"main"};
   std::vector<ExecutableFileMemoryManager::FinalizedAlloc> Allocs;
-  std::map<std::string, uint64_t> Symtab;
+  StringMap<SymbolInfo> Symtab;
 
 public:
   JITLinkLinker(BinaryContext &BC,
                 std::unique_ptr<ExecutableFileMemoryManager> MM);
   ~JITLinkLinker();
 
   void loadObject(MemoryBufferRef Obj, SectionsMapper MapSections) override;
-  std::optional<uint64_t> lookupSymbol(StringRef Name) const override;
+  std::optional<SymbolInfo> lookupSymbolInfo(StringRef Name) const override;
 
   static SmallVector<jitlink::Block *, 2>
   orderedBlocks(const jitlink::Section &Section);
   static size_t sectionSize(const jitlink::Section &Section);
 };
 
 } // namespace bolt
 } // namespace llvm
 
 #endif // BOLT_REWRITE_JITLINK_LINKER_H

bolt/include/bolt/Rewrite/RewriteInstance.h

private:
 
   /// Map code sections generated by BOLT.
   void mapCodeSections(BOLTLinker::SectionMapper MapSection);
 
   /// Map the rest of allocatable sections.
   void mapAllocatableSections(BOLTLinker::SectionMapper MapSection);
 
   /// Update output object's values based on the final \p Layout.
-  void updateOutputValues(const MCAsmLayout &Layout);
+  void updateOutputValues(const BOLTLinker &Linker);
 
   /// Rewrite back all functions (hopefully optimized) that fit in the original
   /// memory footprint for that function. If the function is now larger and does
   /// not fit in the binary, reject it and preserve the original version of the
   /// function. If we couldn't understand the function for some reason in
   /// disassembleFunctions(), also preserve the original version.
   void rewriteFile();
 

bolt/lib/Core/BinaryBasicBlock.cpp

 //===- bolt/Core/BinaryBasicBlock.cpp - Low-level basic block -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the BinaryBasicBlock class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Core/BinaryBasicBlock.h"
 #include "bolt/Core/BinaryContext.h"
 #include "bolt/Core/BinaryFunction.h"
 #include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/Support/Errc.h"
 
 #define DEBUG_TYPE "bolt"
 
 namespace llvm {
 namespace bolt {
 

bolt/lib/Core/BinaryFunction.cpp

 #include "bolt/Utils/NameShortener.h"
 #include "bolt/Utils/Utils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/MC/MCAsmInfo.h"
-#include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Object/ObjectFile.h"
for (BinaryLoop::Edge &Exit : ExitEdges) {
           L->ExitCount += BI->Count;
         }
         ++BI;
       }
     }
   }
 }
 
-void BinaryFunction::updateOutputValues(const MCAsmLayout &Layout) {
+void BinaryFunction::updateOutputValues(const BOLTLinker &Linker) {
   if (!isEmitted()) {
     assert(!isInjected() && "injected function should be emitted");
     setOutputAddress(getAddress());
     setOutputSize(getSize());
     return;
   }
 
-  const uint64_t BaseAddress = getCodeSection()->getOutputAddress();
+  const auto SymbolInfo = Linker.lookupSymbolInfo(getSymbol()->getName());
+  assert(SymbolInfo && "Cannot find function entry symbol");
+  setOutputAddress(SymbolInfo->Address);
+  setOutputSize(SymbolInfo->Size);
+
   if (BC.HasRelocations || isInjected()) {
-    const uint64_t StartOffset = Layout.getSymbolOffset(*getSymbol());
-    const uint64_t EndOffset = Layout.getSymbolOffset(*getFunctionEndLabel());
-    setOutputAddress(BaseAddress + StartOffset);
-    setOutputSize(EndOffset - StartOffset);
     if (hasConstantIsland()) {
-      const uint64_t DataOffset =
-          Layout.getSymbolOffset(*getFunctionConstantIslandLabel());
-      setOutputDataAddress(BaseAddress + DataOffset);
+      const auto DataAddress =
+          Linker.lookupSymbol(getFunctionConstantIslandLabel()->getName());
+      assert(DataAddress && "Cannot find function CI symbol");
+      setOutputDataAddress(*DataAddress);
       for (auto It : Islands->Offsets) {
         const uint64_t OldOffset = It.first;
         BinaryData *BD = BC.getBinaryDataAtAddress(getAddress() + OldOffset);
         if (!BD)
           continue;
 
         MCSymbol *Symbol = It.second;
-        const uint64_t NewOffset = Layout.getSymbolOffset(*Symbol);
-        BD->setOutputLocation(*getCodeSection(), NewOffset);
+        const auto NewAddress = Linker.lookupSymbol(Symbol->getName());
+        assert(NewAddress && "Cannot find CI symbol");
+        auto &Section = *getCodeSection();
+        const auto NewOffset = *NewAddress - Section.getOutputAddress();
+        BD->setOutputLocation(Section, NewOffset);
       }
     }
     if (isSplit()) {
       for (FunctionFragment &FF : getLayout().getSplitFragments()) {
         ErrorOr<BinarySection &> ColdSection =
             getCodeSection(FF.getFragmentNum());
         // If fragment is empty, cold section might not exist
         if (FF.empty() && ColdSection.getError())
           continue;
-        const uint64_t ColdBaseAddress = ColdSection->getOutputAddress();
 
         const MCSymbol *ColdStartSymbol = getSymbol(FF.getFragmentNum());
         // If fragment is empty, symbol might have not been emitted
         if (FF.empty() && (!ColdStartSymbol || !ColdStartSymbol->isDefined()) &&
             !hasConstantIsland())
           continue;
         assert(ColdStartSymbol && ColdStartSymbol->isDefined() &&
                "split function should have defined cold symbol");
-        const MCSymbol *ColdEndSymbol =
-            getFunctionEndLabel(FF.getFragmentNum());
-        assert(ColdEndSymbol && ColdEndSymbol->isDefined() &&
-               "split function should have defined cold end symbol");
-        const uint64_t ColdStartOffset =
-            Layout.getSymbolOffset(*ColdStartSymbol);
-        const uint64_t ColdEndOffset = Layout.getSymbolOffset(*ColdEndSymbol);
-        FF.setAddress(ColdBaseAddress + ColdStartOffset);
-        FF.setImageSize(ColdEndOffset - ColdStartOffset);
+        const auto ColdStartSymbolInfo =
+            Linker.lookupSymbolInfo(ColdStartSymbol->getName());
+        assert(ColdStartSymbolInfo && "Cannot find cold start symbol");
+        FF.setAddress(ColdStartSymbolInfo->Address);
+        FF.setImageSize(ColdStartSymbolInfo->Size);
         if (hasConstantIsland()) {
-          const uint64_t DataOffset =
-              Layout.getSymbolOffset(*getFunctionColdConstantIslandLabel());
-          setOutputColdDataAddress(ColdBaseAddress + DataOffset);
+          const auto DataAddress = Linker.lookupSymbol(
+              getFunctionColdConstantIslandLabel()->getName());
+          assert(DataAddress && "Cannot find cold CI symbol");
+          setOutputColdDataAddress(*DataAddress);
         }
       }
     }
-  } else {
-    setOutputAddress(getAddress());
-    setOutputSize(Layout.getSymbolOffset(*getFunctionEndLabel()));
   }
 
   // Update basic block output ranges for the debug info, if we have
   // secondary entry points in the symbol table to update or if writing BAT.
-  if (!opts::UpdateDebugSections && !isMultiEntry() &&
-      !requiresAddressTranslation())
+  if (!requiresAddressMap())
     return;
 
   // Output ranges should match the input if the body hasn't changed.
   if (!isSimple() && !BC.HasRelocations)
     return;
 
   // AArch64 may have functions that only contains a constant island (no code).
   if (getLayout().block_empty())

bolt/lib/Rewrite/JITLinkLinker.cpp

struct JITLinkLinker::Context : jitlink::JITLinkContext {
   }
 
   Error notifyResolved(jitlink::LinkGraph &G) override {
     MapSections([&G](const BinarySection &Section, uint64_t Address) {
       reassignSectionAddress(G, Section, Address);
     });
 
     for (auto *Symbol : G.defined_symbols()) {
-      Linker.Symtab.insert(
-          {Symbol->getName().str(), Symbol->getAddress().getValue()});
+      SymbolInfo Info{Symbol->getAddress().getValue(), Symbol->getSize()};
+      Linker.Symtab.insert({Symbol->getName().str(), Info});
     }
 
     return Error::success();
   }
 
   void notifyFinalized(
       jitlink::JITLinkMemoryManager::FinalizedAlloc Alloc) override {
     Linker.Allocs.push_back(std::move(Alloc));
if (auto E = LG.takeError()) {
     errs() << "BOLT-ERROR: JITLink failed: " << E << '\n';
     exit(1);
   }
 
   auto Ctx = std::make_unique<Context>(*this, MapSections);
   jitlink::link(std::move(*LG), std::move(Ctx));
 }
 
-std::optional<uint64_t> JITLinkLinker::lookupSymbol(StringRef Name) const {
+std::optional<JITLinkLinker::SymbolInfo>
+JITLinkLinker::lookupSymbolInfo(StringRef Name) const {
   auto It = Symtab.find(Name.data());
   if (It == Symtab.end())
     return std::nullopt;
 
   return It->second;
 }
 
 SmallVector<jitlink::Block *, 2>

bolt/lib/Rewrite/MachORewriteInstance.cpp

 #include "bolt/Passes/Instrumentation.h"
 #include "bolt/Passes/PatchEntries.h"
 #include "bolt/Profile/DataReader.h"
 #include "bolt/Rewrite/BinaryPassManager.h"
 #include "bolt/Rewrite/ExecutableFileMemoryManager.h"
 #include "bolt/Rewrite/JITLinkLinker.h"
 #include "bolt/RuntimeLibs/InstrumentationRuntimeLibrary.h"
 #include "bolt/Utils/Utils.h"
-#include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include <memory>
 #include <optional>
 
 namespace opts {
void MachORewriteInstance::emitAndLink() {
 
   std::unique_ptr<MemoryBuffer> ObjectMemBuffer =
       MemoryBuffer::getMemBuffer(BOS->str(), "in-memory object file", false);
   std::unique_ptr<object::ObjectFile> Obj = cantFail(
       object::ObjectFile::createObjectFile(ObjectMemBuffer->getMemBufferRef()),
       "error creating in-memory object");
   assert(Obj && "createObjectFile cannot return nullptr");
 
-  MCAsmLayout FinalLayout(
-      static_cast<MCObjectStreamer *>(Streamer.get())->getAssembler());
-
   auto EFMM = std::make_unique<ExecutableFileMemoryManager>(*BC);
   EFMM->setNewSecPrefix(getNewSecPrefix());
   EFMM->setOrgSecPrefix(getOrgSecPrefix());
 
   Linker = std::make_unique<JITLinkLinker>(*BC, std::move(EFMM));
   Linker->loadObject(ObjectMemBuffer->getMemBufferRef(),
                      [this](auto MapSection) {
                        // Assign addresses to all sections. If key corresponds

bolt/lib/Rewrite/RewriteInstance.cpp

void RewriteInstance::emitAndLink() {
   auto EFMM = std::make_unique<ExecutableFileMemoryManager>(*BC);
   EFMM->setNewSecPrefix(getNewSecPrefix());
   EFMM->setOrgSecPrefix(getOrgSecPrefix());
 
   Linker = std::make_unique<JITLinkLinker>(*BC, std::move(EFMM));
   Linker->loadObject(ObjectMemBuffer->getMemBufferRef(),
                      [this](auto MapSection) { mapFileSections(MapSection); });
 
-  MCAsmLayout FinalLayout(
-      static_cast<MCObjectStreamer *>(Streamer.get())->getAssembler());
-
   // Update output addresses based on the new section map and
   // layout. Only do this for the object created by ourselves.
-  updateOutputValues(FinalLayout);
+  updateOutputValues(*Linker);
 
-  if (opts::UpdateDebugSections)
+  if (opts::UpdateDebugSections) {
+    MCAsmLayout FinalLayout(
+        static_cast<MCObjectStreamer *>(Streamer.get())->getAssembler());
     DebugInfoRewriter->updateLineTableOffsets(FinalLayout);
+  }
 
   if (RuntimeLibrary *RtLibrary = BC->getRuntimeLibrary())
     RtLibrary->link(*BC, ToolPath, *Linker, [this](auto MapSection) {
       // Map newly registered sections.
       this->mapAllocatableSections(MapSection);
     });
 
   // Once the code is emitted, we can rename function sections to actual
if (SType == ST_READONLY) {
       NewWritableSegmentSize = NextAvailableAddress - NewWritableSegmentAddress;
       // Restore NextAvailableAddress if no new writable sections
       if (!NewWritableSegmentSize)
         NextAvailableAddress = LastNextAvailableAddress;
     }
   }
 }
 
-void RewriteInstance::updateOutputValues(const MCAsmLayout &Layout) {
+void RewriteInstance::updateOutputValues(const BOLTLinker &Linker) {
   if (auto MapSection = BC->getUniqueSectionByName(AddressMap::SectionName)) {
     auto Map = AddressMap::parse(MapSection->getOutputContents(), *BC);
     BC->setIOAddressMap(std::move(Map));
     BC->deregisterSection(*MapSection);
   }
 
   for (BinaryFunction *Function : BC->getAllBinaryFunctions())
-    Function->updateOutputValues(Layout);
+    Function->updateOutputValues(Linker);
 }
 
 void RewriteInstance::patchELFPHDRTable() {
   auto ELF64LEFile = cast<ELF64LEObjectFile>(InputFile);
   const ELFFile<ELF64LE> &Obj = ELF64LEFile->getELFFile();
   raw_fd_ostream &OS = Out->os();
 
   // Write/re-write program headers.