Merge from 'sycl' to 'sycl-web'

Author: iclsrc

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -132,6 +132,7 @@ def err_drv_invalid_Xsycl_frontend_with_args : Error<
   "invalid -Xsycl-target-frontend argument: '%0', options requiring arguments are unsupported">;
 def err_drv_bad_fpga_device_count : Error<
   "More than one FPGA specific device binary found in input objects">;
+def err_drv_unsupported_opt_dpcpp : Error<"option '%0' unsupported with DPC++">;
 def err_drv_argument_only_allowed_with : Error<
   "invalid argument '%0' only allowed with '%1'">;
 def err_drv_argument_not_allowed_with : Error<

clang/lib/Driver/ToolChains/Clang.cpp

@@ -6794,14 +6794,26 @@ void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
                            bool *EmitCodeView) const {
   unsigned RTOptionID = options::OPT__SLASH_MT;
   bool isNVPTX = getToolChain().getTriple().isNVPTX();
+  bool isSYCL =
+      Args.hasArg(options::OPT_fsycl) ||
+      getToolChain().getTriple().getEnvironment() == llvm::Triple::SYCLDevice;
+  // For SYCL Windows, /MD is the default.
+  if (isSYCL)
+    RTOptionID = options::OPT__SLASH_MD;
 
   if (Args.hasArg(options::OPT__SLASH_LDd))
-    // The /LDd option implies /MTd. The dependent lib part can be overridden,
-    // but defining _DEBUG is sticky.
-    RTOptionID = options::OPT__SLASH_MTd;
+    // The /LDd option implies /MTd (/MDd for SYCL). The dependent lib part
+    // can be overridden but defining _DEBUG is sticky.
+    RTOptionID = isSYCL ? options::OPT__SLASH_MDd : options::OPT__SLASH_MTd;
 
-  if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
+  if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group)) {
     RTOptionID = A->getOption().getID();
+    if (isSYCL && (RTOptionID == options::OPT__SLASH_MT ||
+                   RTOptionID == options::OPT__SLASH_MTd))
+      // Use of /MT or /MTd is not supported for SYCL.
+      getToolChain().getDriver().Diag(diag::err_drv_unsupported_opt_dpcpp)
+          << A->getOption().getName();
+  }
 
   StringRef FlagForCRT;
   switch (RTOptionID) {

clang/lib/Driver/ToolChains/MSVC.cpp

@@ -375,8 +375,7 @@ void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 
   if (!C.getDriver().IsCLMode() && !Args.hasArg(options::OPT_nostdlib) &&
       Args.hasArg(options::OPT_fsycl) && !Args.hasArg(options::OPT_nolibsycl)) {
-    if (Args.hasArg(options::OPT__SLASH_MDd) ||
-        Args.hasArg(options::OPT__SLASH_MTd))
+    if (Args.hasArg(options::OPT__SLASH_MDd))
       CmdArgs.push_back("-defaultlib:sycld.lib");
     else
       CmdArgs.push_back("-defaultlib:sycl.lib");

clang/test/Driver/sycl-MD-default.cpp

@@ -0,0 +1,16 @@
+// REQUIRES: clang-driver
+
+// RUN: %clang_cl -### -fsycl -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHK-DEFAULT %s
+// RUN: %clang_cl -### -MD -fsycl -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHK-DEFAULT %s
+// RUN: %clang_cl -### -MDd -fsycl -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHK-DEFAULT %s
+// CHK-DEFAULT: "-D_MT" "-D_DLL"
+// CHK-DEFAULT: "--dependent-lib=msvcrt{{d*}}"
+
+// RUN: %clang_cl -### -MT -fsycl -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHK-ERROR %s
+// RUN: %clang_cl -### -MTd -fsycl -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHK-ERROR %s
+// CHK-ERROR: option 'MT{{d*}}' unsupported with DPC++

clang/test/Driver/sycl-offload.c

@@ -589,9 +589,8 @@
 // CHECK-LINK-NOLIBSYCL: "{{.*}}link{{(.exe)?}}"
 // CHECK-LINK-NOLIBSYCL-NOT: "-defaultlib:sycl.lib"
 
-/// Check sycld.lib is chosen with /MDd and /MTd
+/// Check sycld.lib is chosen with /MDd
 // RUN:  %clang_cl -fsycl /MDd %s -o %t -### 2>&1 | FileCheck -check-prefix=CHECK-LINK-SYCL-DEBUG %s
-// RUN:  %clang_cl -fsycl /MTd %s -o %t -### 2>&1 | FileCheck -check-prefix=CHECK-LINK-SYCL-DEBUG %s
 // CHECK-LINK-SYCL-DEBUG: "--dependent-lib=sycld"
 // CHECK-LINK-SYCL-DEBUG-NOT: "-defaultlib:sycld.lib"
 

sycl/doc/EnvironmentVariables.md

@@ -12,8 +12,9 @@ subject to change. Do not rely on these variables in production code.
 | Environment variable | Values | Description |
 | -------------------- | ------ | ----------- |
 | SYCL_PI_TRACE | Described [below](#sycl_pi_trace-options)  | Enable specified level of tracing for PI. |
-| SYCL_BE | PI_OPENCL, PI_LEVEL_ZERO, PI_CUDA | Force SYCL RT to consider only devices of the specified backend during the device selection. |
-| SYCL_DEVICE_TYPE | One of: CPU, GPU, ACC, HOST | Force SYCL to use the specified device type. If unset, default selection rules are applied. If set to any unlisted value, this control has no effect. If the requested device type is not found, a `cl::sycl::runtime_error` exception is thrown. If a non-default device selector is used, a device must satisfy both the selector and this control to be chosen. This control only has effect on devices created with a selector. |
+| SYCL_BE | PI_OPENCL, PI_LEVEL_ZERO, PI_CUDA | Force SYCL RT to consider only devices of the specified backend during the device selection. We are planning to deprecate SYCL_BE environment variable in the future. The specific grace period is not decided yet. Please use the new env var SYCL_DEVICE_FILTER instead. |
+| SYCL_DEVICE_TYPE | One of: CPU, GPU, ACC, HOST | Force SYCL to use the specified device type. If unset, default selection rules are applied. If set to any unlisted value, this control has no effect. If the requested device type is not found, a `cl::sycl::runtime_error` exception is thrown. If a non-default device selector is used, a device must satisfy both the selector and this control to be chosen. This control only has effect on devices created with a selector. We are planning to deprecate SYCL_DEVICE_TYPE environment variable in the future. The specific grace period is not decided yet. Please use the new env var SYCL_DEVICE_FILTER instead. |
+| SYCL_DEVICE_FILTER (tentative name) | {backend:device_type:device_num} | Limits the SYCL RT to use only a subset of the system's devices. Setting this environment variable affects all of the device query functions and all of the device selectors. The value of this environment variable is a comma separated list of filters, where each filter is a triple of the form "backend:device_type:device_num" (without the quotes). Each element of the triple is optional, but each filter must have at least one value. Possible values of "backend" are "host", "level_zero", "opencl", "cuda", or "\*". Possible values of "device_type" are "host", "cpu", "gpu", "acc", or "\*". Device_num is an integer that indexes the enumeration of devices from the sycl::platform::get_device() call, where the first device in that enumeration has index zero. Assuming a filter has all three elements of the triple, it selects only those devices that come from the given backend, have the specified device type, AND have the given device index. If more than one filter is specified, the RT is restricted to the union of devices selected by all filters. The RT always includes the "host" backend and the host device regardless of the filter because the SYCL language requires this device to always be present. Therefore, including "host" in the list of filters is allowed but is unnecessary. Note that the standard selectors like gpu_selector or cpu_selector will throw an exception if the filtered list of devices does not include a device that satisfies the selector. In particular, limiting the devices to only those supported by the "level_zero" backend will cause the cpu_selector to throw an exception since that backend does not support any CPU devices. This environment variable can be used to limit loading only specified plugins into the SYCL RT. |
 | SYCL_PROGRAM_COMPILE_OPTIONS | String of valid OpenCL compile options | Override compile options for all programs. |
 | SYCL_PROGRAM_LINK_OPTIONS | String of valid OpenCL link options | Override link options for all programs. |
 | SYCL_USE_KERNEL_SPV | Path to the SPIR-V binary | Load device image from the specified file. If runtime is unable to read the file, `cl::sycl::runtime_error` exception is thrown.|

sycl/include/CL/sycl/backend_types.hpp

@@ -18,23 +18,26 @@
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 
-enum class backend : char { host, opencl, level_zero, cuda };
+enum class backend : char { host, opencl, level_zero, cuda, all };
 
 template <backend name, typename SYCLObjectT> struct interop;
 
 inline std::ostream &operator<<(std::ostream &Out, backend be) {
   switch (be) {
   case backend::host:
-    Out << std::string("host");
+    Out << "host";
     break;
   case backend::opencl:
-    Out << std::string("opencl");
+    Out << "opencl";
     break;
   case backend::level_zero:
-    Out << std::string("level_zero");
+    Out << "level_zero";
     break;
   case backend::cuda:
-    Out << std::string("cuda");
+    Out << "cuda";
+    break;
+  case backend::all:
+    Out << "all";
   }
   return Out;
 }

sycl/include/CL/sycl/detail/device_filter.hpp

@@ -0,0 +1,83 @@
+//==---------- device_filter.hpp - SYCL device filter descriptor -----------==//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <CL/sycl/backend_types.hpp>
+#include <CL/sycl/detail/defines.hpp>
+#include <CL/sycl/info/info_desc.hpp>
+
+#include <iostream>
+#include <string>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace detail {
+
+struct device_filter {
+  backend Backend = backend::all;
+  info::device_type DeviceType = info::device_type::all;
+  int DeviceNum = 0;
+  bool HasBackend = false;
+  bool HasDeviceType = false;
+  bool HasDeviceNum = false;
+  int MatchesSeen = 0;
+
+  device_filter(){};
+  device_filter(const std::string &FilterString);
+  friend std::ostream &operator<<(std::ostream &Out,
+                                  const device_filter &Filter);
+};
+
+class device_filter_list {
+  std::vector<device_filter> FilterList;
+
+public:
+  device_filter_list() {}
+  device_filter_list(const std::string &FilterString);
+  device_filter_list(device_filter &Filter);
+  void addFilter(device_filter &Filter);
+  std::vector<device_filter> &get() { return FilterList; }
+  friend std::ostream &operator<<(std::ostream &Out,
+                                  const device_filter_list &List);
+};
+
+inline std::ostream &operator<<(std::ostream &Out,
+                                const device_filter &Filter) {
+  Out << Filter.Backend << ":";
+  if (Filter.DeviceType == info::device_type::host) {
+    Out << "host";
+  } else if (Filter.DeviceType == info::device_type::cpu) {
+    Out << "cpu";
+  } else if (Filter.DeviceType == info::device_type::gpu) {
+    Out << "gpu";
+  } else if (Filter.DeviceType == info::device_type::accelerator) {
+    Out << "accelerator";
+  } else if (Filter.DeviceType == info::device_type::all) {
+    Out << "*";
+  } else {
+    Out << "unknown";
+  }
+  if (Filter.HasDeviceNum) {
+    Out << ":" << Filter.DeviceNum;
+  }
+  return Out;
+}
+
+inline std::ostream &operator<<(std::ostream &Out,
+                                const device_filter_list &List) {
+  for (const device_filter &Filter : List.FilterList) {
+    Out << Filter;
+    Out << ",";
+  }
+  return Out;
+}
+
+} // namespace detail
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)