Merge branch 'sycl' of https://github.com/intel/llvm into ij30862

Author: rdeodhar

.github/workflows/linux_post_commit.yml

@@ -6,7 +6,7 @@ on:
       - sycl
 jobs:
    check:
-     runs-on: ubuntu-18.04
+     runs-on: ubuntu-20.04
      if: github.repository == 'intel/llvm'
      strategy:
        fail-fast: false
@@ -18,7 +18,15 @@ jobs:
        with:
          path: src
      - name: Install Ubuntu deps
-       run: sudo apt install -y ninja-build
+       run: sudo apt install -y ninja-build ccache
+     - name: Setup Cache
+       uses: actions/cache@v2
+       id: cache
+       with:
+         path: ${{ github.workspace }}/cache
+         key: build-${{ runner.os }}-${{ matrix.config }}-${{ github.sha }}
+         restore-keys: |
+           build-${{ runner.os }}-${{ matrix.config }}-
      - name: Configure
        run: |
          CONFIG=${{ matrix.config }}
@@ -28,12 +36,12 @@ jobs:
                  ;;
              SharedLibs)
                  wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-                 sudo add-apt-repository "deb http://apt.llvm.org/bionic/   llvm-toolchain-bionic-12 main"
+                 sudo add-apt-repository "deb http://apt.llvm.org/focal/   llvm-toolchain-focal-13 main"
                  sudo apt-get update
-                 sudo apt-get install -y clang-12
+                 sudo apt-get install -y clang-13
                  export ARGS="--shared-libs"
-                 export CC="clang-12"
-                 export CXX="clang++-12"
+                 export CC="clang-13"
+                 export CXX="clang++-13"
                  ;;
              NoAssertions)
                  export ARGS="--no-assertions"
@@ -42,7 +50,10 @@ jobs:
          mkdir -p $GITHUB_WORKSPACE/build
          cd $GITHUB_WORKSPACE/build
          python3 $GITHUB_WORKSPACE/src/buildbot/configure.py -w $GITHUB_WORKSPACE \
-         -s $GITHUB_WORKSPACE/src -o $GITHUB_WORKSPACE/build -t Release $ARGS
+         -s $GITHUB_WORKSPACE/src -o $GITHUB_WORKSPACE/build -t Release \
+         --ci-defaults $ARGS --cmake-opt="-DLLVM_CCACHE_BUILD=ON" \
+         --cmake-opt="-DLLVM_CCACHE_DIR=$GITHUB_WORKSPACE/cache" \
+         --cmake-opt="-DLLVM_CCACHE_MAXSIZE=2G"
      - name: Compile
        run: |
          python3 $GITHUB_WORKSPACE/src/buildbot/compile.py -w  $GITHUB_WORKSPACE \
@@ -74,4 +85,3 @@ jobs:
        with:
          name: sycl_linux_${{ matrix.config }}
          path: llvm_sycl.tar.gz
-

buildbot/configure.py

@@ -41,6 +41,11 @@ def do_configure(args):
 
     sycl_enable_xpti_tracing = 'ON'
 
+    if args.ci_defaults:
+        print("#############################################")
+        print("# Default CI configuration will be applied. #")
+        print("#############################################")
+
     # replace not append, so ARM ^ X86
     if args.arm:
         llvm_targets_to_build = 'ARM;AArch64'
@@ -193,6 +198,7 @@ def main():
     parser.add_argument("--libcxx-library", metavar="LIBCXX_LIBRARY_PATH", help="libcxx library path")
     parser.add_argument("--use-lld", action="store_true", help="Use LLD linker for build")
     parser.add_argument("--llvm-external-projects", help="Add external projects to build. Add as comma seperated list.")
+    parser.add_argument("--ci-defaults", action="store_true", help="Enable default CI parameters")
     args = parser.parse_args()
 
     print("args:{}".format(args))

buildbot/dependency.conf

@@ -4,11 +4,11 @@ ocl_cpu_rt_ver=2021.12.6.0.19
 # https://github.com/intel/llvm/releases/download/2021-WW26/win-oclcpuexp-2021.12.6.0.19_rel.zip
 ocl_cpu_rt_ver_win=2021.12.6.0.19
 # Same GPU driver supports Level Zero and OpenCL
-# https://github.com/intel/compute-runtime/releases/tag/21.34.20767
-ocl_gpu_rt_ver=21.34.20767
+# https://github.com/intel/compute-runtime/releases/tag/21.37.20939
+ocl_gpu_rt_ver=21.37.20939
 # Same GPU driver supports Level Zero and OpenCL
-# https://downloadmirror.intel.com/646152/igfx_win_100.9805.zip
-ocl_gpu_rt_ver_win=30.0.100.9805
+# https://downloadmirror.intel.com/648245/igfx_win_100.9864.zip
+ocl_gpu_rt_ver_win=30.0.100.9864
 intel_sycl_ver=build
 
 # TBB binaries can be built from sources following instructions under
@@ -30,8 +30,8 @@ ocloc_ver_win=27.20.100.9168
 [DRIVER VERSIONS]
 cpu_driver_lin=2021.12.6.0.19
 cpu_driver_win=2021.12.6.0.19
-gpu_driver_lin=21.34.20767
-gpu_driver_win=30.0.100.9805
+gpu_driver_lin=21.37.20939
+gpu_driver_win=30.0.100.9864
 fpga_driver_lin=2021.12.6.0.19
 fpga_driver_win=2021.12.6.0.19
 # NVidia CUDA driver

clang-tools-extra/clang-tidy/abseil/AbseilMatcher.h

@@ -47,15 +47,11 @@ AST_POLYMORPHIC_MATCHER(
   if (PrefixPosition == StringRef::npos)
     return false;
   Path = Path.drop_front(PrefixPosition + AbslPrefix.size());
-  static const char *AbseilLibraries[] = {"algorithm", "base",
-                                          "container", "debugging",
-                                          "flags",     "hash",
-                                          "iterator",  "memory",
-                                          "meta",      "numeric",
-                                          "random",    "status",
-                                          "strings",   "synchronization",
-                                          "time",      "types",
-                                          "utility"};
+  static const char *AbseilLibraries[] = {
+      "algorithm", "base",     "container", "debugging", "flags",
+      "hash",      "iterator", "memory",    "meta",      "numeric",
+      "profiling", "random",   "status",    "strings",   "synchronization",
+      "time",      "types",    "utility"};
   return llvm::any_of(AbseilLibraries, [&](const char *Library) {
     return Path.startswith(Library);
   });

clang-tools-extra/clang-tidy/add_new_check.py

@@ -9,6 +9,7 @@
 #===-----------------------------------------------------------------------===#
 
 from __future__ import print_function
+from __future__ import unicode_literals
 
 import argparse
 import io

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

@@ -65,6 +65,17 @@ static bool isVarThatIsPossiblyChanged(const Decl *Func, const Stmt *LoopStmt,
                  ObjCIvarRefExpr, ObjCPropertyRefExpr, ObjCMessageExpr>(Cond)) {
     // FIXME: Handle MemberExpr.
     return true;
+  } else if (const auto *CE = dyn_cast<CastExpr>(Cond)) {
+    QualType T = CE->getType();
+    while (true) {
+      if (T.isVolatileQualified())
+        return true;
+
+      if (!T->isAnyPointerType() && !T->isReferenceType())
+        break;
+
+      T = T->getPointeeType();
+    }
   }
 
   return false;

clang-tools-extra/clang-tidy/cppcoreguidelines/CMakeLists.txt

@@ -26,6 +26,7 @@ add_clang_library(clangTidyCppCoreGuidelinesModule
   ProTypeVarargCheck.cpp
   SlicingCheck.cpp
   SpecialMemberFunctionsCheck.cpp
+  VirtualClassDestructorCheck.cpp
 
   LINK_LIBS
   clangTidy

clang-tools-extra/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

@@ -35,6 +35,7 @@
 #include "ProTypeVarargCheck.h"
 #include "SlicingCheck.h"
 #include "SpecialMemberFunctionsCheck.h"
+#include "VirtualClassDestructorCheck.h"
 
 namespace clang {
 namespace tidy {
@@ -94,6 +95,8 @@ class CppCoreGuidelinesModule : public ClangTidyModule {
     CheckFactories.registerCheck<SlicingCheck>("cppcoreguidelines-slicing");
     CheckFactories.registerCheck<misc::UnconventionalAssignOperatorCheck>(
         "cppcoreguidelines-c-copy-assignment-signature");
+    CheckFactories.registerCheck<VirtualClassDestructorCheck>(
+        "cppcoreguidelines-virtual-class-destructor");
   }
 
   ClangTidyOptions getModuleOptions() override {

clang-tools-extra/clang-tidy/cppcoreguidelines/PreferMemberInitializerCheck.cpp

@@ -83,7 +83,7 @@ static bool isSafeAssignment(const FieldDecl *Field, const Expr *Init,
       .empty();
 }
 
-static const std::pair<const FieldDecl *, const Expr *>
+static std::pair<const FieldDecl *, const Expr *>
 isAssignmentToMemberOf(const CXXRecordDecl *Rec, const Stmt *S,
                        const CXXConstructorDecl *Ctor) {
   if (const auto *BO = dyn_cast<BinaryOperator>(S)) {

clang-tools-extra/clang-tidy/cppcoreguidelines/VirtualClassDestructorCheck.cpp

@@ -0,0 +1,200 @@
+//===--- VirtualClassDestructorCheck.cpp - clang-tidy -----------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "VirtualClassDestructorCheck.h"
+#include "../utils/LexerUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+#include <string>
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace cppcoreguidelines {
+
+void VirtualClassDestructorCheck::registerMatchers(MatchFinder *Finder) {
+  ast_matchers::internal::Matcher<CXXRecordDecl> InheritsVirtualMethod =
+      hasAnyBase(hasType(cxxRecordDecl(has(cxxMethodDecl(isVirtual())))));
+
+  Finder->addMatcher(
+      cxxRecordDecl(
+          anyOf(has(cxxMethodDecl(isVirtual())), InheritsVirtualMethod),
+          unless(anyOf(
+              has(cxxDestructorDecl(isPublic(), isVirtual())),
+              has(cxxDestructorDecl(isProtected(), unless(isVirtual()))))))
+          .bind("ProblematicClassOrStruct"),
+      this);
+}
+
+static CharSourceRange
+getVirtualKeywordRange(const CXXDestructorDecl &Destructor,
+                       const SourceManager &SM, const LangOptions &LangOpts) {
+  SourceLocation VirtualBeginLoc = Destructor.getBeginLoc();
+  SourceLocation VirtualEndLoc = VirtualBeginLoc.getLocWithOffset(
+      Lexer::MeasureTokenLength(VirtualBeginLoc, SM, LangOpts));
+
+  /// Range ends with \c StartOfNextToken so that any whitespace after \c
+  /// virtual is included.
+  SourceLocation StartOfNextToken =
+      Lexer::findNextToken(VirtualEndLoc, SM, LangOpts)
+          .getValue()
+          .getLocation();
+
+  return CharSourceRange::getCharRange(VirtualBeginLoc, StartOfNextToken);
+}
+
+static const AccessSpecDecl *
+getPublicASDecl(const CXXRecordDecl &StructOrClass) {
+  for (DeclContext::specific_decl_iterator<AccessSpecDecl>
+           AS{StructOrClass.decls_begin()},
+       ASEnd{StructOrClass.decls_end()};
+       AS != ASEnd; ++AS) {
+    AccessSpecDecl *ASDecl = *AS;
+    if (ASDecl->getAccess() == AccessSpecifier::AS_public)
+      return ASDecl;
+  }
+
+  return nullptr;
+}
+
+static FixItHint
+generateUserDeclaredDestructor(const CXXRecordDecl &StructOrClass,
+                               const SourceManager &SourceManager) {
+  std::string DestructorString;
+  SourceLocation Loc;
+  bool AppendLineBreak = false;
+
+  const AccessSpecDecl *AccessSpecDecl = getPublicASDecl(StructOrClass);
+
+  if (!AccessSpecDecl) {
+    if (StructOrClass.isClass()) {
+      Loc = StructOrClass.getEndLoc();
+      DestructorString = "public:";
+      AppendLineBreak = true;
+    } else {
+      Loc = StructOrClass.getBraceRange().getBegin().getLocWithOffset(1);
+    }
+  } else {
+    Loc = AccessSpecDecl->getEndLoc().getLocWithOffset(1);
+  }
+
+  DestructorString = (llvm::Twine(DestructorString) + "\nvirtual ~" +
+                      StructOrClass.getName().str() + "() = default;" +
+                      (AppendLineBreak ? "\n" : ""))
+                         .str();
+
+  return FixItHint::CreateInsertion(Loc, DestructorString);
+}
+
+static std::string getSourceText(const CXXDestructorDecl &Destructor) {
+  std::string SourceText;
+  llvm::raw_string_ostream DestructorStream(SourceText);
+  Destructor.print(DestructorStream);
+  return SourceText;
+}
+
+static std::string eraseKeyword(std::string &DestructorString,
+                                const std::string &Keyword) {
+  size_t KeywordIndex = DestructorString.find(Keyword);
+  if (KeywordIndex != std::string::npos)
+    DestructorString.erase(KeywordIndex, Keyword.length());
+  return DestructorString;
+}
+
+static FixItHint changePrivateDestructorVisibilityTo(
+    const std::string &Visibility, const CXXDestructorDecl &Destructor,
+    const SourceManager &SM, const LangOptions &LangOpts) {
+  std::string DestructorString =
+      (llvm::Twine() + Visibility + ":\n" +
+       (Visibility == "public" && !Destructor.isVirtual() ? "virtual " : ""))
+          .str();
+
+  std::string OriginalDestructor = getSourceText(Destructor);
+  if (Visibility == "protected" && Destructor.isVirtualAsWritten())
+    OriginalDestructor = eraseKeyword(OriginalDestructor, "virtual ");
+
+  DestructorString =
+      (llvm::Twine(DestructorString) + OriginalDestructor +
+       (Destructor.isExplicitlyDefaulted() ? ";\n" : "") + "private:")
+          .str();
+
+  /// Semicolons ending an explicitly defaulted destructor have to be deleted.
+  /// Otherwise, the left-over semicolon trails the \c private: access
+  /// specifier.
+  SourceLocation EndLocation;
+  if (Destructor.isExplicitlyDefaulted())
+    EndLocation =
+        utils::lexer::findNextTerminator(Destructor.getEndLoc(), SM, LangOpts)
+            .getLocWithOffset(1);
+  else
+    EndLocation = Destructor.getEndLoc().getLocWithOffset(1);
+
+  auto OriginalDestructorRange =
+      CharSourceRange::getCharRange(Destructor.getBeginLoc(), EndLocation);
+  return FixItHint::CreateReplacement(OriginalDestructorRange,
+                                      DestructorString);
+}
+
+void VirtualClassDestructorCheck::check(
+    const MatchFinder::MatchResult &Result) {
+
+  const auto *MatchedClassOrStruct =
+      Result.Nodes.getNodeAs<CXXRecordDecl>("ProblematicClassOrStruct");
+
+  const CXXDestructorDecl *Destructor = MatchedClassOrStruct->getDestructor();
+  if (!Destructor)
+    return;
+
+  if (Destructor->getAccess() == AccessSpecifier::AS_private) {
+    diag(MatchedClassOrStruct->getLocation(),
+         "destructor of %0 is private and prevents using the type")
+        << MatchedClassOrStruct;
+    diag(MatchedClassOrStruct->getLocation(),
+         /*FixDescription=*/"make it public and virtual", DiagnosticIDs::Note)
+        << changePrivateDestructorVisibilityTo(
+               "public", *Destructor, *Result.SourceManager, getLangOpts());
+    diag(MatchedClassOrStruct->getLocation(),
+         /*FixDescription=*/"make it protected", DiagnosticIDs::Note)
+        << changePrivateDestructorVisibilityTo(
+               "protected", *Destructor, *Result.SourceManager, getLangOpts());
+
+    return;
+  }
+
+  // Implicit destructors are public and non-virtual for classes and structs.
+  bool ProtectedAndVirtual = false;
+  FixItHint Fix;
+
+  if (MatchedClassOrStruct->hasUserDeclaredDestructor()) {
+    if (Destructor->getAccess() == AccessSpecifier::AS_public) {
+      Fix = FixItHint::CreateInsertion(Destructor->getLocation(), "virtual ");
+    } else if (Destructor->getAccess() == AccessSpecifier::AS_protected) {
+      ProtectedAndVirtual = true;
+      Fix = FixItHint::CreateRemoval(getVirtualKeywordRange(
+          *Destructor, *Result.SourceManager, Result.Context->getLangOpts()));
+    }
+  } else {
+    Fix = generateUserDeclaredDestructor(*MatchedClassOrStruct,
+                                         *Result.SourceManager);
+  }
+
+  diag(MatchedClassOrStruct->getLocation(),
+       "destructor of %0 is %select{public and non-virtual|protected and "
+       "virtual}1")
+      << MatchedClassOrStruct << ProtectedAndVirtual;
+  diag(MatchedClassOrStruct->getLocation(),
+       "make it %select{public and virtual|protected and non-virtual}0",
+       DiagnosticIDs::Note)
+      << ProtectedAndVirtual << Fix;
+}
+
+} // namespace cppcoreguidelines
+} // namespace tidy
+} // namespace clang