Merge remote-tracking branch 'upstream/sycl' into sycl

Author: bso-intel

.github/workflows/gh_pages.yml

@@ -15,7 +15,7 @@ jobs:
     - name: Install deps
       run: |
         sudo apt-get install -y doxygen graphviz ssh ninja-build
-        sudo pip3 install sphinx recommonmark sphinx_markdown_tables
+        sudo pip3 install 'sphinx==3.0.0' 'recommonmark==0.6.0' 'sphinx_markdown_tables==0.0.12'
     - name: Build Docs
       run: |
         mkdir -p $GITHUB_WORKSPACE/build

README.md

@@ -7,6 +7,9 @@ Home for Intel LLVM-based projects:
  - oneAPI Data Parallel C++ compiler - see **sycl** branch. More information on
    oneAPI and DPC++ is available at
 ([https://www.oneapi.com/](https://www.oneapi.com/))
+   - [![Linux Post Commit Checks](https://github.com/intel/llvm/workflows/Linux%20Post%20Commit%20Checks/badge.svg)](https://github.com/intel/llvm/actions?query=workflow%3A%22Linux+Post+Commit+Checks%22) [![Generate Doxygen documentation](https://github.com/intel/llvm/workflows/Generate%20Doxygen%20documentation/badge.svg)](https://github.com/intel/llvm/actions?query=workflow%3A%22Generate+Doxygen+documentation%22)
+
+
 
 ## License
 See [LICENSE.txt](sycl/LICENSE.TXT) for details.

buildbot/check.py

@@ -1,24 +1,41 @@
 import argparse
 import os
+import multiprocessing
 import subprocess
 import sys
 
 DEFAULT_CPU_COUNT = 4
 
 def do_check(args):
-    ret = False
-
-    cpu_count = os.cpu_count()
-    if cpu_count is None:
+    try:
+        cpu_count = multiprocessing.cpu_count()
+    except NotImplementedError:
         cpu_count = DEFAULT_CPU_COUNT
 
+    # Get absolute path to source directory
+    if args.src_dir:
+      abs_src_dir = os.path.abspath(args.src_dir)
+    else:
+      abs_src_dir = os.path.abspath(os.path.join(__file__, "../.."))
+    # Get absolute path to build directory
+    if args.obj_dir:
+      abs_obj_dir = os.path.abspath(args.obj_dir)
+    else:
+      abs_obj_dir = os.path.join(abs_src_dir, "build")
+
+    cmake_cmd = [
+        "cmake",
+        "--build", abs_obj_dir,
+        "--",
+        args.test_suite,
+        "-j", str(cpu_count)]
+
+    print(cmake_cmd)
+
     env_tmp=os.environ
     env_tmp["LIT_ARGS"]="\"{}\"".format("-v")
 
-    make_cmd = ["ninja", args.test_suite, "-j", str(cpu_count)]
-    print(make_cmd)
-
-    subprocess.check_call(make_cmd, cwd=args.obj_dir, env=env_tmp)
+    subprocess.check_call(cmake_cmd, cwd=abs_obj_dir, env=env_tmp)
 
     ret = True
     return ret
@@ -34,8 +51,8 @@ def main():
     parser.add_argument("-w", "--builder-dir", metavar="BUILDER_DIR",
                         help="builder directory, which is the directory contains source and build directories")
     parser.add_argument("-s", "--src-dir", metavar="SRC_DIR", help="source directory")
-    parser.add_argument("-o", "--obj-dir", metavar="OBJ_DIR", required=True, help="build directory")
-    parser.add_argument("-t", "--test-suite", metavar="TEST_SUITE", required=True, help="check-xxx target")
+    parser.add_argument("-o", "--obj-dir", metavar="OBJ_DIR", help="build directory")
+    parser.add_argument("-t", "--test-suite", metavar="TEST_SUITE", default="check-all", help="check-xxx target")
 
     args = parser.parse_args()
 
@@ -47,4 +64,3 @@ def main():
     ret = main()
     exit_code = 0 if ret else 1
     sys.exit(exit_code)
-

buildbot/compile.py

@@ -2,6 +2,7 @@
 import multiprocessing
 import subprocess
 import sys
+import os
 
 DEFAULT_CPU_COUNT = 4
 
@@ -12,10 +13,28 @@ def do_compile(args):
     except NotImplementedError:
         cpu_count = DEFAULT_CPU_COUNT
 
-    make_cmd = ["ninja", "-j", str(cpu_count), "deploy-sycl-toolchain", "deploy-opencl-aot"]
-    print(make_cmd)
+    # Get absolute path to source directory
+    if args.src_dir:
+      abs_src_dir = os.path.abspath(args.src_dir)
+    else:
+      abs_src_dir = os.path.abspath(os.path.join(__file__, "../.."))
+    # Get absolute path to build directory
+    if args.obj_dir:
+      abs_obj_dir = os.path.abspath(args.obj_dir)
+    else:
+      abs_obj_dir = os.path.join(abs_src_dir, "build")
 
-    subprocess.check_call(make_cmd, cwd=args.obj_dir)
+    cmake_cmd = [
+        "cmake",
+        "--build", abs_obj_dir,
+        "--",
+        "deploy-sycl-toolchain",
+        "deploy-opencl-aot",
+        "-j", str(cpu_count)]
+
+    print(cmake_cmd)
+
+    subprocess.check_call(cmake_cmd, cwd=abs_obj_dir)
 
     return True
 
@@ -31,7 +50,7 @@ def main():
     parser.add_argument("-w", "--builder-dir", metavar="BUILDER_DIR",
                         help="builder directory, which is the directory contains source and build directories")
     parser.add_argument("-s", "--src-dir", metavar="SRC_DIR", help="source directory")
-    parser.add_argument("-o", "--obj-dir", metavar="OBJ_DIR", required=True, help="build directory")
+    parser.add_argument("-o", "--obj-dir", metavar="OBJ_DIR", help="build directory")
 
     args = parser.parse_args()
 
@@ -44,4 +63,3 @@ def main():
     ret = main()
     exit_code = 0 if ret else 1
     sys.exit(exit_code)
-

buildbot/configure.py

@@ -4,16 +4,21 @@
 import sys
 import platform
 
-# TODO:
-# 1. Make all required options optional
-# 2. Create obj_dir from the script if it doesn't exist
-
 def do_configure(args):
     ret = False
 
-    # Get absolute paths
-    abs_src_dir = os.path.abspath(args.src_dir)
-    abs_obj_dir = os.path.abspath(args.obj_dir)
+    # Get absolute path to source directory
+    if args.src_dir:
+      abs_src_dir = os.path.abspath(args.src_dir)
+    else:
+      abs_src_dir = os.path.abspath(os.path.join(__file__, "../.."))
+    # Get absolute path to build directory
+    if args.obj_dir:
+      abs_obj_dir = os.path.abspath(args.obj_dir)
+    else:
+      abs_obj_dir = os.path.join(abs_src_dir, "build")
+    if not os.path.isdir(abs_obj_dir):
+      os.makedirs(abs_obj_dir)
 
     llvm_dir = os.path.join(abs_src_dir, "llvm")
     sycl_dir = os.path.join(abs_src_dir, "sycl")
@@ -60,7 +65,7 @@ def do_configure(args):
 
     cmake_cmd = [
         "cmake",
-        "-G", "Ninja",
+        "-G", args.cmake_gen,
         "-DCMAKE_BUILD_TYPE={}".format(args.build_type),
         "-DLLVM_ENABLE_ASSERTIONS={}".format(llvm_enable_assertions),
         "-DLLVM_TARGETS_TO_BUILD={}".format(llvm_targets_to_build),
@@ -117,17 +122,18 @@ def main():
     parser.add_argument("-r", "--pr-number", metavar="PR_NUM", help="pull request number")
     parser.add_argument("-w", "--builder-dir", metavar="BUILDER_DIR",
                         help="builder directory, which is the directory contains source and build directories")
-    parser.add_argument("-s", "--src-dir", metavar="SRC_DIR", required=True, help="source directory")
-    parser.add_argument("-o", "--obj-dir", metavar="OBJ_DIR", required=True, help="build directory")
+    parser.add_argument("-s", "--src-dir", metavar="SRC_DIR", help="source directory (autodetected by default)")
+    parser.add_argument("-o", "--obj-dir", metavar="OBJ_DIR", help="build directory. (<src>/build by default)")
     parser.add_argument("-t", "--build-type",
-                        metavar="BUILD_TYPE", required=True, help="build type, debug or release")
+                        metavar="BUILD_TYPE", default="Release", help="build type: Debug, Release")
     parser.add_argument("--cuda", action='store_true', help="switch from OpenCL to CUDA")
     parser.add_argument("--no-assertions", action='store_true', help="build without assertions")
     parser.add_argument("--docs", action='store_true', help="build Doxygen documentation")
     parser.add_argument("--system-ocl", action='store_true', help="use OpenCL deps from system (no download)")
     parser.add_argument("--no-werror", action='store_true', help="Don't treat warnings as errors")
     parser.add_argument("--shared-libs", action='store_true', help="Build shared libraries")
     parser.add_argument("--cmake-opt", action='append', help="Additional CMake option not configured via script parameters")
+    parser.add_argument("--cmake-gen", default="Ninja", help="CMake generator")
 
     args = parser.parse_args()
 

clang/include/clang/Sema/Sema.h

@@ -12455,6 +12455,7 @@ class Sema final {
   };
 
   bool isKnownGoodSYCLDecl(const Decl *D);
+  void checkSYCLDeviceVarDecl(VarDecl *Var);
   void ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc, MangleContext &MC);
   void MarkDevice();
 

clang/lib/Driver/ToolChains/Clang.cpp

@@ -1217,9 +1217,9 @@ void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA,
   if (JA.isOffloading(Action::OFK_Cuda))
     getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
 
-  if (Args.hasArg(options::OPT_fsycl_device_only)) {
+  if (JA.isOffloading(Action::OFK_SYCL) ||
+      Args.hasArg(options::OPT_fsycl_device_only))
     toolchains::SYCLToolChain::AddSYCLIncludeArgs(D, Args, CmdArgs);
-  }
 
   // If we are offloading to a target via OpenMP we need to include the
   // openmp_wrappers folder which contains alternative system headers.
@@ -4115,6 +4115,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
     CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
   }
 
+  Arg *SYCLStdArg = Args.getLastArg(options::OPT_sycl_std_EQ);
+
   if (UseSYCLTriple) {
     // We want to compile sycl kernels.
     CmdArgs.push_back("-fsycl");
@@ -4147,21 +4149,24 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
                      options::OPT_fno_sycl_allow_func_ptr, false)) {
       CmdArgs.push_back("-fsycl-allow-func-ptr");
     }
-  }
 
-    if (IsSYCL) {
-    if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) {
-      A->render(Args, CmdArgs);
-      CmdArgs.push_back("-fsycl-std-layout-kernel-params");
-    } else {
-      // Ensure the default version in SYCL mode is 1.2.1 (aka 2017)
-      CmdArgs.push_back("-sycl-std=2017");
+    if (!SYCLStdArg) {
       // The user had not pass SYCL version, thus we'll employ no-sycl-strict
       // to allow address-space unqualified pointers in function params/return
       // along with marking the same function with explicit SYCL_EXTERNAL
       CmdArgs.push_back("-Wno-sycl-strict");
     }
+  }
+
+  if (IsSYCL) {
+    if (SYCLStdArg) {
+      SYCLStdArg->render(Args, CmdArgs);
+      CmdArgs.push_back("-fsycl-std-layout-kernel-params");
+    } else {
+      // Ensure the default version in SYCL mode is 1.2.1 (aka 2017)
+      CmdArgs.push_back("-sycl-std=2017");
     }
+  }
 
   if (IsOpenMPDevice) {
     // We have to pass the triple of the host if compiling for an OpenMP device.

clang/lib/Driver/ToolChains/SYCL.cpp

@@ -545,7 +545,6 @@ void SYCLToolChain::AddSYCLIncludeArgs(const clang::driver::Driver &Driver,
 
 void SYCLToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                               ArgStringList &CC1Args) const {
-  AddSYCLIncludeArgs(getDriver(), DriverArgs, CC1Args);
   HostTC.AddClangSystemIncludeArgs(DriverArgs, CC1Args);
 }
 

clang/lib/Sema/SemaDecl.cpp

@@ -12660,6 +12660,9 @@ void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
     }
   }
 
+  if (getLangOpts().SYCLIsDevice)
+    checkSYCLDeviceVarDecl(var);
+
   // In Objective-C, don't allow jumps past the implicit initialization of a
   // local retaining variable.
   if (getLangOpts().ObjC &&

clang/lib/Sema/SemaSYCL.cpp

@@ -200,6 +200,84 @@ bool Sema::isKnownGoodSYCLDecl(const Decl *D) {
   return false;
 }
 
+static bool isZeroSizedArray(QualType Ty) {
+  if (const auto *CATy = dyn_cast<ConstantArrayType>(Ty))
+    return CATy->getSize() == 0;
+  return false;
+}
+
+static Sema::DeviceDiagBuilder
+emitDeferredDiagnosticAndNote(Sema &S, SourceRange Loc, unsigned DiagID,
+                              SourceRange UsedAtLoc) {
+  Sema::DeviceDiagBuilder builder =
+      S.SYCLDiagIfDeviceCode(Loc.getBegin(), DiagID);
+  if (UsedAtLoc.isValid())
+    S.SYCLDiagIfDeviceCode(UsedAtLoc.getBegin(), diag::note_sycl_used_here);
+  return builder;
+}
+
+static void checkSYCLVarType(Sema &S, QualType Ty, SourceRange Loc,
+                             llvm::DenseSet<QualType> Visited,
+                             SourceRange UsedAtLoc = SourceRange()) {
+  // Not all variable types are supported inside SYCL kernels,
+  // for example the quad type __float128 will cause errors in the
+  // SPIR-V translation phase.
+  // Here we check any potentially unsupported declaration and issue
+  // a deferred diagnostic, which will be emitted iff the declaration
+  // is discovered to reside in kernel code.
+  // The optional UsedAtLoc param is used when the SYCL usage is at a
+  // different location than the variable declaration and we need to
+  // inform the user of both, e.g. struct member usage vs declaration.
+
+  //--- check types ---
+
+  // zero length arrays
+  if (isZeroSizedArray(Ty))
+    emitDeferredDiagnosticAndNote(S, Loc, diag::err_typecheck_zero_array_size,
+                                  UsedAtLoc);
+
+  // Sub-reference array or pointer, then proceed with that type.
+  while (Ty->isAnyPointerType() || Ty->isArrayType())
+    Ty = QualType{Ty->getPointeeOrArrayElementType(), 0};
+
+  // __int128, __int128_t, __uint128_t, __float128
+  if (Ty->isSpecificBuiltinType(BuiltinType::Int128) ||
+      Ty->isSpecificBuiltinType(BuiltinType::UInt128) ||
+      (Ty->isSpecificBuiltinType(BuiltinType::Float128) &&
+       !S.Context.getTargetInfo().hasFloat128Type()))
+    emitDeferredDiagnosticAndNote(S, Loc, diag::err_type_unsupported, UsedAtLoc)
+        << Ty.getUnqualifiedType().getCanonicalType();
+
+  //--- now recurse ---
+  // Pointers complicate recursion. Add this type to Visited.
+  // If already there, bail out.
+  if (!Visited.insert(Ty).second)
+    return;
+
+  if (const auto *ATy = dyn_cast<AttributedType>(Ty))
+    return checkSYCLVarType(S, ATy->getModifiedType(), Loc, Visited);
+
+  if (const auto *RD = Ty->getAsRecordDecl()) {
+    for (const auto &Field : RD->fields())
+      checkSYCLVarType(S, Field->getType(), Field->getSourceRange(), Visited,
+                       Loc);
+  } else if (const auto *FPTy = dyn_cast<FunctionProtoType>(Ty)) {
+    for (const auto &ParamTy : FPTy->param_types())
+      checkSYCLVarType(S, ParamTy, Loc, Visited);
+    checkSYCLVarType(S, FPTy->getReturnType(), Loc, Visited);
+  }
+}
+
+void Sema::checkSYCLDeviceVarDecl(VarDecl *Var) {
+  assert(getLangOpts().SYCLIsDevice &&
+         "Should only be called during SYCL compilation");
+  QualType Ty = Var->getType();
+  SourceRange Loc = Var->getLocation();
+  llvm::DenseSet<QualType> Visited;
+
+  checkSYCLVarType(*this, Ty, Loc, Visited);
+}
+
 class MarkDeviceFunction : public RecursiveASTVisitor<MarkDeviceFunction> {
 public:
   MarkDeviceFunction(Sema &S)

clang/lib/Sema/SemaType.cpp

@@ -1527,12 +1527,8 @@ static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
     break;
   case DeclSpec::TST_float128:
     if (!S.Context.getTargetInfo().hasFloat128Type() &&
-        S.getLangOpts().SYCLIsDevice)
-      S.SYCLDiagIfDeviceCode(DS.getTypeSpecTypeLoc(),
-                             diag::err_type_unsupported)
-          << "__float128";
-    else if (!S.Context.getTargetInfo().hasFloat128Type() &&
-             !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
+        !S.getLangOpts().SYCLIsDevice &&
+        !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
           << "__float128";
     Result = Context.Float128Ty;
@@ -2350,12 +2346,6 @@ QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
             << ArraySize->getSourceRange();
         ASM = ArrayType::Normal;
       }
-
-      // Zero length arrays are disallowed in SYCL device code.
-      if (getLangOpts().SYCLIsDevice)
-        SYCLDiagIfDeviceCode(ArraySize->getBeginLoc(),
-                             diag::err_typecheck_zero_array_size)
-            << ArraySize->getSourceRange();
     } else if (!T->isDependentType() && !T->isVariablyModifiedType() &&
                !T->isIncompleteType() && !T->isUndeducedType()) {
       // Is the array too large?