LLVM and SPIRV-LLVM-Translator pulldown (WW25)

LLVM: llvm/llvm-project@af35be5
SPIRV-LLVM-Translator: KhronosGroup/SPIRV-LLVM-Translator@9823690

Community has started to refactor some code assuming opaque pointer only,
however the SPIRV component used in sycl is not ready to enable the opaque pointer by default,
so we have to revert some of the commit by guarding them within macro INTEL_SYCL_OPAQUEPOINTER_READY,
and keep both version of the code.
The old code should be removed once we enable opaque pointer by default.

Author: bb-sycl

.git-blame-ignore-revs

@@ -55,3 +55,6 @@ dd3c26a045c081620375a878159f536758baba6e
 f98ee40f4b5d7474fc67e82824bf6abbaedb7b1c
 2238dcc39358353cac21df75c3c3286ab20b8f53
 f9008e6366c2496b1ca1785b891d5578174ad63e
+
+# [libc++][NFC] Apply clang-format on large parts of the code base
+5aa03b648b827128d439f705cd7d57d59673741d

bolt/CMakeLists.txt

@@ -9,7 +9,7 @@ list(INSERT CMAKE_MODULE_PATH 0 "${BOLT_SOURCE_DIR}/cmake/modules")
 
 # Determine default set of targets to build -- the intersection of
 # those BOLT supports and those LLVM is targeting.
-set(BOLT_TARGETS_TO_BUILD_all "AArch64;X86")
+set(BOLT_TARGETS_TO_BUILD_all "AArch64;X86;RISCV")
 set(BOLT_TARGETS_TO_BUILD_default)
 foreach (tgt ${BOLT_TARGETS_TO_BUILD_all})
   if (tgt IN_LIST LLVM_TARGETS_TO_BUILD)

bolt/CODE_OWNERS.TXT

@@ -20,3 +20,7 @@ D: DWARF support
 N: Vladislav Khmelevsky
 E: [email protected]
 D: AArch64 backend
+
+N: Job Noorman
+E: [email protected]
+D: RISC-V backend

bolt/include/bolt/Core/BinaryContext.h

@@ -59,7 +59,6 @@ using namespace object;
 namespace bolt {
 
 class BinaryFunction;
-class ExecutableFileMemoryManager;
 
 /// Information on loadable part of the file.
 struct SegmentInfo {
@@ -313,10 +312,6 @@ class BinaryContext {
       FilterIterator<binary_data_const_iterator>;
   using FilteredBinaryDataIterator = FilterIterator<binary_data_iterator>;
 
-  /// Memory manager for sections and segments. Used to communicate with ORC
-  /// among other things.
-  std::shared_ptr<ExecutableFileMemoryManager> EFMM;
-
   StringRef getFilename() const { return Filename; }
   void setFilename(StringRef Name) { Filename = std::string(Name); }
 
@@ -727,6 +722,8 @@ class BinaryContext {
            TheTriple->getArch() == llvm::Triple::x86_64;
   }
 
+  bool isRISCV() const { return TheTriple->getArch() == llvm::Triple::riscv64; }
+
   // AArch64-specific functions to check if symbol is used to delimit
   // code/data in .text. Code is marked by $x, data by $d.
   MarkerSymType getMarkerType(const SymbolRef &Symbol) const;
@@ -845,13 +842,11 @@ class BinaryContext {
   /// Return BinaryData for the given \p Name or nullptr if no
   /// global symbol with that name exists.
   const BinaryData *getBinaryDataByName(StringRef Name) const {
-    auto Itr = GlobalSymbols.find(Name);
-    return Itr != GlobalSymbols.end() ? Itr->second : nullptr;
+    return GlobalSymbols.lookup(Name);
   }
 
   BinaryData *getBinaryDataByName(StringRef Name) {
-    auto Itr = GlobalSymbols.find(Name);
-    return Itr != GlobalSymbols.end() ? Itr->second : nullptr;
+    return GlobalSymbols.lookup(Name);
   }
 
   /// Return registered PLT entry BinaryData with the given \p Name
@@ -1165,7 +1160,7 @@ class BinaryContext {
 
   /// Return a dynamic relocation registered at a given \p Address, or nullptr
   /// if there is no dynamic relocation at such address.
-  const Relocation *getDynamicRelocationAt(uint64_t Address);
+  const Relocation *getDynamicRelocationAt(uint64_t Address) const;
 
   /// Remove registered relocation at a given \p Address.
   bool removeRelocationAt(uint64_t Address);

bolt/include/bolt/Core/BinaryFunction.h

@@ -384,6 +384,10 @@ class BinaryFunction {
   /// Indicates the type of profile the function is using.
   uint16_t ProfileFlags{PF_NONE};
 
+  /// True if the function's input profile data has been inaccurate but has
+  /// been adjusted by the profile inference algorithm.
+  bool HasInferredProfile{false};
+
   /// For functions with mismatched profile we store all call profile
   /// information at a function level (as opposed to tying it to
   /// specific call sites).
@@ -1124,11 +1128,7 @@ class BinaryFunction {
   /// secondary entry point into the function, then return a global symbol
   /// that represents the secondary entry point. Otherwise return nullptr.
   MCSymbol *getSecondaryEntryPointSymbol(const MCSymbol *BBLabel) const {
-    auto I = SecondaryEntryPoints.find(BBLabel);
-    if (I == SecondaryEntryPoints.end())
-      return nullptr;
-
-    return I->second;
+    return SecondaryEntryPoints.lookup(BBLabel);
   }
 
   /// If the basic block serves as a secondary entry point to the function,
@@ -1566,6 +1566,12 @@ class BinaryFunction {
   /// Return flags describing a profile for this function.
   uint16_t getProfileFlags() const { return ProfileFlags; }
 
+  /// Return true if the function's input profile data has been inaccurate but
+  /// has been corrected by the profile inference algorithm.
+  bool hasInferredProfile() const { return HasInferredProfile; }
+
+  void setHasInferredProfile(bool Inferred) { HasInferredProfile = Inferred; }
+
   void addCFIInstruction(uint64_t Offset, MCCFIInstruction &&Inst) {
     assert(!Instructions.empty());
 
@@ -2040,9 +2046,11 @@ class BinaryFunction {
   void handleAArch64IndirectCall(MCInst &Instruction, const uint64_t Offset);
 
   /// Scan function for references to other functions. In relocation mode,
-  /// add relocations for external references.
+  /// add relocations for external references. In non-relocation mode, detect
+  /// and mark new entry points.
   ///
-  /// Return true on success.
+  /// Return true on success. False if the disassembly failed or relocations
+  /// could not be created.
   bool scanExternalRefs();
 
   /// Return the size of a data object located at \p Offset in the function.

bolt/include/bolt/Core/BinarySection.h

@@ -56,10 +56,11 @@ class BinarySection {
   unsigned Alignment;          // alignment in bytes (must be > 0)
   unsigned ELFType;            // ELF section type
   unsigned ELFFlags;           // ELF section flags
+  bool IsRelro{false};         // GNU RELRO section (read-only after relocation)
 
   // Relocations associated with this section. Relocation offsets are
   // wrt. to the original section address and size.
-  using RelocationSetType = std::set<Relocation, std::less<>>;
+  using RelocationSetType = std::multiset<Relocation, std::less<>>;
   RelocationSetType Relocations;
 
   // Dynamic relocations associated with this section. Relocation offsets are
@@ -90,7 +91,7 @@ class BinarySection {
   uint64_t OutputFileOffset{0};    // File offset in the rewritten binary file.
   StringRef OutputContents;        // Rewritten section contents.
   const uint64_t SectionNumber;    // Order in which the section was created.
-  unsigned SectionID{-1u};         // Unique ID used for address mapping.
+  std::string SectionID;           // Unique ID used for address mapping.
                                    // Set by ExecutableFileMemoryManager.
   uint32_t Index{0};               // Section index in the output file.
   mutable bool IsReordered{false}; // Have the contents been reordered?
@@ -287,6 +288,8 @@ class BinarySection {
   }
   bool isReordered() const { return IsReordered; }
   bool isAnonymous() const { return IsAnonymous; }
+  bool isRelro() const { return IsRelro; }
+  void setRelro() { IsRelro = true; }
   unsigned getELFType() const { return ELFType; }
   unsigned getELFFlags() const { return ELFFlags; }
 
@@ -345,7 +348,8 @@ class BinarySection {
   bool removeRelocationAt(uint64_t Offset) {
     auto Itr = Relocations.find(Offset);
     if (Itr != Relocations.end()) {
-      Relocations.erase(Itr);
+      auto End = Relocations.upper_bound(Offset);
+      Relocations.erase(Itr, End);
       return true;
     }
     return false;
@@ -430,18 +434,18 @@ class BinarySection {
   }
   uint64_t getOutputAddress() const { return OutputAddress; }
   uint64_t getOutputFileOffset() const { return OutputFileOffset; }
-  unsigned getSectionID() const {
+  StringRef getSectionID() const {
     assert(hasValidSectionID() && "trying to use uninitialized section id");
     return SectionID;
   }
-  bool hasValidSectionID() const { return SectionID != -1u; }
+  bool hasValidSectionID() const { return !SectionID.empty(); }
   bool hasValidIndex() { return Index != 0; }
   uint32_t getIndex() const { return Index; }
 
   // mutation
   void setOutputAddress(uint64_t Address) { OutputAddress = Address; }
   void setOutputFileOffset(uint64_t Offset) { OutputFileOffset = Offset; }
-  void setSectionID(unsigned ID) {
+  void setSectionID(StringRef ID) {
     assert(!hasValidSectionID() && "trying to set section id twice");
     SectionID = ID;
   }

bolt/include/bolt/Core/Linker.h

@@ -0,0 +1,48 @@
+//===- bolt/Core/Linker.h - BOLTLinker interface ----------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the interface BOLT uses for linking.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef BOLT_CORE_LINKER_H
+#define BOLT_CORE_LINKER_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MemoryBufferRef.h"
+
+#include <cstdint>
+#include <functional>
+#include <optional>
+
+namespace llvm {
+namespace bolt {
+
+class BinarySection;
+
+class BOLTLinker {
+public:
+  using SectionMapper =
+      std::function<void(const BinarySection &Section, uint64_t Address)>;
+  using SectionsMapper = std::function<void(SectionMapper)>;
+
+  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 of a symbol or std::nullopt if it cannot be found.
+  virtual std::optional<uint64_t> lookupSymbol(StringRef Name) const = 0;
+};
+
+} // namespace bolt
+} // namespace llvm
+
+#endif // BOLT_CORE_LINKER_H

bolt/include/bolt/Core/MCPlusBuilder.h

@@ -336,9 +336,12 @@ class MCPlusBuilder {
     initSizeMap();
   }
 
-  /// Create and return target-specific MC symbolizer for the \p Function.
+  /// Create and return a target-specific MC symbolizer for the \p Function.
+  /// When \p CreateNewSymbols is set, the symbolizer can create new symbols
+  /// e.g. for jump table references.
   virtual std::unique_ptr<MCSymbolizer>
-  createTargetSymbolizer(BinaryFunction &Function) const {
+  createTargetSymbolizer(BinaryFunction &Function,
+                         bool CreateNewSymbols = true) const {
     return nullptr;
   }
 
@@ -431,7 +434,7 @@ class MCPlusBuilder {
   }
 
   /// Check whether we support inverting this branch
-  virtual bool isUnsupportedBranch(unsigned Opcode) const { return false; }
+  virtual bool isUnsupportedBranch(const MCInst &Inst) const { return false; }
 
   /// Return true of the instruction is of pseudo kind.
   bool isPseudo(const MCInst &Inst) const {
@@ -630,6 +633,12 @@ class MCPlusBuilder {
     return false;
   }
 
+  /// Returns true if First/Second is a AUIPC/JALR call pair.
+  virtual bool isRISCVCall(const MCInst &First, const MCInst &Second) const {
+    llvm_unreachable("not implemented");
+    return false;
+  }
+
   /// If non-zero, this is used to fill the executable space with instructions
   /// that will trap. Defaults to 0.
   virtual unsigned getTrapFillValue() const { return 0; }
@@ -2029,6 +2038,10 @@ MCPlusBuilder *createAArch64MCPlusBuilder(const MCInstrAnalysis *,
                                           const MCInstrInfo *,
                                           const MCRegisterInfo *);
 
+MCPlusBuilder *createRISCVMCPlusBuilder(const MCInstrAnalysis *,
+                                        const MCInstrInfo *,
+                                        const MCRegisterInfo *);
+
 } // namespace bolt
 } // namespace llvm
 

bolt/include/bolt/Core/Relocation.h

@@ -14,10 +14,11 @@
 #ifndef BOLT_CORE_RELOCATION_H
 #define BOLT_CORE_RELOCATION_H
 
+#include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCStreamer.h"
 #include "llvm/TargetParser/Triple.h"
 
 namespace llvm {
-class MCStreamer;
 class MCSymbol;
 class raw_ostream;
 
@@ -122,8 +123,36 @@ struct Relocation {
   /// responsible for setting the position correctly.
   size_t emit(MCStreamer *Streamer) const;
 
+  /// Emit a group of composed relocations. All relocations must have the same
+  /// offset. If std::distance(Begin, End) == 1, this is equivalent to
+  /// Begin->emit(Streamer).
+  template <typename RelocIt>
+  static size_t emit(RelocIt Begin, RelocIt End, MCStreamer *Streamer) {
+    if (Begin == End)
+      return 0;
+
+    const MCExpr *Value = nullptr;
+
+    for (auto RI = Begin; RI != End; ++RI) {
+      assert(RI->Offset == Begin->Offset &&
+             "emitting composed relocations with different offsets");
+      Value = RI->createExpr(Streamer, Value);
+    }
+
+    assert(Value && "failed to create relocation value");
+    auto Size = std::prev(End)->getSize();
+    Streamer->emitValue(Value, Size);
+    return Size;
+  }
+
   /// Print a relocation to \p OS.
   void print(raw_ostream &OS) const;
+
+private:
+  const MCExpr *createExpr(MCStreamer *Streamer) const;
+  const MCExpr *createExpr(MCStreamer *Streamer,
+                           const MCExpr *RetainedValue) const;
+  static MCBinaryExpr::Opcode getComposeOpcodeFor(uint64_t Type);
 };
 
 /// Relocation ordering by offset.

bolt/include/bolt/Passes/FixRISCVCallsPass.h

@@ -0,0 +1,38 @@
+//===- bolt/Passes/FixRISCVCallsPass.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the FixRISCVCallsPass class, which sets the JALR immediate
+// to 0 for AUIPC/JALR pairs with a R_RISCV_CALL(_PLT) relocation. This is
+// necessary since MC expects it to be zero in order to or-in fixups.
+//===----------------------------------------------------------------------===//
+
+#ifndef BOLT_PASSES_FIXRISCVCALLSPASS_H
+#define BOLT_PASSES_FIXRISCVCALLSPASS_H
+
+#include "bolt/Passes/BinaryPasses.h"
+
+namespace llvm {
+namespace bolt {
+
+class FixRISCVCallsPass : public BinaryFunctionPass {
+  void runOnFunction(BinaryFunction &Function);
+
+public:
+  explicit FixRISCVCallsPass(const cl::opt<bool> &PrintPass)
+      : BinaryFunctionPass(PrintPass) {}
+
+  const char *getName() const override { return "fix-riscv-calls"; }
+
+  /// Pass entry point
+  void runOnFunctions(BinaryContext &BC) override;
+};
+
+} // namespace bolt
+} // namespace llvm
+
+#endif

bolt/include/bolt/Profile/YAMLProfileReader.h

@@ -70,6 +70,10 @@ class YAMLProfileReader : public ProfileReaderBase {
   bool parseFunctionProfile(BinaryFunction &Function,
                             const yaml::bolt::BinaryFunctionProfile &YamlBF);
 
+  /// Infer function profile from stale data (collected on older binaries).
+  bool inferStaleProfile(BinaryFunction &Function,
+                         const yaml::bolt::BinaryFunctionProfile &YamlBF);
+
   /// Initialize maps for profile matching.
   void buildNameMaps(std::map<uint64_t, BinaryFunction> &Functions);