LLVM and SPIRV-LLVM-Translator pulldown (WW20)

LLVM: llvm/llvm-project@2051755
SPIRV-LLVM-Translator: KhronosGroup/SPIRV-LLVM-Translator@772c7be

Author: bb-sycl

.github/workflows/release-tasks.yml

@@ -26,7 +26,7 @@ jobs:
 
       - name: Install Dependencies
         run: |
-          sudo apt-get update \
+          sudo apt-get update
           sudo apt-get install -y \
               doxygen \
               graphviz \

.github/workflows/repo-lockdown.yml

@@ -2,6 +2,11 @@ name: 'Repo Lockdown'
 on:
   pull_request_target:
     types: opened
+    paths-ignore:
+      - 'libcxx/**'
+      - 'libcxxabi/**'
+      - 'libunwind/**'
+      - 'runtimes/**'
 
 permissions:
   pull-requests: write

bolt/include/bolt/Core/Relocation.h

@@ -64,8 +64,7 @@ struct Relocation {
   static bool skipRelocationProcess(uint64_t &Type, uint64_t Contents);
 
   // Adjust value depending on relocation type (make it PC relative or not)
-  static uint64_t adjustValue(uint64_t Type, uint64_t Value,
-                              uint64_t PC);
+  static uint64_t encodeValue(uint64_t Type, uint64_t Value, uint64_t PC);
 
   /// Extract current relocated value from binary contents. This is used for
   /// RISC architectures where values are encoded in specific bits depending

bolt/lib/Core/BinarySection.cpp

@@ -146,7 +146,7 @@ void BinarySection::flushPendingRelocations(raw_pwrite_stream &OS,
     if (Reloc.Symbol)
       Value += Resolver(Reloc.Symbol);
 
-    Value = Relocation::adjustValue(Reloc.Type, Value,
+    Value = Relocation::encodeValue(Reloc.Type, Value,
                                     SectionAddress + Reloc.Offset);
 
     OS.pwrite(reinterpret_cast<const char *>(&Value),

bolt/lib/Core/HashUtilities.cpp

@@ -13,6 +13,7 @@
 #include "bolt/Core/HashUtilities.h"
 #include "bolt/Core/BinaryContext.h"
 #include "bolt/Core/BinaryFunction.h"
+#include "llvm/MC/MCInstPrinter.h"
 
 namespace llvm {
 namespace bolt {
@@ -116,13 +117,11 @@ std::string hashBlock(BinaryContext &BC, const BinaryBasicBlock &BB,
     if (IsX86 && BC.MIB->isConditionalBranch(Inst))
       Opcode = BC.MIB->getShortBranchOpcode(Opcode);
 
-    if (Opcode == 0)
+    if (Opcode == 0) {
       HashString.push_back(0);
-
-    while (Opcode) {
-      uint8_t LSB = Opcode & 0xff;
-      HashString.push_back(LSB);
-      Opcode = Opcode >> 8;
+    } else {
+      StringRef OpcodeName = BC.InstPrinter->getOpcodeName(Opcode);
+      HashString.append(OpcodeName.str());
     }
 
     for (const MCOperand &Op : MCPlus::primeOperands(Inst))

bolt/lib/Core/Relocation.cpp

@@ -262,10 +262,11 @@ static bool skipRelocationProcessAArch64(uint64_t &Type, uint64_t Contents) {
   return false;
 }
 
-static uint64_t adjustValueX86(uint64_t Type, uint64_t Value, uint64_t PC) {
+static uint64_t encodeValueX86(uint64_t Type, uint64_t Value, uint64_t PC) {
   switch (Type) {
   default:
-    llvm_unreachable("not supported relocation");
+    llvm_unreachable("unsupported relocation");
+  case ELF::R_X86_64_64:
   case ELF::R_X86_64_32:
     break;
   case ELF::R_X86_64_PC32:
@@ -275,10 +276,10 @@ static uint64_t adjustValueX86(uint64_t Type, uint64_t Value, uint64_t PC) {
   return Value;
 }
 
-static uint64_t adjustValueAArch64(uint64_t Type, uint64_t Value, uint64_t PC) {
+static uint64_t encodeValueAArch64(uint64_t Type, uint64_t Value, uint64_t PC) {
   switch (Type) {
   default:
-    llvm_unreachable("not supported relocation");
+    llvm_unreachable("unsupported relocation");
   case ELF::R_AARCH64_ABS32:
     break;
   case ELF::R_AARCH64_PREL16:
@@ -566,11 +567,10 @@ bool Relocation::skipRelocationProcess(uint64_t &Type, uint64_t Contents) {
   return skipRelocationProcessX86(Type, Contents);
 }
 
-uint64_t Relocation::adjustValue(uint64_t Type, uint64_t Value,
-                                 uint64_t PC) {
+uint64_t Relocation::encodeValue(uint64_t Type, uint64_t Value, uint64_t PC) {
   if (Arch == Triple::aarch64)
-    return adjustValueAArch64(Type, Value, PC);
-  return adjustValueX86(Type, Value, PC);
+    return encodeValueAArch64(Type, Value, PC);
+  return encodeValueX86(Type, Value, PC);
 }
 
 uint64_t Relocation::extractValue(uint64_t Type, uint64_t Contents,

bolt/lib/Passes/RetpolineInsertion.cpp

@@ -22,6 +22,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Passes/RetpolineInsertion.h"
+#include "llvm/MC/MCInstPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "bolt-retpoline"
@@ -173,39 +174,45 @@ BinaryFunction *createNewRetpoline(BinaryContext &BC,
 std::string createRetpolineFunctionTag(BinaryContext &BC,
                                        const IndirectBranchInfo &BrInfo,
                                        bool R11Available) {
-  if (BrInfo.isReg())
-    return "__retpoline_r" + to_string(BrInfo.BranchReg) + "_";
+  std::string Tag;
+  llvm::raw_string_ostream TagOS(Tag);
+  TagOS << "__retpoline_";
+
+  if (BrInfo.isReg()) {
+    BC.InstPrinter->printRegName(TagOS, BrInfo.BranchReg);
+    TagOS << "_";
+    TagOS.flush();
+    return Tag;
+  }
 
   // Memory Branch
   if (R11Available)
     return "__retpoline_r11";
 
-  std::string Tag = "__retpoline_mem_";
-
   const IndirectBranchInfo::MemOpInfo &MemRef = BrInfo.Memory;
 
-  std::string DispExprStr;
-  if (MemRef.DispExpr) {
-    llvm::raw_string_ostream Ostream(DispExprStr);
-    MemRef.DispExpr->print(Ostream, BC.AsmInfo.get());
-    Ostream.flush();
-  }
+  TagOS << "mem_";
 
-  Tag += MemRef.BaseRegNum != BC.MIB->getNoRegister()
-             ? "r" + to_string(MemRef.BaseRegNum)
-             : "";
+  if (MemRef.BaseRegNum != BC.MIB->getNoRegister())
+    BC.InstPrinter->printRegName(TagOS, MemRef.BaseRegNum);
 
-  Tag += MemRef.DispExpr ? "+" + DispExprStr : "+" + to_string(MemRef.DispImm);
+  TagOS << "+";
+  if (MemRef.DispExpr)
+    MemRef.DispExpr->print(TagOS, BC.AsmInfo.get());
+  else
+    TagOS << MemRef.DispImm;
 
-  Tag += MemRef.IndexRegNum != BC.MIB->getNoRegister()
-             ? "+" + to_string(MemRef.ScaleImm) + "*" +
-                   to_string(MemRef.IndexRegNum)
-             : "";
+  if (MemRef.IndexRegNum != BC.MIB->getNoRegister()) {
+    TagOS << "+" << MemRef.ScaleImm << "*";
+    BC.InstPrinter->printRegName(TagOS, MemRef.IndexRegNum);
+  }
 
-  Tag += MemRef.SegRegNum != BC.MIB->getNoRegister()
-             ? "_seg_" + to_string(MemRef.SegRegNum)
-             : "";
+  if (MemRef.SegRegNum != BC.MIB->getNoRegister()) {
+    TagOS << "_seg_";
+    BC.InstPrinter->printRegName(TagOS, MemRef.SegRegNum);
+  }
 
+  TagOS.flush();
   return Tag;
 }
 

bolt/lib/Rewrite/DWARFRewriter.cpp

@@ -199,7 +199,7 @@ void DWARFRewriter::updateDebugInfo() {
           std::make_unique<DebugLoclistWriter>(*CU.get(), DwarfVersion, false);
 
       if (std::optional<uint64_t> DWOId = CU->getDWOId()) {
-        assert(LocListWritersByCU.count(*DWOId) == 0 &&
+        assert(RangeListsWritersByCU.count(*DWOId) == 0 &&
                "RangeLists writer for DWO unit already exists.");
         auto RangeListsSectionWriter =
             std::make_unique<DebugRangeListsSectionWriter>();

bolt/runtime/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.13.4)
+cmake_minimum_required(VERSION 3.20.0)
 include(CheckIncludeFiles)
 include(GNUInstallDirs)
 

bolt/test/CMakeLists.txt

@@ -47,6 +47,7 @@ list(APPEND BOLT_TEST_DEPS
   llvm-objdump
   llvm-readelf
   llvm-readobj
+  llvm-strings
   llvm-strip
   llvm-objcopy
   merge-fdata

bolt/test/X86/Inputs/dwarf5-loc-base-no-loc-accesshelper.s

@@ -286,11 +286,10 @@ fooVar:
 	.long	.Lloclists_table_base0          # DW_AT_loclists_base
 	.byte	2                               # Abbrev [2] 0x27:0xb DW_TAG_variable
 	.byte	3                               # DW_AT_name
-	.long	50                              # DW_AT_type
+	.long	39                              # DW_AT_type
                                         # DW_AT_external
 	.byte	0                               # DW_AT_decl_file
 	.byte	1                               # DW_AT_decl_line
-	.byte	0
 	.byte	3                               # Abbrev [3] 0x32:0x4 DW_TAG_base_type
 	.byte	4                               # DW_AT_name
 	.byte	5                               # DW_AT_encoding
@@ -319,7 +318,7 @@ fooVar:
 	.long	88                              # DW_AT_type
 	.byte	0                               # End Of Children Mark
 	.byte	8                               # Abbrev [8] 0x58:0x5 DW_TAG_pointer_type
-	.long	50                              # DW_AT_type
+	.long	39                              # DW_AT_type
 	.byte	9                               # Abbrev [9] 0x5d:0x31 DW_TAG_subprogram
 	.byte	2                               # DW_AT_low_pc
 	.long	.Lfunc_end1-.Lfunc_begin1       # DW_AT_high_pc
@@ -330,18 +329,18 @@ fooVar:
 	.byte	9                               # DW_AT_name
 	.byte	0                               # DW_AT_decl_file
 	.byte	6                               # DW_AT_decl_line
-	.long	50                              # DW_AT_type
+	.long	39                              # DW_AT_type
                                         # DW_AT_external
 	.byte	10                              # Abbrev [10] 0x6d:0xa DW_TAG_formal_parameter
 	.byte	10                              # DW_AT_name
 	.byte	0                               # DW_AT_decl_file
 	.byte	6                               # DW_AT_decl_line
-	.long	50                              # DW_AT_type
+	.long	39                              # DW_AT_type
 	.byte	11                              # Abbrev [11] 0x77:0x9 DW_TAG_variable
 	.byte	7                               # DW_AT_name
 	.byte	0                               # DW_AT_decl_file
 	.byte	7                               # DW_AT_decl_line
-	.long	50                              # DW_AT_type
+	.long	39                              # DW_AT_type
 	.byte	12                              # Abbrev [12] 0x80:0xd DW_TAG_inlined_subroutine
 	.long	74                              # DW_AT_abstract_origin
 	.byte	2                               # DW_AT_low_pc

bolt/test/X86/cfi-expr-rewrite.s

@@ -11,7 +11,7 @@
 # CHECK-NEXT:  DW_CFA_expression: RBP DW_OP_breg6 RBP+0
 # CHECK-NEXT:  DW_CFA_advance_loc: 5
 # CHECK-NEXT:  DW_CFA_def_cfa_expression: DW_OP_breg6 RBP-8, DW_OP_deref
-# CHECK-NEXT:  DW_CFA_advance_loc2: 3174
+# CHECK-NEXT:  DW_CFA_advance_loc2: 3130
 # CHECK-NEXT:  DW_CFA_def_cfa: R10 +0
 # CHECK-NEXT:  DW_CFA_advance_loc: 5
 # CHECK-NEXT:  DW_CFA_def_cfa: RSP +8

bolt/test/lit.cfg.py

@@ -87,6 +87,7 @@
     ToolSubst('llvm-nm', unresolved='fatal'),
     ToolSubst('llvm-objdump', unresolved='fatal'),
     ToolSubst('llvm-objcopy', unresolved='fatal'),
+    ToolSubst('llvm-strings', unresolved='fatal'),
     ToolSubst('llvm-strip', unresolved='fatal'),
     ToolSubst('llvm-readelf', unresolved='fatal'),
     ToolSubst('link_fdata', command=sys.executable, unresolved='fatal', extra_args=[link_fdata_cmd]),

bolt/test/runtime/X86/retpoline-synthetic.test

@@ -20,5 +20,11 @@ CHECK-CALL-NOT: callq  *
 RUN: llvm-objdump -d -j ".text" %t | FileCheck %s -check-prefix=CHECK-JUMP
 CHECK-JUMP-NOT: jmpq   *
 
+# Check generated retpoline stub names
+RUN: llvm-strings %t | FileCheck %s -check-prefix=CHECK-STRINGS
+CHECK-STRINGS-DAG: __retpoline_%rax_
+CHECK-STRINGS-DAG: __retpoline_mem_%rip+DATAat0x[[#]]
+CHECK-STRINGS-DAG: __retpoline_mem_%rax+0
+
 RUN: %t 1000 3 | FileCheck %s
 CHECK: 30000000

clang-tools-extra/clang-tidy/ClangTidyCheck.h

@@ -407,7 +407,6 @@ class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
 
 private:
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
-  StringRef getID() const override { return CheckName; }
   std::string CheckName;
   ClangTidyContext *Context;
 
@@ -422,6 +421,7 @@ class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
   bool areDiagsSelfContained() const {
     return Context->areDiagsSelfContained();
   }
+  StringRef getID() const override { return CheckName; }
 };
 
 /// Read a named option from the ``Context`` and parse it as a bool.

clang-tools-extra/clang-tidy/bugprone/AssertSideEffectCheck.cpp

@@ -117,13 +117,13 @@ void AssertSideEffectCheck::check(const MatchFinder::MatchResult &Result) {
   StringRef AssertMacroName;
   while (Loc.isValid() && Loc.isMacroID()) {
     StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM, LangOpts);
+    Loc = SM.getImmediateMacroCallerLoc(Loc);
 
     // Check if this macro is an assert.
     if (llvm::is_contained(AssertMacros, MacroName)) {
       AssertMacroName = MacroName;
       break;
     }
-    Loc = SM.getImmediateMacroCallerLoc(Loc);
   }
   if (AssertMacroName.empty())
     return;

clang-tools-extra/clang-tidy/bugprone/UncheckedOptionalAccessCheck.cpp

@@ -40,7 +40,7 @@ analyzeFunction(const FunctionDecl &FuncDecl, ASTContext &ASTCtx,
   using llvm::Expected;
 
   Expected<ControlFlowContext> Context =
-      ControlFlowContext::build(&FuncDecl, *FuncDecl.getBody(), ASTCtx);
+      ControlFlowContext::build(FuncDecl, *FuncDecl.getBody(), ASTCtx);
   if (!Context)
     return std::nullopt;
 

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp

@@ -453,10 +453,6 @@ static bool containerIsConst(const Expr *ContainerExpr, bool Dereference) {
   return false;
 }
 
-LoopConvertCheck::RangeDescriptor::RangeDescriptor()
-    : ContainerNeedsDereference(false), DerefByConstRef(false),
-      DerefByValue(false), NeedsReverseCall(false) {}
-
 LoopConvertCheck::LoopConvertCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), TUInfo(new TUTrackingInfo),
       MaxCopySize(Options.get("MaxCopySize", 16ULL)),

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.h

@@ -29,13 +29,13 @@ class LoopConvertCheck : public ClangTidyCheck {
 
 private:
   struct RangeDescriptor {
-    RangeDescriptor();
-    bool ContainerNeedsDereference;
-    bool DerefByConstRef;
-    bool DerefByValue;
+    RangeDescriptor() = default;
+    bool ContainerNeedsDereference = false;
+    bool DerefByConstRef = false;
+    bool DerefByValue = false;
     std::string ContainerString;
     QualType ElemType;
-    bool NeedsReverseCall;
+    bool NeedsReverseCall = false;
   };
 
   void getAliasRange(SourceManager &SM, SourceRange &DeclRange);

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

@@ -14,6 +14,7 @@
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
@@ -396,7 +397,7 @@ std::string IdentifierNamingCheck::HungarianNotation::getDeclTypeName(
 
 IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name,
                                              ClangTidyContext *Context)
-    : RenamerClangTidyCheck(Name, Context), Context(Context), CheckName(Name),
+    : RenamerClangTidyCheck(Name, Context), Context(Context),
       GetConfigPerFile(Options.get("GetConfigPerFile", true)),
       IgnoreFailedSplit(Options.get("IgnoreFailedSplit", false)) {
 
@@ -1461,6 +1462,7 @@ IdentifierNamingCheck::getStyleForFile(StringRef FileName) const {
   if (Iter != NamingStylesCache.end())
     return Iter->getValue();
 
+  llvm::StringRef CheckName = getID();
   ClangTidyOptions Options = Context->getOptionsForFile(FileName);
   if (Options.Checks && GlobList(*Options.Checks).contains(CheckName)) {
     auto It = NamingStylesCache.try_emplace(

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h

@@ -11,6 +11,7 @@
 
 #include "../utils/RenamerClangTidyCheck.h"
 #include <optional>
+#include <string>
 namespace clang::tidy {
 namespace readability {
 
@@ -202,7 +203,6 @@ class IdentifierNamingCheck final : public RenamerClangTidyCheck {
   mutable llvm::StringMap<FileStyle> NamingStylesCache;
   FileStyle *MainFileStyle;
   ClangTidyContext *Context;
-  const StringRef CheckName;
   const bool GetConfigPerFile;
   const bool IgnoreFailedSplit;
   HungarianNotation HungarianNotation;