[SYCL][ESIMD] Implement "private globals" (file scope private vars) in Front End.

"private globals" are essentially private variables in a global scope.
Marked with __attribute__((opencl_private)). Additionally can be
marked with __attribute__((register_num(n))) to bind to a specific register.

Signed-off-by: Konstantin S Bobrovsky <[email protected]>

Author: kbobrovs

clang/include/clang/Basic/Attr.td

@@ -1135,6 +1135,28 @@ def SYCLKernel : InheritableAttr {
   let Documentation = [SYCLKernelDocs];
 }
 
+// Marks functions which must not be vectorized via horizontal SIMT widening,
+// e.g. because the function is already vectorized. Used to mark SYCL
+// explicit SIMD kernels and functions.
+def SYCLSimd : InheritableAttr {
+  let Spellings = [GNU<"sycl_explicit_simd">];
+  let Subjects = SubjectList<[Function]>;
+  let LangOpts = [SYCLIsDevice];
+  let Documentation = [SYCLSimdDocs];
+}
+
+// Available in SYCL explicit SIMD extension. Binds a file scope private
+// variable to a specific register.
+def SYCLRegisterNum : InheritableAttr {
+  let Spellings = [GNU<"register_num">, Declspec<"register_num">];
+  let Args = [UnsignedArgument<"Number">];
+  let Subjects = SubjectList<[GlobalVar]>;
+  // This attribute is applied to file-scope variables and must be compilable
+  // for the host device as well
+  let LangOpts = [SYCLExplicitSIMD];
+  let Documentation = [SYCLRegisterNumDocs];
+}
+
 def SYCLScope : Attr {
   // No spelling, as this attribute can't be created in the source code.
   let Spellings = [];

clang/include/clang/Basic/AttrDocs.td

@@ -330,6 +330,30 @@ The SYCL kernel in the previous code sample meets these expectations.
   }];
 }
 
+def SYCLSimdDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+    The ``__attribute__((sycl_explicit_simd))`` attribute is used by the device
+    compiler front end to mark kernels and functions to be compiled and executed
+    in the explicit SIMD mode. In this mode subgroup size is always 1 and
+    explicit SIMD extensions - such as manual vectorization using wide vector
+    data types and operations can be used. Compiler may decide to compile such
+    functions using different different optimization and code generation
+    pipeline.
+  }];
+}
+
+def SYCLRegisterNumDocs : Documentation {
+  let Category = DocCatVariable;
+  let Content = [{
+    The ``__attribute__((register_num(n)))`` attribute can be used to bind
+    "private globals" (SYCL private address space variables declared in the file
+    scope) to a particular register with number 'n'. Actual mapping of registers
+    to numbers is target-specific. For Intel GPUs 'n' is a byte offset in the
+    GRF.
+  }];
+}
+
 def C11NoReturnDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{

clang/lib/CodeGen/CGSYCLRuntime.cpp

@@ -50,9 +50,11 @@ static bool isPFWI(const FunctionDecl &FD) {
   return FD.getName() == "parallel_for_work_item";
 }
 
-const char *WG_SCOPE_MD_ID = "work_group_scope";
-const char *WI_SCOPE_MD_ID = "work_item_scope";
-const char *PFWI_MD_ID = "parallel_for_work_item";
+constexpr char WG_SCOPE_MD_ID[] = "work_group_scope";
+constexpr char WI_SCOPE_MD_ID[] = "work_item_scope";
+constexpr char PFWI_MD_ID[] = "parallel_for_work_item";
+constexpr char ATTR_GENX_VOLATILE[] = "genx_volatile";
+constexpr char ATTR_GENX_BYTE_OFFSET[] = "genx_byte_offset";
 
 } // anonymous namespace
 
@@ -101,6 +103,19 @@ bool CGSYCLRuntime::actOnAutoVarEmit(CodeGenFunction &CGF, const VarDecl &D,
   return true;
 }
 
+bool CGSYCLRuntime::actOnGlobalVarEmit(CodeGenModule &CGM, const VarDecl &D,
+                                       llvm::Value *Addr) {
+  SYCLRegisterNumAttr *RegAttr = D.getAttr<SYCLRegisterNumAttr>();
+  if (!RegAttr)
+    return false;
+  auto *GlobVar = cast<llvm::GlobalVariable>(Addr);
+  GlobVar->addAttribute(ATTR_GENX_VOLATILE);
+  GlobVar->addAttribute(ATTR_GENX_BYTE_OFFSET,
+                        Twine(RegAttr->getNumber()).str());
+  // TODO consider reversing the error/success return values
+  return true;
+}
+
 bool Util::matchQualifiedTypeName(const CXXRecordDecl *RecTy,
                                   ArrayRef<Util::DeclContextDesc> Scopes) {
   // The idea: check the declaration context chain starting from the type

clang/lib/CodeGen/CGSYCLRuntime.h

@@ -34,6 +34,8 @@ class CGSYCLRuntime {
   void emitWorkGroupLocalVarDecl(CodeGenFunction &CGF, const VarDecl &D);
   bool actOnAutoVarEmit(CodeGenFunction &CGF, const VarDecl &D,
                         llvm::Value *Addr);
+  bool actOnGlobalVarEmit(CodeGenModule &CGM, const VarDecl &D,
+                          llvm::Value *Addr);
 };
 
 } // namespace CodeGen

clang/lib/CodeGen/CodeGenModule.cpp

@@ -3885,6 +3885,13 @@ LangAS CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D) {
     if (!D || D->getType().getAddressSpace() == LangAS::Default) {
       return LangAS::opencl_global;
     }
+    if (D)
+      AddrSpace = D->getType().getAddressSpace();
+    if (AddrSpace == LangAS::opencl_private ||
+        AddrSpace == LangAS::opencl_local)
+      // SYCL explicit SIMD path: recognize globals in private or local address
+      // space.
+      return AddrSpace;
   }
 
   if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
@@ -4415,8 +4422,12 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D,
     if (getCodeGenOpts().hasReducedDebugInfo())
       DI->EmitGlobalVariable(GV, D);
 
-  if (LangOpts.SYCLIsDevice)
+  if (LangOpts.SYCLIsDevice) {
     maybeEmitPipeStorageMetadata(D, GV, *this);
+    // Notify SYCL code generation infrastructure that a global variable is
+    // being generated.
+    getSYCLRuntime().actOnGlobalVarEmit(*this, *D, GV);
+  }
 }
 
 void CodeGenModule::EmitExternalVarDeclaration(const VarDecl *D) {

clang/lib/Sema/SemaDecl.cpp

@@ -12578,6 +12578,14 @@ void Sema::ActOnUninitializedDecl(Decl *RealDecl) {
     if (getLangOpts().OpenCL &&
         Var->getType().getAddressSpace() == LangAS::opencl_local)
       return;
+    // In SYCL ESIMD device code non-constant file scope variables can't be
+    // initialized.
+    // TODO add proper diagnostics for both SYCL and OpenCL paths
+    if (getLangOpts().SYCLExplicitSIMD && getLangOpts().SYCLIsDevice &&
+        Var->isFileVarDecl() && Var->hasGlobalStorage() &&
+        (Var->getType().getAddressSpace() != LangAS::opencl_constant))
+      return;
+
     // C++03 [dcl.init]p9:
     //   If no initializer is specified for an object, and the
     //   object is of (possibly cv-qualified) non-POD class type (or

clang/lib/Sema/SemaDeclAttr.cpp

@@ -4497,6 +4497,21 @@ static void handleSYCLDeviceIndirectlyCallableAttr(Sema &S, Decl *D,
   handleSimpleAttribute<SYCLDeviceIndirectlyCallableAttr>(S, D, AL);
 }
 
+static void handleSYCLRegisterNumAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  auto *VD = cast<VarDecl>(D);
+  if (!VD->hasGlobalStorage()) {
+    S.Diag(AL.getLoc(), diag::err_sycl_attibute_cannot_be_applied_here)
+        << AL << 0;
+    return;
+  }
+  assert(AL.getNumArgs() == 1);
+  uint32_t RegNo = 0;
+  const Expr *E = AL.getArgAsExpr(0);
+  if (!checkUInt32Argument(S, AL, E, RegNo, 0, /*StrictlyUnsigned=*/true))
+    return;
+  D->addAttr(::new (S.Context) SYCLRegisterNumAttr(S.Context, AL, RegNo));
+}
+
 static void handleConstantAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (checkAttrMutualExclusion<CUDASharedAttr>(S, D, AL))
     return;
@@ -7536,6 +7551,9 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   case ParsedAttr::AT_SYCLDeviceIndirectlyCallable:
     handleSYCLDeviceIndirectlyCallableAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_SYCLRegisterNum:
+    handleSYCLRegisterNumAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_Format:
     handleFormatAttr(S, D, AL);
     break;

clang/lib/Sema/SemaExpr.cpp

@@ -221,7 +221,9 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
       if (!IsConst && VD->getStorageClass() == SC_Static)
         SYCLDiagIfDeviceCode(*Locs.begin(), diag::err_sycl_restrict)
             << Sema::KernelNonConstStaticDataVariable;
-      else if (!IsConst && VD->hasGlobalStorage() && !isa<ParmVarDecl>(VD))
+      // Non-const globals are allowed for CM.
+      else if (!getLangOpts().SYCLExplicitSIMD && !IsConst &&
+               VD->hasGlobalStorage() && !isa<ParmVarDecl>(VD))
         SYCLDiagIfDeviceCode(*Locs.begin(), diag::err_sycl_restrict)
             << Sema::KernelGlobalVariable;
     }

clang/test/CodeGenSYCL/esimd-private-global.cpp

@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -disable-llvm-passes -triple spir64-unknown-unknown-sycldevice \
+// RUN:   -fsycl -fsycl-is-device -fsycl-explicit-simd -emit-llvm %s -o - | \
+// RUN:   FileCheck %s
+
+// This test checks that FE allows globals with register_num attribute in ESIMD mode.
+
+__attribute__((opencl_private)) __attribute__((register_num(17))) int vc;
+
+// CHECK-DAG: @vc = {{.+}} i32 0, align 4 #0
+// CHECK-DAG: attributes #0 = { "genx_byte_offset"="17" "genx_volatile" }
+
+SYCL_EXTERNAL void init_vc(int x) {
+  vc = x;
+}

clang/test/SemaSYCL/esimd-register-num-attr.cpp

@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -fsycl-explicit-simd -fsyntax-only -verify -pedantic %s
+
+#define ESIMD_PRIVATE __attribute__((opencl_private))
+#define ESIMD_REGISTER_NUM(n) __attribute__((register_num(n)))
+
+// no error expected
+ESIMD_PRIVATE ESIMD_REGISTER_NUM(17) int privGlob;
+
+void foo() {
+  // expected-warning@+1{{'register_num' attribute only applies to global variables}}
+  ESIMD_REGISTER_NUM(17)
+  int privLoc;
+}