LLVM and SPIRV-LLVM-Translator pulldown (WW09)

LLVM: llvm/llvm-project@55639c2
SPIRV-LLVM-Translator: KhronosGroup/SPIRV-LLVM-Translator@f797de2

Author: bb-sycl

bolt/include/bolt/Core/BinaryBasicBlock.h

@@ -31,6 +31,7 @@ class MCCodeEmitter;
 namespace bolt {
 
 class BinaryFunction;
+class JumpTable;
 
 class BinaryBasicBlock {
 public:
@@ -623,6 +624,10 @@ class BinaryBasicBlock {
   /// remove the conditional successor and branch instruction.
   void removeDuplicateConditionalSuccessor(MCInst *CondBranch);
 
+  /// Update successors of the basic block based on the jump table instruction.
+  /// The block must end with a jump table instruction.
+  void updateJumpTableSuccessors();
+
   /// Test if BB is a predecessor of this block.
   bool isPredecessor(const BinaryBasicBlock *BB) const {
     auto Itr = std::find(Predecessors.begin(), Predecessors.end(), BB);
@@ -909,7 +914,12 @@ class BinaryBasicBlock {
     return Index;
   }
 
-  bool hasJumpTable() const;
+  /// Return jump table if the block contains a jump table instruction or
+  /// nullptr otherwise.
+  const JumpTable *getJumpTable() const;
+
+  /// Check if the block has a jump table instruction.
+  bool hasJumpTable() const { return getJumpTable() != nullptr; }
 
 private:
   void adjustNumPseudos(const MCInst &Inst, int Sign);

bolt/include/bolt/Core/BinaryContext.h

@@ -1192,14 +1192,14 @@ class BinaryContext {
                                           /*PIC=*/!HasFixedLoadAddress));
     MCEInstance.LocalCtx->setObjectFileInfo(MCEInstance.LocalMOFI.get());
     MCEInstance.MCE.reset(
-        TheTarget->createMCCodeEmitter(*MII, *MRI, *MCEInstance.LocalCtx));
+        TheTarget->createMCCodeEmitter(*MII, *MCEInstance.LocalCtx));
     return MCEInstance;
   }
 
   /// Creating MCStreamer instance.
   std::unique_ptr<MCStreamer>
   createStreamer(llvm::raw_pwrite_stream &OS) const {
-    MCCodeEmitter *MCE = TheTarget->createMCCodeEmitter(*MII, *MRI, *Ctx);
+    MCCodeEmitter *MCE = TheTarget->createMCCodeEmitter(*MII, *Ctx);
     MCAsmBackend *MAB =
         TheTarget->createMCAsmBackend(*STI, *MRI, MCTargetOptions());
     std::unique_ptr<MCObjectWriter> OW = MAB->createObjectWriter(OS);

bolt/include/bolt/Core/BinarySection.h

@@ -296,6 +296,16 @@ class BinarySection {
     return make_range(Relocations.begin(), Relocations.end());
   }
 
+  /// Iterate over all dynamic relocations for this section.
+  iterator_range<RelocationSetType::iterator> dynamicRelocations() {
+    return make_range(DynamicRelocations.begin(), DynamicRelocations.end());
+  }
+
+  /// Iterate over all dynamic relocations for this section.
+  iterator_range<RelocationSetType::const_iterator> dynamicRelocations() const {
+    return make_range(DynamicRelocations.begin(), DynamicRelocations.end());
+  }
+
   /// Does this section have any non-pending relocations?
   bool hasRelocations() const { return !Relocations.empty(); }
 

bolt/include/bolt/Core/DebugData.h

@@ -494,7 +494,8 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
     PatchValueVariable,
     ReferencePatchValue,
     DWARFUnitOffsetBaseLabel,
-    DestinationReferenceLabel
+    DestinationReferenceLabel,
+    NewDebugEntry
   };
 
   struct Patch {
@@ -605,6 +606,22 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
     }
   };
 
+  struct NewDebugEntry : public Patch {
+    NewDebugEntry() = delete;
+    NewDebugEntry(uint32_t O, std::string &&V)
+        : Patch(O, DebugPatchKind::NewDebugEntry) {
+      CurrentOrder = NewDebugEntry::OrderCounter++;
+      Value = std::move(V);
+    }
+
+    static bool classof(const Patch *Writer) {
+      return Writer->getKind() == DebugPatchKind::NewDebugEntry;
+    }
+    static uint32_t OrderCounter;
+    uint32_t CurrentOrder;
+    std::string Value;
+  };
+
   virtual PatcherKind getKind() const override {
     return PatcherKind::DebugInfoBinaryPatcher;
   }
@@ -646,6 +663,12 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
   void addReferenceToPatch(uint64_t Offset, uint32_t DestinationOffset,
                            uint32_t OldValueSize, dwarf::Form Form);
 
+  /// Inserts a new uint32_t \p Value at the end of \p DIE .
+  void insertNewEntry(const DWARFDie &DIE, uint32_t);
+
+  /// Inserts a new encoded \p Value at the end of \p DIE .
+  void insertNewEntry(const DWARFDie &DIE, std::string &&Value);
+
   /// Clears unordered set for DestinationLabels.
   void clearDestinationLabels() { DestinationLabels.clear(); }
 
@@ -685,6 +708,9 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
       case DebugPatchKind::DestinationReferenceLabel:
         delete reinterpret_cast<DestinationReferenceLabel *>(P);
         break;
+      case DebugPatchKind::NewDebugEntry:
+        delete reinterpret_cast<NewDebugEntry *>(P);
+        break;
       }
     }
   };
@@ -728,10 +754,19 @@ class DebugAbbrevWriter {
     uint8_t NewAttrForm;
   };
 
+  struct AbbrevEntry {
+    dwarf::Attribute Attr;
+    dwarf::Form Form;
+  };
+
   using PatchesTy = std::unordered_map<const DWARFAbbreviationDeclaration *,
                                        SmallVector<PatchInfo, 2>>;
   std::unordered_map<const DWARFUnit *, PatchesTy> Patches;
 
+  using AbbrevEntryTy = std::unordered_map<const DWARFAbbreviationDeclaration *,
+                                           SmallVector<AbbrevEntry, 2>>;
+  std::unordered_map<const DWARFUnit *, AbbrevEntryTy> NewAbbrevEntries;
+
   /// DWARF context containing abbreviations.
   DWARFContext &Context;
 
@@ -777,6 +812,27 @@ class DebugAbbrevWriter {
         PatchInfo{AttrTag, NewAttrTag, NewAttrForm});
   }
 
+  /// Adds attribute \p AttrTag and \p NewAttrForm in abbreviation declaration
+  /// \p Abbrev belonging to CU \p Unit .
+  void addAttribute(const DWARFUnit &Unit,
+                    const DWARFAbbreviationDeclaration *Abbrev,
+                    dwarf::Attribute AttrTag, dwarf::Form AttrForm) {
+    assert(&Unit.getContext() == &Context &&
+           "cannot update attribute from a different DWARF context");
+    std::lock_guard<std::mutex> Lock(WriterMutex);
+    bool AlreadyAdded = false;
+    for (AbbrevEntry &E : NewAbbrevEntries[&Unit][Abbrev])
+      if (E.Attr == AttrTag) {
+        AlreadyAdded = true;
+        break;
+      }
+
+    if (AlreadyAdded)
+      return;
+    NewAbbrevEntries[&Unit][Abbrev].emplace_back(
+        AbbrevEntry{AttrTag, AttrForm});
+  }
+
   /// Return a buffer with concatenated abbrev sections for all CUs and TUs
   /// in the associated DWARF context. Section offsets could be queried using
   /// getAbbreviationsOffsetForUnit() interface. For DWP, we are using DWOId
@@ -882,6 +938,17 @@ class DwarfLineTable {
   }
 };
 
+struct AttrInfo {
+  DWARFFormValue V;
+  uint64_t Offset;
+  uint32_t Size; // Size of the attribute.
+};
+
+Optional<AttrInfo>
+findAttributeInfo(const DWARFDie DIE,
+                  const DWARFAbbreviationDeclaration *AbbrevDecl,
+                  uint32_t Index);
+
 } // namespace bolt
 } // namespace llvm
 

bolt/include/bolt/Core/Relocation.h

@@ -89,6 +89,9 @@ struct Relocation {
   /// Return true if relocation type is for thread local storage.
   static bool isTLS(uint64_t Type);
 
+  /// Return code for a NONE relocation
+  static uint64_t getNone();
+
   /// Return code for a PC-relative 4-byte relocation
   static uint64_t getPC32();
 
@@ -98,6 +101,10 @@ struct Relocation {
   /// Return true if this relocation is PC-relative. Return false otherwise.
   bool isPCRelative() const { return isPCRelative(Type); }
 
+  /// Return true if this relocation is R_*_RELATIVE type. Return false
+  /// otherwise.
+  bool isRelative() const { return isRelative(Type); }
+
   /// Emit relocation at a current \p Streamer' position. The caller is
   /// responsible for setting the position correctly.
   size_t emit(MCStreamer *Streamer) const;

bolt/include/bolt/Rewrite/RewriteInstance.h

@@ -22,6 +22,7 @@
 #include "llvm/Support/Error.h"
 #include <map>
 #include <set>
+#include <unordered_map>
 
 namespace llvm {
 
@@ -124,7 +125,7 @@ class RewriteInstance {
   void processLKSMPLocks();
 
   /// Read relocations from a given section.
-  void readDynamicRelocations(const object::SectionRef &Section);
+  void readDynamicRelocations(const object::SectionRef &Section, bool IsJmpRel);
 
   /// Read relocations from a given section.
   void readRelocations(const object::SectionRef &Section);
@@ -201,6 +202,10 @@ class RewriteInstance {
   /// \p OldAddress address in the original binary.
   uint64_t getNewFunctionAddress(uint64_t OldAddress);
 
+  /// Return address of a function or moved data in the new binary
+  /// corresponding to \p OldAddress address in the original binary.
+  uint64_t getNewFunctionOrDataAddress(uint64_t OldAddress);
+
   /// Return value for the symbol \p Name in the output.
   uint64_t getNewValueForSymbol(const StringRef Name);
 
@@ -299,6 +304,14 @@ class RewriteInstance {
       const std::vector<uint32_t> &NewSectionIndex, WriteFuncTy Write,
       StrTabFuncTy AddToStrTab);
 
+  /// Get output index in dynamic symbol table.
+  uint32_t getOutputDynamicSymbolIndex(const MCSymbol *Symbol) {
+    auto It = SymbolIndex.find(Symbol);
+    if (It != SymbolIndex.end())
+      return It->second;
+    return 0;
+  }
+
   /// Add a notes section containing the BOLT revision and command line options.
   void addBoltInfoSection();
 
@@ -426,11 +439,19 @@ class RewriteInstance {
   /// Location and size of dynamic relocations.
   Optional<uint64_t> DynamicRelocationsAddress;
   uint64_t DynamicRelocationsSize{0};
+  uint64_t DynamicRelativeRelocationsCount{0};
 
   /// PLT relocations are special kind of dynamic relocations stored separately.
   Optional<uint64_t> PLTRelocationsAddress;
   uint64_t PLTRelocationsSize{0};
 
+  /// True if relocation of specified type came from .rela.plt
+  DenseMap<uint64_t, bool> IsJmpRelocation;
+
+  /// Index of specified symbol in the dynamic symbol table. NOTE Currently it
+  /// is filled and used only with the relocations-related symbols.
+  std::unordered_map<const MCSymbol *, uint32_t> SymbolIndex;
+
   /// Store all non-zero symbols in this map for a quick address lookup.
   std::map<uint64_t, llvm::object::SymbolRef> FileSymRefs;
 

bolt/lib/Core/BinaryBasicBlock.cpp

@@ -39,10 +39,10 @@ bool BinaryBasicBlock::hasInstructions() const {
   return getParent()->hasInstructions();
 }
 
-bool BinaryBasicBlock::hasJumpTable() const {
+const JumpTable *BinaryBasicBlock::getJumpTable() const {
   const MCInst *Inst = getLastNonPseudoInstr();
   const JumpTable *JT = Inst ? Function->getJumpTable(*Inst) : nullptr;
-  return (JT != nullptr);
+  return JT;
 }
 
 void BinaryBasicBlock::adjustNumPseudos(const MCInst &Inst, int Sign) {
@@ -351,6 +351,36 @@ void BinaryBasicBlock::removeDuplicateConditionalSuccessor(MCInst *CondBranch) {
   BranchInfo.push_back({Count, 0});
 }
 
+void BinaryBasicBlock::updateJumpTableSuccessors() {
+  const JumpTable *JT = getJumpTable();
+  assert(JT && "Expected jump table instruction.");
+
+  // Clear existing successors.
+  removeAllSuccessors();
+
+  // Generate the list of successors in deterministic order without duplicates.
+  SmallVector<BinaryBasicBlock *, 16> SuccessorBBs;
+  for (const MCSymbol *Label : JT->Entries) {
+    BinaryBasicBlock *BB = getFunction()->getBasicBlockForLabel(Label);
+    // Ignore __builtin_unreachable()
+    if (!BB) {
+      assert(Label == getFunction()->getFunctionEndLabel() &&
+             "JT label should match a block or end of function.");
+      continue;
+    }
+    SuccessorBBs.emplace_back(BB);
+  }
+  llvm::sort(SuccessorBBs,
+             [](const BinaryBasicBlock *BB1, const BinaryBasicBlock *BB2) {
+               return BB1->getInputOffset() < BB2->getInputOffset();
+             });
+  SuccessorBBs.erase(std::unique(SuccessorBBs.begin(), SuccessorBBs.end()),
+                     SuccessorBBs.end());
+
+  for (BinaryBasicBlock *BB : SuccessorBBs)
+    addSuccessor(BB);
+}
+
 void BinaryBasicBlock::adjustExecutionCount(double Ratio) {
   auto adjustedCount = [&](uint64_t Count) -> uint64_t {
     double NewCount = Count * Ratio;

bolt/lib/Core/BinaryContext.cpp

@@ -17,6 +17,7 @@
 #include "bolt/Utils/NameResolver.h"
 #include "bolt/Utils/Utils.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/MC/MCAsmLayout.h"
@@ -222,7 +223,7 @@ BinaryContext::createBinaryContext(const ObjectFile *File, bool IsPIC,
   InstructionPrinter->setPrintImmHex(true);
 
   std::unique_ptr<MCCodeEmitter> MCE(
-      TheTarget->createMCCodeEmitter(*MII, *MRI, *Ctx));
+      TheTarget->createMCCodeEmitter(*MII, *Ctx));
 
   // Make sure we don't miss any output on core dumps.
   outs().SetUnbuffered();
@@ -712,8 +713,10 @@ void BinaryContext::skipMarkedFragments() {
     std::for_each(BF->ParentFragments.begin(), BF->ParentFragments.end(),
                   addToWorklist);
   }
-  errs() << "BOLT-WARNING: Ignored " << FragmentsToSkip.size() << " functions "
-         << "due to cold fragments.\n";
+  if (!FragmentsToSkip.empty())
+    errs() << "BOLT-WARNING: ignored " << FragmentsToSkip.size() << " function"
+           << (FragmentsToSkip.size() == 1 ? "" : "s")
+           << " due to cold fragments\n";
   FragmentsToSkip.clear();
 }
 

bolt/lib/Core/BinaryEmitter.cpp

@@ -17,6 +17,7 @@
 #include "bolt/Core/DebugData.h"
 #include "bolt/Utils/CommandLineOpts.h"
 #include "bolt/Utils/Utils.h"
+#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/CommandLine.h"

bolt/lib/Core/BinaryFunction.cpp

@@ -1875,21 +1875,7 @@ bool BinaryFunction::postProcessIndirectBranches(
     BC.MIB->setJumpTable(*LastIndirectJump, LastJT, LastJTIndexReg, AllocId);
     HasUnknownControlFlow = false;
 
-    // re-populate successors based on the jump table.
-    std::set<const MCSymbol *> JTLabels;
-    LastIndirectJumpBB->removeAllSuccessors();
-    const JumpTable *JT = getJumpTableContainingAddress(LastJT);
-    for (const MCSymbol *Label : JT->Entries)
-      JTLabels.emplace(Label);
-    for (const MCSymbol *Label : JTLabels) {
-      BinaryBasicBlock *BB = getBasicBlockForLabel(Label);
-      // Ignore __builtin_unreachable()
-      if (!BB) {
-        assert(Label == getFunctionEndLabel() && "if no BB found, must be end");
-        continue;
-      }
-      LastIndirectJumpBB->addSuccessor(BB);
-    }
+    LastIndirectJumpBB->updateJumpTableSuccessors();
   }
 
   if (HasFixedIndirectBranch)