LLVM and SPIRV-LLVM-Translator pulldown (WW16)

LLVM: llvm/llvm-project@b9ba053
SPIRV-LLVM-Translator: KhronosGroup/SPIRV-LLVM-Translator@0ed2286

Author: bb-sycl

bolt/lib/Core/BinaryFunction.cpp

@@ -2038,6 +2038,7 @@ bool BinaryFunction::buildCFG(MCPlusBuilder::AllocatorIdTy AllocatorId) {
       MCInst *PrevInstr = PrevBB->getLastNonPseudoInstr();
       assert(PrevInstr && "no previous instruction for a fall through");
       if (MIB->isUnconditionalBranch(Instr) &&
+          !MIB->isIndirectBranch(*PrevInstr) &&
           !MIB->isUnconditionalBranch(*PrevInstr) &&
           !MIB->getConditionalTailCall(*PrevInstr) &&
           !MIB->isReturn(*PrevInstr)) {

bolt/lib/Core/DebugData.cpp

@@ -1166,7 +1166,7 @@ void DebugStrOffsetsWriter::initialize(
          "Dwarf String Offsets Byte Size is not supported.");
   uint32_t Index = 0;
   for (uint64_t Offset = 0; Offset < Contr->Size; Offset += DwarfOffsetByteSize)
-    IndexToAddressMap[Index++] = *reinterpret_cast<const uint32_t *>(
+    IndexToAddressMap[Index++] = support::endian::read32le(
         StrOffsetsSection.Data.data() + Contr->Base + Offset);
 }
 

bolt/lib/Target/AArch64/AArch64MCPlusBuilder.cpp

@@ -265,7 +265,7 @@ class AArch64MCPlusBuilder : public MCPlusBuilder {
         return true;
       }
 
-      DispImm = Inst.getOperand(I).getImm() << 2;
+      DispImm = Inst.getOperand(I).getImm() * 4;
       return true;
     }
     return false;

bolt/test/X86/section-end-sym.s

@@ -1,7 +1,7 @@
 ## Check that BOLT doesn't consider end-of-section symbols (e.g., _etext) as
 ## functions.
 
-# REQUIRES: system-linux, asserts
+# REQUIRES: x86_64-linux, asserts
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t.exe -q

bolt/test/X86/unreachable-jmp.s

@@ -0,0 +1,66 @@
+# This checks that we don't create an invalid CFG when there is an
+# unreachable direct jump right after an indirect one.
+
+# REQUIRES: system-linux
+
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
+# RUN:   %s -o %t.o
+# RUN: link_fdata %s %t.o %t.fdata
+# RUN: llvm-strip --strip-unneeded %t.o
+# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q -nostdlib
+# RUN: llvm-bolt %t.exe -o %t.out --data %t.fdata \
+# RUN:     --eliminate-unreachable --print-cfg | FileCheck %s
+
+  .globl _start
+  .type _start, %function
+_start:
+  .cfi_startproc
+# FDATA: 0 [unknown] 0 1 _start 0 0 1
+  push  %rbp
+  mov   %rsp, %rbp
+  push  %rbx
+  push  %r14
+  subq  $0x20, %rsp
+  movq  %rdi, %rcx
+b:
+  jmpq  *JUMP_TABLE(,%rcx,8)
+# FDATA: 1 _start #b# 1 _start #hotpath# 0 20
+# Unreachable direct jump here. Our CFG should still make sense and properly
+# place this instruction in a new basic block.
+  jmp  .lbb2
+.lbb1:  je  .lexit
+.lbb2:
+  xorq  %rax, %rax
+  addq  $0x20, %rsp
+  pop %r14
+  pop %rbx
+  pop %rbp
+  ret
+hotpath:
+  movq  $2, %rax
+  addq  $0x20, %rsp
+  pop %r14
+  pop %rbx
+  pop %rbp
+  ret
+.lexit:
+  movq  $1, %rax
+  addq  $0x20, %rsp
+  pop %r14
+  pop %rbx
+  pop %rbp
+  ret
+  .cfi_endproc
+  .size _start, .-_start
+
+  .rodata
+  .globl JUMP_TABLE
+JUMP_TABLE:
+  .quad .lbb1
+  .quad .lbb2
+  .quad hotpath
+
+# No basic blocks above should have 4 successors! That is a bug.
+# CHECK-NOT:   Successors: {{.*}} (mispreds: 0, count: 20), {{.*}} (mispreds: 0, count: 0), {{.*}} (mispreds: 0, count: 0), {{.*}} (mispreds: 0, count: 0)
+# Check successful removal of stray direct jmp
+#  CHECK:  UCE removed 1 block

clang-tools-extra/clang-include-fixer/find-all-symbols/STLPostfixHeaderMap.cpp

@@ -267,6 +267,7 @@ const HeaderMapCollector::RegexHeaderMap *getSTLPostfixHeaderMap() {
       {"unordered_set$", "<unordered_set>"},
       {"utility$", "<utility>"},
       {"valarray$", "<valarray>"},
+      {"variant$", "<variant>"},
       {"vector$", "<vector>"},
       {"include/complex.h$", "<complex.h>"},
       {"include/ctype.h$", "<cctype>"},

clang-tools-extra/clang-tidy/ClangTidyOptions.cpp

@@ -117,10 +117,48 @@ void yamlize(IO &IO, ClangTidyOptions::OptionMap &Options, bool,
   }
 }
 
+struct ChecksVariant {
+  std::optional<std::string> AsString;
+  std::optional<std::vector<std::string>> AsVector;
+};
+
+template <>
+void yamlize(IO &IO, ChecksVariant &Checks, bool, EmptyContext &Ctx) {
+  if (!IO.outputting()) {
+    // Special case for reading from YAML
+    // Must support reading from both a string or a list
+    Input &I = reinterpret_cast<Input &>(IO);
+    if (isa<ScalarNode, BlockScalarNode>(I.getCurrentNode())) {
+      Checks.AsString = std::string();
+      yamlize(IO, *Checks.AsString, true, Ctx);
+    } else if (isa<SequenceNode>(I.getCurrentNode())) {
+      Checks.AsVector = std::vector<std::string>();
+      yamlize(IO, *Checks.AsVector, true, Ctx);
+    } else {
+      IO.setError("expected string or sequence");
+    }
+  }
+}
+
+static void mapChecks(IO &IO, std::optional<std::string> &Checks) {
+  if (IO.outputting()) {
+    // Output always a string
+    IO.mapOptional("Checks", Checks);
+  } else {
+    // Input as either a string or a list
+    ChecksVariant ChecksAsVariant;
+    IO.mapOptional("Checks", ChecksAsVariant);
+    if (ChecksAsVariant.AsString)
+      Checks = ChecksAsVariant.AsString;
+    else if (ChecksAsVariant.AsVector)
+      Checks = llvm::join(*ChecksAsVariant.AsVector, ",");
+  }
+}
+
 template <> struct MappingTraits<ClangTidyOptions> {
   static void mapping(IO &IO, ClangTidyOptions &Options) {
     bool Ignored = false;
-    IO.mapOptional("Checks", Options.Checks);
+    mapChecks(IO, Options.Checks);
     IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
     IO.mapOptional("HeaderFileExtensions", Options.HeaderFileExtensions);
     IO.mapOptional("ImplementationFileExtensions",

clang-tools-extra/clang-tidy/altera/IdDependentBackwardBranchCheck.cpp

@@ -31,12 +31,12 @@ void IdDependentBackwardBranchCheck::registerMatchers(MatchFinder *Finder) {
               stmt(
                   anyOf(declStmt(hasDescendant(varDecl(hasInitializer(ThreadID))
                                                    .bind("tid_dep_var"))),
-                        binaryOperator(allOf(
+                        binaryOperator(
                             isAssignmentOperator(), hasRHS(ThreadID),
                             hasLHS(anyOf(
                                 declRefExpr(to(varDecl().bind("tid_dep_var"))),
                                 memberExpr(member(
-                                    fieldDecl().bind("tid_dep_field")))))))))
+                                    fieldDecl().bind("tid_dep_field"))))))))
                   .bind("straight_assignment"))),
       this);
 

clang-tools-extra/clang-tidy/altera/SingleWorkItemBarrierCheck.cpp

@@ -22,17 +22,16 @@ void SingleWorkItemBarrierCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       // Find function declarations...
       functionDecl(
-          allOf(
-              // That are OpenCL kernels...
-              hasAttr(attr::Kind::OpenCLKernel),
-              // And call a barrier function (either 1.x or 2.x version)...
-              forEachDescendant(callExpr(callee(functionDecl(hasAnyName(
-                                             "barrier", "work_group_barrier"))))
-                                    .bind("barrier")),
-              // But do not call an ID function.
-              unless(hasDescendant(callExpr(callee(functionDecl(
-                  hasAnyName("get_global_id", "get_local_id", "get_group_id",
-                             "get_local_linear_id"))))))))
+          // That are OpenCL kernels...
+          hasAttr(attr::Kind::OpenCLKernel),
+          // And call a barrier function (either 1.x or 2.x version)...
+          forEachDescendant(callExpr(callee(functionDecl(hasAnyName(
+                                         "barrier", "work_group_barrier"))))
+                                .bind("barrier")),
+          // But do not call an ID function.
+          unless(hasDescendant(callExpr(callee(functionDecl(
+              hasAnyName("get_global_id", "get_local_id", "get_group_id",
+                         "get_local_linear_id")))))))
           .bind("function"),
       this);
 }

clang-tools-extra/clang-tidy/altera/UnrollLoopsCheck.cpp

@@ -25,14 +25,13 @@ UnrollLoopsCheck::UnrollLoopsCheck(StringRef Name, ClangTidyContext *Context)
 
 void UnrollLoopsCheck::registerMatchers(MatchFinder *Finder) {
   const auto HasLoopBound = hasDescendant(
-      varDecl(allOf(matchesName("__end*"),
-                    hasDescendant(integerLiteral().bind("cxx_loop_bound")))));
+      varDecl(matchesName("__end*"),
+              hasDescendant(integerLiteral().bind("cxx_loop_bound"))));
   const auto CXXForRangeLoop =
       cxxForRangeStmt(anyOf(HasLoopBound, unless(HasLoopBound)));
   const auto AnyLoop = anyOf(forStmt(), whileStmt(), doStmt(), CXXForRangeLoop);
   Finder->addMatcher(
-      stmt(allOf(AnyLoop, unless(hasDescendant(stmt(AnyLoop))))).bind("loop"),
-      this);
+      stmt(AnyLoop, unless(hasDescendant(stmt(AnyLoop)))).bind("loop"), this);
 }
 
 void UnrollLoopsCheck::check(const MatchFinder::MatchResult &Result) {