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

Author: dongkyunahn-intel

.github/CODEOWNERS

@@ -25,7 +25,7 @@ sycl/ @intel/llvm-reviewers-runtime
 sycl/ReleaseNotes.md @pvchupin @tfzhu
 sycl/doc/ @pvchupin @bader
 sycl/doc/extensions/ @intel/dpcpp-specification-reviewers
-sycl/doc/SPIRV @AlexeySotkin @bashbaug @mbelicki
+sycl/doc/extensions/SPIRV/ @AlexeySotkin @bashbaug @mbelicki
 
 # Sub-groups
 sycl/include/CL/sycl/detail/spirv.hpp @Pennycook @AlexeySachkov

.mailmap

@@ -24,6 +24,7 @@
 
 <[email protected]> <[email protected]>
 <[email protected]> <[email protected]>
+<[email protected]> <[email protected]>
 <[email protected]> <[email protected]>
 <[email protected]> <[email protected]>
 <[email protected]> <[email protected]>

CONTRIBUTING.md

@@ -62,21 +62,37 @@ Every product change should be accompanied with corresponding test modification
 (adding new test(s), extending, removing or modifying existing test(s)).
 
 There are 3 types of tests which are used for DPC++ toolchain validation:
-* DPC++ in-tree LIT tests including [check-llvm](../../llvm/test),
-[check-clang](../../clang/test), [check-llvm-spirv](../../llvm-spirv/test) and
-[check-sycl](../../sycl/test) targets stored in this repository. These tests
+* DPC++ in-tree tests including [check-llvm](llvm/test),
+[check-clang](clang/test), [check-llvm-spirv](llvm-spirv/test) and
+[check-sycl](sycl/test) targets stored in this repository. These tests
 should not have hardware (e.g. GPU, FPGA, etc.) or external software
 dependencies (e.g. OpenCL, Level Zero, CUDA runtimes). All tests not following
 this approach should be moved to DPC++ end-to-end or SYCL-CTS tests.
+Generally, any functional change to any of the DPC++ toolchain components
+should be accompanied by one or more tests of this type when possible. They
+allow verifying individual components and tend to be more lightweight than
+end-to-end or SYCL-CTS tests.
+
+    **General guidelines for adding DPC++ in-tree tests**:
 
-    **Guidelines for adding DPC++ in-tree LIT tests (DPC++ Clang FE tests)**:
     - Use `sycl::` namespace instead of `cl::sycl::`
 
+    - Add a helpful comment describing what the test does at the beginning and
+    other comments throughout the test as necessary.
+
+    - Try to follow descriptive naming convention for variables, functions as
+    much as possible.
+    Please refer to
+    [LLVM naming convention](https://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly)
+
+    **DPC++ clang FE tests**:
+
     - Include sycl mock headers as system headers.
     Example: `-internal-isystem %S/Inputs`
     `#include "sycl.hpp"`
 
-    - Use SYCL functions for invoking kernels from the mock header `(single_task, parallel_for, parallel_for_work_group)`
+    - Use SYCL functions for invoking kernels from the mock header
+    `(single_task, parallel_for, parallel_for_work_group)`
     Example:
     ```bash
     `#include "Inputs/sycl.hpp"`
@@ -86,10 +102,14 @@ this approach should be moved to DPC++ end-to-end or SYCL-CTS tests.
     });
     ```
 
-    - Add a helpful comment describing what the test does at the beginning and other comments throughout the test as necessary.
+    **DPC++ headers and runtime tests**:
 
-    - Try to follow descriptive naming convention for variables, functions as much as possible.
-    Please refer [LLVM naming convention](https://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly)
+    - [check-sycl](sycl/test) target contains 2 types of tests: LIT tests and
+    unit tests. LIT tests make compile-time checks of DPC++ headers, e.g. device
+    code IR verification, static_assert tests. Unit tests check DPC++ runtime
+    behavior and do not perform any device code compilation, instead relying on
+    redefining plugin API with [PiMock](sycl/unittests/helpers/PiMock.hpp) when
+    necessary.
 
 * DPC++ end-to-end (E2E) tests which are extension to
 [LLVM\* test suite](https://github.com/intel/llvm-test-suite/tree/intel/SYCL).

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

@@ -24,6 +24,8 @@ AST_MATCHER(Decl, isFromStdNamespaceOrSystemHeader) {
   if (const auto *D = Node.getDeclContext()->getEnclosingNamespaceContext())
     if (D->isStdNamespace())
       return true;
+  if (Node.getLocation().isInvalid())
+    return false;
   return Node.getASTContext().getSourceManager().isInSystemHeader(
       Node.getLocation());
 }

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

@@ -106,9 +106,6 @@ class CppCoreGuidelinesModule : public ClangTidyModule {
     Opts["cppcoreguidelines-non-private-member-variables-in-classes."
          "IgnoreClassesWithAllMemberVariablesBeingPublic"] = "true";
 
-    Opts["cppcoreguidelines-explicit-virtual-functions."
-         "IgnoreDestructors"] = "true";
-
     return Options;
   }
 };

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

@@ -19,16 +19,29 @@ namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
+AST_MATCHER(CXXRecordDecl, hasPublicVirtualOrProtectedNonVirtualDestructor) {
+  // We need to call Node.getDestructor() instead of matching a
+  // CXXDestructorDecl. Otherwise, tests will fail for class templates, since
+  // the primary template (not the specialization) always gets a non-virtual
+  // CXXDestructorDecl in the AST. https://bugs.llvm.org/show_bug.cgi?id=51912
+  const CXXDestructorDecl *Destructor = Node.getDestructor();
+  if (!Destructor)
+    return false;
+
+  return (((Destructor->getAccess() == AccessSpecifier::AS_public) &&
+           Destructor->isVirtual()) ||
+          ((Destructor->getAccess() == AccessSpecifier::AS_protected) &&
+           !Destructor->isVirtual()));
+}
+
 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()))))))
+          unless(hasPublicVirtualOrProtectedNonVirtualDestructor()))
           .bind("ProblematicClassOrStruct"),
       this);
 }

clang-tools-extra/clangd/FindTarget.cpp

@@ -507,7 +507,8 @@ struct TargetFinder {
     // DeclRefExpr).
     if (Arg.getKind() == TemplateArgument::Template ||
         Arg.getKind() == TemplateArgument::TemplateExpansion) {
-      if (TemplateDecl *TD = Arg.getAsTemplate().getAsTemplateDecl()) {
+      if (TemplateDecl *TD =
+              Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl()) {
         report(TD, Flags);
       }
     }

clang-tools-extra/clangd/IncludeCleaner.cpp

@@ -121,9 +121,15 @@ struct ReferencedFiles {
     if (!Macros.insert(FID).second)
       return;
     const auto &Exp = SM.getSLocEntry(FID).getExpansion();
-    add(Exp.getSpellingLoc());
-    add(Exp.getExpansionLocStart());
-    add(Exp.getExpansionLocEnd());
+    // For token pasting operator in macros, spelling and expansion locations
+    // can be within a temporary buffer that Clang creates (scratch space or
+    // ScratchBuffer). That is not a real file we can include.
+    if (!SM.isWrittenInScratchSpace(Exp.getSpellingLoc()))
+      add(Exp.getSpellingLoc());
+    if (!SM.isWrittenInScratchSpace(Exp.getExpansionLocStart()))
+      add(Exp.getExpansionLocStart());
+    if (!SM.isWrittenInScratchSpace(Exp.getExpansionLocEnd()))
+      add(Exp.getExpansionLocEnd());
   }
 };
 

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

@@ -341,6 +341,15 @@ TEST_F(TargetDeclTest, Types) {
   EXPECT_DECLS("TemplateSpecializationTypeLoc", "template <typename> class T");
   Flags.clear();
 
+  Code = R"cpp(
+  template<template<typename> class ...T>
+  class C {
+    C<[[T...]]> foo;
+    };
+  )cpp";
+  EXPECT_DECLS("TemplateArgumentLoc", {"template <typename> class ...T"});
+  Flags.clear();
+
   Code = R"cpp(
     struct S{};
     S X;

clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp

@@ -167,6 +167,47 @@ TEST(IncludeCleaner, GetUnusedHeaders) {
               UnorderedElementsAre("\"unused.h\"", "\"dir/unused.h\""));
 }
 
+TEST(IncludeCleaner, ScratchBuffer) {
+  TestTU TU;
+  TU.Filename = "foo.cpp";
+  TU.Code = R"cpp(
+    #include "macro_spelling_in_scratch_buffer.h"
+
+    using flags::FLAGS_FOO;
+
+    int concat(a, b) = 42;
+    )cpp";
+  // The pasting operator in combination with DEFINE_FLAG will create
+  // ScratchBuffer with `flags::FLAGS_FOO` that will have FileID but not
+  // FileEntry.
+  TU.AdditionalFiles["macro_spelling_in_scratch_buffer.h"] = R"cpp(
+    #define DEFINE_FLAG(X) \
+    namespace flags { \
+    int FLAGS_##X; \
+    } \
+
+    DEFINE_FLAG(FOO)
+
+    #define ab x
+    #define concat(x, y) x##y
+    )cpp";
+  ParsedAST AST = TU.build();
+  auto &SM = AST.getSourceManager();
+  auto &Includes = AST.getIncludeStructure();
+  auto ReferencedFiles = findReferencedFiles(findReferencedLocations(AST), SM);
+  auto Entry = SM.getFileManager().getFile(
+      testPath("macro_spelling_in_scratch_buffer.h"));
+  ASSERT_TRUE(Entry);
+  auto FID = SM.translateFile(*Entry);
+  // No "<scratch space>" FID.
+  EXPECT_THAT(ReferencedFiles, UnorderedElementsAre(FID));
+  // Should not crash due to <scratch space> "files" missing from include
+  // structure.
+  EXPECT_THAT(
+      getUnused(Includes, translateToHeaderIDs(ReferencedFiles, Includes, SM)),
+      ::testing::IsEmpty());
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang