[SYCL]Emit an error if array size exceeds 65532 for SPIRV targets

* Due to SPIR-V intermediate format limitations, const global arrays with
  number of elements more than 65532 cannot be used inside SYCL kernel.
* A possible workaround is to split the array into several ones.

Author: srividya-sundaram

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10908,6 +10908,9 @@ def err_sycl_restrict : Error<
   "|use a const static or global variable that is neither zero-initialized "
   "nor constant-initialized"
   "}0">;
+def err_array_num_elements_exceeded
+    : Error<"Due to SPIR-V intermediate format limitations, constant arrays with number of elements more than 65532 cannot be used in SYCL."
+            "You can workaround this limitation by splitting the array into several ones">;
 def err_sycl_virtual_types : Error<
   "No class with a vtable can be used in a SYCL kernel or any code included in the kernel">;
 def note_sycl_recursive_function_declared_here: Note<"function implemented using recursion declared here">;

clang/include/clang/Sema/Sema.h

@@ -9969,6 +9969,7 @@ class Sema final {
   bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);
   bool checkAllowedSYCLInitializer(VarDecl *VD,
                                    bool CheckValueDependent = false);
+  bool isArrayZeroInitialized(VarDecl *VD, bool CheckValueDependent = false);
 
   // Adds an intel_reqd_sub_group_size attribute to a particular declaration.
   void addIntelReqdSubGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI,

clang/lib/Sema/SemaExpr.cpp

@@ -229,6 +229,21 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
                !checkAllowedSYCLInitializer(VD, /*CheckValueDependent =*/true))
         SYCLDiagIfDeviceCode(*Locs.begin(), diag::err_sycl_restrict)
             << Sema::KernelConstStaticVariable;
+      // Emit an error if a const global array's size exceeds SPIR-V
+      // intermediate format limitations for SPIRV compatible devices.
+      else if (IsConst && VD->hasGlobalStorage() &&
+               Context.getTargetInfo().getTriple().isSPIR() &&
+               !isArrayZeroInitialized(VD, /*CheckValueDependent =*/true)) {
+        QualType Ty = VD->getType();
+        if (const auto *CAType = dyn_cast<ConstantArrayType>(Ty)) {
+          assert(CAType);
+          const int MaxNumElements = 65535 - 3;
+          int64_t arrayElements = CAType->getSize().getSExtValue();
+          if (arrayElements > MaxNumElements)
+            SYCLDiagIfDeviceCode(*Locs.begin(),
+                                 diag::err_array_num_elements_exceeded);
+        }
+      }
     }
   }
 

clang/lib/Sema/SemaSYCL.cpp

@@ -2077,6 +2077,22 @@ void Sema::finalizeSYCLDelayedAnalysis(const FunctionDecl *Caller,
   }
 }
 
+bool Sema::isArrayZeroInitialized(VarDecl *VD, bool CheckValueDependent) {
+  assert(getLangOpts().SYCLIsDevice &&
+         "Should only be called during device compilation");
+  if (VD->isInvalidDecl() || !VD->hasInit() || !VD->hasGlobalStorage())
+    return false;
+  APValue *Value = nullptr;
+  if (VD->getInit() && !VD->getInit()->isValueDependent())
+    Value = VD->evaluateValue();
+  // zero-initialized arrays do not have any initialized elements.
+  if (Value && Value->isArray() && Value->hasArrayFiller() &&
+      Value->getArrayInitializedElts() == 0) {
+    return true;
+  }
+  return false;
+}
+
 bool Sema::checkAllowedSYCLInitializer(VarDecl *VD, bool CheckValueDependent) {
   assert(getLangOpts().SYCLIsDevice &&
          "Should only be called during SYCL compilation");

clang/test/SemaSYCL/array-num-elements-exceeded.cpp

@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -triple spir-unknown -verify -fsyntax-only %s
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -triple spir64-unknown -verify -fsyntax-only %s
+
+const double big[67000] = {1.0, 2.0, 3.0};
+const int zero_init_array[67000] = {};
+
+template <typename Name, typename Func>
+__attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
+  kernelFunc(); // expected-note {{called by 'kernel_single_task<fake_kernel, (lambda}}
+}
+
+int main() {
+  double hostResult = big[0]; // no error thrown, since accessing global const arrays with size > 65532 is valid from host code.
+  kernel_single_task<class fake_kernel>([]() {
+    int a = zero_init_array[0]; // no error thrown, since accessing zero-initialized arrays with size > 65532 is valid.
+    double kernelGlobal = big[0]; // expected-error {{Due to SPIR-V intermediate format limitations, constant arrays with number of elements more than 65532 cannot be used in SYCL.You can workaround this limitation by splitting the array into several ones}}
+  });
+  return 0;
+}