[SYCL] Elizabeth's changes to emit OpenCL kernel metadata for SYCL kernels.

tahonermann · tahonermann · commit 3f56f9204040 · 2025-03-28T14:37:08.000-07:00
Elizabeth's changes to perform code generation for SYCL kernel device entry point functions caused the following kernel metadata annotations to be emitted for all device targets. - `kernel_arg_addr_space` - `kernel_arg_access_qual` - `kernel_arg_type` - `kernel_arg_base_type` - `kernel_arg_type_qual` It turns out that such metadata is not needed for SYCL; the above annotations are only needed for OpenCL. Investigation revealed that these annotations are emitted by the oneAPI compiler for ESIMD functions, but that was apparently due to an incorrect merge conflict resolution that is now being addressed by intel/llvm#17723. The above annotations are referenced by the SPIR-V Translator documentation. See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/blob/main/docs/SPIRVRepresentationInLLVM.rst#function-metadata. The oneAPI compiler does emit a `kernel_arg_buffer_location` annotation that is presumed to be needed as part of the support for the dead kernel argument elimination pass. Support for that annotation does not yet exist upstream.
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -619,21 +619,17 @@ CodeGenFunction::getUBSanFunctionTypeHash(QualType Ty) const {
       CGM.Int32Ty, static_cast<uint32_t>(llvm::xxh3_64bits(Mangled)));
 }
 
-void CodeGenFunction::EmitKernelMetadata(const FunctionDecl *FD,
-                                         llvm::Function *Fn) {
-  if (!FD->hasAttr<OpenCLKernelAttr>() && !FD->hasAttr<CUDAGlobalAttr>())
-    return;
-
+void CodeGenFunction::EmitKernelMetadata(const Decl *D, llvm::Function *Fn,
+                                         const OutlinedFunctionDecl *OFD) {
   llvm::LLVMContext &Context = getLLVMContext();
-
-  CGM.GenKernelArgMetadata(Fn, FD, this);
+  CGM.GenKernelArgMetadata(Fn, D, this, OFD);
 
   if (!(getLangOpts().OpenCL ||
         (getLangOpts().CUDA &&
          getContext().getTargetInfo().getTriple().isSPIRV())))
     return;
 
-  if (const VecTypeHintAttr *A = FD->getAttr<VecTypeHintAttr>()) {
+  if (const VecTypeHintAttr *A = D->getAttr<VecTypeHintAttr>()) {
     QualType HintQTy = A->getTypeHint();
     const ExtVectorType *HintEltQTy = HintQTy->getAs<ExtVectorType>();
     bool IsSignedInteger =
@@ -648,9 +644,9 @@ void CodeGenFunction::EmitKernelMetadata(const FunctionDecl *FD,
     Fn->setMetadata("vec_type_hint", llvm::MDNode::get(Context, AttrMDArgs));
   }
 
-  if (const WorkGroupSizeHintAttr *A = FD->getAttr<WorkGroupSizeHintAttr>()) {
+  if (const WorkGroupSizeHintAttr *A = D->getAttr<WorkGroupSizeHintAttr>()) {
     auto Eval = [&](Expr *E) {
-      return E->EvaluateKnownConstInt(FD->getASTContext()).getExtValue();
+      return E->EvaluateKnownConstInt(D->getASTContext()).getExtValue();
     };
     llvm::Metadata *AttrMDArgs[] = {
         llvm::ConstantAsMetadata::get(Builder.getInt32(Eval(A->getXDim()))),
@@ -659,9 +655,9 @@ void CodeGenFunction::EmitKernelMetadata(const FunctionDecl *FD,
     Fn->setMetadata("work_group_size_hint", llvm::MDNode::get(Context, AttrMDArgs));
   }
 
-  if (const ReqdWorkGroupSizeAttr *A = FD->getAttr<ReqdWorkGroupSizeAttr>()) {
+  if (const ReqdWorkGroupSizeAttr *A = D->getAttr<ReqdWorkGroupSizeAttr>()) {
     auto Eval = [&](Expr *E) {
-      return E->EvaluateKnownConstInt(FD->getASTContext()).getExtValue();
+      return E->EvaluateKnownConstInt(D->getASTContext()).getExtValue();
     };
     llvm::Metadata *AttrMDArgs[] = {
         llvm::ConstantAsMetadata::get(Builder.getInt32(Eval(A->getXDim()))),
@@ -671,7 +667,7 @@ void CodeGenFunction::EmitKernelMetadata(const FunctionDecl *FD,
   }
 
   if (const OpenCLIntelReqdSubGroupSizeAttr *A =
-          FD->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
+          D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
     llvm::Metadata *AttrMDArgs[] = {
         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getSubGroupSize()))};
     Fn->setMetadata("intel_reqd_sub_group_size",
@@ -751,17 +747,24 @@ static llvm::Constant *getPrologueSignature(CodeGenModule &CGM,
   return CGM.getTargetCodeGenInfo().getUBSanFunctionSignature(CGM);
 }
 
-void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
-                                    llvm::Function *Fn,
-                                    const CGFunctionInfo &FnInfo,
-                                    const FunctionArgList &Args,
-                                    SourceLocation Loc,
-                                    SourceLocation StartLoc) {
+void CodeGenFunction::StartFunction(
+    GlobalDecl GD, QualType RetTy, llvm::Function *Fn,
+    const CGFunctionInfo &FnInfo, const FunctionArgList &Args,
+    SourceLocation Loc, SourceLocation StartLoc,
+    const OutlinedFunctionDecl *OutlinedFnDecl) {
   assert(!CurFn &&
          "Do not use a CodeGenFunction object for more than one function");
 
   const Decl *D = GD.getDecl();
 
+  bool GeneratingSYCLOffloadKernel = false;
+  // The presence of OutlinedFnDecl indicates that we are currently
+  // generating the SYCL offload kernel.
+  if (getLangOpts().SYCLIsDevice && OutlinedFnDecl) {
+    D = OutlinedFnDecl;
+    GeneratingSYCLOffloadKernel = true;
+  }
+
   DidCallStackSave = false;
   CurCodeDecl = D;
   const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
@@ -1026,13 +1029,14 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
       Fn->addFnAttr(llvm::Attribute::FnRetThunkExtern);
   }
 
-  if (FD && (getLangOpts().OpenCL ||
-             (getLangOpts().CUDA &&
-              getContext().getTargetInfo().getTriple().isSPIRV()) ||
-             ((getLangOpts().HIP || getLangOpts().OffloadViaLLVM) &&
-              getLangOpts().CUDAIsDevice))) {
+  if (GeneratingSYCLOffloadKernel ||
+      (FD && ((getLangOpts().OpenCL && D->hasAttr<OpenCLKernelAttr>()) ||
+              (getLangOpts().CUDA &&
+               getContext().getTargetInfo().getTriple().isSPIRV()) ||
+              ((getLangOpts().HIP || getLangOpts().OffloadViaLLVM) &&
+               getLangOpts().CUDAIsDevice)))) {
     // Add metadata for a kernel function.
-    EmitKernelMetadata(FD, Fn);
+    EmitKernelMetadata(D, Fn, OutlinedFnDecl);
   }
 
   if (FD && FD->hasAttr<ClspvLibclcBuiltinAttr>()) {
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
@@ -2184,9 +2184,10 @@ class CodeGenFunction : public CodeGenTypeCache {
   /// the constructor, but could be overwritten to true if this is a coroutine.
   bool ShouldEmitLifetimeMarkers;
 
-  /// Add OpenCL kernel arg metadata and the kernel attribute metadata to
+  /// Add kernel arg metadata and the kernel attribute metadata to
   /// the function metadata.
-  void EmitKernelMetadata(const FunctionDecl *FD, llvm::Function *Fn);
+  void EmitKernelMetadata(const Decl *D, llvm::Function *Fn,
+                          const OutlinedFunctionDecl *OFD);
 
 public:
   CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext = false);
@@ -2422,7 +2423,8 @@ class CodeGenFunction : public CodeGenTypeCache {
   void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn,
                      const CGFunctionInfo &FnInfo, const FunctionArgList &Args,
                      SourceLocation Loc = SourceLocation(),
-                     SourceLocation StartLoc = SourceLocation());
+                     SourceLocation StartLoc = SourceLocation(),
+                     const OutlinedFunctionDecl *OutlinedFnDecl = nullptr);
 
   static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor);
 
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -2291,15 +2291,17 @@ static unsigned ArgInfoAddressSpace(LangAS AS) {
   }
 }
 
-void CodeGenModule::GenKernelArgMetadata(llvm::Function *Fn,
-                                         const FunctionDecl *FD,
-                                         CodeGenFunction *CGF) {
-  assert(((FD && CGF) || (!FD && !CGF)) &&
-         "Incorrect use - FD and CGF should either be both null or not!");
+void CodeGenModule::GenKernelArgMetadata(llvm::Function *Fn, const Decl *D,
+                                         CodeGenFunction *CGF,
+                                         const OutlinedFunctionDecl *OFD) {
+  assert(((D && CGF) || (!D && !CGF)) &&
+         "Incorrect use - D and CGF should either be both null or not!");
   // Create MDNodes that represent the kernel arg metadata.
   // Each MDNode is a list in the form of "key", N number of values which is
   // the same number of values as their are kernel arguments.
 
+  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
+
   const PrintingPolicy &Policy = Context.getPrintingPolicy();
 
   // MDNode for the kernel argument address space qualifiers.
@@ -2320,14 +2322,17 @@ void CodeGenModule::GenKernelArgMetadata(llvm::Function *Fn,
   // MDNode for the kernel argument names.
   SmallVector<llvm::Metadata *, 8> argNames;
 
-  if (FD && CGF)
-    for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
-      const ParmVarDecl *parm = FD->getParamDecl(i);
+  if (D && CGF) {
+    unsigned NumParam = OFD ? OFD->getNumParams() : FD->getNumParams();
+    for (unsigned i = 0, e = NumParam; i != e; ++i) {
+      const VarDecl *parm = OFD ? cast<VarDecl>(OFD->getParam(i))
+                                : cast<VarDecl>(FD->getParamDecl(i));
       // Get argument name.
       argNames.push_back(llvm::MDString::get(VMContext, parm->getName()));
 
-      if (!getLangOpts().OpenCL)
+      if (!getLangOpts().OpenCL && !getLangOpts().SYCLIsDevice)
         continue;
+
       QualType ty = parm->getType();
       std::string typeQuals;
 
@@ -2417,8 +2422,9 @@ void CodeGenModule::GenKernelArgMetadata(llvm::Function *Fn,
       }
       argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));
     }
+  }
 
-  if (getLangOpts().OpenCL) {
+  if (getLangOpts().OpenCL || getLangOpts().SYCLIsDevice) {
     Fn->setMetadata("kernel_arg_addr_space",
                     llvm::MDNode::get(VMContext, addressQuals));
     Fn->setMetadata("kernel_arg_access_qual",
diff --git a/clang/lib/CodeGen/CodeGenModule.h b/clang/lib/CodeGen/CodeGenModule.h
@@ -1682,9 +1682,11 @@ class CodeGenModule : public CodeGenTypeCache {
   /// \param FN is a pointer to IR function being generated.
   /// \param FD is a pointer to function declaration if any.
   /// \param CGF is a pointer to CodeGenFunction that generates this function.
-  void GenKernelArgMetadata(llvm::Function *FN,
-                            const FunctionDecl *FD = nullptr,
-                            CodeGenFunction *CGF = nullptr);
+  /// \param OFD is a pointer to the outlined function if we are generating a
+  ///        SYCL offload kernel.
+  void GenKernelArgMetadata(llvm::Function *FN, const Decl *D = nullptr,
+                            CodeGenFunction *CGF = nullptr,
+                            const OutlinedFunctionDecl *OFD = nullptr);
 
   /// Get target specific null pointer.
   /// \param T is the LLVM type of the null pointer.
diff --git a/clang/lib/CodeGen/CodeGenSYCL.cpp b/clang/lib/CodeGen/CodeGenSYCL.cpp
@@ -65,7 +65,7 @@ void CodeGenModule::EmitSYCLKernelCaller(const FunctionDecl *KernelEntryPointFn,
   SetLLVMFunctionAttributes(GlobalDecl(), FnInfo, Fn, false);
   SetSYCLKernelAttributes(Fn, CGF);
   CGF.StartFunction(GlobalDecl(), Ctx.VoidTy, Fn, FnInfo, Args,
-                    SourceLocation(), SourceLocation());
+                    SourceLocation(), SourceLocation(), OutlinedFnDecl);
   CGF.EmitFunctionBody(OutlinedFnDecl->getBody());
   setDSOLocal(Fn);
   SetLLVMFunctionAttributesForDefinition(cast<Decl>(OutlinedFnDecl), Fn);
diff --git a/clang/test/CodeGenSYCL/kernel-caller-entry-point.cpp b/clang/test/CodeGenSYCL/kernel-caller-entry-point.cpp
@@ -106,7 +106,13 @@ int main() {
 //
 // CHECK-AMDGCN:      Function Attrs: convergent mustprogress noinline norecurse nounwind optnone
 // CHECK-AMDGCN-NEXT: define dso_local amdgpu_kernel void @_ZTS26single_purpose_kernel_name
-// CHECK-AMDGCN-SAME:   (ptr addrspace(4) noundef byref(%struct.single_purpose_kernel) align 1 %0) #[[AMDGCN_ATTR0:[0-9]+]] {
+// CHECK-AMDGCN-SAME:   (ptr addrspace(4) noundef byref(%struct.single_purpose_kernel) align 1 %0) #[[AMDGCN_ATTR0:[0-9]+]]
+// CHECK-AMDGCN-SAME:   !kernel_arg_addr_space ![[KERNEL_ARG_ADDRSP:[0-9]+]]
+// CHECK-AMDGCN-SAME:   !kernel_arg_access_qual ![[KERNEL_ARG_ACCQUAL:[0-9]+]]
+// CHECK-AMDGCN-SAME:   !kernel_arg_type ![[KERNEL_ARG_TYPE1:[0-9]+]]
+// CHECK-AMDGCN-SAME:   !kernel_arg_base_type ![[KERNEL_ARG_TYPE1]]
+// CHECK-AMDGCN-SAME:   !kernel_arg_type_qual ![[KERNEL_ARG_TYPEQ:[0-9]+]]
+// CHECK-AMDGCN-SAME: {
 // CHECK-AMDGCN-NEXT: entry:
 // CHECK-AMDGCN-NEXT:   %coerce = alloca %struct.single_purpose_kernel, align 1, addrspace(5)
 // CHECK-AMDGCN-NEXT:   %kernelFunc = addrspacecast ptr addrspace(5) %coerce to ptr
@@ -119,7 +125,13 @@ int main() {
 //
 // CHECK-NVPTX:       Function Attrs: convergent mustprogress noinline norecurse nounwind optnone
 // CHECK-NVPTX-NEXT:  define dso_local ptx_kernel void @_ZTS26single_purpose_kernel_name
-// CHECK-NVPTX-SAME:    (ptr noundef byval(%struct.single_purpose_kernel) align 1 %kernelFunc) #[[NVPTX_ATTR0:[0-9]+]] {
+// CHECK-NVPTX-SAME:    (ptr noundef byval(%struct.single_purpose_kernel) align 1 %kernelFunc) #[[NVPTX_ATTR0:[0-9]+]]
+// CHECK-NVPTX-SAME:    !kernel_arg_addr_space ![[KERNEL_ARG_ADDRSP:[0-9]+]]
+// CHECK-NVPTX-SAME:    !kernel_arg_access_qual ![[KERNEL_ARG_ACCQUAL:[0-9]+]]
+// CHECK-NVPTX-SAME:    !kernel_arg_type ![[KERNEL_ARG_TYPE1:[0-9]+]]
+// CHECK-NVPTX-SAME:    !kernel_arg_base_type ![[KERNEL_ARG_TYPE1]]
+// CHECK-NVPTX-SAME:    !kernel_arg_type_qual ![[KERNEL_ARG_TYPEQ:[0-9]+]]
+// CHECK-NVPTX-SAME:  {
 // CHECK-NVPTX-NEXT:  entry:
 // CHECK-NVPTX-NEXT:    call void @_ZNK21single_purpose_kernelclEv
 // CHECK-NVPTX-SAME:      (ptr noundef nonnull align 1 dereferenceable(1) %kernelFunc) #[[NVPTX_ATTR1:[0-9]+]]
@@ -129,7 +141,13 @@ int main() {
 //
 // CHECK-SPIR:        Function Attrs: convergent mustprogress noinline norecurse nounwind optnone
 // CHECK-SPIR-NEXT:   define {{[a-z_ ]*}}spir_kernel void @_ZTS26single_purpose_kernel_name
-// CHECK-SPIR-SAME:     (ptr noundef byval(%struct.single_purpose_kernel) align 1 %kernelFunc) #[[SPIR_ATTR0:[0-9]+]] {
+// CHECK-SPIR-SAME:     (ptr noundef byval(%struct.single_purpose_kernel) align 1 %kernelFunc) #[[SPIR_ATTR0:[0-9]+]]
+// CHECK-SPIR-SAME:     !kernel_arg_addr_space ![[KERNEL_ARG_ADDRSP:[0-9]+]]
+// CHECK-SPIR-SAME:     !kernel_arg_access_qual ![[KERNEL_ARG_ACCQUAL:[0-9]+]]
+// CHECK-SPIR-SAME:     !kernel_arg_type ![[KERNEL_ARG_TYPE1:[0-9]+]]
+// CHECK-SPIR-SAME:     !kernel_arg_base_type ![[KERNEL_ARG_TYPE1]]
+// CHECK-SPIR-SAME:     !kernel_arg_type_qual ![[KERNEL_ARG_TYPEQ:[0-9]+]]
+// CHECK-SPIR-SAME:   {
 // CHECK-SPIR-NEXT:   entry:
 // CHECK-SPIR-NEXT:     %kernelFunc.ascast = addrspacecast ptr %kernelFunc to ptr addrspace(4)
 // CHECK-SPIR-NEXT:     call spir_func void @_ZNK21single_purpose_kernelclEv
@@ -143,7 +161,13 @@ int main() {
 //
 // CHECK-AMDGCN:      Function Attrs: convergent mustprogress noinline norecurse nounwind optnone
 // CHECK-AMDGCN-NEXT: define dso_local amdgpu_kernel void @_ZTSZ4mainE18lambda_kernel_name
-// CHECK-AMDGCN-SAME:   (i32 %kernelFunc.coerce) #[[AMDGCN_ATTR0]] {
+// CHECK-AMDGCN-SAME:   (i32 %kernelFunc.coerce) #[[AMDGCN_ATTR0]]
+// CHECK-AMDGCN-SAME:   !kernel_arg_addr_space ![[KERNEL_ARG_ADDRSP]]
+// CHECK-AMDGCN-SAME:   !kernel_arg_access_qual ![[KERNEL_ARG_ACCQUAL]]
+// CHECK-AMDGCN-SAME:   !kernel_arg_type ![[KERNEL_ARG_TYPE2:[0-9]+]]
+// CHECK-AMDGCN-SAME:   !kernel_arg_base_type ![[KERNEL_ARG_TYPE2]]
+// CHECK-AMDGCN-SAME:   !kernel_arg_type_qual ![[KERNEL_ARG_TYPEQ]]
+// CHECK-AMDGCN-SAME: {
 // CHECK-AMDGCN-NEXT: entry:
 // CHECK-AMDGCN-NEXT:   %kernelFunc = alloca %class.anon, align 4, addrspace(5)
 // CHECK-AMDGCN-NEXT:   %kernelFunc1 = addrspacecast ptr addrspace(5) %kernelFunc to ptr
@@ -157,7 +181,13 @@ int main() {
 //
 // CHECK-NVPTX:       Function Attrs: convergent mustprogress noinline norecurse nounwind optnone
 // CHECK-NVPTX-NEXT:  define dso_local ptx_kernel void @_ZTSZ4mainE18lambda_kernel_name
-// CHECK-NVPTX-SAME:    (ptr noundef byval(%class.anon) align 4 %kernelFunc) #[[NVPTX_ATTR0]] {
+// CHECK-NVPTX-SAME:    (ptr noundef byval(%class.anon) align 4 %kernelFunc) #[[NVPTX_ATTR0]]
+// CHECK-NVPTX-SAME:    !kernel_arg_addr_space ![[KERNEL_ARG_ADDRSP]]
+// CHECK-NVPTX-SAME:    !kernel_arg_access_qual ![[KERNEL_ARG_ACCQUAL]]
+// CHECK-NVPTX-SAME:    !kernel_arg_type ![[KERNEL_ARG_TYPE2:[0-9]+]]
+// CHECK-NVPTX-SAME:    !kernel_arg_base_type ![[KERNEL_ARG_TYPE2]]
+// CHECK-NVPTX-SAME:    !kernel_arg_type_qual ![[KERNEL_ARG_TYPEQ]]
+// CHECK-NVPTX-SAME:  {
 // CHECK-NVPTX-NEXT:  entry:
 // CHECK-NVPTX-NEXT:    call void @_ZZ4mainENKUlvE_clEv
 // CHECK-NVPTX-SAME:      (ptr noundef nonnull align 4 dereferenceable(4) %kernelFunc) #[[NVPTX_ATTR1]]
@@ -167,7 +197,13 @@ int main() {
 //
 // CHECK-SPIR:        Function Attrs: convergent mustprogress noinline norecurse nounwind optnone
 // CHECK-SPIR-NEXT:   define {{[a-z_ ]*}}spir_kernel void @_ZTSZ4mainE18lambda_kernel_name
-// CHECK-SPIR-SAME:     (ptr noundef byval(%class.anon) align 4 %kernelFunc) #[[SPIR_ATTR0]] {
+// CHECK-SPIR-SAME:     (ptr noundef byval(%class.anon) align 4 %kernelFunc) #[[SPIR_ATTR0]]
+// CHECK-SPIR-SAME:     !kernel_arg_addr_space ![[KERNEL_ARG_ADDRSP]]
+// CHECK-SPIR-SAME:     !kernel_arg_access_qual ![[KERNEL_ARG_ACCQUAL]]
+// CHECK-SPIR-SAME:     !kernel_arg_type ![[KERNEL_ARG_TYPE2:[0-9]+]]
+// CHECK-SPIR-SAME:     !kernel_arg_base_type ![[KERNEL_ARG_TYPE2]]
+// CHECK-SPIR-SAME:     !kernel_arg_type_qual ![[KERNEL_ARG_TYPEQ]]
+// CHECK-SPIR-SAME:   {
 // CHECK-SPIR-NEXT:   entry:
 // CHECK-SPIR-NEXT:     %kernelFunc.ascast = addrspacecast ptr %kernelFunc to ptr addrspace(4)
 // CHECK-SPIR-NEXT:     call spir_func void @_ZZ4mainENKUlvE_clEv
@@ -184,3 +220,9 @@ int main() {
 //
 // CHECK-SPIR: #[[SPIR_ATTR0]] = { convergent mustprogress noinline norecurse nounwind optnone "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
 // CHECK-SPIR: #[[SPIR_ATTR1]] = { convergent nounwind }
+
+// CHECK-DEVICE: ![[KERNEL_ARG_ADDRSP]] = !{i32 0}
+// CHECK-DEVICE: ![[KERNEL_ARG_ACCQUAL]] = !{!"none"}
+// CHECK-DEVICE: ![[KERNEL_ARG_TYPE1]] = !{!"single_purpose_kernel"}
+// CHECK-DEVICE: ![[KERNEL_ARG_TYPEQ]] = !{!""}
+// CHECK-DEVICE: ![[KERNEL_ARG_TYPE2]] = !{!"(lambda
