LLVM and SPIRV-LLVM-Translator pulldown (WW34)

.github/workflows/sync-release-repo.yml

@@ -0,0 +1,17 @@
+name: Sync Release Repositories
+permissions:
+  contents: write
+on:
+  workflow_dispatch
+env:
+  RELEASE_BRANCH: release/17.x
+  GH_TOKEN: ${{ secrets.RELEASE_WORKFLOW_PUSH_SECRET }}
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Fetch LLVM sources
+        uses: actions/checkout@v3
+      - name: Run Sync Script
+        run: |
+          llvm/utils/git/sync-release-repo.sh

bolt/README.md

@@ -30,14 +30,6 @@ compiler option. Since GCC8 enables this option by default, you have to
 explicitly disable it by adding `-fno-reorder-blocks-and-partition` flag if
 you are compiling with GCC8 or above.
 
-NOTE2: DWARF v5 is the new debugging format generated by the latest LLVM and GCC
-compilers. It offers several benefits over the previous DWARF v4. Currently, the
-support for v5 is a work in progress for BOLT. While you will be able to
-optimize binaries produced by the latest compilers, until the support is
-complete, you will not be able to update the debug info with
-`-update-debug-sections`. To temporarily work around the issue, we recommend
-compiling binaries with `-gdwarf-4` option that forces DWARF v4 output.
-
 PIE and .so support has been added recently. Please report bugs if you
 encounter any issues.
 

bolt/include/bolt/Core/AddressMap.h

@@ -0,0 +1,59 @@
+//===- bolt/Core/AddressMap.h - Input-output address map --------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Helper class to create a mapping from input to output addresses needed for
+// updating debugging symbols and BAT. We emit an MCSection containing
+// <Input address, Output MCSymbol> pairs to the object file and JITLink will
+// transform this in <Input address, Output address> pairs. The linker output
+// can then be parsed and used to establish the mapping.
+//
+//===----------------------------------------------------------------------===//
+//
+#ifndef BOLT_CORE_ADDRESS_MAP_H
+#define BOLT_CORE_ADDRESS_MAP_H
+
+#include "llvm/ADT/StringRef.h"
+
+#include <optional>
+#include <unordered_map>
+
+namespace llvm {
+
+class MCStreamer;
+
+namespace bolt {
+
+class BinaryContext;
+
+class AddressMap {
+  using MapTy = std::unordered_multimap<uint64_t, uint64_t>;
+  MapTy Map;
+
+public:
+  static const char *const SectionName;
+
+  static void emit(MCStreamer &Streamer, BinaryContext &BC);
+  static AddressMap parse(StringRef Buffer, const BinaryContext &BC);
+
+  std::optional<uint64_t> lookup(uint64_t InputAddress) const {
+    auto It = Map.find(InputAddress);
+    if (It != Map.end())
+      return It->second;
+    return std::nullopt;
+  }
+
+  std::pair<MapTy::const_iterator, MapTy::const_iterator>
+  lookupAll(uint64_t InputAddress) const {
+    return Map.equal_range(InputAddress);
+  }
+};
+
+} // namespace bolt
+} // namespace llvm
+
+#endif

bolt/include/bolt/Core/BinaryBasicBlock.h

@@ -100,16 +100,6 @@ class BinaryBasicBlock {
   using LocSymsTy = std::vector<std::pair<uint32_t, const MCSymbol *>>;
   std::unique_ptr<LocSymsTy> LocSyms;
 
-  /// After output/codegen, map output offsets of instructions in this basic
-  /// block to instruction offsets in the original function. Note that the
-  /// output basic block could be different from the input basic block.
-  /// We only map instruction of interest, such as calls and markers.
-  ///
-  /// We store the offset array in a basic block to facilitate BAT tables
-  /// generation. Otherwise, the mapping could be done at function level.
-  using OffsetTranslationTableTy = std::vector<std::pair<uint32_t, uint32_t>>;
-  std::unique_ptr<OffsetTranslationTableTy> OffsetTranslationTable;
-
   /// Alignment requirements for the block.
   uint32_t Alignment{1};
 
@@ -828,8 +818,7 @@ class BinaryBasicBlock {
     return OutputAddressRange;
   }
 
-  /// Update addresses of special instructions inside this basic block.
-  void updateOutputValues(const MCAsmLayout &Layout);
+  bool hasLocSyms() const { return LocSyms != nullptr; }
 
   /// Return mapping of input offsets to symbols in the output.
   LocSymsTy &getLocSyms() {
@@ -841,19 +830,6 @@ class BinaryBasicBlock {
     return const_cast<BinaryBasicBlock *>(this)->getLocSyms();
   }
 
-  /// Return offset translation table for the basic block.
-  OffsetTranslationTableTy &getOffsetTranslationTable() {
-    return OffsetTranslationTable
-               ? *OffsetTranslationTable
-               : *(OffsetTranslationTable =
-                       std::make_unique<OffsetTranslationTableTy>());
-  }
-
-  /// Return offset translation table for the basic block.
-  const OffsetTranslationTableTy &getOffsetTranslationTable() const {
-    return const_cast<BinaryBasicBlock *>(this)->getOffsetTranslationTable();
-  }
-
   /// Return size of the basic block in the output binary.
   uint64_t getOutputSize() const {
     return OutputAddressRange.second - OutputAddressRange.first;

bolt/include/bolt/Core/BinaryContext.h

@@ -13,6 +13,7 @@
 #ifndef BOLT_CORE_BINARY_CONTEXT_H
 #define BOLT_CORE_BINARY_CONTEXT_H
 
+#include "bolt/Core/AddressMap.h"
 #include "bolt/Core/BinaryData.h"
 #include "bolt/Core/BinarySection.h"
 #include "bolt/Core/DebugData.h"
@@ -221,6 +222,9 @@ class BinaryContext {
   bool ContainsDwarf5{false};
   bool ContainsDwarfLegacy{false};
 
+  /// Mapping from input to output addresses.
+  std::optional<AddressMap> IOAddressMap;
+
   /// Preprocess DWO debug information.
   void preprocessDWODebugInfo();
 
@@ -1343,6 +1347,12 @@ class BinaryContext {
         /* DWARFMustBeAtTheEnd */ false));
     return Streamer;
   }
+
+  void setIOAddressMap(AddressMap Map) { IOAddressMap = std::move(Map); }
+  const AddressMap &getIOAddressMap() const {
+    assert(IOAddressMap && "Address map not set yet");
+    return *IOAddressMap;
+  }
 };
 
 template <typename T, typename = std::enable_if_t<sizeof(T) == 1>>

bolt/include/bolt/Core/BinaryFunction.h

@@ -366,14 +366,15 @@ class BinaryFunction {
   std::string ColdCodeSectionName;
 
   /// Parent function fragment for split function fragments.
-  SmallPtrSet<BinaryFunction *, 1> ParentFragments;
+  using FragmentsSetTy = SmallPtrSet<BinaryFunction *, 1>;
+  FragmentsSetTy ParentFragments;
 
   /// Indicate if the function body was folded into another function.
   /// Used by ICF optimization.
   BinaryFunction *FoldedIntoFunction{nullptr};
 
   /// All fragments for a parent function.
-  SmallPtrSet<BinaryFunction *, 1> Fragments;
+  FragmentsSetTy Fragments;
 
   /// The profile data for the number of times the function was executed.
   uint64_t ExecutionCount{COUNT_NO_PROFILE};
@@ -576,9 +577,6 @@ class BinaryFunction {
   /// Count the number of functions created.
   static uint64_t Count;
 
-  /// Map offsets of special instructions to addresses in the output.
-  InputOffsetToAddressMapTy InputOffsetToAddressMap;
-
   /// Register alternative function name.
   void addAlternativeName(std::string NewName) {
     Aliases.push_back(std::move(NewName));
@@ -1225,13 +1223,6 @@ class BinaryFunction {
   /// Update output values of the function based on the final \p Layout.
   void updateOutputValues(const MCAsmLayout &Layout);
 
-  /// Return mapping of input to output addresses. Most users should call
-  /// translateInputToOutputAddress() for address translation.
-  InputOffsetToAddressMapTy &getInputOffsetToAddressMap() {
-    assert(isEmitted() && "cannot use address mapping before code emission");
-    return InputOffsetToAddressMap;
-  }
-
   /// 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.
@@ -1779,6 +1770,15 @@ class BinaryFunction {
     return llvm::is_contained(Fragments, &Other);
   }
 
+  /// Return the child fragment form parent function
+  iterator_range<FragmentsSetTy::const_iterator> getFragments() const {
+    return iterator_range<FragmentsSetTy::const_iterator>(Fragments.begin(),
+                                                          Fragments.end());
+  }
+
+  /// Return the parent function for split function fragments.
+  FragmentsSetTy *getParentFragments() { return &ParentFragments; }
+
   /// Returns if this function is a parent or child of \p Other function.
   bool isParentOrChildOf(const BinaryFunction &Other) const {
     return isChildOf(Other) || isParentOf(Other);
@@ -2170,6 +2170,11 @@ class BinaryFunction {
   /// its code emission.
   bool requiresAddressTranslation() const;
 
+  /// Return true if the linker needs to generate an address map for this
+  /// function. Used for keeping track of the mapping from input to out
+  /// addresses of basic blocks.
+  bool requiresAddressMap() const;
+
   /// Adjust branch instructions to match the CFG.
   ///
   /// As it comes to internal branches, the CFG represents "the ultimate source

bolt/include/bolt/Core/BinarySection.h

@@ -97,6 +97,8 @@ class BinarySection {
   mutable bool IsReordered{false}; // Have the contents been reordered?
   bool IsAnonymous{false};         // True if the name should not be included
                                    // in the output file.
+  bool IsLinkOnly{false};          // True if the section should not be included
+                                   // in the output file.
 
   uint64_t hash(const BinaryData &BD,
                 std::map<const BinaryData *, uint64_t> &Cache) const;
@@ -452,6 +454,8 @@ class BinarySection {
   void setIndex(uint32_t I) { Index = I; }
   void setOutputName(const Twine &Name) { OutputName = Name.str(); }
   void setAnonymous(bool Flag) { IsAnonymous = Flag; }
+  bool isLinkOnly() const { return IsLinkOnly; }
+  void setLinkOnly() { IsLinkOnly = true; }
 
   /// Emit the section as data, possibly with relocations.
   /// Use name \p SectionName for the section during the emission.

bolt/include/bolt/Core/DIEBuilder.h

@@ -21,12 +21,12 @@
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Support/Allocator.h"
-#include "llvm/Support/ErrorHandling.h"
 
 #include <list>
 #include <memory>
 #include <optional>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 namespace llvm {
@@ -113,6 +113,7 @@ class DIEBuilder {
     std::vector<LocWithReference> LocWithReferencesToProcess;
     BumpPtrAllocator DIEAlloc;
     ProcessingType Type;
+    std::unordered_set<uint64_t> DWARFDieAddressesParsed;
   };
 
   std::unique_ptr<State> BuilderState;

bolt/include/bolt/Core/DebugData.h

@@ -313,9 +313,6 @@ class DebugAddrWriter {
   /// Adds Address to map.
   uint32_t getIndexFromAddress(uint64_t Address, DWARFUnit &CU);
 
-  /// Adds {\p Address, \p Index} to \p CU.
-  void addIndexAddress(uint64_t Address, uint32_t Index, DWARFUnit &CU);
-
   /// Write out entries in to .debug_addr section for CUs.
   virtual void update(DIEBuilder &DIEBlder, DWARFUnit &CUs);
 

bolt/lib/Core/AddressMap.cpp

@@ -0,0 +1,63 @@
+#include "bolt/Core/AddressMap.h"
+#include "bolt/Core/BinaryContext.h"
+#include "bolt/Core/BinaryFunction.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/Support/DataExtractor.h"
+
+namespace llvm {
+namespace bolt {
+
+const char *const AddressMap::SectionName = ".bolt.address_map";
+
+static void emitLabel(MCStreamer &Streamer, uint64_t InputAddress,
+                      const MCSymbol *OutputLabel) {
+  Streamer.emitIntValue(InputAddress, 8);
+  Streamer.emitSymbolValue(OutputLabel, 8);
+}
+
+void AddressMap::emit(MCStreamer &Streamer, BinaryContext &BC) {
+  Streamer.switchSection(BC.getDataSection(SectionName));
+
+  for (const auto &[BFAddress, BF] : BC.getBinaryFunctions()) {
+    if (!BF.requiresAddressMap())
+      continue;
+
+    for (const auto &BB : BF) {
+      if (!BB.getLabel()->isDefined())
+        continue;
+
+      emitLabel(Streamer, BFAddress + BB.getInputAddressRange().first,
+                BB.getLabel());
+
+      if (!BB.hasLocSyms())
+        continue;
+
+      for (auto [Offset, Symbol] : BB.getLocSyms())
+        emitLabel(Streamer, BFAddress + Offset, Symbol);
+    }
+  }
+}
+
+AddressMap AddressMap::parse(StringRef Buffer, const BinaryContext &BC) {
+  const auto EntrySize = 2 * BC.AsmInfo->getCodePointerSize();
+  assert(Buffer.size() % EntrySize == 0 && "Unexpected address map size");
+
+  DataExtractor DE(Buffer, BC.AsmInfo->isLittleEndian(),
+                   BC.AsmInfo->getCodePointerSize());
+  DataExtractor::Cursor Cursor(0);
+
+  AddressMap Parsed;
+  Parsed.Map.reserve(Buffer.size() / EntrySize);
+
+  while (Cursor && !DE.eof(Cursor)) {
+    const auto Input = DE.getAddress(Cursor);
+    const auto Output = DE.getAddress(Cursor);
+    Parsed.Map.insert({Input, Output});
+  }
+
+  assert(Cursor && "Error reading address map section");
+  return Parsed;
+}
+
+} // namespace bolt
+} // namespace llvm

bolt/lib/Core/BinaryBasicBlock.cpp

@@ -613,27 +613,5 @@ BinaryBasicBlock *BinaryBasicBlock::splitAt(iterator II) {
   return NewBlock;
 }
 
-void BinaryBasicBlock::updateOutputValues(const MCAsmLayout &Layout) {
-  if (!LocSyms)
-    return;
-
-  const uint64_t BBAddress = getOutputAddressRange().first;
-  const uint64_t BBOffset = Layout.getSymbolOffset(*getLabel());
-  for (const auto &LocSymKV : *LocSyms) {
-    const uint32_t InputFunctionOffset = LocSymKV.first;
-    const uint32_t OutputOffset = static_cast<uint32_t>(
-        Layout.getSymbolOffset(*LocSymKV.second) - BBOffset);
-    getOffsetTranslationTable().emplace_back(
-        std::make_pair(OutputOffset, InputFunctionOffset));
-
-    // Update reverse (relative to BAT) address lookup table for function.
-    if (getFunction()->requiresAddressTranslation()) {
-      getFunction()->getInputOffsetToAddressMap().emplace(
-          std::make_pair(InputFunctionOffset, OutputOffset + BBAddress));
-    }
-  }
-  LocSyms.reset(nullptr);
-}
-
 } // namespace bolt
 } // namespace llvm

bolt/lib/Core/BinaryEmitter.cpp

@@ -214,6 +214,10 @@ void BinaryEmitter::emitAll(StringRef OrgSecPrefix) {
   }
 
   emitDataSections(OrgSecPrefix);
+
+  // TODO Enable for Mach-O once BinaryContext::getDataSection supports it.
+  if (BC.isELF())
+    AddressMap::emit(Streamer, BC);
 }
 
 void BinaryEmitter::emitFunctions() {