LLVM and SPIRV-LLVM-Translator pulldown (WW42 2026)

bolt/docs/conf.py

@@ -15,7 +15,7 @@
 
 from llvm_sphinx import *  # see llvm-project/utils/docs/README.md
 
-globals().update(common_conf(tags, markdown=Markdown.NEVER))
+globals().update(common_conf(tags))
 
 # -- General configuration -----------------------------------------------------
 

bolt/include/bolt/Core/BinaryContext.h

@@ -24,6 +24,7 @@
 #include "llvm/ADT/AddressRanges.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/EquivalenceClasses.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
@@ -949,6 +950,10 @@ class BinaryContext {
   /// and are referenced from BinaryFunction.
   std::list<std::pair<BinaryFunction *, uint64_t>> InterproceduralReferences;
 
+  /// Invalid external branch targets discovered during validation.
+  DenseSet<std::pair<BinaryFunction *, uint64_t>>
+      InvalidInterproceduralReferences;
+
   /// DWARF encoding. Available encoding types defined in BinaryFormat/Dwarf.h
   /// enum Constants, e.g. DW_EH_PE_omit.
   unsigned LSDAEncoding = dwarf::DW_EH_PE_omit;
@@ -1061,8 +1066,9 @@ class BinaryContext {
   /// point.
   ///
   /// This function also performs validations: If \p Address points to an
-  /// invalid instruction or lies within a constant island, return nullptr and
-  /// mark both \p Source and \p Target as ignored.
+  /// invalid instruction or lies within a constant island, return nullptr. The
+  /// caller is responsible for marking \p Source and \p Target as ignored
+  /// after all relevant references have been validated.
   MCSymbol *handleExternalBranchTarget(uint64_t Address, BinaryFunction &Source,
                                        BinaryFunction &Target);
 
@@ -1206,6 +1212,9 @@ class BinaryContext {
     return ".text.injected.cold";
   }
 
+  /// Return true if \p A should be emitted before \p B in code section order.
+  bool compareSectionNames(StringRef A, StringRef B) const;
+
   ErrorOr<BinarySection &> getGdbIndexSection() const {
     return getUniqueSectionByName(".gdb_index");
   }
@@ -1460,9 +1469,10 @@ class BinaryContext {
   }
 
   /// Register dynamic relocation at \p Address.
-  void addDynamicRelocation(uint64_t Address, MCSymbol *Symbol, uint32_t Type,
-                            uint64_t Addend, uint64_t Value = 0,
-                            bool IsRELR = false);
+  void addDynamicRelocation(
+      uint64_t Address, MCSymbol *Symbol, uint32_t Type, uint64_t Addend,
+      uint64_t Value = 0, bool IsRELR = false,
+      uint32_t JmpRelocationIndex = Relocation::NoJmpRelocationIndex);
 
   /// Return a dynamic relocation registered at a given \p Address, or nullptr
   /// if there is no dynamic relocation at such address.

bolt/include/bolt/Core/BinaryFunction.h

@@ -394,6 +394,9 @@ class BinaryFunction {
   /// True if the function is used for patching code at a fixed address.
   bool IsPatch{false};
 
+  /// True if the function is a synthetic branch/call thunk.
+  bool IsThunk{false};
+
   /// True if the original entry point of the function may get called, but the
   /// original body cannot be executed and needs to be patched with code that
   /// redirects execution to the new function body.
@@ -402,10 +405,6 @@ class BinaryFunction {
   /// True if the function should not have an associated symbol table entry.
   bool IsAnonymous{false};
 
-  /// Indicates whether branch validation has already been performed,
-  /// to avoid redundant processing.
-  bool NeedBranchValidation{true};
-
   /// Name for the section this function code should reside in. When unset, the
   /// default name is derived on demand from the function's name (see
   /// getMainSectionName()). Deferring this avoids eagerly storing a copy of the
@@ -905,6 +904,12 @@ class BinaryFunction {
   /// Returns whether there are any labels at Offset.
   bool hasLabelAt(unsigned Offset) const { return Labels.count(Offset) != 0; }
 
+  /// Return the label at \p Offset, or nullptr if none exists.
+  MCSymbol *getLabelAtOffset(unsigned Offset) const {
+    auto It = Labels.find(Offset);
+    return It == Labels.end() ? nullptr : It->second;
+  }
+
   /// Iterate over all jump tables associated with this function.
   iterator_range<std::map<uint64_t, JumpTable *>::const_iterator>
   jumpTables() const {
@@ -1504,6 +1509,9 @@ class BinaryFunction {
   /// Return true if this function is used for patching existing code.
   bool isPatch() const { return IsPatch; }
 
+  /// Return true if this function is a synthetic branch/call thunk.
+  bool isThunk() const { return IsThunk; }
+
   /// Return true if the function requires a patch.
   bool needsPatch() const { return NeedsPatch; }
 
@@ -1941,6 +1949,12 @@ class BinaryFunction {
     IsPatch = V;
   }
 
+  /// Indicate that this function is a synthetic branch/call thunk.
+  void setIsThunk(bool V) {
+    assert(isInjected() && "Only injected functions can be used as thunks");
+    IsThunk = V;
+  }
+
   /// Mark the function for patching.
   void setNeedsPatch(bool V) { NeedsPatch = V; }
 

bolt/include/bolt/Core/BinarySection.h

@@ -365,11 +365,12 @@ class BinarySection {
   }
 
   /// Add a dynamic relocation at the given /p Offset.
-  void addDynamicRelocation(uint64_t Offset, MCSymbol *Symbol, uint32_t Type,
-                            uint64_t Addend, uint64_t Value = 0,
-                            bool IsRELR = false) {
-    addDynamicRelocation(
-        Relocation{Offset, Symbol, Type, Addend, Value, IsRELR});
+  void addDynamicRelocation(
+      uint64_t Offset, MCSymbol *Symbol, uint32_t Type, uint64_t Addend,
+      uint64_t Value = 0, bool IsRELR = false,
+      uint32_t JmpRelocationIndex = Relocation::NoJmpRelocationIndex) {
+    addDynamicRelocation(Relocation{Offset, Symbol, Type, Addend, Value, IsRELR,
+                                    JmpRelocationIndex});
   }
 
   void addDynamicRelocation(const Relocation &Reloc) {

bolt/include/bolt/Core/DebugNames.h

@@ -109,6 +109,10 @@ class DWARF5AcceleratorTable {
     uint32_t HashValue;
     uint64_t EntryOffset;
     std::vector<BOLTDWARF5AccelTableData *> Values;
+    /// Points at the name this entry was keyed by. Invalid before finalize()
+    const std::string *Name = nullptr;
+    /// New name (not in .debug_str). StrOffset is invalid before finalize()
+    bool NeedsStrOffset = false;
   };
   using HashList = std::vector<HashData *>;
   using BucketList = std::vector<HashList>;
@@ -170,6 +174,8 @@ class DWARF5AcceleratorTable {
   getSecondIndexForEntry(const BOLTDWARF5AccelTableData &Value) const;
   /// Uniquify Entries.
   void finalize();
+  /// Append the new names that are not already in .debug_str
+  void assignStrOffsets();
   /// Computes bucket count.
   void computeBucketCount();
   /// Populate Abbreviations Map.

bolt/include/bolt/Core/MCPlusBuilder.h

@@ -1958,6 +1958,15 @@ class MCPlusBuilder {
     return {};
   }
 
+  /// Materializing \p ConstantData value in the target register of \p Inst
+  virtual InstructionListType materializeConstant(BinaryContext &BC,
+                                                  const MCInst &Inst,
+                                                  StringRef ConstantData,
+                                                  uint64_t Offset) const {
+    llvm_unreachable("not implemented");
+    return {};
+  }
+
   /// Creates a new unconditional branch instruction in Inst and set its operand
   /// to TBB.
   virtual void createUncondBranch(MCInst &Inst, const MCSymbol *TBB,

bolt/include/bolt/Core/Relocation.h

@@ -37,17 +37,21 @@ namespace bolt {
 /// Relocation class.
 class Relocation {
 public:
+  static constexpr uint32_t NoJmpRelocationIndex = (1u << 30) - 1;
+
   Relocation(uint64_t Offset, MCSymbol *Symbol, uint32_t Type, uint64_t Addend,
-             uint64_t Value, bool IsRELR = false)
-      : Offset(Offset), Symbol(Symbol), Type(Type), Optional(false),
-        IsRELR(IsRELR), Addend(Addend), Value(Value) {
+             uint64_t Value, bool IsRELR = false,
+             uint32_t JmpRelocationIndex = NoJmpRelocationIndex)
+      : Offset(Offset), Symbol(Symbol), Addend(Addend), Value(Value),
+        Type(Type), JmpRelocationIndex(JmpRelocationIndex), Optional(false),
+        IsRELR(IsRELR) {
     assert((isRelative() || !isRELR()) &&
            "Only relative relocations can be relr.");
   }
 
   Relocation()
-      : Offset(0), Symbol(0), Type(0), Optional(0), IsRELR(0), Addend(0),
-        Value(0) {}
+      : Offset(0), Symbol(0), Addend(0), Value(0), Type(0),
+        JmpRelocationIndex(NoJmpRelocationIndex), Optional(0), IsRELR(0) {}
 
   static Triple::ArchType Arch; /// set by BinaryContext ctor.
 
@@ -57,27 +61,40 @@ class Relocation {
   /// The symbol this relocation is referring to.
   MCSymbol *Symbol;
 
+  /// The offset from the \p Symbol base used to compute the final
+  /// value of this relocation.
+  uint64_t Addend;
+
+  /// The computed relocation value extracted from the binary file.
+  /// Used to validate relocation correctness.
+  uint64_t Value;
+
   /// Relocation type.
   uint32_t Type;
 
 private:
+  /// Original index in DT_JMPREL, or NoJmpRelocationIndex for relocations
+  /// originating from other relocation tables.
+  uint32_t JmpRelocationIndex : 30;
+
   /// Relocations added by optimizations can be optional, meaning they can be
   /// omitted under certain circumstances.
-  bool Optional = false;
+  uint32_t Optional : 1;
 
   /// Track which relocations originate from a relr section. Emit these
   /// exclusively into the relr section and do not accidentally promote relative
   /// rela entries, because that would require growing the relr section.
-  bool IsRELR = false;
+  uint32_t IsRELR : 1;
 
 public:
-  /// The offset from the \p Symbol base used to compute the final
-  /// value of this relocation.
-  uint64_t Addend;
+  bool isJmpRelocation() const {
+    return JmpRelocationIndex != NoJmpRelocationIndex;
+  }
 
-  /// The computed relocation value extracted from the binary file.
-  /// Used to validate relocation correctness.
-  uint64_t Value;
+  uint32_t getJmpRelocationIndex() const {
+    assert(isJmpRelocation() && "not a DT_JMPREL relocation");
+    return JmpRelocationIndex;
+  }
 
   /// Return size in bytes of the given relocation \p Type.
   static size_t getSizeForType(uint32_t Type);

bolt/include/bolt/Passes/LongJmp.h

@@ -10,6 +10,7 @@
 #define BOLT_PASSES_LONGJMP_H
 
 #include "bolt/Passes/BinaryPasses.h"
+#include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
 namespace bolt {
@@ -80,46 +81,8 @@ class LongJmpPass : public BinaryFunctionPass {
   bool relaxLocalBranches(BinaryFunction &BF,
                           const BranchLivenessInfo *BLI = nullptr);
 
-  /// A group of functions that are located within the longest direct
-  /// branch/call instruction distance. Functions within the cluster do not
-  /// require a thunk for calls in the same cluster. The cluster may include
-  /// a set of thunks for covering calls to functions outside.
-  struct FunctionCluster {
-    /// All functions in this cluster.
-    DenseSet<BinaryFunction *> Functions;
-
-    /// Symbols corresponding to entry points of functions that this cluster
-    /// calls. Note that it excludes all functions in the cluster itself.
-    DenseSet<const MCSymbol *> Callees;
-
-    /// Estimated size of the cluster in bytes.
-    uint64_t Size{0};
-
-    /// The index of the last function in the cluster. Used as an insertion
-    /// point for adding thunks to the output function list.
-    size_t LastFunctionIndex = -1;
-
-    /// When placing hot code at the end of the binary, track the first function
-    /// for insertion purposes.
-    size_t FirstFunctionIndex = -1;
-
-    /// Thunks located at the end of this cluster.
-    BinaryFunctionListType ThunkList;
-
-    /// Thunks used by this cluster. Some could be in a ThunkList of the
-    /// preceding cluster.
-    ///
-    /// <Function Symbol> -> <Thunk Function>.
-    DenseMap<const MCSymbol *, BinaryFunction *> Thunks;
-  };
-
-  /// Maximum size of combined regular functions in the cluster. Note that it's
-  /// less than 128MB, because the size of the cluster plus its thunks should be
-  /// less than 128MB.
-  static constexpr uint64_t MaxClusterSize = 125 * 1024 * 1024;
-
-  /// Relax calls using function cluster approach.
-  void relaxCalls(BinaryContext &BC);
+  /// Relax calls and direct unconditional branches using one cluster layout.
+  void relaxWithClusters(BinaryContext &BC);
 
   ///                 -- Layout estimation methods --
   /// Try to do layout before running the emitter, by looking at BinaryFunctions

bolt/include/bolt/Rewrite/RewriteInstance.h

@@ -23,8 +23,10 @@
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Regex.h"
 #include <map>
+#include <optional>
 #include <set>
 #include <unordered_map>
+#include <utility>
 
 namespace llvm {
 
@@ -241,10 +243,15 @@ class RewriteInstance {
   /// Used by non-relocation mode and for patched functions.
   void rewriteFunctionsInPlace(raw_fd_ostream &OS);
 
-  /// When --use-old-text reuses input file regions, zero the alignment
-  /// padding after BOLT-written text sections so the output does not retain
-  /// stale bytes from the input binary.
-  void zeroPaddingForReusedSections(raw_fd_ostream &OS);
+  /// Return the input file range [Start, End) that BOLT reuses for new
+  /// content (like with --use-old-text). Return std::nullopt when no input
+  /// region is being reused.
+  std::optional<std::pair<uint64_t, uint64_t>> getReusedInputFileRange() const;
+
+  /// When certain input file region is reused (like with --use-old-text),
+  /// overwrite every byte of that region not covered by newly written content
+  /// so the output does not retain stale bytes from the input binary.
+  void zeroStaleBytesInReusedRegion(raw_fd_ostream &OS);
 
   /// Return address of a function in the new binary corresponding to
   /// \p OldAddress address in the original binary.
@@ -543,8 +550,8 @@ class RewriteInstance {
   std::optional<uint64_t> PLTRelocationsAddress;
   uint64_t PLTRelocationsSize{0};
 
-  /// True if relocation of specified type came from .rela.plt
-  DenseMap<uint64_t, bool> IsJmpRelocation;
+  /// Number of relocations read from DT_JMPREL.
+  uint32_t NumJmpRelocations{0};
 
   /// Index of specified symbol in the dynamic symbol table. NOTE Currently it
   /// is filled and used only with the relocations-related symbols.