Merge branch 'sycl' into chedy/fix-mipmap-leak

Author: ProGTX

.github/workflows/sycl-nightly.yml

@@ -110,7 +110,7 @@ jobs:
       image_options: ${{ matrix.image_options }}
       target_devices: ${{ matrix.target_devices }}
       tests_selector: ${{ matrix.tests_selector }}
-      extra_lit_opts: ${{ matrix.extra_lit_opts }}
+      extra_lit_opts: "--param 'cxx_flags=-D_GLIBCXX_USE_CXX11_ABI=0' ${{ matrix.extra_lit_opts }}"
       reset_intel_gpu: ${{ matrix.reset_intel_gpu }}
       ref: ${{ github.sha }}
       merge_ref: ''

clang/include/clang/Basic/Builtins.h

@@ -43,6 +43,7 @@ enum LanguageID : uint16_t {
   OCL_DSE = 0x400,           // builtin requires OpenCL device side enqueue.
   ALL_OCL_LANGUAGES = 0x800, // builtin for OCL languages.
   HLSL_LANG = 0x1000,        // builtin requires HLSL.
+  SYCL_LANG = 0x2000,        // builtin requires SYCL.
   ALL_LANGUAGES = C_LANG | CXX_LANG | OBJC_LANG, // builtin for all languages.
   ALL_GNU_LANGUAGES = ALL_LANGUAGES | GNU_LANG,  // builtin requires GNU mode.
   ALL_MS_LANGUAGES = ALL_LANGUAGES | MS_LANG     // builtin requires MS mode.

clang/include/clang/Basic/Builtins.td

@@ -4731,6 +4731,25 @@ def GetDeviceSideMangledName : LangBuiltin<"CUDA_LANG"> {
   let Prototype = "char const*(...)";
 }
 
+// SYCL
+def SYCLIsKernel : LangBuiltin<"SYCL_LANG"> {
+  let Spellings = ["__builtin_sycl_is_kernel"];
+  let Attributes = [NoThrow, Const, Constexpr, CustomTypeChecking];
+  let Prototype = "bool(...)";
+}
+
+def SYCLIsSingleTaskKernel : LangBuiltin<"SYCL_LANG"> {
+  let Spellings = ["__builtin_sycl_is_single_task_kernel"];
+  let Attributes = [NoThrow, Const, Constexpr, CustomTypeChecking];
+  let Prototype = "bool(...)";
+}
+
+def SYCLIsNDRangeKernel : LangBuiltin<"SYCL_LANG"> {
+  let Spellings = ["__builtin_sycl_is_nd_range_kernel"];
+  let Attributes = [NoThrow, Const, Constexpr, CustomTypeChecking];
+  let Prototype = "bool(...)";
+}
+
 // HLSL
 def HLSLAll : LangBuiltin<"HLSL_LANG"> {
   let Spellings = ["__builtin_hlsl_all"];

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -827,6 +827,9 @@ def warn_unreachable_association : Warning<
   InGroup<UnreachableCodeGenericAssoc>;
 
 /// Built-in functions.
+def err_builtin_invalid_argument_count : Error<
+  "builtin %plural{0:takes no arguments|1:takes one argument|"
+  ":requires exactly %0 arguments}0">;
 def ext_implicit_lib_function_decl : ExtWarn<
   "implicitly declaring library function '%0' with type %1">,
   InGroup<ImplicitFunctionDeclare>;
@@ -12397,7 +12400,11 @@ def err_builtin_invalid_arg_type: Error <
   "a vector of integers|"
   "an unsigned integer|"
   "an 'int'|"
-  "a vector of floating points}1 (was %2)">;
+  "a vector of floating points|"
+  "a function pointer}1 (was %2)">;
+
+def err_builtin_invalid_arg_value: Error<
+  "%ordinal0 argument must be a strictly positive value (was %1)">;
 
 def err_builtin_matrix_disabled: Error<
   "matrix types extension is disabled. Pass -fenable-matrix to enable it">;

clang/lib/AST/ExprConstant.cpp

@@ -12729,6 +12729,45 @@ static bool getBuiltinAlignArguments(const CallExpr *E, EvalInfo &Info,
   return true;
 }
 
+static bool isSYCLFreeFunctionKernel(IntExprEvaluator &IEV,
+                                     const EvalInfo &Info, const CallExpr *E,
+                                     StringRef NameStr1, StringRef NameStr2,
+                                     bool CheckNDRangeKernelDim = false) {
+  const Expr *ArgExpr = E->getArg(0)->IgnoreParenImpCasts();
+  while (isa<CastExpr>(ArgExpr))
+    ArgExpr = cast<CastExpr>(ArgExpr)->getSubExpr();
+  auto *DRE = dyn_cast<DeclRefExpr>(ArgExpr);
+  if (DRE) {
+    const FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
+    if (FD) {
+      auto *SAIRAttr = FD->getAttr<SYCLAddIRAttributesFunctionAttr>();
+      if (!SAIRAttr)
+        return IEV.Success(false, E);
+      SmallVector<std::pair<std::string, std::string>, 4> NameValuePairs =
+          SAIRAttr->getFilteredAttributeNameValuePairs(Info.Ctx);
+      for (const auto &NVPair : NameValuePairs) {
+        if (!NVPair.first.compare(NameStr1) ||
+            (!NameStr2.empty() && !NVPair.first.compare(NameStr2))) {
+          if (CheckNDRangeKernelDim) {
+            uint64_t Dim =
+                E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
+            // Return true only if the dimensions match.
+            if (std::stoul(NVPair.second) == Dim)
+              return IEV.Success(true, E);
+            else
+              return IEV.Success(false, E);
+          }
+          // Return true if it has the sycl-single-task-kernel or the
+          // sycl-nd-range-kernel attribute.
+          return IEV.Success(true, E);
+        }
+      }
+      return IEV.Success(false, E);
+    }
+  }
+  return false;
+}
+
 bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
                                             unsigned BuiltinOp) {
   switch (BuiltinOp) {
@@ -13674,6 +13713,19 @@ bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
         Result.setBitVal(P++, Val[I]);
     return Success(Result, E);
   }
+
+  case Builtin::BI__builtin_sycl_is_kernel: {
+    return isSYCLFreeFunctionKernel(*this, Info, E, "sycl-single-task-kernel",
+                                    "sycl-nd-range-kernel");
+  }
+  case Builtin::BI__builtin_sycl_is_single_task_kernel: {
+    return isSYCLFreeFunctionKernel(*this, Info, E, "sycl-single-task-kernel",
+                                    "");
+  }
+  case Builtin::BI__builtin_sycl_is_nd_range_kernel: {
+    return isSYCLFreeFunctionKernel(*this, Info, E, "sycl-nd-range-kernel", "",
+                                    /*CheckNDRangeDim=*/true);
+  }
   }
 }
 

clang/lib/Basic/Builtins.cpp

@@ -119,6 +119,9 @@ static bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
   /* CUDA Unsupported */
   if (!LangOpts.CUDA && BuiltinInfo.Langs == CUDA_LANG)
     return false;
+  /* SYCL Unsupported */
+  if (!LangOpts.isSYCL() && BuiltinInfo.Langs == SYCL_LANG)
+    return false;
   /* CPlusPlus Unsupported */
   if (!LangOpts.CPlusPlus && BuiltinInfo.Langs == CXX_LANG)
     return false;

clang/lib/CodeGen/CGBuiltin.cpp

@@ -2716,6 +2716,53 @@ static RValue EmitHipStdParUnsupportedBuiltin(CodeGenFunction *CGF,
   return RValue::get(CGF->Builder.CreateCall(UBF, Args));
 }
 
+static RValue EmitSYCLFreeFunctionKernelBuiltin(CodeGenFunction &CGF,
+                                                const CallExpr *E,
+                                                StringRef NameStr1,
+                                                StringRef NameStr2,
+                                                bool CheckNDRangeDim = false) {
+  const Expr *ArgExpr = E->getArg(0)->IgnoreImpCasts();
+  auto *UO = dyn_cast<clang::UnaryOperator>(ArgExpr);
+  // If this is of the form &function or *function, get to the function
+  // sub-expression.
+  if (UO && (UO->getOpcode() == UO_AddrOf || UO->getOpcode() == UO_Deref))
+    ArgExpr = UO->getSubExpr()->IgnoreParenImpCasts();
+  while (isa<CastExpr>(ArgExpr))
+    ArgExpr = cast<CastExpr>(ArgExpr)->getSubExpr();
+  auto *DRE = dyn_cast<DeclRefExpr>(ArgExpr);
+  if (DRE) {
+    const FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
+    if (FD && FD->hasAttr<SYCLAddIRAttributesFunctionAttr>()) {
+      auto *SAIRAttr = FD->getAttr<SYCLAddIRAttributesFunctionAttr>();
+      SmallVector<std::pair<std::string, std::string>, 4> NameValuePairs =
+          SAIRAttr->getFilteredAttributeNameValuePairs(CGF.CGM.getContext());
+      for (const auto &NVPair : NameValuePairs) {
+        if (!NVPair.first.compare(NameStr1) ||
+            (!NameStr2.empty() && !!NVPair.first.compare(NameStr2))) {
+          if (CheckNDRangeDim) {
+            uint64_t Dim = E->getArg(1)
+                               ->EvaluateKnownConstInt(CGF.CGM.getContext())
+                               .getZExtValue();
+            // Return true only if the dimensions match.
+            if (std::stoul(NVPair.second) == Dim)
+              return RValue::get(
+                  llvm::ConstantInt::getTrue(CGF.ConvertType(E->getType())));
+            else
+              return RValue::get(
+                  llvm::ConstantInt::getFalse(CGF.ConvertType(E->getType())));
+          }
+          // Return true if the kernel type matches.
+          return RValue::get(
+              llvm::ConstantInt::getTrue(CGF.ConvertType(E->getType())));
+        }
+      }
+    }
+  }
+  // Return false otherwise.
+  return RValue::get(
+      llvm::ConstantInt::getFalse(CGF.ConvertType(E->getType())));
+}
+
 RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
                                         const CallExpr *E,
                                         ReturnValueSlot ReturnValue) {
@@ -6363,6 +6410,18 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     auto Str = CGM.GetAddrOfConstantCString(Name, "");
     return RValue::get(Str.getPointer());
   }
+  case Builtin::BI__builtin_sycl_is_kernel: {
+    return EmitSYCLFreeFunctionKernelBuiltin(
+        *this, E, "sycl-single-task-kernel", "sycl-nd-range-kernel");
+  }
+  case Builtin::BI__builtin_sycl_is_single_task_kernel: {
+    return EmitSYCLFreeFunctionKernelBuiltin(*this, E,
+                                             "sycl-single-task-kernel", "");
+  }
+  case Builtin::BI__builtin_sycl_is_nd_range_kernel: {
+    return EmitSYCLFreeFunctionKernelBuiltin(*this, E, "sycl-nd-range-kernel",
+                                             "", /*CheckNDRangeDim=*/true);
+  }
   }
 
   // If this is an alias for a lib function (e.g. __builtin_sin), emit

clang/lib/CodeGen/CGCall.cpp

@@ -3020,6 +3020,21 @@ namespace {
   };
 }
 
+static bool hasSYCLRestrictPropertyIRAttr(const VarDecl *Arg,
+                                          const ASTContext &Context) {
+  auto *IRAttr = Arg->getAttr<SYCLAddIRAttributesKernelParameterAttr>();
+  if (!IRAttr)
+    return false;
+
+  SmallVector<std::pair<std::string, std::string>, 4> NameValuePairs =
+      IRAttr->getAttributeNameValuePairs(Context);
+  return std::any_of(
+      NameValuePairs.begin(), NameValuePairs.end(),
+      [](const std::pair<std::string, std::string> &NameValuePair) {
+        return NameValuePair.first == "sycl-restrict";
+      });
+}
+
 void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
                                          llvm::Function *Fn,
                                          const FunctionArgList &Args) {
@@ -3244,9 +3259,10 @@ void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
 
         // Set 'noalias' if an argument type has the `restrict` qualifier.
         if (Arg->getType().isRestrictQualified() ||
-            (CurCodeDecl &&
-             CurCodeDecl->hasAttr<SYCLIntelKernelArgsRestrictAttr>() &&
-             Arg->getType()->isPointerType()) ||
+            (Arg->getType()->isPointerType() &&
+             ((CurCodeDecl &&
+               CurCodeDecl->hasAttr<SYCLIntelKernelArgsRestrictAttr>()) ||
+              hasSYCLRestrictPropertyIRAttr(Arg, getContext()))) ||
             (Arg->hasAttr<RestrictAttr>() && Arg->getType()->isPointerType()))
           AI->addAttr(llvm::Attribute::NoAlias);
       }

clang/lib/Driver/OffloadBundler.cpp

@@ -692,7 +692,7 @@ class ObjectFileHandler final : public FileHandler {
         if (SF->isIR() &&
             (Name == "llvm.used" || Name == "llvm.compiler.used" ||
              Name == "__AsanDeviceGlobalMetadata" ||
-             Name == "__AsanKernelMetadata"))
+             Name == "__AsanKernelMetadata" || Name == "__MsanKernelMetadata"))
           continue;
 
         // Add symbol name with the target prefix to the buffer.

clang/lib/Driver/SanitizerArgs.cpp

@@ -1169,6 +1169,7 @@ void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
   // SPIR/SPIRV sanitizer support is experimental and will pass a fixed set of
   // flags
   if (TC.getTriple().isSPIROrSPIRV()) {
+#if !defined(_WIN32)
     if (Sanitizers.has(SanitizerKind::Address)) {
       CmdArgs.push_back("-fsanitize=address");
       CmdArgs.push_back("-fsanitize-address-use-after-return=never");
@@ -1200,7 +1201,26 @@ void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
 
       addSpecialCaseListOpt(Args, CmdArgs,
                             "-fsanitize-ignorelist=", UserIgnorelistFiles);
+    } else if (Sanitizers.has(SanitizerKind::Memory)) {
+      CmdArgs.push_back("-fsanitize=memory");
+
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back("-msan-instrumentation-with-call-threshold=0");
+
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back("-msan-eager-checks=1");
     }
+#else // _WIN32
+    std::string SanitizeArg;
+    if (Sanitizers.has(SanitizerKind::Address))
+      SanitizeArg = "-fsanitize=address";
+    else if (Sanitizers.has(SanitizerKind::Memory))
+      SanitizeArg = "-fsanitize=memory";
+
+    if (!SanitizeArg.empty())
+      TC.getDriver().Diag(diag::warn_drv_unsupported_option_for_target)
+          << SanitizeArg << TC.getTripleString();
+#endif
     return;
   }