[SYCL] Allow buitin_assume_aligned to be called from device code. (#6705)

Prior to this PR, if there is a direct call to __builtin_assume_aligned
from within the device code, we would get the following error:
`error: SYCL kernel cannot call a variadic function`

This PR allows `__builtin_assume_aligned` to be invoked from within
device code.
The reason for doing so is, for example, if we load a float* pointer
from a data structure, the compiler has no way of knowing the underlying
alignment of the data the pointer points to, and therefore it cannot
combine the load/stores and one ends up with many unnecessary load/store
instructions plus lots of unnecessary pointer arithmetic plus increased
register pressure. We see this all over the place in our kernels. With
`__builtin_assume_aligned` we can tell the compiler to safely assume a
certain alignment, therefore implicitly forcing coalescing.

Author: srividya-sundaram

clang/include/clang/Sema/Sema.h

@@ -13982,7 +13982,7 @@ class Sema final {
     KernelConstStaticVariable
   };
 
-  bool isKnownGoodSYCLDecl(const Decl *D);
+  bool isDeclAllowedInSYCLDeviceCode(const Decl *D);
   void checkSYCLDeviceVarDecl(VarDecl *Var);
   void copySYCLKernelAttrs(const CXXRecordDecl *KernelObj);
   void ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc, MangleContext &MC);

clang/lib/Sema/SemaChecking.cpp

@@ -5967,8 +5967,8 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
     CheckSYCLKernelCall(FD, Range, Args);
 
   // Diagnose variadic calls in SYCL.
-  if (FD && FD ->isVariadic() && getLangOpts().SYCLIsDevice &&
-      !isUnevaluatedContext() && !isKnownGoodSYCLDecl(FD))
+  if (FD && FD->isVariadic() && getLangOpts().SYCLIsDevice &&
+      !isUnevaluatedContext() && !isDeclAllowedInSYCLDeviceCode(FD))
     SYCLDiagIfDeviceCode(Loc, diag::err_sycl_restrict)
         << Sema::KernelCallVariadicFunction;
 }

clang/lib/Sema/SemaSYCL.cpp

@@ -364,9 +364,15 @@ static bool IsSyclMathFunc(unsigned BuiltinID) {
   return true;
 }
 
-bool Sema::isKnownGoodSYCLDecl(const Decl *D) {
+bool Sema::isDeclAllowedInSYCLDeviceCode(const Decl *D) {
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     const IdentifierInfo *II = FD->getIdentifier();
+
+    // Allow __builtin_assume_aligned to be called from within device code.
+    if (FD->getBuiltinID() &&
+        FD->getBuiltinID() == Builtin::BI__builtin_assume_aligned)
+      return true;
+
     // Allow to use `::printf` only for CUDA.
     if (Context.getTargetInfo().getTriple().isNVPTX()) {
       if (FD->getBuiltinID() == Builtin::BIprintf)

clang/test/SemaSYCL/remove-restriction-builtin-assume-aligned.cpp

@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -fsycl-is-device -internal-isystem %S/Inputs -sycl-std=2020 -verify -fsyntax-only %s
+// This test checks if __builtin_assume_aligned does not throw an error when
+// called from within device code.
+
+#include "sycl.hpp"
+
+using namespace sycl;
+queue q;
+
+int main() {
+  int *Ptr[2];
+  // expected-no-diagnostics
+  q.submit([&](handler &h) {
+    h.single_task<class kernelA>([=]() {
+    int *APtr = (int *)__builtin_assume_aligned(Ptr, 32);
+    *APtr = 42;
+    });
+  });
+  return 0;
+}
+