LLVM and SPIRV-LLVM-Translator pulldown (WW33)

.clang-tidy

@@ -1,4 +1,21 @@
-Checks: '-*,clang-diagnostic-*,llvm-*,misc-*,-misc-unused-parameters,-misc-non-private-member-variables-in-classes,-misc-no-recursion,readability-identifier-naming'
+Checks: |
+  -*,
+  clang-diagnostic-*,
+  llvm-*,
+  -llvm-header-guard,
+  misc-*,
+  -misc-no-recursion,
+  -misc-non-private-member-variables-in-classes,
+  -misc-unused-parameters,
+  readability-identifier-naming
+WarningsAsErrors: |
+  llvm-*,
+  -llvm-header-guard,
+  misc-*,
+  -misc-no-recursion,
+  -misc-non-private-member-variables-in-classes,
+  -misc-unused-parameters,
+  readability-identifier-naming
 CheckOptions:
   - key:             readability-identifier-naming.ClassCase
     value:           CamelCase
@@ -24,3 +41,5 @@ CheckOptions:
     value:           1
   - key:             modernize-use-default-member-init.UseAssignment
     value:           1
+  - key:             llvm-namespace-comment.ShortNamespaceLines
+    value:           '25'

.github/workflows/issue-release-workflow.yml

@@ -87,4 +87,5 @@ jobs:
           --token ${{ secrets.RELEASE_WORKFLOW_PUSH_SECRET }} \
           release-workflow \
           --issue-number ${{ github.event.issue.number }} \
+          --phab-token ${{ secrets.RELEASE_WORKFLOW_PHAB_TOKEN }} \
           auto

.github/workflows/libclang-abi-tests.yml

@@ -124,12 +124,10 @@ jobs:
     - name: Dump ABI
       run: |
         parallel abi-dumper -lver ${{ matrix.ref }} -skip-cxx -public-headers ./install/include/${{ needs.abi-dump-setup.outputs.ABI_HEADERS }} -o {}-${{ matrix.ref }}.abi ./build/lib/{} ::: ${{ needs.abi-dump-setup.outputs.ABI_LIBS }}
-        # Remove symbol versioning from dumps, so we can compare across major
-        # versions.  We don't need to do this for libclang.so since its ABI
-        # is stable across major releases and the symbol versions don't change.
-        if [ -e libclang-cpp.so-${{ matrix.ref }}.abi ]; then
-          sed -i 's/LLVM_[0-9]\+/LLVM_NOVERSION/' libclang-cpp.so-${{ matrix.ref }}.abi
-        fi
+        for lib in ${{ needs.abi-dump-setup.outputs.ABI_LIBS }}; do
+          # Remove symbol versioning from dumps, so we can compare across major versions.
+          sed -i 's/LLVM_[0-9]\+/LLVM_NOVERSION/' $lib-${{ matrix.ref }}.abi
+        done
     - name: Upload ABI file
       uses: actions/upload-artifact@v2
       with:

README.md

@@ -5,6 +5,8 @@ Intel LLVM-based projects:
 
 - [oneAPI DPC++ compiler](#oneapi-dpc-compiler)
 - [Late-outline OpenMP and OpenMP Offload](#late-outline-openmp-and-openmp-offload)
+sudo apt-get install llvm-16-dev llvm-16-tools clang-16 libclang-16-dev
+`-DLLVM_EXTERNAL_LIT="/usr/lib/llvm-16/build/utils/lit/lit.py"` is
 
 ## oneAPI DPC++ compiler
 

bolt/include/bolt/Core/BinaryDomTree.h

@@ -14,12 +14,13 @@
 #ifndef BOLT_CORE_BINARY_DOMTREE_H
 #define BOLT_CORE_BINARY_DOMTREE_H
 
+#include "bolt/Core/BinaryBasicBlock.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/Support/GenericDomTreeConstruction.h"
 
 namespace llvm {
 namespace bolt {
 
-class BinaryBasicBlock;
 using BinaryDomTreeNode = DomTreeNodeBase<BinaryBasicBlock>;
 using BinaryDominatorTree = DomTreeBase<BinaryBasicBlock>;
 

bolt/include/bolt/Core/BinaryFunction.h

@@ -994,7 +994,7 @@ class BinaryFunction {
   bool hasName(const std::string &FunctionName) const {
     auto Res =
         forEachName([&](StringRef Name) { return Name == FunctionName; });
-    return Res.hasValue();
+    return Res.has_value();
   }
 
   /// Check if any of function names matches the given regex.
@@ -1005,7 +1005,7 @@ class BinaryFunction {
   Optional<StringRef> hasRestoredNameRegex(const StringRef NameRegex) const;
 
   /// Return a vector of all possible names for the function.
-  const std::vector<StringRef> getNames() const {
+  std::vector<StringRef> getNames() const {
     std::vector<StringRef> AllNames;
     forEachName([&AllNames](StringRef Name) {
       AllNames.push_back(Name);
@@ -1427,17 +1427,15 @@ class BinaryFunction {
 
   const CallSitesType &getColdCallSites() const { return ColdCallSites; }
 
-  const ArrayRef<uint8_t> getLSDAActionTable() const { return LSDAActionTable; }
+  ArrayRef<uint8_t> getLSDAActionTable() const { return LSDAActionTable; }
 
   const LSDATypeTableTy &getLSDATypeTable() const { return LSDATypeTable; }
 
   const LSDATypeTableTy &getLSDATypeAddressTable() const {
     return LSDATypeAddressTable;
   }
 
-  const ArrayRef<uint8_t> getLSDATypeIndexTable() const {
-    return LSDATypeIndexTable;
-  }
+  ArrayRef<uint8_t> getLSDATypeIndexTable() const { return LSDATypeIndexTable; }
 
   const LabelsMapType &getLabels() const { return Labels; }
 
@@ -1652,7 +1650,6 @@ class BinaryFunction {
     }
     OffsetToCFI.emplace(Offset, FrameInstructions.size());
     FrameInstructions.emplace_back(std::forward<MCCFIInstruction>(Inst));
-    return;
   }
 
   BinaryBasicBlock::iterator addCFIInstruction(BinaryBasicBlock *BB,

bolt/include/bolt/Core/DebugData.h

@@ -226,22 +226,22 @@ class DebugRangeListsSectionWriter : public DebugRangesSectionWriter {
   static void setAddressWriter(DebugAddrWriter *AddrW) { AddrWriter = AddrW; }
 
   /// Add ranges with caching.
-  virtual uint64_t addRanges(
+  uint64_t addRanges(
       DebugAddressRangesVector &&Ranges,
       std::map<DebugAddressRangesVector, uint64_t> &CachedRanges) override;
 
   /// Add ranges and return offset into section.
-  virtual uint64_t addRanges(const DebugAddressRangesVector &Ranges) override;
+  uint64_t addRanges(const DebugAddressRangesVector &Ranges) override;
 
-  virtual std::unique_ptr<DebugBufferVector> releaseBuffer() override {
+  std::unique_ptr<DebugBufferVector> releaseBuffer() override {
     return std::move(RangesBuffer);
   }
 
   /// Needs to be invoked before each \p CU is processed.
-  void virtual initSection(DWARFUnit &CU) override;
+  void initSection(DWARFUnit &CU) override;
 
   /// Writes out range lists for a current CU being processed.
-  void virtual finalizeSection() override;
+  void finalizeSection() override;
 
   // Returns true if section is empty.
   bool empty() { return RangesBuffer->empty(); }
@@ -391,15 +391,15 @@ class DebugAddrWriterDwarf5 : public DebugAddrWriter {
   DebugAddrWriterDwarf5(BinaryContext *BC) : DebugAddrWriter(BC) {}
 
   /// Creates consolidated .debug_addr section, and builds DWOID to offset map.
-  virtual AddressSectionBuffer finalize() override;
+  AddressSectionBuffer finalize() override;
   /// Given DWARFUnit \p Unit returns offset of this CU in to .debug_addr
   /// section.
-  virtual uint64_t getOffset(DWARFUnit &Unit) override;
+  uint64_t getOffset(DWARFUnit &Unit) override;
 
 protected:
   /// Given DWARFUnit \p Unit returns either DWO ID or it's offset within
   /// .debug_info.
-  virtual uint64_t getCUID(DWARFUnit &Unit) override {
+  uint64_t getCUID(DWARFUnit &Unit) override {
     if (Unit.isDWOUnit()) {
       DWARFUnit *SkeletonCU = Unit.getLinkedUnit();
       return SkeletonCU->getOffset();
@@ -561,9 +561,9 @@ class DebugLoclistWriter : public DebugLocWriter {
   static void setAddressWriter(DebugAddrWriter *AddrW) { AddrWriter = AddrW; }
 
   /// Stores location lists internally to be written out during finalize phase.
-  virtual void addList(AttrInfo &AttrVal, DebugLocationsVector &LocList,
-                       DebugInfoBinaryPatcher &DebugInfoPatcher,
-                       DebugAbbrevWriter &AbbrevWriter) override;
+  void addList(AttrInfo &AttrVal, DebugLocationsVector &LocList,
+               DebugInfoBinaryPatcher &DebugInfoPatcher,
+               DebugAbbrevWriter &AbbrevWriter) override;
 
   /// Writes out locations in to a local buffer and applies debug info patches.
   void finalize(DebugInfoBinaryPatcher &DebugInfoPatcher,
@@ -685,7 +685,7 @@ class SimpleBinaryPatcher : public BinaryPatcher {
 
   /// This function takes in \p BinaryContents, applies patches to it and
   /// returns an updated string.
-  virtual std::string patchBinary(StringRef BinaryContents) override;
+  std::string patchBinary(StringRef BinaryContents) override;
 };
 
 class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
@@ -843,7 +843,7 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
     std::string Value;
   };
 
-  virtual PatcherKind getKind() const override {
+  PatcherKind getKind() const override {
     return PatcherKind::DebugInfoBinaryPatcher;
   }
 
@@ -853,23 +853,23 @@ class DebugInfoBinaryPatcher : public SimpleBinaryPatcher {
 
   /// This function takes in \p BinaryContents, and re-writes it with new
   /// patches inserted into it. It returns an updated string.
-  virtual std::string patchBinary(StringRef BinaryContents) override;
+  std::string patchBinary(StringRef BinaryContents) override;
 
   /// Adds a patch to put the integer \p NewValue encoded as a 64-bit
   /// little-endian value at offset \p Offset.
-  virtual void addLE64Patch(uint64_t Offset, uint64_t NewValue) override;
+  void addLE64Patch(uint64_t Offset, uint64_t NewValue) override;
 
   /// Adds a patch to put the integer \p NewValue encoded as a 32-bit
   /// little-endian value at offset \p Offset.
   /// The \p OldValueSize is the size of the old value that will be replaced.
-  virtual void addLE32Patch(uint64_t Offset, uint32_t NewValue,
-                            uint32_t OldValueSize = 4) override;
+  void addLE32Patch(uint64_t Offset, uint32_t NewValue,
+                    uint32_t OldValueSize = 4) override;
 
   /// Add a patch at \p Offset with \p Value using unsigned LEB128 encoding with
   /// size \p OldValueSize.
   /// The \p OldValueSize is the size of the old value that will be replaced.
-  virtual void addUDataPatch(uint64_t Offset, uint64_t Value,
-                             uint32_t OldValueSize) override;
+  void addUDataPatch(uint64_t Offset, uint64_t Value,
+                     uint32_t OldValueSize) override;
 
   /// Adds a label \p Offset for DWARF UNit.
   /// Used to recompute relative references.

bolt/include/bolt/Core/JumpTable.h

@@ -109,7 +109,7 @@ class JumpTable : public BinaryData {
   /// starting at (or containing) 'Addr'.
   std::pair<size_t, size_t> getEntriesForAddress(const uint64_t Addr) const;
 
-  virtual bool isJumpTable() const override { return true; }
+  bool isJumpTable() const override { return true; }
 
   /// Change all entries of the jump table in \p JTAddress pointing to
   /// \p OldDest to \p NewDest. Return false if unsuccessful.
@@ -120,7 +120,7 @@ class JumpTable : public BinaryData {
   void updateOriginal();
 
   /// Print for debugging purposes.
-  virtual void print(raw_ostream &OS) const override;
+  void print(raw_ostream &OS) const override;
 };
 
 } // namespace bolt

bolt/include/bolt/Passes/RegReAssign.h

@@ -9,6 +9,7 @@
 #ifndef BOLT_PASSES_REGREASSIGN_H
 #define BOLT_PASSES_REGREASSIGN_H
 
+#include "bolt/Passes/BinaryFunctionCallGraph.h"
 #include "bolt/Passes/BinaryPasses.h"
 #include "bolt/Passes/RegAnalysis.h"
 

bolt/include/bolt/Profile/BoltAddressTranslation.h

@@ -76,26 +76,29 @@ class BoltAddressTranslation {
   /// output binary
   static const char *SECTION_NAME;
 
-  BoltAddressTranslation(BinaryContext &BC) : BC(BC) {}
+  BoltAddressTranslation() {}
 
   /// Write the serialized address translation tables for each reordered
   /// function
-  void write(raw_ostream &OS);
+  void write(const BinaryContext &BC, raw_ostream &OS);
 
   /// Read the serialized address translation tables and load them internally
   /// in memory. Return a parse error if failed.
   std::error_code parse(StringRef Buf);
 
+  /// Dump the parsed address translation tables
+  void dump(raw_ostream &OS);
+
   /// If the maps are loaded in memory, perform the lookup to translate LBR
-  /// addresses in \p Func.
-  uint64_t translate(const BinaryFunction &Func, uint64_t Offset,
+  /// addresses in function located at \p FuncAddress.
+  uint64_t translate(uint64_t FuncAddress, uint64_t Offset,
                      bool IsBranchSrc) const;
 
   /// Use the map keys containing basic block addresses to infer fall-throughs
   /// taken in the path started at FirstLBR.To and ending at SecondLBR.From.
   /// Return NoneType if trace is invalid or the list of fall-throughs
   /// otherwise.
-  Optional<FallthroughListTy> getFallthroughsInTrace(const BinaryFunction &Func,
+  Optional<FallthroughListTy> getFallthroughsInTrace(uint64_t FuncAddress,
                                                      uint64_t From,
                                                      uint64_t To) const;
 
@@ -115,8 +118,6 @@ class BoltAddressTranslation {
   void writeEntriesForBB(MapTy &Map, const BinaryBasicBlock &BB,
                          uint64_t FuncAddress);
 
-  BinaryContext &BC;
-
   std::map<uint64_t, MapTy> Maps;
 
   /// Links outlined cold bocks to their original function

bolt/include/bolt/Profile/DataReader.h

@@ -268,18 +268,18 @@ class DataReader : public ProfileReaderBase {
 
   bool isTrustedSource() const override { return false; }
 
-  virtual Error preprocessProfile(BinaryContext &BC) override;
+  Error preprocessProfile(BinaryContext &BC) override;
 
-  virtual Error readProfilePreCFG(BinaryContext &BC) override;
+  Error readProfilePreCFG(BinaryContext &BC) override;
 
-  virtual Error readProfile(BinaryContext &BC) override;
+  Error readProfile(BinaryContext &BC) override;
 
-  virtual bool hasLocalsWithFileName() const override;
+  bool hasLocalsWithFileName() const override;
 
-  virtual bool mayHaveProfileData(const BinaryFunction &BF) override;
+  bool mayHaveProfileData(const BinaryFunction &BF) override;
 
   /// Return all event names used to collect this profile
-  virtual StringSet<> getEventNames() const override { return EventNames; }
+  StringSet<> getEventNames() const override { return EventNames; }
 
 protected:
   /// Read profile information available for the function.

bolt/include/bolt/Profile/YAMLProfileReader.h

@@ -33,9 +33,9 @@ class YAMLProfileReader : public ProfileReaderBase {
 
   Error preprocessProfile(BinaryContext &BC) override;
 
-  virtual bool hasLocalsWithFileName() const override;
+  bool hasLocalsWithFileName() const override;
 
-  virtual bool mayHaveProfileData(const BinaryFunction &BF) override;
+  bool mayHaveProfileData(const BinaryFunction &BF) override;
 
   /// Check if the file contains YAML.
   static bool isYAML(StringRef Filename);

bolt/lib/Core/BinaryContext.cpp

@@ -622,10 +622,6 @@ bool BinaryContext::analyzeJumpTable(
 void BinaryContext::populateJumpTables() {
   LLVM_DEBUG(dbgs() << "DataPCRelocations: " << DataPCRelocations.size()
                     << '\n');
-
-  // Collect jump tables that pass the analyzeJumpTable's first check,
-  // but fail the analyzeJumpTable's second check
-  SmallVector<JumpTable *, 1> AbortedJTs;
   for (auto JTI = JumpTables.begin(), JTE = JumpTables.end(); JTI != JTE;
        ++JTI) {
     JumpTable *JT = JTI->second;
@@ -644,13 +640,6 @@ void BinaryContext::populateJumpTables() {
     const bool Success =
         analyzeJumpTable(JT->getAddress(), JT->Type, *(JT->Parents[0]),
                          NextJTAddress, &JT->EntriesAsAddress);
-    // !Success means a false positive from earlier analysis run due to
-    // different context. A possible culprit is instruction bounds check.
-    // Previous run happens during disassembly. If the target function
-    // is not disassembled, the check will be skipped, leading to a false
-    // positive
-    //
-    // Solution: Ignore fragments accessing JT that fails the check
     if (!Success) {
       LLVM_DEBUG(ListSeparator LS;
                  dbgs() << "failed to analyze jump table in function ";
@@ -670,8 +659,7 @@ void BinaryContext::populateJumpTables() {
                    dbgs() << "\n";);
         NextJTI->second->print(dbgs());
       }
-      AbortedJTs.push_back(JT);
-      continue;
+      llvm_unreachable("jump table heuristic failure");
     }
     for (BinaryFunction *Frag : JT->Parents) {
       for (uint64_t EntryAddress : JT->EntriesAsAddress)
@@ -701,15 +689,6 @@ void BinaryContext::populateJumpTables() {
         addFragmentsToSkip(Frag);
   }
 
-  // Ignore fragments accessing JT that fails analyzeJumpTable check
-  for (JumpTable *JT : AbortedJTs) {
-    for (BinaryFunction *Frag : JT->Parents) {
-      Frag->setIgnored();
-      Frag->JumpTables.erase(Frag->JumpTables.find(JT->getAddress()));
-    }
-    JumpTables.erase(JumpTables.find(JT->getAddress()));
-  }
-
   if (opts::StrictMode && DataPCRelocations.size()) {
     LLVM_DEBUG({
       dbgs() << DataPCRelocations.size()
@@ -799,9 +778,8 @@ BinaryContext::getOrCreateJumpTable(BinaryFunction &Function, uint64_t Address,
     // Prevent associating a jump table to a specific fragment twice.
     // This simple check arises from the assumption: no more than 2 fragments.
     if (JT->Parents.size() == 1 && JT->Parents[0] != &Function) {
-      bool SameFunction = isFragmentOf(JT->Parents[0], &Function) ||
-                          isFragmentOf(&Function, JT->Parents[0]);
-      assert(SameFunction &&
+      assert((isFragmentOf(JT->Parents[0], &Function) ||
+              isFragmentOf(&Function, JT->Parents[0])) &&
              "cannot re-use jump table of a different function");
       // Duplicate the entry for the parent function for easy access
       JT->Parents.push_back(&Function);