From 652caa8e1b6c4c5ec989879eaf526a704d1db79a Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Wed, 14 Aug 2024 15:16:05 -0700
Subject: [PATCH 001/107] Preliminary implementation of work_group_memory
 extension

---
 clang/include/clang/Basic/Attr.td                 |  4 ++--
 .../SemaSYCL/Inputs/sycl/detail/kernel_desc.hpp   |  1 +
 sycl/include/sycl/detail/kernel_desc.hpp          |  1 +
 sycl/include/sycl/handler.hpp                     | 10 +++++++++-
 sycl/include/sycl/sycl.hpp                        |  1 +
 sycl/source/detail/scheduler/commands.cpp         |  2 ++
 sycl/source/feature_test.hpp.in                   |  1 +
 sycl/source/handler.cpp                           | 15 ++++++++++-----
 8 files changed, 27 insertions(+), 8 deletions(-)

diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td
index 1dc61986be561..f3e2890cd1068 100644
--- a/clang/include/clang/Basic/Attr.td
+++ b/clang/include/clang/Basic/Attr.td
@@ -1513,12 +1513,12 @@ def SYCLType: InheritableAttr {
   let Subjects = SubjectList<[CXXRecord, Enum], ErrorDiag>;
   let LangOpts = [SYCLIsDevice, SilentlyIgnoreSYCLIsHost];
   let Args = [EnumArgument<"Type", "SYCLType", /*is_string=*/true,
-                           ["accessor", "local_accessor",
+                           ["accessor", "local_accessor", "work_group_memory",
                             "specialization_id", "kernel_handler", "buffer_location",
                             "no_alias", "accessor_property_list", "group",
                             "private_memory", "aspect", "annotated_ptr", "annotated_arg",
                             "stream", "sampler", "host_pipe", "multi_ptr"],
-                           ["accessor", "local_accessor",
+                           ["accessor", "local_accessor", "work_group_memory",
                             "specialization_id", "kernel_handler", "buffer_location",
                             "no_alias", "accessor_property_list", "group",
                             "private_memory", "aspect", "annotated_ptr", "annotated_arg",
diff --git a/clang/test/SemaSYCL/Inputs/sycl/detail/kernel_desc.hpp b/clang/test/SemaSYCL/Inputs/sycl/detail/kernel_desc.hpp
index 6ef9122d45209..820013ed0eff7 100644
--- a/clang/test/SemaSYCL/Inputs/sycl/detail/kernel_desc.hpp
+++ b/clang/test/SemaSYCL/Inputs/sycl/detail/kernel_desc.hpp
@@ -18,6 +18,7 @@ namespace detail {
     kind_pointer = 3,
     kind_specialization_constants_buffer = 4,
     kind_stream = 5,
+    kind_work_group_memory = 6,
     kind_invalid = 0xf, // not a valid kernel kind
   };
 
diff --git a/sycl/include/sycl/detail/kernel_desc.hpp b/sycl/include/sycl/detail/kernel_desc.hpp
index 85519c3388efd..535ab3d730298 100644
--- a/sycl/include/sycl/detail/kernel_desc.hpp
+++ b/sycl/include/sycl/detail/kernel_desc.hpp
@@ -42,6 +42,7 @@ enum class kernel_param_kind_t {
   kind_pointer = 3,
   kind_specialization_constants_buffer = 4,
   kind_stream = 5,
+  kind_work_group_memory = 6,
   kind_invalid = 0xf, // not a valid kernel kind
 };
 
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 6f2e9f9fc19b7..c41055479a3ea 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -35,6 +35,7 @@
 #include <sycl/ext/oneapi/experimental/raw_kernel_arg.hpp>
 #include <sycl/ext/oneapi/experimental/use_root_sync_prop.hpp>
 #include <sycl/ext/oneapi/experimental/virtual_functions.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 #include <sycl/ext/oneapi/kernel_properties/properties.hpp>
 #include <sycl/ext/oneapi/properties/properties.hpp>
 #include <sycl/group.hpp>
@@ -687,7 +688,10 @@ class __SYCL_EXPORT handler {
     setLocalAccessorArgHelper(ArgIndex, Arg);
 #endif
   }
-
+  template <typename DataT>
+  void setArgHelper(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT> Arg) {
+    addArg(detail::kernel_param_kind_t::kind_work_group_memory, nullptr, Arg->size, ArgIndex);
+}
   // setArgHelper for non local accessor argument.
   template <typename DataT, int Dims, access::mode AccessMode,
             access::target AccessTarget, access::placeholder IsPlaceholder>
@@ -2021,6 +2025,10 @@ class __SYCL_EXPORT handler {
     setArgHelper(ArgIndex, std::move(Arg));
   }
 
+  template<typename DataT>
+  void set_arg(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT> Arg) {
+    setArgHelper(ArgIndex, std::move(Arg));
+}
   // set_arg for graph dynamic_parameters
   template <typename T>
   void set_arg(int argIndex,
diff --git a/sycl/include/sycl/sycl.hpp b/sycl/include/sycl/sycl.hpp
index ab44642639b0d..fc5aff80487f8 100644
--- a/sycl/include/sycl/sycl.hpp
+++ b/sycl/include/sycl/sycl.hpp
@@ -100,6 +100,7 @@
 #include <sycl/ext/oneapi/experimental/raw_kernel_arg.hpp>
 #include <sycl/ext/oneapi/experimental/root_group.hpp>
 #include <sycl/ext/oneapi/experimental/tangle_group.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 #include <sycl/ext/oneapi/filter_selector.hpp>
 #include <sycl/ext/oneapi/free_function_queries.hpp>
 #include <sycl/ext/oneapi/functional.hpp>
diff --git a/sycl/source/detail/scheduler/commands.cpp b/sycl/source/detail/scheduler/commands.cpp
index f2ac3963b76c6..7e0fa1d372a7c 100644
--- a/sycl/source/detail/scheduler/commands.cpp
+++ b/sycl/source/detail/scheduler/commands.cpp
@@ -2282,6 +2282,8 @@ void SetArgBasedOnType(
     const std::function<void *(Requirement *Req)> &getMemAllocationFunc,
     const sycl::context &Context, detail::ArgDesc &Arg, size_t NextTrueIndex) {
   switch (Arg.MType) {
+  case kernel_param_kind_t::kind_work_group_memory:
+    break;
   case kernel_param_kind_t::kind_stream:
     break;
   case kernel_param_kind_t::kind_accessor: {
diff --git a/sycl/source/feature_test.hpp.in b/sycl/source/feature_test.hpp.in
index ac0ba886240e3..1cfbdaf53c525 100644
--- a/sycl/source/feature_test.hpp.in
+++ b/sycl/source/feature_test.hpp.in
@@ -112,6 +112,7 @@ inline namespace _V1 {
 #define SYCL_EXT_ONEAPI_RAW_KERNEL_ARG 1
 #define SYCL_EXT_ONEAPI_PROFILING_TAG 1
 #define SYCL_EXT_ONEAPI_ENQUEUE_NATIVE_COMMAND 1
+#define SYCL_EXT_ONEAPI_WORK_GROUP_MEMORY 1
 
 #ifndef __has_include
 #define __has_include(x) 0
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index 95421a80a8ce5..d8bc8d2258d33 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "ur_api.h"
 #include "sycl/detail/helpers.hpp"
+#include "ur_api.h"
 #include <algorithm>
 
 #include <detail/config.hpp>
@@ -789,6 +789,11 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
     }
     break;
   }
+  case kernel_param_kind_t::kind_work_group_memory: {
+    addArg(kernel_param_kind_t::kind_std_layout, nullptr, Size,
+           Index + IndexShift);
+    break;
+  }
   case kernel_param_kind_t::kind_sampler: {
     addArg(kernel_param_kind_t::kind_sampler, Ptr, sizeof(sampler),
            Index + IndexShift);
@@ -1127,7 +1132,7 @@ void handler::ext_oneapi_copy(
           sycl_ext_oneapi_bindless_images>();
   Desc.verify();
 
-  MSrcPtr = reinterpret_cast<void*>(Src.raw_handle);
+  MSrcPtr = reinterpret_cast<void *>(Src.raw_handle);
   MDstPtr = Dest;
 
   ur_image_desc_t UrDesc = {};
@@ -1180,8 +1185,8 @@ void handler::ext_oneapi_copy(
           sycl_ext_oneapi_bindless_images>();
   ImageDesc.verify();
 
-  MSrcPtr = reinterpret_cast<void*>(Src.raw_handle);
-  MDstPtr = reinterpret_cast<void*>(Dest.raw_handle);
+  MSrcPtr = reinterpret_cast<void *>(Src.raw_handle);
+  MDstPtr = reinterpret_cast<void *>(Dest.raw_handle);
 
   ur_image_desc_t UrDesc = {};
   UrDesc.stype = UR_STRUCTURE_TYPE_IMAGE_DESC;
@@ -1235,7 +1240,7 @@ void handler::ext_oneapi_copy(
           sycl_ext_oneapi_bindless_images>();
   SrcImgDesc.verify();
 
-  MSrcPtr = reinterpret_cast<void*>(Src.raw_handle);
+  MSrcPtr = reinterpret_cast<void *>(Src.raw_handle);
   MDstPtr = Dest;
 
   ur_image_desc_t UrDesc = {};

From 76daf777145d70816f6395b0bb304637f4d5d421 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Wed, 14 Aug 2024 15:16:28 -0700
Subject: [PATCH 002/107] Preliminary implementation of work_group_memory
 extension

---
 .../oneapi/experimental/work_group_memory.hpp | 77 +++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
new file mode 100644
index 0000000000000..4442ee4b5cc1d
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -0,0 +1,77 @@
+//===-------------------- work_group_memory.hpp ---------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <type_traits>
+
+namespace sycl {
+inline namespace _V1 {
+namespace detail {
+template <typename T> struct is_unbounded_array : std::false_type {};
+
+template <typename T> struct is_unbounded_array<T[]> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
+} // namespace detail
+
+namespace ext::oneapi::experimental {
+
+template <typename DataT, typename PropertyListT = empty_properties_t>
+class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory {
+public:
+  using value_type = std::remove_all_extents_t<DataT>;
+  work_group_memory() = default;
+  work_group_memory(const work_group_memory &rhs) = default;
+  work_group_memory &operator=(const work_group_memory &rhs) = default;
+#ifndef __SYCL_DEVICE_ONLY__
+  template <typename T = DataT,
+            typename = std::enable_if_t<!sycl::detail::is_unbounded_array_v<T>>>
+  work_group_memory(handler &) : size{sizeof(DataT)} {}
+  template <typename T = DataT,
+            typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
+  work_group_memory(size_t num, handler &cgh) {
+    size = num * sizeof(std::remove_extent_t<DataT>);
+  }
+#endif
+#ifdef __SYCL_DEVICE_ONLY__
+  template <access::decorated IsDecorated = access::decorated::no>
+  multi_ptr<value_type, access::address_space::local_space, IsDecorated>
+  get_multi_ptr() const {
+    return sycl::address_space_cast<access::address_space::local_space,
+                                    IsDecorated, value_type>(ptr);
+  }
+  DataT *operator&() const { return reinterpret_cast<DataT *>(ptr); }
+  operator DataT &() const { return *(this->operator&()); }
+  template <typename T = DataT,
+            typename = std::enable_if_t<!std::is_array_v<T>>>
+  const work_group_memory &operator=(const DataT &value) const {
+    *ptr = value;
+    return *this;
+  }
+
+  void __init(decoratedPtr ptr) { this->ptr = ptr; }
+#endif
+private:
+#ifdef __SYCL_DEVICE_ONLY__
+  using decoratedPtr = typename detail::DecoratedType<
+      value_type, access : address_space::local_space>::type *;
+  decoratedPtr ptr;
+#endif
+  size_t size;
+  friend class handler;
+};
+} // namespace ext::oneapi::experimental
+} // namespace _V1
+
+template <typename DataT>
+struct is_device_copyable<ext::oneapi::experimental::work_group_memory<DataT>>
+    : std::true_type {};
+
+} // namespace sycl

From 21e082b1dc7867424b1d362864ad1422822b9e0a Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Fri, 16 Aug 2024 12:21:27 -0700
Subject: [PATCH 003/107] Implement work_group_memory extension

---
 clang/include/clang/Sema/SemaSYCL.h           |  3 +-
 clang/lib/Sema/SemaSYCL.cpp                   | 68 +++++++++----------
 .../oneapi/experimental/work_group_memory.hpp | 49 ++++++++-----
 sycl/include/sycl/handler.hpp                 | 11 +--
 sycl/source/handler.cpp                       |  2 +-
 5 files changed, 74 insertions(+), 59 deletions(-)

diff --git a/clang/include/clang/Sema/SemaSYCL.h b/clang/include/clang/Sema/SemaSYCL.h
index f285dbfb0baa8..b5cab369724b7 100644
--- a/clang/include/clang/Sema/SemaSYCL.h
+++ b/clang/include/clang/Sema/SemaSYCL.h
@@ -60,7 +60,8 @@ class SYCLIntegrationHeader {
     kind_pointer,
     kind_specialization_constants_buffer,
     kind_stream,
-    kind_last = kind_stream
+    kind_work_group_memory,
+    kind_last = kind_work_group_memory
   };
 
 public:
diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index 75e0d5fd9eb9f..79c57356bdb82 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -23,8 +23,8 @@
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
-#include "clang/Sema/Initialization.h"
 #include "clang/Sema/Attr.h"
+#include "clang/Sema/Initialization.h"
 #include "clang/Sema/ParsedAttr.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/APSInt.h"
@@ -393,8 +393,7 @@ bool SemaSYCL::isDeclAllowedInSYCLDeviceCode(const Decl *D) {
       return true;
 
     const DeclContext *DC = FD->getDeclContext();
-    if (II && II->isStr("__spirv_ocl_printf") &&
-        !FD->isDefined() &&
+    if (II && II->isStr("__spirv_ocl_printf") && !FD->isDefined() &&
         FD->getLanguageLinkage() == CXXLanguageLinkage &&
         DC->getEnclosingNamespaceContext()->isTranslationUnit())
       return true;
@@ -665,9 +664,7 @@ class DiagDeviceFunction : public RecursiveASTVisitor<DiagDeviceFunction> {
 
   // Make sure we skip the condition of the case, since that is a constant
   // expression.
-  bool TraverseCaseStmt(CaseStmt *S) {
-    return TraverseStmt(S->getSubStmt());
-  }
+  bool TraverseCaseStmt(CaseStmt *S) { return TraverseStmt(S->getSubStmt()); }
 
   // Skip checking the size expr, since a constant array type loc's size expr is
   // a constant expression.
@@ -932,7 +929,8 @@ class SingleDeviceFunctionTracker {
         !KernelBody->hasAttr<AlwaysInlineAttr>() &&
         !KernelBody->hasAttr<SYCLSimdAttr>()) {
       KernelBody->addAttr(AlwaysInlineAttr::CreateImplicit(
-          KernelBody->getASTContext(), {}, AlwaysInlineAttr::Keyword_forceinline));
+          KernelBody->getASTContext(), {},
+          AlwaysInlineAttr::Keyword_forceinline));
     }
   }
 
@@ -1024,8 +1022,7 @@ class MarkWIScopeFnVisitor : public RecursiveASTVisitor<MarkWIScopeFnVisitor> {
       // not a member of sycl::group - continue search
       return true;
     auto Name = Callee->getName();
-    if (Name != "wait_for" ||
-        Callee->hasAttr<SYCLScopeAttr>())
+    if (Name != "wait_for" || Callee->hasAttr<SYCLScopeAttr>())
       return true;
     // it is a call to sycl::group::wait_for - mark the callee
     Callee->addAttr(
@@ -1263,7 +1260,7 @@ class KernelObjVisitor {
 
   template <typename ParentTy, typename... HandlerTys>
   void VisitUnionImpl(const CXXRecordDecl *Owner, ParentTy &Parent,
-                      const CXXRecordDecl *Wrapper, HandlerTys &... Handlers) {
+                      const CXXRecordDecl *Wrapper, HandlerTys &...Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.enterUnion(Owner, Parent), 0)...};
     VisitRecordHelper(Wrapper, Wrapper->fields(), Handlers...);
@@ -1273,13 +1270,13 @@ class KernelObjVisitor {
 
   // These enable handler execution only when previous Handlers succeed.
   template <typename... Tn>
-  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&... tn) {
+  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&...tn) {
     bool result = true;
     (void)std::initializer_list<int>{(result = result && tn(FD, FDTy), 0)...};
     return result;
   }
   template <typename... Tn>
-  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&... tn) {
+  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&...tn) {
     bool result = true;
     std::initializer_list<int>{(result = result && tn(BD, BDTy), 0)...};
     return result;
@@ -1324,7 +1321,7 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitComplexRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                           const CXXRecordDecl *Wrapper, QualType RecordTy,
-                          HandlerTys &... Handlers) {
+                          HandlerTys &...Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.enterStruct(Owner, Parent, RecordTy), 0)...};
     VisitRecordHelper(Wrapper, Wrapper->bases(), Handlers...);
@@ -1336,7 +1333,7 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitSimpleRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                          const CXXRecordDecl *Wrapper, QualType RecordTy,
-                         HandlerTys &... Handlers) {
+                         HandlerTys &...Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.handleNonDecompStruct(Owner, Parent, RecordTy), 0)...};
   }
@@ -1344,16 +1341,16 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                    const CXXRecordDecl *Wrapper, QualType RecordTy,
-                   HandlerTys &... Handlers);
+                   HandlerTys &...Handlers);
 
   template <typename ParentTy, typename... HandlerTys>
   void VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
-                  const CXXRecordDecl *Wrapper, HandlerTys &... Handlers);
+                  const CXXRecordDecl *Wrapper, HandlerTys &...Handlers);
 
   template <typename... HandlerTys>
   void VisitRecordHelper(const CXXRecordDecl *Owner,
                          clang::CXXRecordDecl::base_class_const_range Range,
-                         HandlerTys &... Handlers) {
+                         HandlerTys &...Handlers) {
     for (const auto &Base : Range) {
       QualType BaseTy = Base.getType();
       // Handle accessor class as base
@@ -1370,14 +1367,14 @@ class KernelObjVisitor {
   template <typename... HandlerTys>
   void VisitRecordHelper(const CXXRecordDecl *Owner,
                          RecordDecl::field_range Range,
-                         HandlerTys &... Handlers) {
+                         HandlerTys &...Handlers) {
     VisitRecordFields(Owner, Handlers...);
   }
 
   template <typename... HandlerTys>
   void visitArrayElementImpl(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
                              QualType ElementTy, uint64_t Index,
-                             HandlerTys &... Handlers) {
+                             HandlerTys &...Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.nextElement(ElementTy, Index), 0)...};
     visitField(Owner, ArrayField, ElementTy, Handlers...);
@@ -1385,24 +1382,24 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void visitFirstArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
-                              QualType ElementTy, HandlerTys &... Handlers) {
+                              QualType ElementTy, HandlerTys &...Handlers) {
     visitArrayElementImpl(Owner, ArrayField, ElementTy, 0, Handlers...);
   }
   template <typename... HandlerTys>
   void visitNthArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
                             QualType ElementTy, uint64_t Index,
-                            HandlerTys &... Handlers);
+                            HandlerTys &...Handlers);
 
   template <typename... HandlerTys>
   void visitSimpleArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                        QualType ArrayTy, HandlerTys &... Handlers) {
+                        QualType ArrayTy, HandlerTys &...Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.handleSimpleArrayType(Field, ArrayTy), 0)...};
   }
 
   template <typename... HandlerTys>
   void visitComplexArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                         QualType ArrayTy, HandlerTys &... Handlers) {
+                         QualType ArrayTy, HandlerTys &...Handlers) {
     // Array workflow is:
     // handleArrayType
     // enterArray
@@ -1434,7 +1431,7 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void visitField(const CXXRecordDecl *Owner, FieldDecl *Field,
-                  QualType FieldTy, HandlerTys &... Handlers) {
+                  QualType FieldTy, HandlerTys &...Handlers) {
     if (isSyclSpecialType(FieldTy, SemaSYCLRef))
       KF_FOR_EACH(handleSyclSpecialType, Field, FieldTy);
     else if (FieldTy->isStructureOrClassType()) {
@@ -1506,14 +1503,14 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void VisitRecordBases(const CXXRecordDecl *KernelFunctor,
-                        HandlerTys &... Handlers) {
+                        HandlerTys &...Handlers) {
     VisitRecordHelper(KernelFunctor, KernelFunctor->bases(), Handlers...);
   }
 
   // A visitor function that dispatches to functions as defined in
   // SyclKernelFieldHandler for the purposes of kernel generation.
   template <typename... HandlerTys>
-  void VisitRecordFields(const CXXRecordDecl *Owner, HandlerTys &... Handlers) {
+  void VisitRecordFields(const CXXRecordDecl *Owner, HandlerTys &...Handlers) {
     for (const auto Field : Owner->fields())
       visitField(Owner, Field, Field->getType(), Handlers...);
   }
@@ -1716,7 +1713,7 @@ template <bool B, bool... Rest> struct AllTrue {
 template <typename ParentTy, typename... Handlers>
 void KernelObjVisitor::VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
                                   const CXXRecordDecl *Wrapper,
-                                  Handlers &... handlers) {
+                                  Handlers &...handlers) {
   // Don't continue descending if none of the handlers 'care'. This could be 'if
   // constexpr' starting in C++17.  Until then, we have to count on the
   // optimizer to realize "if (false)" is a dead branch.
@@ -1730,7 +1727,7 @@ template <typename... Handlers>
 void KernelObjVisitor::visitNthArrayElement(const CXXRecordDecl *Owner,
                                             FieldDecl *ArrayField,
                                             QualType ElementTy, uint64_t Index,
-                                            Handlers &... handlers) {
+                                            Handlers &...handlers) {
   // Don't continue descending if none of the handlers 'care'. This could be 'if
   // constexpr' starting in C++17.  Until then, we have to count on the
   // optimizer to realize "if (false)" is a dead branch.
@@ -1744,8 +1741,7 @@ void KernelObjVisitor::visitNthArrayElement(const CXXRecordDecl *Owner,
 template <typename ParentTy, typename... HandlerTys>
 void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                                    const CXXRecordDecl *Wrapper,
-                                   QualType RecordTy,
-                                   HandlerTys &... Handlers) {
+                                   QualType RecordTy, HandlerTys &...Handlers) {
   RecordDecl *RD = RecordTy->getAsRecordDecl();
   assert(RD && "should not be null.");
   if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
@@ -1790,7 +1786,7 @@ void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
 
 template <typename... HandlerTys>
 void KernelObjVisitor::visitArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                                  QualType ArrayTy, HandlerTys &... Handlers) {
+                                  QualType ArrayTy, HandlerTys &...Handlers) {
 
   if (Field->hasAttr<SYCLRequiresDecompositionAttr>()) {
     visitComplexArray(Owner, Field, ArrayTy, Handlers...);
@@ -4480,6 +4476,7 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
     uint64_t Size;
     Size =
         SemaSYCLRef.getASTContext().getTypeSizeInChars(ParamTy).getQuantity();
+    ParamTy->dump();
     Header.addParamDesc(Kind, static_cast<unsigned>(Size),
                         static_cast<unsigned>(CurOffset + OffsetAdj));
   }
@@ -4540,6 +4537,8 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
                           CurOffset + offsetOf(FD, FieldTy));
     } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::stream)) {
       addParam(FD, FieldTy, SYCLIntegrationHeader::kind_stream);
+    } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::work_group_memory)) {
+      addParam(FieldTy, SYCLIntegrationHeader::kind_work_group_memory, offsetOf(FD, FieldTy));
     } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::sampler) ||
                SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::annotated_ptr) ||
                SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::annotated_arg)) {
@@ -5672,6 +5671,7 @@ static const char *paramKind2Str(KernelParamKind K) {
     CASE(stream);
     CASE(specialization_constants_buffer);
     CASE(pointer);
+    CASE(work_group_memory);
   }
   return "<ERROR>";
 
@@ -6187,7 +6187,6 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     O << "\n";
   }
 
-
   O << "// names of all kernels defined in the corresponding source\n";
   O << "static constexpr\n";
   O << "const char* const kernel_names[] = {\n";
@@ -6669,7 +6668,7 @@ bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
   for (const VarDecl *VD : GlobalVars) {
     VD = VD->getCanonicalDecl();
 
-    // Skip if this isn't a SpecIdType, DeviceGlobal, or HostPipe.  This 
+    // Skip if this isn't a SpecIdType, DeviceGlobal, or HostPipe.  This
     // can happen if it was a deduced type.
     if (!SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::specialization_id) &&
         !SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::host_pipe) &&
@@ -6714,8 +6713,7 @@ bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
         VD->getNameForDiagnostic(HostPipesOS, Policy, true);
       }
       HostPipesOS << ", \"";
-      HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(),
-                                                         VD);
+      HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(), VD);
       HostPipesOS << "\");\n";
     } else {
       EmittedFirstSpecConstant = true;
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 4442ee4b5cc1d..ba186446b4dbc 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -19,53 +19,68 @@ template <typename T> struct is_unbounded_array<T[]> : std::true_type {};
 
 template <typename T>
 inline constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
+
+class work_group_memory_impl {
+public:
+  work_group_memory_impl() = default;
+  work_group_memory_impl(const work_group_memory_impl &rhs) = default;
+  work_group_memory_impl &
+  operator=(const work_group_memory_impl &rhs) = default;
+  work_group_memory_impl(size_t sz) : size{sz} {}
+  size_t size;
+};
+
 } // namespace detail
 
 namespace ext::oneapi::experimental {
 
 template <typename DataT, typename PropertyListT = empty_properties_t>
-class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory {
+class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
+    : sycl::detail::work_group_memory_impl {
 public:
   using value_type = std::remove_all_extents_t<DataT>;
+
+private:
+  using element_type = std::remove_extent_t<DataT>;
+  using decoratedPtr = typename sycl::detail::DecoratedType<
+      value_type, access::address_space::local_space>::type *;
+
+public:
   work_group_memory() = default;
   work_group_memory(const work_group_memory &rhs) = default;
   work_group_memory &operator=(const work_group_memory &rhs) = default;
-#ifndef __SYCL_DEVICE_ONLY__
   template <typename T = DataT,
             typename = std::enable_if_t<!sycl::detail::is_unbounded_array_v<T>>>
-  work_group_memory(handler &) : size{sizeof(DataT)} {}
+  work_group_memory(handler &)
+      : sycl::detail::work_group_memory_impl(sizeof(DataT)) {}
   template <typename T = DataT,
             typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
-  work_group_memory(size_t num, handler &cgh) {
-    size = num * sizeof(std::remove_extent_t<DataT>);
-  }
-#endif
-#ifdef __SYCL_DEVICE_ONLY__
+  work_group_memory(size_t num, handler &cgh)
+      : sycl::detail::work_group_memory_impl(
+            num * sizeof(std::remove_extent_t<DataT>)) {}
   template <access::decorated IsDecorated = access::decorated::no>
   multi_ptr<value_type, access::address_space::local_space, IsDecorated>
   get_multi_ptr() const {
     return sycl::address_space_cast<access::address_space::local_space,
                                     IsDecorated, value_type>(ptr);
   }
-  DataT *operator&() const { return reinterpret_cast<DataT *>(ptr); }
-  operator DataT &() const { return *(this->operator&()); }
+  __attribute__((always_inline)) DataT *operator&() const {
+    return reinterpret_cast<DataT *>(ptr);
+  }
+  __attribute__((always_inline)) operator DataT &() const {
+    return *reinterpret_cast<DataT *>(ptr);
+  }
   template <typename T = DataT,
             typename = std::enable_if_t<!std::is_array_v<T>>>
   const work_group_memory &operator=(const DataT &value) const {
     *ptr = value;
     return *this;
   }
-
+#ifdef __SYCL_DEVICE_ONLY__
   void __init(decoratedPtr ptr) { this->ptr = ptr; }
 #endif
 private:
-#ifdef __SYCL_DEVICE_ONLY__
-  using decoratedPtr = typename detail::DecoratedType<
-      value_type, access : address_space::local_space>::type *;
   decoratedPtr ptr;
-#endif
-  size_t size;
-  friend class handler;
 };
 } // namespace ext::oneapi::experimental
 } // namespace _V1
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index c41055479a3ea..3f783dc35bcfc 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -689,8 +689,8 @@ class __SYCL_EXPORT handler {
 #endif
   }
   template <typename DataT>
-  void setArgHelper(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT> Arg) {
-    addArg(detail::kernel_param_kind_t::kind_work_group_memory, nullptr, Arg->size, ArgIndex);
+  void setArgHelper(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT> &&Arg) {
+    addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg, sizeof(Arg), ArgIndex);
 }
   // setArgHelper for non local accessor argument.
   template <typename DataT, int Dims, access::mode AccessMode,
@@ -913,13 +913,14 @@ class __SYCL_EXPORT handler {
 
     constexpr bool KernelHasName =
         KI::getName() != nullptr && KI::getName()[0] != '\0';
-
+std::cout << sizeof(KernelFunc) << std::endl;
+std::cout << KI::getKernelSize() << std::endl;
     // Some host compilers may have different captures from Clang. Currently
     // there is no stable way of handling this when extracting the captures, so
     // a static assert is made to fail for incompatible kernel lambdas.
     static_assert(
         !KernelHasName || sizeof(KernelFunc) == KI::getKernelSize(),
-        "Unexpected kernel lambda size. This can be caused by an "
+        "Unexpected kernel lambda size. Expected This can be caused by an "
         "external host compiler producing a lambda with an "
         "unexpected layout. This is a limitation of the compiler."
         "In many cases the difference is related to capturing constexpr "
@@ -2026,7 +2027,7 @@ class __SYCL_EXPORT handler {
   }
 
   template<typename DataT>
-  void set_arg(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT> Arg) {
+  void set_arg(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT> &&Arg) {
     setArgHelper(ArgIndex, std::move(Arg));
 }
   // set_arg for graph dynamic_parameters
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index d8bc8d2258d33..237970133b7e3 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -790,7 +790,7 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
     break;
   }
   case kernel_param_kind_t::kind_work_group_memory: {
-    addArg(kernel_param_kind_t::kind_std_layout, nullptr, Size,
+    addArg(kernel_param_kind_t::kind_std_layout, nullptr, static_cast<detail::work_group_memory_impl *>(Ptr)->size,
            Index + IndexShift);
     break;
   }

From 025cbc4dd40705b01cbbc0f68563dff5c54eb4cf Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Mon, 19 Aug 2024 10:23:26 -0700
Subject: [PATCH 004/107] Implement work_group_memory extension

---
 .../oneapi/experimental/work_group_memory.hpp | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index ba186446b4dbc..0a5fc480a6f62 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -41,7 +41,12 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   using value_type = std::remove_all_extents_t<DataT>;
 
 private:
-  using element_type = std::remove_extent_t<DataT>;
+  using reference_type =
+      std::conditional_t<sycl::detail::is_unbounded_array_v<DataT>,
+                         std::decay_t<DataT>, DataT &>;
+  using pointer_type =
+      std::conditional_t<sycl::detail::is_unbounded_array_v<DataT>,
+                         std::decay_t<DataT>, DataT *>;
   using decoratedPtr = typename sycl::detail::DecoratedType<
       value_type, access::address_space::local_space>::type *;
 
@@ -64,11 +69,13 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     return sycl::address_space_cast<access::address_space::local_space,
                                     IsDecorated, value_type>(ptr);
   }
-  __attribute__((always_inline)) DataT *operator&() const {
-    return reinterpret_cast<DataT *>(ptr);
-  }
-  __attribute__((always_inline)) operator DataT &() const {
-    return *reinterpret_cast<DataT *>(ptr);
+  pointer_type operator&() const { return reinterpret_cast<pointer_type>(ptr); }
+  operator reference_type() const {
+    if constexpr (!sycl::detail::is_unbounded_array_v<DataT>) {
+      return *(this->operator&());
+    } else {
+      return this->operator&();
+    }
   }
   template <typename T = DataT,
             typename = std::enable_if_t<!std::is_array_v<T>>>

From b94f7c94574ff22d43a42b8f1130a9c8a614752e Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 20 Aug 2024 07:22:42 -0700
Subject: [PATCH 005/107] Implement work group memory

---
 .../sycl/ext/oneapi/experimental/work_group_memory.hpp        | 4 ++--
 sycl/include/sycl/sycl.hpp                                    | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 0a5fc480a6f62..2fe160601144d 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -43,7 +43,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
 private:
   using reference_type =
       std::conditional_t<sycl::detail::is_unbounded_array_v<DataT>,
-                         std::decay_t<DataT>, DataT &>;
+                         std::decay_t<DataT> &, DataT &>;
   using pointer_type =
       std::conditional_t<sycl::detail::is_unbounded_array_v<DataT>,
                          std::decay_t<DataT>, DataT *>;
@@ -74,7 +74,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     if constexpr (!sycl::detail::is_unbounded_array_v<DataT>) {
       return *(this->operator&());
     } else {
-      return this->operator&();
+      return std::reference_wrapper<pointer_type>(this->operator&());
     }
   }
   template <typename T = DataT,
diff --git a/sycl/include/sycl/sycl.hpp b/sycl/include/sycl/sycl.hpp
index fc5aff80487f8..283d6ee5ca9ee 100644
--- a/sycl/include/sycl/sycl.hpp
+++ b/sycl/include/sycl/sycl.hpp
@@ -22,6 +22,7 @@
 #include <sycl/builtins.hpp>
 #include <sycl/context.hpp>
 #include <sycl/define_vendors.hpp>
+#include <sycl/detail/device_assert_win.hpp>
 #include <sycl/device.hpp>
 #include <sycl/device_aspect_traits.hpp>
 #include <sycl/device_selector.hpp>

From 0d6d694dc0f28882560995ee664fa3ee124d53e5 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Wed, 21 Aug 2024 19:39:11 -0700
Subject: [PATCH 006/107] Remove debug dumps

---
 clang/lib/Sema/SemaSYCL.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index 79c57356bdb82..da15f56614e47 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -4476,7 +4476,6 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
     uint64_t Size;
     Size =
         SemaSYCLRef.getASTContext().getTypeSizeInChars(ParamTy).getQuantity();
-    ParamTy->dump();
     Header.addParamDesc(Kind, static_cast<unsigned>(Size),
                         static_cast<unsigned>(CurOffset + OffsetAdj));
   }

From 9f2973a51a6dc3de8751328ddc9f9c82c5c0d7cd Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <113361374+lbushi25@users.noreply.github.com>
Date: Wed, 21 Aug 2024 22:56:11 -0400
Subject: [PATCH 007/107] Update work_group_memory.hpp

---
 .../sycl/ext/oneapi/experimental/work_group_memory.hpp     | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 2fe160601144d..76e333daeb963 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -41,9 +41,12 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   using value_type = std::remove_all_extents_t<DataT>;
 
 private:
+  // if DataT is an unbounded array, use as reference_type and
+  // pointer_type the decayed type of DataT. This is because
+  // unbounded arrays do not work well with the IR<->SPIRV translator
   using reference_type =
       std::conditional_t<sycl::detail::is_unbounded_array_v<DataT>,
-                         std::decay_t<DataT> &, DataT &>;
+                         std::decay_t<DataT>, DataT &>;
   using pointer_type =
       std::conditional_t<sycl::detail::is_unbounded_array_v<DataT>,
                          std::decay_t<DataT>, DataT *>;
@@ -74,7 +77,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     if constexpr (!sycl::detail::is_unbounded_array_v<DataT>) {
       return *(this->operator&());
     } else {
-      return std::reference_wrapper<pointer_type>(this->operator&());
+      return this->operator&();
     }
   }
   template <typename T = DataT,

From 852315fd4ece3e282049af5f3744e87ef52ffb8e Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Thu, 22 Aug 2024 05:27:01 +0200
Subject: [PATCH 008/107] Remove include of deleted header file

---
 sycl/include/sycl/sycl.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sycl/include/sycl/sycl.hpp b/sycl/include/sycl/sycl.hpp
index 283d6ee5ca9ee..fc5aff80487f8 100644
--- a/sycl/include/sycl/sycl.hpp
+++ b/sycl/include/sycl/sycl.hpp
@@ -22,7 +22,6 @@
 #include <sycl/builtins.hpp>
 #include <sycl/context.hpp>
 #include <sycl/define_vendors.hpp>
-#include <sycl/detail/device_assert_win.hpp>
 #include <sycl/device.hpp>
 #include <sycl/device_aspect_traits.hpp>
 #include <sycl/device_selector.hpp>

From 4234022582c7d3162ca73ed0d200967f20f689fa Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 01:31:32 +0200
Subject: [PATCH 009/107] Fix SPIRV compilation errors

---
 sycl-jit/common/include/Kernel.h              |  1 +
 .../oneapi/experimental/work_group_memory.hpp | 39 +++++++------------
 sycl/include/sycl/handler.hpp                 | 21 +++++-----
 sycl/source/detail/jit_compiler.cpp           |  2 +
 sycl/source/handler.cpp                       |  3 +-
 5 files changed, 32 insertions(+), 34 deletions(-)

diff --git a/sycl-jit/common/include/Kernel.h b/sycl-jit/common/include/Kernel.h
index 4b4bb35b9bbf9..2959b2e1b9871 100644
--- a/sycl-jit/common/include/Kernel.h
+++ b/sycl-jit/common/include/Kernel.h
@@ -58,6 +58,7 @@ enum class ParameterKind : uint32_t {
   Pointer = 3,
   SpecConstBuffer = 4,
   Stream = 5,
+  WorkGroupMemory = 6,
   Invalid = 0xF,
 };
 
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 76e333daeb963..0951ccebaedd5 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -26,33 +26,28 @@ class work_group_memory_impl {
   work_group_memory_impl(const work_group_memory_impl &rhs) = default;
   work_group_memory_impl &
   operator=(const work_group_memory_impl &rhs) = default;
-  work_group_memory_impl(size_t sz) : size{sz} {}
-  size_t size;
+  work_group_memory_impl(size_t wgm_size, size_t buffer_size) : wgm_size{ wgm_size }, buffer_size{ buffer_size }  {}
+  size_t wgm_size;
+  size_t buffer_size;
 };
 
+inline size_t getWorkGroupMemoryOwnSize(detail::work_group_memory_impl * wgm) {
+        return wgm->wgm_size;
+}
+inline size_t getWorkGroupMemoryBufferSize(detail::work_group_memory_impl * wgm) {
+        return wgm->buffer_size;
+}
 } // namespace detail
 
 namespace ext::oneapi::experimental {
-
 template <typename DataT, typename PropertyListT = empty_properties_t>
 class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     : sycl::detail::work_group_memory_impl {
 public:
   using value_type = std::remove_all_extents_t<DataT>;
-
 private:
-  // if DataT is an unbounded array, use as reference_type and
-  // pointer_type the decayed type of DataT. This is because
-  // unbounded arrays do not work well with the IR<->SPIRV translator
-  using reference_type =
-      std::conditional_t<sycl::detail::is_unbounded_array_v<DataT>,
-                         std::decay_t<DataT>, DataT &>;
-  using pointer_type =
-      std::conditional_t<sycl::detail::is_unbounded_array_v<DataT>,
-                         std::decay_t<DataT>, DataT *>;
   using decoratedPtr = typename sycl::detail::DecoratedType<
-      value_type, access::address_space::local_space>::type *;
-
+      DataT, access::address_space::local_space>::type *;
 public:
   work_group_memory() = default;
   work_group_memory(const work_group_memory &rhs) = default;
@@ -60,11 +55,11 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   template <typename T = DataT,
             typename = std::enable_if_t<!sycl::detail::is_unbounded_array_v<T>>>
   work_group_memory(handler &)
-      : sycl::detail::work_group_memory_impl(sizeof(DataT)) {}
+      : sycl::detail::work_group_memory_impl(sizeof(work_group_memory), sizeof(DataT)) {}
   template <typename T = DataT,
             typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
   work_group_memory(size_t num, handler &cgh)
-      : sycl::detail::work_group_memory_impl(
+      : sycl::detail::work_group_memory_impl(sizeof(work_group_memory),
             num * sizeof(std::remove_extent_t<DataT>)) {}
   template <access::decorated IsDecorated = access::decorated::no>
   multi_ptr<value_type, access::address_space::local_space, IsDecorated>
@@ -72,13 +67,9 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     return sycl::address_space_cast<access::address_space::local_space,
                                     IsDecorated, value_type>(ptr);
   }
-  pointer_type operator&() const { return reinterpret_cast<pointer_type>(ptr); }
-  operator reference_type() const {
-    if constexpr (!sycl::detail::is_unbounded_array_v<DataT>) {
-      return *(this->operator&());
-    } else {
-      return this->operator&();
-    }
+  DataT * operator&() const { return ptr; }
+  operator DataT&() const {
+    return *(this->operator&());
   }
   template <typename T = DataT,
             typename = std::enable_if_t<!std::is_array_v<T>>>
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 3f783dc35bcfc..b33e7682c61e4 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -35,7 +35,6 @@
 #include <sycl/ext/oneapi/experimental/raw_kernel_arg.hpp>
 #include <sycl/ext/oneapi/experimental/use_root_sync_prop.hpp>
 #include <sycl/ext/oneapi/experimental/virtual_functions.hpp>
-#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 #include <sycl/ext/oneapi/kernel_properties/properties.hpp>
 #include <sycl/ext/oneapi/properties/properties.hpp>
 #include <sycl/group.hpp>
@@ -161,7 +160,11 @@ template <class _name, class _dataT, int32_t _min_capacity, class _propertiesT,
 class pipe;
 }
 
+
 namespace ext ::oneapi ::experimental {
+template <typename, typename>
+class work_group_memory;
+
 struct image_descriptor;
 } // namespace ext::oneapi::experimental
 
@@ -169,7 +172,9 @@ namespace ext::oneapi::experimental::detail {
 class graph_impl;
 } // namespace ext::oneapi::experimental::detail
 namespace detail {
-
+class work_group_memory_impl;
+size_t getWorkGroupMemoryOwnSize(work_group_memory_impl *);
+size_t getWorkGroupMemoryBufferSize(work_group_memory_impl *);
 class handler_impl;
 class kernel_impl;
 class queue_impl;
@@ -688,9 +693,9 @@ class __SYCL_EXPORT handler {
     setLocalAccessorArgHelper(ArgIndex, Arg);
 #endif
   }
-  template <typename DataT>
-  void setArgHelper(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT> &&Arg) {
-    addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg, sizeof(Arg), ArgIndex);
+  template <typename DataT, typename PropertyListT>
+  void setArgHelper(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &&Arg) {
+    addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg, detail::getWorkGroupMemoryOwnSize(static_cast<detail::work_group_memory_impl *>(Arg)), ArgIndex);
 }
   // setArgHelper for non local accessor argument.
   template <typename DataT, int Dims, access::mode AccessMode,
@@ -913,8 +918,6 @@ class __SYCL_EXPORT handler {
 
     constexpr bool KernelHasName =
         KI::getName() != nullptr && KI::getName()[0] != '\0';
-std::cout << sizeof(KernelFunc) << std::endl;
-std::cout << KI::getKernelSize() << std::endl;
     // Some host compilers may have different captures from Clang. Currently
     // there is no stable way of handling this when extracting the captures, so
     // a static assert is made to fail for incompatible kernel lambdas.
@@ -2026,8 +2029,8 @@ std::cout << KI::getKernelSize() << std::endl;
     setArgHelper(ArgIndex, std::move(Arg));
   }
 
-  template<typename DataT>
-  void set_arg(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT> &&Arg) {
+  template<typename DataT, typename PropertyListT = ext::oneapi::experimental::empty_properties_t>
+  void set_arg(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &&Arg) {
     setArgHelper(ArgIndex, std::move(Arg));
 }
   // set_arg for graph dynamic_parameters
diff --git a/sycl/source/detail/jit_compiler.cpp b/sycl/source/detail/jit_compiler.cpp
index 2359293851c55..4ff2727a9268c 100644
--- a/sycl/source/detail/jit_compiler.cpp
+++ b/sycl/source/detail/jit_compiler.cpp
@@ -133,6 +133,8 @@ translateArgType(kernel_param_kind_t Kind) {
     return PK::SpecConstBuffer;
   case kind::kind_stream:
     return PK::Stream;
+  case kind::kind_work_group_memory:
+    return PK::WorkGroupMemory;
   case kind::kind_invalid:
     return PK::Invalid;
   }
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index 21a99ff475d62..58e2575550529 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -33,6 +33,7 @@
 
 #include <sycl/ext/oneapi/bindless_images_memory.hpp>
 #include <sycl/ext/oneapi/memcpy2d.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 
 namespace sycl {
 inline namespace _V1 {
@@ -790,7 +791,7 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
     break;
   }
   case kernel_param_kind_t::kind_work_group_memory: {
-    addArg(kernel_param_kind_t::kind_std_layout, nullptr, static_cast<detail::work_group_memory_impl *>(Ptr)->size,
+    addArg(kernel_param_kind_t::kind_std_layout, nullptr, detail::getWorkGroupMemoryBufferSize(static_cast<detail::work_group_memory_impl *>(Ptr)),
            Index + IndexShift);
     break;
   }

From ae5eb7e628093070d618cea574b64b9cb10ffcdb Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 05:05:16 +0200
Subject: [PATCH 010/107] Remove accidental change

---
 sycl/include/sycl/handler.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index b33e7682c61e4..572016edcbe43 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -923,7 +923,7 @@ class __SYCL_EXPORT handler {
     // a static assert is made to fail for incompatible kernel lambdas.
     static_assert(
         !KernelHasName || sizeof(KernelFunc) == KI::getKernelSize(),
-        "Unexpected kernel lambda size. Expected This can be caused by an "
+        "Unexpected kernel lambda size. This can be caused by an "
         "external host compiler producing a lambda with an "
         "unexpected layout. This is a limitation of the compiler."
         "In many cases the difference is related to capturing constexpr "

From 8ce0280028c1d3385dfbcff0edd5a02d0273083e Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 05:29:14 +0200
Subject: [PATCH 011/107] Formatting changes

---
 clang/lib/Sema/SemaSYCL.cpp   | 62 +++++++++++++++++++----------------
 sycl/include/sycl/handler.hpp |  3 ++
 sycl/source/handler.cpp       | 10 +++---
 3 files changed, 42 insertions(+), 33 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index c8aa9e597b87b..3102cde4b0378 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -393,7 +393,8 @@ bool SemaSYCL::isDeclAllowedInSYCLDeviceCode(const Decl *D) {
       return true;
 
     const DeclContext *DC = FD->getDeclContext();
-    if (II && II->isStr("__spirv_ocl_printf") && !FD->isDefined() &&
+    if (II && II->isStr("__spirv_ocl_printf") && 
+	!FD->isDefined() &&
         FD->getLanguageLinkage() == CXXLanguageLinkage &&
         DC->getEnclosingNamespaceContext()->isTranslationUnit())
       return true;
@@ -644,7 +645,9 @@ class DiagDeviceFunction : public RecursiveASTVisitor<DiagDeviceFunction> {
 
   // Make sure we skip the condition of the case, since that is a constant
   // expression.
-  bool TraverseCaseStmt(CaseStmt *S) { return TraverseStmt(S->getSubStmt()); }
+  bool TraverseCaseStmt(CaseStmt *S) { 
+    return TraverseStmt(S->getSubStmt());
+  }
 
   // Skip checking the size expr, since a constant array type loc's size expr is
   // a constant expression.
@@ -909,8 +912,7 @@ class SingleDeviceFunctionTracker {
         !KernelBody->hasAttr<AlwaysInlineAttr>() &&
         !KernelBody->hasAttr<SYCLSimdAttr>()) {
       KernelBody->addAttr(AlwaysInlineAttr::CreateImplicit(
-          KernelBody->getASTContext(), {},
-          AlwaysInlineAttr::Keyword_forceinline));
+          KernelBody->getASTContext(), {}, AlwaysInlineAttr::Keyword_forceinline));
     }
   }
 
@@ -1002,7 +1004,8 @@ class MarkWIScopeFnVisitor : public RecursiveASTVisitor<MarkWIScopeFnVisitor> {
       // not a member of sycl::group - continue search
       return true;
     auto Name = Callee->getName();
-    if (Name != "wait_for" || Callee->hasAttr<SYCLScopeAttr>())
+    if (Name != "wait_for" || 
+	Callee->hasAttr<SYCLScopeAttr>())
       return true;
     // it is a call to sycl::group::wait_for - mark the callee
     Callee->addAttr(
@@ -1238,7 +1241,7 @@ class KernelObjVisitor {
 
   template <typename ParentTy, typename... HandlerTys>
   void VisitUnionImpl(const CXXRecordDecl *Owner, ParentTy &Parent,
-                      const CXXRecordDecl *Wrapper, HandlerTys &...Handlers) {
+                      const CXXRecordDecl *Wrapper, HandlerTys &... Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.enterUnion(Owner, Parent), 0)...};
     VisitRecordHelper(Wrapper, Wrapper->fields(), Handlers...);
@@ -1248,13 +1251,13 @@ class KernelObjVisitor {
 
   // These enable handler execution only when previous Handlers succeed.
   template <typename... Tn>
-  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&...tn) {
+  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&... tn) {
     bool result = true;
     (void)std::initializer_list<int>{(result = result && tn(FD, FDTy), 0)...};
     return result;
   }
   template <typename... Tn>
-  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&...tn) {
+  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&... tn) {
     bool result = true;
     std::initializer_list<int>{(result = result && tn(BD, BDTy), 0)...};
     return result;
@@ -1299,7 +1302,7 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitComplexRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                           const CXXRecordDecl *Wrapper, QualType RecordTy,
-                          HandlerTys &...Handlers) {
+                          HandlerTys &... Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.enterStruct(Owner, Parent, RecordTy), 0)...};
     VisitRecordHelper(Wrapper, Wrapper->bases(), Handlers...);
@@ -1311,7 +1314,7 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitSimpleRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                          const CXXRecordDecl *Wrapper, QualType RecordTy,
-                         HandlerTys &...Handlers) {
+                         HandlerTys &... Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.handleNonDecompStruct(Owner, Parent, RecordTy), 0)...};
   }
@@ -1319,16 +1322,16 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                    const CXXRecordDecl *Wrapper, QualType RecordTy,
-                   HandlerTys &...Handlers);
+                   HandlerTys &... Handlers);
 
   template <typename ParentTy, typename... HandlerTys>
   void VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
-                  const CXXRecordDecl *Wrapper, HandlerTys &...Handlers);
+                  const CXXRecordDecl *Wrapper, HandlerTys &... Handlers);
 
   template <typename... HandlerTys>
   void VisitRecordHelper(const CXXRecordDecl *Owner,
                          clang::CXXRecordDecl::base_class_const_range Range,
-                         HandlerTys &...Handlers) {
+                         HandlerTys &... Handlers) {
     for (const auto &Base : Range) {
       QualType BaseTy = Base.getType();
       // Handle accessor class as base
@@ -1345,14 +1348,14 @@ class KernelObjVisitor {
   template <typename... HandlerTys>
   void VisitRecordHelper(const CXXRecordDecl *Owner,
                          RecordDecl::field_range Range,
-                         HandlerTys &...Handlers) {
+                         HandlerTys &... Handlers) {
     VisitRecordFields(Owner, Handlers...);
   }
 
   template <typename... HandlerTys>
   void visitArrayElementImpl(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
                              QualType ElementTy, uint64_t Index,
-                             HandlerTys &...Handlers) {
+                             HandlerTys &... Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.nextElement(ElementTy, Index), 0)...};
     visitField(Owner, ArrayField, ElementTy, Handlers...);
@@ -1360,24 +1363,24 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void visitFirstArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
-                              QualType ElementTy, HandlerTys &...Handlers) {
+                              QualType ElementTy, HandlerTys &... Handlers) {
     visitArrayElementImpl(Owner, ArrayField, ElementTy, 0, Handlers...);
   }
   template <typename... HandlerTys>
   void visitNthArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
                             QualType ElementTy, uint64_t Index,
-                            HandlerTys &...Handlers);
+                            HandlerTys &... Handlers);
 
   template <typename... HandlerTys>
   void visitSimpleArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                        QualType ArrayTy, HandlerTys &...Handlers) {
+                        QualType ArrayTy, HandlerTys &... Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.handleSimpleArrayType(Field, ArrayTy), 0)...};
   }
 
   template <typename... HandlerTys>
   void visitComplexArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                         QualType ArrayTy, HandlerTys &...Handlers) {
+                         QualType ArrayTy, HandlerTys &... Handlers) {
     // Array workflow is:
     // handleArrayType
     // enterArray
@@ -1409,7 +1412,7 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void visitField(const CXXRecordDecl *Owner, FieldDecl *Field,
-                  QualType FieldTy, HandlerTys &...Handlers) {
+                  QualType FieldTy, HandlerTys &... Handlers) {
     if (isSyclSpecialType(FieldTy, SemaSYCLRef))
       KF_FOR_EACH(handleSyclSpecialType, Field, FieldTy);
     else if (FieldTy->isStructureOrClassType()) {
@@ -1481,14 +1484,14 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void VisitRecordBases(const CXXRecordDecl *KernelFunctor,
-                        HandlerTys &...Handlers) {
+                        HandlerTys &... Handlers) {
     VisitRecordHelper(KernelFunctor, KernelFunctor->bases(), Handlers...);
   }
 
   // A visitor function that dispatches to functions as defined in
   // SyclKernelFieldHandler for the purposes of kernel generation.
   template <typename... HandlerTys>
-  void VisitRecordFields(const CXXRecordDecl *Owner, HandlerTys &...Handlers) {
+  void VisitRecordFields(const CXXRecordDecl *Owner, HandlerTys &... Handlers) {
     for (const auto Field : Owner->fields())
       visitField(Owner, Field, Field->getType(), Handlers...);
   }
@@ -1691,7 +1694,7 @@ template <bool B, bool... Rest> struct AllTrue {
 template <typename ParentTy, typename... Handlers>
 void KernelObjVisitor::VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
                                   const CXXRecordDecl *Wrapper,
-                                  Handlers &...handlers) {
+                                  Handlers &... handlers) {
   // Don't continue descending if none of the handlers 'care'. This could be 'if
   // constexpr' starting in C++17.  Until then, we have to count on the
   // optimizer to realize "if (false)" is a dead branch.
@@ -1705,7 +1708,7 @@ template <typename... Handlers>
 void KernelObjVisitor::visitNthArrayElement(const CXXRecordDecl *Owner,
                                             FieldDecl *ArrayField,
                                             QualType ElementTy, uint64_t Index,
-                                            Handlers &...handlers) {
+                                            Handlers &... handlers) {
   // Don't continue descending if none of the handlers 'care'. This could be 'if
   // constexpr' starting in C++17.  Until then, we have to count on the
   // optimizer to realize "if (false)" is a dead branch.
@@ -1719,7 +1722,8 @@ void KernelObjVisitor::visitNthArrayElement(const CXXRecordDecl *Owner,
 template <typename ParentTy, typename... HandlerTys>
 void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                                    const CXXRecordDecl *Wrapper,
-                                   QualType RecordTy, HandlerTys &...Handlers) {
+                                   QualType RecordTy,
+				   HandlerTys &...Handlers) {
   RecordDecl *RD = RecordTy->getAsRecordDecl();
   assert(RD && "should not be null.");
   if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
@@ -1764,7 +1768,7 @@ void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
 
 template <typename... HandlerTys>
 void KernelObjVisitor::visitArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                                  QualType ArrayTy, HandlerTys &...Handlers) {
+                                  QualType ArrayTy, HandlerTys &... Handlers) {
 
   if (Field->hasAttr<SYCLRequiresDecompositionAttr>()) {
     visitComplexArray(Owner, Field, ArrayTy, Handlers...);
@@ -6156,6 +6160,7 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     O << "\n";
   }
 
+
   O << "// names of all kernels defined in the corresponding source\n";
   O << "static constexpr\n";
   O << "const char* const kernel_names[] = {\n";
@@ -6637,7 +6642,7 @@ bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
   for (const VarDecl *VD : GlobalVars) {
     VD = VD->getCanonicalDecl();
 
-    // Skip if this isn't a SpecIdType, DeviceGlobal, or HostPipe.  This
+    // Skip if this isn't a SpecIdType, DeviceGlobal, or HostPipe.  This 
     // can happen if it was a deduced type.
     if (!SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::specialization_id) &&
         !SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::host_pipe) &&
@@ -6682,7 +6687,8 @@ bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
         VD->getNameForDiagnostic(HostPipesOS, Policy, true);
       }
       HostPipesOS << ", \"";
-      HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(), VD);
+      HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(),
+		      					 VD);
       HostPipesOS << "\");\n";
     } else {
       EmittedFirstSpecConstant = true;
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 572016edcbe43..ea3ce36aceaed 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -172,6 +172,7 @@ namespace ext::oneapi::experimental::detail {
 class graph_impl;
 } // namespace ext::oneapi::experimental::detail
 namespace detail {
+
 class work_group_memory_impl;
 size_t getWorkGroupMemoryOwnSize(work_group_memory_impl *);
 size_t getWorkGroupMemoryBufferSize(work_group_memory_impl *);
@@ -693,6 +694,7 @@ class __SYCL_EXPORT handler {
     setLocalAccessorArgHelper(ArgIndex, Arg);
 #endif
   }
+
   template <typename DataT, typename PropertyListT>
   void setArgHelper(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &&Arg) {
     addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg, detail::getWorkGroupMemoryOwnSize(static_cast<detail::work_group_memory_impl *>(Arg)), ArgIndex);
@@ -918,6 +920,7 @@ class __SYCL_EXPORT handler {
 
     constexpr bool KernelHasName =
         KI::getName() != nullptr && KI::getName()[0] != '\0';
+
     // Some host compilers may have different captures from Clang. Currently
     // there is no stable way of handling this when extracting the captures, so
     // a static assert is made to fail for incompatible kernel lambdas.
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index 58e2575550529..2d3bedfda2dea 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "sycl/detail/helpers.hpp"
 #include "ur_api.h"
+#include "sycl/detail/helpers.hpp"
 #include <algorithm>
 
 #include <detail/config.hpp>
@@ -1133,7 +1133,7 @@ void handler::ext_oneapi_copy(
           sycl_ext_oneapi_bindless_images>();
   Desc.verify();
 
-  MSrcPtr = reinterpret_cast<void *>(Src.raw_handle);
+  MSrcPtr = reinterpret_cast<void*>(Src.raw_handle);
   MDstPtr = Dest;
 
   ur_image_desc_t UrDesc = {};
@@ -1186,8 +1186,8 @@ void handler::ext_oneapi_copy(
           sycl_ext_oneapi_bindless_images>();
   ImageDesc.verify();
 
-  MSrcPtr = reinterpret_cast<void *>(Src.raw_handle);
-  MDstPtr = reinterpret_cast<void *>(Dest.raw_handle);
+  MSrcPtr = reinterpret_cast<void*>(Src.raw_handle);
+  MDstPtr = reinterpret_cast<void*>(Dest.raw_handle);
 
   ur_image_desc_t UrDesc = {};
   UrDesc.stype = UR_STRUCTURE_TYPE_IMAGE_DESC;
@@ -1241,7 +1241,7 @@ void handler::ext_oneapi_copy(
           sycl_ext_oneapi_bindless_images>();
   SrcImgDesc.verify();
 
-  MSrcPtr = reinterpret_cast<void *>(Src.raw_handle);
+  MSrcPtr = reinterpret_cast<void*>(Src.raw_handle);
   MDstPtr = Dest;
 
   ur_image_desc_t UrDesc = {};

From 4ee31a58be2e22d81a5ace13dd7bdd7b2e43dd55 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 05:37:30 +0200
Subject: [PATCH 012/107] Formatting changes

---
 clang/lib/Sema/SemaSYCL.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index 3102cde4b0378..51004626e0a7a 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -393,8 +393,8 @@ bool SemaSYCL::isDeclAllowedInSYCLDeviceCode(const Decl *D) {
       return true;
 
     const DeclContext *DC = FD->getDeclContext();
-    if (II && II->isStr("__spirv_ocl_printf") && 
-	!FD->isDefined() &&
+    if (II && II->isStr("__spirv_ocl_printf") &&
+        !FD->isDefined() &&
         FD->getLanguageLinkage() == CXXLanguageLinkage &&
         DC->getEnclosingNamespaceContext()->isTranslationUnit())
       return true;
@@ -645,7 +645,7 @@ class DiagDeviceFunction : public RecursiveASTVisitor<DiagDeviceFunction> {
 
   // Make sure we skip the condition of the case, since that is a constant
   // expression.
-  bool TraverseCaseStmt(CaseStmt *S) { 
+  bool TraverseCaseStmt(CaseStmt *S) {
     return TraverseStmt(S->getSubStmt());
   }
 
@@ -1004,8 +1004,8 @@ class MarkWIScopeFnVisitor : public RecursiveASTVisitor<MarkWIScopeFnVisitor> {
       // not a member of sycl::group - continue search
       return true;
     auto Name = Callee->getName();
-    if (Name != "wait_for" || 
-	Callee->hasAttr<SYCLScopeAttr>())
+    if (Name != "wait_for" ||
+        Callee->hasAttr<SYCLScopeAttr>())
       return true;
     // it is a call to sycl::group::wait_for - mark the callee
     Callee->addAttr(
@@ -1723,7 +1723,7 @@ template <typename ParentTy, typename... HandlerTys>
 void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                                    const CXXRecordDecl *Wrapper,
                                    QualType RecordTy,
-				   HandlerTys &...Handlers) {
+                                   HandlerTys &... Handlers) {
   RecordDecl *RD = RecordTy->getAsRecordDecl();
   assert(RD && "should not be null.");
   if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
@@ -6688,7 +6688,7 @@ bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
       }
       HostPipesOS << ", \"";
       HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(),
-		      					 VD);
+                                                         VD);
       HostPipesOS << "\");\n";
     } else {
       EmittedFirstSpecConstant = true;

From 7b1b90bcd5451c26058b4eb7f094d7ca69434838 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 05:39:04 +0200
Subject: [PATCH 013/107] Put the work group memory doc to supported

---
 .../sycl_ext_oneapi_work_group_memory.asciidoc                    | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename sycl/doc/extensions/{proposed => supported}/sycl_ext_oneapi_work_group_memory.asciidoc (100%)

diff --git a/sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc b/sycl/doc/extensions/supported/sycl_ext_oneapi_work_group_memory.asciidoc
similarity index 100%
rename from sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc
rename to sycl/doc/extensions/supported/sycl_ext_oneapi_work_group_memory.asciidoc

From cf7476e036d4f1bc3e37282b36ed0561f768836f Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 22 Aug 2024 20:54:21 -0700
Subject: [PATCH 014/107] More formatting changes

---
 clang/lib/Sema/SemaSYCL.cpp                   |  3 ++-
 .../sycl/ext/oneapi/experimental/test.cpp     | 19 ++++++++++++++
 .../oneapi/experimental/work_group_memory.hpp | 26 +++++++++++--------
 sycl/include/sycl/handler.hpp                 | 25 +++++++++++-------
 sycl/source/handler.cpp                       |  2 +-
 5 files changed, 53 insertions(+), 22 deletions(-)
 create mode 100644 sycl/include/sycl/ext/oneapi/experimental/test.cpp

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index 51004626e0a7a..7d9094b12e4c9 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -4519,7 +4519,8 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
     } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::stream)) {
       addParam(FD, FieldTy, SYCLIntegrationHeader::kind_stream);
     } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::work_group_memory)) {
-      addParam(FieldTy, SYCLIntegrationHeader::kind_work_group_memory, offsetOf(FD, FieldTy));
+      addParam(FieldTy, SYCLIntegrationHeader::kind_work_group_memory,
+               offsetOf(FD, FieldTy));
     } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::sampler) ||
                SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::annotated_ptr) ||
                SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::annotated_arg)) {
diff --git a/sycl/include/sycl/ext/oneapi/experimental/test.cpp b/sycl/include/sycl/ext/oneapi/experimental/test.cpp
new file mode 100644
index 0000000000000..f2143f221be9f
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/experimental/test.cpp
@@ -0,0 +1,19 @@
+#include <sycl/sycl.hpp>
+
+using namespace sycl;
+
+template
+struct ptr
+
+int main() {
+    queue q;
+    int magic;
+    buffer<int, 1> b{&magic, 1};
+    q.submit([&](handler& h) {
+    sycl::accessor acc{b, h};
+    local_accessor<int[][2], 0> acc{h};
+    h.parallel_for(nd_range<2>({2, 2}, {1, 1}), [=](nd_item<2> it) {
+        acc[it.get_local_id(0)][it.get_local_id(1)] = 42;
+});
+});
+}
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 0951ccebaedd5..c6999cb3c510a 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -26,16 +26,18 @@ class work_group_memory_impl {
   work_group_memory_impl(const work_group_memory_impl &rhs) = default;
   work_group_memory_impl &
   operator=(const work_group_memory_impl &rhs) = default;
-  work_group_memory_impl(size_t wgm_size, size_t buffer_size) : wgm_size{ wgm_size }, buffer_size{ buffer_size }  {}
+  work_group_memory_impl(size_t wgm_size, size_t buffer_size)
+      : wgm_size{wgm_size}, buffer_size{buffer_size} {}
   size_t wgm_size;
   size_t buffer_size;
 };
 
-inline size_t getWorkGroupMemoryOwnSize(detail::work_group_memory_impl * wgm) {
-        return wgm->wgm_size;
+inline size_t getWorkGroupMemoryOwnSize(detail::work_group_memory_impl *wgm) {
+  return wgm->wgm_size;
 }
-inline size_t getWorkGroupMemoryBufferSize(detail::work_group_memory_impl * wgm) {
-        return wgm->buffer_size;
+inline size_t
+getWorkGroupMemoryBufferSize(detail::work_group_memory_impl *wgm) {
+  return wgm->buffer_size;
 }
 } // namespace detail
 
@@ -45,9 +47,11 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     : sycl::detail::work_group_memory_impl {
 public:
   using value_type = std::remove_all_extents_t<DataT>;
+
 private:
   using decoratedPtr = typename sycl::detail::DecoratedType<
       DataT, access::address_space::local_space>::type *;
+
 public:
   work_group_memory() = default;
   work_group_memory(const work_group_memory &rhs) = default;
@@ -55,11 +59,13 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   template <typename T = DataT,
             typename = std::enable_if_t<!sycl::detail::is_unbounded_array_v<T>>>
   work_group_memory(handler &)
-      : sycl::detail::work_group_memory_impl(sizeof(work_group_memory), sizeof(DataT)) {}
+      : sycl::detail::work_group_memory_impl(sizeof(work_group_memory),
+                                             sizeof(DataT)) {}
   template <typename T = DataT,
             typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
   work_group_memory(size_t num, handler &cgh)
-      : sycl::detail::work_group_memory_impl(sizeof(work_group_memory),
+      : sycl::detail::work_group_memory_impl(
+            sizeof(work_group_memory),
             num * sizeof(std::remove_extent_t<DataT>)) {}
   template <access::decorated IsDecorated = access::decorated::no>
   multi_ptr<value_type, access::address_space::local_space, IsDecorated>
@@ -67,10 +73,8 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     return sycl::address_space_cast<access::address_space::local_space,
                                     IsDecorated, value_type>(ptr);
   }
-  DataT * operator&() const { return ptr; }
-  operator DataT&() const {
-    return *(this->operator&());
-  }
+  DataT *operator&() const { return ptr; }
+  operator DataT &() const { return *(this->operator&()); }
   template <typename T = DataT,
             typename = std::enable_if_t<!std::is_array_v<T>>>
   const work_group_memory &operator=(const DataT &value) const {
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index ea3ce36aceaed..b4abd989db921 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -160,10 +160,8 @@ template <class _name, class _dataT, int32_t _min_capacity, class _propertiesT,
 class pipe;
 }
 
-
 namespace ext ::oneapi ::experimental {
-template <typename, typename>
-class work_group_memory;
+template <typename, typename> class work_group_memory;
 
 struct image_descriptor;
 } // namespace ext::oneapi::experimental
@@ -696,9 +694,13 @@ class __SYCL_EXPORT handler {
   }
 
   template <typename DataT, typename PropertyListT>
-  void setArgHelper(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &&Arg) {
-    addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg, detail::getWorkGroupMemoryOwnSize(static_cast<detail::work_group_memory_impl *>(Arg)), ArgIndex);
-}
+  void setArgHelper(int ArgIndex, ext::oneapi::experimental::work_group_memory<
+                                      DataT, PropertyListT> &&Arg) {
+    addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg,
+           detail::getWorkGroupMemoryOwnSize(
+               static_cast<detail::work_group_memory_impl *>(Arg)),
+           ArgIndex);
+  }
   // setArgHelper for non local accessor argument.
   template <typename DataT, int Dims, access::mode AccessMode,
             access::target AccessTarget, access::placeholder IsPlaceholder>
@@ -2032,10 +2034,15 @@ class __SYCL_EXPORT handler {
     setArgHelper(ArgIndex, std::move(Arg));
   }
 
-  template<typename DataT, typename PropertyListT = ext::oneapi::experimental::empty_properties_t>
-  void set_arg(int ArgIndex, ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &&Arg) {
+  template <typename DataT, typename PropertyListT =
+                                ext::oneapi::experimental::empty_properties_t>
+  void
+  set_arg(int ArgIndex,
+          ext::oneapi::experimental::work_group_memory<DataT, PropertyListT>
+              &&Arg) {
     setArgHelper(ArgIndex, std::move(Arg));
-}
+  }
+
   // set_arg for graph dynamic_parameters
   template <typename T>
   void set_arg(int argIndex,
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index 2d3bedfda2dea..43ebeb0bc4a78 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -32,8 +32,8 @@
 #include <sycl/stream.hpp>
 
 #include <sycl/ext/oneapi/bindless_images_memory.hpp>
-#include <sycl/ext/oneapi/memcpy2d.hpp>
 #include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
+#include <sycl/ext/oneapi/memcpy2d.hpp>
 
 namespace sycl {
 inline namespace _V1 {

From 50c0954d5b914f2b1ca1568dc3d3bf850e71b27a Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <113361374+lbushi25@users.noreply.github.com>
Date: Fri, 23 Aug 2024 00:00:11 -0400
Subject: [PATCH 015/107] Delete
 sycl/include/sycl/ext/oneapi/experimental/test.cpp

---
 .../sycl/ext/oneapi/experimental/test.cpp     | 19 -------------------
 1 file changed, 19 deletions(-)
 delete mode 100644 sycl/include/sycl/ext/oneapi/experimental/test.cpp

diff --git a/sycl/include/sycl/ext/oneapi/experimental/test.cpp b/sycl/include/sycl/ext/oneapi/experimental/test.cpp
deleted file mode 100644
index f2143f221be9f..0000000000000
--- a/sycl/include/sycl/ext/oneapi/experimental/test.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <sycl/sycl.hpp>
-
-using namespace sycl;
-
-template
-struct ptr
-
-int main() {
-    queue q;
-    int magic;
-    buffer<int, 1> b{&magic, 1};
-    q.submit([&](handler& h) {
-    sycl::accessor acc{b, h};
-    local_accessor<int[][2], 0> acc{h};
-    h.parallel_for(nd_range<2>({2, 2}, {1, 1}), [=](nd_item<2> it) {
-        acc[it.get_local_id(0)][it.get_local_id(1)] = 42;
-});
-});
-}

From 44811b85b9f62be8bb0887ad55148a8d26639714 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 22 Aug 2024 21:06:52 -0700
Subject: [PATCH 016/107] Yet more formatting changes

---
 sycl/source/handler.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index 43ebeb0bc4a78..0ff2c785cb8f7 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -791,7 +791,9 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
     break;
   }
   case kernel_param_kind_t::kind_work_group_memory: {
-    addArg(kernel_param_kind_t::kind_std_layout, nullptr, detail::getWorkGroupMemoryBufferSize(static_cast<detail::work_group_memory_impl *>(Ptr)),
+    addArg(kernel_param_kind_t::kind_std_layout, nullptr,
+           detail::getWorkGroupMemoryBufferSize(
+               static_cast<detail::work_group_memory_impl *>(Ptr)),
            Index + IndexShift);
     break;
   }

From d343a2e9cc9154efc5d432f1faba86461806f238 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <113361374+lbushi25@users.noreply.github.com>
Date: Fri, 23 Aug 2024 00:17:48 -0400
Subject: [PATCH 017/107] Fix warnings on Linux

---
 sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index c6999cb3c510a..05c8dedfe8265 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -63,7 +63,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
                                              sizeof(DataT)) {}
   template <typename T = DataT,
             typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
-  work_group_memory(size_t num, handler &cgh)
+  work_group_memory(size_t num, handler &)
       : sycl::detail::work_group_memory_impl(
             sizeof(work_group_memory),
             num * sizeof(std::remove_extent_t<DataT>)) {}

From 3f1bc3075b1f7bb684802b1455da26377a08b635 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <113361374+lbushi25@users.noreply.github.com>
Date: Fri, 23 Aug 2024 00:20:50 -0400
Subject: [PATCH 018/107] Remove unnecessary forward declaration from
 handler.hpp

---
 sycl/include/sycl/handler.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index b4abd989db921..8a14e8e8d9a7d 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -173,7 +173,6 @@ namespace detail {
 
 class work_group_memory_impl;
 size_t getWorkGroupMemoryOwnSize(work_group_memory_impl *);
-size_t getWorkGroupMemoryBufferSize(work_group_memory_impl *);
 class handler_impl;
 class kernel_impl;
 class queue_impl;

From 103e2336ad3bbe426717cf26057c321e9be4faba Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <113361374+lbushi25@users.noreply.github.com>
Date: Fri, 23 Aug 2024 00:25:12 -0400
Subject: [PATCH 019/107] Remove rvalue references in favor of const lvalue
 references

---
 sycl/include/sycl/handler.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 8a14e8e8d9a7d..f0800c47bb6ab 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -693,8 +693,8 @@ class __SYCL_EXPORT handler {
   }
 
   template <typename DataT, typename PropertyListT>
-  void setArgHelper(int ArgIndex, ext::oneapi::experimental::work_group_memory<
-                                      DataT, PropertyListT> &&Arg) {
+  void setArgHelper(int ArgIndex, const ext::oneapi::experimental::work_group_memory<
+                                      DataT, PropertyListT> &Arg) {
     addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg,
            detail::getWorkGroupMemoryOwnSize(
                static_cast<detail::work_group_memory_impl *>(Arg)),
@@ -2037,9 +2037,9 @@ class __SYCL_EXPORT handler {
                                 ext::oneapi::experimental::empty_properties_t>
   void
   set_arg(int ArgIndex,
-          ext::oneapi::experimental::work_group_memory<DataT, PropertyListT>
-              &&Arg) {
-    setArgHelper(ArgIndex, std::move(Arg));
+          const ext::oneapi::experimental::work_group_memory<DataT, PropertyListT>
+              &Arg) {
+    setArgHelper(ArgIndex, Arg));
   }
 
   // set_arg for graph dynamic_parameters

From bfa5830942d28ea59ca47750dc05ba2ed73cec9d Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <113361374+lbushi25@users.noreply.github.com>
Date: Fri, 23 Aug 2024 00:32:32 -0400
Subject: [PATCH 020/107] Fix syntax errors

---
 sycl/include/sycl/handler.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index f0800c47bb6ab..bc10dc2358b02 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -2039,7 +2039,7 @@ class __SYCL_EXPORT handler {
   set_arg(int ArgIndex,
           const ext::oneapi::experimental::work_group_memory<DataT, PropertyListT>
               &Arg) {
-    setArgHelper(ArgIndex, Arg));
+    setArgHelper(ArgIndex, Arg);
   }
 
   // set_arg for graph dynamic_parameters

From 2031478ca886dfc280f84db5be1f29d61086a155 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 22 Aug 2024 21:37:27 -0700
Subject: [PATCH 021/107] Fix syntax errors

---
 sycl/include/sycl/handler.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index bc10dc2358b02..7b8639c8e4c2b 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -693,8 +693,10 @@ class __SYCL_EXPORT handler {
   }
 
   template <typename DataT, typename PropertyListT>
-  void setArgHelper(int ArgIndex, const ext::oneapi::experimental::work_group_memory<
-                                      DataT, PropertyListT> &Arg) {
+  void setArgHelper(
+      int ArgIndex,
+      const ext::oneapi::experimental::work_group_memory<DataT, PropertyListT>
+          &Arg) {
     addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg,
            detail::getWorkGroupMemoryOwnSize(
                static_cast<detail::work_group_memory_impl *>(Arg)),
@@ -2035,10 +2037,8 @@ class __SYCL_EXPORT handler {
 
   template <typename DataT, typename PropertyListT =
                                 ext::oneapi::experimental::empty_properties_t>
-  void
-  set_arg(int ArgIndex,
-          const ext::oneapi::experimental::work_group_memory<DataT, PropertyListT>
-              &Arg) {
+  void set_arg(int ArgIndex, const ext::oneapi::experimental::work_group_memory<
+                                 DataT, PropertyListT> &Arg) {
     setArgHelper(ArgIndex, Arg);
   }
 

From 76f0acce98e64276f37080cd56f073261b722389 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 15:22:06 +0200
Subject: [PATCH 022/107] Don't explicitly make the work_group_memory class
 device-copyable as it already is

---
 .../oneapi/experimental/work_group_memory.hpp  | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 0951ccebaedd5..5dc69b9cf2690 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <type_traits>
+#include <sycl/access/access.hpp>
 
 namespace sycl {
 inline namespace _V1 {
@@ -58,36 +59,31 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
       : sycl::detail::work_group_memory_impl(sizeof(work_group_memory), sizeof(DataT)) {}
   template <typename T = DataT,
             typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
-  work_group_memory(size_t num, handler &cgh)
+  work_group_memory(size_t num, handler &)
       : sycl::detail::work_group_memory_impl(sizeof(work_group_memory),
             num * sizeof(std::remove_extent_t<DataT>)) {}
   template <access::decorated IsDecorated = access::decorated::no>
   multi_ptr<value_type, access::address_space::local_space, IsDecorated>
   get_multi_ptr() const {
     return sycl::address_space_cast<access::address_space::local_space,
-                                    IsDecorated, value_type>(ptr);
+                                    IsDecorated, value_type>(data_ptr);
   }
-  DataT * operator&() const { return ptr; }
+  DataT * operator&() const { return data_ptr; }
   operator DataT&() const {
     return *(this->operator&());
   }
   template <typename T = DataT,
             typename = std::enable_if_t<!std::is_array_v<T>>>
   const work_group_memory &operator=(const DataT &value) const {
-    *ptr = value;
+    *data_ptr = value;
     return *this;
   }
 #ifdef __SYCL_DEVICE_ONLY__
-  void __init(decoratedPtr ptr) { this->ptr = ptr; }
+  void __init(__OPENCL_LOCAL_AS__ DataT data) { this->data_ptr = &data; }
 #endif
 private:
-  decoratedPtr ptr;
+  decoratedPtr data_ptr;
 };
 } // namespace ext::oneapi::experimental
 } // namespace _V1
-
-template <typename DataT>
-struct is_device_copyable<ext::oneapi::experimental::work_group_memory<DataT>>
-    : std::true_type {};
-
 } // namespace sycl

From 3513251fc89f338e9cbd46e07af8c16a4f502b10 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 16:04:58 +0200
Subject: [PATCH 023/107] Remove some more unnecessary code

---
 .../sycl/ext/oneapi/experimental/work_group_memory.hpp      | 6 +-----
 sycl/include/sycl/handler.hpp                               | 3 ++-
 sycl/source/handler.cpp                                     | 3 +--
 3 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 95f096f7851e7..b50593c3ad96e 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include <type_traits>
 #include <sycl/access/access.hpp>
+#include <type_traits>
 
 namespace sycl {
 inline namespace _V1 {
@@ -36,10 +36,6 @@ class work_group_memory_impl {
 inline size_t getWorkGroupMemoryOwnSize(detail::work_group_memory_impl *wgm) {
   return wgm->wgm_size;
 }
-inline size_t
-getWorkGroupMemoryBufferSize(detail::work_group_memory_impl *wgm) {
-  return wgm->buffer_size;
-}
 } // namespace detail
 
 namespace ext::oneapi::experimental {
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 7b8639c8e4c2b..990c585f78fba 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -699,9 +699,10 @@ class __SYCL_EXPORT handler {
           &Arg) {
     addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg,
            detail::getWorkGroupMemoryOwnSize(
-               static_cast<detail::work_group_memory_impl *>(Arg)),
+               static_cast<ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> *>(Arg)),
            ArgIndex);
   }
+
   // setArgHelper for non local accessor argument.
   template <typename DataT, int Dims, access::mode AccessMode,
             access::target AccessTarget, access::placeholder IsPlaceholder>
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index 0ff2c785cb8f7..0e8d927050690 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -792,8 +792,7 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
   }
   case kernel_param_kind_t::kind_work_group_memory: {
     addArg(kernel_param_kind_t::kind_std_layout, nullptr,
-           detail::getWorkGroupMemoryBufferSize(
-               static_cast<detail::work_group_memory_impl *>(Ptr)),
+               static_cast<detail::work_group_memory_impl *>(Ptr)->buffer_size,
            Index + IndexShift);
     break;
   }

From 2cec9976572123c4d4e4bd7673a246d407a8d2e9 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <113361374+lbushi25@users.noreply.github.com>
Date: Fri, 23 Aug 2024 10:06:41 -0400
Subject: [PATCH 024/107] Update work_group_memory.hpp

---
 .../sycl/ext/oneapi/experimental/work_group_memory.hpp      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index b50593c3ad96e..5b0582286d31a 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -68,18 +68,18 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   multi_ptr<value_type, access::address_space::local_space, IsDecorated>
   get_multi_ptr() const {
     return sycl::address_space_cast<access::address_space::local_space,
-                                    IsDecorated, value_type>(data_ptr);
+                                    IsDecorated, value_type>(ptr);
   }
   DataT *operator&() const { return ptr; }
   operator DataT &() const { return *(this->operator&()); }
   template <typename T = DataT,
             typename = std::enable_if_t<!std::is_array_v<T>>>
   const work_group_memory &operator=(const DataT &value) const {
-    *data_ptr = value;
+    *ptr = value;
     return *this;
   }
 #ifdef __SYCL_DEVICE_ONLY__
-  void __init(__OPENCL_LOCAL_AS__ DataT data) { this->data_ptr = &data; }
+  void __init(decoratedPtr ptr) { this->ptr = ptr; }
 #endif
 private:
   decoratedPtr data_ptr;

From 4c8b196dd753303fb8e8c7dde7b88c82b46aca8f Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <113361374+lbushi25@users.noreply.github.com>
Date: Fri, 23 Aug 2024 10:06:54 -0400
Subject: [PATCH 025/107] Update work_group_memory.hpp

---
 sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 5b0582286d31a..979ff34490ef9 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -82,7 +82,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   void __init(decoratedPtr ptr) { this->ptr = ptr; }
 #endif
 private:
-  decoratedPtr data_ptr;
+  decoratedPtr ptr;
 };
 } // namespace ext::oneapi::experimental
 } // namespace _V1

From a0b70e2ac6c5ab6530562ecaa93f8bba149802b5 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 07:19:54 -0700
Subject: [PATCH 026/107] Formatting

---
 sycl/include/sycl/handler.hpp | 3 ++-
 sycl/source/handler.cpp       | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 990c585f78fba..809eed806b5a1 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -699,7 +699,8 @@ class __SYCL_EXPORT handler {
           &Arg) {
     addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg,
            detail::getWorkGroupMemoryOwnSize(
-               static_cast<ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> *>(Arg)),
+               static_cast<ext::oneapi::experimental::work_group_memory<
+                   DataT, PropertyListT> *>(Arg)),
            ArgIndex);
   }
 
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index 0e8d927050690..f2fae01d418f8 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -792,7 +792,7 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
   }
   case kernel_param_kind_t::kind_work_group_memory: {
     addArg(kernel_param_kind_t::kind_std_layout, nullptr,
-               static_cast<detail::work_group_memory_impl *>(Ptr)->buffer_size,
+           static_cast<detail::work_group_memory_impl *>(Ptr)->buffer_size,
            Index + IndexShift);
     break;
   }

From ed8f125cfd502e9b3609374ba15ec4bcbd2ffea2 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 17:10:56 +0200
Subject: [PATCH 027/107] Move doc to experimental folder

---
 .../sycl_ext_oneapi_work_group_memory.asciidoc                    | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename sycl/doc/extensions/{supported => experimental}/sycl_ext_oneapi_work_group_memory.asciidoc (100%)

diff --git a/sycl/doc/extensions/supported/sycl_ext_oneapi_work_group_memory.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc
similarity index 100%
rename from sycl/doc/extensions/supported/sycl_ext_oneapi_work_group_memory.asciidoc
rename to sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc

From 94608763e9ae0445ed268dee54f7184ea93cbbe1 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 17:11:18 +0200
Subject: [PATCH 028/107] Update status section in doc

---
 .../sycl_ext_oneapi_work_group_memory.asciidoc         | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc
index 9a7875c6987ab..a8857dd213168 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc
@@ -49,12 +49,10 @@ This extension also depends on the following other SYCL extensions:
 
 == Status
 
-This is a proposed extension specification, intended to gather community
-feedback.
-Interfaces defined in this specification may not be implemented yet or may be
-in a preliminary state.
-The specification itself may also change in incompatible ways before it is
-finalized.
+This is an experimental extension specification, intended to provide early
+access to features and gather community feedback.  Interfaces defined in this
+specification are implemented in {dpcpp}, but they are not finalized and may
+change incompatibly in future versions of {dpcpp} without prior notice.
 *Shipping software products should not rely on APIs defined in this
 specification.*
 

From e2889b367638c465fd136b30c003b972df651c41 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Fri, 23 Aug 2024 08:17:52 -0700
Subject: [PATCH 029/107] Final fixes

---
 sycl/include/sycl/handler.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 809eed806b5a1..f1ec3d9178953 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -699,8 +699,7 @@ class __SYCL_EXPORT handler {
           &Arg) {
     addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg,
            detail::getWorkGroupMemoryOwnSize(
-               static_cast<ext::oneapi::experimental::work_group_memory<
-                   DataT, PropertyListT> *>(Arg)),
+               static_cast<detail::work_group_memory_impl *>(&Arg)),
            ArgIndex);
   }
 

From d6c78b929fe45349727b2d1542fcefb217dcfcb4 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <113361374+lbushi25@users.noreply.github.com>
Date: Fri, 23 Aug 2024 12:23:19 -0400
Subject: [PATCH 030/107] Remove unnecessary include

---
 sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 979ff34490ef9..fccb58ed25137 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include <sycl/access/access.hpp>
 #include <type_traits>
 
 namespace sycl {

From 8f7a07b420100e0af46e3c8a443661b251a0b325 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Wed, 28 Aug 2024 23:27:06 +0200
Subject: [PATCH 031/107] Add initial tests for work_group_memory extension

---
 .../oneapi/experimental/work_group_memory.hpp |  21 ++-
 .../swap_test_using_work_group_memory.cpp     |  80 +++++++++
 .../work_group_memory_sanity_test.cpp         | 170 ++++++++++++++++++
 3 files changed, 270 insertions(+), 1 deletion(-)
 create mode 100644 sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
 create mode 100644 sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index fccb58ed25137..61afd288a4c4c 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -35,6 +35,25 @@ class work_group_memory_impl {
 inline size_t getWorkGroupMemoryOwnSize(detail::work_group_memory_impl *wgm) {
   return wgm->wgm_size;
 }
+
+// The following 3 functions help us get the address of the first element of a multi-dimensional
+// array, be it bounded or unbounded. A scalar is also included. In that case, it just returns
+// the address of the scalar.
+template <typename DataT>
+auto getData(DataT& scalar) {
+	return &scalar;
+}
+
+template <typename DataT, size_t N>
+auto getData(DataT (&bounded_arr)[N]) {
+        return getData(bounded_arr[0]);
+}
+
+template<typename DataT>
+auto getData(DataT (&unbounded_arr)[]) {
+	return getData(unbounded_arr[0]);
+}
+
 } // namespace detail
 
 namespace ext::oneapi::experimental {
@@ -67,7 +86,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   multi_ptr<value_type, access::address_space::local_space, IsDecorated>
   get_multi_ptr() const {
     return sycl::address_space_cast<access::address_space::local_space,
-                                    IsDecorated, value_type>(ptr);
+                                    IsDecorated, value_type>(sycl::detail::getData(*ptr));
   }
   DataT *operator&() const { return ptr; }
   operator DataT &() const { return *(this->operator&()); }
diff --git a/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp b/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
new file mode 100644
index 0000000000000..903553cdb64a4
--- /dev/null
+++ b/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
@@ -0,0 +1,80 @@
+// RUN: %{build} -o %{t.out}
+// RUN: %{run} %{t.out} 
+
+#include <sycl/detail/core.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
+#include <cassert>
+#include <cstring>
+
+namespace syclexp = sycl::ext::oneapi::experimental;
+
+// This test performs a swap of two scalars/arrays inside a kernel using a work_group_memory object as a temporary buffer.
+// The test is done for scalars types, bounded and unbounded arrays. After the kernel finishes, it is verified on the host side 
+// that the swap worked.
+
+template< typename T>
+void swap_scalar(T& a, T& b) {
+	sycl::queue q;
+	const T old_a = a;
+	const T old_b = b;
+	{
+	sycl::buffer<T, 1> buf_a{ &a, 1};
+	sycl::buffer<T, 1> buf_b{ &b, 1};
+	q.submit([&](sycl::handler &cgh) {
+	sycl::accessor acc_a{ buf_a, cgh };
+	sycl::accessor acc_b { buf_b, cgh };
+	syclexp::work_group_memory<T> temp{ cgh };
+	cgh.single_task([=]() {
+		temp = acc_a[0];
+		acc_a[0] = acc_b[0];
+		acc_b[0] = temp;
+	});});
+	}
+	assert(a == old_b && b == old_a	&& "Swap assertion failed");
+}
+
+template<typename T, size_t N>
+void swap_bounded_array_1d(T (&a)[N], T (&b)[N]) {
+sycl::queue q;
+        T old_a[N];
+  	std::memcpy(old_a, a, sizeof(a));	
+        T old_b[N];
+	std::memcpy(old_b, b, sizeof(b));
+        { 
+        sycl::buffer<T, 1> buf_a{ a, N};
+        sycl::buffer<T, 1> buf_b{ b, N};
+        q.submit([&](sycl::handler &cgh) {
+        sycl::accessor acc_a{ buf_a, cgh };
+        sycl::accessor acc_b { buf_b, cgh };
+        syclexp::work_group_memory<T[N]> temp{ cgh };
+        cgh.single_task([=]() {
+for (int i= 0; i < N; ++i) {
+                temp[i] = acc_a[i];
+                acc_a[i] = acc_b[i];
+                acc_b[i] = temp[i];
+}
+        });});
+        }
+for (int i = 0; i < N; ++i) {
+        assert(a[i] == old_b[i] && b[i] == old_a[i] && "Swap assertion failed");
+}
+	
+}
+int main() {
+	int a = 25;
+	int b = 42;
+	int arr1[5] = {0, 1, 2, 3, 4};
+	int arr2[5] = {5, 6, 7, 8, 9};
+	swap_scalar(a, b);
+	swap_bounded_array_1d(arr1, arr2);
+return 0;
+}
+	
+	
+	
+	
+	
+	
+	
+	
+	
diff --git a/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp b/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp
new file mode 100644
index 0000000000000..b7905c573dae4
--- /dev/null
+++ b/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp
@@ -0,0 +1,170 @@
+// RUN: %{build} -o %{t.out}
+// RUN: %{run} %{t.out}
+
+#include <type_traits>
+#include <cstdlib>
+#include <iostream>
+#include <sycl/detail/core.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
+#include <sycl/usm.hpp>
+
+// Sanity test that checks to see if idiomatic code involving work_group_memory objects compiles and runs with no errors.
+
+namespace syclex = sycl::ext::oneapi::experimental;
+sycl::queue global_q;
+
+constexpr size_t SIZE = 4096;
+constexpr size_t WGSIZE = 256;
+
+struct point {
+  int x;
+  int y;
+};
+
+void simple_inc(const syclex::work_group_memory<int>& mem) {
+  mem++;
+}
+
+void fancy_inc(syclex::work_group_memory<int> mem) {
+  syclex::work_group_memory<int> t = mem;
+  t = mem;
+  t++;
+}
+
+void test_breadth() {
+  sycl::queue q;
+  global_q = q;
+
+  int *res = sycl::malloc_host<int>(16, q);
+
+  q.submit([&](sycl::handler &cgh) {
+    syclex::work_group_memory<int> mem1{cgh};
+    syclex::work_group_memory<int[10]> mem2{cgh};
+    syclex::work_group_memory<int[10]> mem3{cgh};
+    syclex::work_group_memory<int[]> mem4{5, cgh};
+    syclex::work_group_memory<int[][10]> mem5{2, cgh};
+    syclex::work_group_memory<int[][10]> mem6{2, cgh};
+    syclex::work_group_memory<point> mem7{cgh};
+    syclex::work_group_memory<point[][10]> mem8{2, cgh};
+
+    cgh.single_task([=] {
+      // Operations on scalar
+      ++mem1;
+      mem1++;
+      mem1 += 1;
+      mem1 = mem1 + 1;
+      int *p1 = &mem1; (*p1)++;
+      simple_inc(mem1);
+      fancy_inc(mem1);
+      res[0] = *(mem1.get_multi_ptr());
+      res[1] = mem1;
+
+      // Operations on bounded array
+      mem2[4] = mem2[4] + 1;
+      int (*p2)[10] = &mem2; (*p2)[4]++;
+      res[2] = mem2.get_multi_ptr()[4];
+      res[3] = mem2[4];
+
+      mem3[4] = mem3[4] + 1;
+      int (*p3)[10] = &mem3; (*p3)[4]++;
+      res[4] = mem3.get_multi_ptr()[4];
+      res[5] = mem3[4];
+
+      // Operations on unbounded array
+      mem4[4] = mem4[4] + 1;
+      int (*p4)[] = &mem4; (*p4)[4]++;
+      res[6] = mem4.get_multi_ptr()[4];
+      res[7] = mem4[4];
+
+      // Operations on unbounded multi-dimensional array
+      mem5[1][5] = mem5[1][5] + 1;
+      mem5[1][7] = mem5[1][7] + 1;
+      res[8] = mem5.get_multi_ptr()[10 + 5];
+      res[9] = mem5[1][7];
+
+      mem6[1][5] = mem6[1][5] + 1;
+      mem6[1][7] = mem6[1][7] + 1;
+      res[10] = mem6.get_multi_ptr()[10 + 5];
+      res[11] = mem6[1][7];
+
+      // Operations on scalar struct
+      (&mem7)->x++;
+      (&mem7)->y += 1;
+      point pnt = mem7;
+      pnt.x++;
+      pnt.y++;
+      mem7 = pnt;
+      res[12] = (&mem7)->x;
+      res[13] = (&mem7)->y;
+
+      // Operations on unbounded multi-dimensional array of struct
+      mem8[1][5].x++;
+      mem8[1][5].y += 1;
+      res[14] = mem8.get_multi_ptr()[10 + 5].x;
+      res[15] = mem8[1][5].y;
+    });
+  }).wait();
+}
+
+void test_basic() {
+  sycl::queue q;
+
+  q.submit([&](sycl::handler &cgh) {
+    // Allocate one element for each work-item in the work-group.
+    syclex::work_group_memory<int[WGSIZE]> mem{cgh};
+
+    sycl::nd_range ndr{{SIZE}, {WGSIZE}};
+    cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
+      size_t id = it.get_local_linear_id();
+
+      // Each work-item has its own dedicated element of the array.
+      mem[id] = 0;
+    });
+  }).wait();
+}
+
+void test_operations() {
+  sycl::queue q;
+
+  q.submit([&](sycl::handler &cgh) {
+    syclex::work_group_memory<int>       mem1{cgh};    // scalar
+    syclex::work_group_memory<int[10]>   mem2{cgh};    // bounded array
+    syclex::work_group_memory<int[]>     mem3{5, cgh}; // unbounded array
+    syclex::work_group_memory<int[][10]> mem4{2, cgh}; // multi-dimensional array
+    syclex::work_group_memory<point[10]> mem5{cgh};    // array of struct
+
+    sycl::nd_range ndr{{SIZE}, {WGSIZE}};
+    cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
+      if (it.get_group().leader()) {
+        // A "work_group_memory" templated on a scalar type acts much like the
+        // enclosed scalar type.
+        ++mem1;
+        mem1++;
+        mem1 += 1;
+        mem1 = mem1 + 1;
+        int *p1 = &mem1;
+
+        // A "work_group_memory" templated on an array type (either bounded or
+        // unbounded) acts like an array.
+        ++mem2[4];
+        mem2[4]++;
+        mem2[4] = mem2[4] + 1;
+        int *p2 = &mem2[4];
+
+        // A multi-dimensional array works as expected.
+        mem4[1][5] = mem4[1][5] + 1;
+        mem4[1][7] = mem4[1][7] + 1;
+
+        // An array of structs works as expected too.
+        mem5[1].x++;
+        mem5[1].y = mem5[1].y + 1;
+      }
+    });
+  }).wait();
+}
+
+int main() {
+  test_breadth();
+  test_basic();
+  test_operations();
+}

From ae598996dcc9288d3f4058355a03812cdcee0a96 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Thu, 29 Aug 2024 07:37:06 +0200
Subject: [PATCH 032/107] Add E2E tests for work group memory

---
 .../oneapi/experimental/work_group_memory.hpp |   2 +-
 .../swap_test_using_work_group_memory.cpp     | 265 ++++++++++++++++--
 .../work_group_memory_sanity_test.cpp         |   7 +-
 3 files changed, 246 insertions(+), 28 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 61afd288a4c4c..59c5c6f92ab85 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -22,7 +22,7 @@ inline constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
 
 class work_group_memory_impl {
 public:
-  work_group_memory_impl() = default;
+  work_group_memory_impl() : wgm_size{ 0 }, buffer_size{ 0 } {}
   work_group_memory_impl(const work_group_memory_impl &rhs) = default;
   work_group_memory_impl &
   operator=(const work_group_memory_impl &rhs) = default;
diff --git a/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp b/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
index 903553cdb64a4..dfb7bdae2fc50 100644
--- a/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
@@ -1,5 +1,5 @@
-// RUN: %{build} -o %{t.out}
-// RUN: %{run} %{t.out} 
+// RUN: %{build} -o %t.out
+// RUN: %{run} %t.out 
 
 #include <sycl/detail/core.hpp>
 #include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
@@ -9,8 +9,14 @@
 namespace syclexp = sycl::ext::oneapi::experimental;
 
 // This test performs a swap of two scalars/arrays inside a kernel using a work_group_memory object as a temporary buffer.
-// The test is done for scalars types, bounded and unbounded arrays. After the kernel finishes, it is verified on the host side 
+// The test is done for scalar types and bounded arrays. After the kernel finishes, it is verified on the host side 
 // that the swap worked.
+ 
+// One important note is that for unbounded arrays, the feature is unstable. Specifically, the code may or may not compile
+// when kernels reference work group memory objects that have been constructed with the unbounded array type. This is due to a 
+// limitation of SPIRV where it does not allow arrays of length zero. For example, an unbounded array may be translated to an array of length zero in 
+// LLVM IR and during the LLVM IR -> SPIRV translation phase, the translator rejects all arrays of length zero because they are invalid constructs in SPIRV.
+// As a result of this, unbounded arrays do not appear in this test. They do appear in the sanity test though in this directory because there the unbounded arrays are used with concrete subscript indices which seems to work, for now at least.
 
 template< typename T>
 void swap_scalar(T& a, T& b) {
@@ -30,11 +36,69 @@ void swap_scalar(T& a, T& b) {
 		acc_b[0] = temp;
 	});});
 	}
-	assert(a == old_b && b == old_a	&& "Swap assertion failed");
+	assert(a == old_b && b == old_a	&& "Incorrect swap!");
+	// swap again but this time using two temporaries. The first temporary will be used to save the value of a
+	// and the second temporay will be default-constructed and then copy-assigned from the first temporary
+ 	// to be then used to write that value to b.
+	{
+        sycl::buffer<T, 1> buf_a{ &a, 1};
+        sycl::buffer<T, 1> buf_b{ &b, 1};
+        q.submit([&](sycl::handler &cgh) {
+        sycl::accessor acc_a{ buf_a, cgh };
+        sycl::accessor acc_b { buf_b, cgh };
+        syclexp::work_group_memory<T> temp{ cgh };
+	syclexp::work_group_memory<T> temp2;
+        cgh.single_task([=]() {
+		temp2 = temp; // temp and temp2 have the same underlying data
+                temp = acc_a[0];
+                acc_a[0] = acc_b[0];
+                acc_b[0] = temp2; // safe to use temp2
+        });});
+        }
+	// Two swaps same as no swaps
+	assert(a == old_a && b == old_b && "Incorrect swap!");
+	// Initialize a second temporary and instead of assigning the first temporary to it, assign only the value of the data
+	// of the first temporary so that unlike above, the two temporaries will not be aliasing the same memory location but they
+	// will have equal values.
+	{
+        sycl::buffer<T, 1> buf_a{ &a, 1};
+        sycl::buffer<T, 1> buf_b{ &b, 1};
+        q.submit([&](sycl::handler &cgh) {
+        sycl::accessor acc_a{ buf_a, cgh };
+        sycl::accessor acc_b { buf_b, cgh };
+        syclexp::work_group_memory<T> temp{ cgh };
+	syclexp::work_group_memory<T> temp2{ cgh };
+        cgh.single_task([=]() {
+                temp = acc_a[0];
+                acc_a[0] = acc_b[0];
+		temp2 = *(temp.get_multi_ptr()); // temp2 now has the same value as temp but not the same memory location
+                acc_b[0] = temp2;
+        });});
+        }
+	// Three swaps same as one swap
+	assert(a == old_b && b == old_a && "Incorrect swap!");
+	// Same as above but instead of using multi_ptr, use address-of operator.
+	{
+        sycl::buffer<T, 1> buf_a{ &a, 1};
+        sycl::buffer<T, 1> buf_b{ &b, 1};
+        q.submit([&](sycl::handler &cgh) {
+        sycl::accessor acc_a{ buf_a, cgh };
+        sycl::accessor acc_b { buf_b, cgh };
+        syclexp::work_group_memory<T> temp{ cgh };
+syclexp::work_group_memory<T> temp2{ cgh };
+        cgh.single_task([=]() {
+                temp = acc_a[0];
+                acc_a[0] = acc_b[0];
+		temp2 = *(&temp);
+                acc_b[0] = temp2;
+        });});
+        }
+	// Four swaps same as no swap
+	assert(a == old_a && b == old_b && "Incorrect swap!");
 }
 
 template<typename T, size_t N>
-void swap_bounded_array_1d(T (&a)[N], T (&b)[N]) {
+void swap_array_1d(T (&a)[N], T (&b)[N]) {
 sycl::queue q;
         T old_a[N];
   	std::memcpy(old_a, a, sizeof(a));	
@@ -56,25 +120,182 @@ for (int i= 0; i < N; ++i) {
         });});
         }
 for (int i = 0; i < N; ++i) {
-        assert(a[i] == old_b[i] && b[i] == old_a[i] && "Swap assertion failed");
+        assert(a[i] == old_b[i] && b[i] == old_a[i] && "Incorrect swap!");
+}
+
+// Instead of working with the temporary work group memory object, we retrieve its corresponding
+// multi-pointer and work with it instead.
+{
+        sycl::buffer<T, 1> buf_a{ a, N};
+        sycl::buffer<T, 1> buf_b{ b, N};
+        q.submit([&](sycl::handler &cgh) {
+        sycl::accessor acc_a{ buf_a, cgh };
+        sycl::accessor acc_b { buf_b, cgh };
+        syclexp::work_group_memory<T[N]> temp{ cgh };
+        cgh.single_task([=]() {
+		auto ptr = temp.get_multi_ptr();
+for (int i= 0; i < N; ++i) {
+                ptr[i] = acc_a[i];
+                acc_a[i] = acc_b[i];
+                acc_b[i] = ptr[i];
+}
+        });});
+        }
+// Two swaps same as ono swap
+for (int i = 0; i < N; ++i) {
+assert(a[i] == old_a[i] && b[i] == old_b[i] && "Incorrect swap!");
+}
+
+// Same as above but use a pointer returned by the address-of operator instead.
+{
+        sycl::buffer<T, 1> buf_a{ a, N};
+        sycl::buffer<T, 1> buf_b{ b, N};
+        q.submit([&](sycl::handler &cgh) {
+        sycl::accessor acc_a{ buf_a, cgh };
+        sycl::accessor acc_b { buf_b, cgh };
+        syclexp::work_group_memory<T[N]> temp{ cgh };
+        cgh.single_task([=]() {
+auto ptr = &temp;
+for (int i= 0; i < N; ++i) {
+                (*ptr)[i] = acc_a[i];
+                acc_a[i] = acc_b[i];
+                acc_b[i] = (*ptr)[i];
+}
+        });});
+        }
+// Three swaps same as one swap
+for (int i = 0; i < N; ++i) {
+	assert(a[i] == old_b[i] && b[i] == old_a[i] && "Incorrect swap!");
+
 }
-	
 }
+
+
+template<typename T, size_t N, size_t M>
+void swap_array_2d(T (&a)[N][M], T (&b)[N][M]) {
+sycl::queue q;
+        T old_a[N][M];
+for (int i = 0; i < N; ++i) {
+        std::memcpy(old_a[i], a[i], sizeof(a[0]));
+}
+        T old_b[N][M];
+for (int i = 0; i < N; ++i) {
+
+        std::memcpy(old_b[i], b[i], sizeof(b[0]));
+}
+        {
+        sycl::buffer<T, 2> buf_a{ a[0], sycl::range{N, M}};
+        sycl::buffer<T, 2> buf_b{ b[0], sycl::range{N, M}};
+        q.submit([&](sycl::handler &cgh) {
+        sycl::accessor acc_a{ buf_a, cgh };
+        sycl::accessor acc_b { buf_b, cgh };
+        syclexp::work_group_memory<T[N][M]> temp{ cgh };
+        cgh.single_task([=]() {
+for (int i= 0; i < N; ++i) {
+for (int j = 0; j < M; ++j) {
+                temp[i][j]= acc_a[i][j];
+                acc_a[i][j] = acc_b[i][j];
+                acc_b[i][j] = temp[i][j];
+}
+}
+        });});
+        }
+for (int i = 0; i < N; ++i) {
+for (int j = 0; j < M; ++j) {
+        assert(a[i][j] == old_b[i][j] && b[i][j] == old_a[i][j] && "Incorrect swap!");
+}
+}
+
+// Perform the swap but this time use two temporary work group memory objects.
+// One will save the value of acc_a and the other will be copy-assigned from it
+// and will be used to write the values back to acc_b.
+{
+sycl::buffer<T, 2> buf_a{ a[0], sycl::range{N, M}};
+        sycl::buffer<T, 2> buf_b{ b[0], sycl::range{N, M}};
+        q.submit([&](sycl::handler &cgh) {
+        sycl::accessor acc_a{ buf_a, cgh };
+        sycl::accessor acc_b { buf_b, cgh };
+        syclexp::work_group_memory<T[N][M]> temp{ cgh };
+	syclexp::work_group_memory<T[N][M]> temp2{ cgh };
+        cgh.single_task([=]() {
+for (int i= 0; i < N; ++i) {
+for (int j = 0; j < M; ++j) {
+                temp[i][j]= acc_a[i][j];
+                acc_a[i][j] = acc_b[i][j];
+}
+}
+syclexp::work_group_memory<T[N][M]> temp2;
+temp2 = temp;
+for (int i = 0; i < N; ++i) {
+for (int j = 0; j < M; ++j) {
+	acc_b[i][j] = temp2[i][j];
+}
+}
+        });});
+        }
+for (int i = 0; i < N; ++i) {
+for (int j = 0; j < M; ++j) {
+// Two swaps are the same as no swap
+        assert(a[i][j] == old_a[i][j] && b[i][j] == old_b[i][j] && "Incorrect swap!");
+}
+}
+
+// Same as above but construct the second temporary inside the kernel and copy-construct it from the first temporary.
+{
+sycl::buffer<T, 2> buf_a{ a[0], sycl::range{N, M}};
+        sycl::buffer<T, 2> buf_b{ b[0], sycl::range{N, M}};
+        q.submit([&](sycl::handler &cgh) {
+        sycl::accessor acc_a{ buf_a, cgh };
+        sycl::accessor acc_b { buf_b, cgh };
+        syclexp::work_group_memory<T[N][M]> temp{ cgh };
+        syclexp::work_group_memory<T[N][M]> temp2{ cgh };
+        cgh.single_task([=]() {
+for (int i= 0; i < N; ++i) {
+for (int j = 0; j < M; ++j) {
+                temp[i][j]= acc_a[i][j];
+                acc_a[i][j] = acc_b[i][j];
+}
+}
+syclexp::work_group_memory<T[N][M]> temp2{ temp };
+for (int i = 0; i < N; ++i) {
+for (int j = 0; j < M; ++j) {
+        acc_b[i][j] = temp2[i][j];
+}
+}
+        });});
+        }
+for (int i = 0; i < N; ++i) {
+for (int j = 0; j < M; ++j) {
+// Three swaps are the same as one swap
+        assert(a[i][j] == old_b[i][j] && b[i][j] == old_a[i][j] && "Incorrect swap!");
+}
+}
+
+}
+constexpr size_t N = 100;
+constexpr size_t M = 100;
 int main() {
-	int a = 25;
-	int b = 42;
-	int arr1[5] = {0, 1, 2, 3, 4};
-	int arr2[5] = {5, 6, 7, 8, 9};
-	swap_scalar(a, b);
-	swap_bounded_array_1d(arr1, arr2);
+	int intarr1[N][M];
+	int intarr2[N][M];
+	float floatarr1[N][M];
+	float floatarr2[N][M];
+	for (int i = 0; i < N; ++i) {
+		for (int j = 0; j < M; ++j) {
+			intarr1[i][j] = i + j;
+			intarr2[i][j] = i * j;
+			floatarr1[i][j] = (i + 1) / (j + 1);
+			floatarr2[i][j] = (j + 1) / (i + 1);
+}
+}
+for (int i = 0; i < N; ++i) {
+	for (int j = 0; j < M; ++j) {
+		swap_scalar(intarr1[i][j], intarr2[i][j]);
+		swap_scalar(floatarr1[i][j], floatarr2[i][j]);
+}
+swap_array_1d(intarr1[i], intarr2[i]);
+swap_array_1d(floatarr1[i], floatarr2[i]);
+}
+swap_array_2d(intarr1, intarr2);
+swap_array_2d(floatarr1, floatarr2);	
 return 0;
 }
-	
-	
-	
-	
-	
-	
-	
-	
-	
diff --git a/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp b/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp
index b7905c573dae4..f1d37d00272b4 100644
--- a/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp
@@ -1,9 +1,6 @@
-// RUN: %{build} -o %{t.out}
-// RUN: %{run} %{t.out}
+// RUN: %{build} -o %t.out
+// RUN: %{run} %t.out
 
-#include <type_traits>
-#include <cstdlib>
-#include <iostream>
 #include <sycl/detail/core.hpp>
 #include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 #include <sycl/usm.hpp>

From 8cff6033eac64a95b2e15071508d95dd5be2fcd9 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Wed, 28 Aug 2024 22:43:03 -0700
Subject: [PATCH 033/107] Fix formatting

---
 .../oneapi/experimental/work_group_memory.hpp |  26 +-
 .../swap_test_using_work_group_memory.cpp     | 566 +++++++++---------
 .../work_group_memory_sanity_test.cpp         | 230 +++----
 3 files changed, 423 insertions(+), 399 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 59c5c6f92ab85..5e10bece6a317 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -22,7 +22,7 @@ inline constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
 
 class work_group_memory_impl {
 public:
-  work_group_memory_impl() : wgm_size{ 0 }, buffer_size{ 0 } {}
+  work_group_memory_impl() : wgm_size{0}, buffer_size{0} {}
   work_group_memory_impl(const work_group_memory_impl &rhs) = default;
   work_group_memory_impl &
   operator=(const work_group_memory_impl &rhs) = default;
@@ -36,22 +36,17 @@ inline size_t getWorkGroupMemoryOwnSize(detail::work_group_memory_impl *wgm) {
   return wgm->wgm_size;
 }
 
-// The following 3 functions help us get the address of the first element of a multi-dimensional
-// array, be it bounded or unbounded. A scalar is also included. In that case, it just returns
-// the address of the scalar.
-template <typename DataT>
-auto getData(DataT& scalar) {
-	return &scalar;
-}
+// The following 3 functions help us get the address of the first element of a
+// multi-dimensional array, be it bounded or unbounded. A scalar is also
+// included. In that case, it just returns the address of the scalar.
+template <typename DataT> auto getData(DataT &scalar) { return &scalar; }
 
-template <typename DataT, size_t N>
-auto getData(DataT (&bounded_arr)[N]) {
-        return getData(bounded_arr[0]);
+template <typename DataT, size_t N> auto getData(DataT (&bounded_arr)[N]) {
+  return getData(bounded_arr[0]);
 }
 
-template<typename DataT>
-auto getData(DataT (&unbounded_arr)[]) {
-	return getData(unbounded_arr[0]);
+template <typename DataT> auto getData(DataT (&unbounded_arr)[]) {
+  return getData(unbounded_arr[0]);
 }
 
 } // namespace detail
@@ -86,7 +81,8 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   multi_ptr<value_type, access::address_space::local_space, IsDecorated>
   get_multi_ptr() const {
     return sycl::address_space_cast<access::address_space::local_space,
-                                    IsDecorated, value_type>(sycl::detail::getData(*ptr));
+                                    IsDecorated, value_type>(
+        sycl::detail::getData(*ptr));
   }
   DataT *operator&() const { return ptr; }
   operator DataT &() const { return *(this->operator&()); }
diff --git a/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp b/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
index dfb7bdae2fc50..00b284b7017ee 100644
--- a/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
@@ -1,301 +1,325 @@
 // RUN: %{build} -o %t.out
-// RUN: %{run} %t.out 
+// RUN: %{run} %t.out
 
-#include <sycl/detail/core.hpp>
-#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 #include <cassert>
 #include <cstring>
+#include <sycl/detail/core.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 
 namespace syclexp = sycl::ext::oneapi::experimental;
 
-// This test performs a swap of two scalars/arrays inside a kernel using a work_group_memory object as a temporary buffer.
-// The test is done for scalar types and bounded arrays. After the kernel finishes, it is verified on the host side 
-// that the swap worked.
- 
-// One important note is that for unbounded arrays, the feature is unstable. Specifically, the code may or may not compile
-// when kernels reference work group memory objects that have been constructed with the unbounded array type. This is due to a 
-// limitation of SPIRV where it does not allow arrays of length zero. For example, an unbounded array may be translated to an array of length zero in 
-// LLVM IR and during the LLVM IR -> SPIRV translation phase, the translator rejects all arrays of length zero because they are invalid constructs in SPIRV.
-// As a result of this, unbounded arrays do not appear in this test. They do appear in the sanity test though in this directory because there the unbounded arrays are used with concrete subscript indices which seems to work, for now at least.
+// This test performs a swap of two scalars/arrays inside a kernel using a
+// work_group_memory object as a temporary buffer. The test is done for scalar
+// types and bounded arrays. After the kernel finishes, it is verified on the
+// host side that the swap worked.
 
-template< typename T>
-void swap_scalar(T& a, T& b) {
-	sycl::queue q;
-	const T old_a = a;
-	const T old_b = b;
-	{
-	sycl::buffer<T, 1> buf_a{ &a, 1};
-	sycl::buffer<T, 1> buf_b{ &b, 1};
-	q.submit([&](sycl::handler &cgh) {
-	sycl::accessor acc_a{ buf_a, cgh };
-	sycl::accessor acc_b { buf_b, cgh };
-	syclexp::work_group_memory<T> temp{ cgh };
-	cgh.single_task([=]() {
-		temp = acc_a[0];
-		acc_a[0] = acc_b[0];
-		acc_b[0] = temp;
-	});});
-	}
-	assert(a == old_b && b == old_a	&& "Incorrect swap!");
-	// swap again but this time using two temporaries. The first temporary will be used to save the value of a
-	// and the second temporay will be default-constructed and then copy-assigned from the first temporary
- 	// to be then used to write that value to b.
-	{
-        sycl::buffer<T, 1> buf_a{ &a, 1};
-        sycl::buffer<T, 1> buf_b{ &b, 1};
-        q.submit([&](sycl::handler &cgh) {
-        sycl::accessor acc_a{ buf_a, cgh };
-        sycl::accessor acc_b { buf_b, cgh };
-        syclexp::work_group_memory<T> temp{ cgh };
-	syclexp::work_group_memory<T> temp2;
-        cgh.single_task([=]() {
-		temp2 = temp; // temp and temp2 have the same underlying data
-                temp = acc_a[0];
-                acc_a[0] = acc_b[0];
-                acc_b[0] = temp2; // safe to use temp2
-        });});
-        }
-	// Two swaps same as no swaps
-	assert(a == old_a && b == old_b && "Incorrect swap!");
-	// Initialize a second temporary and instead of assigning the first temporary to it, assign only the value of the data
-	// of the first temporary so that unlike above, the two temporaries will not be aliasing the same memory location but they
-	// will have equal values.
-	{
-        sycl::buffer<T, 1> buf_a{ &a, 1};
-        sycl::buffer<T, 1> buf_b{ &b, 1};
-        q.submit([&](sycl::handler &cgh) {
-        sycl::accessor acc_a{ buf_a, cgh };
-        sycl::accessor acc_b { buf_b, cgh };
-        syclexp::work_group_memory<T> temp{ cgh };
-	syclexp::work_group_memory<T> temp2{ cgh };
-        cgh.single_task([=]() {
-                temp = acc_a[0];
-                acc_a[0] = acc_b[0];
-		temp2 = *(temp.get_multi_ptr()); // temp2 now has the same value as temp but not the same memory location
-                acc_b[0] = temp2;
-        });});
-        }
-	// Three swaps same as one swap
-	assert(a == old_b && b == old_a && "Incorrect swap!");
-	// Same as above but instead of using multi_ptr, use address-of operator.
-	{
-        sycl::buffer<T, 1> buf_a{ &a, 1};
-        sycl::buffer<T, 1> buf_b{ &b, 1};
-        q.submit([&](sycl::handler &cgh) {
-        sycl::accessor acc_a{ buf_a, cgh };
-        sycl::accessor acc_b { buf_b, cgh };
-        syclexp::work_group_memory<T> temp{ cgh };
-syclexp::work_group_memory<T> temp2{ cgh };
-        cgh.single_task([=]() {
-                temp = acc_a[0];
-                acc_a[0] = acc_b[0];
-		temp2 = *(&temp);
-                acc_b[0] = temp2;
-        });});
-        }
-	// Four swaps same as no swap
-	assert(a == old_a && b == old_b && "Incorrect swap!");
-}
+// One important note is that for unbounded arrays, the feature is unstable.
+// Specifically, the code may or may not compile when kernels reference work
+// group memory objects that have been constructed with the unbounded array
+// type. This is due to a limitation of SPIRV where it does not allow arrays of
+// length zero. For example, an unbounded array may be translated to an array of
+// length zero in LLVM IR and during the LLVM IR -> SPIRV translation phase, the
+// translator rejects all arrays of length zero because they are invalid
+// constructs in SPIRV. As a result of this, unbounded arrays do not appear in
+// this test. They do appear in the sanity test though in this directory because
+// there the unbounded arrays are used with concrete subscript indices which
+// seems to work, for now at least.
 
-template<typename T, size_t N>
-void swap_array_1d(T (&a)[N], T (&b)[N]) {
-sycl::queue q;
-        T old_a[N];
-  	std::memcpy(old_a, a, sizeof(a));	
-        T old_b[N];
-	std::memcpy(old_b, b, sizeof(b));
-        { 
-        sycl::buffer<T, 1> buf_a{ a, N};
-        sycl::buffer<T, 1> buf_b{ b, N};
-        q.submit([&](sycl::handler &cgh) {
-        sycl::accessor acc_a{ buf_a, cgh };
-        sycl::accessor acc_b { buf_b, cgh };
-        syclexp::work_group_memory<T[N]> temp{ cgh };
-        cgh.single_task([=]() {
-for (int i= 0; i < N; ++i) {
-                temp[i] = acc_a[i];
-                acc_a[i] = acc_b[i];
-                acc_b[i] = temp[i];
-}
-        });});
-        }
-for (int i = 0; i < N; ++i) {
-        assert(a[i] == old_b[i] && b[i] == old_a[i] && "Incorrect swap!");
-}
+template <typename T> void swap_scalar(T &a, T &b) {
+  sycl::queue q;
+  const T old_a = a;
+  const T old_b = b;
+  {
+    sycl::buffer<T, 1> buf_a{&a, 1};
+    sycl::buffer<T, 1> buf_b{&b, 1};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T> temp{cgh};
+      cgh.single_task([=]() {
+        temp = acc_a[0];
+        acc_a[0] = acc_b[0];
+        acc_b[0] = temp;
+      });
+    });
+  }
+  assert(a == old_b && b == old_a && "Incorrect swap!");
 
-// Instead of working with the temporary work group memory object, we retrieve its corresponding
-// multi-pointer and work with it instead.
-{
-        sycl::buffer<T, 1> buf_a{ a, N};
-        sycl::buffer<T, 1> buf_b{ b, N};
-        q.submit([&](sycl::handler &cgh) {
-        sycl::accessor acc_a{ buf_a, cgh };
-        sycl::accessor acc_b { buf_b, cgh };
-        syclexp::work_group_memory<T[N]> temp{ cgh };
-        cgh.single_task([=]() {
-		auto ptr = temp.get_multi_ptr();
-for (int i= 0; i < N; ++i) {
-                ptr[i] = acc_a[i];
-                acc_a[i] = acc_b[i];
-                acc_b[i] = ptr[i];
+  // swap again but this time using two temporaries. The first temporary will be
+  // used to save the value of a and the second temporay will be
+  // default-constructed and then copy-assigned from the first temporary to be
+  // then used to write that value to b.
+  {
+    sycl::buffer<T, 1> buf_a{&a, 1};
+    sycl::buffer<T, 1> buf_b{&b, 1};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T> temp{cgh};
+      syclexp::work_group_memory<T> temp2;
+      cgh.single_task([=]() {
+        temp2 = temp; // temp and temp2 have the same underlying data
+        temp = acc_a[0];
+        acc_a[0] = acc_b[0];
+        acc_b[0] = temp2; // safe to use temp2
+      });
+    });
+  }
+  // Two swaps same as no swaps
+  assert(a == old_a && b == old_b && "Incorrect swap!");
+
+  // Initialize a second temporary and instead of assigning the first temporary
+  // to it, assign only the value of the data of the first temporary so that
+  // unlike above, the two temporaries will not be aliasing the same memory
+  // location but they will have equal values.
+  {
+    sycl::buffer<T, 1> buf_a{&a, 1};
+    sycl::buffer<T, 1> buf_b{&b, 1};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T> temp{cgh};
+      syclexp::work_group_memory<T> temp2{cgh};
+      cgh.single_task([=]() {
+        temp = acc_a[0];
+        acc_a[0] = acc_b[0];
+        temp2 = *(temp.get_multi_ptr()); // temp2 now has the same value as temp
+                                         // but not the same memory location
+        acc_b[0] = temp2;
+      });
+    });
+  }
+  // Three swaps same as one swap
+  assert(a == old_b && b == old_a && "Incorrect swap!");
+
+  // Same as above but instead of using multi_ptr, use address-of operator.
+  {
+    sycl::buffer<T, 1> buf_a{&a, 1};
+    sycl::buffer<T, 1> buf_b{&b, 1};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T> temp{cgh};
+      syclexp::work_group_memory<T> temp2{cgh};
+      cgh.single_task([=]() {
+        temp = acc_a[0];
+        acc_a[0] = acc_b[0];
+        temp2 = *(&temp);
+        acc_b[0] = temp2;
+      });
+    });
+  }
+  // Four swaps same as no swap
+  assert(a == old_a && b == old_b && "Incorrect swap!");
 }
-        });});
+
+template <typename T, size_t N> void swap_array_1d(T (&a)[N], T (&b)[N]) {
+  sycl::queue q;
+  T old_a[N];
+  std::memcpy(old_a, a, sizeof(a));
+  T old_b[N];
+  std::memcpy(old_b, b, sizeof(b));
+  {
+    sycl::buffer<T, 1> buf_a{a, N};
+    sycl::buffer<T, 1> buf_b{b, N};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T[N]> temp{cgh};
+      cgh.single_task([=]() {
+        for (int i = 0; i < N; ++i) {
+          temp[i] = acc_a[i];
+          acc_a[i] = acc_b[i];
+          acc_b[i] = temp[i];
         }
-// Two swaps same as ono swap
-for (int i = 0; i < N; ++i) {
-assert(a[i] == old_a[i] && b[i] == old_b[i] && "Incorrect swap!");
-}
+      });
+    });
+  }
+  for (int i = 0; i < N; ++i) {
+    assert(a[i] == old_b[i] && b[i] == old_a[i] && "Incorrect swap!");
+  }
 
-// Same as above but use a pointer returned by the address-of operator instead.
-{
-        sycl::buffer<T, 1> buf_a{ a, N};
-        sycl::buffer<T, 1> buf_b{ b, N};
-        q.submit([&](sycl::handler &cgh) {
-        sycl::accessor acc_a{ buf_a, cgh };
-        sycl::accessor acc_b { buf_b, cgh };
-        syclexp::work_group_memory<T[N]> temp{ cgh };
-        cgh.single_task([=]() {
-auto ptr = &temp;
-for (int i= 0; i < N; ++i) {
-                (*ptr)[i] = acc_a[i];
-                acc_a[i] = acc_b[i];
-                acc_b[i] = (*ptr)[i];
-}
-        });});
+  // Instead of working with the temporary work group memory object, we retrieve
+  // its corresponding multi-pointer and work with it instead.
+  {
+    sycl::buffer<T, 1> buf_a{a, N};
+    sycl::buffer<T, 1> buf_b{b, N};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T[N]> temp{cgh};
+      cgh.single_task([=]() {
+        auto ptr = temp.get_multi_ptr();
+        for (int i = 0; i < N; ++i) {
+          ptr[i] = acc_a[i];
+          acc_a[i] = acc_b[i];
+          acc_b[i] = ptr[i];
         }
-// Three swaps same as one swap
-for (int i = 0; i < N; ++i) {
-	assert(a[i] == old_b[i] && b[i] == old_a[i] && "Incorrect swap!");
+      });
+    });
+  }
+  // Two swaps same as no swap
+  for (int i = 0; i < N; ++i) {
+    assert(a[i] == old_a[i] && b[i] == old_b[i] && "Incorrect swap!");
+  }
 
+  // Same as above but use a pointer returned by the address-of operator
+  // instead.
+  {
+    sycl::buffer<T, 1> buf_a{a, N};
+    sycl::buffer<T, 1> buf_b{b, N};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T[N]> temp{cgh};
+      cgh.single_task([=]() {
+        auto ptr = &temp;
+        for (int i = 0; i < N; ++i) {
+          (*ptr)[i] = acc_a[i];
+          acc_a[i] = acc_b[i];
+          acc_b[i] = (*ptr)[i];
+        }
+      });
+    });
+  }
+  // Three swaps same as one swap
+  for (int i = 0; i < N; ++i) {
+    assert(a[i] == old_b[i] && b[i] == old_a[i] && "Incorrect swap!");
+  }
 }
-}
-
 
-template<typename T, size_t N, size_t M>
+template <typename T, size_t N, size_t M>
 void swap_array_2d(T (&a)[N][M], T (&b)[N][M]) {
-sycl::queue q;
-        T old_a[N][M];
-for (int i = 0; i < N; ++i) {
-        std::memcpy(old_a[i], a[i], sizeof(a[0]));
-}
-        T old_b[N][M];
-for (int i = 0; i < N; ++i) {
+  sycl::queue q;
+  T old_a[N][M];
+  for (int i = 0; i < N; ++i) {
+    std::memcpy(old_a[i], a[i], sizeof(a[0]));
+  }
+  T old_b[N][M];
+  for (int i = 0; i < N; ++i) {
 
-        std::memcpy(old_b[i], b[i], sizeof(b[0]));
-}
-        {
-        sycl::buffer<T, 2> buf_a{ a[0], sycl::range{N, M}};
-        sycl::buffer<T, 2> buf_b{ b[0], sycl::range{N, M}};
-        q.submit([&](sycl::handler &cgh) {
-        sycl::accessor acc_a{ buf_a, cgh };
-        sycl::accessor acc_b { buf_b, cgh };
-        syclexp::work_group_memory<T[N][M]> temp{ cgh };
-        cgh.single_task([=]() {
-for (int i= 0; i < N; ++i) {
-for (int j = 0; j < M; ++j) {
-                temp[i][j]= acc_a[i][j];
-                acc_a[i][j] = acc_b[i][j];
-                acc_b[i][j] = temp[i][j];
-}
-}
-        });});
+    std::memcpy(old_b[i], b[i], sizeof(b[0]));
+  }
+  {
+    sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, M}};
+    sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, M}};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T[N][M]> temp{cgh};
+      cgh.single_task([=]() {
+        for (int i = 0; i < N; ++i) {
+          for (int j = 0; j < M; ++j) {
+            temp[i][j] = acc_a[i][j];
+            acc_a[i][j] = acc_b[i][j];
+            acc_b[i][j] = temp[i][j];
+          }
         }
-for (int i = 0; i < N; ++i) {
-for (int j = 0; j < M; ++j) {
-        assert(a[i][j] == old_b[i][j] && b[i][j] == old_a[i][j] && "Incorrect swap!");
-}
-}
+      });
+    });
+  }
+  for (int i = 0; i < N; ++i) {
+    for (int j = 0; j < M; ++j) {
+      assert(a[i][j] == old_b[i][j] && b[i][j] == old_a[i][j] &&
+             "Incorrect swap!");
+    }
+  }
 
-// Perform the swap but this time use two temporary work group memory objects.
-// One will save the value of acc_a and the other will be copy-assigned from it
-// and will be used to write the values back to acc_b.
-{
-sycl::buffer<T, 2> buf_a{ a[0], sycl::range{N, M}};
-        sycl::buffer<T, 2> buf_b{ b[0], sycl::range{N, M}};
-        q.submit([&](sycl::handler &cgh) {
-        sycl::accessor acc_a{ buf_a, cgh };
-        sycl::accessor acc_b { buf_b, cgh };
-        syclexp::work_group_memory<T[N][M]> temp{ cgh };
-	syclexp::work_group_memory<T[N][M]> temp2{ cgh };
-        cgh.single_task([=]() {
-for (int i= 0; i < N; ++i) {
-for (int j = 0; j < M; ++j) {
-                temp[i][j]= acc_a[i][j];
-                acc_a[i][j] = acc_b[i][j];
-}
-}
-syclexp::work_group_memory<T[N][M]> temp2;
-temp2 = temp;
-for (int i = 0; i < N; ++i) {
-for (int j = 0; j < M; ++j) {
-	acc_b[i][j] = temp2[i][j];
-}
-}
-        });});
+  // Perform the swap but this time use two temporary work group memory objects.
+  // One will save the value of acc_a and the other will be copy-assigned from
+  // it and will be used to write the values back to acc_b.
+  {
+    sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, M}};
+    sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, M}};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T[N][M]> temp{cgh};
+      syclexp::work_group_memory<T[N][M]> temp2{cgh};
+      cgh.single_task([=]() {
+        for (int i = 0; i < N; ++i) {
+          for (int j = 0; j < M; ++j) {
+            temp[i][j] = acc_a[i][j];
+            acc_a[i][j] = acc_b[i][j];
+          }
         }
-for (int i = 0; i < N; ++i) {
-for (int j = 0; j < M; ++j) {
-// Two swaps are the same as no swap
-        assert(a[i][j] == old_a[i][j] && b[i][j] == old_b[i][j] && "Incorrect swap!");
-}
-}
+        syclexp::work_group_memory<T[N][M]> temp2;
+        temp2 = temp;
+        for (int i = 0; i < N; ++i) {
+          for (int j = 0; j < M; ++j) {
+            acc_b[i][j] = temp2[i][j];
+          }
+        }
+      });
+    });
+  }
+  for (int i = 0; i < N; ++i) {
+    for (int j = 0; j < M; ++j) {
+      // Two swaps are the same as no swap
+      assert(a[i][j] == old_a[i][j] && b[i][j] == old_b[i][j] &&
+             "Incorrect swap!");
+    }
+  }
 
-// Same as above but construct the second temporary inside the kernel and copy-construct it from the first temporary.
-{
-sycl::buffer<T, 2> buf_a{ a[0], sycl::range{N, M}};
-        sycl::buffer<T, 2> buf_b{ b[0], sycl::range{N, M}};
-        q.submit([&](sycl::handler &cgh) {
-        sycl::accessor acc_a{ buf_a, cgh };
-        sycl::accessor acc_b { buf_b, cgh };
-        syclexp::work_group_memory<T[N][M]> temp{ cgh };
-        syclexp::work_group_memory<T[N][M]> temp2{ cgh };
-        cgh.single_task([=]() {
-for (int i= 0; i < N; ++i) {
-for (int j = 0; j < M; ++j) {
-                temp[i][j]= acc_a[i][j];
-                acc_a[i][j] = acc_b[i][j];
-}
-}
-syclexp::work_group_memory<T[N][M]> temp2{ temp };
-for (int i = 0; i < N; ++i) {
-for (int j = 0; j < M; ++j) {
-        acc_b[i][j] = temp2[i][j];
-}
-}
-        });});
+  // Same as above but construct the second temporary inside the kernel and
+  // copy-construct it from the first temporary.
+  {
+    sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, M}};
+    sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, M}};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T[N][M]> temp{cgh};
+      syclexp::work_group_memory<T[N][M]> temp2{cgh};
+      cgh.single_task([=]() {
+        for (int i = 0; i < N; ++i) {
+          for (int j = 0; j < M; ++j) {
+            temp[i][j] = acc_a[i][j];
+            acc_a[i][j] = acc_b[i][j];
+          }
         }
-for (int i = 0; i < N; ++i) {
-for (int j = 0; j < M; ++j) {
-// Three swaps are the same as one swap
-        assert(a[i][j] == old_b[i][j] && b[i][j] == old_a[i][j] && "Incorrect swap!");
-}
+        syclexp::work_group_memory<T[N][M]> temp2{temp};
+        for (int i = 0; i < N; ++i) {
+          for (int j = 0; j < M; ++j) {
+            acc_b[i][j] = temp2[i][j];
+          }
+        }
+      });
+    });
+  }
+  for (int i = 0; i < N; ++i) {
+    for (int j = 0; j < M; ++j) {
+      // Three swaps are the same as one swap
+      assert(a[i][j] == old_b[i][j] && b[i][j] == old_a[i][j] &&
+             "Incorrect swap!");
+    }
+  }
 }
 
-}
 constexpr size_t N = 100;
 constexpr size_t M = 100;
 int main() {
-	int intarr1[N][M];
-	int intarr2[N][M];
-	float floatarr1[N][M];
-	float floatarr2[N][M];
-	for (int i = 0; i < N; ++i) {
-		for (int j = 0; j < M; ++j) {
-			intarr1[i][j] = i + j;
-			intarr2[i][j] = i * j;
-			floatarr1[i][j] = (i + 1) / (j + 1);
-			floatarr2[i][j] = (j + 1) / (i + 1);
-}
-}
-for (int i = 0; i < N; ++i) {
-	for (int j = 0; j < M; ++j) {
-		swap_scalar(intarr1[i][j], intarr2[i][j]);
-		swap_scalar(floatarr1[i][j], floatarr2[i][j]);
-}
-swap_array_1d(intarr1[i], intarr2[i]);
-swap_array_1d(floatarr1[i], floatarr2[i]);
-}
-swap_array_2d(intarr1, intarr2);
-swap_array_2d(floatarr1, floatarr2);	
-return 0;
+  int intarr1[N][M];
+  int intarr2[N][M];
+  float floatarr1[N][M];
+  float floatarr2[N][M];
+  for (int i = 0; i < N; ++i) {
+    for (int j = 0; j < M; ++j) {
+      intarr1[i][j] = i + j;
+      intarr2[i][j] = i * j;
+      floatarr1[i][j] = (i + 1) / (j + 1);
+      floatarr2[i][j] = (j + 1) / (i + 1);
+    }
+  }
+  for (int i = 0; i < N; ++i) {
+    for (int j = 0; j < M; ++j) {
+      swap_scalar(intarr1[i][j], intarr2[i][j]);
+      swap_scalar(floatarr1[i][j], floatarr2[i][j]);
+    }
+    swap_array_1d(intarr1[i], intarr2[i]);
+    swap_array_1d(floatarr1[i], floatarr2[i]);
+  }
+  swap_array_2d(intarr1, intarr2);
+  swap_array_2d(floatarr1, floatarr2);
+  return 0;
 }
diff --git a/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp b/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp
index f1d37d00272b4..7e53e61c54686 100644
--- a/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp
@@ -5,7 +5,8 @@
 #include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 #include <sycl/usm.hpp>
 
-// Sanity test that checks to see if idiomatic code involving work_group_memory objects compiles and runs with no errors.
+// Sanity test that checks to see if idiomatic code involving work_group_memory
+// objects compiles and runs with no errors.
 
 namespace syclex = sycl::ext::oneapi::experimental;
 sycl::queue global_q;
@@ -18,9 +19,7 @@ struct point {
   int y;
 };
 
-void simple_inc(const syclex::work_group_memory<int>& mem) {
-  mem++;
-}
+void simple_inc(const syclex::work_group_memory<int> &mem) { mem++; }
 
 void fancy_inc(syclex::work_group_memory<int> mem) {
   syclex::work_group_memory<int> t = mem;
@@ -35,129 +34,134 @@ void test_breadth() {
   int *res = sycl::malloc_host<int>(16, q);
 
   q.submit([&](sycl::handler &cgh) {
-    syclex::work_group_memory<int> mem1{cgh};
-    syclex::work_group_memory<int[10]> mem2{cgh};
-    syclex::work_group_memory<int[10]> mem3{cgh};
-    syclex::work_group_memory<int[]> mem4{5, cgh};
-    syclex::work_group_memory<int[][10]> mem5{2, cgh};
-    syclex::work_group_memory<int[][10]> mem6{2, cgh};
-    syclex::work_group_memory<point> mem7{cgh};
-    syclex::work_group_memory<point[][10]> mem8{2, cgh};
-
-    cgh.single_task([=] {
-      // Operations on scalar
-      ++mem1;
-      mem1++;
-      mem1 += 1;
-      mem1 = mem1 + 1;
-      int *p1 = &mem1; (*p1)++;
-      simple_inc(mem1);
-      fancy_inc(mem1);
-      res[0] = *(mem1.get_multi_ptr());
-      res[1] = mem1;
-
-      // Operations on bounded array
-      mem2[4] = mem2[4] + 1;
-      int (*p2)[10] = &mem2; (*p2)[4]++;
-      res[2] = mem2.get_multi_ptr()[4];
-      res[3] = mem2[4];
-
-      mem3[4] = mem3[4] + 1;
-      int (*p3)[10] = &mem3; (*p3)[4]++;
-      res[4] = mem3.get_multi_ptr()[4];
-      res[5] = mem3[4];
-
-      // Operations on unbounded array
-      mem4[4] = mem4[4] + 1;
-      int (*p4)[] = &mem4; (*p4)[4]++;
-      res[6] = mem4.get_multi_ptr()[4];
-      res[7] = mem4[4];
-
-      // Operations on unbounded multi-dimensional array
-      mem5[1][5] = mem5[1][5] + 1;
-      mem5[1][7] = mem5[1][7] + 1;
-      res[8] = mem5.get_multi_ptr()[10 + 5];
-      res[9] = mem5[1][7];
-
-      mem6[1][5] = mem6[1][5] + 1;
-      mem6[1][7] = mem6[1][7] + 1;
-      res[10] = mem6.get_multi_ptr()[10 + 5];
-      res[11] = mem6[1][7];
-
-      // Operations on scalar struct
-      (&mem7)->x++;
-      (&mem7)->y += 1;
-      point pnt = mem7;
-      pnt.x++;
-      pnt.y++;
-      mem7 = pnt;
-      res[12] = (&mem7)->x;
-      res[13] = (&mem7)->y;
-
-      // Operations on unbounded multi-dimensional array of struct
-      mem8[1][5].x++;
-      mem8[1][5].y += 1;
-      res[14] = mem8.get_multi_ptr()[10 + 5].x;
-      res[15] = mem8[1][5].y;
-    });
-  }).wait();
+     syclex::work_group_memory<int> mem1{cgh};
+     syclex::work_group_memory<int[10]> mem2{cgh};
+     syclex::work_group_memory<int[10]> mem3{cgh};
+     syclex::work_group_memory<int[]> mem4{5, cgh};
+     syclex::work_group_memory<int[][10]> mem5{2, cgh};
+     syclex::work_group_memory<int[][10]> mem6{2, cgh};
+     syclex::work_group_memory<point> mem7{cgh};
+     syclex::work_group_memory<point[][10]> mem8{2, cgh};
+
+     cgh.single_task([=] {
+       // Operations on scalar
+       ++mem1;
+       mem1++;
+       mem1 += 1;
+       mem1 = mem1 + 1;
+       int *p1 = &mem1;
+       (*p1)++;
+       simple_inc(mem1);
+       fancy_inc(mem1);
+       res[0] = *(mem1.get_multi_ptr());
+       res[1] = mem1;
+
+       // Operations on bounded array
+       mem2[4] = mem2[4] + 1;
+       int(*p2)[10] = &mem2;
+       (*p2)[4]++;
+       res[2] = mem2.get_multi_ptr()[4];
+       res[3] = mem2[4];
+
+       mem3[4] = mem3[4] + 1;
+       int(*p3)[10] = &mem3;
+       (*p3)[4]++;
+       res[4] = mem3.get_multi_ptr()[4];
+       res[5] = mem3[4];
+
+       // Operations on unbounded array
+       mem4[4] = mem4[4] + 1;
+       int(*p4)[] = &mem4;
+       (*p4)[4]++;
+       res[6] = mem4.get_multi_ptr()[4];
+       res[7] = mem4[4];
+
+       // Operations on unbounded multi-dimensional array
+       mem5[1][5] = mem5[1][5] + 1;
+       mem5[1][7] = mem5[1][7] + 1;
+       res[8] = mem5.get_multi_ptr()[10 + 5];
+       res[9] = mem5[1][7];
+
+       mem6[1][5] = mem6[1][5] + 1;
+       mem6[1][7] = mem6[1][7] + 1;
+       res[10] = mem6.get_multi_ptr()[10 + 5];
+       res[11] = mem6[1][7];
+
+       // Operations on scalar struct
+       (&mem7)->x++;
+       (&mem7)->y += 1;
+       point pnt = mem7;
+       pnt.x++;
+       pnt.y++;
+       mem7 = pnt;
+       res[12] = (&mem7)->x;
+       res[13] = (&mem7)->y;
+
+       // Operations on unbounded multi-dimensional array of struct
+       mem8[1][5].x++;
+       mem8[1][5].y += 1;
+       res[14] = mem8.get_multi_ptr()[10 + 5].x;
+       res[15] = mem8[1][5].y;
+     });
+   }).wait();
 }
 
 void test_basic() {
   sycl::queue q;
 
   q.submit([&](sycl::handler &cgh) {
-    // Allocate one element for each work-item in the work-group.
-    syclex::work_group_memory<int[WGSIZE]> mem{cgh};
+     // Allocate one element for each work-item in the work-group.
+     syclex::work_group_memory<int[WGSIZE]> mem{cgh};
 
-    sycl::nd_range ndr{{SIZE}, {WGSIZE}};
-    cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
-      size_t id = it.get_local_linear_id();
+     sycl::nd_range ndr{{SIZE}, {WGSIZE}};
+     cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
+       size_t id = it.get_local_linear_id();
 
-      // Each work-item has its own dedicated element of the array.
-      mem[id] = 0;
-    });
-  }).wait();
+       // Each work-item has its own dedicated element of the array.
+       mem[id] = 0;
+     });
+   }).wait();
 }
 
 void test_operations() {
   sycl::queue q;
 
   q.submit([&](sycl::handler &cgh) {
-    syclex::work_group_memory<int>       mem1{cgh};    // scalar
-    syclex::work_group_memory<int[10]>   mem2{cgh};    // bounded array
-    syclex::work_group_memory<int[]>     mem3{5, cgh}; // unbounded array
-    syclex::work_group_memory<int[][10]> mem4{2, cgh}; // multi-dimensional array
-    syclex::work_group_memory<point[10]> mem5{cgh};    // array of struct
-
-    sycl::nd_range ndr{{SIZE}, {WGSIZE}};
-    cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
-      if (it.get_group().leader()) {
-        // A "work_group_memory" templated on a scalar type acts much like the
-        // enclosed scalar type.
-        ++mem1;
-        mem1++;
-        mem1 += 1;
-        mem1 = mem1 + 1;
-        int *p1 = &mem1;
-
-        // A "work_group_memory" templated on an array type (either bounded or
-        // unbounded) acts like an array.
-        ++mem2[4];
-        mem2[4]++;
-        mem2[4] = mem2[4] + 1;
-        int *p2 = &mem2[4];
-
-        // A multi-dimensional array works as expected.
-        mem4[1][5] = mem4[1][5] + 1;
-        mem4[1][7] = mem4[1][7] + 1;
-
-        // An array of structs works as expected too.
-        mem5[1].x++;
-        mem5[1].y = mem5[1].y + 1;
-      }
-    });
-  }).wait();
+     syclex::work_group_memory<int> mem1{cgh};      // scalar
+     syclex::work_group_memory<int[10]> mem2{cgh};  // bounded array
+     syclex::work_group_memory<int[]> mem3{5, cgh}; // unbounded array
+     syclex::work_group_memory<int[][10]> mem4{2,
+                                               cgh}; // multi-dimensional array
+     syclex::work_group_memory<point[10]> mem5{cgh}; // array of struct
+
+     sycl::nd_range ndr{{SIZE}, {WGSIZE}};
+     cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
+       if (it.get_group().leader()) {
+         // A "work_group_memory" templated on a scalar type acts much like the
+         // enclosed scalar type.
+         ++mem1;
+         mem1++;
+         mem1 += 1;
+         mem1 = mem1 + 1;
+         int *p1 = &mem1;
+
+         // A "work_group_memory" templated on an array type (either bounded or
+         // unbounded) acts like an array.
+         ++mem2[4];
+         mem2[4]++;
+         mem2[4] = mem2[4] + 1;
+         int *p2 = &mem2[4];
+
+         // A multi-dimensional array works as expected.
+         mem4[1][5] = mem4[1][5] + 1;
+         mem4[1][7] = mem4[1][7] + 1;
+
+         // An array of structs works as expected too.
+         mem5[1].x++;
+         mem5[1].y = mem5[1].y + 1;
+       }
+     });
+   }).wait();
 }
 
 int main() {

From 3228aebf83a8de26602df880764a6d59b132b8c3 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 27 Sep 2024 18:32:09 +0200
Subject: [PATCH 034/107] Revamp tests for work group memory extension

---
 .../oneapi/experimental/work_group_memory.hpp |  27 +--
 sycl/include/sycl/handler.hpp                 |  15 +-
 .../WorkGroupMemory/UR_argument_test.cpp      |  20 ++
 .../swap_test_using_work_group_memory.cpp     | 220 +++++++++---------
 .../WorkGroupMemory/unbounded_array_test.cpp  |  23 ++
 .../work_group_memory_invalid_usage_test.cpp  |  38 +++
 6 files changed, 213 insertions(+), 130 deletions(-)
 create mode 100644 sycl/test-e2e/WorkGroupMemory/UR_argument_test.cpp
 create mode 100644 sycl/test-e2e/WorkGroupMemory/unbounded_array_test.cpp
 create mode 100644 sycl/test-e2e/WorkGroupMemory/work_group_memory_invalid_usage_test.cpp

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 5e10bece6a317..8644806ea9572 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -35,20 +35,6 @@ class work_group_memory_impl {
 inline size_t getWorkGroupMemoryOwnSize(detail::work_group_memory_impl *wgm) {
   return wgm->wgm_size;
 }
-
-// The following 3 functions help us get the address of the first element of a
-// multi-dimensional array, be it bounded or unbounded. A scalar is also
-// included. In that case, it just returns the address of the scalar.
-template <typename DataT> auto getData(DataT &scalar) { return &scalar; }
-
-template <typename DataT, size_t N> auto getData(DataT (&bounded_arr)[N]) {
-  return getData(bounded_arr[0]);
-}
-
-template <typename DataT> auto getData(DataT (&unbounded_arr)[]) {
-  return getData(unbounded_arr[0]);
-}
-
 } // namespace detail
 
 namespace ext::oneapi::experimental {
@@ -60,7 +46,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
 
 private:
   using decoratedPtr = typename sycl::detail::DecoratedType<
-      DataT, access::address_space::local_space>::type *;
+      value_type, access::address_space::local_space>::type *;
 
 public:
   work_group_memory() = default;
@@ -68,12 +54,12 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   work_group_memory &operator=(const work_group_memory &rhs) = default;
   template <typename T = DataT,
             typename = std::enable_if_t<!sycl::detail::is_unbounded_array_v<T>>>
-  work_group_memory(handler &)
+  work_group_memory(handler &cgh)
       : sycl::detail::work_group_memory_impl(sizeof(work_group_memory),
                                              sizeof(DataT)) {}
   template <typename T = DataT,
             typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
-  work_group_memory(size_t num, handler &)
+  work_group_memory(size_t num, handler &cgh)
       : sycl::detail::work_group_memory_impl(
             sizeof(work_group_memory),
             num * sizeof(std::remove_extent_t<DataT>)) {}
@@ -81,11 +67,10 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   multi_ptr<value_type, access::address_space::local_space, IsDecorated>
   get_multi_ptr() const {
     return sycl::address_space_cast<access::address_space::local_space,
-                                    IsDecorated, value_type>(
-        sycl::detail::getData(*ptr));
+                                    IsDecorated, value_type>(ptr);
   }
-  DataT *operator&() const { return ptr; }
-  operator DataT &() const { return *(this->operator&()); }
+  DataT *operator&() const { return reinterpret_cast<DataT *>(ptr); }
+  operator DataT &() const { return *reinterpret_cast<DataT *>(ptr); }
   template <typename T = DataT,
             typename = std::enable_if_t<!std::is_array_v<T>>>
   const work_group_memory &operator=(const DataT &value) const {
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 46a134231686a..987e4ac6cea3a 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -539,8 +539,10 @@ class __SYCL_EXPORT handler {
   /// According to section 4.7.6.11. of the SYCL specification, a local accessor
   /// must not be used in a SYCL kernel function that is invoked via single_task
   /// or via the simple form of parallel_for that takes a range parameter.
+  /// The same restriction is in place for work group memory objects. Refer to
+  /// its spec for more details.
   template <typename KernelName, typename KernelType>
-  void throwOnLocalAccessorMisuse() const {
+  void throwOnKernelParameterMisuse() const {
     using NameT =
         typename detail::get_kernel_name_t<KernelName, KernelType>::name;
     for (unsigned I = 0; I < detail::getKernelNumParams<NameT>(); ++I) {
@@ -556,6 +558,13 @@ class __SYCL_EXPORT handler {
             "A local accessor must not be used in a SYCL kernel function "
             "that is invoked via single_task or via the simple form of "
             "parallel_for that takes a range parameter.");
+      if (Kind == detail::kernel_param_kind_t::kind_work_group_memory)
+        throw sycl::exception(
+            make_error_code(errc::kernel_argument),
+            "A work group memory object must not be used in a SYCL kernel "
+            "function that is invoked via single_task or via the simple form "
+            "of "
+            "parallel_for that takes a range parameter.");
     }
   }
 
@@ -1331,7 +1340,7 @@ class __SYCL_EXPORT handler {
   void parallel_for_lambda_impl(range<Dims> UserRange, PropertiesT Props,
                                 KernelType KernelFunc) {
     throwIfActionIsCreated();
-    throwOnLocalAccessorMisuse<KernelName, KernelType>();
+    throwOnKernelParameterMisuse<KernelName, KernelType>();
     if (!range_size_fits_in_size_t(UserRange))
       throw sycl::exception(make_error_code(errc::runtime),
                             "The total number of work-items in "
@@ -1856,7 +1865,7 @@ class __SYCL_EXPORT handler {
                                _KERNELFUNCPARAM(KernelFunc)) {
     (void)Props;
     throwIfActionIsCreated();
-    throwOnLocalAccessorMisuse<KernelName, KernelType>();
+    throwOnKernelParameterMisuse<KernelName, KernelType>();
     // TODO: Properties may change the kernel function, so in order to avoid
     //       conflicts they should be included in the name.
     using NameT =
diff --git a/sycl/test-e2e/WorkGroupMemory/UR_argument_test.cpp b/sycl/test-e2e/WorkGroupMemory/UR_argument_test.cpp
new file mode 100644
index 0000000000000..82fa25cf62549
--- /dev/null
+++ b/sycl/test-e2e/WorkGroupMemory/UR_argument_test.cpp
@@ -0,0 +1,20 @@
+// RUN: %{build} -o %t.out
+// RUN: env SYCL_UR_TRACE=2 %{run} %t.out | FileCheck %s
+
+#include <sycl/detail/core.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
+
+// Check that the work group memory object is mapped to exactly one backend
+// kernel argument.
+
+int main() {
+  sycl::queue q;
+  q.submit([&](sycl::handler &cgh) {
+    sycl::ext::oneapi::experimental::work_group_memory<int[2]> data{cgh};
+    cgh.parallel_for(sycl::nd_range<1>{1, 1},
+                     [=](sycl::nd_item<1> it) { data[0] = 42; });
+  });
+}
+
+// CHECK-COUNT-1: ---> urKernelSetArg
+// CHECK-NOT: ---> urKernelSetArg
diff --git a/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp b/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
index 00b284b7017ee..080e551e622e2 100644
--- a/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
@@ -1,34 +1,25 @@
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out
-
 #include <cassert>
 #include <cstring>
 #include <sycl/detail/core.hpp>
 #include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
-
+#include <sycl/group_barrier.hpp>
+#include <sycl/sycl.hpp>
 namespace syclexp = sycl::ext::oneapi::experimental;
 
+sycl::queue q;
+
 // This test performs a swap of two scalars/arrays inside a kernel using a
 // work_group_memory object as a temporary buffer. The test is done for scalar
 // types and bounded arrays. After the kernel finishes, it is verified on the
 // host side that the swap worked.
 
-// One important note is that for unbounded arrays, the feature is unstable.
-// Specifically, the code may or may not compile when kernels reference work
-// group memory objects that have been constructed with the unbounded array
-// type. This is due to a limitation of SPIRV where it does not allow arrays of
-// length zero. For example, an unbounded array may be translated to an array of
-// length zero in LLVM IR and during the LLVM IR -> SPIRV translation phase, the
-// translator rejects all arrays of length zero because they are invalid
-// constructs in SPIRV. As a result of this, unbounded arrays do not appear in
-// this test. They do appear in the sanity test though in this directory because
-// there the unbounded arrays are used with concrete subscript indices which
-// seems to work, for now at least.
-
 template <typename T> void swap_scalar(T &a, T &b) {
-  sycl::queue q;
   const T old_a = a;
   const T old_b = b;
+  const size_t size = 1;
+  const size_t wgsize = 1;
   {
     sycl::buffer<T, 1> buf_a{&a, 1};
     sycl::buffer<T, 1> buf_b{&b, 1};
@@ -36,7 +27,8 @@ template <typename T> void swap_scalar(T &a, T &b) {
       sycl::accessor acc_a{buf_a, cgh};
       sycl::accessor acc_b{buf_b, cgh};
       syclexp::work_group_memory<T> temp{cgh};
-      cgh.single_task([=]() {
+      sycl::nd_range<1> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<1> it) {
         temp = acc_a[0];
         acc_a[0] = acc_b[0];
         acc_b[0] = temp;
@@ -56,8 +48,9 @@ template <typename T> void swap_scalar(T &a, T &b) {
       sycl::accessor acc_a{buf_a, cgh};
       sycl::accessor acc_b{buf_b, cgh};
       syclexp::work_group_memory<T> temp{cgh};
-      syclexp::work_group_memory<T> temp2;
-      cgh.single_task([=]() {
+      sycl::nd_range<1> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<1> it) {
+        syclexp::work_group_memory<T> temp2;
         temp2 = temp; // temp and temp2 have the same underlying data
         temp = acc_a[0];
         acc_a[0] = acc_b[0];
@@ -80,7 +73,8 @@ template <typename T> void swap_scalar(T &a, T &b) {
       sycl::accessor acc_b{buf_b, cgh};
       syclexp::work_group_memory<T> temp{cgh};
       syclexp::work_group_memory<T> temp2{cgh};
-      cgh.single_task([=]() {
+      sycl::nd_range<1> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
         temp = acc_a[0];
         acc_a[0] = acc_b[0];
         temp2 = *(temp.get_multi_ptr()); // temp2 now has the same value as temp
@@ -101,7 +95,8 @@ template <typename T> void swap_scalar(T &a, T &b) {
       sycl::accessor acc_b{buf_b, cgh};
       syclexp::work_group_memory<T> temp{cgh};
       syclexp::work_group_memory<T> temp2{cgh};
-      cgh.single_task([=]() {
+      sycl::nd_range<1> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
         temp = acc_a[0];
         acc_a[0] = acc_b[0];
         temp2 = *(&temp);
@@ -113,12 +108,17 @@ template <typename T> void swap_scalar(T &a, T &b) {
   assert(a == old_a && b == old_b && "Incorrect swap!");
 }
 
-template <typename T, size_t N> void swap_array_1d(T (&a)[N], T (&b)[N]) {
+// Swap two 1d arrays in batches of size batch_size where each batch will be
+// swapped by items in the same work group.
+template <typename T, size_t N>
+void swap_array_1d(T (&a)[N], T (&b)[N], size_t batch_size) {
   sycl::queue q;
   T old_a[N];
   std::memcpy(old_a, a, sizeof(a));
   T old_b[N];
   std::memcpy(old_b, b, sizeof(b));
+  const size_t size = N;
+  const size_t wgsize = batch_size;
   {
     sycl::buffer<T, 1> buf_a{a, N};
     sycl::buffer<T, 1> buf_b{b, N};
@@ -126,12 +126,12 @@ template <typename T, size_t N> void swap_array_1d(T (&a)[N], T (&b)[N]) {
       sycl::accessor acc_a{buf_a, cgh};
       sycl::accessor acc_b{buf_b, cgh};
       syclexp::work_group_memory<T[N]> temp{cgh};
-      cgh.single_task([=]() {
-        for (int i = 0; i < N; ++i) {
-          temp[i] = acc_a[i];
-          acc_a[i] = acc_b[i];
-          acc_b[i] = temp[i];
-        }
+      sycl::nd_range<1> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
+        const auto i = it.get_global_id();
+        temp[i] = acc_a[i];
+        acc_a[i] = acc_b[i];
+        acc_b[i] = temp[i];
       });
     });
   }
@@ -148,13 +148,13 @@ template <typename T, size_t N> void swap_array_1d(T (&a)[N], T (&b)[N]) {
       sycl::accessor acc_a{buf_a, cgh};
       sycl::accessor acc_b{buf_b, cgh};
       syclexp::work_group_memory<T[N]> temp{cgh};
-      cgh.single_task([=]() {
+      sycl::nd_range<1> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
         auto ptr = temp.get_multi_ptr();
-        for (int i = 0; i < N; ++i) {
-          ptr[i] = acc_a[i];
-          acc_a[i] = acc_b[i];
-          acc_b[i] = ptr[i];
-        }
+        const auto i = it.get_global_id();
+        ptr[i] = acc_a[i];
+        acc_a[i] = acc_b[i];
+        acc_b[i] = ptr[i];
       });
     });
   }
@@ -172,13 +172,13 @@ template <typename T, size_t N> void swap_array_1d(T (&a)[N], T (&b)[N]) {
       sycl::accessor acc_a{buf_a, cgh};
       sycl::accessor acc_b{buf_b, cgh};
       syclexp::work_group_memory<T[N]> temp{cgh};
-      cgh.single_task([=]() {
+      sycl::nd_range<1> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
+        const auto i = it.get_global_id();
         auto ptr = &temp;
-        for (int i = 0; i < N; ++i) {
-          (*ptr)[i] = acc_a[i];
-          acc_a[i] = acc_b[i];
-          acc_b[i] = (*ptr)[i];
-        }
+        (*ptr)[i] = acc_a[i];
+        acc_a[i] = acc_b[i];
+        acc_b[i] = (*ptr)[i];
       });
     });
   }
@@ -188,38 +188,39 @@ template <typename T, size_t N> void swap_array_1d(T (&a)[N], T (&b)[N]) {
   }
 }
 
-template <typename T, size_t N, size_t M>
-void swap_array_2d(T (&a)[N][M], T (&b)[N][M]) {
+template <typename T, size_t N>
+void swap_array_2d(T (&a)[N][N], T (&b)[N][N], size_t batch_size) {
   sycl::queue q;
-  T old_a[N][M];
+  T old_a[N][N];
   for (int i = 0; i < N; ++i) {
     std::memcpy(old_a[i], a[i], sizeof(a[0]));
   }
-  T old_b[N][M];
+  T old_b[N][N];
   for (int i = 0; i < N; ++i) {
 
     std::memcpy(old_b[i], b[i], sizeof(b[0]));
   }
+  const auto size = sycl::range{N, N};
+  const auto wgsize = sycl::range{batch_size, batch_size};
   {
-    sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, M}};
-    sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, M}};
+    sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, N}};
+    sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, N}};
     q.submit([&](sycl::handler &cgh) {
       sycl::accessor acc_a{buf_a, cgh};
       sycl::accessor acc_b{buf_b, cgh};
-      syclexp::work_group_memory<T[N][M]> temp{cgh};
-      cgh.single_task([=]() {
-        for (int i = 0; i < N; ++i) {
-          for (int j = 0; j < M; ++j) {
-            temp[i][j] = acc_a[i][j];
-            acc_a[i][j] = acc_b[i][j];
-            acc_b[i][j] = temp[i][j];
-          }
-        }
+      syclexp::work_group_memory<T[N][N]> temp{cgh};
+      sycl::nd_range<2> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<2> it) {
+        const auto i = it.get_global_id()[0];
+        const auto j = it.get_global_id()[1];
+        temp[i][j] = acc_a[i][j];
+        acc_a[i][j] = acc_b[i][j];
+        acc_b[i][j] = temp[i][j];
       });
     });
   }
   for (int i = 0; i < N; ++i) {
-    for (int j = 0; j < M; ++j) {
+    for (int j = 0; j < N; ++j) {
       assert(a[i][j] == old_b[i][j] && b[i][j] == old_a[i][j] &&
              "Incorrect swap!");
     }
@@ -229,32 +230,26 @@ void swap_array_2d(T (&a)[N][M], T (&b)[N][M]) {
   // One will save the value of acc_a and the other will be copy-assigned from
   // it and will be used to write the values back to acc_b.
   {
-    sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, M}};
-    sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, M}};
+    sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, N}};
+    sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, N}};
     q.submit([&](sycl::handler &cgh) {
       sycl::accessor acc_a{buf_a, cgh};
       sycl::accessor acc_b{buf_b, cgh};
-      syclexp::work_group_memory<T[N][M]> temp{cgh};
-      syclexp::work_group_memory<T[N][M]> temp2{cgh};
-      cgh.single_task([=]() {
-        for (int i = 0; i < N; ++i) {
-          for (int j = 0; j < M; ++j) {
-            temp[i][j] = acc_a[i][j];
-            acc_a[i][j] = acc_b[i][j];
-          }
-        }
-        syclexp::work_group_memory<T[N][M]> temp2;
+      syclexp::work_group_memory<T[N][N]> temp{cgh};
+      sycl::nd_range<2> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<2> it) {
+        const auto i = it.get_global_id()[0];
+        const auto j = it.get_global_id()[1];
+        temp[i][j] = acc_a[i][j];
+        acc_a[i][j] = acc_b[i][j];
+        syclexp::work_group_memory<T[N][N]> temp2;
         temp2 = temp;
-        for (int i = 0; i < N; ++i) {
-          for (int j = 0; j < M; ++j) {
-            acc_b[i][j] = temp2[i][j];
-          }
-        }
+        acc_b[i][j] = temp2[i][j];
       });
     });
   }
   for (int i = 0; i < N; ++i) {
-    for (int j = 0; j < M; ++j) {
+    for (int j = 0; j < N; ++j) {
       // Two swaps are the same as no swap
       assert(a[i][j] == old_a[i][j] && b[i][j] == old_b[i][j] &&
              "Incorrect swap!");
@@ -264,31 +259,25 @@ void swap_array_2d(T (&a)[N][M], T (&b)[N][M]) {
   // Same as above but construct the second temporary inside the kernel and
   // copy-construct it from the first temporary.
   {
-    sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, M}};
-    sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, M}};
+    sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, N}};
+    sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, N}};
     q.submit([&](sycl::handler &cgh) {
       sycl::accessor acc_a{buf_a, cgh};
       sycl::accessor acc_b{buf_b, cgh};
-      syclexp::work_group_memory<T[N][M]> temp{cgh};
-      syclexp::work_group_memory<T[N][M]> temp2{cgh};
-      cgh.single_task([=]() {
-        for (int i = 0; i < N; ++i) {
-          for (int j = 0; j < M; ++j) {
-            temp[i][j] = acc_a[i][j];
-            acc_a[i][j] = acc_b[i][j];
-          }
-        }
-        syclexp::work_group_memory<T[N][M]> temp2{temp};
-        for (int i = 0; i < N; ++i) {
-          for (int j = 0; j < M; ++j) {
-            acc_b[i][j] = temp2[i][j];
-          }
-        }
+      syclexp::work_group_memory<T[N][N]> temp{cgh};
+      sycl::nd_range<2> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<2> it) {
+        const auto i = it.get_global_id()[0];
+        const auto j = it.get_global_id()[1];
+        temp[i][j] = acc_a[i][j];
+        acc_a[i][j] = acc_b[i][j];
+        syclexp::work_group_memory<T[N][N]> temp2{temp};
+        acc_b[i][j] = temp2[i][j];
       });
     });
   }
   for (int i = 0; i < N; ++i) {
-    for (int j = 0; j < M; ++j) {
+    for (int j = 0; j < N; ++j) {
       // Three swaps are the same as one swap
       assert(a[i][j] == old_b[i][j] && b[i][j] == old_a[i][j] &&
              "Incorrect swap!");
@@ -296,30 +285,49 @@ void swap_array_2d(T (&a)[N][M], T (&b)[N][M]) {
   }
 }
 
-constexpr size_t N = 100;
-constexpr size_t M = 100;
+// Coherency test that checks that work group memory is truly shared by
+// work-items in a work group. The test allocates an integer in
+// work group memory and each leader of the work groups will assign
+// its work group index to this integer. The computation that the
+// leader does yields the same value for all work-items in the work-group
+// so we can verify that each work-item sees the value written by its leader.
+// The test also is a sanity check that different work groups get different
+// work group memory locations as otherwise we'd have data races.
+void coherency(size_t size, size_t wgsize) {
+  q.submit([&](sycl::handler &cgh) {
+    syclexp::work_group_memory<int> data{cgh};
+    sycl::nd_range<1> ndr{size, wgsize};
+    cgh.parallel_for(ndr, [=](sycl::nd_item<1> it) {
+      if (it.get_group().leader()) {
+        data = it.get_global_id() / wgsize;
+      }
+      sycl::group_barrier(it.get_group());
+      assert(data == it.get_global_id() / wgsize);
+    });
+  });
+}
+
+constexpr size_t N = 128;
 int main() {
-  int intarr1[N][M];
-  int intarr2[N][M];
-  float floatarr1[N][M];
-  float floatarr2[N][M];
+  int intarr1[N][N];
+  int intarr2[N][N];
   for (int i = 0; i < N; ++i) {
-    for (int j = 0; j < M; ++j) {
+    for (int j = 0; j < N; ++j) {
       intarr1[i][j] = i + j;
       intarr2[i][j] = i * j;
-      floatarr1[i][j] = (i + 1) / (j + 1);
-      floatarr2[i][j] = (j + 1) / (i + 1);
     }
   }
   for (int i = 0; i < N; ++i) {
-    for (int j = 0; j < M; ++j) {
+    for (int j = 0; j < N; ++j) {
       swap_scalar(intarr1[i][j], intarr2[i][j]);
-      swap_scalar(floatarr1[i][j], floatarr2[i][j]);
     }
-    swap_array_1d(intarr1[i], intarr2[i]);
-    swap_array_1d(floatarr1[i], floatarr2[i]);
+    swap_array_1d(intarr1[i], intarr2[i], 8);
   }
-  swap_array_2d(intarr1, intarr2);
-  swap_array_2d(floatarr1, floatarr2);
+  swap_array_2d(intarr1, intarr2, 8);
+  coherency(N, N / 2);
+  coherency(N, N / 4);
+  coherency(N, N / 8);
+  coherency(N, N / 16);
+  coherency(N, N / 32);
   return 0;
 }
diff --git a/sycl/test-e2e/WorkGroupMemory/unbounded_array_test.cpp b/sycl/test-e2e/WorkGroupMemory/unbounded_array_test.cpp
new file mode 100644
index 0000000000000..d280f82c18e43
--- /dev/null
+++ b/sycl/test-e2e/WorkGroupMemory/unbounded_array_test.cpp
@@ -0,0 +1,23 @@
+// RUN: %{build} -o %t.out
+// RUN: %{run} %t.out
+
+#include <sycl/detail/core.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
+
+// This test checks that work group memory objects can be used with unbounded
+// arrays as template arguments.
+
+// Unbounded array support is not yet implemented for work group memory
+// due to a LLVM IR <-> SPIRV translation problem.
+// XFAIL: *
+
+int main() {
+  sycl::queue q;
+  q.submit([&](sycl::handler &cgh) {
+    sycl::ext::oneapi::experimental::work_group_memory<int[]> data{16, cgh};
+    cgh.parallel_for(sycl::nd_range<1>{1, 1}, [=](sycl::nd_item<1> it) {
+      for (int i = 0; i < 16; ++i)
+        data[i] = 42;
+    });
+  });
+}
diff --git a/sycl/test-e2e/WorkGroupMemory/work_group_memory_invalid_usage_test.cpp b/sycl/test-e2e/WorkGroupMemory/work_group_memory_invalid_usage_test.cpp
new file mode 100644
index 0000000000000..3a1609ac21607
--- /dev/null
+++ b/sycl/test-e2e/WorkGroupMemory/work_group_memory_invalid_usage_test.cpp
@@ -0,0 +1,38 @@
+// RUN: %{build} -o %t.out
+// RUN: %{run} %t.out
+#include <cassert>
+#include <sycl/sycl.hpp>
+using namespace sycl::ext::oneapi::experimental;
+
+// As per the spec, a work_group_memory object cannot be used in a single task
+// kernel or in a sycl::range kernel. An exception with error code
+// errc::kernel_argument must be thrown in such cases. This test verifies this.
+
+int main() {
+
+  sycl::queue q;
+  try {
+    q.submit([&](sycl::handler &cgh) {
+      work_group_memory<int> mem{cgh};
+      cgh.single_task([=]() { mem = 42; });
+    });
+    assert(false && "Work group memory was used in a single_task kernel and an "
+                    "exception was not seen"); // Fail, exception was not seen
+  } catch (sycl::exception &e) {
+    // Exception seen but must verify that the error code is correct
+    assert(e.code() == sycl::errc::kernel_argument);
+  }
+  // Same thing but with a range kernel
+  try {
+    q.submit([&](sycl::handler &cgh) {
+      work_group_memory<int> mem{cgh};
+      cgh.parallel_for(sycl::range{1}, [=](sycl::id<> it) { mem = 42; });
+    });
+    assert(false && "Work group memory was used in a range kernel and an "
+                    "exception was not seen"); // Fail, exception was not seen
+  } catch (sycl::exception &e) {
+    // Exception seen but must verify that the error code is correct
+    assert(e.code() == sycl::errc::kernel_argument);
+  }
+  return 0;
+}

From 0e95ee5a3d27114bb61cf87b48ef90604291a284 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 27 Sep 2024 18:33:51 +0200
Subject: [PATCH 035/107] Remove sanity test

---
 ...nvalid_usage_test.cpp => invalid_test.cpp} |   0
 ...ng_work_group_memory.cpp => swap_test.cpp} |   0
 .../work_group_memory_sanity_test.cpp         | 171 ------------------
 3 files changed, 171 deletions(-)
 rename sycl/test-e2e/WorkGroupMemory/{work_group_memory_invalid_usage_test.cpp => invalid_test.cpp} (100%)
 rename sycl/test-e2e/WorkGroupMemory/{swap_test_using_work_group_memory.cpp => swap_test.cpp} (100%)
 delete mode 100644 sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp

diff --git a/sycl/test-e2e/WorkGroupMemory/work_group_memory_invalid_usage_test.cpp b/sycl/test-e2e/WorkGroupMemory/invalid_test.cpp
similarity index 100%
rename from sycl/test-e2e/WorkGroupMemory/work_group_memory_invalid_usage_test.cpp
rename to sycl/test-e2e/WorkGroupMemory/invalid_test.cpp
diff --git a/sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp b/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
similarity index 100%
rename from sycl/test-e2e/WorkGroupMemory/swap_test_using_work_group_memory.cpp
rename to sycl/test-e2e/WorkGroupMemory/swap_test.cpp
diff --git a/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp b/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp
deleted file mode 100644
index 7e53e61c54686..0000000000000
--- a/sycl/test-e2e/WorkGroupMemory/work_group_memory_sanity_test.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-// RUN: %{build} -o %t.out
-// RUN: %{run} %t.out
-
-#include <sycl/detail/core.hpp>
-#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
-#include <sycl/usm.hpp>
-
-// Sanity test that checks to see if idiomatic code involving work_group_memory
-// objects compiles and runs with no errors.
-
-namespace syclex = sycl::ext::oneapi::experimental;
-sycl::queue global_q;
-
-constexpr size_t SIZE = 4096;
-constexpr size_t WGSIZE = 256;
-
-struct point {
-  int x;
-  int y;
-};
-
-void simple_inc(const syclex::work_group_memory<int> &mem) { mem++; }
-
-void fancy_inc(syclex::work_group_memory<int> mem) {
-  syclex::work_group_memory<int> t = mem;
-  t = mem;
-  t++;
-}
-
-void test_breadth() {
-  sycl::queue q;
-  global_q = q;
-
-  int *res = sycl::malloc_host<int>(16, q);
-
-  q.submit([&](sycl::handler &cgh) {
-     syclex::work_group_memory<int> mem1{cgh};
-     syclex::work_group_memory<int[10]> mem2{cgh};
-     syclex::work_group_memory<int[10]> mem3{cgh};
-     syclex::work_group_memory<int[]> mem4{5, cgh};
-     syclex::work_group_memory<int[][10]> mem5{2, cgh};
-     syclex::work_group_memory<int[][10]> mem6{2, cgh};
-     syclex::work_group_memory<point> mem7{cgh};
-     syclex::work_group_memory<point[][10]> mem8{2, cgh};
-
-     cgh.single_task([=] {
-       // Operations on scalar
-       ++mem1;
-       mem1++;
-       mem1 += 1;
-       mem1 = mem1 + 1;
-       int *p1 = &mem1;
-       (*p1)++;
-       simple_inc(mem1);
-       fancy_inc(mem1);
-       res[0] = *(mem1.get_multi_ptr());
-       res[1] = mem1;
-
-       // Operations on bounded array
-       mem2[4] = mem2[4] + 1;
-       int(*p2)[10] = &mem2;
-       (*p2)[4]++;
-       res[2] = mem2.get_multi_ptr()[4];
-       res[3] = mem2[4];
-
-       mem3[4] = mem3[4] + 1;
-       int(*p3)[10] = &mem3;
-       (*p3)[4]++;
-       res[4] = mem3.get_multi_ptr()[4];
-       res[5] = mem3[4];
-
-       // Operations on unbounded array
-       mem4[4] = mem4[4] + 1;
-       int(*p4)[] = &mem4;
-       (*p4)[4]++;
-       res[6] = mem4.get_multi_ptr()[4];
-       res[7] = mem4[4];
-
-       // Operations on unbounded multi-dimensional array
-       mem5[1][5] = mem5[1][5] + 1;
-       mem5[1][7] = mem5[1][7] + 1;
-       res[8] = mem5.get_multi_ptr()[10 + 5];
-       res[9] = mem5[1][7];
-
-       mem6[1][5] = mem6[1][5] + 1;
-       mem6[1][7] = mem6[1][7] + 1;
-       res[10] = mem6.get_multi_ptr()[10 + 5];
-       res[11] = mem6[1][7];
-
-       // Operations on scalar struct
-       (&mem7)->x++;
-       (&mem7)->y += 1;
-       point pnt = mem7;
-       pnt.x++;
-       pnt.y++;
-       mem7 = pnt;
-       res[12] = (&mem7)->x;
-       res[13] = (&mem7)->y;
-
-       // Operations on unbounded multi-dimensional array of struct
-       mem8[1][5].x++;
-       mem8[1][5].y += 1;
-       res[14] = mem8.get_multi_ptr()[10 + 5].x;
-       res[15] = mem8[1][5].y;
-     });
-   }).wait();
-}
-
-void test_basic() {
-  sycl::queue q;
-
-  q.submit([&](sycl::handler &cgh) {
-     // Allocate one element for each work-item in the work-group.
-     syclex::work_group_memory<int[WGSIZE]> mem{cgh};
-
-     sycl::nd_range ndr{{SIZE}, {WGSIZE}};
-     cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
-       size_t id = it.get_local_linear_id();
-
-       // Each work-item has its own dedicated element of the array.
-       mem[id] = 0;
-     });
-   }).wait();
-}
-
-void test_operations() {
-  sycl::queue q;
-
-  q.submit([&](sycl::handler &cgh) {
-     syclex::work_group_memory<int> mem1{cgh};      // scalar
-     syclex::work_group_memory<int[10]> mem2{cgh};  // bounded array
-     syclex::work_group_memory<int[]> mem3{5, cgh}; // unbounded array
-     syclex::work_group_memory<int[][10]> mem4{2,
-                                               cgh}; // multi-dimensional array
-     syclex::work_group_memory<point[10]> mem5{cgh}; // array of struct
-
-     sycl::nd_range ndr{{SIZE}, {WGSIZE}};
-     cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
-       if (it.get_group().leader()) {
-         // A "work_group_memory" templated on a scalar type acts much like the
-         // enclosed scalar type.
-         ++mem1;
-         mem1++;
-         mem1 += 1;
-         mem1 = mem1 + 1;
-         int *p1 = &mem1;
-
-         // A "work_group_memory" templated on an array type (either bounded or
-         // unbounded) acts like an array.
-         ++mem2[4];
-         mem2[4]++;
-         mem2[4] = mem2[4] + 1;
-         int *p2 = &mem2[4];
-
-         // A multi-dimensional array works as expected.
-         mem4[1][5] = mem4[1][5] + 1;
-         mem4[1][7] = mem4[1][7] + 1;
-
-         // An array of structs works as expected too.
-         mem5[1].x++;
-         mem5[1].y = mem5[1].y + 1;
-       }
-     });
-   }).wait();
-}
-
-int main() {
-  test_breadth();
-  test_basic();
-  test_operations();
-}

From 52f13f01cea8ffcf32a3a2d71d24d2ab5fe1251a Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 27 Sep 2024 19:32:16 +0200
Subject: [PATCH 036/107] Move extension doc to proposed

---
 .../sycl_ext_oneapi_work_group_memory.asciidoc                   | 0
 sycl/source/feature_test.hpp.in                                  | 1 -
 2 files changed, 1 deletion(-)
 rename sycl/doc/extensions/{experimental => proposed}/sycl_ext_oneapi_work_group_memory.asciidoc (100%)

diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc b/sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc
similarity index 100%
rename from sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc
rename to sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc
diff --git a/sycl/source/feature_test.hpp.in b/sycl/source/feature_test.hpp.in
index c409a4e10db8a..a61e504eb5e4c 100644
--- a/sycl/source/feature_test.hpp.in
+++ b/sycl/source/feature_test.hpp.in
@@ -108,7 +108,6 @@ inline namespace _V1 {
 #define SYCL_EXT_ONEAPI_RAW_KERNEL_ARG 1
 #define SYCL_EXT_ONEAPI_PROFILING_TAG 1
 #define SYCL_EXT_ONEAPI_ENQUEUE_NATIVE_COMMAND 1
-#define SYCL_EXT_ONEAPI_WORK_GROUP_MEMORY 1
 // In progress yet
 #define SYCL_EXT_ONEAPI_ATOMIC16 0
 

From 71d101332bdfdd3a2e1f0e19e5c2a3b2401b459d Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 27 Sep 2024 20:19:16 +0200
Subject: [PATCH 037/107] Restore proposed status of work group memory doc

---
 .../sycl_ext_oneapi_work_group_memory.asciidoc         | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc b/sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc
index a8857dd213168..9a7875c6987ab 100644
--- a/sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc
+++ b/sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc
@@ -49,10 +49,12 @@ This extension also depends on the following other SYCL extensions:
 
 == Status
 
-This is an experimental extension specification, intended to provide early
-access to features and gather community feedback.  Interfaces defined in this
-specification are implemented in {dpcpp}, but they are not finalized and may
-change incompatibly in future versions of {dpcpp} without prior notice.
+This is a proposed extension specification, intended to gather community
+feedback.
+Interfaces defined in this specification may not be implemented yet or may be
+in a preliminary state.
+The specification itself may also change in incompatible ways before it is
+finalized.
 *Shipping software products should not rely on APIs defined in this
 specification.*
 

From d48bc42d740b764fd1e3ff39fd07c03ab0ec9451 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 27 Sep 2024 21:27:54 +0200
Subject: [PATCH 038/107] Fix unusd variable warning

---
 .../sycl/ext/oneapi/experimental/work_group_memory.hpp        | 4 ++--
 .../WorkGroupMemory/{invalid_test.cpp => invalid_usage.cpp}   | 0
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename sycl/test-e2e/WorkGroupMemory/{invalid_test.cpp => invalid_usage.cpp} (100%)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 8644806ea9572..dec901adcd63a 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -54,12 +54,12 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   work_group_memory &operator=(const work_group_memory &rhs) = default;
   template <typename T = DataT,
             typename = std::enable_if_t<!sycl::detail::is_unbounded_array_v<T>>>
-  work_group_memory(handler &cgh)
+  work_group_memory(handler &)
       : sycl::detail::work_group_memory_impl(sizeof(work_group_memory),
                                              sizeof(DataT)) {}
   template <typename T = DataT,
             typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
-  work_group_memory(size_t num, handler &cgh)
+  work_group_memory(size_t num, handler &)
       : sycl::detail::work_group_memory_impl(
             sizeof(work_group_memory),
             num * sizeof(std::remove_extent_t<DataT>)) {}
diff --git a/sycl/test-e2e/WorkGroupMemory/invalid_test.cpp b/sycl/test-e2e/WorkGroupMemory/invalid_usage.cpp
similarity index 100%
rename from sycl/test-e2e/WorkGroupMemory/invalid_test.cpp
rename to sycl/test-e2e/WorkGroupMemory/invalid_usage.cpp

From f6515bc89f05e37ce21e1f891c8fcb08951804a1 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 27 Sep 2024 22:03:46 +0200
Subject: [PATCH 039/107] Reduce test size to make sure UR does not run out or
 resources

---
 sycl/test-e2e/WorkGroupMemory/swap_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/test-e2e/WorkGroupMemory/swap_test.cpp b/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
index 080e551e622e2..2d0aae14adab1 100644
--- a/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
@@ -307,7 +307,7 @@ void coherency(size_t size, size_t wgsize) {
   });
 }
 
-constexpr size_t N = 128;
+constexpr size_t N = 32;
 int main() {
   int intarr1[N][N];
   int intarr2[N][N];

From 3e4c73c37ec2afaded640fed6492560a873f2bb7 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 27 Sep 2024 22:50:53 +0200
Subject: [PATCH 040/107] Replace sycl.hpp with core.hpp in the includes of E2E
 test

---
 sycl/test-e2e/WorkGroupMemory/invalid_usage.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sycl/test-e2e/WorkGroupMemory/invalid_usage.cpp b/sycl/test-e2e/WorkGroupMemory/invalid_usage.cpp
index 3a1609ac21607..7501fcd7591d5 100644
--- a/sycl/test-e2e/WorkGroupMemory/invalid_usage.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/invalid_usage.cpp
@@ -1,7 +1,8 @@
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out
 #include <cassert>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 using namespace sycl::ext::oneapi::experimental;
 
 // As per the spec, a work_group_memory object cannot be used in a single task

From c84229e8e17c86c4e4adcc5bb15d79673d30b06b Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Sun, 29 Sep 2024 22:15:44 -0400
Subject: [PATCH 041/107] Remove sycl.hpp include from tests

---
 sycl/test-e2e/WorkGroupMemory/swap_test.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sycl/test-e2e/WorkGroupMemory/swap_test.cpp b/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
index 2d0aae14adab1..2c67490d4c48a 100644
--- a/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
@@ -5,7 +5,6 @@
 #include <sycl/detail/core.hpp>
 #include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 #include <sycl/group_barrier.hpp>
-#include <sycl/sycl.hpp>
 namespace syclexp = sycl::ext::oneapi::experimental;
 
 sycl::queue q;

From d2fddd84e64a2209ab38ab66b9950485cfe4a20f Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Wed, 2 Oct 2024 22:35:50 +0200
Subject: [PATCH 042/107] Add support for unbounded arrays

---
 clang/lib/CodeGen/CodeGenTypes.cpp            |  8 +++
 .../oneapi/experimental/work_group_memory.hpp | 17 +++----
 sycl/include/sycl/handler.hpp                 |  5 +-
 sycl/test-e2e/WorkGroupMemory/swap_test.cpp   | 50 +++++++++++++++++++
 .../WorkGroupMemory/unbounded_array_test.cpp  | 23 ---------
 5 files changed, 66 insertions(+), 37 deletions(-)
 delete mode 100644 sycl/test-e2e/WorkGroupMemory/unbounded_array_test.cpp

diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index edf26dd6186ba..cdf80f2d8397c 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -488,6 +488,14 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
         return Ty;
     }
   }
+  // An incomplete array AST type is typically lowered to an array of length zero in LLVM IR.
+  // For SYCL devices, this is incompatible with SPIRV which does not accept arrays of length zero
+  // so we explicitly intercept this case to instead lower to an array of length 1 instead.
+  if (Context.getLangOpts().SYCLIsDevice) 
+	if (T->isIncompleteArrayType()) {
+		return llvm::ArrayType::get(ConvertType(cast<ArrayType>(T)->getElementType()), 1);
+}
+}
 
   // RecordTypes are cached and processed specially.
   if (const RecordType *RT = dyn_cast<RecordType>(Ty))
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index dec901adcd63a..dfded4c3b7216 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -22,19 +22,17 @@ inline constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
 
 class work_group_memory_impl {
 public:
-  work_group_memory_impl() : wgm_size{0}, buffer_size{0} {}
+  work_group_memory_impl() : buffer_size{0} {}
   work_group_memory_impl(const work_group_memory_impl &rhs) = default;
   work_group_memory_impl &
   operator=(const work_group_memory_impl &rhs) = default;
-  work_group_memory_impl(size_t wgm_size, size_t buffer_size)
-      : wgm_size{wgm_size}, buffer_size{buffer_size} {}
-  size_t wgm_size;
+  work_group_memory_impl(size_t buffer_size)
+      : buffer_size{buffer_size} {}
+  private:
   size_t buffer_size;
+  friend class sycl::handler;
 };
 
-inline size_t getWorkGroupMemoryOwnSize(detail::work_group_memory_impl *wgm) {
-  return wgm->wgm_size;
-}
 } // namespace detail
 
 namespace ext::oneapi::experimental {
@@ -55,13 +53,12 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   template <typename T = DataT,
             typename = std::enable_if_t<!sycl::detail::is_unbounded_array_v<T>>>
   work_group_memory(handler &)
-      : sycl::detail::work_group_memory_impl(sizeof(work_group_memory),
+      : sycl::detail::work_group_memory_impl(
                                              sizeof(DataT)) {}
   template <typename T = DataT,
             typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
   work_group_memory(size_t num, handler &)
       : sycl::detail::work_group_memory_impl(
-            sizeof(work_group_memory),
             num * sizeof(std::remove_extent_t<DataT>)) {}
   template <access::decorated IsDecorated = access::decorated::no>
   multi_ptr<value_type, access::address_space::local_space, IsDecorated>
@@ -70,7 +67,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
                                     IsDecorated, value_type>(ptr);
   }
   DataT *operator&() const { return reinterpret_cast<DataT *>(ptr); }
-  operator DataT &() const { return *reinterpret_cast<DataT *>(ptr); }
+  operator DataT &() const { return *(this->operator&()); }
   template <typename T = DataT,
             typename = std::enable_if_t<!std::is_array_v<T>>>
   const work_group_memory &operator=(const DataT &value) const {
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 987e4ac6cea3a..70da0dddc225c 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -171,8 +171,6 @@ class graph_impl;
 } // namespace ext::oneapi::experimental::detail
 namespace detail {
 
-class work_group_memory_impl;
-size_t getWorkGroupMemoryOwnSize(work_group_memory_impl *);
 class handler_impl;
 class kernel_impl;
 class queue_impl;
@@ -720,8 +718,7 @@ class __SYCL_EXPORT handler {
       const ext::oneapi::experimental::work_group_memory<DataT, PropertyListT>
           &Arg) {
     addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg,
-           detail::getWorkGroupMemoryOwnSize(
-               static_cast<detail::work_group_memory_impl *>(&Arg)),
+           0,
            ArgIndex);
   }
 
diff --git a/sycl/test-e2e/WorkGroupMemory/swap_test.cpp b/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
index 2d0aae14adab1..1db06559e7639 100644
--- a/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
@@ -186,6 +186,29 @@ void swap_array_1d(T (&a)[N], T (&b)[N], size_t batch_size) {
   for (int i = 0; i < N; ++i) {
     assert(a[i] == old_b[i] && b[i] == old_a[i] && "Incorrect swap!");
   }
+
+  // Same as above but use an unbounded array as temporary storage
+  {
+    sycl::buffer<T, 1> buf_a{a, N};
+    sycl::buffer<T, 1> buf_b{b, N};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T[]> temp{N, cgh};
+      sycl::nd_range<1> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<> it) {
+        const auto i = it.get_global_id();
+        auto ptr = &temp;
+        (*ptr)[i] = acc_a[i];
+        acc_a[i] = acc_b[i];
+        acc_b[i] = (*ptr)[i];
+      });
+    });
+  }
+  // Four swaps same as no swap
+  for (int i = 0; i < N; ++i) {
+    assert(a[i] == old_a[i] && b[i] == old_b[i] && "Incorrect swap!");
+  }
 }
 
 template <typename T, size_t N>
@@ -283,6 +306,33 @@ void swap_array_2d(T (&a)[N][N], T (&b)[N][N], size_t batch_size) {
              "Incorrect swap!");
     }
   }
+  
+  // Same as above but use an unbounded array as temporary storage
+{
+    sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, N}};
+    sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, N}};
+    q.submit([&](sycl::handler &cgh) {
+      sycl::accessor acc_a{buf_a, cgh};
+      sycl::accessor acc_b{buf_b, cgh};
+      syclexp::work_group_memory<T[][N]> temp{N, cgh};
+      sycl::nd_range<2> ndr{size, wgsize};
+      cgh.parallel_for(ndr, [=](sycl::nd_item<2> it) {
+        const auto i = it.get_global_id()[0];
+        const auto j = it.get_global_id()[1];
+        temp[i][j] = acc_a[i][j];
+        acc_a[i][j] = acc_b[i][j];
+        syclexp::work_group_memory<T[][N]> temp2{temp};
+        acc_b[i][j] = temp2[i][j];
+      });
+    });
+  } 
+  for (int i = 0; i < N; ++i) {
+    for (int j = 0; j < N; ++j) {
+      // Four swaps are the same as no swap
+      assert(a[i][j] == old_a[i][j] && b[i][j] == old_b[i][j] &&
+             "Incorrect swap!");
+    }
+  }
 }
 
 // Coherency test that checks that work group memory is truly shared by
diff --git a/sycl/test-e2e/WorkGroupMemory/unbounded_array_test.cpp b/sycl/test-e2e/WorkGroupMemory/unbounded_array_test.cpp
deleted file mode 100644
index d280f82c18e43..0000000000000
--- a/sycl/test-e2e/WorkGroupMemory/unbounded_array_test.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// RUN: %{build} -o %t.out
-// RUN: %{run} %t.out
-
-#include <sycl/detail/core.hpp>
-#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
-
-// This test checks that work group memory objects can be used with unbounded
-// arrays as template arguments.
-
-// Unbounded array support is not yet implemented for work group memory
-// due to a LLVM IR <-> SPIRV translation problem.
-// XFAIL: *
-
-int main() {
-  sycl::queue q;
-  q.submit([&](sycl::handler &cgh) {
-    sycl::ext::oneapi::experimental::work_group_memory<int[]> data{16, cgh};
-    cgh.parallel_for(sycl::nd_range<1>{1, 1}, [=](sycl::nd_item<1> it) {
-      for (int i = 0; i < 16; ++i)
-        data[i] = 42;
-    });
-  });
-}

From 0f677c297e0237eefe6254953b8be16304f402bf Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Wed, 2 Oct 2024 22:38:22 +0200
Subject: [PATCH 043/107] Fix compilation errors

---
 clang/lib/CodeGen/CodeGenTypes.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index cdf80f2d8397c..e8ec8b97ed0eb 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -488,14 +488,14 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
         return Ty;
     }
   }
-  // An incomplete array AST type is typically lowered to an array of length zero in LLVM IR.
-  // For SYCL devices, this is incompatible with SPIRV which does not accept arrays of length zero
-  // so we explicitly intercept this case to instead lower to an array of length 1 instead.
-  if (Context.getLangOpts().SYCLIsDevice) 
-	if (T->isIncompleteArrayType()) {
-		return llvm::ArrayType::get(ConvertType(cast<ArrayType>(T)->getElementType()), 1);
-}
-}
+  // An incomplete array AST type is typically lowered to an array of length
+  // zero in LLVM IR. For SYCL devices, this is incompatible with SPIRV which
+  // does not accept arrays of length zero so we explicitly intercept this case
+  // to instead lower to an array of length 1 instead.
+  if (Context.getLangOpts().SYCLIsDevice)
+    if (T->isIncompleteArrayType())
+      return llvm::ArrayType::get(
+          ConvertType(cast<ArrayType>(T)->getElementType()), 1);
 
   // RecordTypes are cached and processed specially.
   if (const RecordType *RT = dyn_cast<RecordType>(Ty))

From 6ef823ed2185fdb3f15ab4f9ddc7ac75bfdf30ff Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Wed, 2 Oct 2024 22:41:37 +0200
Subject: [PATCH 044/107] Improve swap test

---
 sycl/test-e2e/WorkGroupMemory/swap_test.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/sycl/test-e2e/WorkGroupMemory/swap_test.cpp b/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
index 1db06559e7639..e82e986f7dc62 100644
--- a/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/swap_test.cpp
@@ -306,9 +306,9 @@ void swap_array_2d(T (&a)[N][N], T (&b)[N][N], size_t batch_size) {
              "Incorrect swap!");
     }
   }
-  
+
   // Same as above but use an unbounded array as temporary storage
-{
+  {
     sycl::buffer<T, 2> buf_a{a[0], sycl::range{N, N}};
     sycl::buffer<T, 2> buf_b{b[0], sycl::range{N, N}};
     q.submit([&](sycl::handler &cgh) {
@@ -325,7 +325,7 @@ void swap_array_2d(T (&a)[N][N], T (&b)[N][N], size_t batch_size) {
         acc_b[i][j] = temp2[i][j];
       });
     });
-  } 
+  }
   for (int i = 0; i < N; ++i) {
     for (int j = 0; j < N; ++j) {
       // Four swaps are the same as no swap

From 4de6d5034e5b9c08898487621f77f568fcd284d8 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Thu, 3 Oct 2024 06:17:52 +0200
Subject: [PATCH 045/107] Refactor CodeGenTypes.cpp changes

---
 clang/lib/CodeGen/CodeGenTypes.cpp | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index e8ec8b97ed0eb..85366762792c3 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -488,15 +488,6 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
         return Ty;
     }
   }
-  // An incomplete array AST type is typically lowered to an array of length
-  // zero in LLVM IR. For SYCL devices, this is incompatible with SPIRV which
-  // does not accept arrays of length zero so we explicitly intercept this case
-  // to instead lower to an array of length 1 instead.
-  if (Context.getLangOpts().SYCLIsDevice)
-    if (T->isIncompleteArrayType())
-      return llvm::ArrayType::get(
-          ConvertType(cast<ArrayType>(T)->getElementType()), 1);
-
   // RecordTypes are cached and processed specially.
   if (const RecordType *RT = dyn_cast<RecordType>(Ty))
     return ConvertRecordDeclType(RT->getDecl());
@@ -816,7 +807,7 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
       SkippedLayout = true;
       ResultType = llvm::Type::getInt8Ty(getLLVMContext());
     }
-    ResultType = llvm::ArrayType::get(ResultType, 0);
+    ResultType = llvm::ArrayType::get(ResultType, 1);
     break;
   }
   case Type::ArrayParameter:

From 5653f045bbd6550327b6d8e4d927977d841944d8 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Thu, 3 Oct 2024 06:18:40 +0200
Subject: [PATCH 046/107] Refactor CodeGenTypes.cpp changes

---
 clang/lib/CodeGen/CodeGenTypes.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index 85366762792c3..bdb917cd8f405 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -488,6 +488,7 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
         return Ty;
     }
   }
+
   // RecordTypes are cached and processed specially.
   if (const RecordType *RT = dyn_cast<RecordType>(Ty))
     return ConvertRecordDeclType(RT->getDecl());

From 40eb63ef7cdaa386bd17bbd645deb637d0b46301 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Thu, 3 Oct 2024 18:15:31 +0200
Subject: [PATCH 047/107] translate unbounded arrays to 1-sized arrays in LLVM
 IR in device compilation

---
 clang/lib/CodeGen/CodeGenTypes.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index bdb917cd8f405..4fcb7ebe6d80c 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -807,8 +807,8 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
     if (!ResultType->isSized()) {
       SkippedLayout = true;
       ResultType = llvm::Type::getInt8Ty(getLLVMContext());
-    }
-    ResultType = llvm::ArrayType::get(ResultType, 1);
+    } 
+    ResultType = llvm::ArrayType::get(ResultType, Context.getLangOpts().SYCLIsDevice ? 1 : 0);
     break;
   }
   case Type::ArrayParameter:

From f6a0df72d09a6b5980313da9ae837ae461328d78 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 3 Oct 2024 12:16:14 -0400
Subject: [PATCH 048/107] Remove trailing spaces

---
 clang/lib/CodeGen/CodeGenTypes.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index 4fcb7ebe6d80c..b452e4062a1bb 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -807,7 +807,7 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
     if (!ResultType->isSized()) {
       SkippedLayout = true;
       ResultType = llvm::Type::getInt8Ty(getLLVMContext());
-    } 
+    }
     ResultType = llvm::ArrayType::get(ResultType, Context.getLangOpts().SYCLIsDevice ? 1 : 0);
     break;
   }

From 026501c7fe5d4cf3659bc3108588b151345d9dd2 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Thu, 3 Oct 2024 19:04:54 +0200
Subject: [PATCH 049/107] Add unbounded array support by modifying LLVM IR ->
 SPIRV type lowering

---
 clang/lib/CodeGen/CodeGenTypes.cpp   |  5 +++--
 llvm-spirv/lib/SPIRV/SPIRVWriter.cpp | 11 +++--------
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index 4fcb7ebe6d80c..943dd29834a10 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -807,8 +807,9 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
     if (!ResultType->isSized()) {
       SkippedLayout = true;
       ResultType = llvm::Type::getInt8Ty(getLLVMContext());
-    } 
-    ResultType = llvm::ArrayType::get(ResultType, Context.getLangOpts().SYCLIsDevice ? 1 : 0);
+    }
+    ResultType = llvm::ArrayType::get(
+        ResultType, 0);
     break;
   }
   case Type::ArrayParameter:
diff --git a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
index 775296146c528..ddd424f55e2fd 100644
--- a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
+++ b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
@@ -453,24 +453,19 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
   if (T->isArrayTy()) {
     // SPIR-V 1.3 s3.32.6: Length is the number of elements in the array.
     //                     It must be at least 1.
-    if (T->getArrayNumElements() < 1) {
-      std::string Str;
-      llvm::raw_string_ostream OS(Str);
-      OS << *T;
-      SPIRVCK(T->getArrayNumElements() >= 1, InvalidArraySize, OS.str());
-    }
+    const auto ArraySize = T->getArrayNumElements() ? T->getArrayNumElements() : 1;
     Type *ElTy = T->getArrayElementType();
     SPIRVType *TransType = BM->addArrayType(
         transType(ElTy),
         static_cast<SPIRVConstant *>(transValue(
-            ConstantInt::get(getSizetType(), T->getArrayNumElements(), false),
+            ConstantInt::get(getSizetType(), ArraySize, false),
             nullptr)));
     mapType(T, TransType);
     if (ElTy->isPointerTy()) {
       mapType(
           ArrayType::get(TypedPointerType::get(Type::getInt8Ty(*Ctx),
                                                ElTy->getPointerAddressSpace()),
-                         T->getArrayNumElements()),
+                         ArraySize),
           TransType);
     }
     return TransType;

From 2ce21b35865413f7e3d07f87f370c6404d28e168 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Thu, 3 Oct 2024 19:05:45 +0200
Subject: [PATCH 050/107] Revert CodeGenTypes.cpp changes

---
 clang/lib/CodeGen/CodeGenTypes.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index 943dd29834a10..edf26dd6186ba 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -808,8 +808,7 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
       SkippedLayout = true;
       ResultType = llvm::Type::getInt8Ty(getLLVMContext());
     }
-    ResultType = llvm::ArrayType::get(
-        ResultType, 0);
+    ResultType = llvm::ArrayType::get(ResultType, 0);
     break;
   }
   case Type::ArrayParameter:

From d73b0b19fcb05a3eb2b414f8e8b586bc4ee312b7 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Mon, 7 Oct 2024 19:35:52 +0200
Subject: [PATCH 051/107] Update SPIRVWriter.cpp

---
 llvm-spirv/lib/SPIRV/SPIRVWriter.cpp | 6 +++---
 sycl/include/sycl/handler.hpp        | 3 +--
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
index ddd424f55e2fd..e34a50dbd74a0 100644
--- a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
+++ b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
@@ -453,13 +453,13 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
   if (T->isArrayTy()) {
     // SPIR-V 1.3 s3.32.6: Length is the number of elements in the array.
     //                     It must be at least 1.
-    const auto ArraySize = T->getArrayNumElements() ? T->getArrayNumElements() : 1;
+    const auto ArraySize =
+        T->getArrayNumElements() ? T->getArrayNumElements() : 1;
     Type *ElTy = T->getArrayElementType();
     SPIRVType *TransType = BM->addArrayType(
         transType(ElTy),
         static_cast<SPIRVConstant *>(transValue(
-            ConstantInt::get(getSizetType(), ArraySize, false),
-            nullptr)));
+            ConstantInt::get(getSizetType(), ArraySize, false), nullptr)));
     mapType(T, TransType);
     if (ElTy->isPointerTy()) {
       mapType(
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 70da0dddc225c..5b20d55816082 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -717,8 +717,7 @@ class __SYCL_EXPORT handler {
       int ArgIndex,
       const ext::oneapi::experimental::work_group_memory<DataT, PropertyListT>
           &Arg) {
-    addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg,
-           0,
+    addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg, 0,
            ArgIndex);
   }
 

From 31481b8197480970d9bd271888ac918ee083e37b Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Thu, 10 Oct 2024 21:00:13 +0200
Subject: [PATCH 052/107] Revert SPIRV translator changes

---
 clang/lib/Sema/SemaSYCL.cpp                   | 7007 -----------------
 llvm-spirv/lib/SPIRV/SPIRVWriter.cpp          |  130 +-
 .../oneapi/experimental/work_group_memory.hpp |   85 -
 3 files changed, 45 insertions(+), 7177 deletions(-)
 delete mode 100644 clang/lib/Sema/SemaSYCL.cpp
 delete mode 100644 sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
deleted file mode 100644
index d8925669b1ae3..0000000000000
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ /dev/null
@@ -1,7007 +0,0 @@
-//===- SemaSYCL.cpp - Semantic Analysis for SYCL constructs ---------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// This implements Semantic Analysis for SYCL constructs.
-//===----------------------------------------------------------------------===//
-
-#include "clang/Sema/SemaSYCL.h"
-#include "TreeTransform.h"
-#include "clang/AST/AST.h"
-#include "clang/AST/Mangle.h"
-#include "clang/AST/QualTypeNames.h"
-#include "clang/AST/RecordLayout.h"
-#include "clang/AST/RecursiveASTVisitor.h"
-#include "clang/AST/TemplateArgumentVisitor.h"
-#include "clang/AST/TypeOrdering.h"
-#include "clang/AST/TypeVisitor.h"
-#include "clang/Analysis/CallGraph.h"
-#include "clang/Basic/Attributes.h"
-#include "clang/Basic/Builtins.h"
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/TargetInfo.h"
-#include "clang/Basic/Version.h"
-#include "clang/Sema/Attr.h"
-#include "clang/Sema/Initialization.h"
-#include "clang/Sema/ParsedAttr.h"
-#include "clang/Sema/Sema.h"
-#include "llvm/ADT/APSInt.h"
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/raw_ostream.h"
-
-#include <array>
-#include <functional>
-#include <initializer_list>
-
-using namespace clang;
-using namespace std::placeholders;
-
-using KernelParamKind = SYCLIntegrationHeader::kernel_param_kind_t;
-
-enum target {
-  global_buffer = 2014,
-  constant_buffer,
-  local,
-  image,
-  host_buffer,
-  host_image,
-  image_array
-};
-
-using ParamDesc = std::tuple<QualType, IdentifierInfo *, TypeSourceInfo *>;
-
-enum KernelInvocationKind {
-  InvokeUnknown,
-  InvokeSingleTask,
-  InvokeParallelFor,
-  InvokeParallelForWorkGroup
-};
-
-static constexpr llvm::StringLiteral InitMethodName = "__init";
-static constexpr llvm::StringLiteral InitESIMDMethodName = "__init_esimd";
-static constexpr llvm::StringLiteral InitSpecConstantsBuffer =
-    "__init_specialization_constants_buffer";
-static constexpr llvm::StringLiteral FinalizeMethodName = "__finalize";
-static constexpr llvm::StringLiteral LibstdcxxFailedAssertion =
-    "__failed_assertion";
-constexpr unsigned MaxKernelArgsSize = 2048;
-
-bool SemaSYCL::isSyclType(QualType Ty, SYCLTypeAttr::SYCLType TypeName) {
-  const auto *RD = Ty->getAsCXXRecordDecl();
-  if (!RD)
-    return false;
-
-  if (const auto *Attr = RD->getAttr<SYCLTypeAttr>())
-    return Attr->getType() == TypeName;
-
-  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
-    if (CXXRecordDecl *TemplateDecl =
-            CTSD->getSpecializedTemplate()->getTemplatedDecl())
-      if (const auto *Attr = TemplateDecl->getAttr<SYCLTypeAttr>())
-        return Attr->getType() == TypeName;
-
-  return false;
-}
-
-static bool isSyclAccessorType(QualType Ty) {
-  return SemaSYCL::isSyclType(Ty, SYCLTypeAttr::accessor) ||
-         SemaSYCL::isSyclType(Ty, SYCLTypeAttr::local_accessor);
-}
-
-// FIXME: Accessor property lists should be modified to use compile-time
-// properties. Once implemented, this function (and possibly all/most code
-// in SemaSYCL.cpp handling no_alias and buffer_location property) can be
-// removed.
-static bool isAccessorPropertyType(QualType Ty,
-                                   SYCLTypeAttr::SYCLType TypeName) {
-  if (const auto *RD = Ty->getAsCXXRecordDecl())
-    if (const auto *Parent = dyn_cast<CXXRecordDecl>(RD->getParent()))
-      if (const auto *Attr = Parent->getAttr<SYCLTypeAttr>())
-        return Attr->getType() == TypeName;
-
-  return false;
-}
-
-static bool isSyclSpecialType(QualType Ty, SemaSYCL &S) {
-  return S.isTypeDecoratedWithDeclAttribute<SYCLSpecialClassAttr>(Ty);
-}
-
-ExprResult SemaSYCL::ActOnSYCLBuiltinNumFieldsExpr(ParsedType PT) {
-  TypeSourceInfo *TInfo = nullptr;
-  QualType QT = Sema::GetTypeFromParser(PT, &TInfo);
-  assert(TInfo && "couldn't get type info from a type from the parser?");
-  SourceLocation TypeLoc = TInfo->getTypeLoc().getBeginLoc();
-
-  return BuildSYCLBuiltinNumFieldsExpr(TypeLoc, QT);
-}
-
-ExprResult SemaSYCL::BuildSYCLBuiltinNumFieldsExpr(SourceLocation Loc,
-                                                   QualType SourceTy) {
-  if (!SourceTy->isDependentType()) {
-    if (SemaRef.RequireCompleteType(
-            Loc, SourceTy, diag::err_sycl_type_trait_requires_complete_type,
-            /*__builtin_num_fields*/ 0))
-      return ExprError();
-
-    if (!SourceTy->isRecordType()) {
-      Diag(Loc, diag::err_sycl_type_trait_requires_record_type)
-          << /*__builtin_num_fields*/ 0;
-      return ExprError();
-    }
-  }
-  return new (getASTContext())
-      SYCLBuiltinNumFieldsExpr(Loc, SourceTy, getASTContext().getSizeType());
-}
-
-ExprResult SemaSYCL::ActOnSYCLBuiltinFieldTypeExpr(ParsedType PT, Expr *Idx) {
-  TypeSourceInfo *TInfo = nullptr;
-  QualType QT = Sema::GetTypeFromParser(PT, &TInfo);
-  assert(TInfo && "couldn't get type info from a type from the parser?");
-  SourceLocation TypeLoc = TInfo->getTypeLoc().getBeginLoc();
-
-  return BuildSYCLBuiltinFieldTypeExpr(TypeLoc, QT, Idx);
-}
-
-ExprResult SemaSYCL::BuildSYCLBuiltinFieldTypeExpr(SourceLocation Loc,
-                                                   QualType SourceTy,
-                                                   Expr *Idx) {
-  // If the expression appears in an evaluated context, we want to give an
-  // error so that users don't attempt to use the value of this expression.
-  if (!SemaRef.isUnevaluatedContext()) {
-    Diag(Loc, diag::err_sycl_builtin_type_trait_evaluated)
-        << /*__builtin_field_type*/ 0;
-    return ExprError();
-  }
-
-  // We may not be able to calculate the field type (the source type may be a
-  // dependent type), so use the source type as a basic fallback. This will
-  // ensure that the AST node will have a dependent type that gets resolved
-  // later to the real type.
-  QualType FieldTy = SourceTy;
-  ExprValueKind ValueKind = VK_PRValue;
-  if (!SourceTy->isDependentType()) {
-    if (SemaRef.RequireCompleteType(
-            Loc, SourceTy, diag::err_sycl_type_trait_requires_complete_type,
-            /*__builtin_field_type*/ 1))
-      return ExprError();
-
-    if (!SourceTy->isRecordType()) {
-      Diag(Loc, diag::err_sycl_type_trait_requires_record_type)
-          << /*__builtin_field_type*/ 1;
-      return ExprError();
-    }
-
-    if (!Idx->isValueDependent()) {
-      std::optional<llvm::APSInt> IdxVal =
-          Idx->getIntegerConstantExpr(getASTContext());
-      if (IdxVal) {
-        RecordDecl *RD = SourceTy->getAsRecordDecl();
-        assert(RD && "Record type but no record decl?");
-        int64_t Index = IdxVal->getExtValue();
-
-        if (Index < 0) {
-          Diag(Idx->getExprLoc(),
-               diag::err_sycl_type_trait_requires_nonnegative_index)
-              << /*fields*/ 0;
-          return ExprError();
-        }
-
-        // Ensure that the index is within range.
-        int64_t NumFields = std::distance(RD->field_begin(), RD->field_end());
-        if (Index >= NumFields) {
-          Diag(Idx->getExprLoc(),
-               diag::err_sycl_builtin_type_trait_index_out_of_range)
-              << toString(*IdxVal, 10) << SourceTy << /*fields*/ 0;
-          return ExprError();
-        }
-        const FieldDecl *FD = *std::next(RD->field_begin(), Index);
-        FieldTy = FD->getType();
-
-        // If the field type was a reference type, adjust it now.
-        if (FieldTy->isLValueReferenceType()) {
-          ValueKind = VK_LValue;
-          FieldTy = FieldTy.getNonReferenceType();
-        } else if (FieldTy->isRValueReferenceType()) {
-          ValueKind = VK_XValue;
-          FieldTy = FieldTy.getNonReferenceType();
-        }
-      }
-    }
-  }
-  return new (getASTContext())
-      SYCLBuiltinFieldTypeExpr(Loc, SourceTy, Idx, FieldTy, ValueKind);
-}
-
-ExprResult SemaSYCL::ActOnSYCLBuiltinNumBasesExpr(ParsedType PT) {
-  TypeSourceInfo *TInfo = nullptr;
-  QualType QT = Sema::GetTypeFromParser(PT, &TInfo);
-  assert(TInfo && "couldn't get type info from a type from the parser?");
-  SourceLocation TypeLoc = TInfo->getTypeLoc().getBeginLoc();
-
-  return BuildSYCLBuiltinNumBasesExpr(TypeLoc, QT);
-}
-
-ExprResult SemaSYCL::BuildSYCLBuiltinNumBasesExpr(SourceLocation Loc,
-                                                  QualType SourceTy) {
-  if (!SourceTy->isDependentType()) {
-    if (SemaRef.RequireCompleteType(
-            Loc, SourceTy, diag::err_sycl_type_trait_requires_complete_type,
-            /*__builtin_num_bases*/ 2))
-      return ExprError();
-
-    if (!SourceTy->isRecordType()) {
-      Diag(Loc, diag::err_sycl_type_trait_requires_record_type)
-          << /*__builtin_num_bases*/ 2;
-      return ExprError();
-    }
-  }
-  return new (getASTContext())
-      SYCLBuiltinNumBasesExpr(Loc, SourceTy, getASTContext().getSizeType());
-}
-
-ExprResult SemaSYCL::ActOnSYCLBuiltinBaseTypeExpr(ParsedType PT, Expr *Idx) {
-  TypeSourceInfo *TInfo = nullptr;
-  QualType QT = SemaRef.GetTypeFromParser(PT, &TInfo);
-  assert(TInfo && "couldn't get type info from a type from the parser?");
-  SourceLocation TypeLoc = TInfo->getTypeLoc().getBeginLoc();
-
-  return BuildSYCLBuiltinBaseTypeExpr(TypeLoc, QT, Idx);
-}
-
-ExprResult SemaSYCL::BuildSYCLBuiltinBaseTypeExpr(SourceLocation Loc,
-                                                  QualType SourceTy,
-                                                  Expr *Idx) {
-  // If the expression appears in an evaluated context, we want to give an
-  // error so that users don't attempt to use the value of this expression.
-  if (!SemaRef.isUnevaluatedContext()) {
-    Diag(Loc, diag::err_sycl_builtin_type_trait_evaluated)
-        << /*__builtin_base_type*/ 1;
-    return ExprError();
-  }
-
-  // We may not be able to calculate the base type (the source type may be a
-  // dependent type), so use the source type as a basic fallback. This will
-  // ensure that the AST node will have a dependent type that gets resolved
-  // later to the real type.
-  QualType BaseTy = SourceTy;
-  if (!SourceTy->isDependentType()) {
-    if (SemaRef.RequireCompleteType(
-            Loc, SourceTy, diag::err_sycl_type_trait_requires_complete_type,
-            /*__builtin_base_type*/ 3))
-      return ExprError();
-
-    if (!SourceTy->isRecordType()) {
-      Diag(Loc, diag::err_sycl_type_trait_requires_record_type)
-          << /*__builtin_base_type*/ 3;
-      return ExprError();
-    }
-
-    if (!Idx->isValueDependent()) {
-      std::optional<llvm::APSInt> IdxVal =
-          Idx->getIntegerConstantExpr(getASTContext());
-      if (IdxVal) {
-        CXXRecordDecl *RD = SourceTy->getAsCXXRecordDecl();
-        assert(RD && "Record type but no record decl?");
-        int64_t Index = IdxVal->getExtValue();
-
-        if (Index < 0) {
-          Diag(Idx->getExprLoc(),
-               diag::err_sycl_type_trait_requires_nonnegative_index)
-              << /*bases*/ 1;
-          return ExprError();
-        }
-
-        // Ensure that the index is within range.
-        if (Index >= RD->getNumBases()) {
-          Diag(Idx->getExprLoc(),
-               diag::err_sycl_builtin_type_trait_index_out_of_range)
-              << toString(*IdxVal, 10) << SourceTy << /*bases*/ 1;
-          return ExprError();
-        }
-
-        const CXXBaseSpecifier &Spec = *std::next(RD->bases_begin(), Index);
-        BaseTy = Spec.getType();
-      }
-    }
-  }
-  return new (getASTContext())
-      SYCLBuiltinBaseTypeExpr(Loc, SourceTy, Idx, BaseTy);
-}
-
-/// Returns true if the target requires a new type.
-/// This happens if a pointer to generic cannot be passed
-static bool targetRequiresNewType(ASTContext &Context) {
-  llvm::Triple T = Context.getTargetInfo().getTriple();
-  return !T.isNVPTX();
-}
-
-// This information is from Section 4.13 of the SYCL spec
-// https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf
-// This function returns false if the math lib function
-// corresponding to the input builtin is not supported
-// for SYCL
-static bool IsSyclMathFunc(unsigned BuiltinID) {
-  switch (BuiltinID) {
-  case Builtin::BIlround:
-  case Builtin::BI__builtin_lround:
-  case Builtin::BIceill:
-  case Builtin::BI__builtin_ceill:
-  case Builtin::BIcopysignl:
-  case Builtin::BI__builtin_copysignl:
-  case Builtin::BIcosl:
-  case Builtin::BI__builtin_cosl:
-  case Builtin::BIexpl:
-  case Builtin::BI__builtin_expl:
-  case Builtin::BIexp2l:
-  case Builtin::BI__builtin_exp2l:
-  case Builtin::BIfabsl:
-  case Builtin::BI__builtin_fabsl:
-  case Builtin::BIfloorl:
-  case Builtin::BI__builtin_floorl:
-  case Builtin::BIfmal:
-  case Builtin::BI__builtin_fmal:
-  case Builtin::BIfmaxl:
-  case Builtin::BI__builtin_fmaxl:
-  case Builtin::BIfminl:
-  case Builtin::BI__builtin_fminl:
-  case Builtin::BIfmodl:
-  case Builtin::BI__builtin_fmodl:
-  case Builtin::BIlogl:
-  case Builtin::BI__builtin_logl:
-  case Builtin::BIlog10l:
-  case Builtin::BI__builtin_log10l:
-  case Builtin::BIlog2l:
-  case Builtin::BI__builtin_log2l:
-  case Builtin::BIpowl:
-  case Builtin::BI__builtin_powl:
-  case Builtin::BIrintl:
-  case Builtin::BI__builtin_rintl:
-  case Builtin::BIroundl:
-  case Builtin::BI__builtin_roundl:
-  case Builtin::BIsinl:
-  case Builtin::BI__builtin_sinl:
-  case Builtin::BIsqrtl:
-  case Builtin::BI__builtin_sqrtl:
-  case Builtin::BItruncl:
-  case Builtin::BI__builtin_truncl:
-  case Builtin::BIlroundl:
-  case Builtin::BI__builtin_lroundl:
-  case Builtin::BIlroundf:
-  case Builtin::BI__builtin_lroundf:
-    return false;
-  default:
-    break;
-  }
-  return true;
-}
-
-bool SemaSYCL::isDeclAllowedInSYCLDeviceCode(const Decl *D) {
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
-    const IdentifierInfo *II = FD->getIdentifier();
-
-    // Allow __builtin_assume_aligned and __builtin_printf to be called from
-    // within device code.
-    if (FD->getBuiltinID() &&
-        (FD->getBuiltinID() == Builtin::BI__builtin_assume_aligned ||
-         FD->getBuiltinID() == Builtin::BI__builtin_printf))
-      return true;
-
-    const DeclContext *DC = FD->getDeclContext();
-    if (II && II->isStr("__spirv_ocl_printf") &&
-        !FD->isDefined() &&
-        FD->getLanguageLinkage() == CXXLanguageLinkage &&
-        DC->getEnclosingNamespaceContext()->isTranslationUnit())
-      return true;
-  }
-  return false;
-}
-
-SemaSYCL::SemaSYCL(Sema &S)
-    : SemaBase(S), SyclIntHeader(nullptr), SyclIntFooter(nullptr) {}
-
-static bool isZeroSizedArray(SemaSYCL &S, QualType Ty) {
-  if (const auto *CAT = S.getASTContext().getAsConstantArrayType(Ty))
-    return CAT->isZeroSize();
-  return false;
-}
-
-static void checkSYCLType(SemaSYCL &S, QualType Ty, SourceRange Loc,
-                          llvm::DenseSet<QualType> Visited,
-                          SourceRange UsedAtLoc = SourceRange()) {
-  // Not all variable types are supported inside SYCL kernels,
-  // for example the quad type __float128 will cause errors in the
-  // SPIR-V translation phase.
-  // Here we check any potentially unsupported declaration and issue
-  // a deferred diagnostic, which will be emitted iff the declaration
-  // is discovered to reside in kernel code.
-  // The optional UsedAtLoc param is used when the SYCL usage is at a
-  // different location than the variable declaration and we need to
-  // inform the user of both, e.g. struct member usage vs declaration.
-
-  bool Emitting = false;
-
-  //--- check types ---
-
-  // zero length arrays
-  if (isZeroSizedArray(S, Ty)) {
-    S.DiagIfDeviceCode(Loc.getBegin(), diag::err_typecheck_zero_array_size)
-        << 1;
-    Emitting = true;
-  }
-
-  // variable length arrays
-  if (Ty->isVariableArrayType()) {
-    S.DiagIfDeviceCode(Loc.getBegin(), diag::err_vla_unsupported) << 0;
-    Emitting = true;
-  }
-
-  // Sub-reference array or pointer, then proceed with that type.
-  while (Ty->isAnyPointerType() || Ty->isArrayType())
-    Ty = QualType{Ty->getPointeeOrArrayElementType(), 0};
-
-  // __int128, __int128_t, __uint128_t, long double, __float128
-  if (Ty->isSpecificBuiltinType(BuiltinType::Int128) ||
-      Ty->isSpecificBuiltinType(BuiltinType::UInt128) ||
-      Ty->isSpecificBuiltinType(BuiltinType::LongDouble) ||
-      Ty->isSpecificBuiltinType(BuiltinType::BFloat16) ||
-      (Ty->isSpecificBuiltinType(BuiltinType::Float128) &&
-       !S.getASTContext().getTargetInfo().hasFloat128Type())) {
-    S.DiagIfDeviceCode(Loc.getBegin(), diag::err_type_unsupported)
-        << Ty.getUnqualifiedType().getCanonicalType();
-    Emitting = true;
-  }
-
-  if (Emitting && UsedAtLoc.isValid())
-    S.DiagIfDeviceCode(UsedAtLoc.getBegin(), diag::note_used_here);
-
-  //--- now recurse ---
-  // Pointers complicate recursion. Add this type to Visited.
-  // If already there, bail out.
-  if (!Visited.insert(Ty).second)
-    return;
-
-  if (const auto *ATy = dyn_cast<AttributedType>(Ty))
-    return checkSYCLType(S, ATy->getModifiedType(), Loc, Visited);
-
-  if (const auto *RD = Ty->getAsRecordDecl()) {
-    for (const auto &Field : RD->fields())
-      checkSYCLType(S, Field->getType(), Field->getSourceRange(), Visited, Loc);
-  } else if (const auto *FPTy = dyn_cast<FunctionProtoType>(Ty)) {
-    for (const auto &ParamTy : FPTy->param_types())
-      checkSYCLType(S, ParamTy, Loc, Visited);
-    checkSYCLType(S, FPTy->getReturnType(), Loc, Visited);
-  }
-}
-
-void SemaSYCL::checkSYCLDeviceVarDecl(VarDecl *Var) {
-  assert(getLangOpts().SYCLIsDevice &&
-         "Should only be called during SYCL compilation");
-  QualType Ty = Var->getType();
-  SourceRange Loc = Var->getLocation();
-  llvm::DenseSet<QualType> Visited;
-
-  checkSYCLType(*this, Ty, Loc, Visited);
-}
-
-enum NotForwardDeclarableReason {
-  UnscopedEnum,
-  StdNamespace,
-  UnnamedTag,
-  NotAtNamespaceScope,
-  None
-};
-
-// This is a helper function which is used to check if a class declaration is:
-//   * declared within namespace 'std' (at any level)
-//     e.g., namespace std { namespace literals { class Whatever; } }
-//     h.single_task<std::literals::Whatever>([]() {});
-//   * declared within a function
-//     e.g., void foo() { struct S { int i; };
-//     h.single_task<S>([]() {}); }
-//   * declared within another tag
-//     e.g., struct S { struct T { int i } t; };
-//     h.single_task<S::T>([]() {});
-//  User for kernel name types and class/struct types used in free function
-//  kernel arguments.
-static NotForwardDeclarableReason
-isForwardDeclarable(const NamedDecl *DeclToCheck, SemaSYCL &S,
-                    bool DiagForFreeFunction = false) {
-  if (const auto *ED = dyn_cast<EnumDecl>(DeclToCheck);
-      ED && !ED->isScoped() && !ED->isFixed())
-    return NotForwardDeclarableReason::UnscopedEnum;
-
-  const DeclContext *DeclCtx = DeclToCheck->getDeclContext();
-  if (DeclCtx) {
-    while (!DeclCtx->isTranslationUnit() &&
-           (isa<NamespaceDecl>(DeclCtx) || isa<LinkageSpecDecl>(DeclCtx))) {
-      const auto *NSDecl = dyn_cast<NamespaceDecl>(DeclCtx);
-      // We don't report free function kernel parameter case because the
-      // restriction for the type used there to be forward declarable comes from
-      // the need to forward declare it in the integration header. We're safe
-      // to do so because the integration header is an implemention detail and
-      // is generated by the compiler.
-      // We do diagnose case with kernel name type since the spec requires us to
-      // do so.
-      if (!DiagForFreeFunction && NSDecl && NSDecl->isStdNamespace())
-        return NotForwardDeclarableReason::StdNamespace;
-      DeclCtx = DeclCtx->getParent();
-    }
-  }
-
-  // Check if the we've met a Tag declaration local to a non-namespace scope
-  // (i.e. Inside a function or within another Tag etc).
-  if (const auto *Tag = dyn_cast<TagDecl>(DeclToCheck)) {
-    if (Tag->getIdentifier() == nullptr)
-      return NotForwardDeclarableReason::UnnamedTag;
-    if (!DeclCtx->isTranslationUnit()) {
-      // Diagnose used types without complete definition i.e.
-      //   int main() {
-      //     class KernelName1;
-      //     parallel_for<class KernelName1>(..);
-      //   }
-      // For kernel name type This case can only be diagnosed during host
-      // compilation because the integration header is required to distinguish
-      // between the invalid code (above) and the following valid code:
-      //   int main() {
-      //     parallel_for<class KernelName2>(..);
-      //   }
-      // The device compiler forward declares both KernelName1 and
-      // KernelName2 in the integration header as ::KernelName1 and
-      // ::KernelName2. The problem with the former case is the additional
-      // declaration 'class KernelName1' in non-global scope. Lookup in this
-      // case will resolve to ::main::KernelName1 (instead of
-      // ::KernelName1). Since this is not visible to runtime code that
-      // submits kernels, this is invalid.
-      if (Tag->isCompleteDefinition() ||
-          S.getLangOpts().SYCLEnableIntHeaderDiags || DiagForFreeFunction)
-        return NotForwardDeclarableReason::NotAtNamespaceScope;
-    }
-  }
-
-  return NotForwardDeclarableReason::None;
-}
-
-// Tests whether given function is a lambda function or '()' operator used as
-// SYCL kernel body function (e.g. in parallel_for).
-// NOTE: This is incomplete implemenation. See TODO in the FE TODO list for the
-// ESIMD extension.
-static bool isSYCLKernelBodyFunction(FunctionDecl *FD) {
-  return FD->getOverloadedOperator() == OO_Call;
-}
-
-static bool isSYCLUndefinedAllowed(const FunctionDecl *Callee,
-                                   const SourceManager &SrcMgr) {
-  if (!Callee)
-    return false;
-
-  // The check below requires declaration name, make sure we have it.
-  if (!Callee->getIdentifier())
-    return false;
-
-  // libstdc++-11 introduced an undefined function "void __failed_assertion()"
-  // which may lead to SemaSYCL check failure. However, this undefined function
-  // is used to trigger some compilation error when the check fails at compile
-  // time and will be ignored when the check succeeds. We allow calls to this
-  // function to support some important std functions in SYCL device.
-  return (Callee->getName() == LibstdcxxFailedAssertion) &&
-         Callee->getNumParams() == 0 && Callee->getReturnType()->isVoidType() &&
-         SrcMgr.isInSystemHeader(Callee->getLocation());
-}
-
-// Helper function to report conflicting function attributes.
-// F - the function, A1 - function attribute, A2 - the attribute it conflicts
-// with.
-static void reportConflictingAttrs(SemaSYCL &S, FunctionDecl *F, const Attr *A1,
-                                   const Attr *A2) {
-  S.Diag(F->getLocation(), diag::err_conflicting_sycl_kernel_attributes);
-  S.Diag(A1->getLocation(), diag::note_conflicting_attribute);
-  S.Diag(A2->getLocation(), diag::note_conflicting_attribute);
-  F->setInvalidDecl();
-}
-
-/// Returns the signed constant integer value represented by given expression
-static int64_t getIntExprValue(const Expr *E, ASTContext &Ctx) {
-  return E->getIntegerConstantExpr(Ctx)->getSExtValue();
-}
-
-// Collect function attributes related to SYCL.
-static void collectSYCLAttributes(SemaSYCL &S, FunctionDecl *FD,
-                                  llvm::SmallVectorImpl<Attr *> &Attrs,
-                                  bool DirectlyCalled) {
-  if (!FD->hasAttrs())
-    return;
-
-  // In SYCL 2020 mode, the attributes aren't propagated from the function they
-  // are applied on to the kernel which calls the function.
-  if (DirectlyCalled) {
-    llvm::copy_if(FD->getAttrs(), std::back_inserter(Attrs), [](Attr *A) {
-      // FIXME: Make this list self-adapt as new SYCL attributes are added.
-      return isa<IntelReqdSubGroupSizeAttr, IntelNamedSubGroupSizeAttr,
-                 SYCLReqdWorkGroupSizeAttr, SYCLWorkGroupSizeHintAttr,
-                 SYCLIntelKernelArgsRestrictAttr, SYCLIntelNumSimdWorkItemsAttr,
-                 SYCLIntelSchedulerTargetFmaxMhzAttr,
-                 SYCLIntelMaxWorkGroupSizeAttr, SYCLIntelMaxGlobalWorkDimAttr,
-                 SYCLIntelMinWorkGroupsPerComputeUnitAttr,
-                 SYCLIntelMaxWorkGroupsPerMultiprocessorAttr,
-                 SYCLIntelNoGlobalWorkOffsetAttr, SYCLSimdAttr,
-                 SYCLIntelLoopFuseAttr, SYCLIntelMaxConcurrencyAttr,
-                 SYCLIntelDisableLoopPipeliningAttr,
-                 SYCLIntelInitiationIntervalAttr,
-                 SYCLIntelUseStallEnableClustersAttr, SYCLDeviceHasAttr,
-                 SYCLAddIRAttributesFunctionAttr>(A);
-    });
-  }
-}
-
-class DiagDeviceFunction : public RecursiveASTVisitor<DiagDeviceFunction> {
-  SemaSYCL &SemaSYCLRef;
-  const llvm::SmallPtrSetImpl<const FunctionDecl *> &RecursiveFuncs;
-
-public:
-  DiagDeviceFunction(
-      SemaSYCL &S,
-      const llvm::SmallPtrSetImpl<const FunctionDecl *> &RecursiveFuncs)
-      : RecursiveASTVisitor(), SemaSYCLRef(S), RecursiveFuncs(RecursiveFuncs) {}
-
-  void CheckBody(Stmt *ToBeDiagnosed) { TraverseStmt(ToBeDiagnosed); }
-
-  bool VisitCallExpr(CallExpr *e) {
-    if (FunctionDecl *Callee = e->getDirectCallee()) {
-      Callee = Callee->getCanonicalDecl();
-      assert(Callee && "Device function canonical decl must be available");
-
-      // Remember that all SYCL kernel functions have deferred
-      // instantiation as template functions. It means that
-      // all functions used by kernel have already been parsed and have
-      // definitions.
-      if (RecursiveFuncs.count(Callee)) {
-        SemaSYCLRef.Diag(e->getExprLoc(), diag::err_sycl_restrict)
-            << SemaSYCL::KernelCallRecursiveFunction;
-        SemaSYCLRef.Diag(Callee->getSourceRange().getBegin(),
-                         diag::note_sycl_recursive_function_declared_here)
-            << SemaSYCL::KernelCallRecursiveFunction;
-      }
-
-      // Specifically check if the math library function corresponding to this
-      // builtin is supported for SYCL
-      unsigned BuiltinID = Callee->getBuiltinID();
-      if (BuiltinID && !IsSyclMathFunc(BuiltinID)) {
-        StringRef Name =
-            SemaSYCLRef.getASTContext().BuiltinInfo.getName(BuiltinID);
-        SemaSYCLRef.Diag(e->getExprLoc(), diag::err_builtin_target_unsupported)
-            << Name << "SYCL device";
-      }
-    } else if (!SemaSYCLRef.getLangOpts().SYCLAllowFuncPtr &&
-               !e->isTypeDependent() &&
-               !isa<CXXPseudoDestructorExpr>(e->getCallee())) {
-      bool MaybeConstantExpr = false;
-      Expr *NonDirectCallee = e->getCallee();
-      if (!NonDirectCallee->isValueDependent())
-        MaybeConstantExpr =
-            NonDirectCallee->isCXX11ConstantExpr(SemaSYCLRef.getASTContext());
-      if (!MaybeConstantExpr)
-        SemaSYCLRef.Diag(e->getExprLoc(), diag::err_sycl_restrict)
-            << SemaSYCL::KernelCallFunctionPointer;
-    }
-    return true;
-  }
-
-  bool VisitCXXTypeidExpr(CXXTypeidExpr *E) {
-    SemaSYCLRef.Diag(E->getExprLoc(), diag::err_sycl_restrict)
-        << SemaSYCL::KernelRTTI;
-    return true;
-  }
-
-  bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
-    SemaSYCLRef.Diag(E->getExprLoc(), diag::err_sycl_restrict)
-        << SemaSYCL::KernelRTTI;
-    return true;
-  }
-
-  // Skip checking rules on variables initialized during constant evaluation.
-  bool TraverseVarDecl(VarDecl *VD) {
-    if (VD->isConstexpr())
-      return true;
-    return RecursiveASTVisitor::TraverseVarDecl(VD);
-  }
-
-  // Skip checking rules on template arguments, since these are constant
-  // expressions.
-  bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
-    return true;
-  }
-
-  // Skip checking the static assert, both components are required to be
-  // constant expressions.
-  bool TraverseStaticAssertDecl(StaticAssertDecl *D) { return true; }
-
-  // Make sure we skip the condition of the case, since that is a constant
-  // expression.
-  bool TraverseCaseStmt(CaseStmt *S) {
-    return TraverseStmt(S->getSubStmt());
-  }
-
-  // Skip checking the size expr, since a constant array type loc's size expr is
-  // a constant expression.
-  bool TraverseConstantArrayTypeLoc(const ConstantArrayTypeLoc &ArrLoc) {
-    return true;
-  }
-
-  bool TraverseIfStmt(IfStmt *S) {
-    if (std::optional<Stmt *> ActiveStmt =
-            S->getNondiscardedCase(SemaSYCLRef.getASTContext())) {
-      if (*ActiveStmt)
-        return TraverseStmt(*ActiveStmt);
-      return true;
-    }
-    return RecursiveASTVisitor::TraverseIfStmt(S);
-  }
-};
-
-// This type manages the list of device functions and recursive functions, as
-// well as an entry point for attribute collection, for the translation unit
-// during MarkDevices. On construction, this type makes sure that all of the
-// root-device functions, (that is, those marked with SYCL_EXTERNAL) are
-// collected.  On destruction, it manages and runs the diagnostics required.
-// When processing individual kernel/external functions, the
-// SingleDeviceFunctionTracker type updates this type.
-class DeviceFunctionTracker {
-  friend class SingleDeviceFunctionTracker;
-  CallGraph CG;
-  SemaSYCL &SemaSYCLRef;
-  // The list of functions used on the device, kept so we can diagnose on them
-  // later.
-  llvm::SmallPtrSet<FunctionDecl *, 16> DeviceFunctions;
-  llvm::SmallPtrSet<const FunctionDecl *, 16> RecursiveFunctions;
-
-  void CollectSyclExternalFuncs() {
-    for (CallGraphNode::CallRecord Record : CG.getRoot()->callees())
-      if (auto *FD = dyn_cast<FunctionDecl>(Record.Callee->getDecl()))
-        if (FD->hasBody() && FD->hasAttr<SYCLDeviceAttr>())
-          SemaSYCLRef.addSyclDeviceDecl(FD);
-  }
-
-  CallGraphNode *getNodeForKernel(FunctionDecl *Kernel) {
-    assert(CG.getNode(Kernel) && "No call graph entry for a kernel?");
-    return CG.getNode(Kernel);
-  }
-
-  void AddSingleFunction(
-      const llvm::SmallPtrSetImpl<FunctionDecl *> &DevFuncs,
-      const llvm::SmallPtrSetImpl<const FunctionDecl *> &Recursive) {
-    DeviceFunctions.insert(DevFuncs.begin(), DevFuncs.end());
-    RecursiveFunctions.insert(Recursive.begin(), Recursive.end());
-  }
-
-public:
-  DeviceFunctionTracker(SemaSYCL &S) : SemaSYCLRef(S) {
-    CG.setSkipConstantExpressions(S.getASTContext());
-    CG.addToCallGraph(S.getASTContext().getTranslationUnitDecl());
-    CollectSyclExternalFuncs();
-  }
-
-  ~DeviceFunctionTracker() {
-    DiagDeviceFunction Diagnoser{SemaSYCLRef, RecursiveFunctions};
-    for (const FunctionDecl *FD : DeviceFunctions)
-      if (const FunctionDecl *Def = FD->getDefinition())
-        Diagnoser.CheckBody(Def->getBody());
-  }
-};
-
-/// This function checks whether given DeclContext contains a topmost
-/// namespace with name "sycl".
-static bool isDeclaredInSYCLNamespace(const Decl *D) {
-  const DeclContext *DC = D->getDeclContext()->getEnclosingNamespaceContext();
-  const auto *ND = dyn_cast<NamespaceDecl>(DC);
-  // If this is not a namespace, then we are done.
-  if (!ND)
-    return false;
-
-  // While it is a namespace, find its parent scope.
-  while (const DeclContext *Parent = ND->getParent()) {
-    if (!isa<NamespaceDecl>(Parent))
-      break;
-    ND = cast<NamespaceDecl>(Parent);
-  }
-
-  return ND && ND->getName() == "sycl";
-}
-
-static bool isSYCLPrivateMemoryVar(VarDecl *VD) {
-  return SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::private_memory);
-}
-
-static void addScopeAttrToLocalVars(FunctionDecl &F) {
-  for (Decl *D : F.decls()) {
-    VarDecl *VD = dyn_cast<VarDecl>(D);
-
-    if (!VD || isa<ParmVarDecl>(VD) ||
-        VD->getStorageDuration() != StorageDuration::SD_Automatic)
-      continue;
-    // Local variables of private_memory type in the WG scope still have WI
-    // scope, all the rest - WG scope. Simple logic
-    // "if no scope than it is WG scope" won't work, because compiler may add
-    // locals not declared in user code (lambda object parameter, byval
-    // arguments) which will result in alloca w/o any attribute, so need WI
-    // scope too.
-    SYCLScopeAttr::Level L = isSYCLPrivateMemoryVar(VD)
-                                 ? SYCLScopeAttr::Level::WorkItem
-                                 : SYCLScopeAttr::Level::WorkGroup;
-    VD->addAttr(SYCLScopeAttr::CreateImplicit(F.getASTContext(), L));
-  }
-}
-
-// This type does the heavy lifting for the management of device functions,
-// recursive function detection, and attribute collection for a single
-// kernel/external function. It walks the callgraph to find all functions that
-// are called, marks the recursive-functions, and figures out the list of
-// attributes that apply to this kernel.
-//
-// Upon destruction, this type updates the DeviceFunctionTracker.
-class SingleDeviceFunctionTracker {
-  DeviceFunctionTracker &Parent;
-  FunctionDecl *SYCLKernel = nullptr;
-  FunctionDecl *KernelBody = nullptr;
-  llvm::SmallPtrSet<FunctionDecl *, 16> DeviceFunctions;
-  llvm::SmallPtrSet<const FunctionDecl *, 16> RecursiveFunctions;
-  llvm::SmallVector<Attr *> CollectedAttributes;
-
-  FunctionDecl *GetFDFromNode(CallGraphNode *Node) {
-    FunctionDecl *FD = Node->getDecl()->getAsFunction();
-    if (!FD)
-      return nullptr;
-
-    return FD->getMostRecentDecl();
-  }
-
-  void VisitCallNode(CallGraphNode *Node, FunctionDecl *CurrentDecl,
-                     llvm::SmallVectorImpl<FunctionDecl *> &CallStack) {
-    // If this isn't a function, I don't think there is anything we can do here.
-    if (!CurrentDecl)
-      return;
-
-    // Determine if this is a recursive function. If so, we're done.
-    if (llvm::is_contained(CallStack, CurrentDecl)) {
-      RecursiveFunctions.insert(CurrentDecl->getCanonicalDecl());
-      return;
-    }
-
-    // If this is a routine that is not defined and it does not have either
-    // a SYCLKernel or SYCLDevice attribute on it, add it to the set of
-    // routines potentially reachable on device. This is to diagnose such
-    // cases later in finalizeSYCLDelayedAnalysis().
-    if (!CurrentDecl->isDefined() && !CurrentDecl->hasAttr<SYCLKernelAttr>() &&
-        !CurrentDecl->hasAttr<SYCLDeviceAttr>())
-      Parent.SemaSYCLRef.addFDToReachableFromSyclDevice(CurrentDecl,
-                                                        CallStack.back());
-
-    // If this is a parallel_for_work_item that is declared in the
-    // sycl namespace, mark it with the WorkItem scope attribute.
-    // Note: Here, we assume that this is called from within a
-    // parallel_for_work_group; it is undefined to call it otherwise.
-    // We deliberately do not diagnose a violation.
-    // The following changes have also been added:
-    // 1. The function inside which the parallel_for_work_item exists is
-    //    marked with WorkGroup scope attribute, if not present already.
-    // 2. The local variables inside the function are marked with appropriate
-    //    scope.
-    if (CurrentDecl->getIdentifier() &&
-        CurrentDecl->getIdentifier()->getName() == "parallel_for_work_item" &&
-        isDeclaredInSYCLNamespace(CurrentDecl) &&
-        !CurrentDecl->hasAttr<SYCLScopeAttr>()) {
-      CurrentDecl->addAttr(SYCLScopeAttr::CreateImplicit(
-          Parent.SemaSYCLRef.getASTContext(), SYCLScopeAttr::Level::WorkItem));
-      FunctionDecl *Caller = CallStack.back();
-      if (!Caller->hasAttr<SYCLScopeAttr>()) {
-        Caller->addAttr(
-            SYCLScopeAttr::CreateImplicit(Parent.SemaSYCLRef.getASTContext(),
-                                          SYCLScopeAttr::Level::WorkGroup));
-        addScopeAttrToLocalVars(*Caller);
-      }
-    }
-
-    // We previously thought we could skip this function if we'd seen it before,
-    // but if we haven't seen it before in this call graph, we can end up
-    // missing a recursive call.  SO, we have to revisit call-graphs we've
-    // already seen, just in case it ALSO has recursion.  For example:
-    // void recurse1();
-    // void recurse2() { recurse1(); }
-    // void recurse1() { recurse2(); }
-    // void CallerInKernel() { recurse1(); recurse2(); }
-    // When checking 'recurse1', we'd have ended up 'visiting' recurse2 without
-    // realizing it was recursive, since we never went into the
-    // child-of-its-child, since THAT was recursive and exited early out of
-    // necessity.
-    // Then when we go to visit the kernel's call to recurse2, we would
-    // immediately escape not noticing it was recursive. SO, we have to do a
-    // little extra work in this case, and make sure we visit the entire call
-    // graph.
-    DeviceFunctions.insert(CurrentDecl);
-
-    // Collect attributes for functions that aren't the root kernel.
-    if (!CallStack.empty()) {
-      bool DirectlyCalled = CallStack.size() == 1;
-      collectSYCLAttributes(Parent.SemaSYCLRef, CurrentDecl,
-                            CollectedAttributes, DirectlyCalled);
-    }
-
-    // Calculate the kernel body.  Note the 'isSYCLKernelBodyFunction' only
-    // tests that it is operator(), so hopefully this doesn't get us too many
-    // false-positives.
-    if (isSYCLKernelBodyFunction(CurrentDecl)) {
-      // This is a direct callee of the kernel.
-      if (CallStack.size() == 1 &&
-          CallStack.back()->hasAttr<SYCLKernelAttr>()) {
-        assert(!KernelBody && "inconsistent call graph - only one kernel body "
-                              "function can be called");
-        KernelBody = CurrentDecl;
-      } else if (CallStack.size() == 2 && KernelBody == CallStack.back()) {
-        // To implement rounding-up of a parallel-for range the
-        // SYCL header implementation modifies the kernel call like this:
-        // auto Wrapper = [=](TransformedArgType Arg) {
-        //  if (Arg[0] >= NumWorkItems[0])
-        //    return;
-        //  Arg.set_allowed_range(NumWorkItems);
-        //  KernelFunc(Arg);
-        // };
-        //
-        // This transformation leads to a condition where a kernel body
-        // function becomes callable from a new kernel body function.
-        // Hence this test.
-        // FIXME: We need to be more selective here, this can be hit by simply
-        // having a kernel lambda with a lambda call inside of it.
-        KernelBody = CurrentDecl;
-      }
-      if (KernelBody)
-        Parent.SemaSYCLRef.addSYCLKernelFunction(KernelBody);
-    }
-
-    // Recurse.
-    CallStack.push_back(CurrentDecl);
-    llvm::SmallPtrSet<FunctionDecl *, 16> SeenCallees;
-    for (CallGraphNode *CI : Node->callees()) {
-      FunctionDecl *CurFD = GetFDFromNode(CI);
-
-      // Make sure we only visit each callee 1x from this function to avoid very
-      // time consuming template recursion cases.
-      if (!llvm::is_contained(SeenCallees, CurFD)) {
-        VisitCallNode(CI, CurFD, CallStack);
-        SeenCallees.insert(CurFD);
-      }
-    }
-    CallStack.pop_back();
-  }
-
-  // Function to walk the call graph and identify the important information.
-  void Init() {
-    CallGraphNode *KernelNode = Parent.getNodeForKernel(SYCLKernel);
-    llvm::SmallVector<FunctionDecl *> CallStack;
-    VisitCallNode(KernelNode, GetFDFromNode(KernelNode), CallStack);
-
-    // Always inline the KernelBody in the kernel entry point. For ESIMD
-    // inlining is handled later down the pipeline.
-    if (KernelBody &&
-        Parent.SemaSYCLRef.getLangOpts().SYCLForceInlineKernelLambda &&
-        !KernelBody->hasAttr<NoInlineAttr>() &&
-        !KernelBody->hasAttr<AlwaysInlineAttr>() &&
-        !KernelBody->hasAttr<SYCLSimdAttr>()) {
-      KernelBody->addAttr(AlwaysInlineAttr::CreateImplicit(
-          KernelBody->getASTContext(), {}, AlwaysInlineAttr::Keyword_forceinline));
-    }
-  }
-
-public:
-  SingleDeviceFunctionTracker(DeviceFunctionTracker &P, Decl *Kernel)
-      : Parent(P), SYCLKernel(Kernel->getAsFunction()) {
-    Init();
-  }
-
-  FunctionDecl *GetSYCLKernel() { return SYCLKernel; }
-
-  FunctionDecl *GetKernelBody() { return KernelBody; }
-
-  llvm::SmallVectorImpl<Attr *> &GetCollectedAttributes() {
-    return CollectedAttributes;
-  }
-
-  llvm::SmallPtrSetImpl<FunctionDecl *> &GetDeviceFunctions() {
-    return DeviceFunctions;
-  }
-
-  ~SingleDeviceFunctionTracker() {
-    Parent.AddSingleFunction(DeviceFunctions, RecursiveFunctions);
-  }
-};
-
-class KernelBodyTransform : public TreeTransform<KernelBodyTransform> {
-public:
-  KernelBodyTransform(std::pair<DeclaratorDecl *, DeclaratorDecl *> &MPair,
-                      Sema &S)
-      : TreeTransform<KernelBodyTransform>(S), MappingPair(MPair), SemaRef(S) {}
-  bool AlwaysRebuild() { return true; }
-
-  ExprResult TransformDeclRefExpr(DeclRefExpr *DRE) {
-    auto Ref = dyn_cast<DeclaratorDecl>(DRE->getDecl());
-    if (Ref && Ref == MappingPair.first) {
-      auto NewDecl = MappingPair.second;
-      return DeclRefExpr::Create(
-          SemaRef.getASTContext(), DRE->getQualifierLoc(),
-          DRE->getTemplateKeywordLoc(), NewDecl, false, DRE->getNameInfo(),
-          NewDecl->getType(), DRE->getValueKind());
-    }
-    return DRE;
-  }
-
-private:
-  std::pair<DeclaratorDecl *, DeclaratorDecl *> MappingPair;
-  Sema &SemaRef;
-};
-
-/// Creates a kernel parameter descriptor
-/// \param Src  field declaration to construct name from
-/// \param Ty   the desired parameter type
-/// \return     the constructed descriptor
-static ParamDesc makeParamDesc(const FieldDecl *Src, QualType Ty) {
-  ASTContext &Ctx = Src->getASTContext();
-  std::string Name = (Twine("_arg_") + Src->getName()).str();
-  return std::make_tuple(Ty, &Ctx.Idents.get(Name),
-                         Ctx.getTrivialTypeSourceInfo(Ty));
-}
-static ParamDesc makeParamDesc(const ParmVarDecl *Src, QualType Ty) {
-  ASTContext &Ctx = Src->getASTContext();
-  std::string Name = (Twine("__arg_") + Src->getName()).str();
-  return std::make_tuple(Ty, &Ctx.Idents.get(Name),
-                         Ctx.getTrivialTypeSourceInfo(Ty));
-}
-
-static ParamDesc makeParamDesc(ASTContext &Ctx, StringRef Name, QualType Ty) {
-  return std::make_tuple(Ty, &Ctx.Idents.get(Name),
-                         Ctx.getTrivialTypeSourceInfo(Ty));
-}
-
-static void unsupportedFreeFunctionParamType() {
-  llvm::report_fatal_error("Only scalars and pointers are permitted as "
-                           "free function parameters");
-}
-
-class MarkWIScopeFnVisitor : public RecursiveASTVisitor<MarkWIScopeFnVisitor> {
-public:
-  MarkWIScopeFnVisitor(ASTContext &Ctx) : Ctx(Ctx) {}
-
-  bool VisitCXXMemberCallExpr(CXXMemberCallExpr *Call) {
-    FunctionDecl *Callee = Call->getDirectCallee();
-    if (!Callee)
-      // not a direct call - continue search
-      return true;
-    QualType Ty = Ctx.getRecordType(Call->getRecordDecl());
-    if (!SemaSYCL::isSyclType(Ty, SYCLTypeAttr::group))
-      // not a member of sycl::group - continue search
-      return true;
-    auto Name = Callee->getName();
-    if (Name != "wait_for" ||
-        Callee->hasAttr<SYCLScopeAttr>())
-      return true;
-    // it is a call to sycl::group::wait_for - mark the callee
-    Callee->addAttr(
-        SYCLScopeAttr::CreateImplicit(Ctx, SYCLScopeAttr::Level::WorkItem));
-    // continue search as there can be other wait_for calls
-    return true;
-  }
-
-private:
-  ASTContext &Ctx;
-};
-
-/// Return method by name
-static CXXMethodDecl *getMethodByName(const CXXRecordDecl *CRD,
-                                      StringRef MethodName) {
-  CXXMethodDecl *Method;
-  auto It = std::find_if(CRD->methods().begin(), CRD->methods().end(),
-                         [MethodName](const CXXMethodDecl *Method) {
-                           return Method->getNameAsString() == MethodName;
-                         });
-  Method = (It != CRD->methods().end()) ? *It : nullptr;
-  return Method;
-}
-
-static KernelInvocationKind
-getKernelInvocationKind(FunctionDecl *KernelCallerFunc) {
-  return llvm::StringSwitch<KernelInvocationKind>(KernelCallerFunc->getName())
-      .Case("kernel_single_task", InvokeSingleTask)
-      .Case("kernel_parallel_for", InvokeParallelFor)
-      .Case("kernel_parallel_for_work_group", InvokeParallelForWorkGroup)
-      .Default(InvokeUnknown);
-}
-
-// The SYCL kernel's 'object type' used for diagnostics and naming/mangling is
-// the first parameter to a function template using the sycl_kernel
-// attribute. In SYCL 1.2.1, this was passed by value,
-// and in SYCL 2020, it is passed by reference.
-static QualType GetSYCLKernelObjectType(const FunctionDecl *KernelCaller) {
-  assert(KernelCaller->getNumParams() > 0 && "Insufficient kernel parameters");
-  QualType KernelParamTy = KernelCaller->getParamDecl(0)->getType();
-
-  // SYCL 2020 kernels are passed by reference.
-  if (KernelParamTy->isReferenceType())
-    KernelParamTy = KernelParamTy->getPointeeType();
-
-  // SYCL 1.2.1
-  return KernelParamTy.getUnqualifiedType();
-}
-
-/// \return the target of given SYCL accessor type
-static target getAccessTarget(QualType FieldTy,
-                              const ClassTemplateSpecializationDecl *AccTy) {
-  if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::local_accessor))
-    return local;
-
-  return static_cast<target>(
-      AccTy->getTemplateArgs()[3].getAsIntegral().getExtValue());
-}
-
-// FIXME: Free functions must have void return type and be declared at file
-// scope, outside any namespaces.
-static bool isFreeFunction(SemaSYCL &SemaSYCLRef, const FunctionDecl *FD) {
-  for (auto *IRAttr : FD->specific_attrs<SYCLAddIRAttributesFunctionAttr>()) {
-    SmallVector<std::pair<std::string, std::string>, 4> NameValuePairs =
-        IRAttr->getAttributeNameValuePairs(SemaSYCLRef.getASTContext());
-    for (const auto &NameValuePair : NameValuePairs) {
-      if (NameValuePair.first == "sycl-nd-range-kernel" ||
-          NameValuePair.first == "sycl-single-task-kernel") {
-        if (!FD->getReturnType()->isVoidType()) {
-          llvm::report_fatal_error(
-              "Only functions at file scope with void return "
-              "type are permitted as free functions");
-          return false;
-        }
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-static int getFreeFunctionRangeDim(SemaSYCL &SemaSYCLRef,
-                                   const FunctionDecl *FD) {
-  for (auto *IRAttr : FD->specific_attrs<SYCLAddIRAttributesFunctionAttr>()) {
-    SmallVector<std::pair<std::string, std::string>, 4> NameValuePairs =
-        IRAttr->getAttributeNameValuePairs(SemaSYCLRef.getASTContext());
-    for (const auto &NameValuePair : NameValuePairs) {
-      if (NameValuePair.first == "sycl-nd-range-kernel")
-        return std::stoi(NameValuePair.second);
-      if (NameValuePair.first == "sycl-single-task-kernel")
-        return 0;
-    }
-  }
-  return false;
-}
-
-// Creates a name for the free function kernel function.
-// Consider a free function named "MyFunction". The normal device function will
-// be given its mangled name, say "_Z10MyFunctionIiEvPT_S0_". The corresponding
-// kernel function for this free function will be named
-// "_Z24__sycl_kernel_MyFunctionIiEvPT_S0_". This is the mangled name of a
-// fictitious function that has the same template and function parameters as the
-// original free function but with identifier prefixed with __sycl_kernel_.
-// We generate this name by starting with the mangled name of the free function
-// and adjusting it textually to simulate the __sycl_kernel_ prefix.
-// Because free functions are allowed only at file scope and cannot be within
-// namespaces the mangled name has the format _Z<length><identifier>... where
-// length is the identifier's length. The text manipulation inserts the prefix
-// __sycl_kernel_ and adjusts the length, leaving the rest of the name as-is.
-static std::pair<std::string, std::string> constructFreeFunctionKernelName(
-    SemaSYCL &SemaSYCLRef, const FunctionDecl *FreeFunc, MangleContext &MC) {
-  SmallString<256> Result;
-  llvm::raw_svector_ostream Out(Result);
-  std::string NewName;
-  std::string StableName;
-
-  // Handle extern "C"
-  if (FreeFunc->getLanguageLinkage() == CLanguageLinkage) {
-    const IdentifierInfo *II = FreeFunc->getIdentifier();
-    NewName = "__sycl_kernel_" + II->getName().str();
-  } else {
-    MC.mangleName(FreeFunc, Out);
-    std::string MangledName(Out.str());
-    size_t StartNums = MangledName.find_first_of("0123456789");
-    size_t EndNums = MangledName.find_first_not_of("0123456789", StartNums);
-    size_t NameLength =
-        std::stoi(MangledName.substr(StartNums, EndNums - StartNums));
-    size_t NewNameLength = 14 /*length of __sycl_kernel_*/ + NameLength;
-    NewName = MangledName.substr(0, StartNums) + std::to_string(NewNameLength) +
-              "__sycl_kernel_" + MangledName.substr(EndNums);
-  }
-  StableName = NewName;
-  return {NewName, StableName};
-}
-
-// The first template argument to the kernel caller function is used to identify
-// the kernel itself.
-static QualType calculateKernelNameType(ASTContext &Ctx,
-                                        const FunctionDecl *KernelCallerFunc) {
-  const TemplateArgumentList *TAL =
-      KernelCallerFunc->getTemplateSpecializationArgs();
-  assert(TAL && "No template argument info");
-  return TAL->get(0).getAsType().getCanonicalType();
-}
-
-// Gets a name for the OpenCL kernel function, calculated from the first
-// template argument of the kernel caller function.
-static std::pair<std::string, std::string>
-constructKernelName(SemaSYCL &S, const FunctionDecl *KernelCallerFunc,
-                    MangleContext &MC) {
-  QualType KernelNameType =
-      calculateKernelNameType(S.getASTContext(), KernelCallerFunc);
-
-  SmallString<256> Result;
-  llvm::raw_svector_ostream Out(Result);
-
-  MC.mangleCanonicalTypeName(KernelNameType, Out);
-  std::string MangledName(Out.str());
-
-  std::string StableName =
-      SYCLUniqueStableNameExpr::ComputeName(S.getASTContext(), KernelNameType);
-
-  // For NativeCPU the kernel name is set to the stable GNU-mangled name
-  // because the default mangling may be different, for example on Windows.
-  // This is needed for compiling kernels for multiple SYCL targets to ensure
-  // the same kernel name can be used for kernel lookup in different target
-  // binaries. This assumes that all SYCL targets use the same mangling
-  // produced for the stable name.
-  // Todo: Check if this assumption is valid, and if it would be better
-  // instead to always compile the NativeCPU device code in GNU mode which
-  // may cause issues when compiling headers with non-standard extensions
-  // written for compilers with different C++ ABIs (like MS VS).
-  if (S.getLangOpts().SYCLIsNativeCPU) {
-    MangledName = StableName;
-  }
-
-  return {MangledName, StableName};
-}
-
-static bool isDefaultSPIRArch(ASTContext &Context) {
-  llvm::Triple T = Context.getTargetInfo().getTriple();
-  if (T.isSPIR() && T.getSubArch() == llvm::Triple::NoSubArch)
-    return true;
-  return false;
-}
-
-static ParmVarDecl *getSyclKernelHandlerArg(FunctionDecl *KernelCallerFunc) {
-  // Specialization constants in SYCL 2020 are not captured by lambda and
-  // accessed through new optional lambda argument kernel_handler
-  auto IsHandlerLambda = [](ParmVarDecl *PVD) {
-    return SemaSYCL::isSyclType(PVD->getType(), SYCLTypeAttr::kernel_handler);
-  };
-
-  assert(llvm::count_if(KernelCallerFunc->parameters(), IsHandlerLambda) <= 1 &&
-         "Multiple kernel_handler parameters");
-
-  auto KHArg = llvm::find_if(KernelCallerFunc->parameters(), IsHandlerLambda);
-
-  return (KHArg != KernelCallerFunc->param_end()) ? *KHArg : nullptr;
-}
-
-static bool isReadOnlyAccessor(const TemplateArgument &AccessModeArg) {
-  const auto *AccessModeArgEnumType =
-      AccessModeArg.getIntegralType()->castAs<EnumType>();
-  const EnumDecl *ED = AccessModeArgEnumType->getDecl();
-
-  auto ReadOnly =
-      llvm::find_if(ED->enumerators(), [&](const EnumConstantDecl *E) {
-        return E->getName() == "read";
-      });
-
-  return ReadOnly != ED->enumerator_end() &&
-         (*ReadOnly)->getInitVal() == AccessModeArg.getAsIntegral();
-}
-
-// anonymous namespace so these don't get linkage.
-namespace {
-
-template <typename T> struct bind_param { using type = T; };
-
-template <> struct bind_param<CXXBaseSpecifier &> {
-  using type = const CXXBaseSpecifier &;
-};
-
-template <> struct bind_param<FieldDecl *&> { using type = FieldDecl *; };
-
-template <> struct bind_param<FieldDecl *const &> { using type = FieldDecl *; };
-
-template <typename T> using bind_param_t = typename bind_param<T>::type;
-
-class KernelObjVisitor {
-  SemaSYCL &SemaSYCLRef;
-
-  template <typename ParentTy, typename... HandlerTys>
-  void VisitUnionImpl(const CXXRecordDecl *Owner, ParentTy &Parent,
-                      const CXXRecordDecl *Wrapper, HandlerTys &... Handlers) {
-    (void)std::initializer_list<int>{
-        (Handlers.enterUnion(Owner, Parent), 0)...};
-    VisitRecordHelper(Wrapper, Wrapper->fields(), Handlers...);
-    (void)std::initializer_list<int>{
-        (Handlers.leaveUnion(Owner, Parent), 0)...};
-  }
-
-  // These enable handler execution only when previous Handlers succeed.
-  template <typename... Tn>
-  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&... tn) {
-    bool result = true;
-    (void)std::initializer_list<int>{(result = result && tn(FD, FDTy), 0)...};
-    return result;
-  }
-  template <typename... Tn>
-  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&... tn) {
-    bool result = true;
-    std::initializer_list<int>{(result = result && tn(BD, BDTy), 0)...};
-    return result;
-  }
-
-// This definition using std::bind is necessary because of a gcc 7.x bug.
-#define KF_FOR_EACH(FUNC, Item, Qt)                                            \
-  handleField(                                                                 \
-      Item, Qt,                                                                \
-      std::bind(static_cast<bool (std::decay_t<decltype(Handlers)>::*)(        \
-                    bind_param_t<decltype(Item)>, QualType)>(                  \
-                    &std::decay_t<decltype(Handlers)>::FUNC),                  \
-                std::ref(Handlers), _1, _2)...)
-
-  // The following simpler definition works with gcc 8.x and later.
-  //#define KF_FOR_EACH(FUNC) \
-//  handleField(Field, FieldTy, ([&](FieldDecl *FD, QualType FDTy) { \
-//                return Handlers.f(FD, FDTy); \
-//              })...)
-
-  // This enables handler execution only when previous Handlers succeed.
-  template <typename... Tn>
-  bool handleParam(ParmVarDecl *PD, QualType PDTy, Tn &&...tn) {
-    bool result = true;
-    (void)std::initializer_list<int>{(result = result && tn(PD, PDTy), 0)...};
-    return result;
-  }
-
-  // This definition using std::bind is necessary because of a gcc 7.x bug.
-#define KP_FOR_EACH(FUNC, Item, Qt)                                            \
-  handleParam(                                                                 \
-      Item, Qt,                                                                \
-      std::bind(static_cast<bool (std::decay_t<decltype(Handlers)>::*)(        \
-                    bind_param_t<decltype(Item)>, QualType)>(                  \
-                    &std::decay_t<decltype(Handlers)>::FUNC),                  \
-                std::ref(Handlers), _1, _2)...)
-
-  // Parent contains the FieldDecl or CXXBaseSpecifier that was used to enter
-  // the Wrapper structure that we're currently visiting. Owner is the parent
-  // type (which doesn't exist in cases where it is a FieldDecl in the
-  // 'root'), and Wrapper is the current struct being unwrapped.
-  template <typename ParentTy, typename... HandlerTys>
-  void visitComplexRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
-                          const CXXRecordDecl *Wrapper, QualType RecordTy,
-                          HandlerTys &... Handlers) {
-    (void)std::initializer_list<int>{
-        (Handlers.enterStruct(Owner, Parent, RecordTy), 0)...};
-    VisitRecordHelper(Wrapper, Wrapper->bases(), Handlers...);
-    VisitRecordHelper(Wrapper, Wrapper->fields(), Handlers...);
-    (void)std::initializer_list<int>{
-        (Handlers.leaveStruct(Owner, Parent, RecordTy), 0)...};
-  }
-
-  template <typename ParentTy, typename... HandlerTys>
-  void visitSimpleRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
-                         const CXXRecordDecl *Wrapper, QualType RecordTy,
-                         HandlerTys &... Handlers) {
-    (void)std::initializer_list<int>{
-        (Handlers.handleNonDecompStruct(Owner, Parent, RecordTy), 0)...};
-  }
-
-  template <typename ParentTy, typename... HandlerTys>
-  void visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
-                   const CXXRecordDecl *Wrapper, QualType RecordTy,
-                   HandlerTys &... Handlers);
-
-  template <typename ParentTy, typename... HandlerTys>
-  void VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
-                  const CXXRecordDecl *Wrapper, HandlerTys &... Handlers);
-
-  template <typename... HandlerTys>
-  void VisitRecordHelper(const CXXRecordDecl *Owner,
-                         clang::CXXRecordDecl::base_class_const_range Range,
-                         HandlerTys &... Handlers) {
-    for (const auto &Base : Range) {
-      QualType BaseTy = Base.getType();
-      // Handle accessor class as base
-      if (isSyclSpecialType(BaseTy, SemaSYCLRef))
-        (void)std::initializer_list<int>{
-            (Handlers.handleSyclSpecialType(Owner, Base, BaseTy), 0)...};
-      else
-        // For all other bases, visit the record
-        visitRecord(Owner, Base, BaseTy->getAsCXXRecordDecl(), BaseTy,
-                    Handlers...);
-    }
-  }
-
-  template <typename... HandlerTys>
-  void VisitRecordHelper(const CXXRecordDecl *Owner,
-                         RecordDecl::field_range Range,
-                         HandlerTys &... Handlers) {
-    VisitRecordFields(Owner, Handlers...);
-  }
-
-  template <typename... HandlerTys>
-  void visitArrayElementImpl(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
-                             QualType ElementTy, uint64_t Index,
-                             HandlerTys &... Handlers) {
-    (void)std::initializer_list<int>{
-        (Handlers.nextElement(ElementTy, Index), 0)...};
-    visitField(Owner, ArrayField, ElementTy, Handlers...);
-  }
-
-  template <typename... HandlerTys>
-  void visitFirstArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
-                              QualType ElementTy, HandlerTys &... Handlers) {
-    visitArrayElementImpl(Owner, ArrayField, ElementTy, 0, Handlers...);
-  }
-  template <typename... HandlerTys>
-  void visitNthArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
-                            QualType ElementTy, uint64_t Index,
-                            HandlerTys &... Handlers);
-
-  template <typename... HandlerTys>
-  void visitSimpleArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                        QualType ArrayTy, HandlerTys &... Handlers) {
-    (void)std::initializer_list<int>{
-        (Handlers.handleSimpleArrayType(Field, ArrayTy), 0)...};
-  }
-
-  template <typename... HandlerTys>
-  void visitComplexArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                         QualType ArrayTy, HandlerTys &... Handlers) {
-    // Array workflow is:
-    // handleArrayType
-    // enterArray
-    // nextElement
-    // VisitField (same as before, note that The FieldDecl is the of array
-    // itself, not the element)
-    // ... repeat per element, opt-out for duplicates.
-    // leaveArray
-
-    if (!KF_FOR_EACH(handleArrayType, Field, ArrayTy))
-      return;
-
-    const ConstantArrayType *CAT =
-        SemaSYCLRef.getASTContext().getAsConstantArrayType(ArrayTy);
-    assert(CAT && "Should only be called on constant-size array.");
-    QualType ET = CAT->getElementType();
-    uint64_t ElemCount = CAT->getSize().getZExtValue();
-
-    (void)std::initializer_list<int>{
-        (Handlers.enterArray(Field, ArrayTy, ET), 0)...};
-
-    visitFirstArrayElement(Owner, Field, ET, Handlers...);
-    for (uint64_t Index = 1; Index < ElemCount; ++Index)
-      visitNthArrayElement(Owner, Field, ET, Index, Handlers...);
-
-    (void)std::initializer_list<int>{
-        (Handlers.leaveArray(Field, ArrayTy, ET), 0)...};
-  }
-
-  template <typename... HandlerTys>
-  void visitField(const CXXRecordDecl *Owner, FieldDecl *Field,
-                  QualType FieldTy, HandlerTys &... Handlers) {
-    if (isSyclSpecialType(FieldTy, SemaSYCLRef))
-      KF_FOR_EACH(handleSyclSpecialType, Field, FieldTy);
-    else if (FieldTy->isStructureOrClassType()) {
-      if (KF_FOR_EACH(handleStructType, Field, FieldTy)) {
-        CXXRecordDecl *RD = FieldTy->getAsCXXRecordDecl();
-        visitRecord(Owner, Field, RD, FieldTy, Handlers...);
-      }
-    } else if (FieldTy->isUnionType()) {
-      if (KF_FOR_EACH(handleUnionType, Field, FieldTy)) {
-        CXXRecordDecl *RD = FieldTy->getAsCXXRecordDecl();
-        VisitUnion(Owner, Field, RD, Handlers...);
-      }
-    } else if (FieldTy->isReferenceType())
-      KF_FOR_EACH(handleReferenceType, Field, FieldTy);
-    else if (FieldTy->isPointerType())
-      KF_FOR_EACH(handlePointerType, Field, FieldTy);
-    else if (FieldTy->isArrayType())
-      visitArray(Owner, Field, FieldTy, Handlers...);
-    else if (FieldTy->isScalarType() || FieldTy->isVectorType())
-      KF_FOR_EACH(handleScalarType, Field, FieldTy);
-    else
-      KF_FOR_EACH(handleOtherType, Field, FieldTy);
-  }
-
-  template <typename... HandlerTys>
-  void visitParam(ParmVarDecl *Param, QualType ParamTy,
-                  HandlerTys &...Handlers) {
-    if (isSyclSpecialType(ParamTy, SemaSYCLRef))
-      KP_FOR_EACH(handleOtherType, Param, ParamTy);
-    else if (ParamTy->isStructureOrClassType()) {
-      if (KP_FOR_EACH(handleStructType, Param, ParamTy)) {
-        CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
-        visitRecord(nullptr, Param, RD, ParamTy, Handlers...);
-      }
-    } else if (ParamTy->isUnionType())
-      KP_FOR_EACH(handleOtherType, Param, ParamTy);
-    else if (ParamTy->isReferenceType())
-      KP_FOR_EACH(handleOtherType, Param, ParamTy);
-    else if (ParamTy->isPointerType())
-      KP_FOR_EACH(handlePointerType, Param, ParamTy);
-    else if (ParamTy->isArrayType())
-      KP_FOR_EACH(handleOtherType, Param, ParamTy);
-    else if (ParamTy->isScalarType())
-      KP_FOR_EACH(handleScalarType, Param, ParamTy);
-    else
-      KP_FOR_EACH(handleOtherType, Param, ParamTy);
-  }
-
-public:
-  KernelObjVisitor(SemaSYCL &S) : SemaSYCLRef(S) {}
-
-  static bool useTopLevelKernelObj(const CXXRecordDecl *KernelObj) {
-    // If the kernel is empty, "decompose" it so we don't generate arguments.
-    if (KernelObj->isEmpty())
-      return false;
-    // FIXME: Workaround to not change large number of tests
-    // this is covered by the test below.
-    if (targetRequiresNewType(KernelObj->getASTContext()))
-      return false;
-    if (KernelObj->hasAttr<SYCLRequiresDecompositionAttr>() ||
-        KernelObj->hasAttr<SYCLGenerateNewTypeAttr>())
-      return false;
-    return true;
-  }
-
-  template <typename... HandlerTys>
-  void visitTopLevelRecord(const CXXRecordDecl *Owner, QualType RecordTy,
-                           HandlerTys &...Handlers) {
-    (void)std::initializer_list<int>{
-        (Handlers.handleTopLevelStruct(Owner, RecordTy), 0)...};
-  }
-
-  template <typename... HandlerTys>
-  void VisitRecordBases(const CXXRecordDecl *KernelFunctor,
-                        HandlerTys &... Handlers) {
-    VisitRecordHelper(KernelFunctor, KernelFunctor->bases(), Handlers...);
-  }
-
-  // A visitor function that dispatches to functions as defined in
-  // SyclKernelFieldHandler for the purposes of kernel generation.
-  template <typename... HandlerTys>
-  void VisitRecordFields(const CXXRecordDecl *Owner, HandlerTys &... Handlers) {
-    for (const auto Field : Owner->fields())
-      visitField(Owner, Field, Field->getType(), Handlers...);
-  }
-
-  template <typename... HandlerTys>
-  void visitArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                  QualType ArrayTy, HandlerTys &...Handlers);
-
-  // A visitor for Kernel object to functions as defined in
-  // SyclKernelFieldHandler by iterating over fields and bases
-  // if they require decomposition or new type.
-  template <typename... HandlerTys>
-  void VisitKernelRecord(const CXXRecordDecl *KernelObj,
-                         QualType KernelFunctorTy, HandlerTys &...Handlers) {
-    if (!useTopLevelKernelObj(KernelObj)) {
-      VisitRecordBases(KernelObj, Handlers...);
-      VisitRecordFields(KernelObj, Handlers...);
-    } else {
-      visitTopLevelRecord(KernelObj, KernelFunctorTy, Handlers...);
-    }
-  }
-
-  // A visitor function that dispatches to functions as defined in
-  // SyclKernelFieldHandler by iterating over a free function parameter list.
-  template <typename... HandlerTys>
-  void VisitFunctionParameters(FunctionDecl *FreeFunc,
-                               HandlerTys &...Handlers) {
-    for (ParmVarDecl *Param : FreeFunc->parameters())
-      visitParam(Param, Param->getType(), Handlers...);
-  }
-
-#undef KF_FOR_EACH
-#undef KP_FOR_EACH
-};
-
-// A base type that the SYCL OpenCL Kernel construction task uses to implement
-// individual tasks.
-class SyclKernelFieldHandlerBase {
-public:
-  static constexpr const bool VisitUnionBody = false;
-  static constexpr const bool VisitNthArrayElement = true;
-  // Opt-in based on whether we should visit inside simple containers (structs,
-  // arrays). All of the 'check' types should likely be true, the int-header,
-  // and kernel decl creation types should not.
-  static constexpr const bool VisitInsideSimpleContainers = true;
-  static constexpr const bool VisitInsideSimpleContainersWithPointer = false;
-  // Mark these virtual so that we can use override in the implementer classes,
-  // despite virtual dispatch never being used.
-
-  // SYCL special class can be a base class or a field decl, so both must be
-  // handled.
-  virtual bool handleSyclSpecialType(const CXXRecordDecl *,
-                                     const CXXBaseSpecifier &, QualType) {
-    return true;
-  }
-  virtual bool handleSyclSpecialType(FieldDecl *, QualType) { return true; }
-  virtual bool handleSyclSpecialType(ParmVarDecl *, QualType) { return true; }
-
-  virtual bool handleStructType(FieldDecl *, QualType) { return true; }
-  virtual bool handleStructType(ParmVarDecl *, QualType) { return true; }
-  virtual bool handleUnionType(FieldDecl *, QualType) { return true; }
-  virtual bool handleUnionType(ParmVarDecl *, QualType) { return true; }
-  virtual bool handleReferenceType(FieldDecl *, QualType) { return true; }
-  virtual bool handleReferenceType(ParmVarDecl *, QualType) { return true; }
-  virtual bool handlePointerType(FieldDecl *, QualType) { return true; }
-  virtual bool handlePointerType(ParmVarDecl *, QualType) { return true; }
-  virtual bool handleArrayType(FieldDecl *, QualType) { return true; }
-  virtual bool handleArrayType(ParmVarDecl *, QualType) { return true; }
-  virtual bool handleScalarType(FieldDecl *, QualType) { return true; }
-  virtual bool handleScalarType(ParmVarDecl *, QualType) { return true; }
-  // Most handlers shouldn't be handling this, just the field checker.
-  virtual bool handleOtherType(FieldDecl *, QualType) { return true; }
-  virtual bool handleOtherType(ParmVarDecl *, QualType) { return true; }
-
-  // Handle the SYCL kernel as a whole. This applies only when the target can
-  // support pointer to the generic address space as arguments and the functor
-  // doesn't have any SYCL special types.
-  virtual bool handleTopLevelStruct(const CXXRecordDecl *, QualType) {
-    return true;
-  }
-
-  // Handle a simple struct that doesn't need to be decomposed, only called on
-  // handlers with VisitInsideSimpleContainers as false.  Replaces
-  // handleStructType, enterStruct, leaveStruct, and visiting of sub-elements.
-  virtual bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *,
-                                     QualType) {
-    return true;
-  }
-
-  virtual bool handleNonDecompStruct(const CXXRecordDecl *, ParmVarDecl *,
-                                     QualType) {
-    return true;
-  }
-
-  virtual bool handleNonDecompStruct(const CXXRecordDecl *,
-                                     const CXXBaseSpecifier &, QualType) {
-    return true;
-  }
-
-  // Instead of handleArrayType, enterArray, leaveArray, and nextElement (plus
-  // descending down the elements), this function gets called in the event of an
-  // array containing simple elements (even in the case of an MD array).
-  virtual bool handleSimpleArrayType(FieldDecl *, QualType) { return true; }
-
-  // The following are only used for keeping track of where we are in the base
-  // class/field graph. Int Headers use this to calculate offset, most others
-  // don't have a need for these.
-
-  virtual bool enterStruct(const CXXRecordDecl *, FieldDecl *, QualType) {
-    return true;
-  }
-  virtual bool leaveStruct(const CXXRecordDecl *, FieldDecl *, QualType) {
-    return true;
-  }
-  virtual bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) {
-    return true;
-  }
-  virtual bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) {
-    return true;
-  }
-  virtual bool enterStruct(const CXXRecordDecl *, const CXXBaseSpecifier &,
-                           QualType) {
-    return true;
-  }
-  virtual bool leaveStruct(const CXXRecordDecl *, const CXXBaseSpecifier &,
-                           QualType) {
-    return true;
-  }
-  virtual bool enterUnion(const CXXRecordDecl *, FieldDecl *) { return true; }
-  virtual bool leaveUnion(const CXXRecordDecl *, FieldDecl *) { return true; }
-  virtual bool enterUnion(const CXXRecordDecl *, ParmVarDecl *) { return true; }
-  virtual bool leaveUnion(const CXXRecordDecl *, ParmVarDecl *) { return true; }
-
-  // The following are used for stepping through array elements.
-  virtual bool enterArray(FieldDecl *, QualType ArrayTy, QualType ElementTy) {
-    return true;
-  }
-  virtual bool leaveArray(FieldDecl *, QualType ArrayTy, QualType ElementTy) {
-    return true;
-  }
-  virtual bool enterArray(ParmVarDecl *, QualType ArrayTy, QualType ElementTy) {
-    return true;
-  }
-  virtual bool leaveArray(ParmVarDecl *, QualType ArrayTy, QualType ElementTy) {
-    return true;
-  }
-
-  virtual bool nextElement(QualType, uint64_t) { return true; }
-
-  virtual ~SyclKernelFieldHandlerBase() = default;
-};
-
-// A class to act as the direct base for all the SYCL OpenCL Kernel construction
-// tasks that contains a reference to Sema (and potentially any other
-// universally required data).
-class SyclKernelFieldHandler : public SyclKernelFieldHandlerBase {
-protected:
-  SemaSYCL &SemaSYCLRef;
-  SyclKernelFieldHandler(SemaSYCL &S) : SemaSYCLRef(S) {}
-
-  // Returns 'true' if the thing we're visiting (Based on the FD/QualType pair)
-  // is an element of an array. FD will always be the array field. When
-  // traversing the array field, Ty will be the type of the array field or the
-  // type of array element (or some decomposed type from array).
-  bool isArrayElement(const FieldDecl *FD, QualType Ty) const {
-    return !SemaSYCLRef.getASTContext().hasSameType(FD->getType(), Ty);
-  }
-};
-
-// A class to represent the 'do nothing' case for filtering purposes.
-class SyclEmptyHandler final : public SyclKernelFieldHandlerBase {};
-SyclEmptyHandler GlobalEmptyHandler;
-
-template <bool Keep, typename H> struct HandlerFilter;
-template <typename H> struct HandlerFilter<true, H> {
-  H &Handler;
-  HandlerFilter(H &Handler) : Handler(Handler) {}
-};
-template <typename H> struct HandlerFilter<false, H> {
-  SyclEmptyHandler &Handler = GlobalEmptyHandler;
-  HandlerFilter(H &Handler) {}
-};
-
-template <bool B, bool... Rest> struct AnyTrue;
-
-template <bool B> struct AnyTrue<B> { static constexpr bool Value = B; };
-
-template <bool B, bool... Rest> struct AnyTrue {
-  static constexpr bool Value = B || AnyTrue<Rest...>::Value;
-};
-
-template <bool B, bool... Rest> struct AllTrue;
-
-template <bool B> struct AllTrue<B> { static constexpr bool Value = B; };
-
-template <bool B, bool... Rest> struct AllTrue {
-  static constexpr bool Value = B && AllTrue<Rest...>::Value;
-};
-
-template <typename ParentTy, typename... Handlers>
-void KernelObjVisitor::VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
-                                  const CXXRecordDecl *Wrapper,
-                                  Handlers &... handlers) {
-  // Don't continue descending if none of the handlers 'care'. This could be 'if
-  // constexpr' starting in C++17.  Until then, we have to count on the
-  // optimizer to realize "if (false)" is a dead branch.
-  if (AnyTrue<Handlers::VisitUnionBody...>::Value)
-    VisitUnionImpl(
-        Owner, Parent, Wrapper,
-        HandlerFilter<Handlers::VisitUnionBody, Handlers>(handlers).Handler...);
-}
-
-template <typename... Handlers>
-void KernelObjVisitor::visitNthArrayElement(const CXXRecordDecl *Owner,
-                                            FieldDecl *ArrayField,
-                                            QualType ElementTy, uint64_t Index,
-                                            Handlers &... handlers) {
-  // Don't continue descending if none of the handlers 'care'. This could be 'if
-  // constexpr' starting in C++17.  Until then, we have to count on the
-  // optimizer to realize "if (false)" is a dead branch.
-  if (AnyTrue<Handlers::VisitNthArrayElement...>::Value)
-    visitArrayElementImpl(
-        Owner, ArrayField, ElementTy, Index,
-        HandlerFilter<Handlers::VisitNthArrayElement, Handlers>(handlers)
-            .Handler...);
-}
-
-template <typename ParentTy, typename... HandlerTys>
-void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
-                                   const CXXRecordDecl *Wrapper,
-                                   QualType RecordTy,
-                                   HandlerTys &... Handlers) {
-  RecordDecl *RD = RecordTy->getAsRecordDecl();
-  assert(RD && "should not be null.");
-  if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
-    // If this container requires decomposition, we have to visit it as
-    // 'complex', so all handlers are called in this case with the 'complex'
-    // case.
-    visitComplexRecord(Owner, Parent, Wrapper, RecordTy, Handlers...);
-  } else if (AnyTrue<HandlerTys::VisitInsideSimpleContainersWithPointer...>::
-                 Value) {
-    // We are currently in PointerHandler visitor.
-    if (RD->hasAttr<SYCLGenerateNewTypeAttr>()) {
-      // This is a record containing pointers.
-      visitComplexRecord(Owner, Parent, Wrapper, RecordTy, Handlers...);
-    } else {
-      // This is a record without pointers.
-      visitSimpleRecord(Owner, Parent, Wrapper, RecordTy, Handlers...);
-    }
-  } else {
-    // "Simple" Containers are those that do NOT need to be decomposed,
-    // "Complex" containers are those that DO. In the case where the container
-    // does NOT need to be decomposed, we can call VisitSimpleRecord on the
-    // handlers that have opted-out of VisitInsideSimpleContainers. The 'if'
-    // makes sure we only do that if at least 1 has opted out.
-    if (!AllTrue<HandlerTys::VisitInsideSimpleContainers...>::Value)
-      visitSimpleRecord(
-          Owner, Parent, Wrapper, RecordTy,
-          HandlerFilter<!HandlerTys::VisitInsideSimpleContainers, HandlerTys>(
-              Handlers)
-              .Handler...);
-
-    // Even though this is a 'simple' container, some handlers (via
-    // VisitInsideSimpleContainers = true) need to treat it as if it needs
-    // decomposing, so we call VisitComplexRecord iif at least one has.
-    if (AnyTrue<HandlerTys::VisitInsideSimpleContainers...>::Value)
-      visitComplexRecord(
-          Owner, Parent, Wrapper, RecordTy,
-          HandlerFilter<HandlerTys::VisitInsideSimpleContainers, HandlerTys>(
-              Handlers)
-              .Handler...);
-  }
-}
-
-template <typename... HandlerTys>
-void KernelObjVisitor::visitArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                                  QualType ArrayTy, HandlerTys &... Handlers) {
-
-  if (Field->hasAttr<SYCLRequiresDecompositionAttr>()) {
-    visitComplexArray(Owner, Field, ArrayTy, Handlers...);
-  } else if (AnyTrue<HandlerTys::VisitInsideSimpleContainersWithPointer...>::
-                 Value) {
-    // We are currently in PointerHandler visitor.
-    if (Field->hasAttr<SYCLGenerateNewTypeAttr>()) {
-      // This is an array of pointers, or an array of a type containing
-      // pointers.
-      visitComplexArray(Owner, Field, ArrayTy, Handlers...);
-    } else {
-      // This is an array which does not contain pointers.
-      visitSimpleArray(Owner, Field, ArrayTy, Handlers...);
-    }
-  } else {
-    if (!AllTrue<HandlerTys::VisitInsideSimpleContainers...>::Value)
-      visitSimpleArray(
-          Owner, Field, ArrayTy,
-          HandlerFilter<!HandlerTys::VisitInsideSimpleContainers, HandlerTys>(
-              Handlers)
-              .Handler...);
-
-    if (AnyTrue<HandlerTys::VisitInsideSimpleContainers...>::Value)
-      visitComplexArray(
-          Owner, Field, ArrayTy,
-          HandlerFilter<HandlerTys::VisitInsideSimpleContainers, HandlerTys>(
-              Handlers)
-              .Handler...);
-  }
-}
-
-// A type to check the validity of all of the argument types.
-class SyclKernelFieldChecker : public SyclKernelFieldHandler {
-  bool IsInvalid = false;
-  DiagnosticsEngine &Diag;
-  // Keeps track of whether we are currently handling fields inside a struct.
-  // Fields of kernel functor or direct kernel captures will have a depth 0.
-  int StructFieldDepth = 0;
-  // Initialize with -1 so that fields of a base class of the kernel functor
-  // has depth 0. Visitor method enterStruct increments this to 0 when the base
-  // class is entered.
-  int StructBaseDepth = -1;
-
-  // Check whether the object should be disallowed from being copied to kernel.
-  // Return true if not copyable, false if copyable.
-  bool checkNotCopyableToKernel(const FieldDecl *FD, QualType FieldTy) {
-    if (FieldTy->isArrayType()) {
-      if (const auto *CAT =
-              SemaSYCLRef.getASTContext().getAsConstantArrayType(FieldTy)) {
-        QualType ET = CAT->getElementType();
-        return checkNotCopyableToKernel(FD, ET);
-      }
-      return Diag.Report(FD->getLocation(),
-                         diag::err_sycl_non_constant_array_type)
-             << FieldTy;
-    }
-
-    return false;
-  }
-
-  bool checkPropertyListType(TemplateArgument PropList, SourceLocation Loc) {
-    if (PropList.getKind() != TemplateArgument::ArgKind::Type)
-      return SemaSYCLRef.Diag(
-          Loc, diag::err_sycl_invalid_accessor_property_template_param);
-
-    QualType PropListTy = PropList.getAsType();
-    if (!SemaSYCL::isSyclType(PropListTy, SYCLTypeAttr::accessor_property_list))
-      return SemaSYCLRef.Diag(
-          Loc, diag::err_sycl_invalid_accessor_property_template_param);
-
-    const auto *AccPropListDecl =
-        cast<ClassTemplateSpecializationDecl>(PropListTy->getAsRecordDecl());
-    if (AccPropListDecl->getTemplateArgs().size() != 1)
-      return SemaSYCLRef.Diag(Loc,
-                              diag::err_sycl_invalid_property_list_param_number)
-             << "accessor_property_list";
-
-    const auto TemplArg = AccPropListDecl->getTemplateArgs()[0];
-    if (TemplArg.getKind() != TemplateArgument::ArgKind::Pack)
-      return SemaSYCLRef.Diag(
-                 Loc,
-                 diag::err_sycl_invalid_accessor_property_list_template_param)
-             << /*accessor_property_list*/ 0 << /*parameter pack*/ 0;
-
-    for (TemplateArgument::pack_iterator Prop = TemplArg.pack_begin();
-         Prop != TemplArg.pack_end(); ++Prop) {
-      if (Prop->getKind() != TemplateArgument::ArgKind::Type)
-        return SemaSYCLRef.Diag(
-                   Loc,
-                   diag::err_sycl_invalid_accessor_property_list_template_param)
-               << /*accessor_property_list pack argument*/ 1 << /*type*/ 1;
-      QualType PropTy = Prop->getAsType();
-      if (isAccessorPropertyType(PropTy, SYCLTypeAttr::buffer_location) &&
-          checkBufferLocationType(PropTy, Loc))
-        return true;
-    }
-    return false;
-  }
-
-  bool checkBufferLocationType(QualType PropTy, SourceLocation Loc) {
-    const auto *PropDecl =
-        cast<ClassTemplateSpecializationDecl>(PropTy->getAsRecordDecl());
-    if (PropDecl->getTemplateArgs().size() != 1)
-      return SemaSYCLRef.Diag(Loc,
-                              diag::err_sycl_invalid_property_list_param_number)
-             << "buffer_location";
-
-    const auto BufferLoc = PropDecl->getTemplateArgs()[0];
-    if (BufferLoc.getKind() != TemplateArgument::ArgKind::Integral)
-      return SemaSYCLRef.Diag(
-                 Loc,
-                 diag::err_sycl_invalid_accessor_property_list_template_param)
-             << /*buffer_location*/ 2 << /*non-negative integer*/ 2;
-
-    int LocationID = static_cast<int>(BufferLoc.getAsIntegral().getExtValue());
-    if (LocationID < 0)
-      return SemaSYCLRef.Diag(
-                 Loc,
-                 diag::err_sycl_invalid_accessor_property_list_template_param)
-             << /*buffer_location*/ 2 << /*non-negative integer*/ 2;
-
-    return false;
-  }
-
-  bool checkSyclSpecialType(QualType Ty, SourceRange Loc) {
-    assert(isSyclSpecialType(Ty, SemaSYCLRef) &&
-           "Should only be called on sycl special class types.");
-
-    // Annotated pointers and annotated arguments must be captured
-    // directly by the SYCL kernel.
-    if ((SemaSYCL::isSyclType(Ty, SYCLTypeAttr::annotated_ptr) ||
-         SemaSYCL::isSyclType(Ty, SYCLTypeAttr::annotated_arg)) &&
-        (StructFieldDepth > 0 || StructBaseDepth > 0))
-      return SemaSYCLRef.Diag(Loc.getBegin(),
-                              diag::err_bad_kernel_param_data_members)
-             << Ty << /*Struct*/ 1;
-
-    const RecordDecl *RecD = Ty->getAsRecordDecl();
-    if (const ClassTemplateSpecializationDecl *CTSD =
-            dyn_cast<ClassTemplateSpecializationDecl>(RecD)) {
-      const TemplateArgumentList &TAL = CTSD->getTemplateArgs();
-      TemplateArgument TA = TAL.get(0);
-
-      // Parameter packs are used by properties so they are always valid.
-      if (TA.getKind() != TemplateArgument::Pack) {
-        llvm::DenseSet<QualType> Visited;
-        checkSYCLType(SemaSYCLRef, TA.getAsType(), Loc, Visited);
-      }
-
-      if (TAL.size() > 5)
-        return checkPropertyListType(TAL.get(5), Loc.getBegin());
-    }
-    return false;
-  }
-
-public:
-  SyclKernelFieldChecker(SemaSYCL &S)
-      : SyclKernelFieldHandler(S), Diag(S.getASTContext().getDiagnostics()) {}
-  static constexpr const bool VisitNthArrayElement = false;
-  bool isValid() { return !IsInvalid; }
-
-  bool handleReferenceType(FieldDecl *FD, QualType FieldTy) final {
-    Diag.Report(FD->getLocation(), diag::err_bad_kernel_param_type) << FieldTy;
-    IsInvalid = true;
-    return isValid();
-  }
-
-  bool handleReferenceType(ParmVarDecl *PD, QualType ParamTy) final {
-    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
-    IsInvalid = true;
-    return isValid();
-  }
-
-  bool handleStructType(FieldDecl *FD, QualType FieldTy) final {
-    CXXRecordDecl *RD = FieldTy->getAsCXXRecordDecl();
-    assert(RD && "Not a RecordDecl inside the handler for struct type");
-    if (RD->isLambda()) {
-      for (const LambdaCapture &LC : RD->captures())
-        if (LC.capturesThis() && LC.isImplicit()) {
-          SemaSYCLRef.Diag(LC.getLocation(), diag::err_implicit_this_capture);
-          IsInvalid = true;
-        }
-    }
-    return isValid();
-  }
-
-  bool handleStructType(ParmVarDecl *PD, QualType ParamTy) final {
-    CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
-    // For free functions all struct/class kernel arguments are forward declared
-    // in integration header, that adds additional restrictions for kernel
-    // arguments.
-    NotForwardDeclarableReason NFDR =
-        isForwardDeclarable(RD, SemaSYCLRef, /*DiagForFreeFunction=*/true);
-    if (NFDR != NotForwardDeclarableReason::None) {
-      Diag.Report(PD->getLocation(),
-                  diag::err_bad_kernel_param_type)
-          << ParamTy;
-      Diag.Report(PD->getLocation(),
-                  diag::note_free_function_kernel_param_type_not_fwd_declarable)
-          << ParamTy;
-      IsInvalid = true;
-    }
-    return isValid();
-  }
-
-  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                             QualType FieldTy) final {
-    IsInvalid |= checkSyclSpecialType(FieldTy, BS.getBeginLoc());
-    return isValid();
-  }
-
-  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
-    IsInvalid |= checkSyclSpecialType(FieldTy, FD->getLocation());
-    return isValid();
-  }
-
-  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
-    IsInvalid = true;
-    return isValid();
-  }
-
-  bool handleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    IsInvalid |= checkNotCopyableToKernel(FD, FieldTy);
-    return isValid();
-  }
-
-  bool handleArrayType(ParmVarDecl *PD, QualType ParamTy) final {
-    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
-    IsInvalid = true;
-    return isValid();
-  }
-
-  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
-    while (FieldTy->isAnyPointerType()) {
-      FieldTy = QualType{FieldTy->getPointeeOrArrayElementType(), 0};
-      if (FieldTy->isVariableArrayType()) {
-        Diag.Report(FD->getLocation(), diag::err_vla_unsupported) << 0;
-        IsInvalid = true;
-        break;
-      }
-    }
-    return isValid();
-  }
-
-  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
-    while (ParamTy->isAnyPointerType()) {
-      ParamTy = QualType{ParamTy->getPointeeOrArrayElementType(), 0};
-      if (ParamTy->isVariableArrayType()) {
-        Diag.Report(PD->getLocation(), diag::err_vla_unsupported) << 0;
-        IsInvalid = true;
-        break;
-      }
-    }
-    return isValid();
-  }
-
-  bool handleOtherType(FieldDecl *FD, QualType FieldTy) final {
-    Diag.Report(FD->getLocation(), diag::err_bad_kernel_param_type) << FieldTy;
-    IsInvalid = true;
-    return isValid();
-  }
-
-  bool handleOtherType(ParmVarDecl *PD, QualType ParamTy) final {
-    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
-    IsInvalid = true;
-    return isValid();
-  }
-
-  bool enterStruct(const CXXRecordDecl *, FieldDecl *, QualType) final {
-    ++StructFieldDepth;
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, FieldDecl *, QualType) final {
-    --StructFieldDepth;
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
-    // TODO manipulate struct depth once special types are supported for free
-    // function kernels.
-    // ++StructFieldDepth;
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *PD,
-                   QualType ParamTy) final {
-    // TODO manipulate struct depth once special types are supported for free
-    // function kernels.
-    // --StructFieldDepth;
-    // TODO We don't yet support special types and therefore structs that
-    // require decomposition and leaving/entering. Diagnose for better user
-    // experience.
-    CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
-    if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
-      Diag.Report(PD->getLocation(),
-                  diag::err_bad_kernel_param_type)
-          << ParamTy;
-      Diag.Report(PD->getLocation(),
-                  diag::note_free_function_kernel_param_type_not_supported)
-          << ParamTy;
-      IsInvalid = true;
-    }
-    return isValid();
-  }
-
-  bool enterStruct(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                   QualType FieldTy) final {
-    ++StructBaseDepth;
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                   QualType FieldTy) final {
-    --StructBaseDepth;
-    return true;
-  }
-};
-
-// A type to check the validity of accessing accessor/sampler/stream
-// types as kernel parameters inside union.
-class SyclKernelUnionChecker : public SyclKernelFieldHandler {
-  int UnionCount = 0;
-  bool IsInvalid = false;
-  DiagnosticsEngine &Diag;
-
-public:
-  SyclKernelUnionChecker(SemaSYCL &S)
-      : SyclKernelFieldHandler(S), Diag(S.getASTContext().getDiagnostics()) {}
-  bool isValid() { return !IsInvalid; }
-  static constexpr const bool VisitUnionBody = true;
-  static constexpr const bool VisitNthArrayElement = false;
-
-  bool checkType(SourceLocation Loc, QualType Ty) {
-    if (UnionCount) {
-      IsInvalid = true;
-      Diag.Report(Loc, diag::err_bad_kernel_param_data_members)
-          << Ty << /*Union*/ 0;
-    }
-    return isValid();
-  }
-
-  bool enterUnion(const CXXRecordDecl *RD, FieldDecl *FD) override {
-    ++UnionCount;
-    return true;
-  }
-
-  bool enterUnion(const CXXRecordDecl *, ParmVarDecl *) override {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool leaveUnion(const CXXRecordDecl *RD, FieldDecl *FD) override {
-    --UnionCount;
-    return true;
-  }
-
-  bool leaveUnion(const CXXRecordDecl *, ParmVarDecl *) override {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
-    return checkType(FD->getLocation(), FieldTy);
-  }
-
-  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                             QualType FieldTy) final {
-    return checkType(BS.getBeginLoc(), FieldTy);
-  }
-};
-
-// A type to mark whether a collection requires decomposition
-// or needs to be transformed to a new type. If a collection
-// contains pointers, and is not decomposed, a new type must
-// be generated with all pointers in global address space.
-class SyclKernelDecompMarker : public SyclKernelFieldHandler {
-  llvm::SmallVector<bool, 16> CollectionStack;
-  llvm::SmallVector<bool, 16> PointerStack;
-
-public:
-  static constexpr const bool VisitUnionBody = false;
-  static constexpr const bool VisitNthArrayElement = false;
-
-  SyclKernelDecompMarker(SemaSYCL &S) : SyclKernelFieldHandler(S) {
-    // Base entry.
-    CollectionStack.push_back(false);
-    PointerStack.push_back(false);
-  }
-
-  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &,
-                             QualType) final {
-    CollectionStack.back() = true;
-    return true;
-  }
-  bool handleSyclSpecialType(FieldDecl *, QualType) final {
-    CollectionStack.back() = true;
-    return true;
-  }
-
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
-    // TODO We don't support special types in free function kernel parameters,
-    // but track them to diagnose the case properly.
-    CollectionStack.back() = true;
-    return true;
-  }
-
-  bool handlePointerType(FieldDecl *, QualType) final {
-    PointerStack.back() = targetRequiresNewType(SemaSYCLRef.getASTContext());
-    return true;
-  }
-
-  bool handlePointerType(ParmVarDecl *, QualType) final {
-    PointerStack.back() = targetRequiresNewType(SemaSYCLRef.getASTContext());
-    return true;
-  }
-
-  // Add Top level information to ease checks for processor.
-  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
-    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
-    assert(RD && "should not be null.");
-    if (CollectionStack.pop_back_val() ||
-        SemaSYCLRef.getLangOpts().SYCLDecomposeStruct) {
-      if (!RD->hasAttr<SYCLRequiresDecompositionAttr>())
-        RD->addAttr(SYCLRequiresDecompositionAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-      PointerStack.pop_back();
-    } else if (PointerStack.pop_back_val()) {
-      if (!RD->hasAttr<SYCLGenerateNewTypeAttr>())
-        RD->addAttr(SYCLGenerateNewTypeAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-    }
-    assert(CollectionStack.size() == 0);
-    assert(PointerStack.size() == 0);
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *, FieldDecl *, QualType) final {
-    CollectionStack.push_back(false);
-    PointerStack.push_back(false);
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
-    CollectionStack.push_back(false);
-    PointerStack.push_back(false);
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, FieldDecl *, QualType Ty) final {
-    // If a record needs to be decomposed, it is marked with
-    // SYCLRequiresDecompositionAttr. Else if a record contains
-    // a pointer, it is marked with SYCLGenerateNewTypeAttr. A record
-    // will never be marked with both attributes.
-    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
-    assert(RD && "should not be null.");
-    if (CollectionStack.pop_back_val()) {
-      if (!RD->hasAttr<SYCLRequiresDecompositionAttr>())
-        RD->addAttr(SYCLRequiresDecompositionAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-      CollectionStack.back() = true;
-      PointerStack.pop_back();
-    } else if (PointerStack.pop_back_val()) {
-      PointerStack.back() = true;
-      if (!RD->hasAttr<SYCLGenerateNewTypeAttr>())
-        RD->addAttr(SYCLGenerateNewTypeAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-    }
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *,
-                   QualType ParamTy) final {
-    CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
-    assert(RD && "should not be null.");
-    if (CollectionStack.pop_back_val()) {
-      if (!RD->hasAttr<SYCLRequiresDecompositionAttr>())
-        RD->addAttr(SYCLRequiresDecompositionAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-      CollectionStack.back() = true;
-      PointerStack.pop_back();
-    } else if (PointerStack.pop_back_val()) {
-      PointerStack.back() = true;
-      if (!RD->hasAttr<SYCLGenerateNewTypeAttr>())
-        RD->addAttr(SYCLGenerateNewTypeAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-    }
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *, const CXXBaseSpecifier &,
-                   QualType) final {
-    CollectionStack.push_back(false);
-    PointerStack.push_back(false);
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, const CXXBaseSpecifier &,
-                   QualType Ty) final {
-    // If a record needs to be decomposed, it is marked with
-    // SYCLRequiresDecompositionAttr. Else if a record contains
-    // a pointer, it is marked with SYCLGenerateNewTypeAttr. A record
-    // will never be marked with both attributes.
-    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
-    assert(RD && "should not be null.");
-    if (CollectionStack.pop_back_val()) {
-      if (!RD->hasAttr<SYCLRequiresDecompositionAttr>())
-        RD->addAttr(SYCLRequiresDecompositionAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-      CollectionStack.back() = true;
-      PointerStack.pop_back();
-    } else if (PointerStack.pop_back_val()) {
-      PointerStack.back() = true;
-      if (!RD->hasAttr<SYCLGenerateNewTypeAttr>())
-        RD->addAttr(SYCLGenerateNewTypeAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-    }
-    return true;
-  }
-
-  bool enterArray(FieldDecl *, QualType ArrayTy, QualType ElementTy) final {
-    CollectionStack.push_back(false);
-    PointerStack.push_back(false);
-    return true;
-  }
-
-  bool enterArray(ParmVarDecl *, QualType ArrayTy, QualType ElementTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool leaveArray(FieldDecl *FD, QualType ArrayTy, QualType ElementTy) final {
-    // If an array needs to be decomposed, it is marked with
-    // SYCLRequiresDecompositionAttr. Else if the array is an array of pointers
-    // or an array of structs containing pointers, it is marked with
-    // SYCLGenerateNewTypeAttr. An array will never be marked with both
-    // attributes.
-    if (CollectionStack.pop_back_val()) {
-      // Cannot assert, since in MD arrays we'll end up marking them multiple
-      // times.
-      if (!FD->hasAttr<SYCLRequiresDecompositionAttr>())
-        FD->addAttr(SYCLRequiresDecompositionAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-      CollectionStack.back() = true;
-      PointerStack.pop_back();
-    } else if (PointerStack.pop_back_val()) {
-      if (!FD->hasAttr<SYCLGenerateNewTypeAttr>())
-        FD->addAttr(SYCLGenerateNewTypeAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-      PointerStack.back() = true;
-    }
-    return true;
-  }
-
-  bool leaveArray(ParmVarDecl *PD, QualType ArrayTy, QualType ElementTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-};
-
-static QualType ModifyAddressSpace(SemaSYCL &SemaSYCLRef, QualType Ty) {
-  // USM allows to use raw pointers instead of buffers/accessors, but these
-  // pointers point to the specially allocated memory. For pointer fields,
-  // except for function pointer fields, we add a kernel argument with the
-  // same type as field but global address space, because OpenCL requires it.
-  // Function pointers should have program address space. This is set in
-  // CodeGen.
-  QualType PointeeTy = Ty->getPointeeType();
-  Qualifiers Quals = PointeeTy.getQualifiers();
-  LangAS AS = Quals.getAddressSpace();
-  // Leave global_device and global_host address spaces as is to help FPGA
-  // device in memory allocations.
-  if (!PointeeTy->isFunctionType() && AS != LangAS::sycl_global_device &&
-      AS != LangAS::sycl_global_host)
-    Quals.setAddressSpace(LangAS::sycl_global);
-  PointeeTy = SemaSYCLRef.getASTContext().getQualifiedType(
-      PointeeTy.getUnqualifiedType(), Quals);
-  return SemaSYCLRef.getASTContext().getPointerType(PointeeTy);
-}
-
-// This visitor is used to traverse a non-decomposed record/array to
-// generate a new type corresponding to this record/array.
-class SyclKernelPointerHandler : public SyclKernelFieldHandler {
-  llvm::SmallVector<CXXRecordDecl *, 8> ModifiedRecords;
-  SmallVector<CXXBaseSpecifier *, 8> ModifiedBases;
-  SmallVector<QualType, 8> ModifiedArrayElementsOrArray;
-
-  IdentifierInfo *getModifiedName(IdentifierInfo *Id) {
-    std::string Name =
-        Id ? (Twine("__generated_") + Id->getName()).str() : "__generated_";
-    return &SemaSYCLRef.getASTContext().Idents.get(Name);
-  }
-
-  // Create Decl for the new type we are generating.
-  // The fields (and base classes) of this record will be generated as
-  // the visitor traverses kernel object record fields.
-  void createNewType(const CXXRecordDecl *RD) {
-    auto *ModifiedRD = CXXRecordDecl::Create(
-        SemaSYCLRef.getASTContext(), RD->getTagKind(),
-        const_cast<DeclContext *>(RD->getDeclContext()), SourceLocation(),
-        SourceLocation(), getModifiedName(RD->getIdentifier()));
-    ModifiedRD->startDefinition();
-    if (RD->hasAttrs())
-      ModifiedRD->setAttrs(RD->getAttrs());
-    ModifiedRecords.push_back(ModifiedRD);
-  }
-
-  // Create and add FieldDecl for FieldTy to generated record.
-  void addField(const FieldDecl *FD, QualType FieldTy) {
-    assert(!ModifiedRecords.empty() &&
-           "ModifiedRecords should have at least 1 record");
-    ASTContext &Ctx = SemaSYCLRef.getASTContext();
-    auto *Field = FieldDecl::Create(
-        Ctx, ModifiedRecords.back(), SourceLocation(), SourceLocation(),
-        getModifiedName(FD->getIdentifier()), FieldTy,
-        Ctx.getTrivialTypeSourceInfo(FieldTy, SourceLocation()), /*BW=*/nullptr,
-        /*Mutable=*/false, ICIS_NoInit);
-    Field->setAccess(FD->getAccess());
-    if (FD->hasAttrs())
-      Field->setAttrs(FD->getAttrs());
-    // Add generated field to generated record.
-    ModifiedRecords.back()->addDecl(Field);
-  }
-
-  void createBaseSpecifier(const CXXRecordDecl *Parent, const CXXRecordDecl *RD,
-                           const CXXBaseSpecifier &BS) {
-    TypeSourceInfo *TInfo =
-        SemaSYCLRef.getASTContext().getTrivialTypeSourceInfo(
-            QualType(RD->getTypeForDecl(), 0), SourceLocation());
-    CXXBaseSpecifier *ModifiedBase = SemaSYCLRef.SemaRef.CheckBaseSpecifier(
-        const_cast<CXXRecordDecl *>(Parent), SourceRange(), BS.isVirtual(),
-        BS.getAccessSpecifier(), TInfo, SourceLocation());
-    ModifiedBases.push_back(ModifiedBase);
-  }
-
-  CXXRecordDecl *getGeneratedNewRecord(const CXXRecordDecl *OldBaseDecl) {
-    // At this point we have finished generating fields for the new
-    // class corresponding to OldBaseDecl. Pop out the generated
-    // record.
-    CXXRecordDecl *ModifiedRD = ModifiedRecords.pop_back_val();
-    ModifiedRD->completeDefinition();
-    // Check the 'old' class for base classes.
-    // Set bases classes for newly generated class if it has any.
-    if (OldBaseDecl->getNumBases() > 0) {
-      SmallVector<CXXBaseSpecifier *, 8> BasesForGeneratedClass;
-      for (size_t I = 0; I < OldBaseDecl->getNumBases(); ++I)
-        BasesForGeneratedClass.insert(BasesForGeneratedClass.begin(),
-                                      ModifiedBases.pop_back_val());
-      ModifiedRD->setBases(BasesForGeneratedClass.data(),
-                           OldBaseDecl->getNumBases());
-    }
-    return ModifiedRD;
-  }
-
-public:
-  static constexpr const bool VisitInsideSimpleContainersWithPointer = true;
-  static constexpr const bool VisitNthArrayElement = false;
-  SyclKernelPointerHandler(SemaSYCL &S, const CXXRecordDecl *RD)
-      : SyclKernelFieldHandler(S) {
-    createNewType(RD);
-  }
-
-  SyclKernelPointerHandler(SemaSYCL &S) : SyclKernelFieldHandler(S) {}
-
-  bool enterStruct(const CXXRecordDecl *, FieldDecl *, QualType Ty) final {
-    createNewType(Ty->getAsCXXRecordDecl());
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *,
-                   QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
-    CXXRecordDecl *ModifiedRD = getGeneratedNewRecord(Ty->getAsCXXRecordDecl());
-
-    // Add this record as a field of it's parent record if it is not an
-    // array element.
-    if (!isArrayElement(FD, Ty))
-      addField(FD, QualType(ModifiedRD->getTypeForDecl(), 0));
-    else
-      ModifiedArrayElementsOrArray.push_back(
-          QualType(ModifiedRD->getTypeForDecl(), 0));
-
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *PD,
-                   QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *, const CXXBaseSpecifier &,
-                   QualType Ty) final {
-    createNewType(Ty->getAsCXXRecordDecl());
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *Parent, const CXXBaseSpecifier &BS,
-                   QualType Ty) final {
-    CXXRecordDecl *ModifiedRD = getGeneratedNewRecord(Ty->getAsCXXRecordDecl());
-
-    // Create CXXBaseSpecifier for this generated class.
-    createBaseSpecifier(Parent, ModifiedRD, BS);
-    return true;
-  }
-
-  bool leaveArray(FieldDecl *FD, QualType ArrayTy, QualType ET) final {
-    QualType ModifiedArrayElement = ModifiedArrayElementsOrArray.pop_back_val();
-
-    const ConstantArrayType *CAT =
-        SemaSYCLRef.getASTContext().getAsConstantArrayType(ArrayTy);
-    assert(CAT && "Should only be called on constant-size array.");
-    QualType ModifiedArray = SemaSYCLRef.getASTContext().getConstantArrayType(
-        ModifiedArrayElement, CAT->getSize(),
-        const_cast<Expr *>(CAT->getSizeExpr()), CAT->getSizeModifier(),
-        CAT->getIndexTypeCVRQualifiers());
-
-    if (ModifiedRecords.empty()) {
-      // This is a top-level kernel argument.
-      ModifiedArrayElementsOrArray.push_back(ModifiedArray);
-    } else if (!isArrayElement(FD, ArrayTy)) {
-      // Add this array field as a field of it's parent record.
-      addField(FD, ModifiedArray);
-    } else {
-      // Multi-dimensional array element.
-      ModifiedArrayElementsOrArray.push_back(ModifiedArray);
-    }
-
-    return true;
-  }
-
-  bool leaveArray(ParmVarDecl *PD, QualType ArrayTy, QualType ET) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
-    QualType ModifiedPointerType = ModifyAddressSpace(SemaSYCLRef, FieldTy);
-    if (!isArrayElement(FD, FieldTy))
-      addField(FD, ModifiedPointerType);
-    else
-      ModifiedArrayElementsOrArray.push_back(ModifiedPointerType);
-    // We do not need to wrap pointers since this is a pointer inside
-    // non-decomposed struct.
-    return true;
-  }
-
-  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
-    addField(FD, FieldTy);
-    return true;
-  }
-
-  bool handleScalarType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
-    return handleScalarType(FD, FieldTy);
-  }
-
-  bool handleUnionType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
-                             QualType Ty) final {
-    addField(FD, Ty);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *, ParmVarDecl *PD,
-                             QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *Parent,
-                             const CXXBaseSpecifier &BS, QualType Ty) final {
-    createBaseSpecifier(Parent, Ty->getAsCXXRecordDecl(), BS);
-    return true;
-  }
-
-  bool handleSimpleArrayType(FieldDecl *FD, QualType Ty) final {
-    addField(FD, Ty);
-    return true;
-  }
-
-public:
-  QualType getNewRecordType() {
-    CXXRecordDecl *ModifiedRD = ModifiedRecords.pop_back_val();
-    ModifiedRD->completeDefinition();
-
-    if (!ModifiedBases.empty())
-      ModifiedRD->setBases(ModifiedBases.data(), ModifiedBases.size());
-
-    return QualType(ModifiedRD->getTypeForDecl(), 0);
-  }
-  QualType getNewArrayType() {
-    return ModifiedArrayElementsOrArray.pop_back_val();
-  }
-};
-
-// A type to Create and own the FunctionDecl for the kernel.
-class SyclKernelDeclCreator : public SyclKernelFieldHandler {
-  FunctionDecl *KernelDecl = nullptr;
-  llvm::SmallVector<ParmVarDecl *, 8> Params;
-  Sema::ContextRAII FuncContext;
-  // Holds the last handled field's first parameter. This doesn't store an
-  // iterator as push_back invalidates iterators.
-  size_t LastParamIndex = 0;
-  // Keeps track of whether we are currently handling fields inside a struct.
-  int StructDepth = 0;
-
-  void addParam(const FieldDecl *FD, QualType FieldTy) {
-    ParamDesc newParamDesc = makeParamDesc(FD, FieldTy);
-    addParam(newParamDesc, FieldTy);
-  }
-
-  void addParam(const ParmVarDecl *PD, QualType ParamTy) {
-    ParamDesc newParamDesc = makeParamDesc(PD, ParamTy);
-    addParam(newParamDesc, ParamTy);
-  }
-
-  void addParam(const CXXBaseSpecifier &BS, QualType FieldTy) {
-    // TODO: There is no name for the base available, but duplicate names are
-    // seemingly already possible, so we'll give them all the same name for now.
-    // This only happens with the accessor types.
-    StringRef Name = "_arg__base";
-    ParamDesc newParamDesc =
-        makeParamDesc(SemaSYCLRef.getASTContext(), Name, FieldTy);
-    addParam(newParamDesc, FieldTy);
-  }
-  // Add a parameter with specified name and type
-  void addParam(StringRef Name, QualType ParamTy) {
-    ParamDesc newParamDesc =
-        makeParamDesc(SemaSYCLRef.getASTContext(), Name, ParamTy);
-    addParam(newParamDesc, ParamTy);
-  }
-
-  void addParam(ParamDesc newParamDesc, QualType FieldTy) {
-    // Create a new ParmVarDecl based on the new info.
-    ASTContext &Ctx = SemaSYCLRef.getASTContext();
-    auto *NewParam = ParmVarDecl::Create(
-        Ctx, KernelDecl, SourceLocation(), SourceLocation(),
-        std::get<1>(newParamDesc), std::get<0>(newParamDesc),
-        std::get<2>(newParamDesc), SC_None, /*DefArg*/ nullptr);
-    NewParam->setScopeInfo(0, Params.size());
-    NewParam->setIsUsed();
-
-    LastParamIndex = Params.size();
-    Params.push_back(NewParam);
-  }
-
-  // Handle accessor properties. If any properties were found in
-  // the accessor_property_list - add the appropriate attributes to ParmVarDecl.
-  void handleAccessorPropertyList(ParmVarDecl *Param,
-                                  const CXXRecordDecl *RecordDecl,
-                                  SourceLocation Loc) {
-    const auto *AccTy = cast<ClassTemplateSpecializationDecl>(RecordDecl);
-    if (AccTy->getTemplateArgs().size() < 6)
-      return;
-    const auto PropList = cast<TemplateArgument>(AccTy->getTemplateArgs()[5]);
-    QualType PropListTy = PropList.getAsType();
-    const auto *AccPropListDecl =
-        cast<ClassTemplateSpecializationDecl>(PropListTy->getAsRecordDecl());
-    const auto TemplArg = AccPropListDecl->getTemplateArgs()[0];
-    // Move through TemplateArgs list of a property list and search for
-    // properties. If found - apply the appropriate attribute to ParmVarDecl.
-    for (TemplateArgument::pack_iterator Prop = TemplArg.pack_begin();
-         Prop != TemplArg.pack_end(); ++Prop) {
-      QualType PropTy = Prop->getAsType();
-      if (isAccessorPropertyType(PropTy, SYCLTypeAttr::no_alias))
-        handleNoAliasProperty(Param, PropTy, Loc);
-      if (isAccessorPropertyType(PropTy, SYCLTypeAttr::buffer_location))
-        handleBufferLocationProperty(Param, PropTy, Loc);
-    }
-  }
-
-  void handleNoAliasProperty(ParmVarDecl *Param, QualType PropTy,
-                             SourceLocation Loc) {
-    ASTContext &Ctx = SemaSYCLRef.getASTContext();
-    Param->addAttr(RestrictAttr::CreateImplicit(Ctx, Loc));
-  }
-
-  // Obtain an integer value stored in a template parameter of buffer_location
-  // property to pass it to buffer_location kernel attribute
-  void handleBufferLocationProperty(ParmVarDecl *Param, QualType PropTy,
-                                    SourceLocation Loc) {
-    // If we have more than 1 buffer_location properties on a single
-    // accessor - emit an error
-    if (Param->hasAttr<SYCLIntelBufferLocationAttr>()) {
-      SemaSYCLRef.Diag(Loc, diag::err_sycl_compiletime_property_duplication)
-          << "buffer_location";
-      return;
-    }
-    ASTContext &Ctx = SemaSYCLRef.getASTContext();
-    const auto *PropDecl =
-        cast<ClassTemplateSpecializationDecl>(PropTy->getAsRecordDecl());
-    const auto BufferLoc = PropDecl->getTemplateArgs()[0];
-    int LocationID = static_cast<int>(BufferLoc.getAsIntegral().getExtValue());
-    Param->addAttr(
-        SYCLIntelBufferLocationAttr::CreateImplicit(Ctx, LocationID));
-  }
-
-  // Additional processing is required for accessor type.
-  void handleAccessorType(QualType FieldTy, const CXXRecordDecl *RecordDecl,
-                          SourceLocation Loc) {
-    handleAccessorPropertyList(Params.back(), RecordDecl, Loc);
-
-    // If "accessor" type check if read only
-    if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::accessor)) {
-      // Get access mode of accessor.
-      const auto *AccessorSpecializationDecl =
-          cast<ClassTemplateSpecializationDecl>(RecordDecl);
-      const TemplateArgument &AccessModeArg =
-          AccessorSpecializationDecl->getTemplateArgs().get(2);
-      if (isReadOnlyAccessor(AccessModeArg))
-        Params.back()->addAttr(SYCLAccessorReadonlyAttr::CreateImplicit(
-            SemaSYCLRef.getASTContext()));
-    }
-
-    // Add implicit attribute to parameter decl when it is a read only
-    // SYCL accessor.
-    Params.back()->addAttr(
-        SYCLAccessorPtrAttr::CreateImplicit(SemaSYCLRef.getASTContext()));
-  }
-
-  // All special SYCL objects must have __init method. We extract types for
-  // kernel parameters from __init method parameters. We will use __init method
-  // and kernel parameters which we build here to initialize special objects in
-  // the kernel body.
-  bool handleSpecialType(FieldDecl *FD, QualType FieldTy) {
-    const auto *RecordDecl = FieldTy->getAsCXXRecordDecl();
-    assert(RecordDecl && "The type must be a RecordDecl");
-    llvm::StringLiteral MethodName =
-        KernelDecl->hasAttr<SYCLSimdAttr>() && isSyclAccessorType(FieldTy)
-            ? InitESIMDMethodName
-            : InitMethodName;
-    CXXMethodDecl *InitMethod = getMethodByName(RecordDecl, MethodName);
-    assert(InitMethod && "The type must have the __init method");
-
-    // Don't do -1 here because we count on this to be the first parameter added
-    // (if any).
-    size_t ParamIndex = Params.size();
-    for (const ParmVarDecl *Param : InitMethod->parameters()) {
-      QualType ParamTy = Param->getType();
-      addParam(FD, ParamTy.getCanonicalType());
-
-      // Propagate add_ir_attributes_kernel_parameter attribute.
-      if (const auto *AddIRAttr =
-              Param->getAttr<SYCLAddIRAttributesKernelParameterAttr>())
-        Params.back()->addAttr(AddIRAttr->clone(SemaSYCLRef.getASTContext()));
-
-      // FIXME: This code is temporary, and will be removed once __init_esimd
-      // is removed and property list refactored.
-      // The function handleAccessorType includes a call to
-      // handleAccessorPropertyList. If new classes with property list are
-      // added, this code needs to be refactored to call
-      // handleAccessorPropertyList for each class which requires it.
-      if (ParamTy.getTypePtr()->isPointerType() && isSyclAccessorType(FieldTy))
-        handleAccessorType(FieldTy, RecordDecl, FD->getBeginLoc());
-    }
-    LastParamIndex = ParamIndex;
-    return true;
-  }
-
-  static void setKernelImplicitAttrs(ASTContext &Context, FunctionDecl *FD,
-                                     bool IsSIMDKernel) {
-    // Set implicit attributes.
-    FD->addAttr(OpenCLKernelAttr::CreateImplicit(Context));
-    FD->addAttr(ArtificialAttr::CreateImplicit(Context));
-    if (IsSIMDKernel)
-      FD->addAttr(SYCLSimdAttr::CreateImplicit(Context));
-  }
-
-  static FunctionDecl *createKernelDecl(ASTContext &Ctx, SourceLocation Loc,
-                                        bool IsInline, bool IsSIMDKernel) {
-    // Create this with no prototype, and we can fix this up after we've seen
-    // all the params.
-    FunctionProtoType::ExtProtoInfo Info(CC_OpenCLKernel);
-    QualType FuncType = Ctx.getFunctionType(Ctx.VoidTy, {}, Info);
-
-    FunctionDecl *FD = FunctionDecl::Create(
-        Ctx, Ctx.getTranslationUnitDecl(), Loc, Loc, DeclarationName(),
-        FuncType, Ctx.getTrivialTypeSourceInfo(Ctx.VoidTy), SC_None);
-    FD->setImplicitlyInline(IsInline);
-    setKernelImplicitAttrs(Ctx, FD, IsSIMDKernel);
-
-    // Add kernel to translation unit to see it in AST-dump.
-    Ctx.getTranslationUnitDecl()->addDecl(FD);
-    return FD;
-  }
-
-  // If the record has been marked with SYCLGenerateNewTypeAttr,
-  // it implies that it contains a pointer within. This function
-  // defines a PointerHandler visitor which visits this record
-  // recursively and modifies the address spaces of any pointer
-  // found as required, thereby generating a new record with all
-  // pointers in 'right' address space. PointerHandler.getNewRecordType()
-  // returns this generated type.
-  QualType GenerateNewRecordType(const CXXRecordDecl *RD) {
-    SyclKernelPointerHandler PointerHandler(SemaSYCLRef, RD);
-    KernelObjVisitor Visitor{SemaSYCLRef};
-    Visitor.VisitRecordBases(RD, PointerHandler);
-    Visitor.VisitRecordFields(RD, PointerHandler);
-    return PointerHandler.getNewRecordType();
-  }
-
-  // If the array has been marked with SYCLGenerateNewTypeAttr,
-  // it implies that this is an array of pointers, or an array
-  // of a type which contains pointers. This function generates
-  // a new array with all pointers in the required address space.
-  QualType GenerateNewArrayType(FieldDecl *FD, QualType FieldTy) {
-    const auto *Owner = dyn_cast<CXXRecordDecl>(FD->getParent());
-    SyclKernelPointerHandler PointerHandler(SemaSYCLRef);
-    KernelObjVisitor Visitor{SemaSYCLRef};
-    Visitor.visitArray(Owner, FD, FieldTy, PointerHandler);
-    return PointerHandler.getNewArrayType();
-  }
-
-public:
-  static constexpr const bool VisitInsideSimpleContainers = false;
-  SyclKernelDeclCreator(SemaSYCL &S, SourceLocation Loc, bool IsInline,
-                        bool IsSIMDKernel, FunctionDecl *SYCLKernel)
-      : SyclKernelFieldHandler(S),
-        KernelDecl(
-            createKernelDecl(S.getASTContext(), Loc, IsInline, IsSIMDKernel)),
-        FuncContext(SemaSYCLRef.SemaRef, KernelDecl) {
-    S.addSyclOpenCLKernel(SYCLKernel, KernelDecl);
-    for (const auto *IRAttr :
-         SYCLKernel->specific_attrs<SYCLAddIRAttributesFunctionAttr>()) {
-      KernelDecl->addAttr(IRAttr->clone(SemaSYCLRef.getASTContext()));
-    }
-  }
-
-  ~SyclKernelDeclCreator() {
-    ASTContext &Ctx = SemaSYCLRef.getASTContext();
-    FunctionProtoType::ExtProtoInfo Info(CC_OpenCLKernel);
-
-    SmallVector<QualType, 8> ArgTys;
-    std::transform(std::begin(Params), std::end(Params),
-                   std::back_inserter(ArgTys),
-                   [](const ParmVarDecl *PVD) { return PVD->getType(); });
-
-    QualType FuncType = Ctx.getFunctionType(Ctx.VoidTy, ArgTys, Info);
-    KernelDecl->setType(FuncType);
-    KernelDecl->setParams(Params);
-
-    // Make sure that this is marked as a kernel so that the code-gen can make
-    // decisions based on that. We cannot add this earlier, otherwise the call
-    // to TransformStmt in replaceWithLocalClone can diagnose something that got
-    // diagnosed on the actual kernel.
-    KernelDecl->addAttr(
-        SYCLKernelAttr::CreateImplicit(SemaSYCLRef.getASTContext()));
-
-    SemaSYCLRef.addSyclDeviceDecl(KernelDecl);
-  }
-
-  bool enterStruct(const CXXRecordDecl *, FieldDecl *, QualType) final {
-    ++StructDepth;
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
-    // TODO
-    // ++StructDepth;
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, FieldDecl *, QualType) final {
-    --StructDepth;
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
-    // TODO
-    // --StructDepth;
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                   QualType FieldTy) final {
-    ++StructDepth;
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                   QualType FieldTy) final {
-    --StructDepth;
-    return true;
-  }
-
-  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                             QualType FieldTy) final {
-    const auto *RecordDecl = FieldTy->getAsCXXRecordDecl();
-    assert(RecordDecl && "The type must be a RecordDecl");
-    llvm::StringLiteral MethodName =
-        KernelDecl->hasAttr<SYCLSimdAttr>() && isSyclAccessorType(FieldTy)
-            ? InitESIMDMethodName
-            : InitMethodName;
-    CXXMethodDecl *InitMethod = getMethodByName(RecordDecl, MethodName);
-    assert(InitMethod && "The type must have the __init method");
-
-    // Don't do -1 here because we count on this to be the first parameter added
-    // (if any).
-    size_t ParamIndex = Params.size();
-    for (const ParmVarDecl *Param : InitMethod->parameters()) {
-      QualType ParamTy = Param->getType();
-      addParam(BS, ParamTy.getCanonicalType());
-      // FIXME: This code is temporary, and will be removed once __init_esimd
-      // is removed and property list refactored.
-      // The function handleAccessorType includes a call to
-      // handleAccessorPropertyList. If new classes with property list are
-      // added, this code needs to be refactored to call
-      // handleAccessorPropertyList for each class which requires it.
-      if (ParamTy.getTypePtr()->isPointerType() && isSyclAccessorType(FieldTy))
-        handleAccessorType(FieldTy, RecordDecl, BS.getBeginLoc());
-    }
-    LastParamIndex = ParamIndex;
-    return true;
-  }
-
-  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
-    return handleSpecialType(FD, FieldTy);
-  }
-
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  RecordDecl *wrapField(FieldDecl *Field, QualType FieldTy) {
-    RecordDecl *WrapperClass =
-        SemaSYCLRef.getASTContext().buildImplicitRecord("__wrapper_class");
-    WrapperClass->startDefinition();
-    Field = FieldDecl::Create(
-        SemaSYCLRef.getASTContext(), WrapperClass, SourceLocation(),
-        SourceLocation(), /*Id=*/nullptr, FieldTy,
-        SemaSYCLRef.getASTContext().getTrivialTypeSourceInfo(FieldTy,
-                                                             SourceLocation()),
-        /*BW=*/nullptr, /*Mutable=*/false, /*InitStyle=*/ICIS_NoInit);
-    Field->setAccess(AS_public);
-    WrapperClass->addDecl(Field);
-    WrapperClass->completeDefinition();
-    return WrapperClass;
-  };
-
-  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
-    QualType ModTy = ModifyAddressSpace(SemaSYCLRef, FieldTy);
-    // When the kernel is generated, struct type kernel arguments are
-    // decomposed; i.e. the parameters of the kernel are the fields of the
-    // struct, and not the struct itself. This causes an error in the backend
-    // when the struct field is a pointer, since non-USM pointers cannot be
-    // passed directly. To work around this issue, all pointers inside the
-    // struct are wrapped in a generated '__wrapper_class'.
-    if (StructDepth) {
-      RecordDecl *WrappedPointer = wrapField(FD, ModTy);
-      ModTy = SemaSYCLRef.getASTContext().getRecordType(WrappedPointer);
-    }
-
-    addParam(FD, ModTy);
-    return true;
-  }
-
-  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
-    QualType ModTy = ModifyAddressSpace(SemaSYCLRef, ParamTy);
-    addParam(PD, ModTy);
-    return true;
-  }
-
-  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    QualType ArrayTy = FieldTy;
-
-    // This is an array of pointers or an array of a type with pointer.
-    if (FD->hasAttr<SYCLGenerateNewTypeAttr>())
-      ArrayTy = GenerateNewArrayType(FD, FieldTy);
-
-    // Arrays are wrapped in a struct since they cannot be passed directly.
-    RecordDecl *WrappedArray = wrapField(FD, ArrayTy);
-    addParam(FD, SemaSYCLRef.getASTContext().getRecordType(WrappedArray));
-    return true;
-  }
-
-  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
-    addParam(FD, FieldTy);
-    return true;
-  }
-
-  bool handleScalarType(ParmVarDecl *PD, QualType ParamTy) final {
-    addParam(PD, ParamTy);
-    return true;
-  }
-
-  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
-    StringRef Name = "_arg__sycl_functor";
-    addParam(Name, Ty);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *RD, FieldDecl *FD,
-                             QualType Ty) final {
-    // This is a field which should not be decomposed.
-    CXXRecordDecl *FieldRecordDecl = Ty->getAsCXXRecordDecl();
-    assert(FieldRecordDecl && "Type must be a C++ record type");
-    // Check if we need to generate a new type for this record,
-    // i.e. this record contains pointers.
-    if (FieldRecordDecl->hasAttr<SYCLGenerateNewTypeAttr>())
-      addParam(FD, GenerateNewRecordType(FieldRecordDecl));
-    else
-      addParam(FD, Ty);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *RD, ParmVarDecl *PD,
-                             QualType ParamTy) final {
-    // This is a struct parameter which should not be decomposed.
-    CXXRecordDecl *ParamRecordDecl = ParamTy->getAsCXXRecordDecl();
-    assert(ParamRecordDecl && "Type must be a C++ record type");
-    // Check if we need to generate a new type for this record,
-    // i.e. this record contains pointers.
-    if (ParamRecordDecl->hasAttr<SYCLGenerateNewTypeAttr>())
-      addParam(PD, GenerateNewRecordType(ParamRecordDecl));
-    else
-      addParam(PD, ParamTy);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *Base,
-                             const CXXBaseSpecifier &BS, QualType Ty) final {
-    // This is a base class which should not be decomposed.
-    CXXRecordDecl *BaseRecordDecl = Ty->getAsCXXRecordDecl();
-    assert(BaseRecordDecl && "Type must be a C++ record type");
-    // Check if we need to generate a new type for this record,
-    // i.e. this record contains pointers.
-    if (BaseRecordDecl->hasAttr<SYCLGenerateNewTypeAttr>())
-      addParam(BS, GenerateNewRecordType(BaseRecordDecl));
-    else
-      addParam(BS, Ty);
-    return true;
-  }
-
-  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
-    return handleScalarType(FD, FieldTy);
-  }
-
-  bool handleUnionType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  // Generate kernel argument to initialize specialization constants.
-  void handleSyclKernelHandlerType() {
-    ASTContext &Context = SemaSYCLRef.getASTContext();
-    StringRef Name = "_arg__specialization_constants_buffer";
-    addParam(Name, Context.getPointerType(Context.getAddrSpaceQualType(
-                       Context.CharTy, LangAS::sycl_global)));
-  }
-
-  void setBody(CompoundStmt *KB) { KernelDecl->setBody(KB); }
-
-  FunctionDecl *getKernelDecl() { return KernelDecl; }
-
-  llvm::ArrayRef<ParmVarDecl *> getParamVarDeclsForCurrentField() {
-    return ArrayRef<ParmVarDecl *>(std::begin(Params) + LastParamIndex,
-                                   std::end(Params));
-  }
-};
-
-// This Visitor traverses the AST of the function with
-// `sycl_kernel` attribute and returns the version of “operator()()” that is
-// called by KernelFunc. There will only be one call to KernelFunc in that
-// AST because the DPC++ headers are structured such that the user’s
-// kernel function is only called once. This ensures that the correct
-// “operator()()” function call is returned, when a named function object used
-// to define a kernel has more than one “operator()()” calls defined in it. For
-// example, in the code below, 'operator()(sycl::id<1> id)' is returned based on
-// the 'parallel_for' invocation which takes a 'sycl::range<1>(16)' argument.
-//   class MyKernel {
-//    public:
-//      void operator()() const {
-//        // code
-//      }
-//
-//      [[intel::reqd_sub_group_size(4)]] void operator()(sycl::id<1> id) const
-//      {
-//        // code
-//      }
-//    };
-//
-//    int main() {
-//
-//    Q.submit([&](sycl::handler& cgh) {
-//      MyKernel kernelFunctorObject;
-//      cgh.parallel_for(sycl::range<1>(16), kernelFunctorObject);
-//    });
-//      return 0;
-//    }
-
-class KernelCallOperatorVisitor
-    : public RecursiveASTVisitor<KernelCallOperatorVisitor> {
-
-  FunctionDecl *KernelCallerFunc;
-
-public:
-  CXXMethodDecl *CallOperator = nullptr;
-  const CXXRecordDecl *KernelObj;
-
-  KernelCallOperatorVisitor(FunctionDecl *KernelCallerFunc,
-                            const CXXRecordDecl *KernelObj)
-      : KernelCallerFunc(KernelCallerFunc), KernelObj(KernelObj) {}
-
-  bool VisitCallExpr(CallExpr *CE) {
-    Decl *CalleeDecl = CE->getCalleeDecl();
-    if (isa_and_nonnull<CXXMethodDecl>(CalleeDecl)) {
-      CXXMethodDecl *MD = cast<CXXMethodDecl>(CalleeDecl);
-      if (MD->getOverloadedOperator() == OO_Call &&
-          MD->getParent() == KernelObj) {
-        CallOperator = MD;
-      }
-    }
-    return true;
-  }
-
-  CXXMethodDecl *getCallOperator() {
-    if (CallOperator)
-      return CallOperator;
-
-    TraverseDecl(KernelCallerFunc);
-    return CallOperator;
-  }
-};
-
-class ESIMDKernelDiagnostics : public SyclKernelFieldHandler {
-
-  SourceLocation KernelLoc;
-  bool IsESIMD = false;
-
-  bool handleSpecialType(QualType FieldTy) {
-    const CXXRecordDecl *RecordDecl = FieldTy->getAsCXXRecordDecl();
-
-    if (IsESIMD && !isSyclAccessorType(FieldTy))
-      return SemaSYCLRef.Diag(KernelLoc,
-                              diag::err_sycl_esimd_not_supported_for_type)
-             << RecordDecl;
-    return true;
-  }
-
-public:
-  ESIMDKernelDiagnostics(SemaSYCL &S, SourceLocation Loc, bool IsESIMD)
-      : SyclKernelFieldHandler(S), KernelLoc(Loc), IsESIMD(IsESIMD) {}
-
-  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
-    return handleSpecialType(FieldTy);
-  }
-
-  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                             QualType FieldTy) final {
-    return handleSpecialType(FieldTy);
-  }
-
-  using SyclKernelFieldHandler::handleSyclSpecialType;
-};
-
-class SyclKernelArgsSizeChecker : public SyclKernelFieldHandler {
-  SourceLocation KernelLoc;
-  unsigned SizeOfParams = 0;
-  bool IsESIMD = false;
-
-  void addParam(QualType ArgTy) {
-    SizeOfParams +=
-        SemaSYCLRef.getASTContext().getTypeSizeInChars(ArgTy).getQuantity();
-  }
-
-  bool handleSpecialType(QualType FieldTy) {
-    const CXXRecordDecl *RecordDecl = FieldTy->getAsCXXRecordDecl();
-    assert(RecordDecl && "The type must be a RecordDecl");
-    llvm::StringLiteral MethodName = (IsESIMD && isSyclAccessorType(FieldTy))
-                                         ? InitESIMDMethodName
-                                         : InitMethodName;
-    CXXMethodDecl *InitMethod = getMethodByName(RecordDecl, MethodName);
-    assert(InitMethod && "The type must have the __init method");
-    for (const ParmVarDecl *Param : InitMethod->parameters())
-      addParam(Param->getType());
-    return true;
-  }
-
-public:
-  static constexpr const bool VisitInsideSimpleContainers = false;
-  SyclKernelArgsSizeChecker(SemaSYCL &S, SourceLocation Loc, bool IsESIMD)
-      : SyclKernelFieldHandler(S), KernelLoc(Loc), IsESIMD(IsESIMD) {}
-
-  ~SyclKernelArgsSizeChecker() {
-    if (SizeOfParams > MaxKernelArgsSize)
-      SemaSYCLRef.Diag(KernelLoc, diag::warn_sycl_kernel_too_big_args)
-          << SizeOfParams << MaxKernelArgsSize;
-  }
-
-  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
-    return handleSpecialType(FieldTy);
-  }
-
-  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                             QualType FieldTy) final {
-    return handleSpecialType(FieldTy);
-  }
-
-  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
-    addParam(FieldTy);
-    return true;
-  }
-
-  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
-    addParam(ParamTy);
-    return true;
-  }
-
-  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
-    addParam(FieldTy);
-    return true;
-  }
-
-  bool handleScalarType(ParmVarDecl *PD, QualType ParamTy) final {
-    addParam(ParamTy);
-    return true;
-  }
-
-  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    addParam(FieldTy);
-    return true;
-  }
-
-  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
-    addParam(Ty);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
-                             QualType Ty) final {
-    addParam(Ty);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *, ParmVarDecl *,
-                             QualType ParamTy) final {
-    addParam(ParamTy);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *Base,
-                             const CXXBaseSpecifier &BS, QualType Ty) final {
-    addParam(Ty);
-    return true;
-  }
-
-  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
-    return handleScalarType(FD, FieldTy);
-  }
-
-  bool handleUnionType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-};
-
-std::string getKernelArgDesc(StringRef KernelArgDescription) {
-  if (KernelArgDescription == "")
-    return "";
-  return ("Compiler generated argument for " + KernelArgDescription + ",")
-      .str();
-}
-
-class SyclOptReportCreator : public SyclKernelFieldHandler {
-  SyclKernelDeclCreator &DC;
-  SourceLocation KernelInvocationLoc;
-
-  void addParam(const FieldDecl *KernelArg, QualType KernelArgType,
-                StringRef KernelArgDescription,
-                bool IsCompilerGeneratedType = false) {
-    StringRef NameToEmitInDescription = KernelArg->getName();
-    const RecordDecl *KernelArgParent = KernelArg->getParent();
-    if (KernelArgParent && KernelArgDescription == "decomposed struct/class")
-      NameToEmitInDescription = KernelArgParent->getName();
-
-    unsigned KernelArgSize = SemaSYCLRef.getASTContext()
-                                 .getTypeSizeInChars(KernelArgType)
-                                 .getQuantity();
-
-    SemaSYCLRef.getDiagnostics().getSYCLOptReport().AddKernelArgs(
-        DC.getKernelDecl(), NameToEmitInDescription,
-        IsCompilerGeneratedType ? "Compiler generated"
-                                : KernelArgType.getAsString(),
-        KernelInvocationLoc, KernelArgSize,
-        getKernelArgDesc(KernelArgDescription),
-        (KernelArgDescription == "decomposed struct/class")
-            ? ("Field:" + KernelArg->getName().str() + ", ")
-            : "");
-  }
-
-  void addParam(const FieldDecl *FD, QualType FieldTy) {
-    std::string KernelArgDescription = "";
-    const RecordDecl *RD = FD->getParent();
-    if (RD && RD->hasAttr<SYCLRequiresDecompositionAttr>())
-      KernelArgDescription = "decomposed struct/class";
-
-    addParam(FD, FieldTy, KernelArgDescription);
-  }
-
-  // Handles base classes.
-  void addParam(const CXXBaseSpecifier &, QualType KernelArgType,
-                StringRef KernelArgDescription,
-                bool IsCompilerGeneratedType = false) {
-    unsigned KernelArgSize = SemaSYCLRef.getASTContext()
-                                 .getTypeSizeInChars(KernelArgType)
-                                 .getQuantity();
-    SemaSYCLRef.getDiagnostics().getSYCLOptReport().AddKernelArgs(
-        DC.getKernelDecl(), KernelArgType.getAsString(),
-        IsCompilerGeneratedType ? "Compiler generated"
-                                : KernelArgType.getAsString(),
-        KernelInvocationLoc, KernelArgSize,
-        getKernelArgDesc(KernelArgDescription), "");
-  }
-
-  // Handles specialization constants.
-  void addParam(QualType KernelArgType, std::string KernelArgDescription) {
-    unsigned KernelArgSize = SemaSYCLRef.getASTContext()
-                                 .getTypeSizeInChars(KernelArgType)
-                                 .getQuantity();
-    SemaSYCLRef.getDiagnostics().getSYCLOptReport().AddKernelArgs(
-        DC.getKernelDecl(), "", KernelArgType.getAsString(),
-        KernelInvocationLoc, KernelArgSize,
-        getKernelArgDesc(KernelArgDescription), "");
-  }
-
-public:
-  static constexpr const bool VisitInsideSimpleContainers = false;
-  SyclOptReportCreator(SemaSYCL &S, SyclKernelDeclCreator &DC,
-                       SourceLocation Loc)
-      : SyclKernelFieldHandler(S), DC(DC), KernelInvocationLoc(Loc) {}
-
-  using SyclKernelFieldHandler::handleSyclSpecialType;
-  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
-    for (const auto *Param : DC.getParamVarDeclsForCurrentField())
-      addParam(FD, Param->getType(), FieldTy.getAsString());
-    return true;
-  }
-
-  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                             QualType FieldTy) final {
-    std::string KernelArgDescription = "base class " + FieldTy.getAsString();
-    for (const auto *Param : DC.getParamVarDeclsForCurrentField()) {
-      QualType KernelArgType = Param->getType();
-      unsigned KernelArgSize = SemaSYCLRef.getASTContext()
-                                   .getTypeSizeInChars(KernelArgType)
-                                   .getQuantity();
-      SemaSYCLRef.getDiagnostics().getSYCLOptReport().AddKernelArgs(
-          DC.getKernelDecl(), FieldTy.getAsString(),
-          KernelArgType.getAsString(), KernelInvocationLoc, KernelArgSize,
-          getKernelArgDesc(KernelArgDescription), "");
-    }
-    return true;
-  }
-
-  using SyclKernelFieldHandler::handlePointerType;
-  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
-    std::string KernelArgDescription = "";
-    bool IsCompilerGeneratedType = false;
-    ParmVarDecl *KernelParameter = DC.getParamVarDeclsForCurrentField()[0];
-    // Compiler generated openCL kernel argument for current pointer field
-    // is not a pointer. This means we are processing a nested pointer and
-    // the openCL kernel argument is of type __wrapper_class.
-    if (!KernelParameter->getType()->isPointerType()) {
-      KernelArgDescription = "nested pointer";
-      IsCompilerGeneratedType = true;
-    }
-
-    for (const auto *Param : DC.getParamVarDeclsForCurrentField())
-      addParam(FD, Param->getType(), KernelArgDescription,
-               IsCompilerGeneratedType);
-    return true;
-  }
-
-  using SyclKernelFieldHandler::handleScalarType;
-  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
-    addParam(FD, FieldTy);
-    return true;
-  }
-
-  using SyclKernelFieldHandler::handleSimpleArrayType;
-  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    // Simple arrays are always wrapped.
-    for (const auto *Param : DC.getParamVarDeclsForCurrentField())
-      addParam(FD, Param->getType(), "array", /*IsCompilerGeneratedType*/ true);
-    return true;
-  }
-
-  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
-    addParam(DC.getParamVarDeclsForCurrentField()[0]->getType(),
-             "SYCL Functor");
-    return true;
-  }
-
-  using SyclKernelFieldHandler::handleNonDecompStruct;
-  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
-                             QualType Ty) final {
-    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
-    assert(RD && "Type must be a C++ record type");
-    if (RD->hasAttr<SYCLGenerateNewTypeAttr>())
-      addParam(FD, Ty, "object with pointer", /*IsCompilerGeneratedType*/ true);
-    else
-      addParam(FD, Ty);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                             QualType Ty) final {
-    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
-    assert(RD && "Type must be a C++ record type");
-    if (RD->hasAttr<SYCLGenerateNewTypeAttr>())
-      addParam(BS, Ty, "base class with pointer",
-               /*IsCompilerGeneratedType*/ true);
-    else
-      addParam(BS, Ty, "base class");
-    return true;
-  }
-
-  using SyclKernelFieldHandler::handleUnionType;
-  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
-    return handleScalarType(FD, FieldTy);
-  }
-
-  void handleSyclKernelHandlerType() {
-    addParam(DC.getParamVarDeclsForCurrentField()[0]->getType(),
-             "SYCL2020 specialization constant");
-  }
-};
-
-static bool isESIMDKernelType(CXXMethodDecl *CallOperator) {
-  return (CallOperator != nullptr) && CallOperator->hasAttr<SYCLSimdAttr>();
-}
-
-class SyclKernelBodyCreator : public SyclKernelFieldHandler {
-  bool UseTopLevelKernelObj;
-  SyclKernelDeclCreator &DeclCreator;
-  llvm::SmallVector<Stmt *, 16> BodyStmts;
-  llvm::SmallVector<InitListExpr *, 16> CollectionInitExprs;
-  llvm::SmallVector<Stmt *, 16> FinalizeStmts;
-  // This collection contains the information required to add/remove information
-  // about arrays as we enter them.  The InitializedEntity component is
-  // necessary for initializing child members.  uin64_t is the index of the
-  // current element being worked on, which is updated every time we visit
-  // nextElement.
-  llvm::SmallVector<std::pair<InitializedEntity, uint64_t>, 8> ArrayInfos;
-  VarDecl *KernelObjClone;
-  std::optional<InitializedEntity> VarEntity;
-  llvm::SmallVector<Expr *, 16> MemberExprBases;
-  llvm::SmallVector<Expr *, 16> ArrayParamBases;
-  FunctionDecl *KernelCallerFunc;
-  SourceLocation KernelCallerSrcLoc; // KernelCallerFunc source location.
-  // Contains a count of how many containers we're in.  This is used by the
-  // pointer-struct-wrapping code to ensure that we don't try to wrap
-  // top-level pointers.
-  uint64_t StructDepth = 0;
-  VarDecl *KernelHandlerClone = nullptr;
-  bool IsESIMD = false;
-  CXXMethodDecl *CallOperator = nullptr;
-
-  Stmt *replaceWithLocalClone(ParmVarDecl *OriginalParam, VarDecl *LocalClone,
-                              Stmt *FunctionBody) {
-    // DeclRefExpr with valid source location but with decl which is not marked
-    // as used is invalid.
-    LocalClone->setIsUsed();
-    std::pair<DeclaratorDecl *, DeclaratorDecl *> MappingPair =
-        std::make_pair(OriginalParam, LocalClone);
-    KernelBodyTransform KBT(MappingPair, SemaSYCLRef.SemaRef);
-    return KBT.TransformStmt(FunctionBody).get();
-  }
-
-  // Using the statements/init expressions that we've created, this generates
-  // the kernel body compound stmt. CompoundStmt needs to know its number of
-  // statements in advance to allocate it, so we cannot do this as we go along.
-  CompoundStmt *createKernelBody() {
-    // Push the Kernel function scope to ensure the scope isn't empty
-    SemaSYCLRef.SemaRef.PushFunctionScope();
-
-    if (!UseTopLevelKernelObj) {
-      // Initialize kernel object local clone
-      assert(CollectionInitExprs.size() == 1 &&
-             "Should have been popped down to just the first one");
-      KernelObjClone->setInit(CollectionInitExprs.back());
-    }
-
-    // Replace references to the kernel object in kernel body, to use the
-    // compiler generated local clone
-    Stmt *NewBody =
-        replaceWithLocalClone(KernelCallerFunc->getParamDecl(0), KernelObjClone,
-                              KernelCallerFunc->getBody());
-
-    // If kernel_handler argument is passed by SYCL kernel, replace references
-    // to this argument in kernel body, to use the compiler generated local
-    // clone
-    if (ParmVarDecl *KernelHandlerParam =
-            getSyclKernelHandlerArg(KernelCallerFunc))
-      NewBody = replaceWithLocalClone(KernelHandlerParam, KernelHandlerClone,
-                                      NewBody);
-
-    // Use transformed body (with clones) as kernel body
-    BodyStmts.push_back(NewBody);
-
-    BodyStmts.insert(BodyStmts.end(), FinalizeStmts.begin(),
-                     FinalizeStmts.end());
-
-    return CompoundStmt::Create(SemaSYCLRef.getASTContext(), BodyStmts,
-                                FPOptionsOverride(), {}, {});
-  }
-
-  void annotateHierarchicalParallelismAPICalls() {
-    // Is this a hierarchical parallelism kernel invocation?
-    if (getKernelInvocationKind(KernelCallerFunc) != InvokeParallelForWorkGroup)
-      return;
-
-    // Mark kernel object with work-group scope attribute to avoid work-item
-    // scope memory allocation.
-    KernelObjClone->addAttr(SYCLScopeAttr::CreateImplicit(
-        SemaSYCLRef.getASTContext(), SYCLScopeAttr::Level::WorkGroup));
-
-    assert(CallOperator && "non callable object is passed as kernel obj");
-    // Mark the function that it "works" in a work group scope:
-    // NOTE: In case of wait_for the marker call itself is
-    // marked with work item scope attribute, here  the '()' operator of the
-    // object passed as parameter is marked. This is an optimization -
-    // there are a lot of locals created at parallel_for_work_group
-    // scope before calling the lambda - it is more efficient to have
-    // all of them in the private address space rather then sharing via
-    // the local AS. See parallel_for_work_group implementation in the
-    // SYCL headers.
-    if (!CallOperator->hasAttr<SYCLScopeAttr>()) {
-      CallOperator->addAttr(SYCLScopeAttr::CreateImplicit(
-          SemaSYCLRef.getASTContext(), SYCLScopeAttr::Level::WorkGroup));
-      // Search and mark wait_for calls:
-      MarkWIScopeFnVisitor MarkWIScope(SemaSYCLRef.getASTContext());
-      MarkWIScope.TraverseDecl(CallOperator);
-      // Now mark local variables declared in the PFWG lambda with work group
-      // scope attribute
-      addScopeAttrToLocalVars(*CallOperator);
-    }
-  }
-
-  // Creates a DeclRefExpr to the ParmVar that represents the current field.
-  Expr *createParamReferenceExpr() {
-    ParmVarDecl *KernelParameter =
-        DeclCreator.getParamVarDeclsForCurrentField()[0];
-
-    QualType ParamType = KernelParameter->getOriginalType();
-    Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-        KernelParameter, ParamType, VK_LValue, KernelCallerSrcLoc);
-    return DRE;
-  }
-
-  // Creates a DeclRefExpr to the ParmVar that represents the current pointer
-  // field.
-  Expr *createPointerParamReferenceExpr(QualType PointerTy, bool Wrapped) {
-    ParmVarDecl *KernelParameter =
-        DeclCreator.getParamVarDeclsForCurrentField()[0];
-
-    QualType ParamType = KernelParameter->getOriginalType();
-    Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-        KernelParameter, ParamType, VK_LValue, KernelCallerSrcLoc);
-
-    // Struct Type kernel arguments are decomposed. The pointer fields are
-    // then wrapped inside a compiler generated struct. Therefore when
-    // generating the initializers, we have to 'unwrap' the pointer.
-    if (Wrapped) {
-      CXXRecordDecl *WrapperStruct = ParamType->getAsCXXRecordDecl();
-      // Pointer field wrapped inside __wrapper_class
-      FieldDecl *Pointer = *(WrapperStruct->field_begin());
-      DRE = buildMemberExpr(DRE, Pointer);
-      ParamType = Pointer->getType();
-    }
-
-    DRE = ImplicitCastExpr::Create(SemaSYCLRef.getASTContext(), ParamType,
-                                   CK_LValueToRValue, DRE, /*BasePath=*/nullptr,
-                                   VK_PRValue, FPOptionsOverride());
-
-    if (PointerTy->getPointeeType().getAddressSpace() !=
-        ParamType->getPointeeType().getAddressSpace())
-      DRE = ImplicitCastExpr::Create(SemaSYCLRef.getASTContext(), PointerTy,
-                                     CK_AddressSpaceConversion, DRE, nullptr,
-                                     VK_PRValue, FPOptionsOverride());
-
-    return DRE;
-  }
-
-  Expr *createSimpleArrayParamReferenceExpr(QualType ArrayTy) {
-    ParmVarDecl *KernelParameter =
-        DeclCreator.getParamVarDeclsForCurrentField()[0];
-    QualType ParamType = KernelParameter->getOriginalType();
-    Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-        KernelParameter, ParamType, VK_LValue, KernelCallerSrcLoc);
-
-    // Unwrap the array.
-    CXXRecordDecl *WrapperStruct = ParamType->getAsCXXRecordDecl();
-    FieldDecl *ArrayField = *(WrapperStruct->field_begin());
-    return buildMemberExpr(DRE, ArrayField);
-  }
-
-  // Creates an initialized entity for a field/item. In the case where this is a
-  // field, returns a normal member initializer, if we're in a sub-array of a MD
-  // array, returns an element initializer.
-  InitializedEntity getFieldEntity(FieldDecl *FD, QualType Ty) {
-    if (isArrayElement(FD, Ty))
-      return InitializedEntity::InitializeElement(SemaSYCLRef.getASTContext(),
-                                                  ArrayInfos.back().second,
-                                                  ArrayInfos.back().first);
-    return InitializedEntity::InitializeMember(FD, &VarEntity.value());
-  }
-
-  void addFieldInit(FieldDecl *FD, QualType Ty, MultiExprArg ParamRef) {
-    InitializationKind InitKind =
-        InitializationKind::CreateCopy(KernelCallerSrcLoc, KernelCallerSrcLoc);
-    addFieldInit(FD, Ty, ParamRef, InitKind);
-  }
-
-  void addFieldInit(FieldDecl *FD, QualType Ty, MultiExprArg ParamRef,
-                    InitializationKind InitKind) {
-    addFieldInit(FD, Ty, ParamRef, InitKind, getFieldEntity(FD, Ty));
-  }
-
-  void addFieldInit(FieldDecl *FD, QualType Ty, MultiExprArg ParamRef,
-                    InitializationKind InitKind, InitializedEntity Entity) {
-    InitializationSequence InitSeq(SemaSYCLRef.SemaRef, Entity, InitKind,
-                                   ParamRef);
-    ExprResult Init =
-        InitSeq.Perform(SemaSYCLRef.SemaRef, Entity, InitKind, ParamRef);
-
-    InitListExpr *ParentILE = CollectionInitExprs.back();
-    ParentILE->updateInit(SemaSYCLRef.getASTContext(), ParentILE->getNumInits(),
-                          Init.get());
-  }
-
-  void addBaseInit(const CXXBaseSpecifier &BS, QualType Ty,
-                   InitializationKind InitKind) {
-    InitializedEntity Entity = InitializedEntity::InitializeBase(
-        SemaSYCLRef.getASTContext(), &BS, /*IsInheritedVirtualBase*/ false,
-        &VarEntity.value());
-    InitializationSequence InitSeq(SemaSYCLRef.SemaRef, Entity, InitKind,
-                                   std::nullopt);
-    ExprResult Init =
-        InitSeq.Perform(SemaSYCLRef.SemaRef, Entity, InitKind, std::nullopt);
-
-    InitListExpr *ParentILE = CollectionInitExprs.back();
-    ParentILE->updateInit(SemaSYCLRef.getASTContext(), ParentILE->getNumInits(),
-                          Init.get());
-  }
-
-  void addBaseInit(const CXXBaseSpecifier &BS, QualType Ty,
-                   InitializationKind InitKind, MultiExprArg Args) {
-    InitializedEntity Entity = InitializedEntity::InitializeBase(
-        SemaSYCLRef.getASTContext(), &BS, /*IsInheritedVirtualBase*/ false,
-        &VarEntity.value());
-    InitializationSequence InitSeq(SemaSYCLRef.SemaRef, Entity, InitKind, Args);
-    ExprResult Init =
-        InitSeq.Perform(SemaSYCLRef.SemaRef, Entity, InitKind, Args);
-
-    InitListExpr *ParentILE = CollectionInitExprs.back();
-    ParentILE->updateInit(SemaSYCLRef.getASTContext(), ParentILE->getNumInits(),
-                          Init.get());
-  }
-
-  void addSimpleBaseInit(const CXXBaseSpecifier &BS, QualType Ty) {
-    InitializationKind InitKind =
-        InitializationKind::CreateCopy(KernelCallerSrcLoc, KernelCallerSrcLoc);
-
-    InitializedEntity Entity = InitializedEntity::InitializeBase(
-        SemaSYCLRef.getASTContext(), &BS, /*IsInheritedVirtualBase*/ false,
-        &VarEntity.value());
-
-    Expr *ParamRef = createParamReferenceExpr();
-    InitializationSequence InitSeq(SemaSYCLRef.SemaRef, Entity, InitKind,
-                                   ParamRef);
-    ExprResult Init =
-        InitSeq.Perform(SemaSYCLRef.SemaRef, Entity, InitKind, ParamRef);
-
-    InitListExpr *ParentILE = CollectionInitExprs.back();
-    ParentILE->updateInit(SemaSYCLRef.getASTContext(), ParentILE->getNumInits(),
-                          Init.get());
-  }
-
-  // Adds an initializer that handles a simple initialization of a field.
-  void addSimpleFieldInit(FieldDecl *FD, QualType Ty) {
-    Expr *ParamRef = createParamReferenceExpr();
-    addFieldInit(FD, Ty, ParamRef);
-  }
-
-  Expr *createGetAddressOf(Expr *E) {
-    return UnaryOperator::Create(
-        SemaSYCLRef.getASTContext(), E, UO_AddrOf,
-        SemaSYCLRef.getASTContext().getPointerType(E->getType()), VK_PRValue,
-        OK_Ordinary, KernelCallerSrcLoc, false,
-        SemaSYCLRef.SemaRef.CurFPFeatureOverrides());
-  }
-
-  Expr *createDerefOp(Expr *E) {
-    return UnaryOperator::Create(SemaSYCLRef.getASTContext(), E, UO_Deref,
-                                 E->getType()->getPointeeType(), VK_LValue,
-                                 OK_Ordinary, KernelCallerSrcLoc, false,
-                                 SemaSYCLRef.SemaRef.CurFPFeatureOverrides());
-  }
-
-  Expr *createReinterpretCastExpr(Expr *E, QualType To) {
-    return CXXReinterpretCastExpr::Create(
-        SemaSYCLRef.getASTContext(), To, VK_PRValue, CK_BitCast, E,
-        /*Path=*/nullptr,
-        SemaSYCLRef.getASTContext().getTrivialTypeSourceInfo(To),
-        SourceLocation(), SourceLocation(), SourceRange());
-  }
-
-  void handleGeneratedType(FieldDecl *FD, QualType Ty) {
-    // Equivalent of the following code is generated here:
-    // void ocl_kernel(__generated_type GT) {
-    //   Kernel KernelObjClone { *(reinterpret_cast<UsersType*>(&GT)) };
-    // }
-
-    Expr *RCE = createReinterpretCastExpr(
-        createGetAddressOf(createParamReferenceExpr()),
-        SemaSYCLRef.getASTContext().getPointerType(Ty));
-    Expr *Initializer = createDerefOp(RCE);
-    addFieldInit(FD, Ty, Initializer);
-  }
-
-  void handleGeneratedType(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
-                           QualType Ty) {
-    // Equivalent of the following code is generated here:
-    // void ocl_kernel(__generated_type GT) {
-    //   Kernel KernelObjClone { *(reinterpret_cast<UsersType*>(&GT)) };
-    // }
-    Expr *RCE = createReinterpretCastExpr(
-        createGetAddressOf(createParamReferenceExpr()),
-        SemaSYCLRef.getASTContext().getPointerType(Ty));
-    Expr *Initializer = createDerefOp(RCE);
-    InitializationKind InitKind =
-        InitializationKind::CreateCopy(KernelCallerSrcLoc, KernelCallerSrcLoc);
-    addBaseInit(BS, Ty, InitKind, Initializer);
-  }
-
-  MemberExpr *buildMemberExpr(Expr *Base, ValueDecl *Member) {
-    DeclAccessPair MemberDAP = DeclAccessPair::make(Member, AS_none);
-    MemberExpr *Result = SemaSYCLRef.SemaRef.BuildMemberExpr(
-        Base, /*IsArrow */ false, KernelCallerSrcLoc, NestedNameSpecifierLoc(),
-        KernelCallerSrcLoc, Member, MemberDAP,
-        /*HadMultipleCandidates*/ false,
-        DeclarationNameInfo(Member->getDeclName(), KernelCallerSrcLoc),
-        Member->getType(), VK_LValue, OK_Ordinary);
-    return Result;
-  }
-
-  void addFieldMemberExpr(FieldDecl *FD, QualType Ty) {
-    if (!isArrayElement(FD, Ty))
-      MemberExprBases.push_back(buildMemberExpr(MemberExprBases.back(), FD));
-  }
-
-  void removeFieldMemberExpr(const FieldDecl *FD, QualType Ty) {
-    if (!isArrayElement(FD, Ty))
-      MemberExprBases.pop_back();
-  }
-
-  void createSpecialMethodCall(const CXXRecordDecl *RD, StringRef MethodName,
-                               SmallVectorImpl<Stmt *> &AddTo) {
-    CXXMethodDecl *Method = getMethodByName(RD, MethodName);
-    if (!Method)
-      return;
-
-    unsigned NumParams = Method->getNumParams();
-    llvm::SmallVector<Expr *, 4> ParamDREs(NumParams);
-    llvm::ArrayRef<ParmVarDecl *> KernelParameters =
-        DeclCreator.getParamVarDeclsForCurrentField();
-    for (size_t I = 0; I < NumParams; ++I) {
-      QualType ParamType = KernelParameters[I]->getOriginalType();
-      ParamDREs[I] = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-          KernelParameters[I], ParamType, VK_LValue, KernelCallerSrcLoc);
-    }
-
-    MemberExpr *MethodME = buildMemberExpr(MemberExprBases.back(), Method);
-
-    QualType ResultTy = Method->getReturnType();
-    ExprValueKind VK = Expr::getValueKindForType(ResultTy);
-    ResultTy = ResultTy.getNonLValueExprType(SemaSYCLRef.getASTContext());
-    llvm::SmallVector<Expr *, 4> ParamStmts;
-    const auto *Proto = cast<FunctionProtoType>(Method->getType());
-    SemaSYCLRef.SemaRef.GatherArgumentsForCall(KernelCallerSrcLoc, Method,
-                                               Proto, 0, ParamDREs, ParamStmts);
-    // [kernel_obj or wrapper object].accessor.__init(_ValueType*,
-    // range<int>, range<int>, id<int>)
-    AddTo.push_back(CXXMemberCallExpr::Create(
-        SemaSYCLRef.getASTContext(), MethodME, ParamStmts, ResultTy, VK,
-        KernelCallerSrcLoc, FPOptionsOverride()));
-  }
-
-  // Creates an empty InitListExpr of the correct number of child-inits
-  // of this to append into.
-  void addCollectionInitListExpr(const CXXRecordDecl *RD) {
-    const ASTRecordLayout &Info =
-        SemaSYCLRef.getASTContext().getASTRecordLayout(RD);
-    uint64_t NumInitExprs = Info.getFieldCount() + RD->getNumBases();
-    addCollectionInitListExpr(QualType(RD->getTypeForDecl(), 0), NumInitExprs);
-  }
-
-  InitListExpr *createInitListExpr(const CXXRecordDecl *RD) {
-    const ASTRecordLayout &Info =
-        SemaSYCLRef.getASTContext().getASTRecordLayout(RD);
-    uint64_t NumInitExprs = Info.getFieldCount() + RD->getNumBases();
-    return createInitListExpr(QualType(RD->getTypeForDecl(), 0), NumInitExprs);
-  }
-
-  InitListExpr *createInitListExpr(QualType InitTy, uint64_t NumChildInits) {
-    InitListExpr *ILE = new (SemaSYCLRef.getASTContext())
-        InitListExpr(SemaSYCLRef.getASTContext(), KernelCallerSrcLoc, {},
-                     KernelCallerSrcLoc);
-    ILE->reserveInits(SemaSYCLRef.getASTContext(), NumChildInits);
-    ILE->setType(InitTy);
-
-    return ILE;
-  }
-
-  // Create an empty InitListExpr of the type/size for the rest of the visitor
-  // to append into.
-  void addCollectionInitListExpr(QualType InitTy, uint64_t NumChildInits) {
-
-    InitListExpr *ILE = createInitListExpr(InitTy, NumChildInits);
-    InitListExpr *ParentILE = CollectionInitExprs.back();
-    ParentILE->updateInit(SemaSYCLRef.getASTContext(), ParentILE->getNumInits(),
-                          ILE);
-
-    CollectionInitExprs.push_back(ILE);
-  }
-
-  static VarDecl *createKernelObjClone(ASTContext &Ctx, DeclContext *DC,
-                                       const CXXRecordDecl *KernelObj) {
-    TypeSourceInfo *TSInfo =
-        KernelObj->isLambda() ? KernelObj->getLambdaTypeInfo() : nullptr;
-    IdentifierInfo *Ident = KernelObj->getIdentifier();
-    if (!Ident)
-      Ident = &Ctx.Idents.get("__SYCLKernel");
-
-    VarDecl *VD = VarDecl::Create(
-        Ctx, DC, KernelObj->getLocation(), KernelObj->getLocation(), Ident,
-        QualType(KernelObj->getTypeForDecl(), 0), TSInfo, SC_None);
-    return VD;
-  }
-
-  const llvm::StringLiteral getInitMethodName() const {
-    return IsESIMD ? InitESIMDMethodName : InitMethodName;
-  }
-
-  // Default inits the type, then calls the init-method in the body.
-  bool handleSpecialType(FieldDecl *FD, QualType Ty) {
-    addFieldInit(FD, Ty, std::nullopt,
-                 InitializationKind::CreateDefault(KernelCallerSrcLoc));
-
-    addFieldMemberExpr(FD, Ty);
-
-    const auto *RecordDecl = Ty->getAsCXXRecordDecl();
-    createSpecialMethodCall(RecordDecl, getInitMethodName(), BodyStmts);
-    CXXMethodDecl *FinalizeMethod =
-        getMethodByName(RecordDecl, FinalizeMethodName);
-    // A finalize-method is expected for special type such as stream.
-    if (FinalizeMethod)
-      createSpecialMethodCall(RecordDecl, FinalizeMethodName, FinalizeStmts);
-
-    removeFieldMemberExpr(FD, Ty);
-
-    return true;
-  }
-
-  bool handleSpecialType(const CXXBaseSpecifier &BS, QualType Ty) {
-    const auto *RecordDecl = Ty->getAsCXXRecordDecl();
-    addBaseInit(BS, Ty, InitializationKind::CreateDefault(KernelCallerSrcLoc));
-    createSpecialMethodCall(RecordDecl, getInitMethodName(), BodyStmts);
-    return true;
-  }
-
-  // Generate __init call for kernel handler argument
-  void handleSpecialType(QualType KernelHandlerTy) {
-    DeclRefExpr *KernelHandlerCloneRef = DeclRefExpr::Create(
-        SemaSYCLRef.getASTContext(), NestedNameSpecifierLoc(),
-        KernelCallerSrcLoc, KernelHandlerClone, false, DeclarationNameInfo(),
-        KernelHandlerTy, VK_LValue);
-    const auto *RecordDecl =
-        KernelHandlerClone->getType()->getAsCXXRecordDecl();
-    MemberExprBases.push_back(KernelHandlerCloneRef);
-    createSpecialMethodCall(RecordDecl, InitSpecConstantsBuffer, BodyStmts);
-    MemberExprBases.pop_back();
-  }
-
-  void createKernelHandlerClone(ASTContext &Ctx, DeclContext *DC,
-                                ParmVarDecl *KernelHandlerArg) {
-    QualType Ty = KernelHandlerArg->getType();
-    TypeSourceInfo *TSInfo = Ctx.getTrivialTypeSourceInfo(Ty);
-    KernelHandlerClone =
-        VarDecl::Create(Ctx, DC, KernelCallerSrcLoc, KernelCallerSrcLoc,
-                        KernelHandlerArg->getIdentifier(), Ty, TSInfo, SC_None);
-
-    // Default initialize clone
-    InitializedEntity VarEntity =
-        InitializedEntity::InitializeVariable(KernelHandlerClone);
-    InitializationKind InitKind =
-        InitializationKind::CreateDefault(KernelCallerSrcLoc);
-    InitializationSequence InitSeq(SemaSYCLRef.SemaRef, VarEntity, InitKind,
-                                   std::nullopt);
-    ExprResult Init =
-        InitSeq.Perform(SemaSYCLRef.SemaRef, VarEntity, InitKind, std::nullopt);
-    KernelHandlerClone->setInit(
-        SemaSYCLRef.SemaRef.MaybeCreateExprWithCleanups(Init.get()));
-    KernelHandlerClone->setInitStyle(VarDecl::CallInit);
-  }
-
-  Expr *createArraySubscriptExpr(uint64_t Index, Expr *ArrayRef) {
-    QualType SizeT = SemaSYCLRef.getASTContext().getSizeType();
-    llvm::APInt IndexVal{
-        static_cast<unsigned>(SemaSYCLRef.getASTContext().getTypeSize(SizeT)),
-        Index, SizeT->isSignedIntegerType()};
-    auto IndexLiteral = IntegerLiteral::Create(
-        SemaSYCLRef.getASTContext(), IndexVal, SizeT, KernelCallerSrcLoc);
-    ExprResult IndexExpr = SemaSYCLRef.SemaRef.CreateBuiltinArraySubscriptExpr(
-        ArrayRef, KernelCallerSrcLoc, IndexLiteral, KernelCallerSrcLoc);
-    assert(!IndexExpr.isInvalid());
-    return IndexExpr.get();
-  }
-
-  void addSimpleArrayInit(FieldDecl *FD, QualType FieldTy) {
-    Expr *ArrayRef = createSimpleArrayParamReferenceExpr(FieldTy);
-    InitializationKind InitKind = InitializationKind::CreateDirect({}, {}, {});
-
-    InitializedEntity Entity = InitializedEntity::InitializeMember(
-        FD, &VarEntity.value(), /*Implicit*/ true);
-
-    addFieldInit(FD, FieldTy, ArrayRef, InitKind, Entity);
-  }
-
-  void addArrayElementInit(FieldDecl *FD, QualType T) {
-    Expr *RCE = createReinterpretCastExpr(
-        createGetAddressOf(ArrayParamBases.pop_back_val()),
-        SemaSYCLRef.getASTContext().getPointerType(T));
-    Expr *Initializer = createDerefOp(RCE);
-    addFieldInit(FD, T, Initializer);
-  }
-
-  // This function is recursive in order to handle
-  // multi-dimensional arrays. If the array element is
-  // an array, it implies that the array is multi-dimensional.
-  // We continue recursion till we reach a non-array element to
-  // generate required array subscript expressions.
-  void createArrayInit(FieldDecl *FD, QualType T) {
-    const ConstantArrayType *CAT =
-        SemaSYCLRef.getASTContext().getAsConstantArrayType(T);
-
-    if (!CAT) {
-      addArrayElementInit(FD, T);
-      return;
-    }
-
-    QualType ET = CAT->getElementType();
-    uint64_t ElemCount = CAT->getSize().getZExtValue();
-    enterArray(FD, T, ET);
-
-    for (uint64_t Index = 0; Index < ElemCount; ++Index) {
-      ArrayInfos.back().second = Index;
-      Expr *ArraySubscriptExpr =
-          createArraySubscriptExpr(Index, ArrayParamBases.back());
-      ArrayParamBases.push_back(ArraySubscriptExpr);
-      createArrayInit(FD, ET);
-    }
-
-    leaveArray(FD, T, ET);
-  }
-
-  // This function is used to create initializers for a top
-  // level array which contains pointers. The openCl kernel
-  // parameter for this array will be a wrapper class
-  // which contains the generated type. This function generates
-  // code equivalent to:
-  // void ocl_kernel(__wrapper_class WrappedGT) {
-  //   Kernel KernelObjClone {
-  //   *reinterpret_cast<UserArrayET*>(&WrappedGT.GeneratedArr[0]),
-  //                           *reinterpret_cast<UserArrayET*>(&WrappedGT.GeneratedArr[1]),
-  //                           *reinterpret_cast<UserArrayET*>(&WrappedGT.GeneratedArr[2])
-  //                         };
-  // }
-  void handleGeneratedArrayType(FieldDecl *FD, QualType FieldTy) {
-    ArrayParamBases.push_back(createSimpleArrayParamReferenceExpr(FieldTy));
-    createArrayInit(FD, FieldTy);
-  }
-
-public:
-  static constexpr const bool VisitInsideSimpleContainers = false;
-  SyclKernelBodyCreator(SemaSYCL &S, SyclKernelDeclCreator &DC,
-                        const CXXRecordDecl *KernelObj,
-                        FunctionDecl *KernelCallerFunc, bool IsSIMDKernel,
-                        CXXMethodDecl *CallOperator)
-      : SyclKernelFieldHandler(S),
-        UseTopLevelKernelObj(KernelObjVisitor::useTopLevelKernelObj(KernelObj)),
-        DeclCreator(DC),
-        KernelObjClone(UseTopLevelKernelObj
-                           ? nullptr
-                           : createKernelObjClone(S.getASTContext(),
-                                                  DC.getKernelDecl(),
-                                                  KernelObj)),
-        VarEntity(), KernelCallerFunc(KernelCallerFunc),
-        KernelCallerSrcLoc(KernelCallerFunc->getLocation()),
-        IsESIMD(IsSIMDKernel), CallOperator(CallOperator) {
-    if (!UseTopLevelKernelObj) {
-      VarEntity.emplace(InitializedEntity::InitializeVariable(KernelObjClone));
-      Stmt *DS = new (S.getASTContext()) DeclStmt(
-          DeclGroupRef(KernelObjClone), KernelCallerSrcLoc, KernelCallerSrcLoc);
-      BodyStmts.push_back(DS);
-      CollectionInitExprs.push_back(createInitListExpr(KernelObj));
-      DeclRefExpr *KernelObjCloneRef = DeclRefExpr::Create(
-          S.getASTContext(), NestedNameSpecifierLoc(), KernelCallerSrcLoc,
-          KernelObjClone, false, DeclarationNameInfo(),
-          QualType(KernelObj->getTypeForDecl(), 0), VK_LValue);
-      MemberExprBases.push_back(KernelObjCloneRef);
-    }
-  }
-
-  ~SyclKernelBodyCreator() {
-    annotateHierarchicalParallelismAPICalls();
-    CompoundStmt *KernelBody = createKernelBody();
-    DeclCreator.setBody(KernelBody);
-  }
-
-  bool handleSyclSpecialType(FieldDecl *FD, QualType Ty) final {
-    return handleSpecialType(FD, Ty);
-  }
-
-  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                             QualType Ty) final {
-    return handleSpecialType(BS, Ty);
-  }
-
-  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
-    Expr *PointerRef =
-        createPointerParamReferenceExpr(FieldTy, StructDepth != 0);
-    addFieldInit(FD, FieldTy, PointerRef);
-    return true;
-  }
-
-  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    if (FD->hasAttr<SYCLGenerateNewTypeAttr>())
-      handleGeneratedArrayType(FD, FieldTy);
-    else
-      addSimpleArrayInit(FD, FieldTy);
-    return true;
-  }
-
-  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
-    // As the functor is passed as a whole, use the param as the vardecl
-    // otherwise used as the clone.
-    KernelObjClone = DeclCreator.getParamVarDeclsForCurrentField()[0];
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
-                             QualType Ty) final {
-    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
-    assert(RD && "Type must be a C++ record type");
-    if (RD->hasAttr<SYCLGenerateNewTypeAttr>())
-      handleGeneratedType(FD, Ty);
-    else
-      addSimpleFieldInit(FD, Ty);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *RD,
-                             const CXXBaseSpecifier &BS, QualType Ty) final {
-    CXXRecordDecl *BaseDecl = Ty->getAsCXXRecordDecl();
-    assert(BaseDecl && "Type must be a C++ record type");
-    if (BaseDecl->hasAttr<SYCLGenerateNewTypeAttr>())
-      handleGeneratedType(RD, BS, Ty);
-    else
-      addSimpleBaseInit(BS, Ty);
-    return true;
-  }
-
-  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
-    addSimpleFieldInit(FD, FieldTy);
-    return true;
-  }
-
-  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
-    addSimpleFieldInit(FD, FieldTy);
-    return true;
-  }
-
-  // Default inits the type, then calls the init-method in the body
-  void handleSyclKernelHandlerType(ParmVarDecl *KernelHandlerArg) {
-
-    // Create and default initialize local clone of kernel handler
-    createKernelHandlerClone(SemaSYCLRef.getASTContext(),
-                             DeclCreator.getKernelDecl(), KernelHandlerArg);
-
-    // Add declaration statement to openCL kernel body
-    Stmt *DS = new (SemaSYCLRef.getASTContext())
-        DeclStmt(DeclGroupRef(KernelHandlerClone), KernelCallerSrcLoc,
-                 KernelCallerSrcLoc);
-    BodyStmts.push_back(DS);
-
-    // Generate
-    // KernelHandlerClone.__init_specialization_constants_buffer(specialization_constants_buffer)
-    // call if target does not have native support for specialization constants.
-    // Here, specialization_constants_buffer is the compiler generated kernel
-    // argument of type char*.
-    if (!isDefaultSPIRArch(SemaSYCLRef.getASTContext()))
-      handleSpecialType(KernelHandlerArg->getType());
-  }
-
-  bool enterStruct(const CXXRecordDecl *RD, FieldDecl *FD, QualType Ty) final {
-    ++StructDepth;
-    addCollectionInitListExpr(Ty->getAsCXXRecordDecl());
-
-    addFieldMemberExpr(FD, Ty);
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
-    --StructDepth;
-    CollectionInitExprs.pop_back();
-
-    removeFieldMemberExpr(FD, Ty);
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
-                   QualType) final {
-    ++StructDepth;
-
-    CXXCastPath BasePath;
-    QualType DerivedTy(RD->getTypeForDecl(), 0);
-    QualType BaseTy = BS.getType();
-    SemaSYCLRef.SemaRef.CheckDerivedToBaseConversion(
-        DerivedTy, BaseTy, KernelCallerSrcLoc, SourceRange(), &BasePath,
-        /*IgnoreBaseAccess*/ true);
-    auto Cast = ImplicitCastExpr::Create(
-        SemaSYCLRef.getASTContext(), BaseTy, CK_DerivedToBase,
-        MemberExprBases.back(),
-        /* CXXCastPath=*/&BasePath, VK_LValue, FPOptionsOverride());
-    MemberExprBases.push_back(Cast);
-    addCollectionInitListExpr(BaseTy->getAsCXXRecordDecl());
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
-                   QualType) final {
-    --StructDepth;
-    MemberExprBases.pop_back();
-    CollectionInitExprs.pop_back();
-    return true;
-  }
-
-  bool enterArray(FieldDecl *FD, QualType ArrayType,
-                  QualType ElementType) final {
-    const ConstantArrayType *CAT =
-        SemaSYCLRef.getASTContext().getAsConstantArrayType(ArrayType);
-    assert(CAT && "Should only be called on constant-size array.");
-    uint64_t ArraySize = CAT->getSize().getZExtValue();
-    addCollectionInitListExpr(ArrayType, ArraySize);
-    ArrayInfos.emplace_back(getFieldEntity(FD, ArrayType), 0);
-
-    // If this is the top-level array, we need to make a MemberExpr in addition
-    // to an array subscript.
-    addFieldMemberExpr(FD, ArrayType);
-    return true;
-  }
-
-  bool nextElement(QualType, uint64_t Index) final {
-    ArrayInfos.back().second = Index;
-
-    // Pop off the last member expr base.
-    if (Index != 0)
-      MemberExprBases.pop_back();
-
-    MemberExprBases.push_back(
-        createArraySubscriptExpr(Index, MemberExprBases.back()));
-    return true;
-  }
-
-  bool leaveArray(FieldDecl *FD, QualType ArrayType,
-                  QualType ElementType) final {
-    CollectionInitExprs.pop_back();
-    ArrayInfos.pop_back();
-
-    // Remove the IndexExpr.
-    if (!FD->hasAttr<SYCLGenerateNewTypeAttr>())
-      MemberExprBases.pop_back();
-    else
-      ArrayParamBases.pop_back();
-
-    // Remove the field access expr as well.
-    removeFieldMemberExpr(FD, ArrayType);
-    return true;
-  }
-  using SyclKernelFieldHandler::enterArray;
-  using SyclKernelFieldHandler::enterStruct;
-  using SyclKernelFieldHandler::handleNonDecompStruct;
-  using SyclKernelFieldHandler::handlePointerType;
-  using SyclKernelFieldHandler::handleScalarType;
-  using SyclKernelFieldHandler::handleSyclSpecialType;
-  using SyclKernelFieldHandler::handleUnionType;
-  using SyclKernelFieldHandler::leaveArray;
-  using SyclKernelFieldHandler::leaveStruct;
-};
-
-class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
-  SyclKernelDeclCreator &DeclCreator;
-  llvm::SmallVector<Stmt *, 16> BodyStmts;
-  FunctionDecl *FreeFunc = nullptr;
-  SourceLocation FreeFunctionSrcLoc; // Free function source location.
-  llvm::SmallVector<Expr *, 8> ArgExprs;
-
-  // Creates a DeclRefExpr to the ParmVar that represents the current free
-  // function parameter.
-  Expr *createParamReferenceExpr() {
-    ParmVarDecl *FreeFunctionParameter =
-        DeclCreator.getParamVarDeclsForCurrentField()[0];
-
-    QualType FreeFunctionParamType = FreeFunctionParameter->getOriginalType();
-    Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-        FreeFunctionParameter, FreeFunctionParamType, VK_LValue,
-        FreeFunctionSrcLoc);
-    DRE = SemaSYCLRef.SemaRef.DefaultLvalueConversion(DRE).get();
-    return DRE;
-  }
-
-  // Creates a DeclRefExpr to the ParmVar that represents the current pointer
-  // parameter.
-  Expr *createPointerParamReferenceExpr(QualType PointerTy) {
-    ParmVarDecl *FreeFunctionParameter =
-        DeclCreator.getParamVarDeclsForCurrentField()[0];
-
-    QualType FreeFunctionParamType = FreeFunctionParameter->getOriginalType();
-    Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-        FreeFunctionParameter, FreeFunctionParamType, VK_LValue,
-        FreeFunctionSrcLoc);
-    DRE = SemaSYCLRef.SemaRef.DefaultLvalueConversion(DRE).get();
-
-    if (PointerTy->getPointeeType().getAddressSpace() !=
-        FreeFunctionParamType->getPointeeType().getAddressSpace())
-      DRE = ImplicitCastExpr::Create(SemaSYCLRef.getASTContext(), PointerTy,
-                                     CK_AddressSpaceConversion, DRE, nullptr,
-                                     VK_PRValue, FPOptionsOverride());
-    return DRE;
-  }
-
-  Expr *createGetAddressOf(Expr *E) {
-    return UnaryOperator::Create(
-        SemaSYCLRef.getASTContext(), E, UO_AddrOf,
-        SemaSYCLRef.getASTContext().getPointerType(E->getType()), VK_PRValue,
-        OK_Ordinary, SourceLocation(), false,
-        SemaSYCLRef.SemaRef.CurFPFeatureOverrides());
-  }
-
-  Expr *createDerefOp(Expr *E) {
-    return UnaryOperator::Create(SemaSYCLRef.getASTContext(), E, UO_Deref,
-                                 E->getType()->getPointeeType(), VK_LValue,
-                                 OK_Ordinary, SourceLocation(), false,
-                                 SemaSYCLRef.SemaRef.CurFPFeatureOverrides());
-  }
-
-  Expr *createReinterpretCastExpr(Expr *E, QualType To) {
-    return CXXReinterpretCastExpr::Create(
-        SemaSYCLRef.getASTContext(), To, VK_PRValue, CK_BitCast, E,
-        /*Path=*/nullptr,
-        SemaSYCLRef.getASTContext().getTrivialTypeSourceInfo(To),
-        SourceLocation(), SourceLocation(), SourceRange());
-  }
-
-  Expr *createCopyInitExpr(ParmVarDecl *OrigFunctionParameter) {
-    Expr *DRE = createParamReferenceExpr();
-
-    assert(OrigFunctionParameter && "no parameter?");
-
-    CXXRecordDecl *RD = OrigFunctionParameter->getType()->getAsCXXRecordDecl();
-    InitializedEntity Entity = InitializedEntity::InitializeParameter(
-        SemaSYCLRef.getASTContext(), OrigFunctionParameter);
-
-    if (RD->hasAttr<SYCLGenerateNewTypeAttr>()) {
-      DRE = createReinterpretCastExpr(
-          createGetAddressOf(DRE), SemaSYCLRef.getASTContext().getPointerType(
-                                       OrigFunctionParameter->getType()));
-      DRE = createDerefOp(DRE);
-    }
-
-    ExprResult ArgE = SemaSYCLRef.SemaRef.PerformCopyInitialization(
-        Entity, SourceLocation(), DRE, false, false);
-    return ArgE.getAs<Expr>();
-  }
-
-  // For a free function such as:
-  // void f(int i, int* p, struct Simple S) { ... }
-  //
-  // Keep the function as-is for the version callable from device code.
-  // void f(int i, int *p, struct Simple S) { ... }
-  //
-  // For the host-callable kernel function generate this:
-  // void __sycl_kernel_f(int __arg_i, int* __arg_p, struct Simple __arg_S)
-  // {
-  //   f(__arg_i, __arg_p, __arg_S);
-  // }
-  CompoundStmt *createFreeFunctionKernelBody() {
-    SemaSYCLRef.SemaRef.PushFunctionScope();
-    Expr *Fn = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-        FreeFunc, FreeFunc->getType(), VK_LValue, FreeFunctionSrcLoc);
-    ASTContext &Context = SemaSYCLRef.getASTContext();
-    QualType ResultTy = FreeFunc->getReturnType();
-    ExprValueKind VK = Expr::getValueKindForType(ResultTy);
-    ResultTy = ResultTy.getNonLValueExprType(Context);
-    Fn = ImplicitCastExpr::Create(Context,
-                                  Context.getPointerType(FreeFunc->getType()),
-                                  CK_FunctionToPointerDecay, Fn, nullptr,
-                                  VK_PRValue, FPOptionsOverride());
-    auto CallExpr = CallExpr::Create(Context, Fn, ArgExprs, ResultTy, VK,
-                                     FreeFunctionSrcLoc, FPOptionsOverride());
-    BodyStmts.push_back(CallExpr);
-    return CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
-                                {});
-  }
-
-public:
-  static constexpr const bool VisitInsideSimpleContainers = false;
-
-  FreeFunctionKernelBodyCreator(SemaSYCL &S, SyclKernelDeclCreator &DC,
-                                FunctionDecl *FF)
-      : SyclKernelFieldHandler(S), DeclCreator(DC), FreeFunc(FF),
-        FreeFunctionSrcLoc(FF->getLocation()) {}
-
-  ~FreeFunctionKernelBodyCreator() {
-    CompoundStmt *KernelBody = createFreeFunctionKernelBody();
-    DeclCreator.setBody(KernelBody);
-  }
-
-  bool handleSyclSpecialType(FieldDecl *FD, QualType Ty) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
-                             QualType Ty) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
-    Expr *PointerRef = createPointerParamReferenceExpr(ParamTy);
-    ArgExprs.push_back(PointerRef);
-    return true;
-  }
-
-  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
-                             QualType Ty) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *, ParmVarDecl *PD,
-                             QualType) final {
-    Expr *TempCopy = createCopyInitExpr(PD);
-    ArgExprs.push_back(TempCopy);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *RD,
-                             const CXXBaseSpecifier &BS, QualType Ty) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleScalarType(ParmVarDecl *, QualType) final {
-    Expr *ParamRef = createParamReferenceExpr();
-    ArgExprs.push_back(ParamRef);
-    return true;
-  }
-
-  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handleUnionType(ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *RD, FieldDecl *FD, QualType Ty) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
-                   QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
-                   QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool enterArray(FieldDecl *FD, QualType ArrayType,
-                  QualType ElementType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool enterArray(ParmVarDecl *PD, QualType ArrayType,
-                  QualType ElementType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool leaveArray(FieldDecl *FD, QualType ArrayType,
-                  QualType ElementType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool leaveArray(ParmVarDecl *PD, QualType ArrayType,
-                  QualType ElementType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-};
-
-// Kernels are only the unnamed-lambda feature if the feature is enabled, AND
-// the first template argument has been corrected by the library to match the
-// functor type.
-static bool IsSYCLUnnamedKernel(SemaSYCL &SemaSYCLRef, const FunctionDecl *FD) {
-  if (!SemaSYCLRef.getLangOpts().SYCLUnnamedLambda)
-    return false;
-
-  QualType FunctorTy = GetSYCLKernelObjectType(FD);
-  QualType TmplArgTy = calculateKernelNameType(SemaSYCLRef.getASTContext(), FD);
-  return SemaSYCLRef.getASTContext().hasSameType(FunctorTy, TmplArgTy);
-}
-
-class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
-  SYCLIntegrationHeader &Header;
-  int64_t CurOffset = 0;
-  llvm::SmallVector<size_t, 16> ArrayBaseOffsets;
-  int StructDepth = 0;
-
-  // A series of functions to calculate the change in offset based on the type.
-  int64_t offsetOf(const FieldDecl *FD, QualType ArgTy) const {
-    return isArrayElement(FD, ArgTy)
-               ? 0
-               : SemaSYCLRef.getASTContext().getFieldOffset(FD) / 8;
-  }
-  // For free functions each parameter is stand-alone, so offsets within a
-  // lambda/function object are not relevant. Therefore offsetOf will always be
-  // 0.
-  int64_t offsetOf(const ParmVarDecl *, QualType) const { return 0; }
-
-  int64_t offsetOf(const CXXRecordDecl *RD, const CXXRecordDecl *Base) const {
-    const ASTRecordLayout &Layout =
-        SemaSYCLRef.getASTContext().getASTRecordLayout(RD);
-    return Layout.getBaseClassOffset(Base).getQuantity();
-  }
-
-  void addParam(const FieldDecl *FD, QualType ArgTy,
-                SYCLIntegrationHeader::kernel_param_kind_t Kind) {
-    addParam(ArgTy, Kind, offsetOf(FD, ArgTy));
-  }
-
-  // For free functions we increment the current offset as each parameter is
-  // added.
-  void addParam(const ParmVarDecl *PD, QualType ParamTy,
-                SYCLIntegrationHeader::kernel_param_kind_t Kind) {
-    addParam(ParamTy, Kind, offsetOf(PD, ParamTy));
-    CurOffset +=
-        SemaSYCLRef.getASTContext().getTypeSizeInChars(ParamTy).getQuantity();
-  }
-
-  void addParam(QualType ParamTy,
-                SYCLIntegrationHeader::kernel_param_kind_t Kind,
-                uint64_t OffsetAdj) {
-    uint64_t Size;
-    Size =
-        SemaSYCLRef.getASTContext().getTypeSizeInChars(ParamTy).getQuantity();
-    Header.addParamDesc(Kind, static_cast<unsigned>(Size),
-                        static_cast<unsigned>(CurOffset + OffsetAdj));
-  }
-
-public:
-  static constexpr const bool VisitInsideSimpleContainers = false;
-  SyclKernelIntHeaderCreator(bool IsESIMD, SemaSYCL &S,
-                             SYCLIntegrationHeader &H,
-                             const CXXRecordDecl *KernelObj, QualType NameType,
-                             FunctionDecl *KernelFunc)
-      : SyclKernelFieldHandler(S), Header(H) {
-
-    // The header needs to access the kernel object size.
-    int64_t ObjSize = SemaSYCLRef.getASTContext()
-                          .getTypeSizeInChars(KernelObj->getTypeForDecl())
-                          .getQuantity();
-    Header.startKernel(KernelFunc, NameType, KernelObj->getLocation(), IsESIMD,
-                       IsSYCLUnnamedKernel(S, KernelFunc), ObjSize);
-  }
-
-  SyclKernelIntHeaderCreator(SemaSYCL &S, SYCLIntegrationHeader &H,
-                             QualType NameType, FunctionDecl *FreeFunc)
-      : SyclKernelFieldHandler(S), Header(H) {
-    Header.startKernel(FreeFunc, NameType, FreeFunc->getLocation(),
-                       false /*IsESIMD*/, true /*IsSYCLUnnamedKernel*/,
-                       0 /*ObjSize*/);
-  }
-
-  bool handleSyclSpecialType(const CXXRecordDecl *RD,
-                             const CXXBaseSpecifier &BC,
-                             QualType FieldTy) final {
-    const auto *AccTy =
-        cast<ClassTemplateSpecializationDecl>(FieldTy->getAsRecordDecl());
-    assert(AccTy->getTemplateArgs().size() >= 2 &&
-           "Incorrect template args for Accessor Type");
-    int Dims = static_cast<int>(
-        AccTy->getTemplateArgs()[1].getAsIntegral().getExtValue());
-    int Info = getAccessTarget(FieldTy, AccTy) | (Dims << 11);
-    Header.addParamDesc(SYCLIntegrationHeader::kind_accessor, Info,
-                        CurOffset +
-                            offsetOf(RD, BC.getType()->getAsCXXRecordDecl()));
-    return true;
-  }
-
-  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
-    const auto *ClassTy = FieldTy->getAsCXXRecordDecl();
-    assert(ClassTy && "Type must be a C++ record type");
-    if (isSyclAccessorType(FieldTy)) {
-      const auto *AccTy =
-          cast<ClassTemplateSpecializationDecl>(FieldTy->getAsRecordDecl());
-      assert(AccTy->getTemplateArgs().size() >= 2 &&
-             "Incorrect template args for Accessor Type");
-      int Dims = static_cast<int>(
-          AccTy->getTemplateArgs()[1].getAsIntegral().getExtValue());
-      int Info = getAccessTarget(FieldTy, AccTy) | (Dims << 11);
-
-      Header.addParamDesc(SYCLIntegrationHeader::kind_accessor, Info,
-                          CurOffset + offsetOf(FD, FieldTy));
-    } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::stream)) {
-      addParam(FD, FieldTy, SYCLIntegrationHeader::kind_stream);
-    } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::work_group_memory)) {
-      addParam(FieldTy, SYCLIntegrationHeader::kind_work_group_memory,
-               offsetOf(FD, FieldTy));
-    } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::sampler) ||
-               SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::annotated_ptr) ||
-               SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::annotated_arg)) {
-      CXXMethodDecl *InitMethod = getMethodByName(ClassTy, InitMethodName);
-      assert(InitMethod && "type must have __init method");
-      const ParmVarDecl *InitArg = InitMethod->getParamDecl(0);
-      assert(InitArg && "Init method must have arguments");
-      QualType T = InitArg->getType();
-      SYCLIntegrationHeader::kernel_param_kind_t ParamKind =
-          SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::sampler)
-              ? SYCLIntegrationHeader::kind_sampler
-              : (T->isPointerType() ? SYCLIntegrationHeader::kind_pointer
-                                    : SYCLIntegrationHeader::kind_std_layout);
-      addParam(T, ParamKind, offsetOf(FD, FieldTy));
-    } else {
-      llvm_unreachable(
-          "Unexpected SYCL special class when generating integration header");
-    }
-    return true;
-  }
-
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
-    addParam(FD, FieldTy,
-             ((StructDepth) ? SYCLIntegrationHeader::kind_std_layout
-                            : SYCLIntegrationHeader::kind_pointer));
-    return true;
-  }
-
-  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
-    addParam(PD, ParamTy, SYCLIntegrationHeader::kind_pointer);
-    return true;
-  }
-
-  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
-    addParam(FD, FieldTy, SYCLIntegrationHeader::kind_std_layout);
-    return true;
-  }
-
-  bool handleScalarType(ParmVarDecl *PD, QualType ParamTy) final {
-    addParam(PD, ParamTy, SYCLIntegrationHeader::kind_std_layout);
-    return true;
-  }
-
-  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    // Arrays are always wrapped inside of structs, so just treat it as a simple
-    // struct.
-    addParam(FD, FieldTy, SYCLIntegrationHeader::kind_std_layout);
-    return true;
-  }
-
-  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
-    addParam(Ty, SYCLIntegrationHeader::kind_std_layout, /*Offset=*/0);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
-                             QualType Ty) final {
-    addParam(FD, Ty, SYCLIntegrationHeader::kind_std_layout);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *, ParmVarDecl *PD,
-                             QualType ParamTy) final {
-    addParam(PD, ParamTy, SYCLIntegrationHeader::kind_std_layout);
-    return true;
-  }
-
-  bool handleNonDecompStruct(const CXXRecordDecl *Base,
-                             const CXXBaseSpecifier &, QualType Ty) final {
-    addParam(Ty, SYCLIntegrationHeader::kind_std_layout,
-             offsetOf(Base, Ty->getAsCXXRecordDecl()));
-    return true;
-  }
-
-  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
-    return handleScalarType(FD, FieldTy);
-  }
-
-  bool handleUnionType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  void handleSyclKernelHandlerType(QualType Ty) {
-    // The compiler generated kernel argument used to initialize SYCL 2020
-    // specialization constants, `specialization_constants_buffer`, should
-    // have corresponding entry in integration header.
-    ASTContext &Context = SemaSYCLRef.getASTContext();
-    // Offset is zero since kernel_handler argument is not part of
-    // kernel object (i.e. it is not captured)
-    addParam(Context.getPointerType(Context.CharTy),
-             SYCLIntegrationHeader::kind_specialization_constants_buffer, 0);
-  }
-
-  bool enterStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
-    ++StructDepth;
-    CurOffset += offsetOf(FD, Ty);
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
-    --StructDepth;
-    CurOffset -= offsetOf(FD, Ty);
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool enterStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
-                   QualType) final {
-    CurOffset += offsetOf(RD, BS.getType()->getAsCXXRecordDecl());
-    return true;
-  }
-
-  bool leaveStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
-                   QualType) final {
-    CurOffset -= offsetOf(RD, BS.getType()->getAsCXXRecordDecl());
-    return true;
-  }
-
-  bool enterArray(FieldDecl *FD, QualType ArrayTy, QualType) final {
-    ArrayBaseOffsets.push_back(CurOffset + offsetOf(FD, ArrayTy));
-    return true;
-  }
-
-  bool enterArray(ParmVarDecl *PD, QualType ArrayTy, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  bool nextElement(QualType ET, uint64_t Index) final {
-    int64_t Size =
-        SemaSYCLRef.getASTContext().getTypeSizeInChars(ET).getQuantity();
-    CurOffset = ArrayBaseOffsets.back() + Size * Index;
-    return true;
-  }
-
-  bool leaveArray(FieldDecl *FD, QualType ArrayTy, QualType) final {
-    CurOffset = ArrayBaseOffsets.pop_back_val();
-    CurOffset -= offsetOf(FD, ArrayTy);
-    return true;
-  }
-
-  bool leaveArray(ParmVarDecl *PD, QualType ArrayTy, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
-  }
-
-  using SyclKernelFieldHandler::enterStruct;
-  using SyclKernelFieldHandler::leaveStruct;
-};
-
-class SyclKernelIntFooterCreator : public SyclKernelFieldHandler {
-  SYCLIntegrationFooter &Footer;
-
-public:
-  SyclKernelIntFooterCreator(SemaSYCL &S, SYCLIntegrationFooter &F)
-      : SyclKernelFieldHandler(S), Footer(F) {
-    (void)Footer; // workaround for unused field warning
-  }
-};
-
-} // namespace
-
-class SYCLKernelNameTypeVisitor
-    : public TypeVisitor<SYCLKernelNameTypeVisitor>,
-      public ConstTemplateArgumentVisitor<SYCLKernelNameTypeVisitor> {
-  SemaSYCL &S;
-  SourceLocation KernelInvocationFuncLoc;
-  QualType KernelNameType;
-  using InnerTypeVisitor = TypeVisitor<SYCLKernelNameTypeVisitor>;
-  using InnerTemplArgVisitor =
-      ConstTemplateArgumentVisitor<SYCLKernelNameTypeVisitor>;
-  bool IsInvalid = false;
-  bool IsUnnamedKernel = false;
-
-  void VisitTemplateArgs(ArrayRef<TemplateArgument> Args) {
-    for (auto &A : Args)
-      Visit(A);
-  }
-
-public:
-  SYCLKernelNameTypeVisitor(SemaSYCL &S, SourceLocation KernelInvocationFuncLoc,
-                            QualType KernelNameType, bool IsUnnamedKernel)
-      : S(S), KernelInvocationFuncLoc(KernelInvocationFuncLoc),
-        KernelNameType(KernelNameType), IsUnnamedKernel(IsUnnamedKernel) {}
-
-  bool isValid() { return !IsInvalid; }
-
-  void Visit(QualType T) {
-    if (T.isNull())
-      return;
-
-    const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
-    // If KernelNameType has template args visit each template arg via
-    // ConstTemplateArgumentVisitor
-    if (const auto *TSD =
-            dyn_cast_or_null<ClassTemplateSpecializationDecl>(RD)) {
-      ArrayRef<TemplateArgument> Args = TSD->getTemplateArgs().asArray();
-
-      VisitTemplateArgs(Args);
-    } else {
-      InnerTypeVisitor::Visit(T.getTypePtr());
-    }
-  }
-
-  void Visit(const TemplateArgument &TA) {
-    if (TA.isNull())
-      return;
-    InnerTemplArgVisitor::Visit(TA);
-  }
-
-  void VisitBuiltinType(const BuiltinType *TT) {
-    if (TT->isNullPtrType()) {
-      S.Diag(KernelInvocationFuncLoc, diag::err_nullptr_t_type_in_sycl_kernel)
-          << KernelNameType;
-
-      IsInvalid = true;
-    }
-    return;
-  }
-
-  void VisitTagType(const TagType *TT) {
-    return DiagnoseKernelNameType(TT->getDecl());
-  }
-
-  void DiagnoseKernelNameType(const NamedDecl *DeclNamed) {
-    if (!IsUnnamedKernel) {
-      NotForwardDeclarableReason NFDR = isForwardDeclarable(DeclNamed, S);
-      switch (NFDR) {
-      case NotForwardDeclarableReason::UnscopedEnum:
-        S.Diag(KernelInvocationFuncLoc, diag::err_sycl_kernel_incorrectly_named)
-            << /* unscoped enum requires fixed underlying type */ 1
-            << DeclNamed;
-        IsInvalid = true;
-        return;
-      case NotForwardDeclarableReason::StdNamespace:
-        S.Diag(KernelInvocationFuncLoc,
-               diag::err_invalid_std_type_in_sycl_kernel)
-            << KernelNameType << DeclNamed;
-        IsInvalid = true;
-        return;
-      case NotForwardDeclarableReason::UnnamedTag:
-        S.Diag(KernelInvocationFuncLoc, diag::err_sycl_kernel_incorrectly_named)
-            << /* unnamed type is invalid */ 2 << KernelNameType;
-        IsInvalid = true;
-        return;
-      case NotForwardDeclarableReason::NotAtNamespaceScope:
-        S.Diag(KernelInvocationFuncLoc, diag::err_sycl_kernel_incorrectly_named)
-            << /* kernel name should be forward declarable at namespace
-                  scope */
-            0 << KernelNameType;
-        IsInvalid = true;
-        return;
-      case NotForwardDeclarableReason::None:
-      default:
-        // Do nothing, we're fine.
-        break;
-      }
-    }
-  }
-
-  void VisitTypeTemplateArgument(const TemplateArgument &TA) {
-    QualType T = TA.getAsType();
-    if (const auto *ET = T->getAs<EnumType>())
-      VisitTagType(ET);
-    else
-      Visit(T);
-  }
-
-  void VisitIntegralTemplateArgument(const TemplateArgument &TA) {
-    QualType T = TA.getIntegralType();
-    if (const EnumType *ET = T->getAs<EnumType>())
-      VisitTagType(ET);
-  }
-
-  void VisitTemplateTemplateArgument(const TemplateArgument &TA) {
-    TemplateDecl *TD = TA.getAsTemplate().getAsTemplateDecl();
-    assert(TD && "template declaration must be available");
-    TemplateParameterList *TemplateParams = TD->getTemplateParameters();
-    for (NamedDecl *P : *TemplateParams) {
-      if (NonTypeTemplateParmDecl *TemplateParam =
-              dyn_cast<NonTypeTemplateParmDecl>(P))
-        if (const EnumType *ET = TemplateParam->getType()->getAs<EnumType>())
-          VisitTagType(ET);
-    }
-  }
-
-  void VisitPackTemplateArgument(const TemplateArgument &TA) {
-    VisitTemplateArgs(TA.getPackAsArray());
-  }
-};
-
-void SemaSYCL::CheckSYCLKernelCall(FunctionDecl *KernelFunc,
-                                   ArrayRef<const Expr *> Args) {
-  QualType KernelNameType =
-      calculateKernelNameType(getASTContext(), KernelFunc);
-  SYCLKernelNameTypeVisitor KernelNameTypeVisitor(
-      *this, Args[0]->getExprLoc(), KernelNameType,
-      IsSYCLUnnamedKernel(*this, KernelFunc));
-  KernelNameTypeVisitor.Visit(KernelNameType.getCanonicalType());
-
-  // FIXME: In place until the library works around its 'host' invocation
-  // issues.
-  if (!SemaRef.LangOpts.SYCLIsDevice)
-    return;
-
-  const CXXRecordDecl *KernelObj =
-      GetSYCLKernelObjectType(KernelFunc)->getAsCXXRecordDecl();
-
-  if (!KernelObj || (KernelObj && !KernelObj->hasDefinition())) {
-    Diag(Args[0]->getExprLoc(), diag::err_sycl_kernel_not_function_object);
-    KernelFunc->setInvalidDecl();
-    return;
-  }
-
-  if (KernelObj->isLambda()) {
-    for (const LambdaCapture &LC : KernelObj->captures())
-      if (LC.capturesThis() && LC.isImplicit()) {
-        Diag(LC.getLocation(), diag::err_implicit_this_capture);
-        KernelFunc->setInvalidDecl();
-      }
-  }
-
-  // check that calling kernel conforms to spec
-  QualType KernelParamTy = KernelFunc->getParamDecl(0)->getType();
-  if (not KernelParamTy->isReferenceType()) {
-    // passing by value.  emit warning if using SYCL 2020 or greater
-    if (SemaRef.LangOpts.getSYCLVersion() >= LangOptions::SYCL_2020)
-      Diag(KernelFunc->getLocation(), diag::warn_sycl_pass_by_value_deprecated);
-  }
-
-  // Do not visit invalid kernel object.
-  if (KernelObj->isInvalidDecl())
-    return;
-
-  SyclKernelDecompMarker DecompMarker(*this);
-  SyclKernelFieldChecker FieldChecker(*this);
-  SyclKernelUnionChecker UnionChecker(*this);
-
-  KernelObjVisitor Visitor{*this};
-
-  DiagnosingSYCLKernel = true;
-
-  // Emit diagnostics for SYCL device kernels only
-  Visitor.VisitRecordBases(KernelObj, FieldChecker, UnionChecker, DecompMarker);
-  Visitor.VisitRecordFields(KernelObj, FieldChecker, UnionChecker,
-                            DecompMarker);
-  Visitor.visitTopLevelRecord(KernelObj, GetSYCLKernelObjectType(KernelFunc),
-                              FieldChecker, UnionChecker, DecompMarker);
-
-  DiagnosingSYCLKernel = false;
-  // Set the kernel function as invalid, if any of the checkers fail validation.
-  if (!FieldChecker.isValid() || !UnionChecker.isValid() ||
-      !KernelNameTypeVisitor.isValid())
-    KernelFunc->setInvalidDecl();
-}
-
-// For a wrapped parallel_for, copy attributes from original
-// kernel to wrapped kernel.
-void SemaSYCL::copySYCLKernelAttrs(CXXMethodDecl *CallOperator) {
-  // Get the operator() function of the wrapper.
-  assert(CallOperator && "invalid kernel object");
-
-  typedef std::pair<FunctionDecl *, FunctionDecl *> ChildParentPair;
-  llvm::SmallPtrSet<FunctionDecl *, 16> Visited;
-  llvm::SmallVector<ChildParentPair, 16> WorkList;
-  WorkList.push_back({CallOperator, nullptr});
-  FunctionDecl *KernelBody = nullptr;
-
-  CallGraph SYCLCG;
-  SYCLCG.addToCallGraph(CallOperator);
-  while (!WorkList.empty()) {
-    FunctionDecl *FD = WorkList.back().first;
-    FunctionDecl *ParentFD = WorkList.back().second;
-
-    if ((ParentFD == CallOperator) && isSYCLKernelBodyFunction(FD)) {
-      KernelBody = FD;
-      break;
-    }
-
-    WorkList.pop_back();
-    if (!Visited.insert(FD).second)
-      continue; // We've already seen this Decl
-
-    CallGraphNode *N = SYCLCG.getNode(FD);
-    if (!N)
-      continue;
-
-    for (const CallGraphNode *CI : *N) {
-      if (auto *Callee = dyn_cast<FunctionDecl>(CI->getDecl())) {
-        Callee = Callee->getMostRecentDecl();
-        if (!Visited.count(Callee))
-          WorkList.push_back({Callee, FD});
-      }
-    }
-  }
-
-  assert(KernelBody && "improper parallel_for wrap");
-  if (KernelBody) {
-    llvm::SmallVector<Attr *, 4> Attrs;
-    collectSYCLAttributes(*this, KernelBody, Attrs, /*DirectlyCalled*/ true);
-    if (!Attrs.empty())
-      llvm::for_each(Attrs,
-                     [CallOperator](Attr *A) { CallOperator->addAttr(A); });
-  }
-}
-
-void SemaSYCL::SetSYCLKernelNames() {
-  std::unique_ptr<MangleContext> MangleCtx(
-      getASTContext().createMangleContext());
-  // We assume the list of KernelDescs is the complete list of kernels needing
-  // to be rewritten.
-  for (const std::pair<const FunctionDecl *, FunctionDecl *> &Pair :
-       SyclKernelsToOpenCLKernels) {
-    std::string CalculatedName, StableName;
-    StringRef KernelName;
-    if (isFreeFunction(*this, Pair.first)) {
-      std::tie(CalculatedName, StableName) =
-          constructFreeFunctionKernelName(*this, Pair.first, *MangleCtx);
-      KernelName = CalculatedName;
-    } else {
-      std::tie(CalculatedName, StableName) =
-          constructKernelName(*this, Pair.first, *MangleCtx);
-      KernelName =
-          IsSYCLUnnamedKernel(*this, Pair.first) ? StableName : CalculatedName;
-    }
-
-    getSyclIntegrationHeader().updateKernelNames(Pair.first, KernelName,
-                                                 StableName);
-
-    // Set name of generated kernel.
-    Pair.second->setDeclName(&getASTContext().Idents.get(KernelName));
-    // Update the AsmLabel for this generated kernel.
-    Pair.second->addAttr(
-        AsmLabelAttr::CreateImplicit(getASTContext(), KernelName));
-  }
-}
-
-// Generates the OpenCL kernel using KernelCallerFunc (kernel caller
-// function) defined is SYCL headers.
-// Generated OpenCL kernel contains the body of the kernel caller function,
-// receives OpenCL like parameters and additionally does some manipulation to
-// initialize captured lambda/functor fields with these parameters.
-// SYCL runtime marks kernel caller function with sycl_kernel attribute.
-// To be able to generate OpenCL kernel from KernelCallerFunc we put
-// the following requirements to the function which SYCL runtime can mark with
-// sycl_kernel attribute:
-//   - Must be template function with at least two template parameters.
-//     First parameter must represent "unique kernel name"
-//     Second parameter must be the function object type
-//   - Must have only one function parameter - function object.
-//
-// Example of kernel caller function:
-//   template <typename KernelName, typename KernelType/*, ...*/>
-//   __attribute__((sycl_kernel)) void kernel_caller_function(KernelType
-//                                                            KernelFuncObj) {
-//     KernelFuncObj();
-//   }
-//
-//
-void SemaSYCL::ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc,
-                                     MangleContext &MC) {
-  // The first argument to the KernelCallerFunc is the lambda object.
-  QualType KernelObjTy = GetSYCLKernelObjectType(KernelCallerFunc);
-  const CXXRecordDecl *KernelObj = KernelObjTy->getAsCXXRecordDecl();
-  assert(KernelObj && "invalid kernel caller");
-
-  // Do not visit invalid kernel object.
-  if (KernelObj->isInvalidDecl())
-    return;
-
-  KernelCallOperatorVisitor KernelCallOperator(KernelCallerFunc, KernelObj);
-  CXXMethodDecl *CallOperator = nullptr;
-
-  if (KernelObj->isLambda())
-    CallOperator = KernelObj->getLambdaCallOperator();
-  else
-    CallOperator = KernelCallOperator.getCallOperator();
-
-  {
-    // Do enough to calculate the StableName for the purposes of the hackery
-    // below for __pf_kernel_wrapper. Placed in a scope so that we don't
-    // accidentially use these values below, before the names are stabililzed.
-    std::string CalculatedName, StableName;
-    std::tie(CalculatedName, StableName) =
-        constructKernelName(*this, KernelCallerFunc, MC);
-
-    // Attributes of a user-written SYCL kernel must be copied to the internally
-    // generated alternative kernel, identified by a known string in its name.
-    if (StableName.find("__pf_kernel_wrapper") != std::string::npos)
-      copySYCLKernelAttrs(CallOperator);
-  }
-
-  bool IsSIMDKernel = isESIMDKernelType(CallOperator);
-
-  SyclKernelArgsSizeChecker argsSizeChecker(*this, KernelObj->getLocation(),
-                                            IsSIMDKernel);
-  ESIMDKernelDiagnostics esimdKernel(*this, KernelObj->getLocation(),
-                                     IsSIMDKernel);
-
-  SyclKernelDeclCreator kernel_decl(*this, KernelObj->getLocation(),
-                                    KernelCallerFunc->isInlined(), IsSIMDKernel,
-                                    KernelCallerFunc);
-  SyclKernelBodyCreator kernel_body(*this, kernel_decl, KernelObj,
-                                    KernelCallerFunc, IsSIMDKernel,
-                                    CallOperator);
-  SyclKernelIntHeaderCreator int_header(
-      IsSIMDKernel, *this, getSyclIntegrationHeader(), KernelObj,
-      calculateKernelNameType(getASTContext(), KernelCallerFunc),
-      KernelCallerFunc);
-
-  SyclKernelIntFooterCreator int_footer(*this, getSyclIntegrationFooter());
-  SyclOptReportCreator opt_report(*this, kernel_decl, KernelObj->getLocation());
-
-  KernelObjVisitor Visitor{*this};
-
-  // Visit handlers to generate information for optimization record only if
-  // optimization record is saved.
-  if (!getLangOpts().OptRecordFile.empty()) {
-    Visitor.VisitKernelRecord(KernelObj, KernelObjTy, argsSizeChecker,
-                              esimdKernel, kernel_decl, kernel_body, int_header,
-                              int_footer, opt_report);
-  } else {
-    Visitor.VisitKernelRecord(KernelObj, KernelObjTy, argsSizeChecker,
-                              esimdKernel, kernel_decl, kernel_body, int_header,
-                              int_footer);
-  }
-
-  if (ParmVarDecl *KernelHandlerArg =
-          getSyclKernelHandlerArg(KernelCallerFunc)) {
-    kernel_decl.handleSyclKernelHandlerType();
-    kernel_body.handleSyclKernelHandlerType(KernelHandlerArg);
-    int_header.handleSyclKernelHandlerType(KernelHandlerArg->getType());
-
-    if (!getLangOpts().OptRecordFile.empty())
-      opt_report.handleSyclKernelHandlerType();
-  }
-}
-
-void ConstructFreeFunctionKernel(SemaSYCL &SemaSYCLRef, FunctionDecl *FD) {
-  SyclKernelArgsSizeChecker argsSizeChecker(SemaSYCLRef, FD->getLocation(),
-                                            false /*IsSIMDKernel*/);
-  SyclKernelDeclCreator kernel_decl(SemaSYCLRef, FD->getLocation(),
-                                    FD->isInlined(), false /*IsSIMDKernel */,
-                                    FD);
-
-  FreeFunctionKernelBodyCreator kernel_body(SemaSYCLRef, kernel_decl, FD);
-
-  SyclKernelIntHeaderCreator int_header(
-      SemaSYCLRef, SemaSYCLRef.getSyclIntegrationHeader(), FD->getType(), FD);
-
-  SyclKernelIntFooterCreator int_footer(SemaSYCLRef,
-                                        SemaSYCLRef.getSyclIntegrationFooter());
-  KernelObjVisitor Visitor{SemaSYCLRef};
-
-  Visitor.VisitFunctionParameters(FD, argsSizeChecker, kernel_decl, kernel_body,
-                                  int_header, int_footer);
-}
-
-// Figure out the sub-group for the this function.  First we check the
-// attributes, then the global settings.
-static std::pair<LangOptions::SubGroupSizeType, int64_t>
-CalcEffectiveSubGroup(ASTContext &Ctx, const LangOptions &LO,
-                      const FunctionDecl *FD) {
-  if (const auto *A = FD->getAttr<IntelReqdSubGroupSizeAttr>()) {
-    int64_t Val = getIntExprValue(A->getValue(), Ctx);
-    return {LangOptions::SubGroupSizeType::Integer, Val};
-  }
-
-  if (const auto *A = FD->getAttr<IntelNamedSubGroupSizeAttr>()) {
-    if (A->getType() == IntelNamedSubGroupSizeAttr::Primary)
-      return {LangOptions::SubGroupSizeType::Primary, 0};
-    return {LangOptions::SubGroupSizeType::Auto, 0};
-  }
-
-  // Return the global settings.
-  return {LO.getDefaultSubGroupSizeType(),
-          static_cast<uint64_t>(LO.DefaultSubGroupSize)};
-}
-
-static SourceLocation GetSubGroupLoc(const FunctionDecl *FD) {
-  if (const auto *A = FD->getAttr<IntelReqdSubGroupSizeAttr>())
-    return A->getLocation();
-  if (const auto *A = FD->getAttr<IntelNamedSubGroupSizeAttr>())
-    return A->getLocation();
-  return SourceLocation{};
-}
-
-static void CheckSYCL2020SubGroupSizes(SemaSYCL &S, FunctionDecl *SYCLKernel,
-                                       const FunctionDecl *FD) {
-  // If they are the same, no error.
-  if (CalcEffectiveSubGroup(S.getASTContext(), S.getLangOpts(), SYCLKernel) ==
-      CalcEffectiveSubGroup(S.getASTContext(), S.getLangOpts(), FD))
-    return;
-
-  // No need to validate __spirv routines here since they
-  // are mapped to the equivalent SPIRV operations.
-  const IdentifierInfo *II = FD->getIdentifier();
-  if (II && II->getName().starts_with("__spirv_"))
-    return;
-
-  // Else we need to figure out why they don't match.
-  SourceLocation FDAttrLoc = GetSubGroupLoc(FD);
-  SourceLocation KernelAttrLoc = GetSubGroupLoc(SYCLKernel);
-
-  if (FDAttrLoc.isValid()) {
-    // This side was caused by an attribute.
-    S.Diag(FDAttrLoc, diag::err_sycl_mismatch_group_size)
-        << /*kernel called*/ 0;
-
-    if (KernelAttrLoc.isValid()) {
-      S.Diag(KernelAttrLoc, diag::note_conflicting_attribute);
-    } else {
-      // Kernel is 'default'.
-      S.Diag(SYCLKernel->getLocation(), diag::note_sycl_kernel_declared_here);
-    }
-    return;
-  }
-
-  // Else this doesn't have an attribute, which can only be caused by this being
-  // an undefined SYCL_EXTERNAL, and the kernel has an attribute that conflicts.
-  if (const auto *A = SYCLKernel->getAttr<IntelReqdSubGroupSizeAttr>()) {
-    // Don't diagnose this if the kernel got its size from the 'old' attribute
-    // spelling.
-    if (!A->isSYCL2020Spelling())
-      return;
-  }
-
-  assert(KernelAttrLoc.isValid() && "Kernel doesn't have attribute either?");
-  S.Diag(FD->getLocation(), diag::err_sycl_mismatch_group_size)
-      << /*undefined SYCL_EXTERNAL*/ 1;
-  S.Diag(KernelAttrLoc, diag::note_conflicting_attribute);
-}
-
-// Check SYCL2020 Attributes.  2020 attributes don't propogate, they are only
-// valid if they match the attribute on the kernel. Note that this is a slight
-// difference from what the spec says, which says these attributes are only
-// valid on SYCL Kernels and SYCL_EXTERNAL, but we felt that for
-// self-documentation purposes that it would be nice to be able to repeat these
-// on subsequent functions.
-static void CheckSYCL2020Attributes(
-    SemaSYCL &S, FunctionDecl *SYCLKernel, FunctionDecl *KernelBody,
-    const llvm::SmallPtrSetImpl<FunctionDecl *> &CalledFuncs) {
-
-  if (KernelBody) {
-    // Make sure the kernel itself has all the 2020 attributes, since we don't
-    // do propagation of these.
-    if (auto *A = KernelBody->getAttr<IntelReqdSubGroupSizeAttr>())
-      if (A->isSYCL2020Spelling())
-        SYCLKernel->addAttr(A);
-    if (auto *A = KernelBody->getAttr<IntelNamedSubGroupSizeAttr>())
-      SYCLKernel->addAttr(A);
-
-    // If the kernel has a body, we should get the attributes for the kernel
-    // from there instead, so that we get the functor object.
-    SYCLKernel = KernelBody;
-  }
-
-  for (auto *FD : CalledFuncs) {
-    if (FD == SYCLKernel || FD == KernelBody)
-      continue;
-    for (auto *Attr : FD->attrs()) {
-      switch (Attr->getKind()) {
-      case attr::Kind::IntelReqdSubGroupSize:
-        // Pre SYCL2020 spellings handled during collection.
-        if (!cast<IntelReqdSubGroupSizeAttr>(Attr)->isSYCL2020Spelling())
-          break;
-        LLVM_FALLTHROUGH;
-      case attr::Kind::IntelNamedSubGroupSize:
-        CheckSYCL2020SubGroupSizes(S, SYCLKernel, FD);
-        break;
-      case attr::Kind::SYCLDevice:
-        // If a SYCL_EXTERNAL function is not defined in this TU, its necessary
-        // that it has a compatible sub-group-size. Don't diagnose if it has a
-        // sub-group attribute, we can count on the other checks to catch this.
-        if (!FD->isDefined() && !FD->hasAttr<IntelReqdSubGroupSizeAttr>() &&
-            !FD->hasAttr<IntelNamedSubGroupSizeAttr>())
-          CheckSYCL2020SubGroupSizes(S, SYCLKernel, FD);
-        break;
-      default:
-        break;
-      }
-    }
-  }
-}
-
-static void PropagateAndDiagnoseDeviceAttr(
-    SemaSYCL &S, const SingleDeviceFunctionTracker &Tracker, Attr *A,
-    FunctionDecl *SYCLKernel, FunctionDecl *KernelBody) {
-  switch (A->getKind()) {
-  case attr::Kind::IntelReqdSubGroupSize: {
-    auto *Attr = cast<IntelReqdSubGroupSizeAttr>(A);
-
-    if (Attr->isSYCL2020Spelling())
-      break;
-    const auto *KBSimdAttr =
-        KernelBody ? KernelBody->getAttr<SYCLSimdAttr>() : nullptr;
-    if (auto *Existing = SYCLKernel->getAttr<IntelReqdSubGroupSizeAttr>()) {
-      if (getIntExprValue(Existing->getValue(), S.getASTContext()) !=
-          getIntExprValue(Attr->getValue(), S.getASTContext())) {
-        S.Diag(SYCLKernel->getLocation(),
-               diag::err_conflicting_sycl_kernel_attributes);
-        S.Diag(Existing->getLocation(), diag::note_conflicting_attribute);
-        S.Diag(Attr->getLocation(), diag::note_conflicting_attribute);
-        SYCLKernel->setInvalidDecl();
-      }
-    } else if (KBSimdAttr &&
-               (getIntExprValue(Attr->getValue(), S.getASTContext()) != 1)) {
-      reportConflictingAttrs(S, KernelBody, KBSimdAttr, Attr);
-    } else {
-      SYCLKernel->addAttr(A);
-    }
-    break;
-  }
-  case attr::Kind::SYCLReqdWorkGroupSize: {
-    auto *RWGSA = cast<SYCLReqdWorkGroupSizeAttr>(A);
-    if (auto *Existing = SYCLKernel->getAttr<SYCLReqdWorkGroupSizeAttr>()) {
-      if (S.anyWorkGroupSizesDiffer(Existing->getXDim(), Existing->getYDim(),
-                                    Existing->getZDim(), RWGSA->getXDim(),
-                                    RWGSA->getYDim(), RWGSA->getZDim())) {
-        S.Diag(SYCLKernel->getLocation(),
-               diag::err_conflicting_sycl_kernel_attributes);
-        S.Diag(Existing->getLocation(), diag::note_conflicting_attribute);
-        S.Diag(RWGSA->getLocation(), diag::note_conflicting_attribute);
-        SYCLKernel->setInvalidDecl();
-      }
-    } else if (auto *Existing =
-                   SYCLKernel->getAttr<SYCLIntelMaxWorkGroupSizeAttr>()) {
-      if (S.checkMaxAllowedWorkGroupSize(
-              RWGSA->getXDim(), RWGSA->getYDim(), RWGSA->getZDim(),
-              Existing->getXDim(), Existing->getYDim(), Existing->getZDim())) {
-        S.Diag(SYCLKernel->getLocation(),
-               diag::err_conflicting_sycl_kernel_attributes);
-        S.Diag(Existing->getLocation(), diag::note_conflicting_attribute);
-        S.Diag(RWGSA->getLocation(), diag::note_conflicting_attribute);
-        SYCLKernel->setInvalidDecl();
-      } else {
-        SYCLKernel->addAttr(A);
-      }
-    } else {
-      SYCLKernel->addAttr(A);
-    }
-    break;
-  }
-  case attr::Kind::SYCLWorkGroupSizeHint: {
-    auto *WGSH = cast<SYCLWorkGroupSizeHintAttr>(A);
-    if (auto *Existing = SYCLKernel->getAttr<SYCLWorkGroupSizeHintAttr>()) {
-      if (S.anyWorkGroupSizesDiffer(Existing->getXDim(), Existing->getYDim(),
-                                    Existing->getZDim(), WGSH->getXDim(),
-                                    WGSH->getYDim(), WGSH->getZDim())) {
-        S.Diag(SYCLKernel->getLocation(),
-               diag::err_conflicting_sycl_kernel_attributes);
-        S.Diag(Existing->getLocation(), diag::note_conflicting_attribute);
-        S.Diag(WGSH->getLocation(), diag::note_conflicting_attribute);
-        SYCLKernel->setInvalidDecl();
-      }
-    }
-    SYCLKernel->addAttr(A);
-    break;
-  }
-  case attr::Kind::SYCLIntelMaxWorkGroupSize: {
-    auto *SIMWGSA = cast<SYCLIntelMaxWorkGroupSizeAttr>(A);
-    if (auto *Existing = SYCLKernel->getAttr<SYCLReqdWorkGroupSizeAttr>()) {
-      if (S.checkMaxAllowedWorkGroupSize(
-              Existing->getXDim(), Existing->getYDim(), Existing->getZDim(),
-              SIMWGSA->getXDim(), SIMWGSA->getYDim(), SIMWGSA->getZDim())) {
-        S.Diag(SYCLKernel->getLocation(),
-               diag::err_conflicting_sycl_kernel_attributes);
-        S.Diag(Existing->getLocation(), diag::note_conflicting_attribute);
-        S.Diag(SIMWGSA->getLocation(), diag::note_conflicting_attribute);
-        SYCLKernel->setInvalidDecl();
-      } else {
-        SYCLKernel->addAttr(A);
-      }
-    } else {
-      SYCLKernel->addAttr(A);
-    }
-    break;
-  }
-  case attr::Kind::SYCLSimd:
-    if (KernelBody && !KernelBody->getAttr<SYCLSimdAttr>()) {
-      // Usual kernel can't call ESIMD functions.
-      S.Diag(KernelBody->getLocation(),
-             diag::err_sycl_function_attribute_mismatch)
-          << A;
-      S.Diag(A->getLocation(), diag::note_attribute);
-      KernelBody->setInvalidDecl();
-      break;
-    }
-    LLVM_FALLTHROUGH;
-  case attr::Kind::SYCLIntelKernelArgsRestrict:
-  case attr::Kind::SYCLIntelNumSimdWorkItems:
-  case attr::Kind::SYCLIntelSchedulerTargetFmaxMhz:
-  case attr::Kind::SYCLIntelMaxGlobalWorkDim:
-  case attr::Kind::SYCLIntelMinWorkGroupsPerComputeUnit:
-  case attr::Kind::SYCLIntelMaxWorkGroupsPerMultiprocessor:
-  case attr::Kind::SYCLIntelNoGlobalWorkOffset:
-  case attr::Kind::SYCLIntelLoopFuse:
-  case attr::Kind::SYCLIntelMaxConcurrency:
-  case attr::Kind::SYCLIntelDisableLoopPipelining:
-  case attr::Kind::SYCLIntelInitiationInterval:
-  case attr::Kind::SYCLIntelUseStallEnableClusters:
-  case attr::Kind::SYCLDeviceHas:
-  case attr::Kind::SYCLAddIRAttributesFunction:
-    SYCLKernel->addAttr(A);
-    break;
-  case attr::Kind::IntelNamedSubGroupSize:
-    // Nothing to do here, handled in the SYCL2020 spelling.
-    break;
-  // TODO: vec_len_hint should be handled here
-  default:
-    // Seeing this means that CollectPossibleKernelAttributes was
-    // updated while this switch wasn't...or something went wrong
-    llvm_unreachable("Unexpected attribute was collected by "
-                     "CollectPossibleKernelAttributes");
-  }
-}
-
-void SemaSYCL::MarkDevices() {
-  // This Tracker object ensures that the SyclDeviceDecls collection includes
-  // the SYCL_EXTERNAL functions, and manages the diagnostics for all of the
-  // functions in the kernel.
-  DeviceFunctionTracker Tracker(*this);
-
-  for (Decl *D : syclDeviceDecls()) {
-    auto *SYCLKernel = cast<FunctionDecl>(D);
-
-    // This type does the actual analysis on a per-kernel basis. It does this to
-    // make sure that we're only ever dealing with the context of a single
-    // kernel at a time.
-    SingleDeviceFunctionTracker T{Tracker, SYCLKernel};
-
-    CheckSYCL2020Attributes(*this, T.GetSYCLKernel(), T.GetKernelBody(),
-                            T.GetDeviceFunctions());
-    for (auto *A : T.GetCollectedAttributes())
-      PropagateAndDiagnoseDeviceAttr(*this, T, A, T.GetSYCLKernel(),
-                                     T.GetKernelBody());
-    checkSYCLAddIRAttributesFunctionAttrConflicts(T.GetSYCLKernel());
-  }
-}
-
-void SemaSYCL::ProcessFreeFunction(FunctionDecl *FD) {
-  if (isFreeFunction(*this, FD)) {
-    SyclKernelDecompMarker DecompMarker(*this);
-    SyclKernelFieldChecker FieldChecker(*this);
-    SyclKernelUnionChecker UnionChecker(*this);
-
-    KernelObjVisitor Visitor{*this};
-
-    DiagnosingSYCLKernel = true;
-
-    // Check parameters of free function.
-    Visitor.VisitFunctionParameters(FD, DecompMarker, FieldChecker,
-                                    UnionChecker);
-
-    DiagnosingSYCLKernel = false;
-
-    // Ignore the free function if any of the checkers fail validation.
-    if (!FieldChecker.isValid() || !UnionChecker.isValid())
-      return;
-
-    ConstructFreeFunctionKernel(*this, FD);
-  }
-}
-
-// -----------------------------------------------------------------------------
-// SYCL device specific diagnostics implementation
-// -----------------------------------------------------------------------------
-
-Sema::SemaDiagnosticBuilder
-SemaSYCL::DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID,
-                           DeviceDiagnosticReason Reason) {
-  assert(getLangOpts().SYCLIsDevice &&
-         "Should only be called during SYCL compilation");
-  FunctionDecl *FD = dyn_cast<FunctionDecl>(SemaRef.getCurLexicalContext());
-  SemaDiagnosticBuilder::Kind DiagKind = [this, FD, Reason] {
-    if (DiagnosingSYCLKernel)
-      return SemaDiagnosticBuilder::K_ImmediateWithCallStack;
-    if (!FD)
-      return SemaDiagnosticBuilder::K_Nop;
-    if (SemaRef.isConstantEvaluatedContext() ||
-        SemaRef.currentEvaluationContext().isDiscardedStatementContext())
-      return SemaDiagnosticBuilder::K_Nop;
-    // Defer until we know that the variable's intializer is actually a
-    // manifestly constant-evaluated expression.
-    if (SemaRef.InConstexprVarInit)
-      return SemaDiagnosticBuilder::K_Deferred;
-    if (SemaRef.getEmissionStatus(FD) ==
-        Sema::FunctionEmissionStatus::Emitted) {
-      // Skip the diagnostic if we know it won't be emitted.
-      if ((SemaRef.getEmissionReason(FD) & Reason) ==
-          Sema::DeviceDiagnosticReason::None)
-        return SemaDiagnosticBuilder::K_Nop;
-
-      return SemaDiagnosticBuilder::K_ImmediateWithCallStack;
-    }
-    return SemaDiagnosticBuilder::K_Deferred;
-  }();
-  return SemaDiagnosticBuilder(DiagKind, Loc, DiagID, FD, SemaRef, Reason);
-}
-
-void SemaSYCL::deepTypeCheckForDevice(SourceLocation UsedAt,
-                                      llvm::DenseSet<QualType> Visited,
-                                      ValueDecl *DeclToCheck) {
-  assert(getLangOpts().SYCLIsDevice &&
-         "Should only be called during SYCL compilation");
-  // Emit notes only for the first discovered declaration of unsupported type
-  // to avoid mess of notes. This flag is to track that error already happened.
-  bool NeedToEmitNotes = true;
-
-  auto Check = [&](QualType TypeToCheck, const ValueDecl *D) {
-    bool ErrorFound = false;
-    if (isZeroSizedArray(*this, TypeToCheck)) {
-      DiagIfDeviceCode(UsedAt, diag::err_typecheck_zero_array_size) << 1;
-      ErrorFound = true;
-    }
-    // Checks for other types can also be done here.
-    if (ErrorFound) {
-      if (NeedToEmitNotes) {
-        if (auto *FD = dyn_cast<FieldDecl>(D))
-          DiagIfDeviceCode(FD->getLocation(),
-                           diag::note_illegal_field_declared_here)
-              << FD->getType()->isPointerType() << FD->getType();
-        else
-          DiagIfDeviceCode(D->getLocation(), diag::note_declared_at);
-      }
-    }
-
-    return ErrorFound;
-  };
-
-  // In case we have a Record used do the DFS for a bad field.
-  SmallVector<const ValueDecl *, 4> StackForRecursion;
-  StackForRecursion.push_back(DeclToCheck);
-
-  // While doing DFS save how we get there to emit a nice set of notes.
-  SmallVector<const FieldDecl *, 4> History;
-  History.push_back(nullptr);
-
-  do {
-    const ValueDecl *Next = StackForRecursion.pop_back_val();
-    if (!Next) {
-      assert(!History.empty());
-      // Found a marker, we have gone up a level.
-      History.pop_back();
-      continue;
-    }
-    QualType NextTy = Next->getType();
-
-    if (!Visited.insert(NextTy).second)
-      continue;
-
-    auto EmitHistory = [&]() {
-      // The first element is always nullptr.
-      for (uint64_t Index = 1; Index < History.size(); ++Index) {
-        DiagIfDeviceCode(History[Index]->getLocation(),
-                         diag::note_within_field_of_type)
-            << History[Index]->getType();
-      }
-    };
-
-    if (Check(NextTy, Next)) {
-      if (NeedToEmitNotes)
-        EmitHistory();
-      NeedToEmitNotes = false;
-    }
-
-    // In case pointer/array/reference type is met get pointee type, then
-    // proceed with that type.
-    while (NextTy->isAnyPointerType() || NextTy->isArrayType() ||
-           NextTy->isReferenceType()) {
-      if (NextTy->isArrayType())
-        NextTy = QualType{NextTy->getArrayElementTypeNoTypeQual(), 0};
-      else
-        NextTy = NextTy->getPointeeType();
-      if (Check(NextTy, Next)) {
-        if (NeedToEmitNotes)
-          EmitHistory();
-        NeedToEmitNotes = false;
-      }
-    }
-
-    if (const auto *RecDecl = NextTy->getAsRecordDecl()) {
-      if (auto *NextFD = dyn_cast<FieldDecl>(Next))
-        History.push_back(NextFD);
-      // When nullptr is discovered, this means we've gone back up a level, so
-      // the history should be cleaned.
-      StackForRecursion.push_back(nullptr);
-      llvm::copy(RecDecl->fields(), std::back_inserter(StackForRecursion));
-    }
-  } while (!StackForRecursion.empty());
-}
-
-void SemaSYCL::finalizeSYCLDelayedAnalysis(const FunctionDecl *Caller,
-                                           const FunctionDecl *Callee,
-                                           SourceLocation Loc,
-                                           DeviceDiagnosticReason Reason) {
-  Callee = Callee->getMostRecentDecl();
-
-  // If the reason for the emission of this diagnostic is not SYCL-specific,
-  // and it is not known to be reachable from a routine on device, do not
-  // issue a diagnostic.
-  if ((Reason & DeviceDiagnosticReason::Sycl) == DeviceDiagnosticReason::None &&
-      !isFDReachableFromSyclDevice(Callee, Caller))
-    return;
-
-  // If Callee has a SYCL attribute, no diagnostic needed.
-  if (Callee->hasAttr<SYCLDeviceAttr>() || Callee->hasAttr<SYCLKernelAttr>())
-    return;
-
-  // If Callee has a CUDA device attribute, no diagnostic needed.
-  if (getLangOpts().CUDA && Callee->hasAttr<CUDADeviceAttr>())
-    return;
-
-  // Diagnose if this is an undefined function and it is not a builtin.
-  // Currently, there is an exception of "__failed_assertion" in libstdc++-11,
-  // this undefined function is used to trigger a compiling error.
-  if (!Callee->isDefined() && !Callee->getBuiltinID() &&
-      !Callee->isReplaceableGlobalAllocationFunction() &&
-      !isSYCLUndefinedAllowed(Callee, SemaRef.getSourceManager())) {
-    Diag(Loc, diag::err_sycl_restrict) << SemaSYCL::KernelCallUndefinedFunction;
-    Diag(Callee->getLocation(), diag::note_previous_decl) << Callee;
-    Diag(Caller->getLocation(), diag::note_called_by) << Caller;
-  }
-}
-
-bool SemaSYCL::checkAllowedSYCLInitializer(VarDecl *VD) {
-  assert(getLangOpts().SYCLIsDevice &&
-         "Should only be called during SYCL compilation");
-
-  if (VD->isInvalidDecl() || !VD->hasInit() || !VD->hasGlobalStorage())
-    return true;
-
-  const Expr *Init = VD->getInit();
-  bool ValueDependent = Init && Init->isValueDependent();
-  bool isConstantInit = Init && !ValueDependent &&
-                        Init->isConstantInitializer(getASTContext(), false);
-  if (!VD->isConstexpr() && Init && !ValueDependent && !isConstantInit)
-    return false;
-
-  return true;
-}
-
-// -----------------------------------------------------------------------------
-// Integration header functionality implementation
-// -----------------------------------------------------------------------------
-
-/// Returns a string ID of given parameter kind - used in header
-/// emission.
-static const char *paramKind2Str(KernelParamKind K) {
-#define CASE(x)                                                                \
-  case SYCLIntegrationHeader::kind_##x:                                        \
-    return "kind_" #x
-  switch (K) {
-    CASE(accessor);
-    CASE(std_layout);
-    CASE(sampler);
-    CASE(stream);
-    CASE(specialization_constants_buffer);
-    CASE(pointer);
-    CASE(work_group_memory);
-  }
-  return "<ERROR>";
-
-#undef CASE
-}
-
-// Emits forward declarations of classes and template classes on which
-// declaration of given type depends.
-// For example, consider SimpleVadd
-// class specialization in parallel_for below:
-//
-//   template <typename T1, unsigned int N, typename ... T2>
-//   class SimpleVadd;
-//   ...
-//   template <unsigned int N, typename T1, typename ... T2>
-//   void simple_vadd(const std::array<T1, N>& VA, const std::array<T1, N>&
-//   VB,
-//     std::array<T1, N>& VC, int param, T2 ... varargs) {
-//     ...
-//     deviceQueue.submit([&](sycl::handler& cgh) {
-//       ...
-//       cgh.parallel_for<class SimpleVadd<T1, N, T2...>>(...)
-//       ...
-//     }
-//     ...
-//   }
-//   ...
-//   class MyClass {...};
-//   template <typename T> class MyInnerTmplClass { ... }
-//   template <typename T> class MyTmplClass { ... }
-//   ...
-//   MyClass *c = new MyClass();
-//   MyInnerTmplClass<MyClass**> c1(&c);
-//   simple_vadd(A, B, C, 5, 'a', 1.f,
-//     new MyTmplClass<MyInnerTmplClass<MyClass**>>(c1));
-//
-// it will generate the following forward declarations:
-//   class MyClass;
-//   template <typename T> class MyInnerTmplClass;
-//   template <typename T> class MyTmplClass;
-//   template <typename T1, unsigned int N, typename ...T2> class SimpleVadd;
-//
-class SYCLFwdDeclEmitter
-    : public TypeVisitor<SYCLFwdDeclEmitter>,
-      public ConstTemplateArgumentVisitor<SYCLFwdDeclEmitter> {
-  using InnerTypeVisitor = TypeVisitor<SYCLFwdDeclEmitter>;
-  using InnerTemplArgVisitor = ConstTemplateArgumentVisitor<SYCLFwdDeclEmitter>;
-  raw_ostream &OS;
-  llvm::SmallPtrSet<const NamedDecl *, 4> Printed;
-  PrintingPolicy Policy;
-
-  void printForwardDecl(NamedDecl *D) {
-    // wrap the declaration into namespaces if needed
-    unsigned NamespaceCnt = 0;
-    std::string NSStr = "";
-    const DeclContext *DC = D->getDeclContext();
-
-    while (DC) {
-      if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
-        ++NamespaceCnt;
-        StringRef NSInlinePrefix = NS->isInline() ? "inline " : "";
-        NSStr.insert(
-            0,
-            Twine(NSInlinePrefix + "namespace " + NS->getName() + " { ").str());
-        DC = NS->getDeclContext();
-      } else {
-        // We should be able to handle a subset of the decl-context types to
-        // make our namespaces for forward declarations as specific as possible,
-        // so just skip them here.  We can't use their names, since they would
-        // not be forward declarable, but we can try to make them as specific as
-        // possible.
-        // This permits things such as:
-        // namespace N1 { void foo() { kernel<class K>(...); }}
-        // and
-        // namespace N2 { void foo() { kernel<class K>(...); }}
-        // to co-exist, despite technically being against the SYCL rules.
-        // See SYCLKernelNameTypePrinter for the corresponding part that prints
-        // the kernel information for this type. These two must match.
-        if (isa<FunctionDecl, RecordDecl, LinkageSpecDecl>(DC)) {
-          DC = cast<Decl>(DC)->getDeclContext();
-        } else {
-          break;
-        }
-      }
-    }
-    OS << NSStr;
-    if (NamespaceCnt > 0)
-      OS << "\n";
-
-    D->print(OS, Policy);
-
-    if (const auto *ED = dyn_cast<EnumDecl>(D)) {
-      QualType T = ED->getIntegerType().getCanonicalType();
-      // Backup since getIntegerType() returns null for enum forward
-      // declaration with no fixed underlying type
-      if (T.isNull())
-        T = ED->getPromotionType();
-      OS << " : " << T.getAsString();
-    }
-
-    OS << ";\n";
-
-    // print closing braces for namespaces if needed
-    for (unsigned I = 0; I < NamespaceCnt; ++I)
-      OS << "}";
-    if (NamespaceCnt > 0)
-      OS << "\n";
-  }
-
-  // Checks if we've already printed forward declaration and prints it if not.
-  void checkAndEmitForwardDecl(NamedDecl *D) {
-    if (Printed.insert(D).second)
-      printForwardDecl(D);
-  }
-
-  void VisitTemplateArgs(ArrayRef<TemplateArgument> Args) {
-    for (size_t I = 0, E = Args.size(); I < E; ++I)
-      Visit(Args[I]);
-  }
-
-public:
-  SYCLFwdDeclEmitter(raw_ostream &OS, const LangOptions &LO)
-      : OS(OS), Policy(LO) {
-    Policy.adjustForCPlusPlusFwdDecl();
-    Policy.SuppressTypedefs = true;
-    Policy.SuppressUnwrittenScope = true;
-    Policy.PrintCanonicalTypes = true;
-    Policy.SkipCanonicalizationOfTemplateTypeParms = true;
-    Policy.SuppressFinalSpecifier = true;
-  }
-
-  void Visit(QualType T) {
-    if (T.isNull())
-      return;
-    InnerTypeVisitor::Visit(T.getTypePtr());
-  }
-
-  void VisitReferenceType(const ReferenceType *RT) {
-    // Our forward declarations don't care about references, so we should just
-    // ignore the reference and continue on.
-    Visit(RT->getPointeeType());
-  }
-
-  void Visit(const TemplateArgument &TA) {
-    if (TA.isNull())
-      return;
-    InnerTemplArgVisitor::Visit(TA);
-  }
-
-  void VisitPointerType(const PointerType *T) {
-    // Peel off the pointer types.
-    QualType PT = T->getPointeeType();
-    while (PT->isPointerType())
-      PT = PT->getPointeeType();
-    Visit(PT);
-  }
-
-  void VisitTagType(const TagType *T) {
-    TagDecl *TD = T->getDecl();
-    if (const auto *TSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
-      // - first, recurse into template parameters and emit needed forward
-      //   declarations
-      ArrayRef<TemplateArgument> Args = TSD->getTemplateArgs().asArray();
-      VisitTemplateArgs(Args);
-      // - second, emit forward declaration for the template class being
-      //   specialized
-      ClassTemplateDecl *CTD = TSD->getSpecializedTemplate();
-      assert(CTD && "template declaration must be available");
-
-      checkAndEmitForwardDecl(CTD);
-      return;
-    }
-    checkAndEmitForwardDecl(TD);
-  }
-
-  void VisitTypeTemplateArgument(const TemplateArgument &TA) {
-    QualType T = TA.getAsType();
-    Visit(T);
-  }
-
-  void VisitIntegralTemplateArgument(const TemplateArgument &TA) {
-    QualType T = TA.getIntegralType();
-    if (const EnumType *ET = T->getAs<EnumType>())
-      VisitTagType(ET);
-  }
-
-  void VisitTemplateTemplateArgument(const TemplateArgument &TA) {
-    // recursion is not required, since the maximum possible nesting level
-    // equals two for template argument
-    //
-    // for example:
-    //   template <typename T> class Bar;
-    //   template <template <typename> class> class Baz;
-    //   template <template <template <typename> class> class T>
-    //   class Foo;
-    //
-    // The Baz is a template class. The Baz<Bar> is a class. The class Foo
-    // should be specialized with template class, not a class. The correct
-    // specialization of template class Foo is Foo<Baz>. The incorrect
-    // specialization of template class Foo is Foo<Baz<Bar>>. In this case
-    // template class Foo specialized by class Baz<Bar>, not a template
-    // class template <template <typename> class> class T as it should.
-    TemplateDecl *TD = TA.getAsTemplate().getAsTemplateDecl();
-    assert(TD && "template declaration must be available");
-    TemplateParameterList *TemplateParams = TD->getTemplateParameters();
-    for (NamedDecl *P : *TemplateParams) {
-      // If template template parameter type has an enum value template
-      // parameter, forward declaration of enum type is required. Only enum
-      // values (not types) need to be handled. For example, consider the
-      // following kernel name type:
-      //
-      // template <typename EnumTypeOut, template <EnumValueIn EnumValue,
-      // typename TypeIn> class T> class Foo;
-      //
-      // The correct specialization for Foo (with enum type) is:
-      // Foo<EnumTypeOut, Baz>, where Baz is a template class.
-      //
-      // Therefore the forward class declarations generated in the
-      // integration header are:
-      // template <EnumValueIn EnumValue, typename TypeIn> class Baz;
-      // template <typename EnumTypeOut, template <EnumValueIn EnumValue,
-      // typename EnumTypeIn> class T> class Foo;
-      //
-      // This requires the following enum forward declarations:
-      // enum class EnumTypeOut : int; (Used to template Foo)
-      // enum class EnumValueIn : int; (Used to template Baz)
-      if (NonTypeTemplateParmDecl *TemplateParam =
-              dyn_cast<NonTypeTemplateParmDecl>(P))
-        if (const EnumType *ET = TemplateParam->getType()->getAs<EnumType>())
-          VisitTagType(ET);
-    }
-    checkAndEmitForwardDecl(TD);
-  }
-
-  void VisitPackTemplateArgument(const TemplateArgument &TA) {
-    VisitTemplateArgs(TA.getPackAsArray());
-  }
-
-  void VisitFunctionProtoType(const FunctionProtoType *T) {
-    for (const auto Ty : T->getParamTypes())
-      Visit(Ty.getCanonicalType());
-    // So far this visitor method is only used for free function kernels whose
-    // return type is void anyway, so it is not visited. Otherwise, add if
-    // required.
-  }
-};
-
-class SYCLKernelNameTypePrinter
-    : public TypeVisitor<SYCLKernelNameTypePrinter>,
-      public ConstTemplateArgumentVisitor<SYCLKernelNameTypePrinter> {
-  using InnerTypeVisitor = TypeVisitor<SYCLKernelNameTypePrinter>;
-  using InnerTemplArgVisitor =
-      ConstTemplateArgumentVisitor<SYCLKernelNameTypePrinter>;
-  raw_ostream &OS;
-  PrintingPolicy &Policy;
-
-  void printTemplateArgs(ArrayRef<TemplateArgument> Args) {
-    for (size_t I = 0, E = Args.size(); I < E; ++I) {
-      const TemplateArgument &Arg = Args[I];
-      // If argument is an empty pack argument, skip printing comma and
-      // argument.
-      if (Arg.getKind() == TemplateArgument::ArgKind::Pack && !Arg.pack_size())
-        continue;
-
-      if (I)
-        OS << ", ";
-
-      Visit(Arg);
-    }
-  }
-
-  void VisitQualifiers(Qualifiers Quals) {
-    Quals.print(OS, Policy, /*appendSpaceIfNotEmpty*/ true);
-  }
-
-  // Use recursion to print the namespace-qualified name for the purposes of the
-  // canonical sycl example of a type being created in the kernel call.
-  void PrintNamespaceScopes(const DeclContext *DC) {
-    if (isa<NamespaceDecl, FunctionDecl, RecordDecl, LinkageSpecDecl>(DC)) {
-      PrintNamespaceScopes(DC->getParent());
-
-      const auto *NS = dyn_cast<NamespaceDecl>(DC);
-      if (NS && !NS->isAnonymousNamespace())
-        OS << NS->getName() << "::";
-    }
-  }
-
-public:
-  SYCLKernelNameTypePrinter(raw_ostream &OS, PrintingPolicy &Policy)
-      : OS(OS), Policy(Policy) {}
-
-  void Visit(QualType T) {
-    if (T.isNull())
-      return;
-
-    QualType CT = T.getCanonicalType();
-    VisitQualifiers(CT.getQualifiers());
-
-    InnerTypeVisitor::Visit(CT.getTypePtr());
-  }
-
-  void VisitType(const Type *T) {
-    OS << QualType::getAsString(T, Qualifiers(), Policy);
-  }
-
-  void Visit(const TemplateArgument &TA) {
-    if (TA.isNull())
-      return;
-    InnerTemplArgVisitor::Visit(TA);
-  }
-
-  void VisitTagType(const TagType *T) {
-    TagDecl *RD = T->getDecl();
-    if (const auto *TSD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
-
-      // Print template class name
-      TSD->printQualifiedName(OS, Policy, /*WithGlobalNsPrefix*/ true);
-
-      ArrayRef<TemplateArgument> Args = TSD->getTemplateArgs().asArray();
-      OS << "<";
-      printTemplateArgs(Args);
-      OS << ">";
-
-      return;
-    }
-
-    // Handle the canonical sycl example where the type is created for the first
-    // time in the kernel naming. We want to qualify this as fully as we can,
-    // but not in a way that won't be forward declarable.  See
-    // SYCLFwdDeclEmitter::printForwardDecl for the corresponding list for
-    // printing the forward declaration, these two must match.
-    DeclContext *DC = RD->getDeclContext();
-    if (isa<FunctionDecl, RecordDecl, LinkageSpecDecl>(DC)) {
-      PrintNamespaceScopes(DC);
-      RD->printName(OS, Policy);
-      return;
-    }
-
-    const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(RD->getDeclContext());
-    RD->printQualifiedName(OS, Policy, !(NS && NS->isAnonymousNamespace()));
-  }
-
-  void VisitTemplateArgument(const TemplateArgument &TA) {
-    TA.print(Policy, OS, false /* IncludeType */);
-  }
-
-  void VisitTypeTemplateArgument(const TemplateArgument &TA) {
-    Policy.SuppressTagKeyword = true;
-    QualType T = TA.getAsType();
-    Visit(T);
-    Policy.SuppressTagKeyword = false;
-  }
-
-  void VisitIntegralTemplateArgument(const TemplateArgument &TA) {
-    QualType T = TA.getIntegralType();
-    if (const EnumType *ET = T->getAs<EnumType>()) {
-      const llvm::APSInt &Val = TA.getAsIntegral();
-      OS << "static_cast<";
-      ET->getDecl()->printQualifiedName(OS, Policy,
-                                        /*WithGlobalNsPrefix*/ true);
-      OS << ">(" << Val << ")";
-    } else {
-      TA.print(Policy, OS, false /* IncludeType */);
-    }
-  }
-
-  void VisitTemplateTemplateArgument(const TemplateArgument &TA) {
-    TemplateDecl *TD = TA.getAsTemplate().getAsTemplateDecl();
-    TD->printQualifiedName(OS, Policy);
-  }
-
-  void VisitPackTemplateArgument(const TemplateArgument &TA) {
-    printTemplateArgs(TA.getPackAsArray());
-  }
-};
-
-static void OutputStableNameChar(raw_ostream &O, char C) {
-  // If it is reliably printable, print in the integration header as a
-  // character. Else just print it as the integral representation.
-  if (llvm::isPrint(C))
-    O << '\'' << C << '\'';
-  else
-    O << static_cast<short>(C);
-}
-
-static void OutputStableNameInChars(raw_ostream &O, StringRef Name) {
-  assert(!Name.empty() && "Expected a nonempty string!");
-  OutputStableNameChar(O, Name[0]);
-
-  for (char C : Name.substr(1)) {
-    O << ", ";
-    OutputStableNameChar(O, C);
-  }
-}
-
-static void EmitPragmaDiagnosticPush(raw_ostream &O, StringRef DiagName) {
-  O << "\n";
-  O << "#ifdef __clang__\n";
-  O << "#pragma clang diagnostic push\n";
-  O << "#pragma clang diagnostic ignored \"" << DiagName.str() << "\"\n";
-  O << "#endif // defined(__clang__)\n";
-  O << "\n";
-}
-
-static void EmitPragmaDiagnosticPop(raw_ostream &O) {
-  O << "\n";
-  O << "#ifdef __clang__\n";
-  O << "#pragma clang diagnostic pop\n";
-  O << "#endif // defined(__clang__)\n";
-  O << "\n";
-}
-
-void SYCLIntegrationHeader::emit(raw_ostream &O) {
-  O << "// This is auto-generated SYCL integration header.\n";
-  O << "\n";
-
-  O << "#include <sycl/detail/defines_elementary.hpp>\n";
-  O << "#include <sycl/detail/kernel_desc.hpp>\n";
-  O << "#include <sycl/ext/oneapi/experimental/free_function_traits.hpp>\n";
-
-  O << "\n";
-
-  LangOptions LO;
-  PrintingPolicy Policy(LO);
-  Policy.SuppressTypedefs = true;
-  Policy.SuppressUnwrittenScope = true;
-  // Disable printing anonymous tag locations because on Windows
-  // file path separators are treated as escape sequences and cause errors
-  // when integration header is compiled with host compiler.
-  Policy.AnonymousTagLocations = 0;
-  SYCLFwdDeclEmitter FwdDeclEmitter(O, S.getLangOpts());
-
-  // Predefines which need to be set for custom host compilation
-  // must be defined in integration header.
-  for (const std::pair<StringRef, StringRef> &Macro :
-       getSYCLVersionMacros(S.getLangOpts())) {
-    O << "#ifndef " << Macro.first << '\n';
-    O << "#define " << Macro.first << " " << Macro.second << '\n';
-    O << "#endif //" << Macro.first << "\n\n";
-  }
-
-  switch (S.getLangOpts().getSYCLRangeRounding()) {
-  case LangOptions::SYCLRangeRoundingPreference::Disable:
-    O << "#ifndef __SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING__ \n";
-    O << "#define __SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING__ 1\n";
-    O << "#endif //__SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING__\n\n";
-    break;
-  case LangOptions::SYCLRangeRoundingPreference::Force:
-    O << "#ifndef __SYCL_FORCE_PARALLEL_FOR_RANGE_ROUNDING__ \n";
-    O << "#define __SYCL_FORCE_PARALLEL_FOR_RANGE_ROUNDING__ 1\n";
-    O << "#endif //__SYCL_FORCE_PARALLEL_FOR_RANGE_ROUNDING__\n\n";
-    break;
-  default:
-    break;
-  }
-
-  if (S.getLangOpts().SYCLExperimentalRangeRounding) {
-    O << "#ifndef __SYCL_EXP_PARALLEL_FOR_RANGE_ROUNDING__ \n";
-    O << "#define __SYCL_EXP_PARALLEL_FOR_RANGE_ROUNDING__ 1\n";
-    O << "#endif //__SYCL_EXP_PARALLEL_FOR_RANGE_ROUNDING__\n\n";
-  }
-
-  if (SpecConsts.size() > 0) {
-    O << "// Forward declarations of templated spec constant types:\n";
-    for (const auto &SC : SpecConsts)
-      FwdDeclEmitter.Visit(SC.first);
-    O << "\n";
-
-    // Remove duplicates.
-    std::sort(SpecConsts.begin(), SpecConsts.end(),
-              [](const SpecConstID &SC1, const SpecConstID &SC2) {
-                // Sort by string IDs for stable spec consts order in the
-                // header.
-                return SC1.second.compare(SC2.second) < 0;
-              });
-    SpecConstID *End =
-        std::unique(SpecConsts.begin(), SpecConsts.end(),
-                    [](const SpecConstID &SC1, const SpecConstID &SC2) {
-                      // Here can do faster comparison of types.
-                      return SC1.first == SC2.first;
-                    });
-
-    O << "// Specialization constants IDs:\n";
-    for (const auto &P : llvm::make_range(SpecConsts.begin(), End)) {
-      O << "template <> struct sycl::detail::SpecConstantInfo<";
-      SYCLKernelNameTypePrinter Printer(O, Policy);
-      Printer.Visit(P.first);
-      O << "> {\n";
-      O << "  static constexpr const char* getName() {\n";
-      O << "    return \"" << P.second << "\";\n";
-      O << "  }\n";
-      O << "};\n";
-    }
-  }
-
-  O << "// Forward declarations of templated kernel function types:\n";
-  for (const KernelDesc &K : KernelDescs)
-    if (!K.IsUnnamedKernel)
-      FwdDeclEmitter.Visit(K.NameType);
-  O << "\n";
-
-  O << "namespace sycl {\n";
-  O << "inline namespace _V1 {\n";
-  O << "namespace detail {\n";
-
-  // Generate declaration of variable of type __sycl_device_global_registration
-  // whose sole purpose is to run its constructor before the application's
-  // main() function.
-
-  if (NeedToEmitDeviceGlobalRegistration) {
-    // Supress the reserved identifier diagnostic that clang generates
-    // for the construct below.
-    EmitPragmaDiagnosticPush(O, "-Wreserved-identifier");
-    O << "namespace {\n";
-
-    O << "class __sycl_device_global_registration {\n";
-    O << "public:\n";
-    O << "  __sycl_device_global_registration() noexcept;\n";
-    O << "};\n";
-    O << "__sycl_device_global_registration __sycl_device_global_registrar;\n";
-
-    O << "} // namespace\n";
-
-    O << "\n";
-    EmitPragmaDiagnosticPop(O);
-  }
-
-  // Generate declaration of variable of type __sycl_host_pipe_registration
-  // whose sole purpose is to run its constructor before the application's
-  // main() function.
-  if (NeedToEmitHostPipeRegistration) {
-    // Supress the reserved identifier diagnostic that clang generates
-    // for the construct below.
-    EmitPragmaDiagnosticPush(O, "-Wreserved-identifier");
-    O << "namespace {\n";
-
-    O << "class __sycl_host_pipe_registration {\n";
-    O << "public:\n";
-    O << "  __sycl_host_pipe_registration() noexcept;\n";
-    O << "};\n";
-    O << "__sycl_host_pipe_registration __sycl_host_pipe_registrar;\n";
-
-    O << "} // namespace\n";
-
-    O << "\n";
-    EmitPragmaDiagnosticPop(O);
-  }
-
-
-  O << "// names of all kernels defined in the corresponding source\n";
-  O << "static constexpr\n";
-  O << "const char* const kernel_names[] = {\n";
-
-  for (unsigned I = 0; I < KernelDescs.size(); I++) {
-    O << "  \"" << KernelDescs[I].Name << "\",\n";
-  }
-  // Add a sentinel to avoid warning if the collection is empty
-  // (similar to what we do for kernel_signatures below).
-  O << "  \"\",\n";
-  O << "};\n\n";
-
-  O << "// array representing signatures of all kernels defined in the\n";
-  O << "// corresponding source\n";
-  O << "static constexpr\n";
-  O << "const kernel_param_desc_t kernel_signatures[] = {\n";
-
-  for (unsigned I = 0; I < KernelDescs.size(); I++) {
-    auto &K = KernelDescs[I];
-    O << "  //--- " << K.Name << "\n";
-
-    for (const auto &P : K.Params) {
-      std::string TyStr = paramKind2Str(P.Kind);
-      O << "  { kernel_param_kind_t::" << TyStr << ", ";
-      O << P.Info << ", " << P.Offset << " },\n";
-    }
-    O << "\n";
-  }
-
-  // Sentinel in place for 2 reasons:
-  // 1- to make sure we don't get a warning because this collection is empty.
-  // 2- to provide an obvious value that we can use when debugging to see that
-  //    we have left valid kernel information.
-  // integer-field values are negative, so they are obviously invalid, notable
-  // enough to 'stick out' and 'negative enough' to not be easily reachable by a
-  // mathematical error.
-  O << "  { kernel_param_kind_t::kind_invalid, -987654321, -987654321 }, \n";
-  O << "};\n\n";
-
-  O << "// Specializations of KernelInfo for kernel function types:\n";
-  unsigned CurStart = 0;
-
-  for (const KernelDesc &K : KernelDescs) {
-    const size_t N = K.Params.size();
-    PresumedLoc PLoc = S.getASTContext().getSourceManager().getPresumedLoc(
-        S.getASTContext()
-            .getSourceManager()
-            .getExpansionRange(K.KernelLocation)
-            .getEnd());
-    if (K.IsUnnamedKernel) {
-      O << "template <> struct KernelInfoData<";
-      OutputStableNameInChars(O, K.StableName);
-      O << "> {\n";
-    } else {
-      O << "template <> struct KernelInfo<";
-      SYCLKernelNameTypePrinter Printer(O, Policy);
-      Printer.Visit(K.NameType);
-      O << "> {\n";
-    }
-
-    O << "  __SYCL_DLL_LOCAL\n";
-    O << "  static constexpr const char* getName() { return \"" << K.Name
-      << "\"; }\n";
-    O << "  __SYCL_DLL_LOCAL\n";
-    O << "  static constexpr unsigned getNumParams() { return " << N << "; }\n";
-    O << "  __SYCL_DLL_LOCAL\n";
-    O << "  static constexpr const kernel_param_desc_t& ";
-    O << "getParamDesc(unsigned i) {\n";
-    O << "    return kernel_signatures[i+" << CurStart << "];\n";
-    O << "  }\n";
-    O << "  __SYCL_DLL_LOCAL\n";
-    O << "  static constexpr bool isESIMD() { return " << K.IsESIMDKernel
-      << "; }\n";
-    O << "  __SYCL_DLL_LOCAL\n";
-    O << "  static constexpr const char* getFileName() {\n";
-    O << "#ifndef NDEBUG\n";
-    O << "    return \""
-      << std::string(PLoc.getFilename())
-             .substr(std::string(PLoc.getFilename()).find_last_of("/\\") + 1);
-    O << "\";\n";
-    O << "#else\n";
-    O << "    return \"\";\n";
-    O << "#endif\n";
-    O << "  }\n";
-    O << "  __SYCL_DLL_LOCAL\n";
-    O << "  static constexpr const char* getFunctionName() {\n";
-    O << "#ifndef NDEBUG\n";
-    O << "    return \"";
-    SYCLKernelNameTypePrinter Printer(O, Policy);
-    Printer.Visit(K.NameType);
-    O << "\";\n";
-    O << "#else\n";
-    O << "    return \"\";\n";
-    O << "#endif\n";
-    O << "  }\n";
-    O << "  __SYCL_DLL_LOCAL\n";
-    O << "  static constexpr unsigned getLineNumber() {\n";
-    O << "#ifndef NDEBUG\n";
-    O << "    return " << PLoc.getLine() << ";\n";
-    O << "#else\n";
-    O << "    return 0;\n";
-    O << "#endif\n";
-    O << "  }\n";
-    O << "  __SYCL_DLL_LOCAL\n";
-    O << "  static constexpr unsigned getColumnNumber() {\n";
-    O << "#ifndef NDEBUG\n";
-    O << "    return " << PLoc.getColumn() << ";\n";
-    O << "#else\n";
-    O << "    return 0;\n";
-    O << "#endif\n";
-    O << "  }\n";
-    StringRef ReturnType = (S.getASTContext().getTargetInfo().getInt64Type() ==
-                            TargetInfo::SignedLong)
-                               ? "long"
-                               : "long long";
-    O << "  // Returns the size of the kernel object in bytes.\n";
-    O << "  __SYCL_DLL_LOCAL\n";
-    O << "  static constexpr " << ReturnType << " getKernelSize() { return "
-      << K.ObjSize << "; }\n";
-    O << "};\n";
-    CurStart += N;
-  }
-  O << "\n";
-  O << "} // namespace detail\n";
-  O << "} // namespace _V1\n";
-  O << "} // namespace sycl\n";
-
-  unsigned ShimCounter = 1;
-  int FreeFunctionCount = 0;
-  for (const KernelDesc &K : KernelDescs) {
-    if (!isFreeFunction(S, K.SyclKernel))
-      continue;
-    ++FreeFunctionCount;
-    // Generate forward declaration for free function.
-    O << "\n// Definition of " << K.Name << " as a free function kernel\n";
-
-    O << "\n";
-    O << "// Forward declarations of kernel and its argument types:\n";
-    FwdDeclEmitter.Visit(K.SyclKernel->getType());
-    O << "\n";
-
-    if (K.SyclKernel->getLanguageLinkage() == CLanguageLinkage)
-      O << "extern \"C\" ";
-    std::string ParmList;
-    bool FirstParam = true;
-    for (ParmVarDecl *Param : K.SyclKernel->parameters()) {
-      if (FirstParam)
-        FirstParam = false;
-      else
-        ParmList += ", ";
-      ParmList += Param->getType().getCanonicalType().getAsString();
-    }
-    FunctionTemplateDecl *FTD = K.SyclKernel->getPrimaryTemplate();
-    Policy.SuppressDefinition = true;
-    Policy.PolishForDeclaration = true;
-    if (FTD) {
-      FTD->print(O, Policy);
-    } else {
-      K.SyclKernel->print(O, Policy);
-    }
-    O << ";\n";
-
-    // Generate a shim function that returns the address of the free function.
-    O << "static constexpr auto __sycl_shim" << ShimCounter << "() {\n";
-    O << "  return (void (*)(" << ParmList << "))"
-      << K.SyclKernel->getIdentifier()->getName().data();
-    if (FTD) {
-      const TemplateArgumentList *TAL =
-          K.SyclKernel->getTemplateSpecializationArgs();
-      ArrayRef<TemplateArgument> A = TAL->asArray();
-      bool FirstParam = true;
-      O << "<";
-      for (const auto &X : A) {
-        if (FirstParam)
-          FirstParam = false;
-        else
-          O << ", ";
-        X.print(Policy, O, true);
-      }
-      O << ">";
-    }
-    O << ";\n";
-    O << "}\n";
-
-    // Generate is_kernel, is_single_task_kernel and nd_range_kernel functions.
-    O << "namespace sycl {\n";
-    O << "template <>\n";
-    O << "struct ext::oneapi::experimental::is_kernel<__sycl_shim"
-      << ShimCounter << "()";
-    O << "> {\n";
-    O << "  static constexpr bool value = true;\n";
-    O << "};\n";
-    int Dim = getFreeFunctionRangeDim(S, K.SyclKernel);
-    O << "template <>\n";
-    if (Dim > 0)
-      O << "struct ext::oneapi::experimental::is_nd_range_kernel<__sycl_shim"
-        << ShimCounter << "(), " << Dim;
-    else
-      O << "struct "
-           "ext::oneapi::experimental::is_single_task_kernel<__sycl_shim"
-        << ShimCounter << "()";
-    O << "> {\n";
-    O << "  static constexpr bool value = true;\n";
-    O << "};\n";
-    O << "}\n";
-    ++ShimCounter;
-  }
-
-  if (FreeFunctionCount > 0) {
-    O << "\n#include <sycl/kernel_bundle.hpp>\n";
-  }
-  ShimCounter = 1;
-  for (const KernelDesc &K : KernelDescs) {
-    if (!isFreeFunction(S, K.SyclKernel))
-      continue;
-
-    O << "\n// Definition of kernel_id of " << K.Name << "\n";
-    O << "namespace sycl {\n";
-    O << "template <>\n";
-    O << "kernel_id ext::oneapi::experimental::get_kernel_id<__sycl_shim"
-      << ShimCounter << "()>() {\n";
-    O << "  return sycl::detail::get_kernel_id_impl(std::string_view{\""
-      << K.Name << "\"});\n";
-    O << "}\n";
-    O << "}\n";
-    ++ShimCounter;
-  }
-}
-
-bool SYCLIntegrationHeader::emit(StringRef IntHeaderName) {
-  if (IntHeaderName.empty())
-    return false;
-  int IntHeaderFD = 0;
-  std::error_code EC =
-      llvm::sys::fs::openFileForWrite(IntHeaderName, IntHeaderFD);
-  if (EC) {
-    llvm::errs() << "Error: " << EC.message() << "\n";
-    // compilation will fail on absent include file - don't need to fail here
-    return false;
-  }
-  llvm::raw_fd_ostream Out(IntHeaderFD, true /*close in destructor*/);
-  emit(Out);
-  return true;
-}
-
-void SYCLIntegrationHeader::startKernel(const FunctionDecl *SyclKernel,
-                                        QualType KernelNameType,
-                                        SourceLocation KernelLocation,
-                                        bool IsESIMDKernel,
-                                        bool IsUnnamedKernel, int64_t ObjSize) {
-  KernelDescs.emplace_back(SyclKernel, KernelNameType, KernelLocation,
-                           IsESIMDKernel, IsUnnamedKernel, ObjSize);
-}
-
-void SYCLIntegrationHeader::addParamDesc(kernel_param_kind_t Kind, int Info,
-                                         unsigned Offset) {
-  auto *K = getCurKernelDesc();
-  assert(K && "no kernels");
-  K->Params.push_back(KernelParamDesc());
-  KernelParamDesc &PD = K->Params.back();
-  PD.Kind = Kind;
-  PD.Info = Info;
-  PD.Offset = Offset;
-}
-
-void SYCLIntegrationHeader::endKernel() {
-  // nop for now
-}
-
-void SYCLIntegrationHeader::addSpecConstant(StringRef IDName, QualType IDType) {
-  SpecConsts.emplace_back(std::make_pair(IDType, IDName.str()));
-}
-
-SYCLIntegrationHeader::SYCLIntegrationHeader(SemaSYCL &S) : S(S) {}
-
-void SYCLIntegrationFooter::addVarDecl(const VarDecl *VD) {
-  // Variable template declaration can result in an error case of 'nullptr'
-  // here.
-  if (!VD)
-    return;
-  // Skip the dependent version of these variables, we only care about them
-  // after instantiation.
-  if (VD->getDeclContext()->isDependentContext())
-    return;
-
-  // Skip partial specializations of a variable template, treat other variable
-  // template instantiations as a VarDecl.
-  if (isa<VarTemplatePartialSpecializationDecl>(VD))
-    return;
-  // Step 1: ensure that this is of the correct type template specialization.
-  if (!SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::specialization_id) &&
-      !SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::host_pipe) &&
-      !S.isTypeDecoratedWithDeclAttribute<SYCLDeviceGlobalAttr>(
-          VD->getType())) {
-    // Handle the case where this could be a deduced type, such as a deduction
-    // guide. We have to do this here since this function, unlike most of the
-    // rest of this file, is called during Sema instead of after it. We will
-    // also have to filter out after deduction later.
-    QualType Ty = VD->getType().getCanonicalType();
-    if (!Ty->isUndeducedType())
-      return;
-  }
-  // Step 2: ensure that this is a static member, or a namespace-scope.
-  // Note that isLocalVarDeclorParm excludes thread-local and static-local
-  // intentionally, as there is no way to 'spell' one of those in the
-  // specialization. We just don't generate the specialization for those, and
-  // let an error happen during host compilation. To avoid multiple entries for
-  // redeclarations, variables with external storage are omitted.
-  if (VD->hasLocalStorage() || VD->isLocalVarDeclOrParm() ||
-      VD->hasExternalStorage())
-    return;
-
-  // Step 3: Add to collection.
-  GlobalVars.push_back(VD);
-}
-
-// Post-compile integration header support.
-bool SYCLIntegrationFooter::emit(StringRef IntHeaderName) {
-  if (IntHeaderName.empty())
-    return false;
-  int IntHeaderFD = 0;
-  std::error_code EC =
-      llvm::sys::fs::openFileForWrite(IntHeaderName, IntHeaderFD);
-  if (EC) {
-    llvm::errs() << "Error: " << EC.message() << "\n";
-    // compilation will fail on absent include file - don't need to fail here
-    return false;
-  }
-  llvm::raw_fd_ostream Out(IntHeaderFD, true /*close in destructor*/);
-  return emit(Out);
-}
-
-template <typename BeforeFn, typename AfterFn>
-static void PrintNSHelper(BeforeFn Before, AfterFn After, raw_ostream &OS,
-                          const DeclContext *DC) {
-  if (DC->isTranslationUnit())
-    return;
-
-  const auto *CurDecl = cast<Decl>(DC);
-  // Ensure we are in the canonical version, so that we know we have the 'full'
-  // name of the thing.
-  CurDecl = CurDecl->getCanonicalDecl();
-
-  // We are intentionally skipping linkage decls and record decls.  Namespaces
-  // can appear in a linkage decl, but not a record decl, so we don't have to
-  // worry about the names getting messed up from that.  We handle record decls
-  // later when printing the name of the thing.
-  const auto *NS = dyn_cast<NamespaceDecl>(CurDecl);
-  if (NS)
-    Before(OS, NS);
-
-  if (const DeclContext *NewDC = CurDecl->getDeclContext())
-    PrintNSHelper(Before, After, OS, NewDC);
-
-  if (NS)
-    After(OS, NS);
-}
-
-static void PrintNamespaces(raw_ostream &OS, const DeclContext *DC) {
-  PrintNSHelper([](raw_ostream &OS, const NamespaceDecl *NS) {},
-                [](raw_ostream &OS, const NamespaceDecl *NS) {
-                  if (NS->isInline())
-                    OS << "inline ";
-                  OS << "namespace ";
-                  if (!NS->isAnonymousNamespace())
-                    OS << NS->getName() << " ";
-                  OS << "{\n";
-                },
-                OS, DC);
-}
-
-static void PrintNSClosingBraces(raw_ostream &OS, const DeclContext *DC) {
-  PrintNSHelper(
-      [](raw_ostream &OS, const NamespaceDecl *NS) {
-        OS << "} // ";
-        if (NS->isInline())
-          OS << "inline ";
-
-        OS << "namespace ";
-        if (!NS->isAnonymousNamespace())
-          OS << NS->getName();
-
-        OS << '\n';
-      },
-      [](raw_ostream &OS, const NamespaceDecl *NS) {}, OS, DC);
-}
-
-static std::string EmitShim(raw_ostream &OS, unsigned &ShimCounter,
-                            const std::string &LastShim,
-                            const NamespaceDecl *AnonNS) {
-  std::string NewShimName =
-      "__sycl_detail::__shim_" + std::to_string(ShimCounter) + "()";
-  // Print opening-namespace
-  PrintNamespaces(OS, Decl::castToDeclContext(AnonNS));
-  OS << "namespace __sycl_detail {\n";
-  OS << "static constexpr decltype(" << LastShim << ") &__shim_" << ShimCounter
-     << "() {\n";
-  OS << "  return " << LastShim << ";\n";
-  OS << "}\n";
-  OS << "} // namespace __sycl_detail\n";
-  PrintNSClosingBraces(OS, Decl::castToDeclContext(AnonNS));
-
-  ++ShimCounter;
-  return NewShimName;
-}
-
-// Emit the list of shims required for a DeclContext, calls itself recursively.
-static void EmitShims(raw_ostream &OS, unsigned &ShimCounter,
-                      const DeclContext *DC, std::string &NameForLastShim,
-                      PrintingPolicy &Policy) {
-  if (DC->isTranslationUnit()) {
-    NameForLastShim = "::" + NameForLastShim;
-    return;
-  }
-
-  const auto *CurDecl = cast<Decl>(DC)->getCanonicalDecl();
-
-  // We skip linkage decls, since they don't modify the Qualified name.
-  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {
-    std::string TemplatedName;
-    llvm::raw_string_ostream Stream(TemplatedName);
-    CTSD->getNameForDiagnostic(Stream, Policy, false);
-    Stream.flush();
-    NameForLastShim = TemplatedName + "::" + NameForLastShim;
-  } else if (const auto *RD = dyn_cast<RecordDecl>(CurDecl)) {
-    NameForLastShim = RD->getNameAsString() + "::" + NameForLastShim;
-  } else if (const auto *ND = dyn_cast<NamespaceDecl>(CurDecl)) {
-    if (ND->isAnonymousNamespace()) {
-      // Print current shim, reset 'name for last shim'.
-      NameForLastShim = EmitShim(OS, ShimCounter, NameForLastShim, ND);
-    } else {
-      NameForLastShim = ND->getNameAsString() + "::" + NameForLastShim;
-    }
-  } else {
-    // FIXME: I don't believe there are other declarations that these variables
-    // could possibly find themselves in. LinkageDecls don't change the
-    // qualified name, so there is nothing to do here. At one point we should
-    // probably convince ourselves that this is entire list and remove this
-    // comment.
-    assert((isa<LinkageSpecDecl, ExternCContextDecl>(CurDecl)) &&
-           "Unhandled decl type");
-  }
-
-  EmitShims(OS, ShimCounter, CurDecl->getDeclContext(), NameForLastShim,
-            Policy);
-}
-
-// Emit the list of shims required for a variable declaration.
-// Returns a string containing the FQN of the 'top most' shim, including its
-// function call parameters.
-static std::string EmitShims(raw_ostream &OS, unsigned &ShimCounter,
-                             PrintingPolicy &Policy, const VarDecl *VD) {
-  if (!VD->isInAnonymousNamespace())
-    return "";
-  std::string RelativeName;
-  llvm::raw_string_ostream stream(RelativeName);
-  VD->getNameForDiagnostic(stream, Policy, false);
-  stream.flush();
-
-  EmitShims(OS, ShimCounter, VD->getDeclContext(), RelativeName, Policy);
-  return RelativeName;
-}
-
-bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
-  PrintingPolicy Policy{S.getLangOpts()};
-  Policy.adjustForCPlusPlusFwdDecl();
-  Policy.SuppressTypedefs = true;
-  Policy.SuppressUnwrittenScope = true;
-
-  llvm::SmallSet<const VarDecl *, 8> Visited;
-  bool EmittedFirstSpecConstant = false;
-  bool DeviceGlobalsEmitted = false;
-  bool HostPipesEmitted = false;
-
-  // Used to uniquely name the 'shim's as we generate the names in each
-  // anonymous namespace.
-  unsigned ShimCounter = 0;
-
-  std::string DeviceGlobalsBuf;
-  llvm::raw_string_ostream DeviceGlobOS(DeviceGlobalsBuf);
-  std::string HostPipesBuf;
-  llvm::raw_string_ostream HostPipesOS(HostPipesBuf);
-  for (const VarDecl *VD : GlobalVars) {
-    VD = VD->getCanonicalDecl();
-
-    // Skip if this isn't a SpecIdType, DeviceGlobal, or HostPipe.  This 
-    // can happen if it was a deduced type.
-    if (!SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::specialization_id) &&
-        !SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::host_pipe) &&
-        !S.isTypeDecoratedWithDeclAttribute<SYCLDeviceGlobalAttr>(
-            VD->getType()))
-      continue;
-
-    // Skip if we've already visited this.
-    if (llvm::find(Visited, VD) != Visited.end())
-      continue;
-
-    // We only want to emit the #includes if we have a variable that needs
-    // them, so emit this one on the first time through the loop.
-    if (!EmittedFirstSpecConstant && !DeviceGlobalsEmitted && !HostPipesEmitted)
-      OS << "#include <sycl/detail/defines_elementary.hpp>\n";
-
-    Visited.insert(VD);
-    std::string TopShim = EmitShims(OS, ShimCounter, Policy, VD);
-    if (S.isTypeDecoratedWithDeclAttribute<SYCLDeviceGlobalAttr>(
-            VD->getType())) {
-      DeviceGlobalsEmitted = true;
-      DeviceGlobOS << "device_global_map::add(";
-      DeviceGlobOS << "(void *)&";
-      if (VD->isInAnonymousNamespace()) {
-        DeviceGlobOS << TopShim;
-      } else {
-        DeviceGlobOS << "::";
-        VD->getNameForDiagnostic(DeviceGlobOS, Policy, true);
-      }
-      DeviceGlobOS << ", \"";
-      DeviceGlobOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(),
-                                                          VD);
-      DeviceGlobOS << "\");\n";
-    } else if (SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::host_pipe)) {
-      HostPipesEmitted = true;
-      HostPipesOS << "host_pipe_map::add(";
-      HostPipesOS << "(void *)&";
-      if (VD->isInAnonymousNamespace()) {
-        HostPipesOS << TopShim;
-      } else {
-        HostPipesOS << "::";
-        VD->getNameForDiagnostic(HostPipesOS, Policy, true);
-      }
-      HostPipesOS << ", \"";
-      HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(),
-                                                         VD);
-      HostPipesOS << "\");\n";
-    } else {
-      EmittedFirstSpecConstant = true;
-      OS << "namespace sycl {\n";
-      OS << "inline namespace _V1 {\n";
-      OS << "namespace detail {\n";
-      OS << "template<>\n";
-      OS << "inline const char *get_spec_constant_symbolic_ID_impl<";
-
-      if (VD->isInAnonymousNamespace()) {
-        OS << TopShim;
-      } else {
-        OS << "::";
-        VD->getNameForDiagnostic(OS, Policy, true);
-      }
-
-      OS << ">() {\n";
-      OS << "  return \"";
-      OS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(), VD);
-      OS << "\";\n";
-      OS << "}\n";
-      OS << "} // namespace detail\n";
-      OS << "} // namespace _V1\n";
-      OS << "} // namespace sycl\n";
-    }
-  }
-
-  if (EmittedFirstSpecConstant)
-    OS << "#include <sycl/detail/spec_const_integration.hpp>\n";
-
-  if (DeviceGlobalsEmitted) {
-    OS << "#include <sycl/detail/device_global_map.hpp>\n";
-    DeviceGlobOS.flush();
-    OS << "namespace sycl::detail {\n";
-    // Supress the old-style case diagnostic that clang generates
-    // for the construct below in DeviceGlobalsBuf.
-    EmitPragmaDiagnosticPush(OS, "-Wold-style-cast");
-    OS << "namespace {\n";
-    OS << "__sycl_device_global_registration::__sycl_device_global_"
-          "registration() noexcept {\n";
-    OS << DeviceGlobalsBuf;
-    OS << "}\n";
-    OS << "} // namespace (unnamed)\n";
-    EmitPragmaDiagnosticPop(OS);
-    OS << "} // namespace sycl::detail\n";
-
-    S.getSyclIntegrationHeader().addDeviceGlobalRegistration();
-  }
-
-  if (HostPipesEmitted) {
-    OS << "#include <sycl/detail/host_pipe_map.hpp>\n";
-    HostPipesOS.flush();
-    OS << "namespace sycl::detail {\n";
-    // Supress the old-style case diagnostic that clang generates
-    // for the construct below in HostPipesBuf.
-    EmitPragmaDiagnosticPush(OS, "-Wold-style-cast");
-    OS << "namespace {\n";
-    OS << "__sycl_host_pipe_registration::__sycl_host_pipe_"
-          "registration() noexcept {\n";
-    OS << HostPipesBuf;
-    OS << "}\n";
-    OS << "} // namespace (unnamed)\n";
-    EmitPragmaDiagnosticPop(OS);
-    OS << "} // namespace sycl::detail\n";
-
-    S.getSyclIntegrationHeader().addHostPipeRegistration();
-  }
-
-  return true;
-}
-
-ExprResult SemaSYCL::BuildUniqueStableIdExpr(SourceLocation OpLoc,
-                                             SourceLocation LParen,
-                                             SourceLocation RParen, Expr *E) {
-  if (!E->isInstantiationDependent()) {
-    // Special handling to get us better error messages for a member variable.
-    if (auto *ME = dyn_cast<MemberExpr>(E->IgnoreUnlessSpelledInSource())) {
-      if (isa<FieldDecl>(ME->getMemberDecl()))
-        Diag(E->getExprLoc(), diag::err_unique_stable_id_global_storage);
-      else
-        Diag(E->getExprLoc(), diag::err_unique_stable_id_expected_var);
-      return ExprError();
-    }
-
-    auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreUnlessSpelledInSource());
-
-    if (!DRE || !isa_and_nonnull<VarDecl>(DRE->getDecl())) {
-      Diag(E->getExprLoc(), diag::err_unique_stable_id_expected_var);
-      return ExprError();
-    }
-
-    auto *Var = cast<VarDecl>(DRE->getDecl());
-
-    if (!Var->hasGlobalStorage()) {
-      Diag(E->getExprLoc(), diag::err_unique_stable_id_global_storage);
-      return ExprError();
-    }
-  }
-
-  return SYCLUniqueStableIdExpr::Create(getASTContext(), OpLoc, LParen, RParen,
-                                        E);
-}
-
-ExprResult SemaSYCL::ActOnUniqueStableIdExpr(SourceLocation OpLoc,
-                                             SourceLocation LParen,
-                                             SourceLocation RParen, Expr *E) {
-  return BuildUniqueStableIdExpr(OpLoc, LParen, RParen, E);
-}
-
-ExprResult SemaSYCL::BuildUniqueStableNameExpr(SourceLocation OpLoc,
-                                               SourceLocation LParen,
-                                               SourceLocation RParen,
-                                               TypeSourceInfo *TSI) {
-  return SYCLUniqueStableNameExpr::Create(getASTContext(), OpLoc, LParen,
-                                          RParen, TSI);
-}
-
-ExprResult SemaSYCL::ActOnUniqueStableNameExpr(SourceLocation OpLoc,
-                                               SourceLocation LParen,
-                                               SourceLocation RParen,
-                                               ParsedType ParsedTy) {
-  TypeSourceInfo *TSI = nullptr;
-  QualType Ty = SemaRef.GetTypeFromParser(ParsedTy, &TSI);
-
-  if (Ty.isNull())
-    return ExprError();
-  if (!TSI)
-    TSI = getASTContext().getTrivialTypeSourceInfo(Ty, LParen);
-
-  return BuildUniqueStableNameExpr(OpLoc, LParen, RParen, TSI);
-}
-
-void SemaSYCL::performSYCLDelayedAttributesAnalaysis(const FunctionDecl *FD) {
-  if (SYCLKernelFunctions.contains(FD))
-    return;
-
-  for (const auto *KernelAttr : std::vector<AttributeCommonInfo *>{
-           FD->getAttr<SYCLReqdWorkGroupSizeAttr>(),
-           FD->getAttr<IntelReqdSubGroupSizeAttr>(),
-           FD->getAttr<SYCLWorkGroupSizeHintAttr>(),
-           FD->getAttr<VecTypeHintAttr>()}) {
-    if (KernelAttr)
-      Diag(KernelAttr->getLoc(),
-           diag::warn_sycl_incorrect_use_attribute_non_kernel_function)
-          << KernelAttr;
-  }
-}
diff --git a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
index ecd2539abd7ed..775296146c528 100644
--- a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
+++ b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
@@ -417,8 +417,8 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
   // A pointer to image or pipe type in LLVM is translated to a SPIRV
   // (non-pointer) image or pipe type.
   if (T->isPointerTy()) {
-    auto AddrSpc = T->getPointerAddressSpace();
     auto *ET = Type::getInt8Ty(T->getContext());
+    auto AddrSpc = T->getPointerAddressSpace();
     return transPointerType(ET, AddrSpc);
   }
 
@@ -453,19 +453,24 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
   if (T->isArrayTy()) {
     // SPIR-V 1.3 s3.32.6: Length is the number of elements in the array.
     //                     It must be at least 1.
-    const auto ArraySize =
-        T->getArrayNumElements() ? T->getArrayNumElements() : 1;
+    if (T->getArrayNumElements() < 1) {
+      std::string Str;
+      llvm::raw_string_ostream OS(Str);
+      OS << *T;
+      SPIRVCK(T->getArrayNumElements() >= 1, InvalidArraySize, OS.str());
+    }
     Type *ElTy = T->getArrayElementType();
     SPIRVType *TransType = BM->addArrayType(
         transType(ElTy),
         static_cast<SPIRVConstant *>(transValue(
-            ConstantInt::get(getSizetType(), ArraySize, false), nullptr)));
+            ConstantInt::get(getSizetType(), T->getArrayNumElements(), false),
+            nullptr)));
     mapType(T, TransType);
     if (ElTy->isPointerTy()) {
       mapType(
           ArrayType::get(TypedPointerType::get(Type::getInt8Ty(*Ctx),
                                                ElTy->getPointerAddressSpace()),
-                         ArraySize),
+                         T->getArrayNumElements()),
           TransType);
     }
     return TransType;
@@ -715,6 +720,7 @@ SPIRVType *LLVMToSPIRVBase::transPointerType(Type *ET, unsigned AddrSpc) {
           transType(ET)));
     }
   } else {
+    SPIRVType *ElementType = transType(ET);
     // ET, as a recursive type, may contain exactly the same pointer T, so it
     // may happen that after translation of ET we already have translated T,
     // added the translated pointer to the SPIR-V module and mapped T to this
@@ -723,17 +729,7 @@ SPIRVType *LLVMToSPIRVBase::transPointerType(Type *ET, unsigned AddrSpc) {
     if (Loc != PointeeTypeMap.end()) {
       return Loc->second;
     }
-
-    SPIRVType *ElementType = nullptr;
-    SPIRVType *TranslatedTy = nullptr;
-    if (ET->isPointerTy() &&
-        BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers)) {
-      TranslatedTy = BM->addUntypedPointerKHRType(
-          SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)));
-    } else {
-      ElementType = transType(ET);
-      TranslatedTy = transPointerType(ElementType, AddrSpc);
-    }
+    SPIRVType *TranslatedTy = transPointerType(ElementType, AddrSpc);
     PointeeTypeMap[TypeKey] = TranslatedTy;
     return TranslatedTy;
   }
@@ -748,16 +744,8 @@ SPIRVType *LLVMToSPIRVBase::transPointerType(SPIRVType *ET, unsigned AddrSpc) {
   if (Loc != PointeeTypeMap.end())
     return Loc->second;
 
-  SPIRVType *TranslatedTy = nullptr;
-  if (BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers) &&
-      !(ET->isTypeArray() || ET->isTypeVector() || ET->isTypeStruct() ||
-        ET->isTypeImage() || ET->isTypeSampler() || ET->isTypePipe())) {
-    TranslatedTy = BM->addUntypedPointerKHRType(
-        SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)));
-  } else {
-    TranslatedTy = BM->addPointerType(
-        SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)), ET);
-  }
+  SPIRVType *TranslatedTy = BM->addPointerType(
+      SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)), ET);
   PointeeTypeMap[TypeKey] = TranslatedTy;
   return TranslatedTy;
 }
@@ -1324,8 +1312,7 @@ SPIRVValue *LLVMToSPIRVBase::transConstantUse(Constant *C,
   if (Trans->getType() == ExpectedType || Trans->getType()->isTypePipeStorage())
     return Trans;
 
-  assert((C->getType()->isPointerTy() ||
-          ExpectedType->isTypeUntypedPointerKHR()) &&
+  assert(C->getType()->isPointerTy() &&
          "Only pointer type mismatches should be possible");
   // In the common case of strings ([N x i8] GVs), see if we can emit a GEP
   // instruction.
@@ -2063,12 +2050,8 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
           }
         }
       }
-      if (BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers)) {
-        BVarInit = transConstantUse(Init, transType(Init->getType()));
-      } else {
-        SPIRVType *TransTy = transType(Ty);
-        BVarInit = transConstantUse(Init, TransTy->getPointerElementType());
-      }
+      SPIRVType *TransTy = transType(Ty);
+      BVarInit = transConstantUse(Init, TransTy->getPointerElementType());
     }
 
     SPIRVStorageClassKind StorageClass;
@@ -2101,12 +2084,9 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
     }
 
     SPIRVType *TranslatedTy = transType(Ty);
-    auto *BVar = static_cast<SPIRVVariableBase *>(BM->addVariable(
-        TranslatedTy,
-        TranslatedTy->isTypeUntypedPointerKHR() ? transType(GV->getValueType())
-                                                : nullptr,
-        GV->isConstant(), transLinkageType(GV), BVarInit, GV->getName().str(),
-        StorageClass, nullptr));
+    auto *BVar = static_cast<SPIRVVariable *>(
+        BM->addVariable(TranslatedTy, GV->isConstant(), transLinkageType(GV),
+                        BVarInit, GV->getName().str(), StorageClass, nullptr));
 
     if (IsVectorCompute) {
       BVar->addDecorate(DecorationVectorComputeVariableINTEL);
@@ -2216,13 +2196,8 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
                              MemoryAccessNoAliasINTELMaskMask);
     if (MemoryAccess.front() == 0)
       MemoryAccess.clear();
-    return mapValue(
-        V,
-        BM->addLoadInst(
-            transValue(LD->getPointerOperand(), BB), MemoryAccess, BB,
-            BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers)
-                ? transType(LD->getType())
-                : nullptr));
+    return mapValue(V, BM->addLoadInst(transValue(LD->getPointerOperand(), BB),
+                                       MemoryAccess, BB));
   }
 
   if (BinaryOperator *B = dyn_cast<BinaryOperator>(V)) {
@@ -2295,9 +2270,8 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
             StorageClassFunction,
             BM->addArrayType(transType(Alc->getAllocatedType()), Length));
         SPIRVValue *Arr = BM->addVariable(
-            AllocationType, nullptr, false, spv::internal::LinkageTypeInternal,
-            nullptr, Alc->getName().str() + "_alloca", StorageClassFunction,
-            BB);
+            AllocationType, false, spv::internal::LinkageTypeInternal, nullptr,
+            Alc->getName().str() + "_alloca", StorageClassFunction, BB);
         // Manually set alignment. OpBitcast created below will be decorated as
         // that's the SPIR-V value mapped to the original LLVM one.
         transAlign(Alc, Arr);
@@ -2321,10 +2295,7 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
                                  TranslatedTy->getPointerElementType())
             : TranslatedTy;
     SPIRVValue *Var = BM->addVariable(
-        VarTy,
-        VarTy->isTypeUntypedPointerKHR() ? transType(Alc->getAllocatedType())
-                                         : nullptr,
-        false, spv::internal::LinkageTypeInternal, nullptr,
+        VarTy, false, spv::internal::LinkageTypeInternal, nullptr,
         Alc->getName().str(), StorageClassFunction, BB);
     if (V->getType()->getPointerAddressSpace() == SPIRAS_Generic) {
       SPIRVValue *Cast =
@@ -2436,17 +2407,14 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
 
   if (auto *Phi = dyn_cast<PHINode>(V)) {
     std::vector<SPIRVValue *> IncomingPairs;
-    SPIRVType *Ty = transScavengedType(Phi);
 
     for (size_t I = 0, E = Phi->getNumIncomingValues(); I != E; ++I) {
-      SPIRVValue *Val = transValue(Phi->getIncomingValue(I), BB, true,
-                                   FuncTransMode::Pointer);
-      if (Val->getType() != Ty)
-        Val = BM->addUnaryInst(OpBitcast, Ty, Val, BB);
-      IncomingPairs.push_back(Val);
+      IncomingPairs.push_back(transValue(Phi->getIncomingValue(I), BB, true,
+                                         FuncTransMode::Pointer));
       IncomingPairs.push_back(transValue(Phi->getIncomingBlock(I), nullptr));
     }
-    return mapValue(V, BM->addPhiInst(Ty, IncomingPairs, BB));
+    return mapValue(V,
+                    BM->addPhiInst(transScavengedType(Phi), IncomingPairs, BB));
   }
 
   if (auto *Ext = dyn_cast<ExtractValueInst>(V)) {
@@ -2769,7 +2737,7 @@ void checkIsGlobalVar(SPIRVEntry *E, Decoration Dec) {
   E->getErrorLog().checkError(E->isVariable(), SPIRVEC_InvalidModule, ErrStr);
 
   auto AddrSpace = SPIRSPIRVAddrSpaceMap::rmap(
-      static_cast<SPIRVVariableBase *>(E)->getStorageClass());
+      static_cast<SPIRVVariable *>(E)->getStorageClass());
   ErrStr += " in a global (module) scope";
   E->getErrorLog().checkError(AddrSpace == SPIRAS_Global, SPIRVEC_InvalidModule,
                               ErrStr);
@@ -2917,11 +2885,10 @@ static void transMetadataDecorations(Metadata *MD, SPIRVValue *Target) {
     case spv::internal::DecorationInitModeINTEL:
     case DecorationInitModeINTEL: {
       checkIsGlobalVar(Target, DecoKind);
-      ErrLog.checkError(
-          static_cast<SPIRVVariableBase *>(Target)->getInitializer(),
-          SPIRVEC_InvalidLlvmModule,
-          "InitModeINTEL only be applied to a global (module "
-          "scope) variable which has an Initializer operand");
+      ErrLog.checkError(static_cast<SPIRVVariable *>(Target)->getInitializer(),
+                        SPIRVEC_InvalidLlvmModule,
+                        "InitModeINTEL only be applied to a global (module "
+                        "scope) variable which has an Initializer operand");
 
       ErrLog.checkError(NumOperands == 2, SPIRVEC_InvalidLlvmModule,
                         "InitModeINTEL requires exactly 1 extra operand");
@@ -4163,18 +4130,14 @@ SPIRVValue *LLVMToSPIRVBase::transIntrinsicInst(IntrinsicInst *II,
     SPIRVType *FTy = transType(II->getType()->getStructElementType(0));
     SPIRVTypePointer *ITy = static_cast<SPIRVTypePointer *>(transPointerType(
         II->getType()->getStructElementType(1), SPIRAS_Private));
-    if (!ITy->isTypeUntypedPointerKHR()) {
-      unsigned BitWidth = ITy->getElementType()->getBitWidth();
-      BM->getErrorLog().checkError(BitWidth == 32, SPIRVEC_InvalidBitWidth,
-                                   std::to_string(BitWidth));
-    }
+
+    unsigned BitWidth = ITy->getElementType()->getBitWidth();
+    BM->getErrorLog().checkError(BitWidth == 32, SPIRVEC_InvalidBitWidth,
+                                 std::to_string(BitWidth));
+
     SPIRVValue *IntVal =
-        BM->addVariable(ITy,
-                        ITy->isTypeUntypedPointerKHR()
-                            ? transType(II->getType()->getStructElementType(1))
-                            : nullptr,
-                        false, spv::internal::LinkageTypeInternal, nullptr, "",
-                        ITy->getStorageClass(), BB);
+        BM->addVariable(ITy, false, spv::internal::LinkageTypeInternal, nullptr,
+                        "", ITy->getStorageClass(), BB);
 
     std::vector<SPIRVValue *> Ops{transValue(II->getArgOperand(0), BB), IntVal};
 
@@ -4596,7 +4559,7 @@ SPIRVValue *LLVMToSPIRVBase::transIntrinsicInst(IntrinsicInst *II,
       Init = BM->addCompositeConstant(CompositeTy, Elts);
     }
     SPIRVType *VarTy = transPointerType(AT, SPIRV::SPIRAS_Constant);
-    SPIRVValue *Var = BM->addVariable(VarTy, nullptr, /*isConstant*/ true,
+    SPIRVValue *Var = BM->addVariable(VarTy, /*isConstant*/ true,
                                       spv::internal::LinkageTypeInternal, Init,
                                       "", StorageClassUniformConstant, nullptr);
     SPIRVType *SourceTy =
@@ -6708,12 +6671,9 @@ LLVMToSPIRVBase::transBuiltinToInstWithoutDecoration(Op OC, CallInst *CI,
           assert((Pointee == Args[I] || !isa<Function>(Pointee)) &&
                  "Illegal use of a function pointer type");
         }
-        if (!SPI->isOperandLiteral(I)) {
-          SPIRVValue *Val = transValue(Args[I], BB);
-          SPArgs.push_back(Val->getId());
-        } else {
-          SPArgs.push_back(cast<ConstantInt>(Args[I])->getZExtValue());
-        }
+        SPArgs.push_back(SPI->isOperandLiteral(I)
+                             ? cast<ConstantInt>(Args[I])->getZExtValue()
+                             : transValue(Args[I], BB)->getId());
       }
       BM->addInstTemplate(SPI, SPArgs, BB, SPRetTy);
       if (!SPRetTy || !SPRetTy->isTypeStruct())
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
deleted file mode 100644
index dfded4c3b7216..0000000000000
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-//===-------------------- work_group_memory.hpp ---------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <type_traits>
-
-namespace sycl {
-inline namespace _V1 {
-namespace detail {
-template <typename T> struct is_unbounded_array : std::false_type {};
-
-template <typename T> struct is_unbounded_array<T[]> : std::true_type {};
-
-template <typename T>
-inline constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
-
-class work_group_memory_impl {
-public:
-  work_group_memory_impl() : buffer_size{0} {}
-  work_group_memory_impl(const work_group_memory_impl &rhs) = default;
-  work_group_memory_impl &
-  operator=(const work_group_memory_impl &rhs) = default;
-  work_group_memory_impl(size_t buffer_size)
-      : buffer_size{buffer_size} {}
-  private:
-  size_t buffer_size;
-  friend class sycl::handler;
-};
-
-} // namespace detail
-
-namespace ext::oneapi::experimental {
-template <typename DataT, typename PropertyListT = empty_properties_t>
-class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
-    : sycl::detail::work_group_memory_impl {
-public:
-  using value_type = std::remove_all_extents_t<DataT>;
-
-private:
-  using decoratedPtr = typename sycl::detail::DecoratedType<
-      value_type, access::address_space::local_space>::type *;
-
-public:
-  work_group_memory() = default;
-  work_group_memory(const work_group_memory &rhs) = default;
-  work_group_memory &operator=(const work_group_memory &rhs) = default;
-  template <typename T = DataT,
-            typename = std::enable_if_t<!sycl::detail::is_unbounded_array_v<T>>>
-  work_group_memory(handler &)
-      : sycl::detail::work_group_memory_impl(
-                                             sizeof(DataT)) {}
-  template <typename T = DataT,
-            typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
-  work_group_memory(size_t num, handler &)
-      : sycl::detail::work_group_memory_impl(
-            num * sizeof(std::remove_extent_t<DataT>)) {}
-  template <access::decorated IsDecorated = access::decorated::no>
-  multi_ptr<value_type, access::address_space::local_space, IsDecorated>
-  get_multi_ptr() const {
-    return sycl::address_space_cast<access::address_space::local_space,
-                                    IsDecorated, value_type>(ptr);
-  }
-  DataT *operator&() const { return reinterpret_cast<DataT *>(ptr); }
-  operator DataT &() const { return *(this->operator&()); }
-  template <typename T = DataT,
-            typename = std::enable_if_t<!std::is_array_v<T>>>
-  const work_group_memory &operator=(const DataT &value) const {
-    *ptr = value;
-    return *this;
-  }
-#ifdef __SYCL_DEVICE_ONLY__
-  void __init(decoratedPtr ptr) { this->ptr = ptr; }
-#endif
-private:
-  decoratedPtr ptr;
-};
-} // namespace ext::oneapi::experimental
-} // namespace _V1
-} // namespace sycl

From 396169f08d74b26c70c451b3b2e5dbb21242af7d Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Thu, 10 Oct 2024 21:03:24 +0200
Subject: [PATCH 053/107] Revert SPIRV translator changes

---
 clang/lib/Sema/SemaSYCL.cpp                   | 7007 +++++++++++++++++
 .../oneapi/experimental/work_group_memory.hpp |   85 +
 2 files changed, 7092 insertions(+)
 create mode 100644 clang/lib/Sema/SemaSYCL.cpp
 create mode 100644 sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
new file mode 100644
index 0000000000000..d8925669b1ae3
--- /dev/null
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -0,0 +1,7007 @@
+//===- SemaSYCL.cpp - Semantic Analysis for SYCL constructs ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// This implements Semantic Analysis for SYCL constructs.
+//===----------------------------------------------------------------------===//
+
+#include "clang/Sema/SemaSYCL.h"
+#include "TreeTransform.h"
+#include "clang/AST/AST.h"
+#include "clang/AST/Mangle.h"
+#include "clang/AST/QualTypeNames.h"
+#include "clang/AST/RecordLayout.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/TemplateArgumentVisitor.h"
+#include "clang/AST/TypeOrdering.h"
+#include "clang/AST/TypeVisitor.h"
+#include "clang/Analysis/CallGraph.h"
+#include "clang/Basic/Attributes.h"
+#include "clang/Basic/Builtins.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/Version.h"
+#include "clang/Sema/Attr.h"
+#include "clang/Sema/Initialization.h"
+#include "clang/Sema/ParsedAttr.h"
+#include "clang/Sema/Sema.h"
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <array>
+#include <functional>
+#include <initializer_list>
+
+using namespace clang;
+using namespace std::placeholders;
+
+using KernelParamKind = SYCLIntegrationHeader::kernel_param_kind_t;
+
+enum target {
+  global_buffer = 2014,
+  constant_buffer,
+  local,
+  image,
+  host_buffer,
+  host_image,
+  image_array
+};
+
+using ParamDesc = std::tuple<QualType, IdentifierInfo *, TypeSourceInfo *>;
+
+enum KernelInvocationKind {
+  InvokeUnknown,
+  InvokeSingleTask,
+  InvokeParallelFor,
+  InvokeParallelForWorkGroup
+};
+
+static constexpr llvm::StringLiteral InitMethodName = "__init";
+static constexpr llvm::StringLiteral InitESIMDMethodName = "__init_esimd";
+static constexpr llvm::StringLiteral InitSpecConstantsBuffer =
+    "__init_specialization_constants_buffer";
+static constexpr llvm::StringLiteral FinalizeMethodName = "__finalize";
+static constexpr llvm::StringLiteral LibstdcxxFailedAssertion =
+    "__failed_assertion";
+constexpr unsigned MaxKernelArgsSize = 2048;
+
+bool SemaSYCL::isSyclType(QualType Ty, SYCLTypeAttr::SYCLType TypeName) {
+  const auto *RD = Ty->getAsCXXRecordDecl();
+  if (!RD)
+    return false;
+
+  if (const auto *Attr = RD->getAttr<SYCLTypeAttr>())
+    return Attr->getType() == TypeName;
+
+  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
+    if (CXXRecordDecl *TemplateDecl =
+            CTSD->getSpecializedTemplate()->getTemplatedDecl())
+      if (const auto *Attr = TemplateDecl->getAttr<SYCLTypeAttr>())
+        return Attr->getType() == TypeName;
+
+  return false;
+}
+
+static bool isSyclAccessorType(QualType Ty) {
+  return SemaSYCL::isSyclType(Ty, SYCLTypeAttr::accessor) ||
+         SemaSYCL::isSyclType(Ty, SYCLTypeAttr::local_accessor);
+}
+
+// FIXME: Accessor property lists should be modified to use compile-time
+// properties. Once implemented, this function (and possibly all/most code
+// in SemaSYCL.cpp handling no_alias and buffer_location property) can be
+// removed.
+static bool isAccessorPropertyType(QualType Ty,
+                                   SYCLTypeAttr::SYCLType TypeName) {
+  if (const auto *RD = Ty->getAsCXXRecordDecl())
+    if (const auto *Parent = dyn_cast<CXXRecordDecl>(RD->getParent()))
+      if (const auto *Attr = Parent->getAttr<SYCLTypeAttr>())
+        return Attr->getType() == TypeName;
+
+  return false;
+}
+
+static bool isSyclSpecialType(QualType Ty, SemaSYCL &S) {
+  return S.isTypeDecoratedWithDeclAttribute<SYCLSpecialClassAttr>(Ty);
+}
+
+ExprResult SemaSYCL::ActOnSYCLBuiltinNumFieldsExpr(ParsedType PT) {
+  TypeSourceInfo *TInfo = nullptr;
+  QualType QT = Sema::GetTypeFromParser(PT, &TInfo);
+  assert(TInfo && "couldn't get type info from a type from the parser?");
+  SourceLocation TypeLoc = TInfo->getTypeLoc().getBeginLoc();
+
+  return BuildSYCLBuiltinNumFieldsExpr(TypeLoc, QT);
+}
+
+ExprResult SemaSYCL::BuildSYCLBuiltinNumFieldsExpr(SourceLocation Loc,
+                                                   QualType SourceTy) {
+  if (!SourceTy->isDependentType()) {
+    if (SemaRef.RequireCompleteType(
+            Loc, SourceTy, diag::err_sycl_type_trait_requires_complete_type,
+            /*__builtin_num_fields*/ 0))
+      return ExprError();
+
+    if (!SourceTy->isRecordType()) {
+      Diag(Loc, diag::err_sycl_type_trait_requires_record_type)
+          << /*__builtin_num_fields*/ 0;
+      return ExprError();
+    }
+  }
+  return new (getASTContext())
+      SYCLBuiltinNumFieldsExpr(Loc, SourceTy, getASTContext().getSizeType());
+}
+
+ExprResult SemaSYCL::ActOnSYCLBuiltinFieldTypeExpr(ParsedType PT, Expr *Idx) {
+  TypeSourceInfo *TInfo = nullptr;
+  QualType QT = Sema::GetTypeFromParser(PT, &TInfo);
+  assert(TInfo && "couldn't get type info from a type from the parser?");
+  SourceLocation TypeLoc = TInfo->getTypeLoc().getBeginLoc();
+
+  return BuildSYCLBuiltinFieldTypeExpr(TypeLoc, QT, Idx);
+}
+
+ExprResult SemaSYCL::BuildSYCLBuiltinFieldTypeExpr(SourceLocation Loc,
+                                                   QualType SourceTy,
+                                                   Expr *Idx) {
+  // If the expression appears in an evaluated context, we want to give an
+  // error so that users don't attempt to use the value of this expression.
+  if (!SemaRef.isUnevaluatedContext()) {
+    Diag(Loc, diag::err_sycl_builtin_type_trait_evaluated)
+        << /*__builtin_field_type*/ 0;
+    return ExprError();
+  }
+
+  // We may not be able to calculate the field type (the source type may be a
+  // dependent type), so use the source type as a basic fallback. This will
+  // ensure that the AST node will have a dependent type that gets resolved
+  // later to the real type.
+  QualType FieldTy = SourceTy;
+  ExprValueKind ValueKind = VK_PRValue;
+  if (!SourceTy->isDependentType()) {
+    if (SemaRef.RequireCompleteType(
+            Loc, SourceTy, diag::err_sycl_type_trait_requires_complete_type,
+            /*__builtin_field_type*/ 1))
+      return ExprError();
+
+    if (!SourceTy->isRecordType()) {
+      Diag(Loc, diag::err_sycl_type_trait_requires_record_type)
+          << /*__builtin_field_type*/ 1;
+      return ExprError();
+    }
+
+    if (!Idx->isValueDependent()) {
+      std::optional<llvm::APSInt> IdxVal =
+          Idx->getIntegerConstantExpr(getASTContext());
+      if (IdxVal) {
+        RecordDecl *RD = SourceTy->getAsRecordDecl();
+        assert(RD && "Record type but no record decl?");
+        int64_t Index = IdxVal->getExtValue();
+
+        if (Index < 0) {
+          Diag(Idx->getExprLoc(),
+               diag::err_sycl_type_trait_requires_nonnegative_index)
+              << /*fields*/ 0;
+          return ExprError();
+        }
+
+        // Ensure that the index is within range.
+        int64_t NumFields = std::distance(RD->field_begin(), RD->field_end());
+        if (Index >= NumFields) {
+          Diag(Idx->getExprLoc(),
+               diag::err_sycl_builtin_type_trait_index_out_of_range)
+              << toString(*IdxVal, 10) << SourceTy << /*fields*/ 0;
+          return ExprError();
+        }
+        const FieldDecl *FD = *std::next(RD->field_begin(), Index);
+        FieldTy = FD->getType();
+
+        // If the field type was a reference type, adjust it now.
+        if (FieldTy->isLValueReferenceType()) {
+          ValueKind = VK_LValue;
+          FieldTy = FieldTy.getNonReferenceType();
+        } else if (FieldTy->isRValueReferenceType()) {
+          ValueKind = VK_XValue;
+          FieldTy = FieldTy.getNonReferenceType();
+        }
+      }
+    }
+  }
+  return new (getASTContext())
+      SYCLBuiltinFieldTypeExpr(Loc, SourceTy, Idx, FieldTy, ValueKind);
+}
+
+ExprResult SemaSYCL::ActOnSYCLBuiltinNumBasesExpr(ParsedType PT) {
+  TypeSourceInfo *TInfo = nullptr;
+  QualType QT = Sema::GetTypeFromParser(PT, &TInfo);
+  assert(TInfo && "couldn't get type info from a type from the parser?");
+  SourceLocation TypeLoc = TInfo->getTypeLoc().getBeginLoc();
+
+  return BuildSYCLBuiltinNumBasesExpr(TypeLoc, QT);
+}
+
+ExprResult SemaSYCL::BuildSYCLBuiltinNumBasesExpr(SourceLocation Loc,
+                                                  QualType SourceTy) {
+  if (!SourceTy->isDependentType()) {
+    if (SemaRef.RequireCompleteType(
+            Loc, SourceTy, diag::err_sycl_type_trait_requires_complete_type,
+            /*__builtin_num_bases*/ 2))
+      return ExprError();
+
+    if (!SourceTy->isRecordType()) {
+      Diag(Loc, diag::err_sycl_type_trait_requires_record_type)
+          << /*__builtin_num_bases*/ 2;
+      return ExprError();
+    }
+  }
+  return new (getASTContext())
+      SYCLBuiltinNumBasesExpr(Loc, SourceTy, getASTContext().getSizeType());
+}
+
+ExprResult SemaSYCL::ActOnSYCLBuiltinBaseTypeExpr(ParsedType PT, Expr *Idx) {
+  TypeSourceInfo *TInfo = nullptr;
+  QualType QT = SemaRef.GetTypeFromParser(PT, &TInfo);
+  assert(TInfo && "couldn't get type info from a type from the parser?");
+  SourceLocation TypeLoc = TInfo->getTypeLoc().getBeginLoc();
+
+  return BuildSYCLBuiltinBaseTypeExpr(TypeLoc, QT, Idx);
+}
+
+ExprResult SemaSYCL::BuildSYCLBuiltinBaseTypeExpr(SourceLocation Loc,
+                                                  QualType SourceTy,
+                                                  Expr *Idx) {
+  // If the expression appears in an evaluated context, we want to give an
+  // error so that users don't attempt to use the value of this expression.
+  if (!SemaRef.isUnevaluatedContext()) {
+    Diag(Loc, diag::err_sycl_builtin_type_trait_evaluated)
+        << /*__builtin_base_type*/ 1;
+    return ExprError();
+  }
+
+  // We may not be able to calculate the base type (the source type may be a
+  // dependent type), so use the source type as a basic fallback. This will
+  // ensure that the AST node will have a dependent type that gets resolved
+  // later to the real type.
+  QualType BaseTy = SourceTy;
+  if (!SourceTy->isDependentType()) {
+    if (SemaRef.RequireCompleteType(
+            Loc, SourceTy, diag::err_sycl_type_trait_requires_complete_type,
+            /*__builtin_base_type*/ 3))
+      return ExprError();
+
+    if (!SourceTy->isRecordType()) {
+      Diag(Loc, diag::err_sycl_type_trait_requires_record_type)
+          << /*__builtin_base_type*/ 3;
+      return ExprError();
+    }
+
+    if (!Idx->isValueDependent()) {
+      std::optional<llvm::APSInt> IdxVal =
+          Idx->getIntegerConstantExpr(getASTContext());
+      if (IdxVal) {
+        CXXRecordDecl *RD = SourceTy->getAsCXXRecordDecl();
+        assert(RD && "Record type but no record decl?");
+        int64_t Index = IdxVal->getExtValue();
+
+        if (Index < 0) {
+          Diag(Idx->getExprLoc(),
+               diag::err_sycl_type_trait_requires_nonnegative_index)
+              << /*bases*/ 1;
+          return ExprError();
+        }
+
+        // Ensure that the index is within range.
+        if (Index >= RD->getNumBases()) {
+          Diag(Idx->getExprLoc(),
+               diag::err_sycl_builtin_type_trait_index_out_of_range)
+              << toString(*IdxVal, 10) << SourceTy << /*bases*/ 1;
+          return ExprError();
+        }
+
+        const CXXBaseSpecifier &Spec = *std::next(RD->bases_begin(), Index);
+        BaseTy = Spec.getType();
+      }
+    }
+  }
+  return new (getASTContext())
+      SYCLBuiltinBaseTypeExpr(Loc, SourceTy, Idx, BaseTy);
+}
+
+/// Returns true if the target requires a new type.
+/// This happens if a pointer to generic cannot be passed
+static bool targetRequiresNewType(ASTContext &Context) {
+  llvm::Triple T = Context.getTargetInfo().getTriple();
+  return !T.isNVPTX();
+}
+
+// This information is from Section 4.13 of the SYCL spec
+// https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf
+// This function returns false if the math lib function
+// corresponding to the input builtin is not supported
+// for SYCL
+static bool IsSyclMathFunc(unsigned BuiltinID) {
+  switch (BuiltinID) {
+  case Builtin::BIlround:
+  case Builtin::BI__builtin_lround:
+  case Builtin::BIceill:
+  case Builtin::BI__builtin_ceill:
+  case Builtin::BIcopysignl:
+  case Builtin::BI__builtin_copysignl:
+  case Builtin::BIcosl:
+  case Builtin::BI__builtin_cosl:
+  case Builtin::BIexpl:
+  case Builtin::BI__builtin_expl:
+  case Builtin::BIexp2l:
+  case Builtin::BI__builtin_exp2l:
+  case Builtin::BIfabsl:
+  case Builtin::BI__builtin_fabsl:
+  case Builtin::BIfloorl:
+  case Builtin::BI__builtin_floorl:
+  case Builtin::BIfmal:
+  case Builtin::BI__builtin_fmal:
+  case Builtin::BIfmaxl:
+  case Builtin::BI__builtin_fmaxl:
+  case Builtin::BIfminl:
+  case Builtin::BI__builtin_fminl:
+  case Builtin::BIfmodl:
+  case Builtin::BI__builtin_fmodl:
+  case Builtin::BIlogl:
+  case Builtin::BI__builtin_logl:
+  case Builtin::BIlog10l:
+  case Builtin::BI__builtin_log10l:
+  case Builtin::BIlog2l:
+  case Builtin::BI__builtin_log2l:
+  case Builtin::BIpowl:
+  case Builtin::BI__builtin_powl:
+  case Builtin::BIrintl:
+  case Builtin::BI__builtin_rintl:
+  case Builtin::BIroundl:
+  case Builtin::BI__builtin_roundl:
+  case Builtin::BIsinl:
+  case Builtin::BI__builtin_sinl:
+  case Builtin::BIsqrtl:
+  case Builtin::BI__builtin_sqrtl:
+  case Builtin::BItruncl:
+  case Builtin::BI__builtin_truncl:
+  case Builtin::BIlroundl:
+  case Builtin::BI__builtin_lroundl:
+  case Builtin::BIlroundf:
+  case Builtin::BI__builtin_lroundf:
+    return false;
+  default:
+    break;
+  }
+  return true;
+}
+
+bool SemaSYCL::isDeclAllowedInSYCLDeviceCode(const Decl *D) {
+  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+    const IdentifierInfo *II = FD->getIdentifier();
+
+    // Allow __builtin_assume_aligned and __builtin_printf to be called from
+    // within device code.
+    if (FD->getBuiltinID() &&
+        (FD->getBuiltinID() == Builtin::BI__builtin_assume_aligned ||
+         FD->getBuiltinID() == Builtin::BI__builtin_printf))
+      return true;
+
+    const DeclContext *DC = FD->getDeclContext();
+    if (II && II->isStr("__spirv_ocl_printf") &&
+        !FD->isDefined() &&
+        FD->getLanguageLinkage() == CXXLanguageLinkage &&
+        DC->getEnclosingNamespaceContext()->isTranslationUnit())
+      return true;
+  }
+  return false;
+}
+
+SemaSYCL::SemaSYCL(Sema &S)
+    : SemaBase(S), SyclIntHeader(nullptr), SyclIntFooter(nullptr) {}
+
+static bool isZeroSizedArray(SemaSYCL &S, QualType Ty) {
+  if (const auto *CAT = S.getASTContext().getAsConstantArrayType(Ty))
+    return CAT->isZeroSize();
+  return false;
+}
+
+static void checkSYCLType(SemaSYCL &S, QualType Ty, SourceRange Loc,
+                          llvm::DenseSet<QualType> Visited,
+                          SourceRange UsedAtLoc = SourceRange()) {
+  // Not all variable types are supported inside SYCL kernels,
+  // for example the quad type __float128 will cause errors in the
+  // SPIR-V translation phase.
+  // Here we check any potentially unsupported declaration and issue
+  // a deferred diagnostic, which will be emitted iff the declaration
+  // is discovered to reside in kernel code.
+  // The optional UsedAtLoc param is used when the SYCL usage is at a
+  // different location than the variable declaration and we need to
+  // inform the user of both, e.g. struct member usage vs declaration.
+
+  bool Emitting = false;
+
+  //--- check types ---
+
+  // zero length arrays
+  if (isZeroSizedArray(S, Ty)) {
+    S.DiagIfDeviceCode(Loc.getBegin(), diag::err_typecheck_zero_array_size)
+        << 1;
+    Emitting = true;
+  }
+
+  // variable length arrays
+  if (Ty->isVariableArrayType()) {
+    S.DiagIfDeviceCode(Loc.getBegin(), diag::err_vla_unsupported) << 0;
+    Emitting = true;
+  }
+
+  // Sub-reference array or pointer, then proceed with that type.
+  while (Ty->isAnyPointerType() || Ty->isArrayType())
+    Ty = QualType{Ty->getPointeeOrArrayElementType(), 0};
+
+  // __int128, __int128_t, __uint128_t, long double, __float128
+  if (Ty->isSpecificBuiltinType(BuiltinType::Int128) ||
+      Ty->isSpecificBuiltinType(BuiltinType::UInt128) ||
+      Ty->isSpecificBuiltinType(BuiltinType::LongDouble) ||
+      Ty->isSpecificBuiltinType(BuiltinType::BFloat16) ||
+      (Ty->isSpecificBuiltinType(BuiltinType::Float128) &&
+       !S.getASTContext().getTargetInfo().hasFloat128Type())) {
+    S.DiagIfDeviceCode(Loc.getBegin(), diag::err_type_unsupported)
+        << Ty.getUnqualifiedType().getCanonicalType();
+    Emitting = true;
+  }
+
+  if (Emitting && UsedAtLoc.isValid())
+    S.DiagIfDeviceCode(UsedAtLoc.getBegin(), diag::note_used_here);
+
+  //--- now recurse ---
+  // Pointers complicate recursion. Add this type to Visited.
+  // If already there, bail out.
+  if (!Visited.insert(Ty).second)
+    return;
+
+  if (const auto *ATy = dyn_cast<AttributedType>(Ty))
+    return checkSYCLType(S, ATy->getModifiedType(), Loc, Visited);
+
+  if (const auto *RD = Ty->getAsRecordDecl()) {
+    for (const auto &Field : RD->fields())
+      checkSYCLType(S, Field->getType(), Field->getSourceRange(), Visited, Loc);
+  } else if (const auto *FPTy = dyn_cast<FunctionProtoType>(Ty)) {
+    for (const auto &ParamTy : FPTy->param_types())
+      checkSYCLType(S, ParamTy, Loc, Visited);
+    checkSYCLType(S, FPTy->getReturnType(), Loc, Visited);
+  }
+}
+
+void SemaSYCL::checkSYCLDeviceVarDecl(VarDecl *Var) {
+  assert(getLangOpts().SYCLIsDevice &&
+         "Should only be called during SYCL compilation");
+  QualType Ty = Var->getType();
+  SourceRange Loc = Var->getLocation();
+  llvm::DenseSet<QualType> Visited;
+
+  checkSYCLType(*this, Ty, Loc, Visited);
+}
+
+enum NotForwardDeclarableReason {
+  UnscopedEnum,
+  StdNamespace,
+  UnnamedTag,
+  NotAtNamespaceScope,
+  None
+};
+
+// This is a helper function which is used to check if a class declaration is:
+//   * declared within namespace 'std' (at any level)
+//     e.g., namespace std { namespace literals { class Whatever; } }
+//     h.single_task<std::literals::Whatever>([]() {});
+//   * declared within a function
+//     e.g., void foo() { struct S { int i; };
+//     h.single_task<S>([]() {}); }
+//   * declared within another tag
+//     e.g., struct S { struct T { int i } t; };
+//     h.single_task<S::T>([]() {});
+//  User for kernel name types and class/struct types used in free function
+//  kernel arguments.
+static NotForwardDeclarableReason
+isForwardDeclarable(const NamedDecl *DeclToCheck, SemaSYCL &S,
+                    bool DiagForFreeFunction = false) {
+  if (const auto *ED = dyn_cast<EnumDecl>(DeclToCheck);
+      ED && !ED->isScoped() && !ED->isFixed())
+    return NotForwardDeclarableReason::UnscopedEnum;
+
+  const DeclContext *DeclCtx = DeclToCheck->getDeclContext();
+  if (DeclCtx) {
+    while (!DeclCtx->isTranslationUnit() &&
+           (isa<NamespaceDecl>(DeclCtx) || isa<LinkageSpecDecl>(DeclCtx))) {
+      const auto *NSDecl = dyn_cast<NamespaceDecl>(DeclCtx);
+      // We don't report free function kernel parameter case because the
+      // restriction for the type used there to be forward declarable comes from
+      // the need to forward declare it in the integration header. We're safe
+      // to do so because the integration header is an implemention detail and
+      // is generated by the compiler.
+      // We do diagnose case with kernel name type since the spec requires us to
+      // do so.
+      if (!DiagForFreeFunction && NSDecl && NSDecl->isStdNamespace())
+        return NotForwardDeclarableReason::StdNamespace;
+      DeclCtx = DeclCtx->getParent();
+    }
+  }
+
+  // Check if the we've met a Tag declaration local to a non-namespace scope
+  // (i.e. Inside a function or within another Tag etc).
+  if (const auto *Tag = dyn_cast<TagDecl>(DeclToCheck)) {
+    if (Tag->getIdentifier() == nullptr)
+      return NotForwardDeclarableReason::UnnamedTag;
+    if (!DeclCtx->isTranslationUnit()) {
+      // Diagnose used types without complete definition i.e.
+      //   int main() {
+      //     class KernelName1;
+      //     parallel_for<class KernelName1>(..);
+      //   }
+      // For kernel name type This case can only be diagnosed during host
+      // compilation because the integration header is required to distinguish
+      // between the invalid code (above) and the following valid code:
+      //   int main() {
+      //     parallel_for<class KernelName2>(..);
+      //   }
+      // The device compiler forward declares both KernelName1 and
+      // KernelName2 in the integration header as ::KernelName1 and
+      // ::KernelName2. The problem with the former case is the additional
+      // declaration 'class KernelName1' in non-global scope. Lookup in this
+      // case will resolve to ::main::KernelName1 (instead of
+      // ::KernelName1). Since this is not visible to runtime code that
+      // submits kernels, this is invalid.
+      if (Tag->isCompleteDefinition() ||
+          S.getLangOpts().SYCLEnableIntHeaderDiags || DiagForFreeFunction)
+        return NotForwardDeclarableReason::NotAtNamespaceScope;
+    }
+  }
+
+  return NotForwardDeclarableReason::None;
+}
+
+// Tests whether given function is a lambda function or '()' operator used as
+// SYCL kernel body function (e.g. in parallel_for).
+// NOTE: This is incomplete implemenation. See TODO in the FE TODO list for the
+// ESIMD extension.
+static bool isSYCLKernelBodyFunction(FunctionDecl *FD) {
+  return FD->getOverloadedOperator() == OO_Call;
+}
+
+static bool isSYCLUndefinedAllowed(const FunctionDecl *Callee,
+                                   const SourceManager &SrcMgr) {
+  if (!Callee)
+    return false;
+
+  // The check below requires declaration name, make sure we have it.
+  if (!Callee->getIdentifier())
+    return false;
+
+  // libstdc++-11 introduced an undefined function "void __failed_assertion()"
+  // which may lead to SemaSYCL check failure. However, this undefined function
+  // is used to trigger some compilation error when the check fails at compile
+  // time and will be ignored when the check succeeds. We allow calls to this
+  // function to support some important std functions in SYCL device.
+  return (Callee->getName() == LibstdcxxFailedAssertion) &&
+         Callee->getNumParams() == 0 && Callee->getReturnType()->isVoidType() &&
+         SrcMgr.isInSystemHeader(Callee->getLocation());
+}
+
+// Helper function to report conflicting function attributes.
+// F - the function, A1 - function attribute, A2 - the attribute it conflicts
+// with.
+static void reportConflictingAttrs(SemaSYCL &S, FunctionDecl *F, const Attr *A1,
+                                   const Attr *A2) {
+  S.Diag(F->getLocation(), diag::err_conflicting_sycl_kernel_attributes);
+  S.Diag(A1->getLocation(), diag::note_conflicting_attribute);
+  S.Diag(A2->getLocation(), diag::note_conflicting_attribute);
+  F->setInvalidDecl();
+}
+
+/// Returns the signed constant integer value represented by given expression
+static int64_t getIntExprValue(const Expr *E, ASTContext &Ctx) {
+  return E->getIntegerConstantExpr(Ctx)->getSExtValue();
+}
+
+// Collect function attributes related to SYCL.
+static void collectSYCLAttributes(SemaSYCL &S, FunctionDecl *FD,
+                                  llvm::SmallVectorImpl<Attr *> &Attrs,
+                                  bool DirectlyCalled) {
+  if (!FD->hasAttrs())
+    return;
+
+  // In SYCL 2020 mode, the attributes aren't propagated from the function they
+  // are applied on to the kernel which calls the function.
+  if (DirectlyCalled) {
+    llvm::copy_if(FD->getAttrs(), std::back_inserter(Attrs), [](Attr *A) {
+      // FIXME: Make this list self-adapt as new SYCL attributes are added.
+      return isa<IntelReqdSubGroupSizeAttr, IntelNamedSubGroupSizeAttr,
+                 SYCLReqdWorkGroupSizeAttr, SYCLWorkGroupSizeHintAttr,
+                 SYCLIntelKernelArgsRestrictAttr, SYCLIntelNumSimdWorkItemsAttr,
+                 SYCLIntelSchedulerTargetFmaxMhzAttr,
+                 SYCLIntelMaxWorkGroupSizeAttr, SYCLIntelMaxGlobalWorkDimAttr,
+                 SYCLIntelMinWorkGroupsPerComputeUnitAttr,
+                 SYCLIntelMaxWorkGroupsPerMultiprocessorAttr,
+                 SYCLIntelNoGlobalWorkOffsetAttr, SYCLSimdAttr,
+                 SYCLIntelLoopFuseAttr, SYCLIntelMaxConcurrencyAttr,
+                 SYCLIntelDisableLoopPipeliningAttr,
+                 SYCLIntelInitiationIntervalAttr,
+                 SYCLIntelUseStallEnableClustersAttr, SYCLDeviceHasAttr,
+                 SYCLAddIRAttributesFunctionAttr>(A);
+    });
+  }
+}
+
+class DiagDeviceFunction : public RecursiveASTVisitor<DiagDeviceFunction> {
+  SemaSYCL &SemaSYCLRef;
+  const llvm::SmallPtrSetImpl<const FunctionDecl *> &RecursiveFuncs;
+
+public:
+  DiagDeviceFunction(
+      SemaSYCL &S,
+      const llvm::SmallPtrSetImpl<const FunctionDecl *> &RecursiveFuncs)
+      : RecursiveASTVisitor(), SemaSYCLRef(S), RecursiveFuncs(RecursiveFuncs) {}
+
+  void CheckBody(Stmt *ToBeDiagnosed) { TraverseStmt(ToBeDiagnosed); }
+
+  bool VisitCallExpr(CallExpr *e) {
+    if (FunctionDecl *Callee = e->getDirectCallee()) {
+      Callee = Callee->getCanonicalDecl();
+      assert(Callee && "Device function canonical decl must be available");
+
+      // Remember that all SYCL kernel functions have deferred
+      // instantiation as template functions. It means that
+      // all functions used by kernel have already been parsed and have
+      // definitions.
+      if (RecursiveFuncs.count(Callee)) {
+        SemaSYCLRef.Diag(e->getExprLoc(), diag::err_sycl_restrict)
+            << SemaSYCL::KernelCallRecursiveFunction;
+        SemaSYCLRef.Diag(Callee->getSourceRange().getBegin(),
+                         diag::note_sycl_recursive_function_declared_here)
+            << SemaSYCL::KernelCallRecursiveFunction;
+      }
+
+      // Specifically check if the math library function corresponding to this
+      // builtin is supported for SYCL
+      unsigned BuiltinID = Callee->getBuiltinID();
+      if (BuiltinID && !IsSyclMathFunc(BuiltinID)) {
+        StringRef Name =
+            SemaSYCLRef.getASTContext().BuiltinInfo.getName(BuiltinID);
+        SemaSYCLRef.Diag(e->getExprLoc(), diag::err_builtin_target_unsupported)
+            << Name << "SYCL device";
+      }
+    } else if (!SemaSYCLRef.getLangOpts().SYCLAllowFuncPtr &&
+               !e->isTypeDependent() &&
+               !isa<CXXPseudoDestructorExpr>(e->getCallee())) {
+      bool MaybeConstantExpr = false;
+      Expr *NonDirectCallee = e->getCallee();
+      if (!NonDirectCallee->isValueDependent())
+        MaybeConstantExpr =
+            NonDirectCallee->isCXX11ConstantExpr(SemaSYCLRef.getASTContext());
+      if (!MaybeConstantExpr)
+        SemaSYCLRef.Diag(e->getExprLoc(), diag::err_sycl_restrict)
+            << SemaSYCL::KernelCallFunctionPointer;
+    }
+    return true;
+  }
+
+  bool VisitCXXTypeidExpr(CXXTypeidExpr *E) {
+    SemaSYCLRef.Diag(E->getExprLoc(), diag::err_sycl_restrict)
+        << SemaSYCL::KernelRTTI;
+    return true;
+  }
+
+  bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
+    SemaSYCLRef.Diag(E->getExprLoc(), diag::err_sycl_restrict)
+        << SemaSYCL::KernelRTTI;
+    return true;
+  }
+
+  // Skip checking rules on variables initialized during constant evaluation.
+  bool TraverseVarDecl(VarDecl *VD) {
+    if (VD->isConstexpr())
+      return true;
+    return RecursiveASTVisitor::TraverseVarDecl(VD);
+  }
+
+  // Skip checking rules on template arguments, since these are constant
+  // expressions.
+  bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
+    return true;
+  }
+
+  // Skip checking the static assert, both components are required to be
+  // constant expressions.
+  bool TraverseStaticAssertDecl(StaticAssertDecl *D) { return true; }
+
+  // Make sure we skip the condition of the case, since that is a constant
+  // expression.
+  bool TraverseCaseStmt(CaseStmt *S) {
+    return TraverseStmt(S->getSubStmt());
+  }
+
+  // Skip checking the size expr, since a constant array type loc's size expr is
+  // a constant expression.
+  bool TraverseConstantArrayTypeLoc(const ConstantArrayTypeLoc &ArrLoc) {
+    return true;
+  }
+
+  bool TraverseIfStmt(IfStmt *S) {
+    if (std::optional<Stmt *> ActiveStmt =
+            S->getNondiscardedCase(SemaSYCLRef.getASTContext())) {
+      if (*ActiveStmt)
+        return TraverseStmt(*ActiveStmt);
+      return true;
+    }
+    return RecursiveASTVisitor::TraverseIfStmt(S);
+  }
+};
+
+// This type manages the list of device functions and recursive functions, as
+// well as an entry point for attribute collection, for the translation unit
+// during MarkDevices. On construction, this type makes sure that all of the
+// root-device functions, (that is, those marked with SYCL_EXTERNAL) are
+// collected.  On destruction, it manages and runs the diagnostics required.
+// When processing individual kernel/external functions, the
+// SingleDeviceFunctionTracker type updates this type.
+class DeviceFunctionTracker {
+  friend class SingleDeviceFunctionTracker;
+  CallGraph CG;
+  SemaSYCL &SemaSYCLRef;
+  // The list of functions used on the device, kept so we can diagnose on them
+  // later.
+  llvm::SmallPtrSet<FunctionDecl *, 16> DeviceFunctions;
+  llvm::SmallPtrSet<const FunctionDecl *, 16> RecursiveFunctions;
+
+  void CollectSyclExternalFuncs() {
+    for (CallGraphNode::CallRecord Record : CG.getRoot()->callees())
+      if (auto *FD = dyn_cast<FunctionDecl>(Record.Callee->getDecl()))
+        if (FD->hasBody() && FD->hasAttr<SYCLDeviceAttr>())
+          SemaSYCLRef.addSyclDeviceDecl(FD);
+  }
+
+  CallGraphNode *getNodeForKernel(FunctionDecl *Kernel) {
+    assert(CG.getNode(Kernel) && "No call graph entry for a kernel?");
+    return CG.getNode(Kernel);
+  }
+
+  void AddSingleFunction(
+      const llvm::SmallPtrSetImpl<FunctionDecl *> &DevFuncs,
+      const llvm::SmallPtrSetImpl<const FunctionDecl *> &Recursive) {
+    DeviceFunctions.insert(DevFuncs.begin(), DevFuncs.end());
+    RecursiveFunctions.insert(Recursive.begin(), Recursive.end());
+  }
+
+public:
+  DeviceFunctionTracker(SemaSYCL &S) : SemaSYCLRef(S) {
+    CG.setSkipConstantExpressions(S.getASTContext());
+    CG.addToCallGraph(S.getASTContext().getTranslationUnitDecl());
+    CollectSyclExternalFuncs();
+  }
+
+  ~DeviceFunctionTracker() {
+    DiagDeviceFunction Diagnoser{SemaSYCLRef, RecursiveFunctions};
+    for (const FunctionDecl *FD : DeviceFunctions)
+      if (const FunctionDecl *Def = FD->getDefinition())
+        Diagnoser.CheckBody(Def->getBody());
+  }
+};
+
+/// This function checks whether given DeclContext contains a topmost
+/// namespace with name "sycl".
+static bool isDeclaredInSYCLNamespace(const Decl *D) {
+  const DeclContext *DC = D->getDeclContext()->getEnclosingNamespaceContext();
+  const auto *ND = dyn_cast<NamespaceDecl>(DC);
+  // If this is not a namespace, then we are done.
+  if (!ND)
+    return false;
+
+  // While it is a namespace, find its parent scope.
+  while (const DeclContext *Parent = ND->getParent()) {
+    if (!isa<NamespaceDecl>(Parent))
+      break;
+    ND = cast<NamespaceDecl>(Parent);
+  }
+
+  return ND && ND->getName() == "sycl";
+}
+
+static bool isSYCLPrivateMemoryVar(VarDecl *VD) {
+  return SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::private_memory);
+}
+
+static void addScopeAttrToLocalVars(FunctionDecl &F) {
+  for (Decl *D : F.decls()) {
+    VarDecl *VD = dyn_cast<VarDecl>(D);
+
+    if (!VD || isa<ParmVarDecl>(VD) ||
+        VD->getStorageDuration() != StorageDuration::SD_Automatic)
+      continue;
+    // Local variables of private_memory type in the WG scope still have WI
+    // scope, all the rest - WG scope. Simple logic
+    // "if no scope than it is WG scope" won't work, because compiler may add
+    // locals not declared in user code (lambda object parameter, byval
+    // arguments) which will result in alloca w/o any attribute, so need WI
+    // scope too.
+    SYCLScopeAttr::Level L = isSYCLPrivateMemoryVar(VD)
+                                 ? SYCLScopeAttr::Level::WorkItem
+                                 : SYCLScopeAttr::Level::WorkGroup;
+    VD->addAttr(SYCLScopeAttr::CreateImplicit(F.getASTContext(), L));
+  }
+}
+
+// This type does the heavy lifting for the management of device functions,
+// recursive function detection, and attribute collection for a single
+// kernel/external function. It walks the callgraph to find all functions that
+// are called, marks the recursive-functions, and figures out the list of
+// attributes that apply to this kernel.
+//
+// Upon destruction, this type updates the DeviceFunctionTracker.
+class SingleDeviceFunctionTracker {
+  DeviceFunctionTracker &Parent;
+  FunctionDecl *SYCLKernel = nullptr;
+  FunctionDecl *KernelBody = nullptr;
+  llvm::SmallPtrSet<FunctionDecl *, 16> DeviceFunctions;
+  llvm::SmallPtrSet<const FunctionDecl *, 16> RecursiveFunctions;
+  llvm::SmallVector<Attr *> CollectedAttributes;
+
+  FunctionDecl *GetFDFromNode(CallGraphNode *Node) {
+    FunctionDecl *FD = Node->getDecl()->getAsFunction();
+    if (!FD)
+      return nullptr;
+
+    return FD->getMostRecentDecl();
+  }
+
+  void VisitCallNode(CallGraphNode *Node, FunctionDecl *CurrentDecl,
+                     llvm::SmallVectorImpl<FunctionDecl *> &CallStack) {
+    // If this isn't a function, I don't think there is anything we can do here.
+    if (!CurrentDecl)
+      return;
+
+    // Determine if this is a recursive function. If so, we're done.
+    if (llvm::is_contained(CallStack, CurrentDecl)) {
+      RecursiveFunctions.insert(CurrentDecl->getCanonicalDecl());
+      return;
+    }
+
+    // If this is a routine that is not defined and it does not have either
+    // a SYCLKernel or SYCLDevice attribute on it, add it to the set of
+    // routines potentially reachable on device. This is to diagnose such
+    // cases later in finalizeSYCLDelayedAnalysis().
+    if (!CurrentDecl->isDefined() && !CurrentDecl->hasAttr<SYCLKernelAttr>() &&
+        !CurrentDecl->hasAttr<SYCLDeviceAttr>())
+      Parent.SemaSYCLRef.addFDToReachableFromSyclDevice(CurrentDecl,
+                                                        CallStack.back());
+
+    // If this is a parallel_for_work_item that is declared in the
+    // sycl namespace, mark it with the WorkItem scope attribute.
+    // Note: Here, we assume that this is called from within a
+    // parallel_for_work_group; it is undefined to call it otherwise.
+    // We deliberately do not diagnose a violation.
+    // The following changes have also been added:
+    // 1. The function inside which the parallel_for_work_item exists is
+    //    marked with WorkGroup scope attribute, if not present already.
+    // 2. The local variables inside the function are marked with appropriate
+    //    scope.
+    if (CurrentDecl->getIdentifier() &&
+        CurrentDecl->getIdentifier()->getName() == "parallel_for_work_item" &&
+        isDeclaredInSYCLNamespace(CurrentDecl) &&
+        !CurrentDecl->hasAttr<SYCLScopeAttr>()) {
+      CurrentDecl->addAttr(SYCLScopeAttr::CreateImplicit(
+          Parent.SemaSYCLRef.getASTContext(), SYCLScopeAttr::Level::WorkItem));
+      FunctionDecl *Caller = CallStack.back();
+      if (!Caller->hasAttr<SYCLScopeAttr>()) {
+        Caller->addAttr(
+            SYCLScopeAttr::CreateImplicit(Parent.SemaSYCLRef.getASTContext(),
+                                          SYCLScopeAttr::Level::WorkGroup));
+        addScopeAttrToLocalVars(*Caller);
+      }
+    }
+
+    // We previously thought we could skip this function if we'd seen it before,
+    // but if we haven't seen it before in this call graph, we can end up
+    // missing a recursive call.  SO, we have to revisit call-graphs we've
+    // already seen, just in case it ALSO has recursion.  For example:
+    // void recurse1();
+    // void recurse2() { recurse1(); }
+    // void recurse1() { recurse2(); }
+    // void CallerInKernel() { recurse1(); recurse2(); }
+    // When checking 'recurse1', we'd have ended up 'visiting' recurse2 without
+    // realizing it was recursive, since we never went into the
+    // child-of-its-child, since THAT was recursive and exited early out of
+    // necessity.
+    // Then when we go to visit the kernel's call to recurse2, we would
+    // immediately escape not noticing it was recursive. SO, we have to do a
+    // little extra work in this case, and make sure we visit the entire call
+    // graph.
+    DeviceFunctions.insert(CurrentDecl);
+
+    // Collect attributes for functions that aren't the root kernel.
+    if (!CallStack.empty()) {
+      bool DirectlyCalled = CallStack.size() == 1;
+      collectSYCLAttributes(Parent.SemaSYCLRef, CurrentDecl,
+                            CollectedAttributes, DirectlyCalled);
+    }
+
+    // Calculate the kernel body.  Note the 'isSYCLKernelBodyFunction' only
+    // tests that it is operator(), so hopefully this doesn't get us too many
+    // false-positives.
+    if (isSYCLKernelBodyFunction(CurrentDecl)) {
+      // This is a direct callee of the kernel.
+      if (CallStack.size() == 1 &&
+          CallStack.back()->hasAttr<SYCLKernelAttr>()) {
+        assert(!KernelBody && "inconsistent call graph - only one kernel body "
+                              "function can be called");
+        KernelBody = CurrentDecl;
+      } else if (CallStack.size() == 2 && KernelBody == CallStack.back()) {
+        // To implement rounding-up of a parallel-for range the
+        // SYCL header implementation modifies the kernel call like this:
+        // auto Wrapper = [=](TransformedArgType Arg) {
+        //  if (Arg[0] >= NumWorkItems[0])
+        //    return;
+        //  Arg.set_allowed_range(NumWorkItems);
+        //  KernelFunc(Arg);
+        // };
+        //
+        // This transformation leads to a condition where a kernel body
+        // function becomes callable from a new kernel body function.
+        // Hence this test.
+        // FIXME: We need to be more selective here, this can be hit by simply
+        // having a kernel lambda with a lambda call inside of it.
+        KernelBody = CurrentDecl;
+      }
+      if (KernelBody)
+        Parent.SemaSYCLRef.addSYCLKernelFunction(KernelBody);
+    }
+
+    // Recurse.
+    CallStack.push_back(CurrentDecl);
+    llvm::SmallPtrSet<FunctionDecl *, 16> SeenCallees;
+    for (CallGraphNode *CI : Node->callees()) {
+      FunctionDecl *CurFD = GetFDFromNode(CI);
+
+      // Make sure we only visit each callee 1x from this function to avoid very
+      // time consuming template recursion cases.
+      if (!llvm::is_contained(SeenCallees, CurFD)) {
+        VisitCallNode(CI, CurFD, CallStack);
+        SeenCallees.insert(CurFD);
+      }
+    }
+    CallStack.pop_back();
+  }
+
+  // Function to walk the call graph and identify the important information.
+  void Init() {
+    CallGraphNode *KernelNode = Parent.getNodeForKernel(SYCLKernel);
+    llvm::SmallVector<FunctionDecl *> CallStack;
+    VisitCallNode(KernelNode, GetFDFromNode(KernelNode), CallStack);
+
+    // Always inline the KernelBody in the kernel entry point. For ESIMD
+    // inlining is handled later down the pipeline.
+    if (KernelBody &&
+        Parent.SemaSYCLRef.getLangOpts().SYCLForceInlineKernelLambda &&
+        !KernelBody->hasAttr<NoInlineAttr>() &&
+        !KernelBody->hasAttr<AlwaysInlineAttr>() &&
+        !KernelBody->hasAttr<SYCLSimdAttr>()) {
+      KernelBody->addAttr(AlwaysInlineAttr::CreateImplicit(
+          KernelBody->getASTContext(), {}, AlwaysInlineAttr::Keyword_forceinline));
+    }
+  }
+
+public:
+  SingleDeviceFunctionTracker(DeviceFunctionTracker &P, Decl *Kernel)
+      : Parent(P), SYCLKernel(Kernel->getAsFunction()) {
+    Init();
+  }
+
+  FunctionDecl *GetSYCLKernel() { return SYCLKernel; }
+
+  FunctionDecl *GetKernelBody() { return KernelBody; }
+
+  llvm::SmallVectorImpl<Attr *> &GetCollectedAttributes() {
+    return CollectedAttributes;
+  }
+
+  llvm::SmallPtrSetImpl<FunctionDecl *> &GetDeviceFunctions() {
+    return DeviceFunctions;
+  }
+
+  ~SingleDeviceFunctionTracker() {
+    Parent.AddSingleFunction(DeviceFunctions, RecursiveFunctions);
+  }
+};
+
+class KernelBodyTransform : public TreeTransform<KernelBodyTransform> {
+public:
+  KernelBodyTransform(std::pair<DeclaratorDecl *, DeclaratorDecl *> &MPair,
+                      Sema &S)
+      : TreeTransform<KernelBodyTransform>(S), MappingPair(MPair), SemaRef(S) {}
+  bool AlwaysRebuild() { return true; }
+
+  ExprResult TransformDeclRefExpr(DeclRefExpr *DRE) {
+    auto Ref = dyn_cast<DeclaratorDecl>(DRE->getDecl());
+    if (Ref && Ref == MappingPair.first) {
+      auto NewDecl = MappingPair.second;
+      return DeclRefExpr::Create(
+          SemaRef.getASTContext(), DRE->getQualifierLoc(),
+          DRE->getTemplateKeywordLoc(), NewDecl, false, DRE->getNameInfo(),
+          NewDecl->getType(), DRE->getValueKind());
+    }
+    return DRE;
+  }
+
+private:
+  std::pair<DeclaratorDecl *, DeclaratorDecl *> MappingPair;
+  Sema &SemaRef;
+};
+
+/// Creates a kernel parameter descriptor
+/// \param Src  field declaration to construct name from
+/// \param Ty   the desired parameter type
+/// \return     the constructed descriptor
+static ParamDesc makeParamDesc(const FieldDecl *Src, QualType Ty) {
+  ASTContext &Ctx = Src->getASTContext();
+  std::string Name = (Twine("_arg_") + Src->getName()).str();
+  return std::make_tuple(Ty, &Ctx.Idents.get(Name),
+                         Ctx.getTrivialTypeSourceInfo(Ty));
+}
+static ParamDesc makeParamDesc(const ParmVarDecl *Src, QualType Ty) {
+  ASTContext &Ctx = Src->getASTContext();
+  std::string Name = (Twine("__arg_") + Src->getName()).str();
+  return std::make_tuple(Ty, &Ctx.Idents.get(Name),
+                         Ctx.getTrivialTypeSourceInfo(Ty));
+}
+
+static ParamDesc makeParamDesc(ASTContext &Ctx, StringRef Name, QualType Ty) {
+  return std::make_tuple(Ty, &Ctx.Idents.get(Name),
+                         Ctx.getTrivialTypeSourceInfo(Ty));
+}
+
+static void unsupportedFreeFunctionParamType() {
+  llvm::report_fatal_error("Only scalars and pointers are permitted as "
+                           "free function parameters");
+}
+
+class MarkWIScopeFnVisitor : public RecursiveASTVisitor<MarkWIScopeFnVisitor> {
+public:
+  MarkWIScopeFnVisitor(ASTContext &Ctx) : Ctx(Ctx) {}
+
+  bool VisitCXXMemberCallExpr(CXXMemberCallExpr *Call) {
+    FunctionDecl *Callee = Call->getDirectCallee();
+    if (!Callee)
+      // not a direct call - continue search
+      return true;
+    QualType Ty = Ctx.getRecordType(Call->getRecordDecl());
+    if (!SemaSYCL::isSyclType(Ty, SYCLTypeAttr::group))
+      // not a member of sycl::group - continue search
+      return true;
+    auto Name = Callee->getName();
+    if (Name != "wait_for" ||
+        Callee->hasAttr<SYCLScopeAttr>())
+      return true;
+    // it is a call to sycl::group::wait_for - mark the callee
+    Callee->addAttr(
+        SYCLScopeAttr::CreateImplicit(Ctx, SYCLScopeAttr::Level::WorkItem));
+    // continue search as there can be other wait_for calls
+    return true;
+  }
+
+private:
+  ASTContext &Ctx;
+};
+
+/// Return method by name
+static CXXMethodDecl *getMethodByName(const CXXRecordDecl *CRD,
+                                      StringRef MethodName) {
+  CXXMethodDecl *Method;
+  auto It = std::find_if(CRD->methods().begin(), CRD->methods().end(),
+                         [MethodName](const CXXMethodDecl *Method) {
+                           return Method->getNameAsString() == MethodName;
+                         });
+  Method = (It != CRD->methods().end()) ? *It : nullptr;
+  return Method;
+}
+
+static KernelInvocationKind
+getKernelInvocationKind(FunctionDecl *KernelCallerFunc) {
+  return llvm::StringSwitch<KernelInvocationKind>(KernelCallerFunc->getName())
+      .Case("kernel_single_task", InvokeSingleTask)
+      .Case("kernel_parallel_for", InvokeParallelFor)
+      .Case("kernel_parallel_for_work_group", InvokeParallelForWorkGroup)
+      .Default(InvokeUnknown);
+}
+
+// The SYCL kernel's 'object type' used for diagnostics and naming/mangling is
+// the first parameter to a function template using the sycl_kernel
+// attribute. In SYCL 1.2.1, this was passed by value,
+// and in SYCL 2020, it is passed by reference.
+static QualType GetSYCLKernelObjectType(const FunctionDecl *KernelCaller) {
+  assert(KernelCaller->getNumParams() > 0 && "Insufficient kernel parameters");
+  QualType KernelParamTy = KernelCaller->getParamDecl(0)->getType();
+
+  // SYCL 2020 kernels are passed by reference.
+  if (KernelParamTy->isReferenceType())
+    KernelParamTy = KernelParamTy->getPointeeType();
+
+  // SYCL 1.2.1
+  return KernelParamTy.getUnqualifiedType();
+}
+
+/// \return the target of given SYCL accessor type
+static target getAccessTarget(QualType FieldTy,
+                              const ClassTemplateSpecializationDecl *AccTy) {
+  if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::local_accessor))
+    return local;
+
+  return static_cast<target>(
+      AccTy->getTemplateArgs()[3].getAsIntegral().getExtValue());
+}
+
+// FIXME: Free functions must have void return type and be declared at file
+// scope, outside any namespaces.
+static bool isFreeFunction(SemaSYCL &SemaSYCLRef, const FunctionDecl *FD) {
+  for (auto *IRAttr : FD->specific_attrs<SYCLAddIRAttributesFunctionAttr>()) {
+    SmallVector<std::pair<std::string, std::string>, 4> NameValuePairs =
+        IRAttr->getAttributeNameValuePairs(SemaSYCLRef.getASTContext());
+    for (const auto &NameValuePair : NameValuePairs) {
+      if (NameValuePair.first == "sycl-nd-range-kernel" ||
+          NameValuePair.first == "sycl-single-task-kernel") {
+        if (!FD->getReturnType()->isVoidType()) {
+          llvm::report_fatal_error(
+              "Only functions at file scope with void return "
+              "type are permitted as free functions");
+          return false;
+        }
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+static int getFreeFunctionRangeDim(SemaSYCL &SemaSYCLRef,
+                                   const FunctionDecl *FD) {
+  for (auto *IRAttr : FD->specific_attrs<SYCLAddIRAttributesFunctionAttr>()) {
+    SmallVector<std::pair<std::string, std::string>, 4> NameValuePairs =
+        IRAttr->getAttributeNameValuePairs(SemaSYCLRef.getASTContext());
+    for (const auto &NameValuePair : NameValuePairs) {
+      if (NameValuePair.first == "sycl-nd-range-kernel")
+        return std::stoi(NameValuePair.second);
+      if (NameValuePair.first == "sycl-single-task-kernel")
+        return 0;
+    }
+  }
+  return false;
+}
+
+// Creates a name for the free function kernel function.
+// Consider a free function named "MyFunction". The normal device function will
+// be given its mangled name, say "_Z10MyFunctionIiEvPT_S0_". The corresponding
+// kernel function for this free function will be named
+// "_Z24__sycl_kernel_MyFunctionIiEvPT_S0_". This is the mangled name of a
+// fictitious function that has the same template and function parameters as the
+// original free function but with identifier prefixed with __sycl_kernel_.
+// We generate this name by starting with the mangled name of the free function
+// and adjusting it textually to simulate the __sycl_kernel_ prefix.
+// Because free functions are allowed only at file scope and cannot be within
+// namespaces the mangled name has the format _Z<length><identifier>... where
+// length is the identifier's length. The text manipulation inserts the prefix
+// __sycl_kernel_ and adjusts the length, leaving the rest of the name as-is.
+static std::pair<std::string, std::string> constructFreeFunctionKernelName(
+    SemaSYCL &SemaSYCLRef, const FunctionDecl *FreeFunc, MangleContext &MC) {
+  SmallString<256> Result;
+  llvm::raw_svector_ostream Out(Result);
+  std::string NewName;
+  std::string StableName;
+
+  // Handle extern "C"
+  if (FreeFunc->getLanguageLinkage() == CLanguageLinkage) {
+    const IdentifierInfo *II = FreeFunc->getIdentifier();
+    NewName = "__sycl_kernel_" + II->getName().str();
+  } else {
+    MC.mangleName(FreeFunc, Out);
+    std::string MangledName(Out.str());
+    size_t StartNums = MangledName.find_first_of("0123456789");
+    size_t EndNums = MangledName.find_first_not_of("0123456789", StartNums);
+    size_t NameLength =
+        std::stoi(MangledName.substr(StartNums, EndNums - StartNums));
+    size_t NewNameLength = 14 /*length of __sycl_kernel_*/ + NameLength;
+    NewName = MangledName.substr(0, StartNums) + std::to_string(NewNameLength) +
+              "__sycl_kernel_" + MangledName.substr(EndNums);
+  }
+  StableName = NewName;
+  return {NewName, StableName};
+}
+
+// The first template argument to the kernel caller function is used to identify
+// the kernel itself.
+static QualType calculateKernelNameType(ASTContext &Ctx,
+                                        const FunctionDecl *KernelCallerFunc) {
+  const TemplateArgumentList *TAL =
+      KernelCallerFunc->getTemplateSpecializationArgs();
+  assert(TAL && "No template argument info");
+  return TAL->get(0).getAsType().getCanonicalType();
+}
+
+// Gets a name for the OpenCL kernel function, calculated from the first
+// template argument of the kernel caller function.
+static std::pair<std::string, std::string>
+constructKernelName(SemaSYCL &S, const FunctionDecl *KernelCallerFunc,
+                    MangleContext &MC) {
+  QualType KernelNameType =
+      calculateKernelNameType(S.getASTContext(), KernelCallerFunc);
+
+  SmallString<256> Result;
+  llvm::raw_svector_ostream Out(Result);
+
+  MC.mangleCanonicalTypeName(KernelNameType, Out);
+  std::string MangledName(Out.str());
+
+  std::string StableName =
+      SYCLUniqueStableNameExpr::ComputeName(S.getASTContext(), KernelNameType);
+
+  // For NativeCPU the kernel name is set to the stable GNU-mangled name
+  // because the default mangling may be different, for example on Windows.
+  // This is needed for compiling kernels for multiple SYCL targets to ensure
+  // the same kernel name can be used for kernel lookup in different target
+  // binaries. This assumes that all SYCL targets use the same mangling
+  // produced for the stable name.
+  // Todo: Check if this assumption is valid, and if it would be better
+  // instead to always compile the NativeCPU device code in GNU mode which
+  // may cause issues when compiling headers with non-standard extensions
+  // written for compilers with different C++ ABIs (like MS VS).
+  if (S.getLangOpts().SYCLIsNativeCPU) {
+    MangledName = StableName;
+  }
+
+  return {MangledName, StableName};
+}
+
+static bool isDefaultSPIRArch(ASTContext &Context) {
+  llvm::Triple T = Context.getTargetInfo().getTriple();
+  if (T.isSPIR() && T.getSubArch() == llvm::Triple::NoSubArch)
+    return true;
+  return false;
+}
+
+static ParmVarDecl *getSyclKernelHandlerArg(FunctionDecl *KernelCallerFunc) {
+  // Specialization constants in SYCL 2020 are not captured by lambda and
+  // accessed through new optional lambda argument kernel_handler
+  auto IsHandlerLambda = [](ParmVarDecl *PVD) {
+    return SemaSYCL::isSyclType(PVD->getType(), SYCLTypeAttr::kernel_handler);
+  };
+
+  assert(llvm::count_if(KernelCallerFunc->parameters(), IsHandlerLambda) <= 1 &&
+         "Multiple kernel_handler parameters");
+
+  auto KHArg = llvm::find_if(KernelCallerFunc->parameters(), IsHandlerLambda);
+
+  return (KHArg != KernelCallerFunc->param_end()) ? *KHArg : nullptr;
+}
+
+static bool isReadOnlyAccessor(const TemplateArgument &AccessModeArg) {
+  const auto *AccessModeArgEnumType =
+      AccessModeArg.getIntegralType()->castAs<EnumType>();
+  const EnumDecl *ED = AccessModeArgEnumType->getDecl();
+
+  auto ReadOnly =
+      llvm::find_if(ED->enumerators(), [&](const EnumConstantDecl *E) {
+        return E->getName() == "read";
+      });
+
+  return ReadOnly != ED->enumerator_end() &&
+         (*ReadOnly)->getInitVal() == AccessModeArg.getAsIntegral();
+}
+
+// anonymous namespace so these don't get linkage.
+namespace {
+
+template <typename T> struct bind_param { using type = T; };
+
+template <> struct bind_param<CXXBaseSpecifier &> {
+  using type = const CXXBaseSpecifier &;
+};
+
+template <> struct bind_param<FieldDecl *&> { using type = FieldDecl *; };
+
+template <> struct bind_param<FieldDecl *const &> { using type = FieldDecl *; };
+
+template <typename T> using bind_param_t = typename bind_param<T>::type;
+
+class KernelObjVisitor {
+  SemaSYCL &SemaSYCLRef;
+
+  template <typename ParentTy, typename... HandlerTys>
+  void VisitUnionImpl(const CXXRecordDecl *Owner, ParentTy &Parent,
+                      const CXXRecordDecl *Wrapper, HandlerTys &... Handlers) {
+    (void)std::initializer_list<int>{
+        (Handlers.enterUnion(Owner, Parent), 0)...};
+    VisitRecordHelper(Wrapper, Wrapper->fields(), Handlers...);
+    (void)std::initializer_list<int>{
+        (Handlers.leaveUnion(Owner, Parent), 0)...};
+  }
+
+  // These enable handler execution only when previous Handlers succeed.
+  template <typename... Tn>
+  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&... tn) {
+    bool result = true;
+    (void)std::initializer_list<int>{(result = result && tn(FD, FDTy), 0)...};
+    return result;
+  }
+  template <typename... Tn>
+  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&... tn) {
+    bool result = true;
+    std::initializer_list<int>{(result = result && tn(BD, BDTy), 0)...};
+    return result;
+  }
+
+// This definition using std::bind is necessary because of a gcc 7.x bug.
+#define KF_FOR_EACH(FUNC, Item, Qt)                                            \
+  handleField(                                                                 \
+      Item, Qt,                                                                \
+      std::bind(static_cast<bool (std::decay_t<decltype(Handlers)>::*)(        \
+                    bind_param_t<decltype(Item)>, QualType)>(                  \
+                    &std::decay_t<decltype(Handlers)>::FUNC),                  \
+                std::ref(Handlers), _1, _2)...)
+
+  // The following simpler definition works with gcc 8.x and later.
+  //#define KF_FOR_EACH(FUNC) \
+//  handleField(Field, FieldTy, ([&](FieldDecl *FD, QualType FDTy) { \
+//                return Handlers.f(FD, FDTy); \
+//              })...)
+
+  // This enables handler execution only when previous Handlers succeed.
+  template <typename... Tn>
+  bool handleParam(ParmVarDecl *PD, QualType PDTy, Tn &&...tn) {
+    bool result = true;
+    (void)std::initializer_list<int>{(result = result && tn(PD, PDTy), 0)...};
+    return result;
+  }
+
+  // This definition using std::bind is necessary because of a gcc 7.x bug.
+#define KP_FOR_EACH(FUNC, Item, Qt)                                            \
+  handleParam(                                                                 \
+      Item, Qt,                                                                \
+      std::bind(static_cast<bool (std::decay_t<decltype(Handlers)>::*)(        \
+                    bind_param_t<decltype(Item)>, QualType)>(                  \
+                    &std::decay_t<decltype(Handlers)>::FUNC),                  \
+                std::ref(Handlers), _1, _2)...)
+
+  // Parent contains the FieldDecl or CXXBaseSpecifier that was used to enter
+  // the Wrapper structure that we're currently visiting. Owner is the parent
+  // type (which doesn't exist in cases where it is a FieldDecl in the
+  // 'root'), and Wrapper is the current struct being unwrapped.
+  template <typename ParentTy, typename... HandlerTys>
+  void visitComplexRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
+                          const CXXRecordDecl *Wrapper, QualType RecordTy,
+                          HandlerTys &... Handlers) {
+    (void)std::initializer_list<int>{
+        (Handlers.enterStruct(Owner, Parent, RecordTy), 0)...};
+    VisitRecordHelper(Wrapper, Wrapper->bases(), Handlers...);
+    VisitRecordHelper(Wrapper, Wrapper->fields(), Handlers...);
+    (void)std::initializer_list<int>{
+        (Handlers.leaveStruct(Owner, Parent, RecordTy), 0)...};
+  }
+
+  template <typename ParentTy, typename... HandlerTys>
+  void visitSimpleRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
+                         const CXXRecordDecl *Wrapper, QualType RecordTy,
+                         HandlerTys &... Handlers) {
+    (void)std::initializer_list<int>{
+        (Handlers.handleNonDecompStruct(Owner, Parent, RecordTy), 0)...};
+  }
+
+  template <typename ParentTy, typename... HandlerTys>
+  void visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
+                   const CXXRecordDecl *Wrapper, QualType RecordTy,
+                   HandlerTys &... Handlers);
+
+  template <typename ParentTy, typename... HandlerTys>
+  void VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
+                  const CXXRecordDecl *Wrapper, HandlerTys &... Handlers);
+
+  template <typename... HandlerTys>
+  void VisitRecordHelper(const CXXRecordDecl *Owner,
+                         clang::CXXRecordDecl::base_class_const_range Range,
+                         HandlerTys &... Handlers) {
+    for (const auto &Base : Range) {
+      QualType BaseTy = Base.getType();
+      // Handle accessor class as base
+      if (isSyclSpecialType(BaseTy, SemaSYCLRef))
+        (void)std::initializer_list<int>{
+            (Handlers.handleSyclSpecialType(Owner, Base, BaseTy), 0)...};
+      else
+        // For all other bases, visit the record
+        visitRecord(Owner, Base, BaseTy->getAsCXXRecordDecl(), BaseTy,
+                    Handlers...);
+    }
+  }
+
+  template <typename... HandlerTys>
+  void VisitRecordHelper(const CXXRecordDecl *Owner,
+                         RecordDecl::field_range Range,
+                         HandlerTys &... Handlers) {
+    VisitRecordFields(Owner, Handlers...);
+  }
+
+  template <typename... HandlerTys>
+  void visitArrayElementImpl(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
+                             QualType ElementTy, uint64_t Index,
+                             HandlerTys &... Handlers) {
+    (void)std::initializer_list<int>{
+        (Handlers.nextElement(ElementTy, Index), 0)...};
+    visitField(Owner, ArrayField, ElementTy, Handlers...);
+  }
+
+  template <typename... HandlerTys>
+  void visitFirstArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
+                              QualType ElementTy, HandlerTys &... Handlers) {
+    visitArrayElementImpl(Owner, ArrayField, ElementTy, 0, Handlers...);
+  }
+  template <typename... HandlerTys>
+  void visitNthArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
+                            QualType ElementTy, uint64_t Index,
+                            HandlerTys &... Handlers);
+
+  template <typename... HandlerTys>
+  void visitSimpleArray(const CXXRecordDecl *Owner, FieldDecl *Field,
+                        QualType ArrayTy, HandlerTys &... Handlers) {
+    (void)std::initializer_list<int>{
+        (Handlers.handleSimpleArrayType(Field, ArrayTy), 0)...};
+  }
+
+  template <typename... HandlerTys>
+  void visitComplexArray(const CXXRecordDecl *Owner, FieldDecl *Field,
+                         QualType ArrayTy, HandlerTys &... Handlers) {
+    // Array workflow is:
+    // handleArrayType
+    // enterArray
+    // nextElement
+    // VisitField (same as before, note that The FieldDecl is the of array
+    // itself, not the element)
+    // ... repeat per element, opt-out for duplicates.
+    // leaveArray
+
+    if (!KF_FOR_EACH(handleArrayType, Field, ArrayTy))
+      return;
+
+    const ConstantArrayType *CAT =
+        SemaSYCLRef.getASTContext().getAsConstantArrayType(ArrayTy);
+    assert(CAT && "Should only be called on constant-size array.");
+    QualType ET = CAT->getElementType();
+    uint64_t ElemCount = CAT->getSize().getZExtValue();
+
+    (void)std::initializer_list<int>{
+        (Handlers.enterArray(Field, ArrayTy, ET), 0)...};
+
+    visitFirstArrayElement(Owner, Field, ET, Handlers...);
+    for (uint64_t Index = 1; Index < ElemCount; ++Index)
+      visitNthArrayElement(Owner, Field, ET, Index, Handlers...);
+
+    (void)std::initializer_list<int>{
+        (Handlers.leaveArray(Field, ArrayTy, ET), 0)...};
+  }
+
+  template <typename... HandlerTys>
+  void visitField(const CXXRecordDecl *Owner, FieldDecl *Field,
+                  QualType FieldTy, HandlerTys &... Handlers) {
+    if (isSyclSpecialType(FieldTy, SemaSYCLRef))
+      KF_FOR_EACH(handleSyclSpecialType, Field, FieldTy);
+    else if (FieldTy->isStructureOrClassType()) {
+      if (KF_FOR_EACH(handleStructType, Field, FieldTy)) {
+        CXXRecordDecl *RD = FieldTy->getAsCXXRecordDecl();
+        visitRecord(Owner, Field, RD, FieldTy, Handlers...);
+      }
+    } else if (FieldTy->isUnionType()) {
+      if (KF_FOR_EACH(handleUnionType, Field, FieldTy)) {
+        CXXRecordDecl *RD = FieldTy->getAsCXXRecordDecl();
+        VisitUnion(Owner, Field, RD, Handlers...);
+      }
+    } else if (FieldTy->isReferenceType())
+      KF_FOR_EACH(handleReferenceType, Field, FieldTy);
+    else if (FieldTy->isPointerType())
+      KF_FOR_EACH(handlePointerType, Field, FieldTy);
+    else if (FieldTy->isArrayType())
+      visitArray(Owner, Field, FieldTy, Handlers...);
+    else if (FieldTy->isScalarType() || FieldTy->isVectorType())
+      KF_FOR_EACH(handleScalarType, Field, FieldTy);
+    else
+      KF_FOR_EACH(handleOtherType, Field, FieldTy);
+  }
+
+  template <typename... HandlerTys>
+  void visitParam(ParmVarDecl *Param, QualType ParamTy,
+                  HandlerTys &...Handlers) {
+    if (isSyclSpecialType(ParamTy, SemaSYCLRef))
+      KP_FOR_EACH(handleOtherType, Param, ParamTy);
+    else if (ParamTy->isStructureOrClassType()) {
+      if (KP_FOR_EACH(handleStructType, Param, ParamTy)) {
+        CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
+        visitRecord(nullptr, Param, RD, ParamTy, Handlers...);
+      }
+    } else if (ParamTy->isUnionType())
+      KP_FOR_EACH(handleOtherType, Param, ParamTy);
+    else if (ParamTy->isReferenceType())
+      KP_FOR_EACH(handleOtherType, Param, ParamTy);
+    else if (ParamTy->isPointerType())
+      KP_FOR_EACH(handlePointerType, Param, ParamTy);
+    else if (ParamTy->isArrayType())
+      KP_FOR_EACH(handleOtherType, Param, ParamTy);
+    else if (ParamTy->isScalarType())
+      KP_FOR_EACH(handleScalarType, Param, ParamTy);
+    else
+      KP_FOR_EACH(handleOtherType, Param, ParamTy);
+  }
+
+public:
+  KernelObjVisitor(SemaSYCL &S) : SemaSYCLRef(S) {}
+
+  static bool useTopLevelKernelObj(const CXXRecordDecl *KernelObj) {
+    // If the kernel is empty, "decompose" it so we don't generate arguments.
+    if (KernelObj->isEmpty())
+      return false;
+    // FIXME: Workaround to not change large number of tests
+    // this is covered by the test below.
+    if (targetRequiresNewType(KernelObj->getASTContext()))
+      return false;
+    if (KernelObj->hasAttr<SYCLRequiresDecompositionAttr>() ||
+        KernelObj->hasAttr<SYCLGenerateNewTypeAttr>())
+      return false;
+    return true;
+  }
+
+  template <typename... HandlerTys>
+  void visitTopLevelRecord(const CXXRecordDecl *Owner, QualType RecordTy,
+                           HandlerTys &...Handlers) {
+    (void)std::initializer_list<int>{
+        (Handlers.handleTopLevelStruct(Owner, RecordTy), 0)...};
+  }
+
+  template <typename... HandlerTys>
+  void VisitRecordBases(const CXXRecordDecl *KernelFunctor,
+                        HandlerTys &... Handlers) {
+    VisitRecordHelper(KernelFunctor, KernelFunctor->bases(), Handlers...);
+  }
+
+  // A visitor function that dispatches to functions as defined in
+  // SyclKernelFieldHandler for the purposes of kernel generation.
+  template <typename... HandlerTys>
+  void VisitRecordFields(const CXXRecordDecl *Owner, HandlerTys &... Handlers) {
+    for (const auto Field : Owner->fields())
+      visitField(Owner, Field, Field->getType(), Handlers...);
+  }
+
+  template <typename... HandlerTys>
+  void visitArray(const CXXRecordDecl *Owner, FieldDecl *Field,
+                  QualType ArrayTy, HandlerTys &...Handlers);
+
+  // A visitor for Kernel object to functions as defined in
+  // SyclKernelFieldHandler by iterating over fields and bases
+  // if they require decomposition or new type.
+  template <typename... HandlerTys>
+  void VisitKernelRecord(const CXXRecordDecl *KernelObj,
+                         QualType KernelFunctorTy, HandlerTys &...Handlers) {
+    if (!useTopLevelKernelObj(KernelObj)) {
+      VisitRecordBases(KernelObj, Handlers...);
+      VisitRecordFields(KernelObj, Handlers...);
+    } else {
+      visitTopLevelRecord(KernelObj, KernelFunctorTy, Handlers...);
+    }
+  }
+
+  // A visitor function that dispatches to functions as defined in
+  // SyclKernelFieldHandler by iterating over a free function parameter list.
+  template <typename... HandlerTys>
+  void VisitFunctionParameters(FunctionDecl *FreeFunc,
+                               HandlerTys &...Handlers) {
+    for (ParmVarDecl *Param : FreeFunc->parameters())
+      visitParam(Param, Param->getType(), Handlers...);
+  }
+
+#undef KF_FOR_EACH
+#undef KP_FOR_EACH
+};
+
+// A base type that the SYCL OpenCL Kernel construction task uses to implement
+// individual tasks.
+class SyclKernelFieldHandlerBase {
+public:
+  static constexpr const bool VisitUnionBody = false;
+  static constexpr const bool VisitNthArrayElement = true;
+  // Opt-in based on whether we should visit inside simple containers (structs,
+  // arrays). All of the 'check' types should likely be true, the int-header,
+  // and kernel decl creation types should not.
+  static constexpr const bool VisitInsideSimpleContainers = true;
+  static constexpr const bool VisitInsideSimpleContainersWithPointer = false;
+  // Mark these virtual so that we can use override in the implementer classes,
+  // despite virtual dispatch never being used.
+
+  // SYCL special class can be a base class or a field decl, so both must be
+  // handled.
+  virtual bool handleSyclSpecialType(const CXXRecordDecl *,
+                                     const CXXBaseSpecifier &, QualType) {
+    return true;
+  }
+  virtual bool handleSyclSpecialType(FieldDecl *, QualType) { return true; }
+  virtual bool handleSyclSpecialType(ParmVarDecl *, QualType) { return true; }
+
+  virtual bool handleStructType(FieldDecl *, QualType) { return true; }
+  virtual bool handleStructType(ParmVarDecl *, QualType) { return true; }
+  virtual bool handleUnionType(FieldDecl *, QualType) { return true; }
+  virtual bool handleUnionType(ParmVarDecl *, QualType) { return true; }
+  virtual bool handleReferenceType(FieldDecl *, QualType) { return true; }
+  virtual bool handleReferenceType(ParmVarDecl *, QualType) { return true; }
+  virtual bool handlePointerType(FieldDecl *, QualType) { return true; }
+  virtual bool handlePointerType(ParmVarDecl *, QualType) { return true; }
+  virtual bool handleArrayType(FieldDecl *, QualType) { return true; }
+  virtual bool handleArrayType(ParmVarDecl *, QualType) { return true; }
+  virtual bool handleScalarType(FieldDecl *, QualType) { return true; }
+  virtual bool handleScalarType(ParmVarDecl *, QualType) { return true; }
+  // Most handlers shouldn't be handling this, just the field checker.
+  virtual bool handleOtherType(FieldDecl *, QualType) { return true; }
+  virtual bool handleOtherType(ParmVarDecl *, QualType) { return true; }
+
+  // Handle the SYCL kernel as a whole. This applies only when the target can
+  // support pointer to the generic address space as arguments and the functor
+  // doesn't have any SYCL special types.
+  virtual bool handleTopLevelStruct(const CXXRecordDecl *, QualType) {
+    return true;
+  }
+
+  // Handle a simple struct that doesn't need to be decomposed, only called on
+  // handlers with VisitInsideSimpleContainers as false.  Replaces
+  // handleStructType, enterStruct, leaveStruct, and visiting of sub-elements.
+  virtual bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *,
+                                     QualType) {
+    return true;
+  }
+
+  virtual bool handleNonDecompStruct(const CXXRecordDecl *, ParmVarDecl *,
+                                     QualType) {
+    return true;
+  }
+
+  virtual bool handleNonDecompStruct(const CXXRecordDecl *,
+                                     const CXXBaseSpecifier &, QualType) {
+    return true;
+  }
+
+  // Instead of handleArrayType, enterArray, leaveArray, and nextElement (plus
+  // descending down the elements), this function gets called in the event of an
+  // array containing simple elements (even in the case of an MD array).
+  virtual bool handleSimpleArrayType(FieldDecl *, QualType) { return true; }
+
+  // The following are only used for keeping track of where we are in the base
+  // class/field graph. Int Headers use this to calculate offset, most others
+  // don't have a need for these.
+
+  virtual bool enterStruct(const CXXRecordDecl *, FieldDecl *, QualType) {
+    return true;
+  }
+  virtual bool leaveStruct(const CXXRecordDecl *, FieldDecl *, QualType) {
+    return true;
+  }
+  virtual bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) {
+    return true;
+  }
+  virtual bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) {
+    return true;
+  }
+  virtual bool enterStruct(const CXXRecordDecl *, const CXXBaseSpecifier &,
+                           QualType) {
+    return true;
+  }
+  virtual bool leaveStruct(const CXXRecordDecl *, const CXXBaseSpecifier &,
+                           QualType) {
+    return true;
+  }
+  virtual bool enterUnion(const CXXRecordDecl *, FieldDecl *) { return true; }
+  virtual bool leaveUnion(const CXXRecordDecl *, FieldDecl *) { return true; }
+  virtual bool enterUnion(const CXXRecordDecl *, ParmVarDecl *) { return true; }
+  virtual bool leaveUnion(const CXXRecordDecl *, ParmVarDecl *) { return true; }
+
+  // The following are used for stepping through array elements.
+  virtual bool enterArray(FieldDecl *, QualType ArrayTy, QualType ElementTy) {
+    return true;
+  }
+  virtual bool leaveArray(FieldDecl *, QualType ArrayTy, QualType ElementTy) {
+    return true;
+  }
+  virtual bool enterArray(ParmVarDecl *, QualType ArrayTy, QualType ElementTy) {
+    return true;
+  }
+  virtual bool leaveArray(ParmVarDecl *, QualType ArrayTy, QualType ElementTy) {
+    return true;
+  }
+
+  virtual bool nextElement(QualType, uint64_t) { return true; }
+
+  virtual ~SyclKernelFieldHandlerBase() = default;
+};
+
+// A class to act as the direct base for all the SYCL OpenCL Kernel construction
+// tasks that contains a reference to Sema (and potentially any other
+// universally required data).
+class SyclKernelFieldHandler : public SyclKernelFieldHandlerBase {
+protected:
+  SemaSYCL &SemaSYCLRef;
+  SyclKernelFieldHandler(SemaSYCL &S) : SemaSYCLRef(S) {}
+
+  // Returns 'true' if the thing we're visiting (Based on the FD/QualType pair)
+  // is an element of an array. FD will always be the array field. When
+  // traversing the array field, Ty will be the type of the array field or the
+  // type of array element (or some decomposed type from array).
+  bool isArrayElement(const FieldDecl *FD, QualType Ty) const {
+    return !SemaSYCLRef.getASTContext().hasSameType(FD->getType(), Ty);
+  }
+};
+
+// A class to represent the 'do nothing' case for filtering purposes.
+class SyclEmptyHandler final : public SyclKernelFieldHandlerBase {};
+SyclEmptyHandler GlobalEmptyHandler;
+
+template <bool Keep, typename H> struct HandlerFilter;
+template <typename H> struct HandlerFilter<true, H> {
+  H &Handler;
+  HandlerFilter(H &Handler) : Handler(Handler) {}
+};
+template <typename H> struct HandlerFilter<false, H> {
+  SyclEmptyHandler &Handler = GlobalEmptyHandler;
+  HandlerFilter(H &Handler) {}
+};
+
+template <bool B, bool... Rest> struct AnyTrue;
+
+template <bool B> struct AnyTrue<B> { static constexpr bool Value = B; };
+
+template <bool B, bool... Rest> struct AnyTrue {
+  static constexpr bool Value = B || AnyTrue<Rest...>::Value;
+};
+
+template <bool B, bool... Rest> struct AllTrue;
+
+template <bool B> struct AllTrue<B> { static constexpr bool Value = B; };
+
+template <bool B, bool... Rest> struct AllTrue {
+  static constexpr bool Value = B && AllTrue<Rest...>::Value;
+};
+
+template <typename ParentTy, typename... Handlers>
+void KernelObjVisitor::VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
+                                  const CXXRecordDecl *Wrapper,
+                                  Handlers &... handlers) {
+  // Don't continue descending if none of the handlers 'care'. This could be 'if
+  // constexpr' starting in C++17.  Until then, we have to count on the
+  // optimizer to realize "if (false)" is a dead branch.
+  if (AnyTrue<Handlers::VisitUnionBody...>::Value)
+    VisitUnionImpl(
+        Owner, Parent, Wrapper,
+        HandlerFilter<Handlers::VisitUnionBody, Handlers>(handlers).Handler...);
+}
+
+template <typename... Handlers>
+void KernelObjVisitor::visitNthArrayElement(const CXXRecordDecl *Owner,
+                                            FieldDecl *ArrayField,
+                                            QualType ElementTy, uint64_t Index,
+                                            Handlers &... handlers) {
+  // Don't continue descending if none of the handlers 'care'. This could be 'if
+  // constexpr' starting in C++17.  Until then, we have to count on the
+  // optimizer to realize "if (false)" is a dead branch.
+  if (AnyTrue<Handlers::VisitNthArrayElement...>::Value)
+    visitArrayElementImpl(
+        Owner, ArrayField, ElementTy, Index,
+        HandlerFilter<Handlers::VisitNthArrayElement, Handlers>(handlers)
+            .Handler...);
+}
+
+template <typename ParentTy, typename... HandlerTys>
+void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
+                                   const CXXRecordDecl *Wrapper,
+                                   QualType RecordTy,
+                                   HandlerTys &... Handlers) {
+  RecordDecl *RD = RecordTy->getAsRecordDecl();
+  assert(RD && "should not be null.");
+  if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
+    // If this container requires decomposition, we have to visit it as
+    // 'complex', so all handlers are called in this case with the 'complex'
+    // case.
+    visitComplexRecord(Owner, Parent, Wrapper, RecordTy, Handlers...);
+  } else if (AnyTrue<HandlerTys::VisitInsideSimpleContainersWithPointer...>::
+                 Value) {
+    // We are currently in PointerHandler visitor.
+    if (RD->hasAttr<SYCLGenerateNewTypeAttr>()) {
+      // This is a record containing pointers.
+      visitComplexRecord(Owner, Parent, Wrapper, RecordTy, Handlers...);
+    } else {
+      // This is a record without pointers.
+      visitSimpleRecord(Owner, Parent, Wrapper, RecordTy, Handlers...);
+    }
+  } else {
+    // "Simple" Containers are those that do NOT need to be decomposed,
+    // "Complex" containers are those that DO. In the case where the container
+    // does NOT need to be decomposed, we can call VisitSimpleRecord on the
+    // handlers that have opted-out of VisitInsideSimpleContainers. The 'if'
+    // makes sure we only do that if at least 1 has opted out.
+    if (!AllTrue<HandlerTys::VisitInsideSimpleContainers...>::Value)
+      visitSimpleRecord(
+          Owner, Parent, Wrapper, RecordTy,
+          HandlerFilter<!HandlerTys::VisitInsideSimpleContainers, HandlerTys>(
+              Handlers)
+              .Handler...);
+
+    // Even though this is a 'simple' container, some handlers (via
+    // VisitInsideSimpleContainers = true) need to treat it as if it needs
+    // decomposing, so we call VisitComplexRecord iif at least one has.
+    if (AnyTrue<HandlerTys::VisitInsideSimpleContainers...>::Value)
+      visitComplexRecord(
+          Owner, Parent, Wrapper, RecordTy,
+          HandlerFilter<HandlerTys::VisitInsideSimpleContainers, HandlerTys>(
+              Handlers)
+              .Handler...);
+  }
+}
+
+template <typename... HandlerTys>
+void KernelObjVisitor::visitArray(const CXXRecordDecl *Owner, FieldDecl *Field,
+                                  QualType ArrayTy, HandlerTys &... Handlers) {
+
+  if (Field->hasAttr<SYCLRequiresDecompositionAttr>()) {
+    visitComplexArray(Owner, Field, ArrayTy, Handlers...);
+  } else if (AnyTrue<HandlerTys::VisitInsideSimpleContainersWithPointer...>::
+                 Value) {
+    // We are currently in PointerHandler visitor.
+    if (Field->hasAttr<SYCLGenerateNewTypeAttr>()) {
+      // This is an array of pointers, or an array of a type containing
+      // pointers.
+      visitComplexArray(Owner, Field, ArrayTy, Handlers...);
+    } else {
+      // This is an array which does not contain pointers.
+      visitSimpleArray(Owner, Field, ArrayTy, Handlers...);
+    }
+  } else {
+    if (!AllTrue<HandlerTys::VisitInsideSimpleContainers...>::Value)
+      visitSimpleArray(
+          Owner, Field, ArrayTy,
+          HandlerFilter<!HandlerTys::VisitInsideSimpleContainers, HandlerTys>(
+              Handlers)
+              .Handler...);
+
+    if (AnyTrue<HandlerTys::VisitInsideSimpleContainers...>::Value)
+      visitComplexArray(
+          Owner, Field, ArrayTy,
+          HandlerFilter<HandlerTys::VisitInsideSimpleContainers, HandlerTys>(
+              Handlers)
+              .Handler...);
+  }
+}
+
+// A type to check the validity of all of the argument types.
+class SyclKernelFieldChecker : public SyclKernelFieldHandler {
+  bool IsInvalid = false;
+  DiagnosticsEngine &Diag;
+  // Keeps track of whether we are currently handling fields inside a struct.
+  // Fields of kernel functor or direct kernel captures will have a depth 0.
+  int StructFieldDepth = 0;
+  // Initialize with -1 so that fields of a base class of the kernel functor
+  // has depth 0. Visitor method enterStruct increments this to 0 when the base
+  // class is entered.
+  int StructBaseDepth = -1;
+
+  // Check whether the object should be disallowed from being copied to kernel.
+  // Return true if not copyable, false if copyable.
+  bool checkNotCopyableToKernel(const FieldDecl *FD, QualType FieldTy) {
+    if (FieldTy->isArrayType()) {
+      if (const auto *CAT =
+              SemaSYCLRef.getASTContext().getAsConstantArrayType(FieldTy)) {
+        QualType ET = CAT->getElementType();
+        return checkNotCopyableToKernel(FD, ET);
+      }
+      return Diag.Report(FD->getLocation(),
+                         diag::err_sycl_non_constant_array_type)
+             << FieldTy;
+    }
+
+    return false;
+  }
+
+  bool checkPropertyListType(TemplateArgument PropList, SourceLocation Loc) {
+    if (PropList.getKind() != TemplateArgument::ArgKind::Type)
+      return SemaSYCLRef.Diag(
+          Loc, diag::err_sycl_invalid_accessor_property_template_param);
+
+    QualType PropListTy = PropList.getAsType();
+    if (!SemaSYCL::isSyclType(PropListTy, SYCLTypeAttr::accessor_property_list))
+      return SemaSYCLRef.Diag(
+          Loc, diag::err_sycl_invalid_accessor_property_template_param);
+
+    const auto *AccPropListDecl =
+        cast<ClassTemplateSpecializationDecl>(PropListTy->getAsRecordDecl());
+    if (AccPropListDecl->getTemplateArgs().size() != 1)
+      return SemaSYCLRef.Diag(Loc,
+                              diag::err_sycl_invalid_property_list_param_number)
+             << "accessor_property_list";
+
+    const auto TemplArg = AccPropListDecl->getTemplateArgs()[0];
+    if (TemplArg.getKind() != TemplateArgument::ArgKind::Pack)
+      return SemaSYCLRef.Diag(
+                 Loc,
+                 diag::err_sycl_invalid_accessor_property_list_template_param)
+             << /*accessor_property_list*/ 0 << /*parameter pack*/ 0;
+
+    for (TemplateArgument::pack_iterator Prop = TemplArg.pack_begin();
+         Prop != TemplArg.pack_end(); ++Prop) {
+      if (Prop->getKind() != TemplateArgument::ArgKind::Type)
+        return SemaSYCLRef.Diag(
+                   Loc,
+                   diag::err_sycl_invalid_accessor_property_list_template_param)
+               << /*accessor_property_list pack argument*/ 1 << /*type*/ 1;
+      QualType PropTy = Prop->getAsType();
+      if (isAccessorPropertyType(PropTy, SYCLTypeAttr::buffer_location) &&
+          checkBufferLocationType(PropTy, Loc))
+        return true;
+    }
+    return false;
+  }
+
+  bool checkBufferLocationType(QualType PropTy, SourceLocation Loc) {
+    const auto *PropDecl =
+        cast<ClassTemplateSpecializationDecl>(PropTy->getAsRecordDecl());
+    if (PropDecl->getTemplateArgs().size() != 1)
+      return SemaSYCLRef.Diag(Loc,
+                              diag::err_sycl_invalid_property_list_param_number)
+             << "buffer_location";
+
+    const auto BufferLoc = PropDecl->getTemplateArgs()[0];
+    if (BufferLoc.getKind() != TemplateArgument::ArgKind::Integral)
+      return SemaSYCLRef.Diag(
+                 Loc,
+                 diag::err_sycl_invalid_accessor_property_list_template_param)
+             << /*buffer_location*/ 2 << /*non-negative integer*/ 2;
+
+    int LocationID = static_cast<int>(BufferLoc.getAsIntegral().getExtValue());
+    if (LocationID < 0)
+      return SemaSYCLRef.Diag(
+                 Loc,
+                 diag::err_sycl_invalid_accessor_property_list_template_param)
+             << /*buffer_location*/ 2 << /*non-negative integer*/ 2;
+
+    return false;
+  }
+
+  bool checkSyclSpecialType(QualType Ty, SourceRange Loc) {
+    assert(isSyclSpecialType(Ty, SemaSYCLRef) &&
+           "Should only be called on sycl special class types.");
+
+    // Annotated pointers and annotated arguments must be captured
+    // directly by the SYCL kernel.
+    if ((SemaSYCL::isSyclType(Ty, SYCLTypeAttr::annotated_ptr) ||
+         SemaSYCL::isSyclType(Ty, SYCLTypeAttr::annotated_arg)) &&
+        (StructFieldDepth > 0 || StructBaseDepth > 0))
+      return SemaSYCLRef.Diag(Loc.getBegin(),
+                              diag::err_bad_kernel_param_data_members)
+             << Ty << /*Struct*/ 1;
+
+    const RecordDecl *RecD = Ty->getAsRecordDecl();
+    if (const ClassTemplateSpecializationDecl *CTSD =
+            dyn_cast<ClassTemplateSpecializationDecl>(RecD)) {
+      const TemplateArgumentList &TAL = CTSD->getTemplateArgs();
+      TemplateArgument TA = TAL.get(0);
+
+      // Parameter packs are used by properties so they are always valid.
+      if (TA.getKind() != TemplateArgument::Pack) {
+        llvm::DenseSet<QualType> Visited;
+        checkSYCLType(SemaSYCLRef, TA.getAsType(), Loc, Visited);
+      }
+
+      if (TAL.size() > 5)
+        return checkPropertyListType(TAL.get(5), Loc.getBegin());
+    }
+    return false;
+  }
+
+public:
+  SyclKernelFieldChecker(SemaSYCL &S)
+      : SyclKernelFieldHandler(S), Diag(S.getASTContext().getDiagnostics()) {}
+  static constexpr const bool VisitNthArrayElement = false;
+  bool isValid() { return !IsInvalid; }
+
+  bool handleReferenceType(FieldDecl *FD, QualType FieldTy) final {
+    Diag.Report(FD->getLocation(), diag::err_bad_kernel_param_type) << FieldTy;
+    IsInvalid = true;
+    return isValid();
+  }
+
+  bool handleReferenceType(ParmVarDecl *PD, QualType ParamTy) final {
+    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
+    IsInvalid = true;
+    return isValid();
+  }
+
+  bool handleStructType(FieldDecl *FD, QualType FieldTy) final {
+    CXXRecordDecl *RD = FieldTy->getAsCXXRecordDecl();
+    assert(RD && "Not a RecordDecl inside the handler for struct type");
+    if (RD->isLambda()) {
+      for (const LambdaCapture &LC : RD->captures())
+        if (LC.capturesThis() && LC.isImplicit()) {
+          SemaSYCLRef.Diag(LC.getLocation(), diag::err_implicit_this_capture);
+          IsInvalid = true;
+        }
+    }
+    return isValid();
+  }
+
+  bool handleStructType(ParmVarDecl *PD, QualType ParamTy) final {
+    CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
+    // For free functions all struct/class kernel arguments are forward declared
+    // in integration header, that adds additional restrictions for kernel
+    // arguments.
+    NotForwardDeclarableReason NFDR =
+        isForwardDeclarable(RD, SemaSYCLRef, /*DiagForFreeFunction=*/true);
+    if (NFDR != NotForwardDeclarableReason::None) {
+      Diag.Report(PD->getLocation(),
+                  diag::err_bad_kernel_param_type)
+          << ParamTy;
+      Diag.Report(PD->getLocation(),
+                  diag::note_free_function_kernel_param_type_not_fwd_declarable)
+          << ParamTy;
+      IsInvalid = true;
+    }
+    return isValid();
+  }
+
+  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                             QualType FieldTy) final {
+    IsInvalid |= checkSyclSpecialType(FieldTy, BS.getBeginLoc());
+    return isValid();
+  }
+
+  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
+    IsInvalid |= checkSyclSpecialType(FieldTy, FD->getLocation());
+    return isValid();
+  }
+
+  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
+    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
+    IsInvalid = true;
+    return isValid();
+  }
+
+  bool handleArrayType(FieldDecl *FD, QualType FieldTy) final {
+    IsInvalid |= checkNotCopyableToKernel(FD, FieldTy);
+    return isValid();
+  }
+
+  bool handleArrayType(ParmVarDecl *PD, QualType ParamTy) final {
+    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
+    IsInvalid = true;
+    return isValid();
+  }
+
+  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
+    while (FieldTy->isAnyPointerType()) {
+      FieldTy = QualType{FieldTy->getPointeeOrArrayElementType(), 0};
+      if (FieldTy->isVariableArrayType()) {
+        Diag.Report(FD->getLocation(), diag::err_vla_unsupported) << 0;
+        IsInvalid = true;
+        break;
+      }
+    }
+    return isValid();
+  }
+
+  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
+    while (ParamTy->isAnyPointerType()) {
+      ParamTy = QualType{ParamTy->getPointeeOrArrayElementType(), 0};
+      if (ParamTy->isVariableArrayType()) {
+        Diag.Report(PD->getLocation(), diag::err_vla_unsupported) << 0;
+        IsInvalid = true;
+        break;
+      }
+    }
+    return isValid();
+  }
+
+  bool handleOtherType(FieldDecl *FD, QualType FieldTy) final {
+    Diag.Report(FD->getLocation(), diag::err_bad_kernel_param_type) << FieldTy;
+    IsInvalid = true;
+    return isValid();
+  }
+
+  bool handleOtherType(ParmVarDecl *PD, QualType ParamTy) final {
+    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
+    IsInvalid = true;
+    return isValid();
+  }
+
+  bool enterStruct(const CXXRecordDecl *, FieldDecl *, QualType) final {
+    ++StructFieldDepth;
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, FieldDecl *, QualType) final {
+    --StructFieldDepth;
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
+    // TODO manipulate struct depth once special types are supported for free
+    // function kernels.
+    // ++StructFieldDepth;
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *PD,
+                   QualType ParamTy) final {
+    // TODO manipulate struct depth once special types are supported for free
+    // function kernels.
+    // --StructFieldDepth;
+    // TODO We don't yet support special types and therefore structs that
+    // require decomposition and leaving/entering. Diagnose for better user
+    // experience.
+    CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
+    if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
+      Diag.Report(PD->getLocation(),
+                  diag::err_bad_kernel_param_type)
+          << ParamTy;
+      Diag.Report(PD->getLocation(),
+                  diag::note_free_function_kernel_param_type_not_supported)
+          << ParamTy;
+      IsInvalid = true;
+    }
+    return isValid();
+  }
+
+  bool enterStruct(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                   QualType FieldTy) final {
+    ++StructBaseDepth;
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                   QualType FieldTy) final {
+    --StructBaseDepth;
+    return true;
+  }
+};
+
+// A type to check the validity of accessing accessor/sampler/stream
+// types as kernel parameters inside union.
+class SyclKernelUnionChecker : public SyclKernelFieldHandler {
+  int UnionCount = 0;
+  bool IsInvalid = false;
+  DiagnosticsEngine &Diag;
+
+public:
+  SyclKernelUnionChecker(SemaSYCL &S)
+      : SyclKernelFieldHandler(S), Diag(S.getASTContext().getDiagnostics()) {}
+  bool isValid() { return !IsInvalid; }
+  static constexpr const bool VisitUnionBody = true;
+  static constexpr const bool VisitNthArrayElement = false;
+
+  bool checkType(SourceLocation Loc, QualType Ty) {
+    if (UnionCount) {
+      IsInvalid = true;
+      Diag.Report(Loc, diag::err_bad_kernel_param_data_members)
+          << Ty << /*Union*/ 0;
+    }
+    return isValid();
+  }
+
+  bool enterUnion(const CXXRecordDecl *RD, FieldDecl *FD) override {
+    ++UnionCount;
+    return true;
+  }
+
+  bool enterUnion(const CXXRecordDecl *, ParmVarDecl *) override {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool leaveUnion(const CXXRecordDecl *RD, FieldDecl *FD) override {
+    --UnionCount;
+    return true;
+  }
+
+  bool leaveUnion(const CXXRecordDecl *, ParmVarDecl *) override {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
+    return checkType(FD->getLocation(), FieldTy);
+  }
+
+  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                             QualType FieldTy) final {
+    return checkType(BS.getBeginLoc(), FieldTy);
+  }
+};
+
+// A type to mark whether a collection requires decomposition
+// or needs to be transformed to a new type. If a collection
+// contains pointers, and is not decomposed, a new type must
+// be generated with all pointers in global address space.
+class SyclKernelDecompMarker : public SyclKernelFieldHandler {
+  llvm::SmallVector<bool, 16> CollectionStack;
+  llvm::SmallVector<bool, 16> PointerStack;
+
+public:
+  static constexpr const bool VisitUnionBody = false;
+  static constexpr const bool VisitNthArrayElement = false;
+
+  SyclKernelDecompMarker(SemaSYCL &S) : SyclKernelFieldHandler(S) {
+    // Base entry.
+    CollectionStack.push_back(false);
+    PointerStack.push_back(false);
+  }
+
+  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &,
+                             QualType) final {
+    CollectionStack.back() = true;
+    return true;
+  }
+  bool handleSyclSpecialType(FieldDecl *, QualType) final {
+    CollectionStack.back() = true;
+    return true;
+  }
+
+  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
+    // TODO We don't support special types in free function kernel parameters,
+    // but track them to diagnose the case properly.
+    CollectionStack.back() = true;
+    return true;
+  }
+
+  bool handlePointerType(FieldDecl *, QualType) final {
+    PointerStack.back() = targetRequiresNewType(SemaSYCLRef.getASTContext());
+    return true;
+  }
+
+  bool handlePointerType(ParmVarDecl *, QualType) final {
+    PointerStack.back() = targetRequiresNewType(SemaSYCLRef.getASTContext());
+    return true;
+  }
+
+  // Add Top level information to ease checks for processor.
+  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
+    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
+    assert(RD && "should not be null.");
+    if (CollectionStack.pop_back_val() ||
+        SemaSYCLRef.getLangOpts().SYCLDecomposeStruct) {
+      if (!RD->hasAttr<SYCLRequiresDecompositionAttr>())
+        RD->addAttr(SYCLRequiresDecompositionAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+      PointerStack.pop_back();
+    } else if (PointerStack.pop_back_val()) {
+      if (!RD->hasAttr<SYCLGenerateNewTypeAttr>())
+        RD->addAttr(SYCLGenerateNewTypeAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+    }
+    assert(CollectionStack.size() == 0);
+    assert(PointerStack.size() == 0);
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *, FieldDecl *, QualType) final {
+    CollectionStack.push_back(false);
+    PointerStack.push_back(false);
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
+    CollectionStack.push_back(false);
+    PointerStack.push_back(false);
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, FieldDecl *, QualType Ty) final {
+    // If a record needs to be decomposed, it is marked with
+    // SYCLRequiresDecompositionAttr. Else if a record contains
+    // a pointer, it is marked with SYCLGenerateNewTypeAttr. A record
+    // will never be marked with both attributes.
+    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
+    assert(RD && "should not be null.");
+    if (CollectionStack.pop_back_val()) {
+      if (!RD->hasAttr<SYCLRequiresDecompositionAttr>())
+        RD->addAttr(SYCLRequiresDecompositionAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+      CollectionStack.back() = true;
+      PointerStack.pop_back();
+    } else if (PointerStack.pop_back_val()) {
+      PointerStack.back() = true;
+      if (!RD->hasAttr<SYCLGenerateNewTypeAttr>())
+        RD->addAttr(SYCLGenerateNewTypeAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+    }
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *,
+                   QualType ParamTy) final {
+    CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
+    assert(RD && "should not be null.");
+    if (CollectionStack.pop_back_val()) {
+      if (!RD->hasAttr<SYCLRequiresDecompositionAttr>())
+        RD->addAttr(SYCLRequiresDecompositionAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+      CollectionStack.back() = true;
+      PointerStack.pop_back();
+    } else if (PointerStack.pop_back_val()) {
+      PointerStack.back() = true;
+      if (!RD->hasAttr<SYCLGenerateNewTypeAttr>())
+        RD->addAttr(SYCLGenerateNewTypeAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+    }
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *, const CXXBaseSpecifier &,
+                   QualType) final {
+    CollectionStack.push_back(false);
+    PointerStack.push_back(false);
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, const CXXBaseSpecifier &,
+                   QualType Ty) final {
+    // If a record needs to be decomposed, it is marked with
+    // SYCLRequiresDecompositionAttr. Else if a record contains
+    // a pointer, it is marked with SYCLGenerateNewTypeAttr. A record
+    // will never be marked with both attributes.
+    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
+    assert(RD && "should not be null.");
+    if (CollectionStack.pop_back_val()) {
+      if (!RD->hasAttr<SYCLRequiresDecompositionAttr>())
+        RD->addAttr(SYCLRequiresDecompositionAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+      CollectionStack.back() = true;
+      PointerStack.pop_back();
+    } else if (PointerStack.pop_back_val()) {
+      PointerStack.back() = true;
+      if (!RD->hasAttr<SYCLGenerateNewTypeAttr>())
+        RD->addAttr(SYCLGenerateNewTypeAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+    }
+    return true;
+  }
+
+  bool enterArray(FieldDecl *, QualType ArrayTy, QualType ElementTy) final {
+    CollectionStack.push_back(false);
+    PointerStack.push_back(false);
+    return true;
+  }
+
+  bool enterArray(ParmVarDecl *, QualType ArrayTy, QualType ElementTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool leaveArray(FieldDecl *FD, QualType ArrayTy, QualType ElementTy) final {
+    // If an array needs to be decomposed, it is marked with
+    // SYCLRequiresDecompositionAttr. Else if the array is an array of pointers
+    // or an array of structs containing pointers, it is marked with
+    // SYCLGenerateNewTypeAttr. An array will never be marked with both
+    // attributes.
+    if (CollectionStack.pop_back_val()) {
+      // Cannot assert, since in MD arrays we'll end up marking them multiple
+      // times.
+      if (!FD->hasAttr<SYCLRequiresDecompositionAttr>())
+        FD->addAttr(SYCLRequiresDecompositionAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+      CollectionStack.back() = true;
+      PointerStack.pop_back();
+    } else if (PointerStack.pop_back_val()) {
+      if (!FD->hasAttr<SYCLGenerateNewTypeAttr>())
+        FD->addAttr(SYCLGenerateNewTypeAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+      PointerStack.back() = true;
+    }
+    return true;
+  }
+
+  bool leaveArray(ParmVarDecl *PD, QualType ArrayTy, QualType ElementTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+};
+
+static QualType ModifyAddressSpace(SemaSYCL &SemaSYCLRef, QualType Ty) {
+  // USM allows to use raw pointers instead of buffers/accessors, but these
+  // pointers point to the specially allocated memory. For pointer fields,
+  // except for function pointer fields, we add a kernel argument with the
+  // same type as field but global address space, because OpenCL requires it.
+  // Function pointers should have program address space. This is set in
+  // CodeGen.
+  QualType PointeeTy = Ty->getPointeeType();
+  Qualifiers Quals = PointeeTy.getQualifiers();
+  LangAS AS = Quals.getAddressSpace();
+  // Leave global_device and global_host address spaces as is to help FPGA
+  // device in memory allocations.
+  if (!PointeeTy->isFunctionType() && AS != LangAS::sycl_global_device &&
+      AS != LangAS::sycl_global_host)
+    Quals.setAddressSpace(LangAS::sycl_global);
+  PointeeTy = SemaSYCLRef.getASTContext().getQualifiedType(
+      PointeeTy.getUnqualifiedType(), Quals);
+  return SemaSYCLRef.getASTContext().getPointerType(PointeeTy);
+}
+
+// This visitor is used to traverse a non-decomposed record/array to
+// generate a new type corresponding to this record/array.
+class SyclKernelPointerHandler : public SyclKernelFieldHandler {
+  llvm::SmallVector<CXXRecordDecl *, 8> ModifiedRecords;
+  SmallVector<CXXBaseSpecifier *, 8> ModifiedBases;
+  SmallVector<QualType, 8> ModifiedArrayElementsOrArray;
+
+  IdentifierInfo *getModifiedName(IdentifierInfo *Id) {
+    std::string Name =
+        Id ? (Twine("__generated_") + Id->getName()).str() : "__generated_";
+    return &SemaSYCLRef.getASTContext().Idents.get(Name);
+  }
+
+  // Create Decl for the new type we are generating.
+  // The fields (and base classes) of this record will be generated as
+  // the visitor traverses kernel object record fields.
+  void createNewType(const CXXRecordDecl *RD) {
+    auto *ModifiedRD = CXXRecordDecl::Create(
+        SemaSYCLRef.getASTContext(), RD->getTagKind(),
+        const_cast<DeclContext *>(RD->getDeclContext()), SourceLocation(),
+        SourceLocation(), getModifiedName(RD->getIdentifier()));
+    ModifiedRD->startDefinition();
+    if (RD->hasAttrs())
+      ModifiedRD->setAttrs(RD->getAttrs());
+    ModifiedRecords.push_back(ModifiedRD);
+  }
+
+  // Create and add FieldDecl for FieldTy to generated record.
+  void addField(const FieldDecl *FD, QualType FieldTy) {
+    assert(!ModifiedRecords.empty() &&
+           "ModifiedRecords should have at least 1 record");
+    ASTContext &Ctx = SemaSYCLRef.getASTContext();
+    auto *Field = FieldDecl::Create(
+        Ctx, ModifiedRecords.back(), SourceLocation(), SourceLocation(),
+        getModifiedName(FD->getIdentifier()), FieldTy,
+        Ctx.getTrivialTypeSourceInfo(FieldTy, SourceLocation()), /*BW=*/nullptr,
+        /*Mutable=*/false, ICIS_NoInit);
+    Field->setAccess(FD->getAccess());
+    if (FD->hasAttrs())
+      Field->setAttrs(FD->getAttrs());
+    // Add generated field to generated record.
+    ModifiedRecords.back()->addDecl(Field);
+  }
+
+  void createBaseSpecifier(const CXXRecordDecl *Parent, const CXXRecordDecl *RD,
+                           const CXXBaseSpecifier &BS) {
+    TypeSourceInfo *TInfo =
+        SemaSYCLRef.getASTContext().getTrivialTypeSourceInfo(
+            QualType(RD->getTypeForDecl(), 0), SourceLocation());
+    CXXBaseSpecifier *ModifiedBase = SemaSYCLRef.SemaRef.CheckBaseSpecifier(
+        const_cast<CXXRecordDecl *>(Parent), SourceRange(), BS.isVirtual(),
+        BS.getAccessSpecifier(), TInfo, SourceLocation());
+    ModifiedBases.push_back(ModifiedBase);
+  }
+
+  CXXRecordDecl *getGeneratedNewRecord(const CXXRecordDecl *OldBaseDecl) {
+    // At this point we have finished generating fields for the new
+    // class corresponding to OldBaseDecl. Pop out the generated
+    // record.
+    CXXRecordDecl *ModifiedRD = ModifiedRecords.pop_back_val();
+    ModifiedRD->completeDefinition();
+    // Check the 'old' class for base classes.
+    // Set bases classes for newly generated class if it has any.
+    if (OldBaseDecl->getNumBases() > 0) {
+      SmallVector<CXXBaseSpecifier *, 8> BasesForGeneratedClass;
+      for (size_t I = 0; I < OldBaseDecl->getNumBases(); ++I)
+        BasesForGeneratedClass.insert(BasesForGeneratedClass.begin(),
+                                      ModifiedBases.pop_back_val());
+      ModifiedRD->setBases(BasesForGeneratedClass.data(),
+                           OldBaseDecl->getNumBases());
+    }
+    return ModifiedRD;
+  }
+
+public:
+  static constexpr const bool VisitInsideSimpleContainersWithPointer = true;
+  static constexpr const bool VisitNthArrayElement = false;
+  SyclKernelPointerHandler(SemaSYCL &S, const CXXRecordDecl *RD)
+      : SyclKernelFieldHandler(S) {
+    createNewType(RD);
+  }
+
+  SyclKernelPointerHandler(SemaSYCL &S) : SyclKernelFieldHandler(S) {}
+
+  bool enterStruct(const CXXRecordDecl *, FieldDecl *, QualType Ty) final {
+    createNewType(Ty->getAsCXXRecordDecl());
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *,
+                   QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
+    CXXRecordDecl *ModifiedRD = getGeneratedNewRecord(Ty->getAsCXXRecordDecl());
+
+    // Add this record as a field of it's parent record if it is not an
+    // array element.
+    if (!isArrayElement(FD, Ty))
+      addField(FD, QualType(ModifiedRD->getTypeForDecl(), 0));
+    else
+      ModifiedArrayElementsOrArray.push_back(
+          QualType(ModifiedRD->getTypeForDecl(), 0));
+
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *PD,
+                   QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *, const CXXBaseSpecifier &,
+                   QualType Ty) final {
+    createNewType(Ty->getAsCXXRecordDecl());
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *Parent, const CXXBaseSpecifier &BS,
+                   QualType Ty) final {
+    CXXRecordDecl *ModifiedRD = getGeneratedNewRecord(Ty->getAsCXXRecordDecl());
+
+    // Create CXXBaseSpecifier for this generated class.
+    createBaseSpecifier(Parent, ModifiedRD, BS);
+    return true;
+  }
+
+  bool leaveArray(FieldDecl *FD, QualType ArrayTy, QualType ET) final {
+    QualType ModifiedArrayElement = ModifiedArrayElementsOrArray.pop_back_val();
+
+    const ConstantArrayType *CAT =
+        SemaSYCLRef.getASTContext().getAsConstantArrayType(ArrayTy);
+    assert(CAT && "Should only be called on constant-size array.");
+    QualType ModifiedArray = SemaSYCLRef.getASTContext().getConstantArrayType(
+        ModifiedArrayElement, CAT->getSize(),
+        const_cast<Expr *>(CAT->getSizeExpr()), CAT->getSizeModifier(),
+        CAT->getIndexTypeCVRQualifiers());
+
+    if (ModifiedRecords.empty()) {
+      // This is a top-level kernel argument.
+      ModifiedArrayElementsOrArray.push_back(ModifiedArray);
+    } else if (!isArrayElement(FD, ArrayTy)) {
+      // Add this array field as a field of it's parent record.
+      addField(FD, ModifiedArray);
+    } else {
+      // Multi-dimensional array element.
+      ModifiedArrayElementsOrArray.push_back(ModifiedArray);
+    }
+
+    return true;
+  }
+
+  bool leaveArray(ParmVarDecl *PD, QualType ArrayTy, QualType ET) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
+    QualType ModifiedPointerType = ModifyAddressSpace(SemaSYCLRef, FieldTy);
+    if (!isArrayElement(FD, FieldTy))
+      addField(FD, ModifiedPointerType);
+    else
+      ModifiedArrayElementsOrArray.push_back(ModifiedPointerType);
+    // We do not need to wrap pointers since this is a pointer inside
+    // non-decomposed struct.
+    return true;
+  }
+
+  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
+    addField(FD, FieldTy);
+    return true;
+  }
+
+  bool handleScalarType(ParmVarDecl *PD, QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
+    return handleScalarType(FD, FieldTy);
+  }
+
+  bool handleUnionType(ParmVarDecl *PD, QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
+                             QualType Ty) final {
+    addField(FD, Ty);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, ParmVarDecl *PD,
+                             QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *Parent,
+                             const CXXBaseSpecifier &BS, QualType Ty) final {
+    createBaseSpecifier(Parent, Ty->getAsCXXRecordDecl(), BS);
+    return true;
+  }
+
+  bool handleSimpleArrayType(FieldDecl *FD, QualType Ty) final {
+    addField(FD, Ty);
+    return true;
+  }
+
+public:
+  QualType getNewRecordType() {
+    CXXRecordDecl *ModifiedRD = ModifiedRecords.pop_back_val();
+    ModifiedRD->completeDefinition();
+
+    if (!ModifiedBases.empty())
+      ModifiedRD->setBases(ModifiedBases.data(), ModifiedBases.size());
+
+    return QualType(ModifiedRD->getTypeForDecl(), 0);
+  }
+  QualType getNewArrayType() {
+    return ModifiedArrayElementsOrArray.pop_back_val();
+  }
+};
+
+// A type to Create and own the FunctionDecl for the kernel.
+class SyclKernelDeclCreator : public SyclKernelFieldHandler {
+  FunctionDecl *KernelDecl = nullptr;
+  llvm::SmallVector<ParmVarDecl *, 8> Params;
+  Sema::ContextRAII FuncContext;
+  // Holds the last handled field's first parameter. This doesn't store an
+  // iterator as push_back invalidates iterators.
+  size_t LastParamIndex = 0;
+  // Keeps track of whether we are currently handling fields inside a struct.
+  int StructDepth = 0;
+
+  void addParam(const FieldDecl *FD, QualType FieldTy) {
+    ParamDesc newParamDesc = makeParamDesc(FD, FieldTy);
+    addParam(newParamDesc, FieldTy);
+  }
+
+  void addParam(const ParmVarDecl *PD, QualType ParamTy) {
+    ParamDesc newParamDesc = makeParamDesc(PD, ParamTy);
+    addParam(newParamDesc, ParamTy);
+  }
+
+  void addParam(const CXXBaseSpecifier &BS, QualType FieldTy) {
+    // TODO: There is no name for the base available, but duplicate names are
+    // seemingly already possible, so we'll give them all the same name for now.
+    // This only happens with the accessor types.
+    StringRef Name = "_arg__base";
+    ParamDesc newParamDesc =
+        makeParamDesc(SemaSYCLRef.getASTContext(), Name, FieldTy);
+    addParam(newParamDesc, FieldTy);
+  }
+  // Add a parameter with specified name and type
+  void addParam(StringRef Name, QualType ParamTy) {
+    ParamDesc newParamDesc =
+        makeParamDesc(SemaSYCLRef.getASTContext(), Name, ParamTy);
+    addParam(newParamDesc, ParamTy);
+  }
+
+  void addParam(ParamDesc newParamDesc, QualType FieldTy) {
+    // Create a new ParmVarDecl based on the new info.
+    ASTContext &Ctx = SemaSYCLRef.getASTContext();
+    auto *NewParam = ParmVarDecl::Create(
+        Ctx, KernelDecl, SourceLocation(), SourceLocation(),
+        std::get<1>(newParamDesc), std::get<0>(newParamDesc),
+        std::get<2>(newParamDesc), SC_None, /*DefArg*/ nullptr);
+    NewParam->setScopeInfo(0, Params.size());
+    NewParam->setIsUsed();
+
+    LastParamIndex = Params.size();
+    Params.push_back(NewParam);
+  }
+
+  // Handle accessor properties. If any properties were found in
+  // the accessor_property_list - add the appropriate attributes to ParmVarDecl.
+  void handleAccessorPropertyList(ParmVarDecl *Param,
+                                  const CXXRecordDecl *RecordDecl,
+                                  SourceLocation Loc) {
+    const auto *AccTy = cast<ClassTemplateSpecializationDecl>(RecordDecl);
+    if (AccTy->getTemplateArgs().size() < 6)
+      return;
+    const auto PropList = cast<TemplateArgument>(AccTy->getTemplateArgs()[5]);
+    QualType PropListTy = PropList.getAsType();
+    const auto *AccPropListDecl =
+        cast<ClassTemplateSpecializationDecl>(PropListTy->getAsRecordDecl());
+    const auto TemplArg = AccPropListDecl->getTemplateArgs()[0];
+    // Move through TemplateArgs list of a property list and search for
+    // properties. If found - apply the appropriate attribute to ParmVarDecl.
+    for (TemplateArgument::pack_iterator Prop = TemplArg.pack_begin();
+         Prop != TemplArg.pack_end(); ++Prop) {
+      QualType PropTy = Prop->getAsType();
+      if (isAccessorPropertyType(PropTy, SYCLTypeAttr::no_alias))
+        handleNoAliasProperty(Param, PropTy, Loc);
+      if (isAccessorPropertyType(PropTy, SYCLTypeAttr::buffer_location))
+        handleBufferLocationProperty(Param, PropTy, Loc);
+    }
+  }
+
+  void handleNoAliasProperty(ParmVarDecl *Param, QualType PropTy,
+                             SourceLocation Loc) {
+    ASTContext &Ctx = SemaSYCLRef.getASTContext();
+    Param->addAttr(RestrictAttr::CreateImplicit(Ctx, Loc));
+  }
+
+  // Obtain an integer value stored in a template parameter of buffer_location
+  // property to pass it to buffer_location kernel attribute
+  void handleBufferLocationProperty(ParmVarDecl *Param, QualType PropTy,
+                                    SourceLocation Loc) {
+    // If we have more than 1 buffer_location properties on a single
+    // accessor - emit an error
+    if (Param->hasAttr<SYCLIntelBufferLocationAttr>()) {
+      SemaSYCLRef.Diag(Loc, diag::err_sycl_compiletime_property_duplication)
+          << "buffer_location";
+      return;
+    }
+    ASTContext &Ctx = SemaSYCLRef.getASTContext();
+    const auto *PropDecl =
+        cast<ClassTemplateSpecializationDecl>(PropTy->getAsRecordDecl());
+    const auto BufferLoc = PropDecl->getTemplateArgs()[0];
+    int LocationID = static_cast<int>(BufferLoc.getAsIntegral().getExtValue());
+    Param->addAttr(
+        SYCLIntelBufferLocationAttr::CreateImplicit(Ctx, LocationID));
+  }
+
+  // Additional processing is required for accessor type.
+  void handleAccessorType(QualType FieldTy, const CXXRecordDecl *RecordDecl,
+                          SourceLocation Loc) {
+    handleAccessorPropertyList(Params.back(), RecordDecl, Loc);
+
+    // If "accessor" type check if read only
+    if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::accessor)) {
+      // Get access mode of accessor.
+      const auto *AccessorSpecializationDecl =
+          cast<ClassTemplateSpecializationDecl>(RecordDecl);
+      const TemplateArgument &AccessModeArg =
+          AccessorSpecializationDecl->getTemplateArgs().get(2);
+      if (isReadOnlyAccessor(AccessModeArg))
+        Params.back()->addAttr(SYCLAccessorReadonlyAttr::CreateImplicit(
+            SemaSYCLRef.getASTContext()));
+    }
+
+    // Add implicit attribute to parameter decl when it is a read only
+    // SYCL accessor.
+    Params.back()->addAttr(
+        SYCLAccessorPtrAttr::CreateImplicit(SemaSYCLRef.getASTContext()));
+  }
+
+  // All special SYCL objects must have __init method. We extract types for
+  // kernel parameters from __init method parameters. We will use __init method
+  // and kernel parameters which we build here to initialize special objects in
+  // the kernel body.
+  bool handleSpecialType(FieldDecl *FD, QualType FieldTy) {
+    const auto *RecordDecl = FieldTy->getAsCXXRecordDecl();
+    assert(RecordDecl && "The type must be a RecordDecl");
+    llvm::StringLiteral MethodName =
+        KernelDecl->hasAttr<SYCLSimdAttr>() && isSyclAccessorType(FieldTy)
+            ? InitESIMDMethodName
+            : InitMethodName;
+    CXXMethodDecl *InitMethod = getMethodByName(RecordDecl, MethodName);
+    assert(InitMethod && "The type must have the __init method");
+
+    // Don't do -1 here because we count on this to be the first parameter added
+    // (if any).
+    size_t ParamIndex = Params.size();
+    for (const ParmVarDecl *Param : InitMethod->parameters()) {
+      QualType ParamTy = Param->getType();
+      addParam(FD, ParamTy.getCanonicalType());
+
+      // Propagate add_ir_attributes_kernel_parameter attribute.
+      if (const auto *AddIRAttr =
+              Param->getAttr<SYCLAddIRAttributesKernelParameterAttr>())
+        Params.back()->addAttr(AddIRAttr->clone(SemaSYCLRef.getASTContext()));
+
+      // FIXME: This code is temporary, and will be removed once __init_esimd
+      // is removed and property list refactored.
+      // The function handleAccessorType includes a call to
+      // handleAccessorPropertyList. If new classes with property list are
+      // added, this code needs to be refactored to call
+      // handleAccessorPropertyList for each class which requires it.
+      if (ParamTy.getTypePtr()->isPointerType() && isSyclAccessorType(FieldTy))
+        handleAccessorType(FieldTy, RecordDecl, FD->getBeginLoc());
+    }
+    LastParamIndex = ParamIndex;
+    return true;
+  }
+
+  static void setKernelImplicitAttrs(ASTContext &Context, FunctionDecl *FD,
+                                     bool IsSIMDKernel) {
+    // Set implicit attributes.
+    FD->addAttr(OpenCLKernelAttr::CreateImplicit(Context));
+    FD->addAttr(ArtificialAttr::CreateImplicit(Context));
+    if (IsSIMDKernel)
+      FD->addAttr(SYCLSimdAttr::CreateImplicit(Context));
+  }
+
+  static FunctionDecl *createKernelDecl(ASTContext &Ctx, SourceLocation Loc,
+                                        bool IsInline, bool IsSIMDKernel) {
+    // Create this with no prototype, and we can fix this up after we've seen
+    // all the params.
+    FunctionProtoType::ExtProtoInfo Info(CC_OpenCLKernel);
+    QualType FuncType = Ctx.getFunctionType(Ctx.VoidTy, {}, Info);
+
+    FunctionDecl *FD = FunctionDecl::Create(
+        Ctx, Ctx.getTranslationUnitDecl(), Loc, Loc, DeclarationName(),
+        FuncType, Ctx.getTrivialTypeSourceInfo(Ctx.VoidTy), SC_None);
+    FD->setImplicitlyInline(IsInline);
+    setKernelImplicitAttrs(Ctx, FD, IsSIMDKernel);
+
+    // Add kernel to translation unit to see it in AST-dump.
+    Ctx.getTranslationUnitDecl()->addDecl(FD);
+    return FD;
+  }
+
+  // If the record has been marked with SYCLGenerateNewTypeAttr,
+  // it implies that it contains a pointer within. This function
+  // defines a PointerHandler visitor which visits this record
+  // recursively and modifies the address spaces of any pointer
+  // found as required, thereby generating a new record with all
+  // pointers in 'right' address space. PointerHandler.getNewRecordType()
+  // returns this generated type.
+  QualType GenerateNewRecordType(const CXXRecordDecl *RD) {
+    SyclKernelPointerHandler PointerHandler(SemaSYCLRef, RD);
+    KernelObjVisitor Visitor{SemaSYCLRef};
+    Visitor.VisitRecordBases(RD, PointerHandler);
+    Visitor.VisitRecordFields(RD, PointerHandler);
+    return PointerHandler.getNewRecordType();
+  }
+
+  // If the array has been marked with SYCLGenerateNewTypeAttr,
+  // it implies that this is an array of pointers, or an array
+  // of a type which contains pointers. This function generates
+  // a new array with all pointers in the required address space.
+  QualType GenerateNewArrayType(FieldDecl *FD, QualType FieldTy) {
+    const auto *Owner = dyn_cast<CXXRecordDecl>(FD->getParent());
+    SyclKernelPointerHandler PointerHandler(SemaSYCLRef);
+    KernelObjVisitor Visitor{SemaSYCLRef};
+    Visitor.visitArray(Owner, FD, FieldTy, PointerHandler);
+    return PointerHandler.getNewArrayType();
+  }
+
+public:
+  static constexpr const bool VisitInsideSimpleContainers = false;
+  SyclKernelDeclCreator(SemaSYCL &S, SourceLocation Loc, bool IsInline,
+                        bool IsSIMDKernel, FunctionDecl *SYCLKernel)
+      : SyclKernelFieldHandler(S),
+        KernelDecl(
+            createKernelDecl(S.getASTContext(), Loc, IsInline, IsSIMDKernel)),
+        FuncContext(SemaSYCLRef.SemaRef, KernelDecl) {
+    S.addSyclOpenCLKernel(SYCLKernel, KernelDecl);
+    for (const auto *IRAttr :
+         SYCLKernel->specific_attrs<SYCLAddIRAttributesFunctionAttr>()) {
+      KernelDecl->addAttr(IRAttr->clone(SemaSYCLRef.getASTContext()));
+    }
+  }
+
+  ~SyclKernelDeclCreator() {
+    ASTContext &Ctx = SemaSYCLRef.getASTContext();
+    FunctionProtoType::ExtProtoInfo Info(CC_OpenCLKernel);
+
+    SmallVector<QualType, 8> ArgTys;
+    std::transform(std::begin(Params), std::end(Params),
+                   std::back_inserter(ArgTys),
+                   [](const ParmVarDecl *PVD) { return PVD->getType(); });
+
+    QualType FuncType = Ctx.getFunctionType(Ctx.VoidTy, ArgTys, Info);
+    KernelDecl->setType(FuncType);
+    KernelDecl->setParams(Params);
+
+    // Make sure that this is marked as a kernel so that the code-gen can make
+    // decisions based on that. We cannot add this earlier, otherwise the call
+    // to TransformStmt in replaceWithLocalClone can diagnose something that got
+    // diagnosed on the actual kernel.
+    KernelDecl->addAttr(
+        SYCLKernelAttr::CreateImplicit(SemaSYCLRef.getASTContext()));
+
+    SemaSYCLRef.addSyclDeviceDecl(KernelDecl);
+  }
+
+  bool enterStruct(const CXXRecordDecl *, FieldDecl *, QualType) final {
+    ++StructDepth;
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
+    // TODO
+    // ++StructDepth;
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, FieldDecl *, QualType) final {
+    --StructDepth;
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
+    // TODO
+    // --StructDepth;
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                   QualType FieldTy) final {
+    ++StructDepth;
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                   QualType FieldTy) final {
+    --StructDepth;
+    return true;
+  }
+
+  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                             QualType FieldTy) final {
+    const auto *RecordDecl = FieldTy->getAsCXXRecordDecl();
+    assert(RecordDecl && "The type must be a RecordDecl");
+    llvm::StringLiteral MethodName =
+        KernelDecl->hasAttr<SYCLSimdAttr>() && isSyclAccessorType(FieldTy)
+            ? InitESIMDMethodName
+            : InitMethodName;
+    CXXMethodDecl *InitMethod = getMethodByName(RecordDecl, MethodName);
+    assert(InitMethod && "The type must have the __init method");
+
+    // Don't do -1 here because we count on this to be the first parameter added
+    // (if any).
+    size_t ParamIndex = Params.size();
+    for (const ParmVarDecl *Param : InitMethod->parameters()) {
+      QualType ParamTy = Param->getType();
+      addParam(BS, ParamTy.getCanonicalType());
+      // FIXME: This code is temporary, and will be removed once __init_esimd
+      // is removed and property list refactored.
+      // The function handleAccessorType includes a call to
+      // handleAccessorPropertyList. If new classes with property list are
+      // added, this code needs to be refactored to call
+      // handleAccessorPropertyList for each class which requires it.
+      if (ParamTy.getTypePtr()->isPointerType() && isSyclAccessorType(FieldTy))
+        handleAccessorType(FieldTy, RecordDecl, BS.getBeginLoc());
+    }
+    LastParamIndex = ParamIndex;
+    return true;
+  }
+
+  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
+    return handleSpecialType(FD, FieldTy);
+  }
+
+  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  RecordDecl *wrapField(FieldDecl *Field, QualType FieldTy) {
+    RecordDecl *WrapperClass =
+        SemaSYCLRef.getASTContext().buildImplicitRecord("__wrapper_class");
+    WrapperClass->startDefinition();
+    Field = FieldDecl::Create(
+        SemaSYCLRef.getASTContext(), WrapperClass, SourceLocation(),
+        SourceLocation(), /*Id=*/nullptr, FieldTy,
+        SemaSYCLRef.getASTContext().getTrivialTypeSourceInfo(FieldTy,
+                                                             SourceLocation()),
+        /*BW=*/nullptr, /*Mutable=*/false, /*InitStyle=*/ICIS_NoInit);
+    Field->setAccess(AS_public);
+    WrapperClass->addDecl(Field);
+    WrapperClass->completeDefinition();
+    return WrapperClass;
+  };
+
+  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
+    QualType ModTy = ModifyAddressSpace(SemaSYCLRef, FieldTy);
+    // When the kernel is generated, struct type kernel arguments are
+    // decomposed; i.e. the parameters of the kernel are the fields of the
+    // struct, and not the struct itself. This causes an error in the backend
+    // when the struct field is a pointer, since non-USM pointers cannot be
+    // passed directly. To work around this issue, all pointers inside the
+    // struct are wrapped in a generated '__wrapper_class'.
+    if (StructDepth) {
+      RecordDecl *WrappedPointer = wrapField(FD, ModTy);
+      ModTy = SemaSYCLRef.getASTContext().getRecordType(WrappedPointer);
+    }
+
+    addParam(FD, ModTy);
+    return true;
+  }
+
+  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
+    QualType ModTy = ModifyAddressSpace(SemaSYCLRef, ParamTy);
+    addParam(PD, ModTy);
+    return true;
+  }
+
+  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
+    QualType ArrayTy = FieldTy;
+
+    // This is an array of pointers or an array of a type with pointer.
+    if (FD->hasAttr<SYCLGenerateNewTypeAttr>())
+      ArrayTy = GenerateNewArrayType(FD, FieldTy);
+
+    // Arrays are wrapped in a struct since they cannot be passed directly.
+    RecordDecl *WrappedArray = wrapField(FD, ArrayTy);
+    addParam(FD, SemaSYCLRef.getASTContext().getRecordType(WrappedArray));
+    return true;
+  }
+
+  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
+    addParam(FD, FieldTy);
+    return true;
+  }
+
+  bool handleScalarType(ParmVarDecl *PD, QualType ParamTy) final {
+    addParam(PD, ParamTy);
+    return true;
+  }
+
+  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
+    StringRef Name = "_arg__sycl_functor";
+    addParam(Name, Ty);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *RD, FieldDecl *FD,
+                             QualType Ty) final {
+    // This is a field which should not be decomposed.
+    CXXRecordDecl *FieldRecordDecl = Ty->getAsCXXRecordDecl();
+    assert(FieldRecordDecl && "Type must be a C++ record type");
+    // Check if we need to generate a new type for this record,
+    // i.e. this record contains pointers.
+    if (FieldRecordDecl->hasAttr<SYCLGenerateNewTypeAttr>())
+      addParam(FD, GenerateNewRecordType(FieldRecordDecl));
+    else
+      addParam(FD, Ty);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *RD, ParmVarDecl *PD,
+                             QualType ParamTy) final {
+    // This is a struct parameter which should not be decomposed.
+    CXXRecordDecl *ParamRecordDecl = ParamTy->getAsCXXRecordDecl();
+    assert(ParamRecordDecl && "Type must be a C++ record type");
+    // Check if we need to generate a new type for this record,
+    // i.e. this record contains pointers.
+    if (ParamRecordDecl->hasAttr<SYCLGenerateNewTypeAttr>())
+      addParam(PD, GenerateNewRecordType(ParamRecordDecl));
+    else
+      addParam(PD, ParamTy);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *Base,
+                             const CXXBaseSpecifier &BS, QualType Ty) final {
+    // This is a base class which should not be decomposed.
+    CXXRecordDecl *BaseRecordDecl = Ty->getAsCXXRecordDecl();
+    assert(BaseRecordDecl && "Type must be a C++ record type");
+    // Check if we need to generate a new type for this record,
+    // i.e. this record contains pointers.
+    if (BaseRecordDecl->hasAttr<SYCLGenerateNewTypeAttr>())
+      addParam(BS, GenerateNewRecordType(BaseRecordDecl));
+    else
+      addParam(BS, Ty);
+    return true;
+  }
+
+  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
+    return handleScalarType(FD, FieldTy);
+  }
+
+  bool handleUnionType(ParmVarDecl *PD, QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  // Generate kernel argument to initialize specialization constants.
+  void handleSyclKernelHandlerType() {
+    ASTContext &Context = SemaSYCLRef.getASTContext();
+    StringRef Name = "_arg__specialization_constants_buffer";
+    addParam(Name, Context.getPointerType(Context.getAddrSpaceQualType(
+                       Context.CharTy, LangAS::sycl_global)));
+  }
+
+  void setBody(CompoundStmt *KB) { KernelDecl->setBody(KB); }
+
+  FunctionDecl *getKernelDecl() { return KernelDecl; }
+
+  llvm::ArrayRef<ParmVarDecl *> getParamVarDeclsForCurrentField() {
+    return ArrayRef<ParmVarDecl *>(std::begin(Params) + LastParamIndex,
+                                   std::end(Params));
+  }
+};
+
+// This Visitor traverses the AST of the function with
+// `sycl_kernel` attribute and returns the version of “operator()()” that is
+// called by KernelFunc. There will only be one call to KernelFunc in that
+// AST because the DPC++ headers are structured such that the user’s
+// kernel function is only called once. This ensures that the correct
+// “operator()()” function call is returned, when a named function object used
+// to define a kernel has more than one “operator()()” calls defined in it. For
+// example, in the code below, 'operator()(sycl::id<1> id)' is returned based on
+// the 'parallel_for' invocation which takes a 'sycl::range<1>(16)' argument.
+//   class MyKernel {
+//    public:
+//      void operator()() const {
+//        // code
+//      }
+//
+//      [[intel::reqd_sub_group_size(4)]] void operator()(sycl::id<1> id) const
+//      {
+//        // code
+//      }
+//    };
+//
+//    int main() {
+//
+//    Q.submit([&](sycl::handler& cgh) {
+//      MyKernel kernelFunctorObject;
+//      cgh.parallel_for(sycl::range<1>(16), kernelFunctorObject);
+//    });
+//      return 0;
+//    }
+
+class KernelCallOperatorVisitor
+    : public RecursiveASTVisitor<KernelCallOperatorVisitor> {
+
+  FunctionDecl *KernelCallerFunc;
+
+public:
+  CXXMethodDecl *CallOperator = nullptr;
+  const CXXRecordDecl *KernelObj;
+
+  KernelCallOperatorVisitor(FunctionDecl *KernelCallerFunc,
+                            const CXXRecordDecl *KernelObj)
+      : KernelCallerFunc(KernelCallerFunc), KernelObj(KernelObj) {}
+
+  bool VisitCallExpr(CallExpr *CE) {
+    Decl *CalleeDecl = CE->getCalleeDecl();
+    if (isa_and_nonnull<CXXMethodDecl>(CalleeDecl)) {
+      CXXMethodDecl *MD = cast<CXXMethodDecl>(CalleeDecl);
+      if (MD->getOverloadedOperator() == OO_Call &&
+          MD->getParent() == KernelObj) {
+        CallOperator = MD;
+      }
+    }
+    return true;
+  }
+
+  CXXMethodDecl *getCallOperator() {
+    if (CallOperator)
+      return CallOperator;
+
+    TraverseDecl(KernelCallerFunc);
+    return CallOperator;
+  }
+};
+
+class ESIMDKernelDiagnostics : public SyclKernelFieldHandler {
+
+  SourceLocation KernelLoc;
+  bool IsESIMD = false;
+
+  bool handleSpecialType(QualType FieldTy) {
+    const CXXRecordDecl *RecordDecl = FieldTy->getAsCXXRecordDecl();
+
+    if (IsESIMD && !isSyclAccessorType(FieldTy))
+      return SemaSYCLRef.Diag(KernelLoc,
+                              diag::err_sycl_esimd_not_supported_for_type)
+             << RecordDecl;
+    return true;
+  }
+
+public:
+  ESIMDKernelDiagnostics(SemaSYCL &S, SourceLocation Loc, bool IsESIMD)
+      : SyclKernelFieldHandler(S), KernelLoc(Loc), IsESIMD(IsESIMD) {}
+
+  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
+    return handleSpecialType(FieldTy);
+  }
+
+  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                             QualType FieldTy) final {
+    return handleSpecialType(FieldTy);
+  }
+
+  using SyclKernelFieldHandler::handleSyclSpecialType;
+};
+
+class SyclKernelArgsSizeChecker : public SyclKernelFieldHandler {
+  SourceLocation KernelLoc;
+  unsigned SizeOfParams = 0;
+  bool IsESIMD = false;
+
+  void addParam(QualType ArgTy) {
+    SizeOfParams +=
+        SemaSYCLRef.getASTContext().getTypeSizeInChars(ArgTy).getQuantity();
+  }
+
+  bool handleSpecialType(QualType FieldTy) {
+    const CXXRecordDecl *RecordDecl = FieldTy->getAsCXXRecordDecl();
+    assert(RecordDecl && "The type must be a RecordDecl");
+    llvm::StringLiteral MethodName = (IsESIMD && isSyclAccessorType(FieldTy))
+                                         ? InitESIMDMethodName
+                                         : InitMethodName;
+    CXXMethodDecl *InitMethod = getMethodByName(RecordDecl, MethodName);
+    assert(InitMethod && "The type must have the __init method");
+    for (const ParmVarDecl *Param : InitMethod->parameters())
+      addParam(Param->getType());
+    return true;
+  }
+
+public:
+  static constexpr const bool VisitInsideSimpleContainers = false;
+  SyclKernelArgsSizeChecker(SemaSYCL &S, SourceLocation Loc, bool IsESIMD)
+      : SyclKernelFieldHandler(S), KernelLoc(Loc), IsESIMD(IsESIMD) {}
+
+  ~SyclKernelArgsSizeChecker() {
+    if (SizeOfParams > MaxKernelArgsSize)
+      SemaSYCLRef.Diag(KernelLoc, diag::warn_sycl_kernel_too_big_args)
+          << SizeOfParams << MaxKernelArgsSize;
+  }
+
+  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
+    return handleSpecialType(FieldTy);
+  }
+
+  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                             QualType FieldTy) final {
+    return handleSpecialType(FieldTy);
+  }
+
+  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
+    addParam(FieldTy);
+    return true;
+  }
+
+  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
+    addParam(ParamTy);
+    return true;
+  }
+
+  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
+    addParam(FieldTy);
+    return true;
+  }
+
+  bool handleScalarType(ParmVarDecl *PD, QualType ParamTy) final {
+    addParam(ParamTy);
+    return true;
+  }
+
+  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
+    addParam(FieldTy);
+    return true;
+  }
+
+  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
+    addParam(Ty);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
+                             QualType Ty) final {
+    addParam(Ty);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, ParmVarDecl *,
+                             QualType ParamTy) final {
+    addParam(ParamTy);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *Base,
+                             const CXXBaseSpecifier &BS, QualType Ty) final {
+    addParam(Ty);
+    return true;
+  }
+
+  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
+    return handleScalarType(FD, FieldTy);
+  }
+
+  bool handleUnionType(ParmVarDecl *PD, QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+};
+
+std::string getKernelArgDesc(StringRef KernelArgDescription) {
+  if (KernelArgDescription == "")
+    return "";
+  return ("Compiler generated argument for " + KernelArgDescription + ",")
+      .str();
+}
+
+class SyclOptReportCreator : public SyclKernelFieldHandler {
+  SyclKernelDeclCreator &DC;
+  SourceLocation KernelInvocationLoc;
+
+  void addParam(const FieldDecl *KernelArg, QualType KernelArgType,
+                StringRef KernelArgDescription,
+                bool IsCompilerGeneratedType = false) {
+    StringRef NameToEmitInDescription = KernelArg->getName();
+    const RecordDecl *KernelArgParent = KernelArg->getParent();
+    if (KernelArgParent && KernelArgDescription == "decomposed struct/class")
+      NameToEmitInDescription = KernelArgParent->getName();
+
+    unsigned KernelArgSize = SemaSYCLRef.getASTContext()
+                                 .getTypeSizeInChars(KernelArgType)
+                                 .getQuantity();
+
+    SemaSYCLRef.getDiagnostics().getSYCLOptReport().AddKernelArgs(
+        DC.getKernelDecl(), NameToEmitInDescription,
+        IsCompilerGeneratedType ? "Compiler generated"
+                                : KernelArgType.getAsString(),
+        KernelInvocationLoc, KernelArgSize,
+        getKernelArgDesc(KernelArgDescription),
+        (KernelArgDescription == "decomposed struct/class")
+            ? ("Field:" + KernelArg->getName().str() + ", ")
+            : "");
+  }
+
+  void addParam(const FieldDecl *FD, QualType FieldTy) {
+    std::string KernelArgDescription = "";
+    const RecordDecl *RD = FD->getParent();
+    if (RD && RD->hasAttr<SYCLRequiresDecompositionAttr>())
+      KernelArgDescription = "decomposed struct/class";
+
+    addParam(FD, FieldTy, KernelArgDescription);
+  }
+
+  // Handles base classes.
+  void addParam(const CXXBaseSpecifier &, QualType KernelArgType,
+                StringRef KernelArgDescription,
+                bool IsCompilerGeneratedType = false) {
+    unsigned KernelArgSize = SemaSYCLRef.getASTContext()
+                                 .getTypeSizeInChars(KernelArgType)
+                                 .getQuantity();
+    SemaSYCLRef.getDiagnostics().getSYCLOptReport().AddKernelArgs(
+        DC.getKernelDecl(), KernelArgType.getAsString(),
+        IsCompilerGeneratedType ? "Compiler generated"
+                                : KernelArgType.getAsString(),
+        KernelInvocationLoc, KernelArgSize,
+        getKernelArgDesc(KernelArgDescription), "");
+  }
+
+  // Handles specialization constants.
+  void addParam(QualType KernelArgType, std::string KernelArgDescription) {
+    unsigned KernelArgSize = SemaSYCLRef.getASTContext()
+                                 .getTypeSizeInChars(KernelArgType)
+                                 .getQuantity();
+    SemaSYCLRef.getDiagnostics().getSYCLOptReport().AddKernelArgs(
+        DC.getKernelDecl(), "", KernelArgType.getAsString(),
+        KernelInvocationLoc, KernelArgSize,
+        getKernelArgDesc(KernelArgDescription), "");
+  }
+
+public:
+  static constexpr const bool VisitInsideSimpleContainers = false;
+  SyclOptReportCreator(SemaSYCL &S, SyclKernelDeclCreator &DC,
+                       SourceLocation Loc)
+      : SyclKernelFieldHandler(S), DC(DC), KernelInvocationLoc(Loc) {}
+
+  using SyclKernelFieldHandler::handleSyclSpecialType;
+  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
+    for (const auto *Param : DC.getParamVarDeclsForCurrentField())
+      addParam(FD, Param->getType(), FieldTy.getAsString());
+    return true;
+  }
+
+  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                             QualType FieldTy) final {
+    std::string KernelArgDescription = "base class " + FieldTy.getAsString();
+    for (const auto *Param : DC.getParamVarDeclsForCurrentField()) {
+      QualType KernelArgType = Param->getType();
+      unsigned KernelArgSize = SemaSYCLRef.getASTContext()
+                                   .getTypeSizeInChars(KernelArgType)
+                                   .getQuantity();
+      SemaSYCLRef.getDiagnostics().getSYCLOptReport().AddKernelArgs(
+          DC.getKernelDecl(), FieldTy.getAsString(),
+          KernelArgType.getAsString(), KernelInvocationLoc, KernelArgSize,
+          getKernelArgDesc(KernelArgDescription), "");
+    }
+    return true;
+  }
+
+  using SyclKernelFieldHandler::handlePointerType;
+  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
+    std::string KernelArgDescription = "";
+    bool IsCompilerGeneratedType = false;
+    ParmVarDecl *KernelParameter = DC.getParamVarDeclsForCurrentField()[0];
+    // Compiler generated openCL kernel argument for current pointer field
+    // is not a pointer. This means we are processing a nested pointer and
+    // the openCL kernel argument is of type __wrapper_class.
+    if (!KernelParameter->getType()->isPointerType()) {
+      KernelArgDescription = "nested pointer";
+      IsCompilerGeneratedType = true;
+    }
+
+    for (const auto *Param : DC.getParamVarDeclsForCurrentField())
+      addParam(FD, Param->getType(), KernelArgDescription,
+               IsCompilerGeneratedType);
+    return true;
+  }
+
+  using SyclKernelFieldHandler::handleScalarType;
+  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
+    addParam(FD, FieldTy);
+    return true;
+  }
+
+  using SyclKernelFieldHandler::handleSimpleArrayType;
+  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
+    // Simple arrays are always wrapped.
+    for (const auto *Param : DC.getParamVarDeclsForCurrentField())
+      addParam(FD, Param->getType(), "array", /*IsCompilerGeneratedType*/ true);
+    return true;
+  }
+
+  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
+    addParam(DC.getParamVarDeclsForCurrentField()[0]->getType(),
+             "SYCL Functor");
+    return true;
+  }
+
+  using SyclKernelFieldHandler::handleNonDecompStruct;
+  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
+                             QualType Ty) final {
+    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
+    assert(RD && "Type must be a C++ record type");
+    if (RD->hasAttr<SYCLGenerateNewTypeAttr>())
+      addParam(FD, Ty, "object with pointer", /*IsCompilerGeneratedType*/ true);
+    else
+      addParam(FD, Ty);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                             QualType Ty) final {
+    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
+    assert(RD && "Type must be a C++ record type");
+    if (RD->hasAttr<SYCLGenerateNewTypeAttr>())
+      addParam(BS, Ty, "base class with pointer",
+               /*IsCompilerGeneratedType*/ true);
+    else
+      addParam(BS, Ty, "base class");
+    return true;
+  }
+
+  using SyclKernelFieldHandler::handleUnionType;
+  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
+    return handleScalarType(FD, FieldTy);
+  }
+
+  void handleSyclKernelHandlerType() {
+    addParam(DC.getParamVarDeclsForCurrentField()[0]->getType(),
+             "SYCL2020 specialization constant");
+  }
+};
+
+static bool isESIMDKernelType(CXXMethodDecl *CallOperator) {
+  return (CallOperator != nullptr) && CallOperator->hasAttr<SYCLSimdAttr>();
+}
+
+class SyclKernelBodyCreator : public SyclKernelFieldHandler {
+  bool UseTopLevelKernelObj;
+  SyclKernelDeclCreator &DeclCreator;
+  llvm::SmallVector<Stmt *, 16> BodyStmts;
+  llvm::SmallVector<InitListExpr *, 16> CollectionInitExprs;
+  llvm::SmallVector<Stmt *, 16> FinalizeStmts;
+  // This collection contains the information required to add/remove information
+  // about arrays as we enter them.  The InitializedEntity component is
+  // necessary for initializing child members.  uin64_t is the index of the
+  // current element being worked on, which is updated every time we visit
+  // nextElement.
+  llvm::SmallVector<std::pair<InitializedEntity, uint64_t>, 8> ArrayInfos;
+  VarDecl *KernelObjClone;
+  std::optional<InitializedEntity> VarEntity;
+  llvm::SmallVector<Expr *, 16> MemberExprBases;
+  llvm::SmallVector<Expr *, 16> ArrayParamBases;
+  FunctionDecl *KernelCallerFunc;
+  SourceLocation KernelCallerSrcLoc; // KernelCallerFunc source location.
+  // Contains a count of how many containers we're in.  This is used by the
+  // pointer-struct-wrapping code to ensure that we don't try to wrap
+  // top-level pointers.
+  uint64_t StructDepth = 0;
+  VarDecl *KernelHandlerClone = nullptr;
+  bool IsESIMD = false;
+  CXXMethodDecl *CallOperator = nullptr;
+
+  Stmt *replaceWithLocalClone(ParmVarDecl *OriginalParam, VarDecl *LocalClone,
+                              Stmt *FunctionBody) {
+    // DeclRefExpr with valid source location but with decl which is not marked
+    // as used is invalid.
+    LocalClone->setIsUsed();
+    std::pair<DeclaratorDecl *, DeclaratorDecl *> MappingPair =
+        std::make_pair(OriginalParam, LocalClone);
+    KernelBodyTransform KBT(MappingPair, SemaSYCLRef.SemaRef);
+    return KBT.TransformStmt(FunctionBody).get();
+  }
+
+  // Using the statements/init expressions that we've created, this generates
+  // the kernel body compound stmt. CompoundStmt needs to know its number of
+  // statements in advance to allocate it, so we cannot do this as we go along.
+  CompoundStmt *createKernelBody() {
+    // Push the Kernel function scope to ensure the scope isn't empty
+    SemaSYCLRef.SemaRef.PushFunctionScope();
+
+    if (!UseTopLevelKernelObj) {
+      // Initialize kernel object local clone
+      assert(CollectionInitExprs.size() == 1 &&
+             "Should have been popped down to just the first one");
+      KernelObjClone->setInit(CollectionInitExprs.back());
+    }
+
+    // Replace references to the kernel object in kernel body, to use the
+    // compiler generated local clone
+    Stmt *NewBody =
+        replaceWithLocalClone(KernelCallerFunc->getParamDecl(0), KernelObjClone,
+                              KernelCallerFunc->getBody());
+
+    // If kernel_handler argument is passed by SYCL kernel, replace references
+    // to this argument in kernel body, to use the compiler generated local
+    // clone
+    if (ParmVarDecl *KernelHandlerParam =
+            getSyclKernelHandlerArg(KernelCallerFunc))
+      NewBody = replaceWithLocalClone(KernelHandlerParam, KernelHandlerClone,
+                                      NewBody);
+
+    // Use transformed body (with clones) as kernel body
+    BodyStmts.push_back(NewBody);
+
+    BodyStmts.insert(BodyStmts.end(), FinalizeStmts.begin(),
+                     FinalizeStmts.end());
+
+    return CompoundStmt::Create(SemaSYCLRef.getASTContext(), BodyStmts,
+                                FPOptionsOverride(), {}, {});
+  }
+
+  void annotateHierarchicalParallelismAPICalls() {
+    // Is this a hierarchical parallelism kernel invocation?
+    if (getKernelInvocationKind(KernelCallerFunc) != InvokeParallelForWorkGroup)
+      return;
+
+    // Mark kernel object with work-group scope attribute to avoid work-item
+    // scope memory allocation.
+    KernelObjClone->addAttr(SYCLScopeAttr::CreateImplicit(
+        SemaSYCLRef.getASTContext(), SYCLScopeAttr::Level::WorkGroup));
+
+    assert(CallOperator && "non callable object is passed as kernel obj");
+    // Mark the function that it "works" in a work group scope:
+    // NOTE: In case of wait_for the marker call itself is
+    // marked with work item scope attribute, here  the '()' operator of the
+    // object passed as parameter is marked. This is an optimization -
+    // there are a lot of locals created at parallel_for_work_group
+    // scope before calling the lambda - it is more efficient to have
+    // all of them in the private address space rather then sharing via
+    // the local AS. See parallel_for_work_group implementation in the
+    // SYCL headers.
+    if (!CallOperator->hasAttr<SYCLScopeAttr>()) {
+      CallOperator->addAttr(SYCLScopeAttr::CreateImplicit(
+          SemaSYCLRef.getASTContext(), SYCLScopeAttr::Level::WorkGroup));
+      // Search and mark wait_for calls:
+      MarkWIScopeFnVisitor MarkWIScope(SemaSYCLRef.getASTContext());
+      MarkWIScope.TraverseDecl(CallOperator);
+      // Now mark local variables declared in the PFWG lambda with work group
+      // scope attribute
+      addScopeAttrToLocalVars(*CallOperator);
+    }
+  }
+
+  // Creates a DeclRefExpr to the ParmVar that represents the current field.
+  Expr *createParamReferenceExpr() {
+    ParmVarDecl *KernelParameter =
+        DeclCreator.getParamVarDeclsForCurrentField()[0];
+
+    QualType ParamType = KernelParameter->getOriginalType();
+    Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+        KernelParameter, ParamType, VK_LValue, KernelCallerSrcLoc);
+    return DRE;
+  }
+
+  // Creates a DeclRefExpr to the ParmVar that represents the current pointer
+  // field.
+  Expr *createPointerParamReferenceExpr(QualType PointerTy, bool Wrapped) {
+    ParmVarDecl *KernelParameter =
+        DeclCreator.getParamVarDeclsForCurrentField()[0];
+
+    QualType ParamType = KernelParameter->getOriginalType();
+    Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+        KernelParameter, ParamType, VK_LValue, KernelCallerSrcLoc);
+
+    // Struct Type kernel arguments are decomposed. The pointer fields are
+    // then wrapped inside a compiler generated struct. Therefore when
+    // generating the initializers, we have to 'unwrap' the pointer.
+    if (Wrapped) {
+      CXXRecordDecl *WrapperStruct = ParamType->getAsCXXRecordDecl();
+      // Pointer field wrapped inside __wrapper_class
+      FieldDecl *Pointer = *(WrapperStruct->field_begin());
+      DRE = buildMemberExpr(DRE, Pointer);
+      ParamType = Pointer->getType();
+    }
+
+    DRE = ImplicitCastExpr::Create(SemaSYCLRef.getASTContext(), ParamType,
+                                   CK_LValueToRValue, DRE, /*BasePath=*/nullptr,
+                                   VK_PRValue, FPOptionsOverride());
+
+    if (PointerTy->getPointeeType().getAddressSpace() !=
+        ParamType->getPointeeType().getAddressSpace())
+      DRE = ImplicitCastExpr::Create(SemaSYCLRef.getASTContext(), PointerTy,
+                                     CK_AddressSpaceConversion, DRE, nullptr,
+                                     VK_PRValue, FPOptionsOverride());
+
+    return DRE;
+  }
+
+  Expr *createSimpleArrayParamReferenceExpr(QualType ArrayTy) {
+    ParmVarDecl *KernelParameter =
+        DeclCreator.getParamVarDeclsForCurrentField()[0];
+    QualType ParamType = KernelParameter->getOriginalType();
+    Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+        KernelParameter, ParamType, VK_LValue, KernelCallerSrcLoc);
+
+    // Unwrap the array.
+    CXXRecordDecl *WrapperStruct = ParamType->getAsCXXRecordDecl();
+    FieldDecl *ArrayField = *(WrapperStruct->field_begin());
+    return buildMemberExpr(DRE, ArrayField);
+  }
+
+  // Creates an initialized entity for a field/item. In the case where this is a
+  // field, returns a normal member initializer, if we're in a sub-array of a MD
+  // array, returns an element initializer.
+  InitializedEntity getFieldEntity(FieldDecl *FD, QualType Ty) {
+    if (isArrayElement(FD, Ty))
+      return InitializedEntity::InitializeElement(SemaSYCLRef.getASTContext(),
+                                                  ArrayInfos.back().second,
+                                                  ArrayInfos.back().first);
+    return InitializedEntity::InitializeMember(FD, &VarEntity.value());
+  }
+
+  void addFieldInit(FieldDecl *FD, QualType Ty, MultiExprArg ParamRef) {
+    InitializationKind InitKind =
+        InitializationKind::CreateCopy(KernelCallerSrcLoc, KernelCallerSrcLoc);
+    addFieldInit(FD, Ty, ParamRef, InitKind);
+  }
+
+  void addFieldInit(FieldDecl *FD, QualType Ty, MultiExprArg ParamRef,
+                    InitializationKind InitKind) {
+    addFieldInit(FD, Ty, ParamRef, InitKind, getFieldEntity(FD, Ty));
+  }
+
+  void addFieldInit(FieldDecl *FD, QualType Ty, MultiExprArg ParamRef,
+                    InitializationKind InitKind, InitializedEntity Entity) {
+    InitializationSequence InitSeq(SemaSYCLRef.SemaRef, Entity, InitKind,
+                                   ParamRef);
+    ExprResult Init =
+        InitSeq.Perform(SemaSYCLRef.SemaRef, Entity, InitKind, ParamRef);
+
+    InitListExpr *ParentILE = CollectionInitExprs.back();
+    ParentILE->updateInit(SemaSYCLRef.getASTContext(), ParentILE->getNumInits(),
+                          Init.get());
+  }
+
+  void addBaseInit(const CXXBaseSpecifier &BS, QualType Ty,
+                   InitializationKind InitKind) {
+    InitializedEntity Entity = InitializedEntity::InitializeBase(
+        SemaSYCLRef.getASTContext(), &BS, /*IsInheritedVirtualBase*/ false,
+        &VarEntity.value());
+    InitializationSequence InitSeq(SemaSYCLRef.SemaRef, Entity, InitKind,
+                                   std::nullopt);
+    ExprResult Init =
+        InitSeq.Perform(SemaSYCLRef.SemaRef, Entity, InitKind, std::nullopt);
+
+    InitListExpr *ParentILE = CollectionInitExprs.back();
+    ParentILE->updateInit(SemaSYCLRef.getASTContext(), ParentILE->getNumInits(),
+                          Init.get());
+  }
+
+  void addBaseInit(const CXXBaseSpecifier &BS, QualType Ty,
+                   InitializationKind InitKind, MultiExprArg Args) {
+    InitializedEntity Entity = InitializedEntity::InitializeBase(
+        SemaSYCLRef.getASTContext(), &BS, /*IsInheritedVirtualBase*/ false,
+        &VarEntity.value());
+    InitializationSequence InitSeq(SemaSYCLRef.SemaRef, Entity, InitKind, Args);
+    ExprResult Init =
+        InitSeq.Perform(SemaSYCLRef.SemaRef, Entity, InitKind, Args);
+
+    InitListExpr *ParentILE = CollectionInitExprs.back();
+    ParentILE->updateInit(SemaSYCLRef.getASTContext(), ParentILE->getNumInits(),
+                          Init.get());
+  }
+
+  void addSimpleBaseInit(const CXXBaseSpecifier &BS, QualType Ty) {
+    InitializationKind InitKind =
+        InitializationKind::CreateCopy(KernelCallerSrcLoc, KernelCallerSrcLoc);
+
+    InitializedEntity Entity = InitializedEntity::InitializeBase(
+        SemaSYCLRef.getASTContext(), &BS, /*IsInheritedVirtualBase*/ false,
+        &VarEntity.value());
+
+    Expr *ParamRef = createParamReferenceExpr();
+    InitializationSequence InitSeq(SemaSYCLRef.SemaRef, Entity, InitKind,
+                                   ParamRef);
+    ExprResult Init =
+        InitSeq.Perform(SemaSYCLRef.SemaRef, Entity, InitKind, ParamRef);
+
+    InitListExpr *ParentILE = CollectionInitExprs.back();
+    ParentILE->updateInit(SemaSYCLRef.getASTContext(), ParentILE->getNumInits(),
+                          Init.get());
+  }
+
+  // Adds an initializer that handles a simple initialization of a field.
+  void addSimpleFieldInit(FieldDecl *FD, QualType Ty) {
+    Expr *ParamRef = createParamReferenceExpr();
+    addFieldInit(FD, Ty, ParamRef);
+  }
+
+  Expr *createGetAddressOf(Expr *E) {
+    return UnaryOperator::Create(
+        SemaSYCLRef.getASTContext(), E, UO_AddrOf,
+        SemaSYCLRef.getASTContext().getPointerType(E->getType()), VK_PRValue,
+        OK_Ordinary, KernelCallerSrcLoc, false,
+        SemaSYCLRef.SemaRef.CurFPFeatureOverrides());
+  }
+
+  Expr *createDerefOp(Expr *E) {
+    return UnaryOperator::Create(SemaSYCLRef.getASTContext(), E, UO_Deref,
+                                 E->getType()->getPointeeType(), VK_LValue,
+                                 OK_Ordinary, KernelCallerSrcLoc, false,
+                                 SemaSYCLRef.SemaRef.CurFPFeatureOverrides());
+  }
+
+  Expr *createReinterpretCastExpr(Expr *E, QualType To) {
+    return CXXReinterpretCastExpr::Create(
+        SemaSYCLRef.getASTContext(), To, VK_PRValue, CK_BitCast, E,
+        /*Path=*/nullptr,
+        SemaSYCLRef.getASTContext().getTrivialTypeSourceInfo(To),
+        SourceLocation(), SourceLocation(), SourceRange());
+  }
+
+  void handleGeneratedType(FieldDecl *FD, QualType Ty) {
+    // Equivalent of the following code is generated here:
+    // void ocl_kernel(__generated_type GT) {
+    //   Kernel KernelObjClone { *(reinterpret_cast<UsersType*>(&GT)) };
+    // }
+
+    Expr *RCE = createReinterpretCastExpr(
+        createGetAddressOf(createParamReferenceExpr()),
+        SemaSYCLRef.getASTContext().getPointerType(Ty));
+    Expr *Initializer = createDerefOp(RCE);
+    addFieldInit(FD, Ty, Initializer);
+  }
+
+  void handleGeneratedType(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
+                           QualType Ty) {
+    // Equivalent of the following code is generated here:
+    // void ocl_kernel(__generated_type GT) {
+    //   Kernel KernelObjClone { *(reinterpret_cast<UsersType*>(&GT)) };
+    // }
+    Expr *RCE = createReinterpretCastExpr(
+        createGetAddressOf(createParamReferenceExpr()),
+        SemaSYCLRef.getASTContext().getPointerType(Ty));
+    Expr *Initializer = createDerefOp(RCE);
+    InitializationKind InitKind =
+        InitializationKind::CreateCopy(KernelCallerSrcLoc, KernelCallerSrcLoc);
+    addBaseInit(BS, Ty, InitKind, Initializer);
+  }
+
+  MemberExpr *buildMemberExpr(Expr *Base, ValueDecl *Member) {
+    DeclAccessPair MemberDAP = DeclAccessPair::make(Member, AS_none);
+    MemberExpr *Result = SemaSYCLRef.SemaRef.BuildMemberExpr(
+        Base, /*IsArrow */ false, KernelCallerSrcLoc, NestedNameSpecifierLoc(),
+        KernelCallerSrcLoc, Member, MemberDAP,
+        /*HadMultipleCandidates*/ false,
+        DeclarationNameInfo(Member->getDeclName(), KernelCallerSrcLoc),
+        Member->getType(), VK_LValue, OK_Ordinary);
+    return Result;
+  }
+
+  void addFieldMemberExpr(FieldDecl *FD, QualType Ty) {
+    if (!isArrayElement(FD, Ty))
+      MemberExprBases.push_back(buildMemberExpr(MemberExprBases.back(), FD));
+  }
+
+  void removeFieldMemberExpr(const FieldDecl *FD, QualType Ty) {
+    if (!isArrayElement(FD, Ty))
+      MemberExprBases.pop_back();
+  }
+
+  void createSpecialMethodCall(const CXXRecordDecl *RD, StringRef MethodName,
+                               SmallVectorImpl<Stmt *> &AddTo) {
+    CXXMethodDecl *Method = getMethodByName(RD, MethodName);
+    if (!Method)
+      return;
+
+    unsigned NumParams = Method->getNumParams();
+    llvm::SmallVector<Expr *, 4> ParamDREs(NumParams);
+    llvm::ArrayRef<ParmVarDecl *> KernelParameters =
+        DeclCreator.getParamVarDeclsForCurrentField();
+    for (size_t I = 0; I < NumParams; ++I) {
+      QualType ParamType = KernelParameters[I]->getOriginalType();
+      ParamDREs[I] = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+          KernelParameters[I], ParamType, VK_LValue, KernelCallerSrcLoc);
+    }
+
+    MemberExpr *MethodME = buildMemberExpr(MemberExprBases.back(), Method);
+
+    QualType ResultTy = Method->getReturnType();
+    ExprValueKind VK = Expr::getValueKindForType(ResultTy);
+    ResultTy = ResultTy.getNonLValueExprType(SemaSYCLRef.getASTContext());
+    llvm::SmallVector<Expr *, 4> ParamStmts;
+    const auto *Proto = cast<FunctionProtoType>(Method->getType());
+    SemaSYCLRef.SemaRef.GatherArgumentsForCall(KernelCallerSrcLoc, Method,
+                                               Proto, 0, ParamDREs, ParamStmts);
+    // [kernel_obj or wrapper object].accessor.__init(_ValueType*,
+    // range<int>, range<int>, id<int>)
+    AddTo.push_back(CXXMemberCallExpr::Create(
+        SemaSYCLRef.getASTContext(), MethodME, ParamStmts, ResultTy, VK,
+        KernelCallerSrcLoc, FPOptionsOverride()));
+  }
+
+  // Creates an empty InitListExpr of the correct number of child-inits
+  // of this to append into.
+  void addCollectionInitListExpr(const CXXRecordDecl *RD) {
+    const ASTRecordLayout &Info =
+        SemaSYCLRef.getASTContext().getASTRecordLayout(RD);
+    uint64_t NumInitExprs = Info.getFieldCount() + RD->getNumBases();
+    addCollectionInitListExpr(QualType(RD->getTypeForDecl(), 0), NumInitExprs);
+  }
+
+  InitListExpr *createInitListExpr(const CXXRecordDecl *RD) {
+    const ASTRecordLayout &Info =
+        SemaSYCLRef.getASTContext().getASTRecordLayout(RD);
+    uint64_t NumInitExprs = Info.getFieldCount() + RD->getNumBases();
+    return createInitListExpr(QualType(RD->getTypeForDecl(), 0), NumInitExprs);
+  }
+
+  InitListExpr *createInitListExpr(QualType InitTy, uint64_t NumChildInits) {
+    InitListExpr *ILE = new (SemaSYCLRef.getASTContext())
+        InitListExpr(SemaSYCLRef.getASTContext(), KernelCallerSrcLoc, {},
+                     KernelCallerSrcLoc);
+    ILE->reserveInits(SemaSYCLRef.getASTContext(), NumChildInits);
+    ILE->setType(InitTy);
+
+    return ILE;
+  }
+
+  // Create an empty InitListExpr of the type/size for the rest of the visitor
+  // to append into.
+  void addCollectionInitListExpr(QualType InitTy, uint64_t NumChildInits) {
+
+    InitListExpr *ILE = createInitListExpr(InitTy, NumChildInits);
+    InitListExpr *ParentILE = CollectionInitExprs.back();
+    ParentILE->updateInit(SemaSYCLRef.getASTContext(), ParentILE->getNumInits(),
+                          ILE);
+
+    CollectionInitExprs.push_back(ILE);
+  }
+
+  static VarDecl *createKernelObjClone(ASTContext &Ctx, DeclContext *DC,
+                                       const CXXRecordDecl *KernelObj) {
+    TypeSourceInfo *TSInfo =
+        KernelObj->isLambda() ? KernelObj->getLambdaTypeInfo() : nullptr;
+    IdentifierInfo *Ident = KernelObj->getIdentifier();
+    if (!Ident)
+      Ident = &Ctx.Idents.get("__SYCLKernel");
+
+    VarDecl *VD = VarDecl::Create(
+        Ctx, DC, KernelObj->getLocation(), KernelObj->getLocation(), Ident,
+        QualType(KernelObj->getTypeForDecl(), 0), TSInfo, SC_None);
+    return VD;
+  }
+
+  const llvm::StringLiteral getInitMethodName() const {
+    return IsESIMD ? InitESIMDMethodName : InitMethodName;
+  }
+
+  // Default inits the type, then calls the init-method in the body.
+  bool handleSpecialType(FieldDecl *FD, QualType Ty) {
+    addFieldInit(FD, Ty, std::nullopt,
+                 InitializationKind::CreateDefault(KernelCallerSrcLoc));
+
+    addFieldMemberExpr(FD, Ty);
+
+    const auto *RecordDecl = Ty->getAsCXXRecordDecl();
+    createSpecialMethodCall(RecordDecl, getInitMethodName(), BodyStmts);
+    CXXMethodDecl *FinalizeMethod =
+        getMethodByName(RecordDecl, FinalizeMethodName);
+    // A finalize-method is expected for special type such as stream.
+    if (FinalizeMethod)
+      createSpecialMethodCall(RecordDecl, FinalizeMethodName, FinalizeStmts);
+
+    removeFieldMemberExpr(FD, Ty);
+
+    return true;
+  }
+
+  bool handleSpecialType(const CXXBaseSpecifier &BS, QualType Ty) {
+    const auto *RecordDecl = Ty->getAsCXXRecordDecl();
+    addBaseInit(BS, Ty, InitializationKind::CreateDefault(KernelCallerSrcLoc));
+    createSpecialMethodCall(RecordDecl, getInitMethodName(), BodyStmts);
+    return true;
+  }
+
+  // Generate __init call for kernel handler argument
+  void handleSpecialType(QualType KernelHandlerTy) {
+    DeclRefExpr *KernelHandlerCloneRef = DeclRefExpr::Create(
+        SemaSYCLRef.getASTContext(), NestedNameSpecifierLoc(),
+        KernelCallerSrcLoc, KernelHandlerClone, false, DeclarationNameInfo(),
+        KernelHandlerTy, VK_LValue);
+    const auto *RecordDecl =
+        KernelHandlerClone->getType()->getAsCXXRecordDecl();
+    MemberExprBases.push_back(KernelHandlerCloneRef);
+    createSpecialMethodCall(RecordDecl, InitSpecConstantsBuffer, BodyStmts);
+    MemberExprBases.pop_back();
+  }
+
+  void createKernelHandlerClone(ASTContext &Ctx, DeclContext *DC,
+                                ParmVarDecl *KernelHandlerArg) {
+    QualType Ty = KernelHandlerArg->getType();
+    TypeSourceInfo *TSInfo = Ctx.getTrivialTypeSourceInfo(Ty);
+    KernelHandlerClone =
+        VarDecl::Create(Ctx, DC, KernelCallerSrcLoc, KernelCallerSrcLoc,
+                        KernelHandlerArg->getIdentifier(), Ty, TSInfo, SC_None);
+
+    // Default initialize clone
+    InitializedEntity VarEntity =
+        InitializedEntity::InitializeVariable(KernelHandlerClone);
+    InitializationKind InitKind =
+        InitializationKind::CreateDefault(KernelCallerSrcLoc);
+    InitializationSequence InitSeq(SemaSYCLRef.SemaRef, VarEntity, InitKind,
+                                   std::nullopt);
+    ExprResult Init =
+        InitSeq.Perform(SemaSYCLRef.SemaRef, VarEntity, InitKind, std::nullopt);
+    KernelHandlerClone->setInit(
+        SemaSYCLRef.SemaRef.MaybeCreateExprWithCleanups(Init.get()));
+    KernelHandlerClone->setInitStyle(VarDecl::CallInit);
+  }
+
+  Expr *createArraySubscriptExpr(uint64_t Index, Expr *ArrayRef) {
+    QualType SizeT = SemaSYCLRef.getASTContext().getSizeType();
+    llvm::APInt IndexVal{
+        static_cast<unsigned>(SemaSYCLRef.getASTContext().getTypeSize(SizeT)),
+        Index, SizeT->isSignedIntegerType()};
+    auto IndexLiteral = IntegerLiteral::Create(
+        SemaSYCLRef.getASTContext(), IndexVal, SizeT, KernelCallerSrcLoc);
+    ExprResult IndexExpr = SemaSYCLRef.SemaRef.CreateBuiltinArraySubscriptExpr(
+        ArrayRef, KernelCallerSrcLoc, IndexLiteral, KernelCallerSrcLoc);
+    assert(!IndexExpr.isInvalid());
+    return IndexExpr.get();
+  }
+
+  void addSimpleArrayInit(FieldDecl *FD, QualType FieldTy) {
+    Expr *ArrayRef = createSimpleArrayParamReferenceExpr(FieldTy);
+    InitializationKind InitKind = InitializationKind::CreateDirect({}, {}, {});
+
+    InitializedEntity Entity = InitializedEntity::InitializeMember(
+        FD, &VarEntity.value(), /*Implicit*/ true);
+
+    addFieldInit(FD, FieldTy, ArrayRef, InitKind, Entity);
+  }
+
+  void addArrayElementInit(FieldDecl *FD, QualType T) {
+    Expr *RCE = createReinterpretCastExpr(
+        createGetAddressOf(ArrayParamBases.pop_back_val()),
+        SemaSYCLRef.getASTContext().getPointerType(T));
+    Expr *Initializer = createDerefOp(RCE);
+    addFieldInit(FD, T, Initializer);
+  }
+
+  // This function is recursive in order to handle
+  // multi-dimensional arrays. If the array element is
+  // an array, it implies that the array is multi-dimensional.
+  // We continue recursion till we reach a non-array element to
+  // generate required array subscript expressions.
+  void createArrayInit(FieldDecl *FD, QualType T) {
+    const ConstantArrayType *CAT =
+        SemaSYCLRef.getASTContext().getAsConstantArrayType(T);
+
+    if (!CAT) {
+      addArrayElementInit(FD, T);
+      return;
+    }
+
+    QualType ET = CAT->getElementType();
+    uint64_t ElemCount = CAT->getSize().getZExtValue();
+    enterArray(FD, T, ET);
+
+    for (uint64_t Index = 0; Index < ElemCount; ++Index) {
+      ArrayInfos.back().second = Index;
+      Expr *ArraySubscriptExpr =
+          createArraySubscriptExpr(Index, ArrayParamBases.back());
+      ArrayParamBases.push_back(ArraySubscriptExpr);
+      createArrayInit(FD, ET);
+    }
+
+    leaveArray(FD, T, ET);
+  }
+
+  // This function is used to create initializers for a top
+  // level array which contains pointers. The openCl kernel
+  // parameter for this array will be a wrapper class
+  // which contains the generated type. This function generates
+  // code equivalent to:
+  // void ocl_kernel(__wrapper_class WrappedGT) {
+  //   Kernel KernelObjClone {
+  //   *reinterpret_cast<UserArrayET*>(&WrappedGT.GeneratedArr[0]),
+  //                           *reinterpret_cast<UserArrayET*>(&WrappedGT.GeneratedArr[1]),
+  //                           *reinterpret_cast<UserArrayET*>(&WrappedGT.GeneratedArr[2])
+  //                         };
+  // }
+  void handleGeneratedArrayType(FieldDecl *FD, QualType FieldTy) {
+    ArrayParamBases.push_back(createSimpleArrayParamReferenceExpr(FieldTy));
+    createArrayInit(FD, FieldTy);
+  }
+
+public:
+  static constexpr const bool VisitInsideSimpleContainers = false;
+  SyclKernelBodyCreator(SemaSYCL &S, SyclKernelDeclCreator &DC,
+                        const CXXRecordDecl *KernelObj,
+                        FunctionDecl *KernelCallerFunc, bool IsSIMDKernel,
+                        CXXMethodDecl *CallOperator)
+      : SyclKernelFieldHandler(S),
+        UseTopLevelKernelObj(KernelObjVisitor::useTopLevelKernelObj(KernelObj)),
+        DeclCreator(DC),
+        KernelObjClone(UseTopLevelKernelObj
+                           ? nullptr
+                           : createKernelObjClone(S.getASTContext(),
+                                                  DC.getKernelDecl(),
+                                                  KernelObj)),
+        VarEntity(), KernelCallerFunc(KernelCallerFunc),
+        KernelCallerSrcLoc(KernelCallerFunc->getLocation()),
+        IsESIMD(IsSIMDKernel), CallOperator(CallOperator) {
+    if (!UseTopLevelKernelObj) {
+      VarEntity.emplace(InitializedEntity::InitializeVariable(KernelObjClone));
+      Stmt *DS = new (S.getASTContext()) DeclStmt(
+          DeclGroupRef(KernelObjClone), KernelCallerSrcLoc, KernelCallerSrcLoc);
+      BodyStmts.push_back(DS);
+      CollectionInitExprs.push_back(createInitListExpr(KernelObj));
+      DeclRefExpr *KernelObjCloneRef = DeclRefExpr::Create(
+          S.getASTContext(), NestedNameSpecifierLoc(), KernelCallerSrcLoc,
+          KernelObjClone, false, DeclarationNameInfo(),
+          QualType(KernelObj->getTypeForDecl(), 0), VK_LValue);
+      MemberExprBases.push_back(KernelObjCloneRef);
+    }
+  }
+
+  ~SyclKernelBodyCreator() {
+    annotateHierarchicalParallelismAPICalls();
+    CompoundStmt *KernelBody = createKernelBody();
+    DeclCreator.setBody(KernelBody);
+  }
+
+  bool handleSyclSpecialType(FieldDecl *FD, QualType Ty) final {
+    return handleSpecialType(FD, Ty);
+  }
+
+  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                             QualType Ty) final {
+    return handleSpecialType(BS, Ty);
+  }
+
+  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
+    Expr *PointerRef =
+        createPointerParamReferenceExpr(FieldTy, StructDepth != 0);
+    addFieldInit(FD, FieldTy, PointerRef);
+    return true;
+  }
+
+  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
+    if (FD->hasAttr<SYCLGenerateNewTypeAttr>())
+      handleGeneratedArrayType(FD, FieldTy);
+    else
+      addSimpleArrayInit(FD, FieldTy);
+    return true;
+  }
+
+  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
+    // As the functor is passed as a whole, use the param as the vardecl
+    // otherwise used as the clone.
+    KernelObjClone = DeclCreator.getParamVarDeclsForCurrentField()[0];
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
+                             QualType Ty) final {
+    CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
+    assert(RD && "Type must be a C++ record type");
+    if (RD->hasAttr<SYCLGenerateNewTypeAttr>())
+      handleGeneratedType(FD, Ty);
+    else
+      addSimpleFieldInit(FD, Ty);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *RD,
+                             const CXXBaseSpecifier &BS, QualType Ty) final {
+    CXXRecordDecl *BaseDecl = Ty->getAsCXXRecordDecl();
+    assert(BaseDecl && "Type must be a C++ record type");
+    if (BaseDecl->hasAttr<SYCLGenerateNewTypeAttr>())
+      handleGeneratedType(RD, BS, Ty);
+    else
+      addSimpleBaseInit(BS, Ty);
+    return true;
+  }
+
+  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
+    addSimpleFieldInit(FD, FieldTy);
+    return true;
+  }
+
+  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
+    addSimpleFieldInit(FD, FieldTy);
+    return true;
+  }
+
+  // Default inits the type, then calls the init-method in the body
+  void handleSyclKernelHandlerType(ParmVarDecl *KernelHandlerArg) {
+
+    // Create and default initialize local clone of kernel handler
+    createKernelHandlerClone(SemaSYCLRef.getASTContext(),
+                             DeclCreator.getKernelDecl(), KernelHandlerArg);
+
+    // Add declaration statement to openCL kernel body
+    Stmt *DS = new (SemaSYCLRef.getASTContext())
+        DeclStmt(DeclGroupRef(KernelHandlerClone), KernelCallerSrcLoc,
+                 KernelCallerSrcLoc);
+    BodyStmts.push_back(DS);
+
+    // Generate
+    // KernelHandlerClone.__init_specialization_constants_buffer(specialization_constants_buffer)
+    // call if target does not have native support for specialization constants.
+    // Here, specialization_constants_buffer is the compiler generated kernel
+    // argument of type char*.
+    if (!isDefaultSPIRArch(SemaSYCLRef.getASTContext()))
+      handleSpecialType(KernelHandlerArg->getType());
+  }
+
+  bool enterStruct(const CXXRecordDecl *RD, FieldDecl *FD, QualType Ty) final {
+    ++StructDepth;
+    addCollectionInitListExpr(Ty->getAsCXXRecordDecl());
+
+    addFieldMemberExpr(FD, Ty);
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
+    --StructDepth;
+    CollectionInitExprs.pop_back();
+
+    removeFieldMemberExpr(FD, Ty);
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
+                   QualType) final {
+    ++StructDepth;
+
+    CXXCastPath BasePath;
+    QualType DerivedTy(RD->getTypeForDecl(), 0);
+    QualType BaseTy = BS.getType();
+    SemaSYCLRef.SemaRef.CheckDerivedToBaseConversion(
+        DerivedTy, BaseTy, KernelCallerSrcLoc, SourceRange(), &BasePath,
+        /*IgnoreBaseAccess*/ true);
+    auto Cast = ImplicitCastExpr::Create(
+        SemaSYCLRef.getASTContext(), BaseTy, CK_DerivedToBase,
+        MemberExprBases.back(),
+        /* CXXCastPath=*/&BasePath, VK_LValue, FPOptionsOverride());
+    MemberExprBases.push_back(Cast);
+    addCollectionInitListExpr(BaseTy->getAsCXXRecordDecl());
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
+                   QualType) final {
+    --StructDepth;
+    MemberExprBases.pop_back();
+    CollectionInitExprs.pop_back();
+    return true;
+  }
+
+  bool enterArray(FieldDecl *FD, QualType ArrayType,
+                  QualType ElementType) final {
+    const ConstantArrayType *CAT =
+        SemaSYCLRef.getASTContext().getAsConstantArrayType(ArrayType);
+    assert(CAT && "Should only be called on constant-size array.");
+    uint64_t ArraySize = CAT->getSize().getZExtValue();
+    addCollectionInitListExpr(ArrayType, ArraySize);
+    ArrayInfos.emplace_back(getFieldEntity(FD, ArrayType), 0);
+
+    // If this is the top-level array, we need to make a MemberExpr in addition
+    // to an array subscript.
+    addFieldMemberExpr(FD, ArrayType);
+    return true;
+  }
+
+  bool nextElement(QualType, uint64_t Index) final {
+    ArrayInfos.back().second = Index;
+
+    // Pop off the last member expr base.
+    if (Index != 0)
+      MemberExprBases.pop_back();
+
+    MemberExprBases.push_back(
+        createArraySubscriptExpr(Index, MemberExprBases.back()));
+    return true;
+  }
+
+  bool leaveArray(FieldDecl *FD, QualType ArrayType,
+                  QualType ElementType) final {
+    CollectionInitExprs.pop_back();
+    ArrayInfos.pop_back();
+
+    // Remove the IndexExpr.
+    if (!FD->hasAttr<SYCLGenerateNewTypeAttr>())
+      MemberExprBases.pop_back();
+    else
+      ArrayParamBases.pop_back();
+
+    // Remove the field access expr as well.
+    removeFieldMemberExpr(FD, ArrayType);
+    return true;
+  }
+  using SyclKernelFieldHandler::enterArray;
+  using SyclKernelFieldHandler::enterStruct;
+  using SyclKernelFieldHandler::handleNonDecompStruct;
+  using SyclKernelFieldHandler::handlePointerType;
+  using SyclKernelFieldHandler::handleScalarType;
+  using SyclKernelFieldHandler::handleSyclSpecialType;
+  using SyclKernelFieldHandler::handleUnionType;
+  using SyclKernelFieldHandler::leaveArray;
+  using SyclKernelFieldHandler::leaveStruct;
+};
+
+class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
+  SyclKernelDeclCreator &DeclCreator;
+  llvm::SmallVector<Stmt *, 16> BodyStmts;
+  FunctionDecl *FreeFunc = nullptr;
+  SourceLocation FreeFunctionSrcLoc; // Free function source location.
+  llvm::SmallVector<Expr *, 8> ArgExprs;
+
+  // Creates a DeclRefExpr to the ParmVar that represents the current free
+  // function parameter.
+  Expr *createParamReferenceExpr() {
+    ParmVarDecl *FreeFunctionParameter =
+        DeclCreator.getParamVarDeclsForCurrentField()[0];
+
+    QualType FreeFunctionParamType = FreeFunctionParameter->getOriginalType();
+    Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+        FreeFunctionParameter, FreeFunctionParamType, VK_LValue,
+        FreeFunctionSrcLoc);
+    DRE = SemaSYCLRef.SemaRef.DefaultLvalueConversion(DRE).get();
+    return DRE;
+  }
+
+  // Creates a DeclRefExpr to the ParmVar that represents the current pointer
+  // parameter.
+  Expr *createPointerParamReferenceExpr(QualType PointerTy) {
+    ParmVarDecl *FreeFunctionParameter =
+        DeclCreator.getParamVarDeclsForCurrentField()[0];
+
+    QualType FreeFunctionParamType = FreeFunctionParameter->getOriginalType();
+    Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+        FreeFunctionParameter, FreeFunctionParamType, VK_LValue,
+        FreeFunctionSrcLoc);
+    DRE = SemaSYCLRef.SemaRef.DefaultLvalueConversion(DRE).get();
+
+    if (PointerTy->getPointeeType().getAddressSpace() !=
+        FreeFunctionParamType->getPointeeType().getAddressSpace())
+      DRE = ImplicitCastExpr::Create(SemaSYCLRef.getASTContext(), PointerTy,
+                                     CK_AddressSpaceConversion, DRE, nullptr,
+                                     VK_PRValue, FPOptionsOverride());
+    return DRE;
+  }
+
+  Expr *createGetAddressOf(Expr *E) {
+    return UnaryOperator::Create(
+        SemaSYCLRef.getASTContext(), E, UO_AddrOf,
+        SemaSYCLRef.getASTContext().getPointerType(E->getType()), VK_PRValue,
+        OK_Ordinary, SourceLocation(), false,
+        SemaSYCLRef.SemaRef.CurFPFeatureOverrides());
+  }
+
+  Expr *createDerefOp(Expr *E) {
+    return UnaryOperator::Create(SemaSYCLRef.getASTContext(), E, UO_Deref,
+                                 E->getType()->getPointeeType(), VK_LValue,
+                                 OK_Ordinary, SourceLocation(), false,
+                                 SemaSYCLRef.SemaRef.CurFPFeatureOverrides());
+  }
+
+  Expr *createReinterpretCastExpr(Expr *E, QualType To) {
+    return CXXReinterpretCastExpr::Create(
+        SemaSYCLRef.getASTContext(), To, VK_PRValue, CK_BitCast, E,
+        /*Path=*/nullptr,
+        SemaSYCLRef.getASTContext().getTrivialTypeSourceInfo(To),
+        SourceLocation(), SourceLocation(), SourceRange());
+  }
+
+  Expr *createCopyInitExpr(ParmVarDecl *OrigFunctionParameter) {
+    Expr *DRE = createParamReferenceExpr();
+
+    assert(OrigFunctionParameter && "no parameter?");
+
+    CXXRecordDecl *RD = OrigFunctionParameter->getType()->getAsCXXRecordDecl();
+    InitializedEntity Entity = InitializedEntity::InitializeParameter(
+        SemaSYCLRef.getASTContext(), OrigFunctionParameter);
+
+    if (RD->hasAttr<SYCLGenerateNewTypeAttr>()) {
+      DRE = createReinterpretCastExpr(
+          createGetAddressOf(DRE), SemaSYCLRef.getASTContext().getPointerType(
+                                       OrigFunctionParameter->getType()));
+      DRE = createDerefOp(DRE);
+    }
+
+    ExprResult ArgE = SemaSYCLRef.SemaRef.PerformCopyInitialization(
+        Entity, SourceLocation(), DRE, false, false);
+    return ArgE.getAs<Expr>();
+  }
+
+  // For a free function such as:
+  // void f(int i, int* p, struct Simple S) { ... }
+  //
+  // Keep the function as-is for the version callable from device code.
+  // void f(int i, int *p, struct Simple S) { ... }
+  //
+  // For the host-callable kernel function generate this:
+  // void __sycl_kernel_f(int __arg_i, int* __arg_p, struct Simple __arg_S)
+  // {
+  //   f(__arg_i, __arg_p, __arg_S);
+  // }
+  CompoundStmt *createFreeFunctionKernelBody() {
+    SemaSYCLRef.SemaRef.PushFunctionScope();
+    Expr *Fn = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+        FreeFunc, FreeFunc->getType(), VK_LValue, FreeFunctionSrcLoc);
+    ASTContext &Context = SemaSYCLRef.getASTContext();
+    QualType ResultTy = FreeFunc->getReturnType();
+    ExprValueKind VK = Expr::getValueKindForType(ResultTy);
+    ResultTy = ResultTy.getNonLValueExprType(Context);
+    Fn = ImplicitCastExpr::Create(Context,
+                                  Context.getPointerType(FreeFunc->getType()),
+                                  CK_FunctionToPointerDecay, Fn, nullptr,
+                                  VK_PRValue, FPOptionsOverride());
+    auto CallExpr = CallExpr::Create(Context, Fn, ArgExprs, ResultTy, VK,
+                                     FreeFunctionSrcLoc, FPOptionsOverride());
+    BodyStmts.push_back(CallExpr);
+    return CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
+                                {});
+  }
+
+public:
+  static constexpr const bool VisitInsideSimpleContainers = false;
+
+  FreeFunctionKernelBodyCreator(SemaSYCL &S, SyclKernelDeclCreator &DC,
+                                FunctionDecl *FF)
+      : SyclKernelFieldHandler(S), DeclCreator(DC), FreeFunc(FF),
+        FreeFunctionSrcLoc(FF->getLocation()) {}
+
+  ~FreeFunctionKernelBodyCreator() {
+    CompoundStmt *KernelBody = createFreeFunctionKernelBody();
+    DeclCreator.setBody(KernelBody);
+  }
+
+  bool handleSyclSpecialType(FieldDecl *FD, QualType Ty) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                             QualType Ty) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
+    Expr *PointerRef = createPointerParamReferenceExpr(ParamTy);
+    ArgExprs.push_back(PointerRef);
+    return true;
+  }
+
+  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
+                             QualType Ty) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, ParmVarDecl *PD,
+                             QualType) final {
+    Expr *TempCopy = createCopyInitExpr(PD);
+    ArgExprs.push_back(TempCopy);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *RD,
+                             const CXXBaseSpecifier &BS, QualType Ty) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleScalarType(ParmVarDecl *, QualType) final {
+    Expr *ParamRef = createParamReferenceExpr();
+    ArgExprs.push_back(ParamRef);
+    return true;
+  }
+
+  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handleUnionType(ParmVarDecl *, QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *RD, FieldDecl *FD, QualType Ty) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
+                   QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
+                   QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool enterArray(FieldDecl *FD, QualType ArrayType,
+                  QualType ElementType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool enterArray(ParmVarDecl *PD, QualType ArrayType,
+                  QualType ElementType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool leaveArray(FieldDecl *FD, QualType ArrayType,
+                  QualType ElementType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool leaveArray(ParmVarDecl *PD, QualType ArrayType,
+                  QualType ElementType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+};
+
+// Kernels are only the unnamed-lambda feature if the feature is enabled, AND
+// the first template argument has been corrected by the library to match the
+// functor type.
+static bool IsSYCLUnnamedKernel(SemaSYCL &SemaSYCLRef, const FunctionDecl *FD) {
+  if (!SemaSYCLRef.getLangOpts().SYCLUnnamedLambda)
+    return false;
+
+  QualType FunctorTy = GetSYCLKernelObjectType(FD);
+  QualType TmplArgTy = calculateKernelNameType(SemaSYCLRef.getASTContext(), FD);
+  return SemaSYCLRef.getASTContext().hasSameType(FunctorTy, TmplArgTy);
+}
+
+class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
+  SYCLIntegrationHeader &Header;
+  int64_t CurOffset = 0;
+  llvm::SmallVector<size_t, 16> ArrayBaseOffsets;
+  int StructDepth = 0;
+
+  // A series of functions to calculate the change in offset based on the type.
+  int64_t offsetOf(const FieldDecl *FD, QualType ArgTy) const {
+    return isArrayElement(FD, ArgTy)
+               ? 0
+               : SemaSYCLRef.getASTContext().getFieldOffset(FD) / 8;
+  }
+  // For free functions each parameter is stand-alone, so offsets within a
+  // lambda/function object are not relevant. Therefore offsetOf will always be
+  // 0.
+  int64_t offsetOf(const ParmVarDecl *, QualType) const { return 0; }
+
+  int64_t offsetOf(const CXXRecordDecl *RD, const CXXRecordDecl *Base) const {
+    const ASTRecordLayout &Layout =
+        SemaSYCLRef.getASTContext().getASTRecordLayout(RD);
+    return Layout.getBaseClassOffset(Base).getQuantity();
+  }
+
+  void addParam(const FieldDecl *FD, QualType ArgTy,
+                SYCLIntegrationHeader::kernel_param_kind_t Kind) {
+    addParam(ArgTy, Kind, offsetOf(FD, ArgTy));
+  }
+
+  // For free functions we increment the current offset as each parameter is
+  // added.
+  void addParam(const ParmVarDecl *PD, QualType ParamTy,
+                SYCLIntegrationHeader::kernel_param_kind_t Kind) {
+    addParam(ParamTy, Kind, offsetOf(PD, ParamTy));
+    CurOffset +=
+        SemaSYCLRef.getASTContext().getTypeSizeInChars(ParamTy).getQuantity();
+  }
+
+  void addParam(QualType ParamTy,
+                SYCLIntegrationHeader::kernel_param_kind_t Kind,
+                uint64_t OffsetAdj) {
+    uint64_t Size;
+    Size =
+        SemaSYCLRef.getASTContext().getTypeSizeInChars(ParamTy).getQuantity();
+    Header.addParamDesc(Kind, static_cast<unsigned>(Size),
+                        static_cast<unsigned>(CurOffset + OffsetAdj));
+  }
+
+public:
+  static constexpr const bool VisitInsideSimpleContainers = false;
+  SyclKernelIntHeaderCreator(bool IsESIMD, SemaSYCL &S,
+                             SYCLIntegrationHeader &H,
+                             const CXXRecordDecl *KernelObj, QualType NameType,
+                             FunctionDecl *KernelFunc)
+      : SyclKernelFieldHandler(S), Header(H) {
+
+    // The header needs to access the kernel object size.
+    int64_t ObjSize = SemaSYCLRef.getASTContext()
+                          .getTypeSizeInChars(KernelObj->getTypeForDecl())
+                          .getQuantity();
+    Header.startKernel(KernelFunc, NameType, KernelObj->getLocation(), IsESIMD,
+                       IsSYCLUnnamedKernel(S, KernelFunc), ObjSize);
+  }
+
+  SyclKernelIntHeaderCreator(SemaSYCL &S, SYCLIntegrationHeader &H,
+                             QualType NameType, FunctionDecl *FreeFunc)
+      : SyclKernelFieldHandler(S), Header(H) {
+    Header.startKernel(FreeFunc, NameType, FreeFunc->getLocation(),
+                       false /*IsESIMD*/, true /*IsSYCLUnnamedKernel*/,
+                       0 /*ObjSize*/);
+  }
+
+  bool handleSyclSpecialType(const CXXRecordDecl *RD,
+                             const CXXBaseSpecifier &BC,
+                             QualType FieldTy) final {
+    const auto *AccTy =
+        cast<ClassTemplateSpecializationDecl>(FieldTy->getAsRecordDecl());
+    assert(AccTy->getTemplateArgs().size() >= 2 &&
+           "Incorrect template args for Accessor Type");
+    int Dims = static_cast<int>(
+        AccTy->getTemplateArgs()[1].getAsIntegral().getExtValue());
+    int Info = getAccessTarget(FieldTy, AccTy) | (Dims << 11);
+    Header.addParamDesc(SYCLIntegrationHeader::kind_accessor, Info,
+                        CurOffset +
+                            offsetOf(RD, BC.getType()->getAsCXXRecordDecl()));
+    return true;
+  }
+
+  bool handleSyclSpecialType(FieldDecl *FD, QualType FieldTy) final {
+    const auto *ClassTy = FieldTy->getAsCXXRecordDecl();
+    assert(ClassTy && "Type must be a C++ record type");
+    if (isSyclAccessorType(FieldTy)) {
+      const auto *AccTy =
+          cast<ClassTemplateSpecializationDecl>(FieldTy->getAsRecordDecl());
+      assert(AccTy->getTemplateArgs().size() >= 2 &&
+             "Incorrect template args for Accessor Type");
+      int Dims = static_cast<int>(
+          AccTy->getTemplateArgs()[1].getAsIntegral().getExtValue());
+      int Info = getAccessTarget(FieldTy, AccTy) | (Dims << 11);
+
+      Header.addParamDesc(SYCLIntegrationHeader::kind_accessor, Info,
+                          CurOffset + offsetOf(FD, FieldTy));
+    } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::stream)) {
+      addParam(FD, FieldTy, SYCLIntegrationHeader::kind_stream);
+    } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::work_group_memory)) {
+      addParam(FieldTy, SYCLIntegrationHeader::kind_work_group_memory,
+               offsetOf(FD, FieldTy));
+    } else if (SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::sampler) ||
+               SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::annotated_ptr) ||
+               SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::annotated_arg)) {
+      CXXMethodDecl *InitMethod = getMethodByName(ClassTy, InitMethodName);
+      assert(InitMethod && "type must have __init method");
+      const ParmVarDecl *InitArg = InitMethod->getParamDecl(0);
+      assert(InitArg && "Init method must have arguments");
+      QualType T = InitArg->getType();
+      SYCLIntegrationHeader::kernel_param_kind_t ParamKind =
+          SemaSYCL::isSyclType(FieldTy, SYCLTypeAttr::sampler)
+              ? SYCLIntegrationHeader::kind_sampler
+              : (T->isPointerType() ? SYCLIntegrationHeader::kind_pointer
+                                    : SYCLIntegrationHeader::kind_std_layout);
+      addParam(T, ParamKind, offsetOf(FD, FieldTy));
+    } else {
+      llvm_unreachable(
+          "Unexpected SYCL special class when generating integration header");
+    }
+    return true;
+  }
+
+  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
+    addParam(FD, FieldTy,
+             ((StructDepth) ? SYCLIntegrationHeader::kind_std_layout
+                            : SYCLIntegrationHeader::kind_pointer));
+    return true;
+  }
+
+  bool handlePointerType(ParmVarDecl *PD, QualType ParamTy) final {
+    addParam(PD, ParamTy, SYCLIntegrationHeader::kind_pointer);
+    return true;
+  }
+
+  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
+    addParam(FD, FieldTy, SYCLIntegrationHeader::kind_std_layout);
+    return true;
+  }
+
+  bool handleScalarType(ParmVarDecl *PD, QualType ParamTy) final {
+    addParam(PD, ParamTy, SYCLIntegrationHeader::kind_std_layout);
+    return true;
+  }
+
+  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
+    // Arrays are always wrapped inside of structs, so just treat it as a simple
+    // struct.
+    addParam(FD, FieldTy, SYCLIntegrationHeader::kind_std_layout);
+    return true;
+  }
+
+  bool handleTopLevelStruct(const CXXRecordDecl *, QualType Ty) final {
+    addParam(Ty, SYCLIntegrationHeader::kind_std_layout, /*Offset=*/0);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
+                             QualType Ty) final {
+    addParam(FD, Ty, SYCLIntegrationHeader::kind_std_layout);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, ParmVarDecl *PD,
+                             QualType ParamTy) final {
+    addParam(PD, ParamTy, SYCLIntegrationHeader::kind_std_layout);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *Base,
+                             const CXXBaseSpecifier &, QualType Ty) final {
+    addParam(Ty, SYCLIntegrationHeader::kind_std_layout,
+             offsetOf(Base, Ty->getAsCXXRecordDecl()));
+    return true;
+  }
+
+  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
+    return handleScalarType(FD, FieldTy);
+  }
+
+  bool handleUnionType(ParmVarDecl *PD, QualType ParamTy) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  void handleSyclKernelHandlerType(QualType Ty) {
+    // The compiler generated kernel argument used to initialize SYCL 2020
+    // specialization constants, `specialization_constants_buffer`, should
+    // have corresponding entry in integration header.
+    ASTContext &Context = SemaSYCLRef.getASTContext();
+    // Offset is zero since kernel_handler argument is not part of
+    // kernel object (i.e. it is not captured)
+    addParam(Context.getPointerType(Context.CharTy),
+             SYCLIntegrationHeader::kind_specialization_constants_buffer, 0);
+  }
+
+  bool enterStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
+    ++StructDepth;
+    CurOffset += offsetOf(FD, Ty);
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, FieldDecl *FD, QualType Ty) final {
+    --StructDepth;
+    CurOffset -= offsetOf(FD, Ty);
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *, ParmVarDecl *, QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool enterStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
+                   QualType) final {
+    CurOffset += offsetOf(RD, BS.getType()->getAsCXXRecordDecl());
+    return true;
+  }
+
+  bool leaveStruct(const CXXRecordDecl *RD, const CXXBaseSpecifier &BS,
+                   QualType) final {
+    CurOffset -= offsetOf(RD, BS.getType()->getAsCXXRecordDecl());
+    return true;
+  }
+
+  bool enterArray(FieldDecl *FD, QualType ArrayTy, QualType) final {
+    ArrayBaseOffsets.push_back(CurOffset + offsetOf(FD, ArrayTy));
+    return true;
+  }
+
+  bool enterArray(ParmVarDecl *PD, QualType ArrayTy, QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  bool nextElement(QualType ET, uint64_t Index) final {
+    int64_t Size =
+        SemaSYCLRef.getASTContext().getTypeSizeInChars(ET).getQuantity();
+    CurOffset = ArrayBaseOffsets.back() + Size * Index;
+    return true;
+  }
+
+  bool leaveArray(FieldDecl *FD, QualType ArrayTy, QualType) final {
+    CurOffset = ArrayBaseOffsets.pop_back_val();
+    CurOffset -= offsetOf(FD, ArrayTy);
+    return true;
+  }
+
+  bool leaveArray(ParmVarDecl *PD, QualType ArrayTy, QualType) final {
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
+  }
+
+  using SyclKernelFieldHandler::enterStruct;
+  using SyclKernelFieldHandler::leaveStruct;
+};
+
+class SyclKernelIntFooterCreator : public SyclKernelFieldHandler {
+  SYCLIntegrationFooter &Footer;
+
+public:
+  SyclKernelIntFooterCreator(SemaSYCL &S, SYCLIntegrationFooter &F)
+      : SyclKernelFieldHandler(S), Footer(F) {
+    (void)Footer; // workaround for unused field warning
+  }
+};
+
+} // namespace
+
+class SYCLKernelNameTypeVisitor
+    : public TypeVisitor<SYCLKernelNameTypeVisitor>,
+      public ConstTemplateArgumentVisitor<SYCLKernelNameTypeVisitor> {
+  SemaSYCL &S;
+  SourceLocation KernelInvocationFuncLoc;
+  QualType KernelNameType;
+  using InnerTypeVisitor = TypeVisitor<SYCLKernelNameTypeVisitor>;
+  using InnerTemplArgVisitor =
+      ConstTemplateArgumentVisitor<SYCLKernelNameTypeVisitor>;
+  bool IsInvalid = false;
+  bool IsUnnamedKernel = false;
+
+  void VisitTemplateArgs(ArrayRef<TemplateArgument> Args) {
+    for (auto &A : Args)
+      Visit(A);
+  }
+
+public:
+  SYCLKernelNameTypeVisitor(SemaSYCL &S, SourceLocation KernelInvocationFuncLoc,
+                            QualType KernelNameType, bool IsUnnamedKernel)
+      : S(S), KernelInvocationFuncLoc(KernelInvocationFuncLoc),
+        KernelNameType(KernelNameType), IsUnnamedKernel(IsUnnamedKernel) {}
+
+  bool isValid() { return !IsInvalid; }
+
+  void Visit(QualType T) {
+    if (T.isNull())
+      return;
+
+    const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
+    // If KernelNameType has template args visit each template arg via
+    // ConstTemplateArgumentVisitor
+    if (const auto *TSD =
+            dyn_cast_or_null<ClassTemplateSpecializationDecl>(RD)) {
+      ArrayRef<TemplateArgument> Args = TSD->getTemplateArgs().asArray();
+
+      VisitTemplateArgs(Args);
+    } else {
+      InnerTypeVisitor::Visit(T.getTypePtr());
+    }
+  }
+
+  void Visit(const TemplateArgument &TA) {
+    if (TA.isNull())
+      return;
+    InnerTemplArgVisitor::Visit(TA);
+  }
+
+  void VisitBuiltinType(const BuiltinType *TT) {
+    if (TT->isNullPtrType()) {
+      S.Diag(KernelInvocationFuncLoc, diag::err_nullptr_t_type_in_sycl_kernel)
+          << KernelNameType;
+
+      IsInvalid = true;
+    }
+    return;
+  }
+
+  void VisitTagType(const TagType *TT) {
+    return DiagnoseKernelNameType(TT->getDecl());
+  }
+
+  void DiagnoseKernelNameType(const NamedDecl *DeclNamed) {
+    if (!IsUnnamedKernel) {
+      NotForwardDeclarableReason NFDR = isForwardDeclarable(DeclNamed, S);
+      switch (NFDR) {
+      case NotForwardDeclarableReason::UnscopedEnum:
+        S.Diag(KernelInvocationFuncLoc, diag::err_sycl_kernel_incorrectly_named)
+            << /* unscoped enum requires fixed underlying type */ 1
+            << DeclNamed;
+        IsInvalid = true;
+        return;
+      case NotForwardDeclarableReason::StdNamespace:
+        S.Diag(KernelInvocationFuncLoc,
+               diag::err_invalid_std_type_in_sycl_kernel)
+            << KernelNameType << DeclNamed;
+        IsInvalid = true;
+        return;
+      case NotForwardDeclarableReason::UnnamedTag:
+        S.Diag(KernelInvocationFuncLoc, diag::err_sycl_kernel_incorrectly_named)
+            << /* unnamed type is invalid */ 2 << KernelNameType;
+        IsInvalid = true;
+        return;
+      case NotForwardDeclarableReason::NotAtNamespaceScope:
+        S.Diag(KernelInvocationFuncLoc, diag::err_sycl_kernel_incorrectly_named)
+            << /* kernel name should be forward declarable at namespace
+                  scope */
+            0 << KernelNameType;
+        IsInvalid = true;
+        return;
+      case NotForwardDeclarableReason::None:
+      default:
+        // Do nothing, we're fine.
+        break;
+      }
+    }
+  }
+
+  void VisitTypeTemplateArgument(const TemplateArgument &TA) {
+    QualType T = TA.getAsType();
+    if (const auto *ET = T->getAs<EnumType>())
+      VisitTagType(ET);
+    else
+      Visit(T);
+  }
+
+  void VisitIntegralTemplateArgument(const TemplateArgument &TA) {
+    QualType T = TA.getIntegralType();
+    if (const EnumType *ET = T->getAs<EnumType>())
+      VisitTagType(ET);
+  }
+
+  void VisitTemplateTemplateArgument(const TemplateArgument &TA) {
+    TemplateDecl *TD = TA.getAsTemplate().getAsTemplateDecl();
+    assert(TD && "template declaration must be available");
+    TemplateParameterList *TemplateParams = TD->getTemplateParameters();
+    for (NamedDecl *P : *TemplateParams) {
+      if (NonTypeTemplateParmDecl *TemplateParam =
+              dyn_cast<NonTypeTemplateParmDecl>(P))
+        if (const EnumType *ET = TemplateParam->getType()->getAs<EnumType>())
+          VisitTagType(ET);
+    }
+  }
+
+  void VisitPackTemplateArgument(const TemplateArgument &TA) {
+    VisitTemplateArgs(TA.getPackAsArray());
+  }
+};
+
+void SemaSYCL::CheckSYCLKernelCall(FunctionDecl *KernelFunc,
+                                   ArrayRef<const Expr *> Args) {
+  QualType KernelNameType =
+      calculateKernelNameType(getASTContext(), KernelFunc);
+  SYCLKernelNameTypeVisitor KernelNameTypeVisitor(
+      *this, Args[0]->getExprLoc(), KernelNameType,
+      IsSYCLUnnamedKernel(*this, KernelFunc));
+  KernelNameTypeVisitor.Visit(KernelNameType.getCanonicalType());
+
+  // FIXME: In place until the library works around its 'host' invocation
+  // issues.
+  if (!SemaRef.LangOpts.SYCLIsDevice)
+    return;
+
+  const CXXRecordDecl *KernelObj =
+      GetSYCLKernelObjectType(KernelFunc)->getAsCXXRecordDecl();
+
+  if (!KernelObj || (KernelObj && !KernelObj->hasDefinition())) {
+    Diag(Args[0]->getExprLoc(), diag::err_sycl_kernel_not_function_object);
+    KernelFunc->setInvalidDecl();
+    return;
+  }
+
+  if (KernelObj->isLambda()) {
+    for (const LambdaCapture &LC : KernelObj->captures())
+      if (LC.capturesThis() && LC.isImplicit()) {
+        Diag(LC.getLocation(), diag::err_implicit_this_capture);
+        KernelFunc->setInvalidDecl();
+      }
+  }
+
+  // check that calling kernel conforms to spec
+  QualType KernelParamTy = KernelFunc->getParamDecl(0)->getType();
+  if (not KernelParamTy->isReferenceType()) {
+    // passing by value.  emit warning if using SYCL 2020 or greater
+    if (SemaRef.LangOpts.getSYCLVersion() >= LangOptions::SYCL_2020)
+      Diag(KernelFunc->getLocation(), diag::warn_sycl_pass_by_value_deprecated);
+  }
+
+  // Do not visit invalid kernel object.
+  if (KernelObj->isInvalidDecl())
+    return;
+
+  SyclKernelDecompMarker DecompMarker(*this);
+  SyclKernelFieldChecker FieldChecker(*this);
+  SyclKernelUnionChecker UnionChecker(*this);
+
+  KernelObjVisitor Visitor{*this};
+
+  DiagnosingSYCLKernel = true;
+
+  // Emit diagnostics for SYCL device kernels only
+  Visitor.VisitRecordBases(KernelObj, FieldChecker, UnionChecker, DecompMarker);
+  Visitor.VisitRecordFields(KernelObj, FieldChecker, UnionChecker,
+                            DecompMarker);
+  Visitor.visitTopLevelRecord(KernelObj, GetSYCLKernelObjectType(KernelFunc),
+                              FieldChecker, UnionChecker, DecompMarker);
+
+  DiagnosingSYCLKernel = false;
+  // Set the kernel function as invalid, if any of the checkers fail validation.
+  if (!FieldChecker.isValid() || !UnionChecker.isValid() ||
+      !KernelNameTypeVisitor.isValid())
+    KernelFunc->setInvalidDecl();
+}
+
+// For a wrapped parallel_for, copy attributes from original
+// kernel to wrapped kernel.
+void SemaSYCL::copySYCLKernelAttrs(CXXMethodDecl *CallOperator) {
+  // Get the operator() function of the wrapper.
+  assert(CallOperator && "invalid kernel object");
+
+  typedef std::pair<FunctionDecl *, FunctionDecl *> ChildParentPair;
+  llvm::SmallPtrSet<FunctionDecl *, 16> Visited;
+  llvm::SmallVector<ChildParentPair, 16> WorkList;
+  WorkList.push_back({CallOperator, nullptr});
+  FunctionDecl *KernelBody = nullptr;
+
+  CallGraph SYCLCG;
+  SYCLCG.addToCallGraph(CallOperator);
+  while (!WorkList.empty()) {
+    FunctionDecl *FD = WorkList.back().first;
+    FunctionDecl *ParentFD = WorkList.back().second;
+
+    if ((ParentFD == CallOperator) && isSYCLKernelBodyFunction(FD)) {
+      KernelBody = FD;
+      break;
+    }
+
+    WorkList.pop_back();
+    if (!Visited.insert(FD).second)
+      continue; // We've already seen this Decl
+
+    CallGraphNode *N = SYCLCG.getNode(FD);
+    if (!N)
+      continue;
+
+    for (const CallGraphNode *CI : *N) {
+      if (auto *Callee = dyn_cast<FunctionDecl>(CI->getDecl())) {
+        Callee = Callee->getMostRecentDecl();
+        if (!Visited.count(Callee))
+          WorkList.push_back({Callee, FD});
+      }
+    }
+  }
+
+  assert(KernelBody && "improper parallel_for wrap");
+  if (KernelBody) {
+    llvm::SmallVector<Attr *, 4> Attrs;
+    collectSYCLAttributes(*this, KernelBody, Attrs, /*DirectlyCalled*/ true);
+    if (!Attrs.empty())
+      llvm::for_each(Attrs,
+                     [CallOperator](Attr *A) { CallOperator->addAttr(A); });
+  }
+}
+
+void SemaSYCL::SetSYCLKernelNames() {
+  std::unique_ptr<MangleContext> MangleCtx(
+      getASTContext().createMangleContext());
+  // We assume the list of KernelDescs is the complete list of kernels needing
+  // to be rewritten.
+  for (const std::pair<const FunctionDecl *, FunctionDecl *> &Pair :
+       SyclKernelsToOpenCLKernels) {
+    std::string CalculatedName, StableName;
+    StringRef KernelName;
+    if (isFreeFunction(*this, Pair.first)) {
+      std::tie(CalculatedName, StableName) =
+          constructFreeFunctionKernelName(*this, Pair.first, *MangleCtx);
+      KernelName = CalculatedName;
+    } else {
+      std::tie(CalculatedName, StableName) =
+          constructKernelName(*this, Pair.first, *MangleCtx);
+      KernelName =
+          IsSYCLUnnamedKernel(*this, Pair.first) ? StableName : CalculatedName;
+    }
+
+    getSyclIntegrationHeader().updateKernelNames(Pair.first, KernelName,
+                                                 StableName);
+
+    // Set name of generated kernel.
+    Pair.second->setDeclName(&getASTContext().Idents.get(KernelName));
+    // Update the AsmLabel for this generated kernel.
+    Pair.second->addAttr(
+        AsmLabelAttr::CreateImplicit(getASTContext(), KernelName));
+  }
+}
+
+// Generates the OpenCL kernel using KernelCallerFunc (kernel caller
+// function) defined is SYCL headers.
+// Generated OpenCL kernel contains the body of the kernel caller function,
+// receives OpenCL like parameters and additionally does some manipulation to
+// initialize captured lambda/functor fields with these parameters.
+// SYCL runtime marks kernel caller function with sycl_kernel attribute.
+// To be able to generate OpenCL kernel from KernelCallerFunc we put
+// the following requirements to the function which SYCL runtime can mark with
+// sycl_kernel attribute:
+//   - Must be template function with at least two template parameters.
+//     First parameter must represent "unique kernel name"
+//     Second parameter must be the function object type
+//   - Must have only one function parameter - function object.
+//
+// Example of kernel caller function:
+//   template <typename KernelName, typename KernelType/*, ...*/>
+//   __attribute__((sycl_kernel)) void kernel_caller_function(KernelType
+//                                                            KernelFuncObj) {
+//     KernelFuncObj();
+//   }
+//
+//
+void SemaSYCL::ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc,
+                                     MangleContext &MC) {
+  // The first argument to the KernelCallerFunc is the lambda object.
+  QualType KernelObjTy = GetSYCLKernelObjectType(KernelCallerFunc);
+  const CXXRecordDecl *KernelObj = KernelObjTy->getAsCXXRecordDecl();
+  assert(KernelObj && "invalid kernel caller");
+
+  // Do not visit invalid kernel object.
+  if (KernelObj->isInvalidDecl())
+    return;
+
+  KernelCallOperatorVisitor KernelCallOperator(KernelCallerFunc, KernelObj);
+  CXXMethodDecl *CallOperator = nullptr;
+
+  if (KernelObj->isLambda())
+    CallOperator = KernelObj->getLambdaCallOperator();
+  else
+    CallOperator = KernelCallOperator.getCallOperator();
+
+  {
+    // Do enough to calculate the StableName for the purposes of the hackery
+    // below for __pf_kernel_wrapper. Placed in a scope so that we don't
+    // accidentially use these values below, before the names are stabililzed.
+    std::string CalculatedName, StableName;
+    std::tie(CalculatedName, StableName) =
+        constructKernelName(*this, KernelCallerFunc, MC);
+
+    // Attributes of a user-written SYCL kernel must be copied to the internally
+    // generated alternative kernel, identified by a known string in its name.
+    if (StableName.find("__pf_kernel_wrapper") != std::string::npos)
+      copySYCLKernelAttrs(CallOperator);
+  }
+
+  bool IsSIMDKernel = isESIMDKernelType(CallOperator);
+
+  SyclKernelArgsSizeChecker argsSizeChecker(*this, KernelObj->getLocation(),
+                                            IsSIMDKernel);
+  ESIMDKernelDiagnostics esimdKernel(*this, KernelObj->getLocation(),
+                                     IsSIMDKernel);
+
+  SyclKernelDeclCreator kernel_decl(*this, KernelObj->getLocation(),
+                                    KernelCallerFunc->isInlined(), IsSIMDKernel,
+                                    KernelCallerFunc);
+  SyclKernelBodyCreator kernel_body(*this, kernel_decl, KernelObj,
+                                    KernelCallerFunc, IsSIMDKernel,
+                                    CallOperator);
+  SyclKernelIntHeaderCreator int_header(
+      IsSIMDKernel, *this, getSyclIntegrationHeader(), KernelObj,
+      calculateKernelNameType(getASTContext(), KernelCallerFunc),
+      KernelCallerFunc);
+
+  SyclKernelIntFooterCreator int_footer(*this, getSyclIntegrationFooter());
+  SyclOptReportCreator opt_report(*this, kernel_decl, KernelObj->getLocation());
+
+  KernelObjVisitor Visitor{*this};
+
+  // Visit handlers to generate information for optimization record only if
+  // optimization record is saved.
+  if (!getLangOpts().OptRecordFile.empty()) {
+    Visitor.VisitKernelRecord(KernelObj, KernelObjTy, argsSizeChecker,
+                              esimdKernel, kernel_decl, kernel_body, int_header,
+                              int_footer, opt_report);
+  } else {
+    Visitor.VisitKernelRecord(KernelObj, KernelObjTy, argsSizeChecker,
+                              esimdKernel, kernel_decl, kernel_body, int_header,
+                              int_footer);
+  }
+
+  if (ParmVarDecl *KernelHandlerArg =
+          getSyclKernelHandlerArg(KernelCallerFunc)) {
+    kernel_decl.handleSyclKernelHandlerType();
+    kernel_body.handleSyclKernelHandlerType(KernelHandlerArg);
+    int_header.handleSyclKernelHandlerType(KernelHandlerArg->getType());
+
+    if (!getLangOpts().OptRecordFile.empty())
+      opt_report.handleSyclKernelHandlerType();
+  }
+}
+
+void ConstructFreeFunctionKernel(SemaSYCL &SemaSYCLRef, FunctionDecl *FD) {
+  SyclKernelArgsSizeChecker argsSizeChecker(SemaSYCLRef, FD->getLocation(),
+                                            false /*IsSIMDKernel*/);
+  SyclKernelDeclCreator kernel_decl(SemaSYCLRef, FD->getLocation(),
+                                    FD->isInlined(), false /*IsSIMDKernel */,
+                                    FD);
+
+  FreeFunctionKernelBodyCreator kernel_body(SemaSYCLRef, kernel_decl, FD);
+
+  SyclKernelIntHeaderCreator int_header(
+      SemaSYCLRef, SemaSYCLRef.getSyclIntegrationHeader(), FD->getType(), FD);
+
+  SyclKernelIntFooterCreator int_footer(SemaSYCLRef,
+                                        SemaSYCLRef.getSyclIntegrationFooter());
+  KernelObjVisitor Visitor{SemaSYCLRef};
+
+  Visitor.VisitFunctionParameters(FD, argsSizeChecker, kernel_decl, kernel_body,
+                                  int_header, int_footer);
+}
+
+// Figure out the sub-group for the this function.  First we check the
+// attributes, then the global settings.
+static std::pair<LangOptions::SubGroupSizeType, int64_t>
+CalcEffectiveSubGroup(ASTContext &Ctx, const LangOptions &LO,
+                      const FunctionDecl *FD) {
+  if (const auto *A = FD->getAttr<IntelReqdSubGroupSizeAttr>()) {
+    int64_t Val = getIntExprValue(A->getValue(), Ctx);
+    return {LangOptions::SubGroupSizeType::Integer, Val};
+  }
+
+  if (const auto *A = FD->getAttr<IntelNamedSubGroupSizeAttr>()) {
+    if (A->getType() == IntelNamedSubGroupSizeAttr::Primary)
+      return {LangOptions::SubGroupSizeType::Primary, 0};
+    return {LangOptions::SubGroupSizeType::Auto, 0};
+  }
+
+  // Return the global settings.
+  return {LO.getDefaultSubGroupSizeType(),
+          static_cast<uint64_t>(LO.DefaultSubGroupSize)};
+}
+
+static SourceLocation GetSubGroupLoc(const FunctionDecl *FD) {
+  if (const auto *A = FD->getAttr<IntelReqdSubGroupSizeAttr>())
+    return A->getLocation();
+  if (const auto *A = FD->getAttr<IntelNamedSubGroupSizeAttr>())
+    return A->getLocation();
+  return SourceLocation{};
+}
+
+static void CheckSYCL2020SubGroupSizes(SemaSYCL &S, FunctionDecl *SYCLKernel,
+                                       const FunctionDecl *FD) {
+  // If they are the same, no error.
+  if (CalcEffectiveSubGroup(S.getASTContext(), S.getLangOpts(), SYCLKernel) ==
+      CalcEffectiveSubGroup(S.getASTContext(), S.getLangOpts(), FD))
+    return;
+
+  // No need to validate __spirv routines here since they
+  // are mapped to the equivalent SPIRV operations.
+  const IdentifierInfo *II = FD->getIdentifier();
+  if (II && II->getName().starts_with("__spirv_"))
+    return;
+
+  // Else we need to figure out why they don't match.
+  SourceLocation FDAttrLoc = GetSubGroupLoc(FD);
+  SourceLocation KernelAttrLoc = GetSubGroupLoc(SYCLKernel);
+
+  if (FDAttrLoc.isValid()) {
+    // This side was caused by an attribute.
+    S.Diag(FDAttrLoc, diag::err_sycl_mismatch_group_size)
+        << /*kernel called*/ 0;
+
+    if (KernelAttrLoc.isValid()) {
+      S.Diag(KernelAttrLoc, diag::note_conflicting_attribute);
+    } else {
+      // Kernel is 'default'.
+      S.Diag(SYCLKernel->getLocation(), diag::note_sycl_kernel_declared_here);
+    }
+    return;
+  }
+
+  // Else this doesn't have an attribute, which can only be caused by this being
+  // an undefined SYCL_EXTERNAL, and the kernel has an attribute that conflicts.
+  if (const auto *A = SYCLKernel->getAttr<IntelReqdSubGroupSizeAttr>()) {
+    // Don't diagnose this if the kernel got its size from the 'old' attribute
+    // spelling.
+    if (!A->isSYCL2020Spelling())
+      return;
+  }
+
+  assert(KernelAttrLoc.isValid() && "Kernel doesn't have attribute either?");
+  S.Diag(FD->getLocation(), diag::err_sycl_mismatch_group_size)
+      << /*undefined SYCL_EXTERNAL*/ 1;
+  S.Diag(KernelAttrLoc, diag::note_conflicting_attribute);
+}
+
+// Check SYCL2020 Attributes.  2020 attributes don't propogate, they are only
+// valid if they match the attribute on the kernel. Note that this is a slight
+// difference from what the spec says, which says these attributes are only
+// valid on SYCL Kernels and SYCL_EXTERNAL, but we felt that for
+// self-documentation purposes that it would be nice to be able to repeat these
+// on subsequent functions.
+static void CheckSYCL2020Attributes(
+    SemaSYCL &S, FunctionDecl *SYCLKernel, FunctionDecl *KernelBody,
+    const llvm::SmallPtrSetImpl<FunctionDecl *> &CalledFuncs) {
+
+  if (KernelBody) {
+    // Make sure the kernel itself has all the 2020 attributes, since we don't
+    // do propagation of these.
+    if (auto *A = KernelBody->getAttr<IntelReqdSubGroupSizeAttr>())
+      if (A->isSYCL2020Spelling())
+        SYCLKernel->addAttr(A);
+    if (auto *A = KernelBody->getAttr<IntelNamedSubGroupSizeAttr>())
+      SYCLKernel->addAttr(A);
+
+    // If the kernel has a body, we should get the attributes for the kernel
+    // from there instead, so that we get the functor object.
+    SYCLKernel = KernelBody;
+  }
+
+  for (auto *FD : CalledFuncs) {
+    if (FD == SYCLKernel || FD == KernelBody)
+      continue;
+    for (auto *Attr : FD->attrs()) {
+      switch (Attr->getKind()) {
+      case attr::Kind::IntelReqdSubGroupSize:
+        // Pre SYCL2020 spellings handled during collection.
+        if (!cast<IntelReqdSubGroupSizeAttr>(Attr)->isSYCL2020Spelling())
+          break;
+        LLVM_FALLTHROUGH;
+      case attr::Kind::IntelNamedSubGroupSize:
+        CheckSYCL2020SubGroupSizes(S, SYCLKernel, FD);
+        break;
+      case attr::Kind::SYCLDevice:
+        // If a SYCL_EXTERNAL function is not defined in this TU, its necessary
+        // that it has a compatible sub-group-size. Don't diagnose if it has a
+        // sub-group attribute, we can count on the other checks to catch this.
+        if (!FD->isDefined() && !FD->hasAttr<IntelReqdSubGroupSizeAttr>() &&
+            !FD->hasAttr<IntelNamedSubGroupSizeAttr>())
+          CheckSYCL2020SubGroupSizes(S, SYCLKernel, FD);
+        break;
+      default:
+        break;
+      }
+    }
+  }
+}
+
+static void PropagateAndDiagnoseDeviceAttr(
+    SemaSYCL &S, const SingleDeviceFunctionTracker &Tracker, Attr *A,
+    FunctionDecl *SYCLKernel, FunctionDecl *KernelBody) {
+  switch (A->getKind()) {
+  case attr::Kind::IntelReqdSubGroupSize: {
+    auto *Attr = cast<IntelReqdSubGroupSizeAttr>(A);
+
+    if (Attr->isSYCL2020Spelling())
+      break;
+    const auto *KBSimdAttr =
+        KernelBody ? KernelBody->getAttr<SYCLSimdAttr>() : nullptr;
+    if (auto *Existing = SYCLKernel->getAttr<IntelReqdSubGroupSizeAttr>()) {
+      if (getIntExprValue(Existing->getValue(), S.getASTContext()) !=
+          getIntExprValue(Attr->getValue(), S.getASTContext())) {
+        S.Diag(SYCLKernel->getLocation(),
+               diag::err_conflicting_sycl_kernel_attributes);
+        S.Diag(Existing->getLocation(), diag::note_conflicting_attribute);
+        S.Diag(Attr->getLocation(), diag::note_conflicting_attribute);
+        SYCLKernel->setInvalidDecl();
+      }
+    } else if (KBSimdAttr &&
+               (getIntExprValue(Attr->getValue(), S.getASTContext()) != 1)) {
+      reportConflictingAttrs(S, KernelBody, KBSimdAttr, Attr);
+    } else {
+      SYCLKernel->addAttr(A);
+    }
+    break;
+  }
+  case attr::Kind::SYCLReqdWorkGroupSize: {
+    auto *RWGSA = cast<SYCLReqdWorkGroupSizeAttr>(A);
+    if (auto *Existing = SYCLKernel->getAttr<SYCLReqdWorkGroupSizeAttr>()) {
+      if (S.anyWorkGroupSizesDiffer(Existing->getXDim(), Existing->getYDim(),
+                                    Existing->getZDim(), RWGSA->getXDim(),
+                                    RWGSA->getYDim(), RWGSA->getZDim())) {
+        S.Diag(SYCLKernel->getLocation(),
+               diag::err_conflicting_sycl_kernel_attributes);
+        S.Diag(Existing->getLocation(), diag::note_conflicting_attribute);
+        S.Diag(RWGSA->getLocation(), diag::note_conflicting_attribute);
+        SYCLKernel->setInvalidDecl();
+      }
+    } else if (auto *Existing =
+                   SYCLKernel->getAttr<SYCLIntelMaxWorkGroupSizeAttr>()) {
+      if (S.checkMaxAllowedWorkGroupSize(
+              RWGSA->getXDim(), RWGSA->getYDim(), RWGSA->getZDim(),
+              Existing->getXDim(), Existing->getYDim(), Existing->getZDim())) {
+        S.Diag(SYCLKernel->getLocation(),
+               diag::err_conflicting_sycl_kernel_attributes);
+        S.Diag(Existing->getLocation(), diag::note_conflicting_attribute);
+        S.Diag(RWGSA->getLocation(), diag::note_conflicting_attribute);
+        SYCLKernel->setInvalidDecl();
+      } else {
+        SYCLKernel->addAttr(A);
+      }
+    } else {
+      SYCLKernel->addAttr(A);
+    }
+    break;
+  }
+  case attr::Kind::SYCLWorkGroupSizeHint: {
+    auto *WGSH = cast<SYCLWorkGroupSizeHintAttr>(A);
+    if (auto *Existing = SYCLKernel->getAttr<SYCLWorkGroupSizeHintAttr>()) {
+      if (S.anyWorkGroupSizesDiffer(Existing->getXDim(), Existing->getYDim(),
+                                    Existing->getZDim(), WGSH->getXDim(),
+                                    WGSH->getYDim(), WGSH->getZDim())) {
+        S.Diag(SYCLKernel->getLocation(),
+               diag::err_conflicting_sycl_kernel_attributes);
+        S.Diag(Existing->getLocation(), diag::note_conflicting_attribute);
+        S.Diag(WGSH->getLocation(), diag::note_conflicting_attribute);
+        SYCLKernel->setInvalidDecl();
+      }
+    }
+    SYCLKernel->addAttr(A);
+    break;
+  }
+  case attr::Kind::SYCLIntelMaxWorkGroupSize: {
+    auto *SIMWGSA = cast<SYCLIntelMaxWorkGroupSizeAttr>(A);
+    if (auto *Existing = SYCLKernel->getAttr<SYCLReqdWorkGroupSizeAttr>()) {
+      if (S.checkMaxAllowedWorkGroupSize(
+              Existing->getXDim(), Existing->getYDim(), Existing->getZDim(),
+              SIMWGSA->getXDim(), SIMWGSA->getYDim(), SIMWGSA->getZDim())) {
+        S.Diag(SYCLKernel->getLocation(),
+               diag::err_conflicting_sycl_kernel_attributes);
+        S.Diag(Existing->getLocation(), diag::note_conflicting_attribute);
+        S.Diag(SIMWGSA->getLocation(), diag::note_conflicting_attribute);
+        SYCLKernel->setInvalidDecl();
+      } else {
+        SYCLKernel->addAttr(A);
+      }
+    } else {
+      SYCLKernel->addAttr(A);
+    }
+    break;
+  }
+  case attr::Kind::SYCLSimd:
+    if (KernelBody && !KernelBody->getAttr<SYCLSimdAttr>()) {
+      // Usual kernel can't call ESIMD functions.
+      S.Diag(KernelBody->getLocation(),
+             diag::err_sycl_function_attribute_mismatch)
+          << A;
+      S.Diag(A->getLocation(), diag::note_attribute);
+      KernelBody->setInvalidDecl();
+      break;
+    }
+    LLVM_FALLTHROUGH;
+  case attr::Kind::SYCLIntelKernelArgsRestrict:
+  case attr::Kind::SYCLIntelNumSimdWorkItems:
+  case attr::Kind::SYCLIntelSchedulerTargetFmaxMhz:
+  case attr::Kind::SYCLIntelMaxGlobalWorkDim:
+  case attr::Kind::SYCLIntelMinWorkGroupsPerComputeUnit:
+  case attr::Kind::SYCLIntelMaxWorkGroupsPerMultiprocessor:
+  case attr::Kind::SYCLIntelNoGlobalWorkOffset:
+  case attr::Kind::SYCLIntelLoopFuse:
+  case attr::Kind::SYCLIntelMaxConcurrency:
+  case attr::Kind::SYCLIntelDisableLoopPipelining:
+  case attr::Kind::SYCLIntelInitiationInterval:
+  case attr::Kind::SYCLIntelUseStallEnableClusters:
+  case attr::Kind::SYCLDeviceHas:
+  case attr::Kind::SYCLAddIRAttributesFunction:
+    SYCLKernel->addAttr(A);
+    break;
+  case attr::Kind::IntelNamedSubGroupSize:
+    // Nothing to do here, handled in the SYCL2020 spelling.
+    break;
+  // TODO: vec_len_hint should be handled here
+  default:
+    // Seeing this means that CollectPossibleKernelAttributes was
+    // updated while this switch wasn't...or something went wrong
+    llvm_unreachable("Unexpected attribute was collected by "
+                     "CollectPossibleKernelAttributes");
+  }
+}
+
+void SemaSYCL::MarkDevices() {
+  // This Tracker object ensures that the SyclDeviceDecls collection includes
+  // the SYCL_EXTERNAL functions, and manages the diagnostics for all of the
+  // functions in the kernel.
+  DeviceFunctionTracker Tracker(*this);
+
+  for (Decl *D : syclDeviceDecls()) {
+    auto *SYCLKernel = cast<FunctionDecl>(D);
+
+    // This type does the actual analysis on a per-kernel basis. It does this to
+    // make sure that we're only ever dealing with the context of a single
+    // kernel at a time.
+    SingleDeviceFunctionTracker T{Tracker, SYCLKernel};
+
+    CheckSYCL2020Attributes(*this, T.GetSYCLKernel(), T.GetKernelBody(),
+                            T.GetDeviceFunctions());
+    for (auto *A : T.GetCollectedAttributes())
+      PropagateAndDiagnoseDeviceAttr(*this, T, A, T.GetSYCLKernel(),
+                                     T.GetKernelBody());
+    checkSYCLAddIRAttributesFunctionAttrConflicts(T.GetSYCLKernel());
+  }
+}
+
+void SemaSYCL::ProcessFreeFunction(FunctionDecl *FD) {
+  if (isFreeFunction(*this, FD)) {
+    SyclKernelDecompMarker DecompMarker(*this);
+    SyclKernelFieldChecker FieldChecker(*this);
+    SyclKernelUnionChecker UnionChecker(*this);
+
+    KernelObjVisitor Visitor{*this};
+
+    DiagnosingSYCLKernel = true;
+
+    // Check parameters of free function.
+    Visitor.VisitFunctionParameters(FD, DecompMarker, FieldChecker,
+                                    UnionChecker);
+
+    DiagnosingSYCLKernel = false;
+
+    // Ignore the free function if any of the checkers fail validation.
+    if (!FieldChecker.isValid() || !UnionChecker.isValid())
+      return;
+
+    ConstructFreeFunctionKernel(*this, FD);
+  }
+}
+
+// -----------------------------------------------------------------------------
+// SYCL device specific diagnostics implementation
+// -----------------------------------------------------------------------------
+
+Sema::SemaDiagnosticBuilder
+SemaSYCL::DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID,
+                           DeviceDiagnosticReason Reason) {
+  assert(getLangOpts().SYCLIsDevice &&
+         "Should only be called during SYCL compilation");
+  FunctionDecl *FD = dyn_cast<FunctionDecl>(SemaRef.getCurLexicalContext());
+  SemaDiagnosticBuilder::Kind DiagKind = [this, FD, Reason] {
+    if (DiagnosingSYCLKernel)
+      return SemaDiagnosticBuilder::K_ImmediateWithCallStack;
+    if (!FD)
+      return SemaDiagnosticBuilder::K_Nop;
+    if (SemaRef.isConstantEvaluatedContext() ||
+        SemaRef.currentEvaluationContext().isDiscardedStatementContext())
+      return SemaDiagnosticBuilder::K_Nop;
+    // Defer until we know that the variable's intializer is actually a
+    // manifestly constant-evaluated expression.
+    if (SemaRef.InConstexprVarInit)
+      return SemaDiagnosticBuilder::K_Deferred;
+    if (SemaRef.getEmissionStatus(FD) ==
+        Sema::FunctionEmissionStatus::Emitted) {
+      // Skip the diagnostic if we know it won't be emitted.
+      if ((SemaRef.getEmissionReason(FD) & Reason) ==
+          Sema::DeviceDiagnosticReason::None)
+        return SemaDiagnosticBuilder::K_Nop;
+
+      return SemaDiagnosticBuilder::K_ImmediateWithCallStack;
+    }
+    return SemaDiagnosticBuilder::K_Deferred;
+  }();
+  return SemaDiagnosticBuilder(DiagKind, Loc, DiagID, FD, SemaRef, Reason);
+}
+
+void SemaSYCL::deepTypeCheckForDevice(SourceLocation UsedAt,
+                                      llvm::DenseSet<QualType> Visited,
+                                      ValueDecl *DeclToCheck) {
+  assert(getLangOpts().SYCLIsDevice &&
+         "Should only be called during SYCL compilation");
+  // Emit notes only for the first discovered declaration of unsupported type
+  // to avoid mess of notes. This flag is to track that error already happened.
+  bool NeedToEmitNotes = true;
+
+  auto Check = [&](QualType TypeToCheck, const ValueDecl *D) {
+    bool ErrorFound = false;
+    if (isZeroSizedArray(*this, TypeToCheck)) {
+      DiagIfDeviceCode(UsedAt, diag::err_typecheck_zero_array_size) << 1;
+      ErrorFound = true;
+    }
+    // Checks for other types can also be done here.
+    if (ErrorFound) {
+      if (NeedToEmitNotes) {
+        if (auto *FD = dyn_cast<FieldDecl>(D))
+          DiagIfDeviceCode(FD->getLocation(),
+                           diag::note_illegal_field_declared_here)
+              << FD->getType()->isPointerType() << FD->getType();
+        else
+          DiagIfDeviceCode(D->getLocation(), diag::note_declared_at);
+      }
+    }
+
+    return ErrorFound;
+  };
+
+  // In case we have a Record used do the DFS for a bad field.
+  SmallVector<const ValueDecl *, 4> StackForRecursion;
+  StackForRecursion.push_back(DeclToCheck);
+
+  // While doing DFS save how we get there to emit a nice set of notes.
+  SmallVector<const FieldDecl *, 4> History;
+  History.push_back(nullptr);
+
+  do {
+    const ValueDecl *Next = StackForRecursion.pop_back_val();
+    if (!Next) {
+      assert(!History.empty());
+      // Found a marker, we have gone up a level.
+      History.pop_back();
+      continue;
+    }
+    QualType NextTy = Next->getType();
+
+    if (!Visited.insert(NextTy).second)
+      continue;
+
+    auto EmitHistory = [&]() {
+      // The first element is always nullptr.
+      for (uint64_t Index = 1; Index < History.size(); ++Index) {
+        DiagIfDeviceCode(History[Index]->getLocation(),
+                         diag::note_within_field_of_type)
+            << History[Index]->getType();
+      }
+    };
+
+    if (Check(NextTy, Next)) {
+      if (NeedToEmitNotes)
+        EmitHistory();
+      NeedToEmitNotes = false;
+    }
+
+    // In case pointer/array/reference type is met get pointee type, then
+    // proceed with that type.
+    while (NextTy->isAnyPointerType() || NextTy->isArrayType() ||
+           NextTy->isReferenceType()) {
+      if (NextTy->isArrayType())
+        NextTy = QualType{NextTy->getArrayElementTypeNoTypeQual(), 0};
+      else
+        NextTy = NextTy->getPointeeType();
+      if (Check(NextTy, Next)) {
+        if (NeedToEmitNotes)
+          EmitHistory();
+        NeedToEmitNotes = false;
+      }
+    }
+
+    if (const auto *RecDecl = NextTy->getAsRecordDecl()) {
+      if (auto *NextFD = dyn_cast<FieldDecl>(Next))
+        History.push_back(NextFD);
+      // When nullptr is discovered, this means we've gone back up a level, so
+      // the history should be cleaned.
+      StackForRecursion.push_back(nullptr);
+      llvm::copy(RecDecl->fields(), std::back_inserter(StackForRecursion));
+    }
+  } while (!StackForRecursion.empty());
+}
+
+void SemaSYCL::finalizeSYCLDelayedAnalysis(const FunctionDecl *Caller,
+                                           const FunctionDecl *Callee,
+                                           SourceLocation Loc,
+                                           DeviceDiagnosticReason Reason) {
+  Callee = Callee->getMostRecentDecl();
+
+  // If the reason for the emission of this diagnostic is not SYCL-specific,
+  // and it is not known to be reachable from a routine on device, do not
+  // issue a diagnostic.
+  if ((Reason & DeviceDiagnosticReason::Sycl) == DeviceDiagnosticReason::None &&
+      !isFDReachableFromSyclDevice(Callee, Caller))
+    return;
+
+  // If Callee has a SYCL attribute, no diagnostic needed.
+  if (Callee->hasAttr<SYCLDeviceAttr>() || Callee->hasAttr<SYCLKernelAttr>())
+    return;
+
+  // If Callee has a CUDA device attribute, no diagnostic needed.
+  if (getLangOpts().CUDA && Callee->hasAttr<CUDADeviceAttr>())
+    return;
+
+  // Diagnose if this is an undefined function and it is not a builtin.
+  // Currently, there is an exception of "__failed_assertion" in libstdc++-11,
+  // this undefined function is used to trigger a compiling error.
+  if (!Callee->isDefined() && !Callee->getBuiltinID() &&
+      !Callee->isReplaceableGlobalAllocationFunction() &&
+      !isSYCLUndefinedAllowed(Callee, SemaRef.getSourceManager())) {
+    Diag(Loc, diag::err_sycl_restrict) << SemaSYCL::KernelCallUndefinedFunction;
+    Diag(Callee->getLocation(), diag::note_previous_decl) << Callee;
+    Diag(Caller->getLocation(), diag::note_called_by) << Caller;
+  }
+}
+
+bool SemaSYCL::checkAllowedSYCLInitializer(VarDecl *VD) {
+  assert(getLangOpts().SYCLIsDevice &&
+         "Should only be called during SYCL compilation");
+
+  if (VD->isInvalidDecl() || !VD->hasInit() || !VD->hasGlobalStorage())
+    return true;
+
+  const Expr *Init = VD->getInit();
+  bool ValueDependent = Init && Init->isValueDependent();
+  bool isConstantInit = Init && !ValueDependent &&
+                        Init->isConstantInitializer(getASTContext(), false);
+  if (!VD->isConstexpr() && Init && !ValueDependent && !isConstantInit)
+    return false;
+
+  return true;
+}
+
+// -----------------------------------------------------------------------------
+// Integration header functionality implementation
+// -----------------------------------------------------------------------------
+
+/// Returns a string ID of given parameter kind - used in header
+/// emission.
+static const char *paramKind2Str(KernelParamKind K) {
+#define CASE(x)                                                                \
+  case SYCLIntegrationHeader::kind_##x:                                        \
+    return "kind_" #x
+  switch (K) {
+    CASE(accessor);
+    CASE(std_layout);
+    CASE(sampler);
+    CASE(stream);
+    CASE(specialization_constants_buffer);
+    CASE(pointer);
+    CASE(work_group_memory);
+  }
+  return "<ERROR>";
+
+#undef CASE
+}
+
+// Emits forward declarations of classes and template classes on which
+// declaration of given type depends.
+// For example, consider SimpleVadd
+// class specialization in parallel_for below:
+//
+//   template <typename T1, unsigned int N, typename ... T2>
+//   class SimpleVadd;
+//   ...
+//   template <unsigned int N, typename T1, typename ... T2>
+//   void simple_vadd(const std::array<T1, N>& VA, const std::array<T1, N>&
+//   VB,
+//     std::array<T1, N>& VC, int param, T2 ... varargs) {
+//     ...
+//     deviceQueue.submit([&](sycl::handler& cgh) {
+//       ...
+//       cgh.parallel_for<class SimpleVadd<T1, N, T2...>>(...)
+//       ...
+//     }
+//     ...
+//   }
+//   ...
+//   class MyClass {...};
+//   template <typename T> class MyInnerTmplClass { ... }
+//   template <typename T> class MyTmplClass { ... }
+//   ...
+//   MyClass *c = new MyClass();
+//   MyInnerTmplClass<MyClass**> c1(&c);
+//   simple_vadd(A, B, C, 5, 'a', 1.f,
+//     new MyTmplClass<MyInnerTmplClass<MyClass**>>(c1));
+//
+// it will generate the following forward declarations:
+//   class MyClass;
+//   template <typename T> class MyInnerTmplClass;
+//   template <typename T> class MyTmplClass;
+//   template <typename T1, unsigned int N, typename ...T2> class SimpleVadd;
+//
+class SYCLFwdDeclEmitter
+    : public TypeVisitor<SYCLFwdDeclEmitter>,
+      public ConstTemplateArgumentVisitor<SYCLFwdDeclEmitter> {
+  using InnerTypeVisitor = TypeVisitor<SYCLFwdDeclEmitter>;
+  using InnerTemplArgVisitor = ConstTemplateArgumentVisitor<SYCLFwdDeclEmitter>;
+  raw_ostream &OS;
+  llvm::SmallPtrSet<const NamedDecl *, 4> Printed;
+  PrintingPolicy Policy;
+
+  void printForwardDecl(NamedDecl *D) {
+    // wrap the declaration into namespaces if needed
+    unsigned NamespaceCnt = 0;
+    std::string NSStr = "";
+    const DeclContext *DC = D->getDeclContext();
+
+    while (DC) {
+      if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
+        ++NamespaceCnt;
+        StringRef NSInlinePrefix = NS->isInline() ? "inline " : "";
+        NSStr.insert(
+            0,
+            Twine(NSInlinePrefix + "namespace " + NS->getName() + " { ").str());
+        DC = NS->getDeclContext();
+      } else {
+        // We should be able to handle a subset of the decl-context types to
+        // make our namespaces for forward declarations as specific as possible,
+        // so just skip them here.  We can't use their names, since they would
+        // not be forward declarable, but we can try to make them as specific as
+        // possible.
+        // This permits things such as:
+        // namespace N1 { void foo() { kernel<class K>(...); }}
+        // and
+        // namespace N2 { void foo() { kernel<class K>(...); }}
+        // to co-exist, despite technically being against the SYCL rules.
+        // See SYCLKernelNameTypePrinter for the corresponding part that prints
+        // the kernel information for this type. These two must match.
+        if (isa<FunctionDecl, RecordDecl, LinkageSpecDecl>(DC)) {
+          DC = cast<Decl>(DC)->getDeclContext();
+        } else {
+          break;
+        }
+      }
+    }
+    OS << NSStr;
+    if (NamespaceCnt > 0)
+      OS << "\n";
+
+    D->print(OS, Policy);
+
+    if (const auto *ED = dyn_cast<EnumDecl>(D)) {
+      QualType T = ED->getIntegerType().getCanonicalType();
+      // Backup since getIntegerType() returns null for enum forward
+      // declaration with no fixed underlying type
+      if (T.isNull())
+        T = ED->getPromotionType();
+      OS << " : " << T.getAsString();
+    }
+
+    OS << ";\n";
+
+    // print closing braces for namespaces if needed
+    for (unsigned I = 0; I < NamespaceCnt; ++I)
+      OS << "}";
+    if (NamespaceCnt > 0)
+      OS << "\n";
+  }
+
+  // Checks if we've already printed forward declaration and prints it if not.
+  void checkAndEmitForwardDecl(NamedDecl *D) {
+    if (Printed.insert(D).second)
+      printForwardDecl(D);
+  }
+
+  void VisitTemplateArgs(ArrayRef<TemplateArgument> Args) {
+    for (size_t I = 0, E = Args.size(); I < E; ++I)
+      Visit(Args[I]);
+  }
+
+public:
+  SYCLFwdDeclEmitter(raw_ostream &OS, const LangOptions &LO)
+      : OS(OS), Policy(LO) {
+    Policy.adjustForCPlusPlusFwdDecl();
+    Policy.SuppressTypedefs = true;
+    Policy.SuppressUnwrittenScope = true;
+    Policy.PrintCanonicalTypes = true;
+    Policy.SkipCanonicalizationOfTemplateTypeParms = true;
+    Policy.SuppressFinalSpecifier = true;
+  }
+
+  void Visit(QualType T) {
+    if (T.isNull())
+      return;
+    InnerTypeVisitor::Visit(T.getTypePtr());
+  }
+
+  void VisitReferenceType(const ReferenceType *RT) {
+    // Our forward declarations don't care about references, so we should just
+    // ignore the reference and continue on.
+    Visit(RT->getPointeeType());
+  }
+
+  void Visit(const TemplateArgument &TA) {
+    if (TA.isNull())
+      return;
+    InnerTemplArgVisitor::Visit(TA);
+  }
+
+  void VisitPointerType(const PointerType *T) {
+    // Peel off the pointer types.
+    QualType PT = T->getPointeeType();
+    while (PT->isPointerType())
+      PT = PT->getPointeeType();
+    Visit(PT);
+  }
+
+  void VisitTagType(const TagType *T) {
+    TagDecl *TD = T->getDecl();
+    if (const auto *TSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
+      // - first, recurse into template parameters and emit needed forward
+      //   declarations
+      ArrayRef<TemplateArgument> Args = TSD->getTemplateArgs().asArray();
+      VisitTemplateArgs(Args);
+      // - second, emit forward declaration for the template class being
+      //   specialized
+      ClassTemplateDecl *CTD = TSD->getSpecializedTemplate();
+      assert(CTD && "template declaration must be available");
+
+      checkAndEmitForwardDecl(CTD);
+      return;
+    }
+    checkAndEmitForwardDecl(TD);
+  }
+
+  void VisitTypeTemplateArgument(const TemplateArgument &TA) {
+    QualType T = TA.getAsType();
+    Visit(T);
+  }
+
+  void VisitIntegralTemplateArgument(const TemplateArgument &TA) {
+    QualType T = TA.getIntegralType();
+    if (const EnumType *ET = T->getAs<EnumType>())
+      VisitTagType(ET);
+  }
+
+  void VisitTemplateTemplateArgument(const TemplateArgument &TA) {
+    // recursion is not required, since the maximum possible nesting level
+    // equals two for template argument
+    //
+    // for example:
+    //   template <typename T> class Bar;
+    //   template <template <typename> class> class Baz;
+    //   template <template <template <typename> class> class T>
+    //   class Foo;
+    //
+    // The Baz is a template class. The Baz<Bar> is a class. The class Foo
+    // should be specialized with template class, not a class. The correct
+    // specialization of template class Foo is Foo<Baz>. The incorrect
+    // specialization of template class Foo is Foo<Baz<Bar>>. In this case
+    // template class Foo specialized by class Baz<Bar>, not a template
+    // class template <template <typename> class> class T as it should.
+    TemplateDecl *TD = TA.getAsTemplate().getAsTemplateDecl();
+    assert(TD && "template declaration must be available");
+    TemplateParameterList *TemplateParams = TD->getTemplateParameters();
+    for (NamedDecl *P : *TemplateParams) {
+      // If template template parameter type has an enum value template
+      // parameter, forward declaration of enum type is required. Only enum
+      // values (not types) need to be handled. For example, consider the
+      // following kernel name type:
+      //
+      // template <typename EnumTypeOut, template <EnumValueIn EnumValue,
+      // typename TypeIn> class T> class Foo;
+      //
+      // The correct specialization for Foo (with enum type) is:
+      // Foo<EnumTypeOut, Baz>, where Baz is a template class.
+      //
+      // Therefore the forward class declarations generated in the
+      // integration header are:
+      // template <EnumValueIn EnumValue, typename TypeIn> class Baz;
+      // template <typename EnumTypeOut, template <EnumValueIn EnumValue,
+      // typename EnumTypeIn> class T> class Foo;
+      //
+      // This requires the following enum forward declarations:
+      // enum class EnumTypeOut : int; (Used to template Foo)
+      // enum class EnumValueIn : int; (Used to template Baz)
+      if (NonTypeTemplateParmDecl *TemplateParam =
+              dyn_cast<NonTypeTemplateParmDecl>(P))
+        if (const EnumType *ET = TemplateParam->getType()->getAs<EnumType>())
+          VisitTagType(ET);
+    }
+    checkAndEmitForwardDecl(TD);
+  }
+
+  void VisitPackTemplateArgument(const TemplateArgument &TA) {
+    VisitTemplateArgs(TA.getPackAsArray());
+  }
+
+  void VisitFunctionProtoType(const FunctionProtoType *T) {
+    for (const auto Ty : T->getParamTypes())
+      Visit(Ty.getCanonicalType());
+    // So far this visitor method is only used for free function kernels whose
+    // return type is void anyway, so it is not visited. Otherwise, add if
+    // required.
+  }
+};
+
+class SYCLKernelNameTypePrinter
+    : public TypeVisitor<SYCLKernelNameTypePrinter>,
+      public ConstTemplateArgumentVisitor<SYCLKernelNameTypePrinter> {
+  using InnerTypeVisitor = TypeVisitor<SYCLKernelNameTypePrinter>;
+  using InnerTemplArgVisitor =
+      ConstTemplateArgumentVisitor<SYCLKernelNameTypePrinter>;
+  raw_ostream &OS;
+  PrintingPolicy &Policy;
+
+  void printTemplateArgs(ArrayRef<TemplateArgument> Args) {
+    for (size_t I = 0, E = Args.size(); I < E; ++I) {
+      const TemplateArgument &Arg = Args[I];
+      // If argument is an empty pack argument, skip printing comma and
+      // argument.
+      if (Arg.getKind() == TemplateArgument::ArgKind::Pack && !Arg.pack_size())
+        continue;
+
+      if (I)
+        OS << ", ";
+
+      Visit(Arg);
+    }
+  }
+
+  void VisitQualifiers(Qualifiers Quals) {
+    Quals.print(OS, Policy, /*appendSpaceIfNotEmpty*/ true);
+  }
+
+  // Use recursion to print the namespace-qualified name for the purposes of the
+  // canonical sycl example of a type being created in the kernel call.
+  void PrintNamespaceScopes(const DeclContext *DC) {
+    if (isa<NamespaceDecl, FunctionDecl, RecordDecl, LinkageSpecDecl>(DC)) {
+      PrintNamespaceScopes(DC->getParent());
+
+      const auto *NS = dyn_cast<NamespaceDecl>(DC);
+      if (NS && !NS->isAnonymousNamespace())
+        OS << NS->getName() << "::";
+    }
+  }
+
+public:
+  SYCLKernelNameTypePrinter(raw_ostream &OS, PrintingPolicy &Policy)
+      : OS(OS), Policy(Policy) {}
+
+  void Visit(QualType T) {
+    if (T.isNull())
+      return;
+
+    QualType CT = T.getCanonicalType();
+    VisitQualifiers(CT.getQualifiers());
+
+    InnerTypeVisitor::Visit(CT.getTypePtr());
+  }
+
+  void VisitType(const Type *T) {
+    OS << QualType::getAsString(T, Qualifiers(), Policy);
+  }
+
+  void Visit(const TemplateArgument &TA) {
+    if (TA.isNull())
+      return;
+    InnerTemplArgVisitor::Visit(TA);
+  }
+
+  void VisitTagType(const TagType *T) {
+    TagDecl *RD = T->getDecl();
+    if (const auto *TSD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
+
+      // Print template class name
+      TSD->printQualifiedName(OS, Policy, /*WithGlobalNsPrefix*/ true);
+
+      ArrayRef<TemplateArgument> Args = TSD->getTemplateArgs().asArray();
+      OS << "<";
+      printTemplateArgs(Args);
+      OS << ">";
+
+      return;
+    }
+
+    // Handle the canonical sycl example where the type is created for the first
+    // time in the kernel naming. We want to qualify this as fully as we can,
+    // but not in a way that won't be forward declarable.  See
+    // SYCLFwdDeclEmitter::printForwardDecl for the corresponding list for
+    // printing the forward declaration, these two must match.
+    DeclContext *DC = RD->getDeclContext();
+    if (isa<FunctionDecl, RecordDecl, LinkageSpecDecl>(DC)) {
+      PrintNamespaceScopes(DC);
+      RD->printName(OS, Policy);
+      return;
+    }
+
+    const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(RD->getDeclContext());
+    RD->printQualifiedName(OS, Policy, !(NS && NS->isAnonymousNamespace()));
+  }
+
+  void VisitTemplateArgument(const TemplateArgument &TA) {
+    TA.print(Policy, OS, false /* IncludeType */);
+  }
+
+  void VisitTypeTemplateArgument(const TemplateArgument &TA) {
+    Policy.SuppressTagKeyword = true;
+    QualType T = TA.getAsType();
+    Visit(T);
+    Policy.SuppressTagKeyword = false;
+  }
+
+  void VisitIntegralTemplateArgument(const TemplateArgument &TA) {
+    QualType T = TA.getIntegralType();
+    if (const EnumType *ET = T->getAs<EnumType>()) {
+      const llvm::APSInt &Val = TA.getAsIntegral();
+      OS << "static_cast<";
+      ET->getDecl()->printQualifiedName(OS, Policy,
+                                        /*WithGlobalNsPrefix*/ true);
+      OS << ">(" << Val << ")";
+    } else {
+      TA.print(Policy, OS, false /* IncludeType */);
+    }
+  }
+
+  void VisitTemplateTemplateArgument(const TemplateArgument &TA) {
+    TemplateDecl *TD = TA.getAsTemplate().getAsTemplateDecl();
+    TD->printQualifiedName(OS, Policy);
+  }
+
+  void VisitPackTemplateArgument(const TemplateArgument &TA) {
+    printTemplateArgs(TA.getPackAsArray());
+  }
+};
+
+static void OutputStableNameChar(raw_ostream &O, char C) {
+  // If it is reliably printable, print in the integration header as a
+  // character. Else just print it as the integral representation.
+  if (llvm::isPrint(C))
+    O << '\'' << C << '\'';
+  else
+    O << static_cast<short>(C);
+}
+
+static void OutputStableNameInChars(raw_ostream &O, StringRef Name) {
+  assert(!Name.empty() && "Expected a nonempty string!");
+  OutputStableNameChar(O, Name[0]);
+
+  for (char C : Name.substr(1)) {
+    O << ", ";
+    OutputStableNameChar(O, C);
+  }
+}
+
+static void EmitPragmaDiagnosticPush(raw_ostream &O, StringRef DiagName) {
+  O << "\n";
+  O << "#ifdef __clang__\n";
+  O << "#pragma clang diagnostic push\n";
+  O << "#pragma clang diagnostic ignored \"" << DiagName.str() << "\"\n";
+  O << "#endif // defined(__clang__)\n";
+  O << "\n";
+}
+
+static void EmitPragmaDiagnosticPop(raw_ostream &O) {
+  O << "\n";
+  O << "#ifdef __clang__\n";
+  O << "#pragma clang diagnostic pop\n";
+  O << "#endif // defined(__clang__)\n";
+  O << "\n";
+}
+
+void SYCLIntegrationHeader::emit(raw_ostream &O) {
+  O << "// This is auto-generated SYCL integration header.\n";
+  O << "\n";
+
+  O << "#include <sycl/detail/defines_elementary.hpp>\n";
+  O << "#include <sycl/detail/kernel_desc.hpp>\n";
+  O << "#include <sycl/ext/oneapi/experimental/free_function_traits.hpp>\n";
+
+  O << "\n";
+
+  LangOptions LO;
+  PrintingPolicy Policy(LO);
+  Policy.SuppressTypedefs = true;
+  Policy.SuppressUnwrittenScope = true;
+  // Disable printing anonymous tag locations because on Windows
+  // file path separators are treated as escape sequences and cause errors
+  // when integration header is compiled with host compiler.
+  Policy.AnonymousTagLocations = 0;
+  SYCLFwdDeclEmitter FwdDeclEmitter(O, S.getLangOpts());
+
+  // Predefines which need to be set for custom host compilation
+  // must be defined in integration header.
+  for (const std::pair<StringRef, StringRef> &Macro :
+       getSYCLVersionMacros(S.getLangOpts())) {
+    O << "#ifndef " << Macro.first << '\n';
+    O << "#define " << Macro.first << " " << Macro.second << '\n';
+    O << "#endif //" << Macro.first << "\n\n";
+  }
+
+  switch (S.getLangOpts().getSYCLRangeRounding()) {
+  case LangOptions::SYCLRangeRoundingPreference::Disable:
+    O << "#ifndef __SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING__ \n";
+    O << "#define __SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING__ 1\n";
+    O << "#endif //__SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING__\n\n";
+    break;
+  case LangOptions::SYCLRangeRoundingPreference::Force:
+    O << "#ifndef __SYCL_FORCE_PARALLEL_FOR_RANGE_ROUNDING__ \n";
+    O << "#define __SYCL_FORCE_PARALLEL_FOR_RANGE_ROUNDING__ 1\n";
+    O << "#endif //__SYCL_FORCE_PARALLEL_FOR_RANGE_ROUNDING__\n\n";
+    break;
+  default:
+    break;
+  }
+
+  if (S.getLangOpts().SYCLExperimentalRangeRounding) {
+    O << "#ifndef __SYCL_EXP_PARALLEL_FOR_RANGE_ROUNDING__ \n";
+    O << "#define __SYCL_EXP_PARALLEL_FOR_RANGE_ROUNDING__ 1\n";
+    O << "#endif //__SYCL_EXP_PARALLEL_FOR_RANGE_ROUNDING__\n\n";
+  }
+
+  if (SpecConsts.size() > 0) {
+    O << "// Forward declarations of templated spec constant types:\n";
+    for (const auto &SC : SpecConsts)
+      FwdDeclEmitter.Visit(SC.first);
+    O << "\n";
+
+    // Remove duplicates.
+    std::sort(SpecConsts.begin(), SpecConsts.end(),
+              [](const SpecConstID &SC1, const SpecConstID &SC2) {
+                // Sort by string IDs for stable spec consts order in the
+                // header.
+                return SC1.second.compare(SC2.second) < 0;
+              });
+    SpecConstID *End =
+        std::unique(SpecConsts.begin(), SpecConsts.end(),
+                    [](const SpecConstID &SC1, const SpecConstID &SC2) {
+                      // Here can do faster comparison of types.
+                      return SC1.first == SC2.first;
+                    });
+
+    O << "// Specialization constants IDs:\n";
+    for (const auto &P : llvm::make_range(SpecConsts.begin(), End)) {
+      O << "template <> struct sycl::detail::SpecConstantInfo<";
+      SYCLKernelNameTypePrinter Printer(O, Policy);
+      Printer.Visit(P.first);
+      O << "> {\n";
+      O << "  static constexpr const char* getName() {\n";
+      O << "    return \"" << P.second << "\";\n";
+      O << "  }\n";
+      O << "};\n";
+    }
+  }
+
+  O << "// Forward declarations of templated kernel function types:\n";
+  for (const KernelDesc &K : KernelDescs)
+    if (!K.IsUnnamedKernel)
+      FwdDeclEmitter.Visit(K.NameType);
+  O << "\n";
+
+  O << "namespace sycl {\n";
+  O << "inline namespace _V1 {\n";
+  O << "namespace detail {\n";
+
+  // Generate declaration of variable of type __sycl_device_global_registration
+  // whose sole purpose is to run its constructor before the application's
+  // main() function.
+
+  if (NeedToEmitDeviceGlobalRegistration) {
+    // Supress the reserved identifier diagnostic that clang generates
+    // for the construct below.
+    EmitPragmaDiagnosticPush(O, "-Wreserved-identifier");
+    O << "namespace {\n";
+
+    O << "class __sycl_device_global_registration {\n";
+    O << "public:\n";
+    O << "  __sycl_device_global_registration() noexcept;\n";
+    O << "};\n";
+    O << "__sycl_device_global_registration __sycl_device_global_registrar;\n";
+
+    O << "} // namespace\n";
+
+    O << "\n";
+    EmitPragmaDiagnosticPop(O);
+  }
+
+  // Generate declaration of variable of type __sycl_host_pipe_registration
+  // whose sole purpose is to run its constructor before the application's
+  // main() function.
+  if (NeedToEmitHostPipeRegistration) {
+    // Supress the reserved identifier diagnostic that clang generates
+    // for the construct below.
+    EmitPragmaDiagnosticPush(O, "-Wreserved-identifier");
+    O << "namespace {\n";
+
+    O << "class __sycl_host_pipe_registration {\n";
+    O << "public:\n";
+    O << "  __sycl_host_pipe_registration() noexcept;\n";
+    O << "};\n";
+    O << "__sycl_host_pipe_registration __sycl_host_pipe_registrar;\n";
+
+    O << "} // namespace\n";
+
+    O << "\n";
+    EmitPragmaDiagnosticPop(O);
+  }
+
+
+  O << "// names of all kernels defined in the corresponding source\n";
+  O << "static constexpr\n";
+  O << "const char* const kernel_names[] = {\n";
+
+  for (unsigned I = 0; I < KernelDescs.size(); I++) {
+    O << "  \"" << KernelDescs[I].Name << "\",\n";
+  }
+  // Add a sentinel to avoid warning if the collection is empty
+  // (similar to what we do for kernel_signatures below).
+  O << "  \"\",\n";
+  O << "};\n\n";
+
+  O << "// array representing signatures of all kernels defined in the\n";
+  O << "// corresponding source\n";
+  O << "static constexpr\n";
+  O << "const kernel_param_desc_t kernel_signatures[] = {\n";
+
+  for (unsigned I = 0; I < KernelDescs.size(); I++) {
+    auto &K = KernelDescs[I];
+    O << "  //--- " << K.Name << "\n";
+
+    for (const auto &P : K.Params) {
+      std::string TyStr = paramKind2Str(P.Kind);
+      O << "  { kernel_param_kind_t::" << TyStr << ", ";
+      O << P.Info << ", " << P.Offset << " },\n";
+    }
+    O << "\n";
+  }
+
+  // Sentinel in place for 2 reasons:
+  // 1- to make sure we don't get a warning because this collection is empty.
+  // 2- to provide an obvious value that we can use when debugging to see that
+  //    we have left valid kernel information.
+  // integer-field values are negative, so they are obviously invalid, notable
+  // enough to 'stick out' and 'negative enough' to not be easily reachable by a
+  // mathematical error.
+  O << "  { kernel_param_kind_t::kind_invalid, -987654321, -987654321 }, \n";
+  O << "};\n\n";
+
+  O << "// Specializations of KernelInfo for kernel function types:\n";
+  unsigned CurStart = 0;
+
+  for (const KernelDesc &K : KernelDescs) {
+    const size_t N = K.Params.size();
+    PresumedLoc PLoc = S.getASTContext().getSourceManager().getPresumedLoc(
+        S.getASTContext()
+            .getSourceManager()
+            .getExpansionRange(K.KernelLocation)
+            .getEnd());
+    if (K.IsUnnamedKernel) {
+      O << "template <> struct KernelInfoData<";
+      OutputStableNameInChars(O, K.StableName);
+      O << "> {\n";
+    } else {
+      O << "template <> struct KernelInfo<";
+      SYCLKernelNameTypePrinter Printer(O, Policy);
+      Printer.Visit(K.NameType);
+      O << "> {\n";
+    }
+
+    O << "  __SYCL_DLL_LOCAL\n";
+    O << "  static constexpr const char* getName() { return \"" << K.Name
+      << "\"; }\n";
+    O << "  __SYCL_DLL_LOCAL\n";
+    O << "  static constexpr unsigned getNumParams() { return " << N << "; }\n";
+    O << "  __SYCL_DLL_LOCAL\n";
+    O << "  static constexpr const kernel_param_desc_t& ";
+    O << "getParamDesc(unsigned i) {\n";
+    O << "    return kernel_signatures[i+" << CurStart << "];\n";
+    O << "  }\n";
+    O << "  __SYCL_DLL_LOCAL\n";
+    O << "  static constexpr bool isESIMD() { return " << K.IsESIMDKernel
+      << "; }\n";
+    O << "  __SYCL_DLL_LOCAL\n";
+    O << "  static constexpr const char* getFileName() {\n";
+    O << "#ifndef NDEBUG\n";
+    O << "    return \""
+      << std::string(PLoc.getFilename())
+             .substr(std::string(PLoc.getFilename()).find_last_of("/\\") + 1);
+    O << "\";\n";
+    O << "#else\n";
+    O << "    return \"\";\n";
+    O << "#endif\n";
+    O << "  }\n";
+    O << "  __SYCL_DLL_LOCAL\n";
+    O << "  static constexpr const char* getFunctionName() {\n";
+    O << "#ifndef NDEBUG\n";
+    O << "    return \"";
+    SYCLKernelNameTypePrinter Printer(O, Policy);
+    Printer.Visit(K.NameType);
+    O << "\";\n";
+    O << "#else\n";
+    O << "    return \"\";\n";
+    O << "#endif\n";
+    O << "  }\n";
+    O << "  __SYCL_DLL_LOCAL\n";
+    O << "  static constexpr unsigned getLineNumber() {\n";
+    O << "#ifndef NDEBUG\n";
+    O << "    return " << PLoc.getLine() << ";\n";
+    O << "#else\n";
+    O << "    return 0;\n";
+    O << "#endif\n";
+    O << "  }\n";
+    O << "  __SYCL_DLL_LOCAL\n";
+    O << "  static constexpr unsigned getColumnNumber() {\n";
+    O << "#ifndef NDEBUG\n";
+    O << "    return " << PLoc.getColumn() << ";\n";
+    O << "#else\n";
+    O << "    return 0;\n";
+    O << "#endif\n";
+    O << "  }\n";
+    StringRef ReturnType = (S.getASTContext().getTargetInfo().getInt64Type() ==
+                            TargetInfo::SignedLong)
+                               ? "long"
+                               : "long long";
+    O << "  // Returns the size of the kernel object in bytes.\n";
+    O << "  __SYCL_DLL_LOCAL\n";
+    O << "  static constexpr " << ReturnType << " getKernelSize() { return "
+      << K.ObjSize << "; }\n";
+    O << "};\n";
+    CurStart += N;
+  }
+  O << "\n";
+  O << "} // namespace detail\n";
+  O << "} // namespace _V1\n";
+  O << "} // namespace sycl\n";
+
+  unsigned ShimCounter = 1;
+  int FreeFunctionCount = 0;
+  for (const KernelDesc &K : KernelDescs) {
+    if (!isFreeFunction(S, K.SyclKernel))
+      continue;
+    ++FreeFunctionCount;
+    // Generate forward declaration for free function.
+    O << "\n// Definition of " << K.Name << " as a free function kernel\n";
+
+    O << "\n";
+    O << "// Forward declarations of kernel and its argument types:\n";
+    FwdDeclEmitter.Visit(K.SyclKernel->getType());
+    O << "\n";
+
+    if (K.SyclKernel->getLanguageLinkage() == CLanguageLinkage)
+      O << "extern \"C\" ";
+    std::string ParmList;
+    bool FirstParam = true;
+    for (ParmVarDecl *Param : K.SyclKernel->parameters()) {
+      if (FirstParam)
+        FirstParam = false;
+      else
+        ParmList += ", ";
+      ParmList += Param->getType().getCanonicalType().getAsString();
+    }
+    FunctionTemplateDecl *FTD = K.SyclKernel->getPrimaryTemplate();
+    Policy.SuppressDefinition = true;
+    Policy.PolishForDeclaration = true;
+    if (FTD) {
+      FTD->print(O, Policy);
+    } else {
+      K.SyclKernel->print(O, Policy);
+    }
+    O << ";\n";
+
+    // Generate a shim function that returns the address of the free function.
+    O << "static constexpr auto __sycl_shim" << ShimCounter << "() {\n";
+    O << "  return (void (*)(" << ParmList << "))"
+      << K.SyclKernel->getIdentifier()->getName().data();
+    if (FTD) {
+      const TemplateArgumentList *TAL =
+          K.SyclKernel->getTemplateSpecializationArgs();
+      ArrayRef<TemplateArgument> A = TAL->asArray();
+      bool FirstParam = true;
+      O << "<";
+      for (const auto &X : A) {
+        if (FirstParam)
+          FirstParam = false;
+        else
+          O << ", ";
+        X.print(Policy, O, true);
+      }
+      O << ">";
+    }
+    O << ";\n";
+    O << "}\n";
+
+    // Generate is_kernel, is_single_task_kernel and nd_range_kernel functions.
+    O << "namespace sycl {\n";
+    O << "template <>\n";
+    O << "struct ext::oneapi::experimental::is_kernel<__sycl_shim"
+      << ShimCounter << "()";
+    O << "> {\n";
+    O << "  static constexpr bool value = true;\n";
+    O << "};\n";
+    int Dim = getFreeFunctionRangeDim(S, K.SyclKernel);
+    O << "template <>\n";
+    if (Dim > 0)
+      O << "struct ext::oneapi::experimental::is_nd_range_kernel<__sycl_shim"
+        << ShimCounter << "(), " << Dim;
+    else
+      O << "struct "
+           "ext::oneapi::experimental::is_single_task_kernel<__sycl_shim"
+        << ShimCounter << "()";
+    O << "> {\n";
+    O << "  static constexpr bool value = true;\n";
+    O << "};\n";
+    O << "}\n";
+    ++ShimCounter;
+  }
+
+  if (FreeFunctionCount > 0) {
+    O << "\n#include <sycl/kernel_bundle.hpp>\n";
+  }
+  ShimCounter = 1;
+  for (const KernelDesc &K : KernelDescs) {
+    if (!isFreeFunction(S, K.SyclKernel))
+      continue;
+
+    O << "\n// Definition of kernel_id of " << K.Name << "\n";
+    O << "namespace sycl {\n";
+    O << "template <>\n";
+    O << "kernel_id ext::oneapi::experimental::get_kernel_id<__sycl_shim"
+      << ShimCounter << "()>() {\n";
+    O << "  return sycl::detail::get_kernel_id_impl(std::string_view{\""
+      << K.Name << "\"});\n";
+    O << "}\n";
+    O << "}\n";
+    ++ShimCounter;
+  }
+}
+
+bool SYCLIntegrationHeader::emit(StringRef IntHeaderName) {
+  if (IntHeaderName.empty())
+    return false;
+  int IntHeaderFD = 0;
+  std::error_code EC =
+      llvm::sys::fs::openFileForWrite(IntHeaderName, IntHeaderFD);
+  if (EC) {
+    llvm::errs() << "Error: " << EC.message() << "\n";
+    // compilation will fail on absent include file - don't need to fail here
+    return false;
+  }
+  llvm::raw_fd_ostream Out(IntHeaderFD, true /*close in destructor*/);
+  emit(Out);
+  return true;
+}
+
+void SYCLIntegrationHeader::startKernel(const FunctionDecl *SyclKernel,
+                                        QualType KernelNameType,
+                                        SourceLocation KernelLocation,
+                                        bool IsESIMDKernel,
+                                        bool IsUnnamedKernel, int64_t ObjSize) {
+  KernelDescs.emplace_back(SyclKernel, KernelNameType, KernelLocation,
+                           IsESIMDKernel, IsUnnamedKernel, ObjSize);
+}
+
+void SYCLIntegrationHeader::addParamDesc(kernel_param_kind_t Kind, int Info,
+                                         unsigned Offset) {
+  auto *K = getCurKernelDesc();
+  assert(K && "no kernels");
+  K->Params.push_back(KernelParamDesc());
+  KernelParamDesc &PD = K->Params.back();
+  PD.Kind = Kind;
+  PD.Info = Info;
+  PD.Offset = Offset;
+}
+
+void SYCLIntegrationHeader::endKernel() {
+  // nop for now
+}
+
+void SYCLIntegrationHeader::addSpecConstant(StringRef IDName, QualType IDType) {
+  SpecConsts.emplace_back(std::make_pair(IDType, IDName.str()));
+}
+
+SYCLIntegrationHeader::SYCLIntegrationHeader(SemaSYCL &S) : S(S) {}
+
+void SYCLIntegrationFooter::addVarDecl(const VarDecl *VD) {
+  // Variable template declaration can result in an error case of 'nullptr'
+  // here.
+  if (!VD)
+    return;
+  // Skip the dependent version of these variables, we only care about them
+  // after instantiation.
+  if (VD->getDeclContext()->isDependentContext())
+    return;
+
+  // Skip partial specializations of a variable template, treat other variable
+  // template instantiations as a VarDecl.
+  if (isa<VarTemplatePartialSpecializationDecl>(VD))
+    return;
+  // Step 1: ensure that this is of the correct type template specialization.
+  if (!SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::specialization_id) &&
+      !SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::host_pipe) &&
+      !S.isTypeDecoratedWithDeclAttribute<SYCLDeviceGlobalAttr>(
+          VD->getType())) {
+    // Handle the case where this could be a deduced type, such as a deduction
+    // guide. We have to do this here since this function, unlike most of the
+    // rest of this file, is called during Sema instead of after it. We will
+    // also have to filter out after deduction later.
+    QualType Ty = VD->getType().getCanonicalType();
+    if (!Ty->isUndeducedType())
+      return;
+  }
+  // Step 2: ensure that this is a static member, or a namespace-scope.
+  // Note that isLocalVarDeclorParm excludes thread-local and static-local
+  // intentionally, as there is no way to 'spell' one of those in the
+  // specialization. We just don't generate the specialization for those, and
+  // let an error happen during host compilation. To avoid multiple entries for
+  // redeclarations, variables with external storage are omitted.
+  if (VD->hasLocalStorage() || VD->isLocalVarDeclOrParm() ||
+      VD->hasExternalStorage())
+    return;
+
+  // Step 3: Add to collection.
+  GlobalVars.push_back(VD);
+}
+
+// Post-compile integration header support.
+bool SYCLIntegrationFooter::emit(StringRef IntHeaderName) {
+  if (IntHeaderName.empty())
+    return false;
+  int IntHeaderFD = 0;
+  std::error_code EC =
+      llvm::sys::fs::openFileForWrite(IntHeaderName, IntHeaderFD);
+  if (EC) {
+    llvm::errs() << "Error: " << EC.message() << "\n";
+    // compilation will fail on absent include file - don't need to fail here
+    return false;
+  }
+  llvm::raw_fd_ostream Out(IntHeaderFD, true /*close in destructor*/);
+  return emit(Out);
+}
+
+template <typename BeforeFn, typename AfterFn>
+static void PrintNSHelper(BeforeFn Before, AfterFn After, raw_ostream &OS,
+                          const DeclContext *DC) {
+  if (DC->isTranslationUnit())
+    return;
+
+  const auto *CurDecl = cast<Decl>(DC);
+  // Ensure we are in the canonical version, so that we know we have the 'full'
+  // name of the thing.
+  CurDecl = CurDecl->getCanonicalDecl();
+
+  // We are intentionally skipping linkage decls and record decls.  Namespaces
+  // can appear in a linkage decl, but not a record decl, so we don't have to
+  // worry about the names getting messed up from that.  We handle record decls
+  // later when printing the name of the thing.
+  const auto *NS = dyn_cast<NamespaceDecl>(CurDecl);
+  if (NS)
+    Before(OS, NS);
+
+  if (const DeclContext *NewDC = CurDecl->getDeclContext())
+    PrintNSHelper(Before, After, OS, NewDC);
+
+  if (NS)
+    After(OS, NS);
+}
+
+static void PrintNamespaces(raw_ostream &OS, const DeclContext *DC) {
+  PrintNSHelper([](raw_ostream &OS, const NamespaceDecl *NS) {},
+                [](raw_ostream &OS, const NamespaceDecl *NS) {
+                  if (NS->isInline())
+                    OS << "inline ";
+                  OS << "namespace ";
+                  if (!NS->isAnonymousNamespace())
+                    OS << NS->getName() << " ";
+                  OS << "{\n";
+                },
+                OS, DC);
+}
+
+static void PrintNSClosingBraces(raw_ostream &OS, const DeclContext *DC) {
+  PrintNSHelper(
+      [](raw_ostream &OS, const NamespaceDecl *NS) {
+        OS << "} // ";
+        if (NS->isInline())
+          OS << "inline ";
+
+        OS << "namespace ";
+        if (!NS->isAnonymousNamespace())
+          OS << NS->getName();
+
+        OS << '\n';
+      },
+      [](raw_ostream &OS, const NamespaceDecl *NS) {}, OS, DC);
+}
+
+static std::string EmitShim(raw_ostream &OS, unsigned &ShimCounter,
+                            const std::string &LastShim,
+                            const NamespaceDecl *AnonNS) {
+  std::string NewShimName =
+      "__sycl_detail::__shim_" + std::to_string(ShimCounter) + "()";
+  // Print opening-namespace
+  PrintNamespaces(OS, Decl::castToDeclContext(AnonNS));
+  OS << "namespace __sycl_detail {\n";
+  OS << "static constexpr decltype(" << LastShim << ") &__shim_" << ShimCounter
+     << "() {\n";
+  OS << "  return " << LastShim << ";\n";
+  OS << "}\n";
+  OS << "} // namespace __sycl_detail\n";
+  PrintNSClosingBraces(OS, Decl::castToDeclContext(AnonNS));
+
+  ++ShimCounter;
+  return NewShimName;
+}
+
+// Emit the list of shims required for a DeclContext, calls itself recursively.
+static void EmitShims(raw_ostream &OS, unsigned &ShimCounter,
+                      const DeclContext *DC, std::string &NameForLastShim,
+                      PrintingPolicy &Policy) {
+  if (DC->isTranslationUnit()) {
+    NameForLastShim = "::" + NameForLastShim;
+    return;
+  }
+
+  const auto *CurDecl = cast<Decl>(DC)->getCanonicalDecl();
+
+  // We skip linkage decls, since they don't modify the Qualified name.
+  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {
+    std::string TemplatedName;
+    llvm::raw_string_ostream Stream(TemplatedName);
+    CTSD->getNameForDiagnostic(Stream, Policy, false);
+    Stream.flush();
+    NameForLastShim = TemplatedName + "::" + NameForLastShim;
+  } else if (const auto *RD = dyn_cast<RecordDecl>(CurDecl)) {
+    NameForLastShim = RD->getNameAsString() + "::" + NameForLastShim;
+  } else if (const auto *ND = dyn_cast<NamespaceDecl>(CurDecl)) {
+    if (ND->isAnonymousNamespace()) {
+      // Print current shim, reset 'name for last shim'.
+      NameForLastShim = EmitShim(OS, ShimCounter, NameForLastShim, ND);
+    } else {
+      NameForLastShim = ND->getNameAsString() + "::" + NameForLastShim;
+    }
+  } else {
+    // FIXME: I don't believe there are other declarations that these variables
+    // could possibly find themselves in. LinkageDecls don't change the
+    // qualified name, so there is nothing to do here. At one point we should
+    // probably convince ourselves that this is entire list and remove this
+    // comment.
+    assert((isa<LinkageSpecDecl, ExternCContextDecl>(CurDecl)) &&
+           "Unhandled decl type");
+  }
+
+  EmitShims(OS, ShimCounter, CurDecl->getDeclContext(), NameForLastShim,
+            Policy);
+}
+
+// Emit the list of shims required for a variable declaration.
+// Returns a string containing the FQN of the 'top most' shim, including its
+// function call parameters.
+static std::string EmitShims(raw_ostream &OS, unsigned &ShimCounter,
+                             PrintingPolicy &Policy, const VarDecl *VD) {
+  if (!VD->isInAnonymousNamespace())
+    return "";
+  std::string RelativeName;
+  llvm::raw_string_ostream stream(RelativeName);
+  VD->getNameForDiagnostic(stream, Policy, false);
+  stream.flush();
+
+  EmitShims(OS, ShimCounter, VD->getDeclContext(), RelativeName, Policy);
+  return RelativeName;
+}
+
+bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
+  PrintingPolicy Policy{S.getLangOpts()};
+  Policy.adjustForCPlusPlusFwdDecl();
+  Policy.SuppressTypedefs = true;
+  Policy.SuppressUnwrittenScope = true;
+
+  llvm::SmallSet<const VarDecl *, 8> Visited;
+  bool EmittedFirstSpecConstant = false;
+  bool DeviceGlobalsEmitted = false;
+  bool HostPipesEmitted = false;
+
+  // Used to uniquely name the 'shim's as we generate the names in each
+  // anonymous namespace.
+  unsigned ShimCounter = 0;
+
+  std::string DeviceGlobalsBuf;
+  llvm::raw_string_ostream DeviceGlobOS(DeviceGlobalsBuf);
+  std::string HostPipesBuf;
+  llvm::raw_string_ostream HostPipesOS(HostPipesBuf);
+  for (const VarDecl *VD : GlobalVars) {
+    VD = VD->getCanonicalDecl();
+
+    // Skip if this isn't a SpecIdType, DeviceGlobal, or HostPipe.  This 
+    // can happen if it was a deduced type.
+    if (!SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::specialization_id) &&
+        !SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::host_pipe) &&
+        !S.isTypeDecoratedWithDeclAttribute<SYCLDeviceGlobalAttr>(
+            VD->getType()))
+      continue;
+
+    // Skip if we've already visited this.
+    if (llvm::find(Visited, VD) != Visited.end())
+      continue;
+
+    // We only want to emit the #includes if we have a variable that needs
+    // them, so emit this one on the first time through the loop.
+    if (!EmittedFirstSpecConstant && !DeviceGlobalsEmitted && !HostPipesEmitted)
+      OS << "#include <sycl/detail/defines_elementary.hpp>\n";
+
+    Visited.insert(VD);
+    std::string TopShim = EmitShims(OS, ShimCounter, Policy, VD);
+    if (S.isTypeDecoratedWithDeclAttribute<SYCLDeviceGlobalAttr>(
+            VD->getType())) {
+      DeviceGlobalsEmitted = true;
+      DeviceGlobOS << "device_global_map::add(";
+      DeviceGlobOS << "(void *)&";
+      if (VD->isInAnonymousNamespace()) {
+        DeviceGlobOS << TopShim;
+      } else {
+        DeviceGlobOS << "::";
+        VD->getNameForDiagnostic(DeviceGlobOS, Policy, true);
+      }
+      DeviceGlobOS << ", \"";
+      DeviceGlobOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(),
+                                                          VD);
+      DeviceGlobOS << "\");\n";
+    } else if (SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::host_pipe)) {
+      HostPipesEmitted = true;
+      HostPipesOS << "host_pipe_map::add(";
+      HostPipesOS << "(void *)&";
+      if (VD->isInAnonymousNamespace()) {
+        HostPipesOS << TopShim;
+      } else {
+        HostPipesOS << "::";
+        VD->getNameForDiagnostic(HostPipesOS, Policy, true);
+      }
+      HostPipesOS << ", \"";
+      HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(),
+                                                         VD);
+      HostPipesOS << "\");\n";
+    } else {
+      EmittedFirstSpecConstant = true;
+      OS << "namespace sycl {\n";
+      OS << "inline namespace _V1 {\n";
+      OS << "namespace detail {\n";
+      OS << "template<>\n";
+      OS << "inline const char *get_spec_constant_symbolic_ID_impl<";
+
+      if (VD->isInAnonymousNamespace()) {
+        OS << TopShim;
+      } else {
+        OS << "::";
+        VD->getNameForDiagnostic(OS, Policy, true);
+      }
+
+      OS << ">() {\n";
+      OS << "  return \"";
+      OS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(), VD);
+      OS << "\";\n";
+      OS << "}\n";
+      OS << "} // namespace detail\n";
+      OS << "} // namespace _V1\n";
+      OS << "} // namespace sycl\n";
+    }
+  }
+
+  if (EmittedFirstSpecConstant)
+    OS << "#include <sycl/detail/spec_const_integration.hpp>\n";
+
+  if (DeviceGlobalsEmitted) {
+    OS << "#include <sycl/detail/device_global_map.hpp>\n";
+    DeviceGlobOS.flush();
+    OS << "namespace sycl::detail {\n";
+    // Supress the old-style case diagnostic that clang generates
+    // for the construct below in DeviceGlobalsBuf.
+    EmitPragmaDiagnosticPush(OS, "-Wold-style-cast");
+    OS << "namespace {\n";
+    OS << "__sycl_device_global_registration::__sycl_device_global_"
+          "registration() noexcept {\n";
+    OS << DeviceGlobalsBuf;
+    OS << "}\n";
+    OS << "} // namespace (unnamed)\n";
+    EmitPragmaDiagnosticPop(OS);
+    OS << "} // namespace sycl::detail\n";
+
+    S.getSyclIntegrationHeader().addDeviceGlobalRegistration();
+  }
+
+  if (HostPipesEmitted) {
+    OS << "#include <sycl/detail/host_pipe_map.hpp>\n";
+    HostPipesOS.flush();
+    OS << "namespace sycl::detail {\n";
+    // Supress the old-style case diagnostic that clang generates
+    // for the construct below in HostPipesBuf.
+    EmitPragmaDiagnosticPush(OS, "-Wold-style-cast");
+    OS << "namespace {\n";
+    OS << "__sycl_host_pipe_registration::__sycl_host_pipe_"
+          "registration() noexcept {\n";
+    OS << HostPipesBuf;
+    OS << "}\n";
+    OS << "} // namespace (unnamed)\n";
+    EmitPragmaDiagnosticPop(OS);
+    OS << "} // namespace sycl::detail\n";
+
+    S.getSyclIntegrationHeader().addHostPipeRegistration();
+  }
+
+  return true;
+}
+
+ExprResult SemaSYCL::BuildUniqueStableIdExpr(SourceLocation OpLoc,
+                                             SourceLocation LParen,
+                                             SourceLocation RParen, Expr *E) {
+  if (!E->isInstantiationDependent()) {
+    // Special handling to get us better error messages for a member variable.
+    if (auto *ME = dyn_cast<MemberExpr>(E->IgnoreUnlessSpelledInSource())) {
+      if (isa<FieldDecl>(ME->getMemberDecl()))
+        Diag(E->getExprLoc(), diag::err_unique_stable_id_global_storage);
+      else
+        Diag(E->getExprLoc(), diag::err_unique_stable_id_expected_var);
+      return ExprError();
+    }
+
+    auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreUnlessSpelledInSource());
+
+    if (!DRE || !isa_and_nonnull<VarDecl>(DRE->getDecl())) {
+      Diag(E->getExprLoc(), diag::err_unique_stable_id_expected_var);
+      return ExprError();
+    }
+
+    auto *Var = cast<VarDecl>(DRE->getDecl());
+
+    if (!Var->hasGlobalStorage()) {
+      Diag(E->getExprLoc(), diag::err_unique_stable_id_global_storage);
+      return ExprError();
+    }
+  }
+
+  return SYCLUniqueStableIdExpr::Create(getASTContext(), OpLoc, LParen, RParen,
+                                        E);
+}
+
+ExprResult SemaSYCL::ActOnUniqueStableIdExpr(SourceLocation OpLoc,
+                                             SourceLocation LParen,
+                                             SourceLocation RParen, Expr *E) {
+  return BuildUniqueStableIdExpr(OpLoc, LParen, RParen, E);
+}
+
+ExprResult SemaSYCL::BuildUniqueStableNameExpr(SourceLocation OpLoc,
+                                               SourceLocation LParen,
+                                               SourceLocation RParen,
+                                               TypeSourceInfo *TSI) {
+  return SYCLUniqueStableNameExpr::Create(getASTContext(), OpLoc, LParen,
+                                          RParen, TSI);
+}
+
+ExprResult SemaSYCL::ActOnUniqueStableNameExpr(SourceLocation OpLoc,
+                                               SourceLocation LParen,
+                                               SourceLocation RParen,
+                                               ParsedType ParsedTy) {
+  TypeSourceInfo *TSI = nullptr;
+  QualType Ty = SemaRef.GetTypeFromParser(ParsedTy, &TSI);
+
+  if (Ty.isNull())
+    return ExprError();
+  if (!TSI)
+    TSI = getASTContext().getTrivialTypeSourceInfo(Ty, LParen);
+
+  return BuildUniqueStableNameExpr(OpLoc, LParen, RParen, TSI);
+}
+
+void SemaSYCL::performSYCLDelayedAttributesAnalaysis(const FunctionDecl *FD) {
+  if (SYCLKernelFunctions.contains(FD))
+    return;
+
+  for (const auto *KernelAttr : std::vector<AttributeCommonInfo *>{
+           FD->getAttr<SYCLReqdWorkGroupSizeAttr>(),
+           FD->getAttr<IntelReqdSubGroupSizeAttr>(),
+           FD->getAttr<SYCLWorkGroupSizeHintAttr>(),
+           FD->getAttr<VecTypeHintAttr>()}) {
+    if (KernelAttr)
+      Diag(KernelAttr->getLoc(),
+           diag::warn_sycl_incorrect_use_attribute_non_kernel_function)
+          << KernelAttr;
+  }
+}
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
new file mode 100644
index 0000000000000..dfded4c3b7216
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -0,0 +1,85 @@
+//===-------------------- work_group_memory.hpp ---------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <type_traits>
+
+namespace sycl {
+inline namespace _V1 {
+namespace detail {
+template <typename T> struct is_unbounded_array : std::false_type {};
+
+template <typename T> struct is_unbounded_array<T[]> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
+
+class work_group_memory_impl {
+public:
+  work_group_memory_impl() : buffer_size{0} {}
+  work_group_memory_impl(const work_group_memory_impl &rhs) = default;
+  work_group_memory_impl &
+  operator=(const work_group_memory_impl &rhs) = default;
+  work_group_memory_impl(size_t buffer_size)
+      : buffer_size{buffer_size} {}
+  private:
+  size_t buffer_size;
+  friend class sycl::handler;
+};
+
+} // namespace detail
+
+namespace ext::oneapi::experimental {
+template <typename DataT, typename PropertyListT = empty_properties_t>
+class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
+    : sycl::detail::work_group_memory_impl {
+public:
+  using value_type = std::remove_all_extents_t<DataT>;
+
+private:
+  using decoratedPtr = typename sycl::detail::DecoratedType<
+      value_type, access::address_space::local_space>::type *;
+
+public:
+  work_group_memory() = default;
+  work_group_memory(const work_group_memory &rhs) = default;
+  work_group_memory &operator=(const work_group_memory &rhs) = default;
+  template <typename T = DataT,
+            typename = std::enable_if_t<!sycl::detail::is_unbounded_array_v<T>>>
+  work_group_memory(handler &)
+      : sycl::detail::work_group_memory_impl(
+                                             sizeof(DataT)) {}
+  template <typename T = DataT,
+            typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
+  work_group_memory(size_t num, handler &)
+      : sycl::detail::work_group_memory_impl(
+            num * sizeof(std::remove_extent_t<DataT>)) {}
+  template <access::decorated IsDecorated = access::decorated::no>
+  multi_ptr<value_type, access::address_space::local_space, IsDecorated>
+  get_multi_ptr() const {
+    return sycl::address_space_cast<access::address_space::local_space,
+                                    IsDecorated, value_type>(ptr);
+  }
+  DataT *operator&() const { return reinterpret_cast<DataT *>(ptr); }
+  operator DataT &() const { return *(this->operator&()); }
+  template <typename T = DataT,
+            typename = std::enable_if_t<!std::is_array_v<T>>>
+  const work_group_memory &operator=(const DataT &value) const {
+    *ptr = value;
+    return *this;
+  }
+#ifdef __SYCL_DEVICE_ONLY__
+  void __init(decoratedPtr ptr) { this->ptr = ptr; }
+#endif
+private:
+  decoratedPtr ptr;
+};
+} // namespace ext::oneapi::experimental
+} // namespace _V1
+} // namespace sycl

From 236139f68d32e32ffe0d42c9674c240a3012e3b1 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Thu, 10 Oct 2024 21:14:10 +0200
Subject: [PATCH 054/107] Revert SPIRV translator changes

---
 llvm-spirv/lib/SPIRV/SPIRVWriter.cpp | 117 ++++++++++++++++++---------
 1 file changed, 81 insertions(+), 36 deletions(-)

diff --git a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
index 775296146c528..b5ba78aec867a 100644
--- a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
+++ b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
@@ -417,8 +417,8 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
   // A pointer to image or pipe type in LLVM is translated to a SPIRV
   // (non-pointer) image or pipe type.
   if (T->isPointerTy()) {
-    auto *ET = Type::getInt8Ty(T->getContext());
     auto AddrSpc = T->getPointerAddressSpace();
+    auto *ET = Type::getInt8Ty(T->getContext());
     return transPointerType(ET, AddrSpc);
   }
 
@@ -720,7 +720,6 @@ SPIRVType *LLVMToSPIRVBase::transPointerType(Type *ET, unsigned AddrSpc) {
           transType(ET)));
     }
   } else {
-    SPIRVType *ElementType = transType(ET);
     // ET, as a recursive type, may contain exactly the same pointer T, so it
     // may happen that after translation of ET we already have translated T,
     // added the translated pointer to the SPIR-V module and mapped T to this
@@ -729,7 +728,17 @@ SPIRVType *LLVMToSPIRVBase::transPointerType(Type *ET, unsigned AddrSpc) {
     if (Loc != PointeeTypeMap.end()) {
       return Loc->second;
     }
-    SPIRVType *TranslatedTy = transPointerType(ElementType, AddrSpc);
+
+    SPIRVType *ElementType = nullptr;
+    SPIRVType *TranslatedTy = nullptr;
+    if (ET->isPointerTy() &&
+        BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers)) {
+      TranslatedTy = BM->addUntypedPointerKHRType(
+          SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)));
+    } else {
+      ElementType = transType(ET);
+      TranslatedTy = transPointerType(ElementType, AddrSpc);
+    }
     PointeeTypeMap[TypeKey] = TranslatedTy;
     return TranslatedTy;
   }
@@ -744,8 +753,16 @@ SPIRVType *LLVMToSPIRVBase::transPointerType(SPIRVType *ET, unsigned AddrSpc) {
   if (Loc != PointeeTypeMap.end())
     return Loc->second;
 
-  SPIRVType *TranslatedTy = BM->addPointerType(
-      SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)), ET);
+  SPIRVType *TranslatedTy = nullptr;
+  if (BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers) &&
+      !(ET->isTypeArray() || ET->isTypeVector() || ET->isTypeStruct() ||
+        ET->isTypeImage() || ET->isTypeSampler() || ET->isTypePipe())) {
+    TranslatedTy = BM->addUntypedPointerKHRType(
+        SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)));
+  } else {
+    TranslatedTy = BM->addPointerType(
+        SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)), ET);
+  }
   PointeeTypeMap[TypeKey] = TranslatedTy;
   return TranslatedTy;
 }
@@ -1312,7 +1329,8 @@ SPIRVValue *LLVMToSPIRVBase::transConstantUse(Constant *C,
   if (Trans->getType() == ExpectedType || Trans->getType()->isTypePipeStorage())
     return Trans;
 
-  assert(C->getType()->isPointerTy() &&
+  assert((C->getType()->isPointerTy() ||
+          ExpectedType->isTypeUntypedPointerKHR()) &&
          "Only pointer type mismatches should be possible");
   // In the common case of strings ([N x i8] GVs), see if we can emit a GEP
   // instruction.
@@ -2050,8 +2068,12 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
           }
         }
       }
-      SPIRVType *TransTy = transType(Ty);
-      BVarInit = transConstantUse(Init, TransTy->getPointerElementType());
+      if (BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers)) {
+        BVarInit = transConstantUse(Init, transType(Init->getType()));
+      } else {
+        SPIRVType *TransTy = transType(Ty);
+        BVarInit = transConstantUse(Init, TransTy->getPointerElementType());
+      }
     }
 
     SPIRVStorageClassKind StorageClass;
@@ -2084,9 +2106,12 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
     }
 
     SPIRVType *TranslatedTy = transType(Ty);
-    auto *BVar = static_cast<SPIRVVariable *>(
-        BM->addVariable(TranslatedTy, GV->isConstant(), transLinkageType(GV),
-                        BVarInit, GV->getName().str(), StorageClass, nullptr));
+    auto *BVar = static_cast<SPIRVVariableBase *>(BM->addVariable(
+        TranslatedTy,
+        TranslatedTy->isTypeUntypedPointerKHR() ? transType(GV->getValueType())
+                                                : nullptr,
+        GV->isConstant(), transLinkageType(GV), BVarInit, GV->getName().str(),
+        StorageClass, nullptr));
 
     if (IsVectorCompute) {
       BVar->addDecorate(DecorationVectorComputeVariableINTEL);
@@ -2196,8 +2221,13 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
                              MemoryAccessNoAliasINTELMaskMask);
     if (MemoryAccess.front() == 0)
       MemoryAccess.clear();
-    return mapValue(V, BM->addLoadInst(transValue(LD->getPointerOperand(), BB),
-                                       MemoryAccess, BB));
+    return mapValue(
+        V,
+        BM->addLoadInst(
+            transValue(LD->getPointerOperand(), BB), MemoryAccess, BB,
+            BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers)
+                ? transType(LD->getType())
+                : nullptr));
   }
 
   if (BinaryOperator *B = dyn_cast<BinaryOperator>(V)) {
@@ -2270,8 +2300,9 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
             StorageClassFunction,
             BM->addArrayType(transType(Alc->getAllocatedType()), Length));
         SPIRVValue *Arr = BM->addVariable(
-            AllocationType, false, spv::internal::LinkageTypeInternal, nullptr,
-            Alc->getName().str() + "_alloca", StorageClassFunction, BB);
+            AllocationType, nullptr, false, spv::internal::LinkageTypeInternal,
+            nullptr, Alc->getName().str() + "_alloca", StorageClassFunction,
+            BB);
         // Manually set alignment. OpBitcast created below will be decorated as
         // that's the SPIR-V value mapped to the original LLVM one.
         transAlign(Alc, Arr);
@@ -2295,7 +2326,10 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
                                  TranslatedTy->getPointerElementType())
             : TranslatedTy;
     SPIRVValue *Var = BM->addVariable(
-        VarTy, false, spv::internal::LinkageTypeInternal, nullptr,
+        VarTy,
+        VarTy->isTypeUntypedPointerKHR() ? transType(Alc->getAllocatedType())
+                                         : nullptr,
+        false, spv::internal::LinkageTypeInternal, nullptr,
         Alc->getName().str(), StorageClassFunction, BB);
     if (V->getType()->getPointerAddressSpace() == SPIRAS_Generic) {
       SPIRVValue *Cast =
@@ -2407,14 +2441,17 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
 
   if (auto *Phi = dyn_cast<PHINode>(V)) {
     std::vector<SPIRVValue *> IncomingPairs;
+    SPIRVType *Ty = transScavengedType(Phi);
 
     for (size_t I = 0, E = Phi->getNumIncomingValues(); I != E; ++I) {
-      IncomingPairs.push_back(transValue(Phi->getIncomingValue(I), BB, true,
-                                         FuncTransMode::Pointer));
+      SPIRVValue *Val = transValue(Phi->getIncomingValue(I), BB, true,
+                                   FuncTransMode::Pointer);
+      if (Val->getType() != Ty)
+        Val = BM->addUnaryInst(OpBitcast, Ty, Val, BB);
+      IncomingPairs.push_back(Val);
       IncomingPairs.push_back(transValue(Phi->getIncomingBlock(I), nullptr));
     }
-    return mapValue(V,
-                    BM->addPhiInst(transScavengedType(Phi), IncomingPairs, BB));
+    return mapValue(V, BM->addPhiInst(Ty, IncomingPairs, BB));
   }
 
   if (auto *Ext = dyn_cast<ExtractValueInst>(V)) {
@@ -2737,7 +2774,7 @@ void checkIsGlobalVar(SPIRVEntry *E, Decoration Dec) {
   E->getErrorLog().checkError(E->isVariable(), SPIRVEC_InvalidModule, ErrStr);
 
   auto AddrSpace = SPIRSPIRVAddrSpaceMap::rmap(
-      static_cast<SPIRVVariable *>(E)->getStorageClass());
+      static_cast<SPIRVVariableBase *>(E)->getStorageClass());
   ErrStr += " in a global (module) scope";
   E->getErrorLog().checkError(AddrSpace == SPIRAS_Global, SPIRVEC_InvalidModule,
                               ErrStr);
@@ -2885,10 +2922,11 @@ static void transMetadataDecorations(Metadata *MD, SPIRVValue *Target) {
     case spv::internal::DecorationInitModeINTEL:
     case DecorationInitModeINTEL: {
       checkIsGlobalVar(Target, DecoKind);
-      ErrLog.checkError(static_cast<SPIRVVariable *>(Target)->getInitializer(),
-                        SPIRVEC_InvalidLlvmModule,
-                        "InitModeINTEL only be applied to a global (module "
-                        "scope) variable which has an Initializer operand");
+      ErrLog.checkError(
+          static_cast<SPIRVVariableBase *>(Target)->getInitializer(),
+          SPIRVEC_InvalidLlvmModule,
+          "InitModeINTEL only be applied to a global (module "
+          "scope) variable which has an Initializer operand");
 
       ErrLog.checkError(NumOperands == 2, SPIRVEC_InvalidLlvmModule,
                         "InitModeINTEL requires exactly 1 extra operand");
@@ -4130,14 +4168,18 @@ SPIRVValue *LLVMToSPIRVBase::transIntrinsicInst(IntrinsicInst *II,
     SPIRVType *FTy = transType(II->getType()->getStructElementType(0));
     SPIRVTypePointer *ITy = static_cast<SPIRVTypePointer *>(transPointerType(
         II->getType()->getStructElementType(1), SPIRAS_Private));
-
-    unsigned BitWidth = ITy->getElementType()->getBitWidth();
-    BM->getErrorLog().checkError(BitWidth == 32, SPIRVEC_InvalidBitWidth,
-                                 std::to_string(BitWidth));
-
+    if (!ITy->isTypeUntypedPointerKHR()) {
+      unsigned BitWidth = ITy->getElementType()->getBitWidth();
+      BM->getErrorLog().checkError(BitWidth == 32, SPIRVEC_InvalidBitWidth,
+                                   std::to_string(BitWidth));
+    }
     SPIRVValue *IntVal =
-        BM->addVariable(ITy, false, spv::internal::LinkageTypeInternal, nullptr,
-                        "", ITy->getStorageClass(), BB);
+        BM->addVariable(ITy,
+                        ITy->isTypeUntypedPointerKHR()
+                            ? transType(II->getType()->getStructElementType(1))
+                            : nullptr,
+                        false, spv::internal::LinkageTypeInternal, nullptr, "",
+                        ITy->getStorageClass(), BB);
 
     std::vector<SPIRVValue *> Ops{transValue(II->getArgOperand(0), BB), IntVal};
 
@@ -4559,7 +4601,7 @@ SPIRVValue *LLVMToSPIRVBase::transIntrinsicInst(IntrinsicInst *II,
       Init = BM->addCompositeConstant(CompositeTy, Elts);
     }
     SPIRVType *VarTy = transPointerType(AT, SPIRV::SPIRAS_Constant);
-    SPIRVValue *Var = BM->addVariable(VarTy, /*isConstant*/ true,
+    SPIRVValue *Var = BM->addVariable(VarTy, nullptr, /*isConstant*/ true,
                                       spv::internal::LinkageTypeInternal, Init,
                                       "", StorageClassUniformConstant, nullptr);
     SPIRVType *SourceTy =
@@ -6671,9 +6713,12 @@ LLVMToSPIRVBase::transBuiltinToInstWithoutDecoration(Op OC, CallInst *CI,
           assert((Pointee == Args[I] || !isa<Function>(Pointee)) &&
                  "Illegal use of a function pointer type");
         }
-        SPArgs.push_back(SPI->isOperandLiteral(I)
-                             ? cast<ConstantInt>(Args[I])->getZExtValue()
-                             : transValue(Args[I], BB)->getId());
+        if (!SPI->isOperandLiteral(I)) {
+          SPIRVValue *Val = transValue(Args[I], BB);
+          SPArgs.push_back(Val->getId());
+        } else {
+          SPArgs.push_back(cast<ConstantInt>(Args[I])->getZExtValue());
+        }
       }
       BM->addInstTemplate(SPI, SPArgs, BB, SPRetTy);
       if (!SPRetTy || !SPRetTy->isTypeStruct())

From 2beda8e0787fb2e477fce058331498361f6e56e9 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 11 Oct 2024 06:59:09 +0200
Subject: [PATCH 055/107] Stash changes

---
 clang/lib/Sema/SemaSYCL.cpp                   | 195 ++++++++++++++----
 .../oneapi/experimental/work_group_memory.hpp |  14 +-
 sycl/include/sycl/handler.hpp                 |  26 +--
 sycl/source/handler.cpp                       |   5 +-
 4 files changed, 184 insertions(+), 56 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index d8925669b1ae3..83d8b4b87f148 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 // This implements Semantic Analysis for SYCL constructs.
 //===----------------------------------------------------------------------===//
-
+#include <iostream>
 #include "clang/Sema/SemaSYCL.h"
 #include "TreeTransform.h"
 #include "clang/AST/AST.h"
@@ -1521,8 +1521,9 @@ class KernelObjVisitor {
   template <typename... HandlerTys>
   void visitParam(ParmVarDecl *Param, QualType ParamTy,
                   HandlerTys &...Handlers) {
-    if (isSyclSpecialType(ParamTy, SemaSYCLRef))
-      KP_FOR_EACH(handleOtherType, Param, ParamTy);
+    if (isSyclSpecialType(ParamTy, SemaSYCLRef)){
+      KP_FOR_EACH(handleSyclSpecialType, Param, ParamTy);
+}
     else if (ParamTy->isStructureOrClassType()) {
       if (KP_FOR_EACH(handleStructType, Param, ParamTy)) {
         CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
@@ -2070,8 +2071,28 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
   }
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
-    IsInvalid = true;
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
+      CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
+    // For free functions all struct/class kernel arguments are forward declared
+    // in integration header, that adds additional restrictions for kernel
+    // arguments.
+    NotForwardDeclarableReason NFDR =
+        isForwardDeclarable(RD, SemaSYCLRef, /*DiagForFreeFunction=*/true);
+    if (NFDR != NotForwardDeclarableReason::None) {
+      Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
+          << ParamTy;
+      Diag.Report(PD->getLocation(),
+                  diag::note_free_function_kernel_param_type_not_fwd_declarable)
+          << ParamTy;
+      IsInvalid = true;
+    } else
+    IsInvalid = false;
+}
+    else {
+      Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
+          << ParamTy;
+      IsInvalid = true;
+    }
     return isValid();
   }
 
@@ -2224,6 +2245,7 @@ class SyclKernelUnionChecker : public SyclKernelFieldHandler {
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
     // TODO
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) return true;
     unsupportedFreeFunctionParamType();
     return true;
   }
@@ -2262,7 +2284,7 @@ class SyclKernelDecompMarker : public SyclKernelFieldHandler {
     return true;
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
+  bool handleSyclSpecialType(ParmVarDecl *, QualType Ty) final {
     // TODO We don't support special types in free function kernel parameters,
     // but track them to diagnose the case properly.
     CollectionStack.back() = true;
@@ -3008,10 +3030,29 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
     return handleSpecialType(FD, FieldTy);
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
+  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
     // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
+      const auto *RecordDecl = ParamTy->getAsCXXRecordDecl();
+      assert(RecordDecl && "The type must be a RecordDecl");
+      CXXMethodDecl *InitMethod = getMethodByName(RecordDecl, InitMethodName);
+      assert(InitMethod && "The type must have the __init method");
+
+      // Don't do -1 here because we count on this to be the first parameter
+      // added (if any).
+      size_t ParamIndex = Params.size();
+      for (const ParmVarDecl *Param : InitMethod->parameters()) {
+        QualType ParamTy = Param->getType();
+        addParam(Param, ParamTy.getCanonicalType());
+        // Propagate add_ir_attributes_kernel_parameter attribute.
+        if (const auto *AddIRAttr =
+                Param->getAttr<SYCLAddIRAttributesKernelParameterAttr>())
+          Params.back()->addAttr(AddIRAttr->clone(SemaSYCLRef.getASTContext()));
+      }
+      LastParamIndex = ParamIndex;
+    } else
+      unsupportedFreeFunctionParamType();
+   return true;
   }
 
   RecordDecl *wrapField(FieldDecl *Field, QualType FieldTy) {
@@ -3286,9 +3327,7 @@ class SyclKernelArgsSizeChecker : public SyclKernelFieldHandler {
   }
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
+    return handleSpecialType(ParamTy);
   }
 
   bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
@@ -3601,6 +3640,8 @@ class SyclKernelBodyCreator : public SyclKernelFieldHandler {
 
     BodyStmts.insert(BodyStmts.end(), FinalizeStmts.begin(),
                      FinalizeStmts.end());
+    //CompoundStmt::Create(SemaSYCLRef.getASTContext(), BodyStmts,
+                         //       FPOptionsOverride(), {}, {})->dumpPretty(SemaSYCLRef.getASTContext());
 
     return CompoundStmt::Create(SemaSYCLRef.getASTContext(), BodyStmts,
                                 FPOptionsOverride(), {}, {});
@@ -4118,6 +4159,7 @@ class SyclKernelBodyCreator : public SyclKernelFieldHandler {
     annotateHierarchicalParallelismAPICalls();
     CompoundStmt *KernelBody = createKernelBody();
     DeclCreator.setBody(KernelBody);
+    DeclCreator.getKernelDecl()->dump();
   }
 
   bool handleSyclSpecialType(FieldDecl *FD, QualType Ty) final {
@@ -4308,15 +4350,11 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
   SourceLocation FreeFunctionSrcLoc; // Free function source location.
   llvm::SmallVector<Expr *, 8> ArgExprs;
 
-  // Creates a DeclRefExpr to the ParmVar that represents the current free
-  // function parameter.
-  Expr *createParamReferenceExpr() {
-    ParmVarDecl *FreeFunctionParameter =
-        DeclCreator.getParamVarDeclsForCurrentField()[0];
-
-    QualType FreeFunctionParamType = FreeFunctionParameter->getOriginalType();
+  // Creates a DeclRefExpr to the ParmVar given be PD
+  Expr *createParamReferenceExpr(ParmVarDecl *PD = nullptr) {
+    ParmVarDecl *FreeFunctionParameter = PD ? PD : DeclCreator.getParamVarDeclsForCurrentField()[0];
     Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-        FreeFunctionParameter, FreeFunctionParamType, VK_LValue,
+        FreeFunctionParameter, FreeFunctionParameter->getType(), VK_LValue,
         FreeFunctionSrcLoc);
     DRE = SemaSYCLRef.SemaRef.DefaultLvalueConversion(DRE).get();
     return DRE;
@@ -4412,8 +4450,52 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
     auto CallExpr = CallExpr::Create(Context, Fn, ArgExprs, ResultTy, VK,
                                      FreeFunctionSrcLoc, FPOptionsOverride());
     BodyStmts.push_back(CallExpr);
-    return CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
-                                {});
+  //  CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
+    //                            {})->dumpPretty(SemaSYCLRef.getASTContext());
+return CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
+                                {}); 
+ }
+
+  MemberExpr *buildMemberExpr(Expr *Base, ValueDecl *Member) {
+    DeclAccessPair MemberDAP = DeclAccessPair::make(Member, AS_none);
+    MemberExpr *Result = SemaSYCLRef.SemaRef.BuildMemberExpr(
+        Base, /*IsArrow */ false, FreeFunctionSrcLoc, NestedNameSpecifierLoc(),
+        FreeFunctionSrcLoc, Member, MemberDAP,
+        /*HadMultipleCandidates*/ false,
+        DeclarationNameInfo(Member->getDeclName(), FreeFunctionSrcLoc),
+        Member->getType(), VK_LValue, OK_Ordinary);
+    return Result;
+  }
+
+  void createSpecialMethodCall(const CXXRecordDecl *RD, StringRef MethodName,
+                               Expr *MemberBaseExpr,
+                               SmallVectorImpl<Stmt *> &AddTo) {
+    CXXMethodDecl *Method = getMethodByName(RD, MethodName);
+    if (!Method)
+      return;
+
+    unsigned NumParams = Method->getNumParams();
+    llvm::SmallVector<Expr *, 4> ParamDREs(NumParams);
+    llvm::ArrayRef<ParmVarDecl *> KernelParameters =
+        DeclCreator.getParamVarDeclsForCurrentField();
+    for (size_t I = 0; I < NumParams; ++I) {
+      QualType ParamType = KernelParameters[I]->getOriginalType();
+      ParamDREs[I] = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+          KernelParameters[I], ParamType, VK_LValue, FreeFunctionSrcLoc);
+    }
+
+    MemberExpr *MethodME = buildMemberExpr(MemberBaseExpr, Method);
+
+    QualType ResultTy = Method->getReturnType();
+    ExprValueKind VK = Expr::getValueKindForType(ResultTy);
+    ResultTy = ResultTy.getNonLValueExprType(SemaSYCLRef.getASTContext());
+    llvm::SmallVector<Expr *, 4> ParamStmts;
+    const auto *Proto = cast<FunctionProtoType>(Method->getType());
+    SemaSYCLRef.SemaRef.GatherArgumentsForCall(FreeFunctionSrcLoc, Method,
+                                               Proto, 0, ParamDREs, ParamStmts);
+    AddTo.push_back(CXXMemberCallExpr::Create(
+        SemaSYCLRef.getASTContext(), MethodME, ParamStmts, ResultTy, VK,
+        FreeFunctionSrcLoc, FPOptionsOverride()));
   }
 
 public:
@@ -4427,6 +4509,7 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
   ~FreeFunctionKernelBodyCreator() {
     CompoundStmt *KernelBody = createFreeFunctionKernelBody();
     DeclCreator.setBody(KernelBody);
+    DeclCreator.getKernelDecl()->dump();
   }
 
   bool handleSyclSpecialType(FieldDecl *FD, QualType Ty) final {
@@ -4435,9 +4518,41 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
     return true;
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
+  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
     // TODO
-    unsupportedFreeFunctionParamType();
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
+      const auto *RecordDecl = ParamTy->getAsCXXRecordDecl();
+      QualType Ty = PD->getOriginalType();
+     ASTContext &Ctx = SemaSYCLRef.SemaRef.getASTContext();
+      VarDecl *WorkGroupMemoryClone = VarDecl::Create(
+          Ctx, DeclCreator.getKernelDecl(), FreeFunctionSrcLoc, FreeFunctionSrcLoc, PD->getIdentifier(),
+          PD->getType(),
+          Ctx.getTrivialTypeSourceInfo(Ty), SC_None);
+      InitializedEntity VarEntity =
+          InitializedEntity::InitializeVariable(WorkGroupMemoryClone);
+      InitializationKind InitKind =
+          InitializationKind::CreateDefault(FreeFunctionSrcLoc);
+      InitializationSequence InitSeq(SemaSYCLRef.SemaRef, VarEntity, InitKind,
+                                     std::nullopt);
+      ExprResult Init = InitSeq.Perform(SemaSYCLRef.SemaRef, VarEntity,
+                                        InitKind, std::nullopt);
+      WorkGroupMemoryClone->setInit(
+          SemaSYCLRef.SemaRef.MaybeCreateExprWithCleanups(Init.get()));
+      WorkGroupMemoryClone->setInitStyle(VarDecl::CallInit);
+    Stmt *DS = new (SemaSYCLRef.getASTContext())
+        DeclStmt(DeclGroupRef(WorkGroupMemoryClone), FreeFunctionSrcLoc,
+                 FreeFunctionSrcLoc);
+    BodyStmts.push_back(DS);
+      Expr *MemberBaseExpr = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+          WorkGroupMemoryClone, Ty, VK_LValue, FreeFunctionSrcLoc);
+      //createSpecialMethodCall(RecordDecl, InitMethodName, MemberBaseExpr,
+                              //BodyStmts);
+      Expr *RvalueMemberBaseExpr =  SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+          WorkGroupMemoryClone, Ty, VK_PRValue, FreeFunctionSrcLoc);
+
+      ArgExprs.push_back(RvalueMemberBaseExpr);
+    } else
+      unsupportedFreeFunctionParamType();
     return true;
   }
 
@@ -4717,9 +4832,11 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
     return true;
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
+  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
     // TODO
-    unsupportedFreeFunctionParamType();
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
+      addParam(PD, ParamTy, SYCLIntegrationHeader::kind_work_group_memory);
+    else unsupportedFreeFunctionParamType();
     return true;
   }
 
@@ -4907,7 +5024,6 @@ class SYCLKernelNameTypeVisitor
   void Visit(QualType T) {
     if (T.isNull())
       return;
-
     const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
     // If KernelNameType has template args visit each template arg via
     // ConstTemplateArgumentVisitor
@@ -5566,11 +5682,9 @@ void SemaSYCL::ProcessFreeFunction(FunctionDecl *FD) {
     KernelObjVisitor Visitor{*this};
 
     DiagnosingSYCLKernel = true;
-
     // Check parameters of free function.
     Visitor.VisitFunctionParameters(FD, DecompMarker, FieldChecker,
                                     UnionChecker);
-
     DiagnosingSYCLKernel = false;
 
     // Ignore the free function if any of the checkers fail validation.
@@ -5911,7 +6025,7 @@ class SYCLFwdDeclEmitter
   void Visit(QualType T) {
     if (T.isNull())
       return;
-    InnerTypeVisitor::Visit(T.getTypePtr());
+InnerTypeVisitor::Visit(T.getTypePtr());
   }
 
   void VisitReferenceType(const ReferenceType *RT) {
@@ -5935,7 +6049,7 @@ class SYCLFwdDeclEmitter
   }
 
   void VisitTagType(const TagType *T) {
-    TagDecl *TD = T->getDecl();
+TagDecl *TD = T->getDecl();
     if (const auto *TSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
       // - first, recurse into template parameters and emit needed forward
       //   declarations
@@ -6015,13 +6129,13 @@ class SYCLFwdDeclEmitter
     VisitTemplateArgs(TA.getPackAsArray());
   }
 
-  void VisitFunctionProtoType(const FunctionProtoType *T) {
-    for (const auto Ty : T->getParamTypes())
+  void VisitFunctionProtoType(const FunctionProtoType *T) {    
+for (const auto Ty : T->getParamTypes()) 
       Visit(Ty.getCanonicalType());
     // So far this visitor method is only used for free function kernels whose
     // return type is void anyway, so it is not visited. Otherwise, add if
     // required.
-  }
+}
 };
 
 class SYCLKernelNameTypePrinter
@@ -6196,6 +6310,16 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
   O << "#include <sycl/detail/defines_elementary.hpp>\n";
   O << "#include <sycl/detail/kernel_desc.hpp>\n";
   O << "#include <sycl/ext/oneapi/experimental/free_function_traits.hpp>\n";
+  O << "#include <sycl/ext/oneapi/properties/properties.hpp>\n";
+  O << "namespace sycl { inline namespace _V1 { namespace ext { namespace "
+       "oneapi { namespace experimental {\n"
+       "    template<typename DataT, typename PropertiesT = "
+       "properties<std::tuple<>>> class work_group_memory;\n"
+       "}\n"
+       "}\n"
+       "}\n"
+       "}\n"
+       "}\n";
 
   O << "\n";
 
@@ -6465,8 +6589,7 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     O << "\n";
     O << "// Forward declarations of kernel and its argument types:\n";
     FwdDeclEmitter.Visit(K.SyclKernel->getType());
-    O << "\n";
-
+O << "\n";
     if (K.SyclKernel->getLanguageLinkage() == CLanguageLinkage)
       O << "extern \"C\" ";
     std::string ParmList;
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index dfded4c3b7216..0af3ad47b2345 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -33,10 +33,14 @@ class work_group_memory_impl {
   friend class sycl::handler;
 };
 
-} // namespace detail
 
+} // namespace detail
 namespace ext::oneapi::experimental {
+#ifdef __SYCL_DEVICE_ONLY__
 template <typename DataT, typename PropertyListT = empty_properties_t>
+#else
+template <typename DataT, typename PropertyListT>
+#endif
 class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     : sycl::detail::work_group_memory_impl {
 public:
@@ -79,7 +83,15 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
 #endif
 private:
   decoratedPtr ptr;
+  size_t bufferSize;
+  template <typename DataType>
+  friend size_t getWorkGroupMemorySize();
 };
+
+template <typename DataType>
+size_t getWorkGroupMemorySize() {
+    return work_group_memory<DataType, empty_properties_t>::bufferSize;
+}
 } // namespace ext::oneapi::experimental
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 439b79ec560cf..cc7b316811a5b 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -163,7 +163,7 @@ class pipe;
 
 namespace ext ::oneapi ::experimental {
 template <typename, typename> class work_group_memory;
-
+template<typename DataT> size_t getWorkGroupMemorySize();
 struct image_descriptor;
 } // namespace ext::oneapi::experimental
 
@@ -678,8 +678,8 @@ class __SYCL_EXPORT handler {
   // The version for regular(standard layout) argument.
   template <typename T, typename... Ts>
   void setArgsHelper(int ArgIndex, T &&Arg, Ts &&...Args) {
-    set_arg(ArgIndex, std::move(Arg));
-    setArgsHelper(++ArgIndex, std::move(Args)...);
+    set_arg(ArgIndex, std::forward<T>(Arg));
+    setArgsHelper(++ArgIndex, std::forward<Ts>(Args)...);
   }
 
   void setArgsHelper(int) {}
@@ -717,15 +717,6 @@ class __SYCL_EXPORT handler {
 #endif
   }
 
-  template <typename DataT, typename PropertyListT>
-  void setArgHelper(
-      int ArgIndex,
-      const ext::oneapi::experimental::work_group_memory<DataT, PropertyListT>
-          &Arg) {
-    addArg(detail::kernel_param_kind_t::kind_work_group_memory, &Arg, 0,
-           ArgIndex);
-  }
-
   // setArgHelper for non local accessor argument.
   template <typename DataT, int Dims, access::mode AccessMode,
             access::target AccessTarget, access::placeholder IsPlaceholder>
@@ -1957,9 +1948,11 @@ class __SYCL_EXPORT handler {
 
   template <typename DataT, typename PropertyListT =
                                 ext::oneapi::experimental::empty_properties_t>
-  void set_arg(int ArgIndex, const ext::oneapi::experimental::work_group_memory<
-                                 DataT, PropertyListT> &Arg) {
-    setArgHelper(ArgIndex, Arg);
+  void set_arg(
+      int ArgIndex,
+      ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> Arg) {
+    addArg(detail::kernel_param_kind_t::kind_work_group_memory, nullptr, ext::oneapi::experimental::getWorkGroupMemorySize<DataT>(),
+           ArgIndex);
   }
 
   // set_arg for graph dynamic_parameters
@@ -1980,9 +1973,8 @@ class __SYCL_EXPORT handler {
   ///
   /// \param Args are argument values to be set.
   template <typename... Ts> void set_args(Ts &&...Args) {
-    setArgsHelper(0, std::move(Args)...);
+    setArgsHelper(0, std::forward<Ts>(Args)...);
   }
-
   /// Defines and invokes a SYCL kernel function as a function object type.
   ///
   /// If it is a named function object and the function object type is
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index 52334abccfcf7..fffa09a3ccf25 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -797,8 +797,9 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
     break;
   }
   case kernel_param_kind_t::kind_work_group_memory: {
-    addArg(kernel_param_kind_t::kind_std_layout, nullptr,
-           static_cast<detail::work_group_memory_impl *>(Ptr)->buffer_size,
+//std::cout << static_cast<detail::work_group_memory_impl *>(Ptr)->buffer_size <<std::endl;
+addArg(kernel_param_kind_t::kind_std_layout, nullptr,
+           Size,
            Index + IndexShift);
     break;
   }

From dbafe3105ed9e3696f4eeac1d0d15579ec05849d Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 11 Oct 2024 17:38:09 +0200
Subject: [PATCH 056/107] Add inital free function kernel support for work
 group memory

---
 clang/lib/Sema/SemaSYCL.cpp   | 214 +++++++++++++++++-----------------
 sycl/include/sycl/handler.hpp |   5 +-
 2 files changed, 106 insertions(+), 113 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index 83d8b4b87f148..e9370020cf842 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 // This implements Semantic Analysis for SYCL constructs.
 //===----------------------------------------------------------------------===//
-#include <iostream>
 #include "clang/Sema/SemaSYCL.h"
 #include "TreeTransform.h"
 #include "clang/AST/AST.h"
@@ -35,6 +34,7 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
+#include <iostream>
 
 #include <array>
 #include <functional>
@@ -394,8 +394,7 @@ bool SemaSYCL::isDeclAllowedInSYCLDeviceCode(const Decl *D) {
       return true;
 
     const DeclContext *DC = FD->getDeclContext();
-    if (II && II->isStr("__spirv_ocl_printf") &&
-        !FD->isDefined() &&
+    if (II && II->isStr("__spirv_ocl_printf") && !FD->isDefined() &&
         FD->getLanguageLinkage() == CXXLanguageLinkage &&
         DC->getEnclosingNamespaceContext()->isTranslationUnit())
       return true;
@@ -623,19 +622,18 @@ static void collectSYCLAttributes(SemaSYCL &S, FunctionDecl *FD,
   if (DirectlyCalled) {
     llvm::copy_if(FD->getAttrs(), std::back_inserter(Attrs), [](Attr *A) {
       // FIXME: Make this list self-adapt as new SYCL attributes are added.
-      return isa<IntelReqdSubGroupSizeAttr, IntelNamedSubGroupSizeAttr,
-                 SYCLReqdWorkGroupSizeAttr, SYCLWorkGroupSizeHintAttr,
-                 SYCLIntelKernelArgsRestrictAttr, SYCLIntelNumSimdWorkItemsAttr,
-                 SYCLIntelSchedulerTargetFmaxMhzAttr,
-                 SYCLIntelMaxWorkGroupSizeAttr, SYCLIntelMaxGlobalWorkDimAttr,
-                 SYCLIntelMinWorkGroupsPerComputeUnitAttr,
-                 SYCLIntelMaxWorkGroupsPerMultiprocessorAttr,
-                 SYCLIntelNoGlobalWorkOffsetAttr, SYCLSimdAttr,
-                 SYCLIntelLoopFuseAttr, SYCLIntelMaxConcurrencyAttr,
-                 SYCLIntelDisableLoopPipeliningAttr,
-                 SYCLIntelInitiationIntervalAttr,
-                 SYCLIntelUseStallEnableClustersAttr, SYCLDeviceHasAttr,
-                 SYCLAddIRAttributesFunctionAttr>(A);
+      return isa<
+          IntelReqdSubGroupSizeAttr, IntelNamedSubGroupSizeAttr,
+          SYCLReqdWorkGroupSizeAttr, SYCLWorkGroupSizeHintAttr,
+          SYCLIntelKernelArgsRestrictAttr, SYCLIntelNumSimdWorkItemsAttr,
+          SYCLIntelSchedulerTargetFmaxMhzAttr, SYCLIntelMaxWorkGroupSizeAttr,
+          SYCLIntelMaxGlobalWorkDimAttr,
+          SYCLIntelMinWorkGroupsPerComputeUnitAttr,
+          SYCLIntelMaxWorkGroupsPerMultiprocessorAttr,
+          SYCLIntelNoGlobalWorkOffsetAttr, SYCLSimdAttr, SYCLIntelLoopFuseAttr,
+          SYCLIntelMaxConcurrencyAttr, SYCLIntelDisableLoopPipeliningAttr,
+          SYCLIntelInitiationIntervalAttr, SYCLIntelUseStallEnableClustersAttr,
+          SYCLDeviceHasAttr, SYCLAddIRAttributesFunctionAttr>(A);
     });
   }
 }
@@ -724,9 +722,7 @@ class DiagDeviceFunction : public RecursiveASTVisitor<DiagDeviceFunction> {
 
   // Make sure we skip the condition of the case, since that is a constant
   // expression.
-  bool TraverseCaseStmt(CaseStmt *S) {
-    return TraverseStmt(S->getSubStmt());
-  }
+  bool TraverseCaseStmt(CaseStmt *S) { return TraverseStmt(S->getSubStmt()); }
 
   // Skip checking the size expr, since a constant array type loc's size expr is
   // a constant expression.
@@ -993,7 +989,8 @@ class SingleDeviceFunctionTracker {
         !KernelBody->hasAttr<AlwaysInlineAttr>() &&
         !KernelBody->hasAttr<SYCLSimdAttr>()) {
       KernelBody->addAttr(AlwaysInlineAttr::CreateImplicit(
-          KernelBody->getASTContext(), {}, AlwaysInlineAttr::Keyword_forceinline));
+          KernelBody->getASTContext(), {},
+          AlwaysInlineAttr::Keyword_forceinline));
     }
   }
 
@@ -1085,8 +1082,7 @@ class MarkWIScopeFnVisitor : public RecursiveASTVisitor<MarkWIScopeFnVisitor> {
       // not a member of sycl::group - continue search
       return true;
     auto Name = Callee->getName();
-    if (Name != "wait_for" ||
-        Callee->hasAttr<SYCLScopeAttr>())
+    if (Name != "wait_for" || Callee->hasAttr<SYCLScopeAttr>())
       return true;
     // it is a call to sycl::group::wait_for - mark the callee
     Callee->addAttr(
@@ -1305,15 +1301,21 @@ static bool isReadOnlyAccessor(const TemplateArgument &AccessModeArg) {
 // anonymous namespace so these don't get linkage.
 namespace {
 
-template <typename T> struct bind_param { using type = T; };
+template <typename T> struct bind_param {
+  using type = T;
+};
 
 template <> struct bind_param<CXXBaseSpecifier &> {
   using type = const CXXBaseSpecifier &;
 };
 
-template <> struct bind_param<FieldDecl *&> { using type = FieldDecl *; };
+template <> struct bind_param<FieldDecl *&> {
+  using type = FieldDecl *;
+};
 
-template <> struct bind_param<FieldDecl *const &> { using type = FieldDecl *; };
+template <> struct bind_param<FieldDecl *const &> {
+  using type = FieldDecl *;
+};
 
 template <typename T> using bind_param_t = typename bind_param<T>::type;
 
@@ -1322,7 +1324,7 @@ class KernelObjVisitor {
 
   template <typename ParentTy, typename... HandlerTys>
   void VisitUnionImpl(const CXXRecordDecl *Owner, ParentTy &Parent,
-                      const CXXRecordDecl *Wrapper, HandlerTys &... Handlers) {
+                      const CXXRecordDecl *Wrapper, HandlerTys &...Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.enterUnion(Owner, Parent), 0)...};
     VisitRecordHelper(Wrapper, Wrapper->fields(), Handlers...);
@@ -1332,13 +1334,13 @@ class KernelObjVisitor {
 
   // These enable handler execution only when previous Handlers succeed.
   template <typename... Tn>
-  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&... tn) {
+  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&...tn) {
     bool result = true;
     (void)std::initializer_list<int>{(result = result && tn(FD, FDTy), 0)...};
     return result;
   }
   template <typename... Tn>
-  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&... tn) {
+  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&...tn) {
     bool result = true;
     std::initializer_list<int>{(result = result && tn(BD, BDTy), 0)...};
     return result;
@@ -1354,7 +1356,7 @@ class KernelObjVisitor {
                 std::ref(Handlers), _1, _2)...)
 
   // The following simpler definition works with gcc 8.x and later.
-  //#define KF_FOR_EACH(FUNC) \
+  // #define KF_FOR_EACH(FUNC) \
 //  handleField(Field, FieldTy, ([&](FieldDecl *FD, QualType FDTy) { \
 //                return Handlers.f(FD, FDTy); \
 //              })...)
@@ -1383,7 +1385,7 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitComplexRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                           const CXXRecordDecl *Wrapper, QualType RecordTy,
-                          HandlerTys &... Handlers) {
+                          HandlerTys &...Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.enterStruct(Owner, Parent, RecordTy), 0)...};
     VisitRecordHelper(Wrapper, Wrapper->bases(), Handlers...);
@@ -1395,7 +1397,7 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitSimpleRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                          const CXXRecordDecl *Wrapper, QualType RecordTy,
-                         HandlerTys &... Handlers) {
+                         HandlerTys &...Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.handleNonDecompStruct(Owner, Parent, RecordTy), 0)...};
   }
@@ -1403,16 +1405,16 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                    const CXXRecordDecl *Wrapper, QualType RecordTy,
-                   HandlerTys &... Handlers);
+                   HandlerTys &...Handlers);
 
   template <typename ParentTy, typename... HandlerTys>
   void VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
-                  const CXXRecordDecl *Wrapper, HandlerTys &... Handlers);
+                  const CXXRecordDecl *Wrapper, HandlerTys &...Handlers);
 
   template <typename... HandlerTys>
   void VisitRecordHelper(const CXXRecordDecl *Owner,
                          clang::CXXRecordDecl::base_class_const_range Range,
-                         HandlerTys &... Handlers) {
+                         HandlerTys &...Handlers) {
     for (const auto &Base : Range) {
       QualType BaseTy = Base.getType();
       // Handle accessor class as base
@@ -1429,14 +1431,14 @@ class KernelObjVisitor {
   template <typename... HandlerTys>
   void VisitRecordHelper(const CXXRecordDecl *Owner,
                          RecordDecl::field_range Range,
-                         HandlerTys &... Handlers) {
+                         HandlerTys &...Handlers) {
     VisitRecordFields(Owner, Handlers...);
   }
 
   template <typename... HandlerTys>
   void visitArrayElementImpl(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
                              QualType ElementTy, uint64_t Index,
-                             HandlerTys &... Handlers) {
+                             HandlerTys &...Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.nextElement(ElementTy, Index), 0)...};
     visitField(Owner, ArrayField, ElementTy, Handlers...);
@@ -1444,24 +1446,24 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void visitFirstArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
-                              QualType ElementTy, HandlerTys &... Handlers) {
+                              QualType ElementTy, HandlerTys &...Handlers) {
     visitArrayElementImpl(Owner, ArrayField, ElementTy, 0, Handlers...);
   }
   template <typename... HandlerTys>
   void visitNthArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
                             QualType ElementTy, uint64_t Index,
-                            HandlerTys &... Handlers);
+                            HandlerTys &...Handlers);
 
   template <typename... HandlerTys>
   void visitSimpleArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                        QualType ArrayTy, HandlerTys &... Handlers) {
+                        QualType ArrayTy, HandlerTys &...Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.handleSimpleArrayType(Field, ArrayTy), 0)...};
   }
 
   template <typename... HandlerTys>
   void visitComplexArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                         QualType ArrayTy, HandlerTys &... Handlers) {
+                         QualType ArrayTy, HandlerTys &...Handlers) {
     // Array workflow is:
     // handleArrayType
     // enterArray
@@ -1493,7 +1495,7 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void visitField(const CXXRecordDecl *Owner, FieldDecl *Field,
-                  QualType FieldTy, HandlerTys &... Handlers) {
+                  QualType FieldTy, HandlerTys &...Handlers) {
     if (isSyclSpecialType(FieldTy, SemaSYCLRef))
       KF_FOR_EACH(handleSyclSpecialType, Field, FieldTy);
     else if (FieldTy->isStructureOrClassType()) {
@@ -1521,10 +1523,9 @@ class KernelObjVisitor {
   template <typename... HandlerTys>
   void visitParam(ParmVarDecl *Param, QualType ParamTy,
                   HandlerTys &...Handlers) {
-    if (isSyclSpecialType(ParamTy, SemaSYCLRef)){
+    if (isSyclSpecialType(ParamTy, SemaSYCLRef)) {
       KP_FOR_EACH(handleSyclSpecialType, Param, ParamTy);
-}
-    else if (ParamTy->isStructureOrClassType()) {
+    } else if (ParamTy->isStructureOrClassType()) {
       if (KP_FOR_EACH(handleStructType, Param, ParamTy)) {
         CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
         visitRecord(nullptr, Param, RD, ParamTy, Handlers...);
@@ -1569,14 +1570,14 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void VisitRecordBases(const CXXRecordDecl *KernelFunctor,
-                        HandlerTys &... Handlers) {
+                        HandlerTys &...Handlers) {
     VisitRecordHelper(KernelFunctor, KernelFunctor->bases(), Handlers...);
   }
 
   // A visitor function that dispatches to functions as defined in
   // SyclKernelFieldHandler for the purposes of kernel generation.
   template <typename... HandlerTys>
-  void VisitRecordFields(const CXXRecordDecl *Owner, HandlerTys &... Handlers) {
+  void VisitRecordFields(const CXXRecordDecl *Owner, HandlerTys &...Handlers) {
     for (const auto Field : Owner->fields())
       visitField(Owner, Field, Field->getType(), Handlers...);
   }
@@ -1762,7 +1763,9 @@ template <typename H> struct HandlerFilter<false, H> {
 
 template <bool B, bool... Rest> struct AnyTrue;
 
-template <bool B> struct AnyTrue<B> { static constexpr bool Value = B; };
+template <bool B> struct AnyTrue<B> {
+  static constexpr bool Value = B;
+};
 
 template <bool B, bool... Rest> struct AnyTrue {
   static constexpr bool Value = B || AnyTrue<Rest...>::Value;
@@ -1770,7 +1773,9 @@ template <bool B, bool... Rest> struct AnyTrue {
 
 template <bool B, bool... Rest> struct AllTrue;
 
-template <bool B> struct AllTrue<B> { static constexpr bool Value = B; };
+template <bool B> struct AllTrue<B> {
+  static constexpr bool Value = B;
+};
 
 template <bool B, bool... Rest> struct AllTrue {
   static constexpr bool Value = B && AllTrue<Rest...>::Value;
@@ -1779,7 +1784,7 @@ template <bool B, bool... Rest> struct AllTrue {
 template <typename ParentTy, typename... Handlers>
 void KernelObjVisitor::VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
                                   const CXXRecordDecl *Wrapper,
-                                  Handlers &... handlers) {
+                                  Handlers &...handlers) {
   // Don't continue descending if none of the handlers 'care'. This could be 'if
   // constexpr' starting in C++17.  Until then, we have to count on the
   // optimizer to realize "if (false)" is a dead branch.
@@ -1793,7 +1798,7 @@ template <typename... Handlers>
 void KernelObjVisitor::visitNthArrayElement(const CXXRecordDecl *Owner,
                                             FieldDecl *ArrayField,
                                             QualType ElementTy, uint64_t Index,
-                                            Handlers &... handlers) {
+                                            Handlers &...handlers) {
   // Don't continue descending if none of the handlers 'care'. This could be 'if
   // constexpr' starting in C++17.  Until then, we have to count on the
   // optimizer to realize "if (false)" is a dead branch.
@@ -1807,8 +1812,7 @@ void KernelObjVisitor::visitNthArrayElement(const CXXRecordDecl *Owner,
 template <typename ParentTy, typename... HandlerTys>
 void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                                    const CXXRecordDecl *Wrapper,
-                                   QualType RecordTy,
-                                   HandlerTys &... Handlers) {
+                                   QualType RecordTy, HandlerTys &...Handlers) {
   RecordDecl *RD = RecordTy->getAsRecordDecl();
   assert(RD && "should not be null.");
   if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
@@ -1853,7 +1857,7 @@ void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
 
 template <typename... HandlerTys>
 void KernelObjVisitor::visitArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                                  QualType ArrayTy, HandlerTys &... Handlers) {
+                                  QualType ArrayTy, HandlerTys &...Handlers) {
 
   if (Field->hasAttr<SYCLRequiresDecompositionAttr>()) {
     visitComplexArray(Owner, Field, ArrayTy, Handlers...);
@@ -2048,8 +2052,7 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
     NotForwardDeclarableReason NFDR =
         isForwardDeclarable(RD, SemaSYCLRef, /*DiagForFreeFunction=*/true);
     if (NFDR != NotForwardDeclarableReason::None) {
-      Diag.Report(PD->getLocation(),
-                  diag::err_bad_kernel_param_type)
+      Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
           << ParamTy;
       Diag.Report(PD->getLocation(),
                   diag::note_free_function_kernel_param_type_not_fwd_declarable)
@@ -2073,22 +2076,22 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
     if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
       CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
-    // For free functions all struct/class kernel arguments are forward declared
-    // in integration header, that adds additional restrictions for kernel
-    // arguments.
-    NotForwardDeclarableReason NFDR =
-        isForwardDeclarable(RD, SemaSYCLRef, /*DiagForFreeFunction=*/true);
-    if (NFDR != NotForwardDeclarableReason::None) {
-      Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
-          << ParamTy;
-      Diag.Report(PD->getLocation(),
-                  diag::note_free_function_kernel_param_type_not_fwd_declarable)
-          << ParamTy;
-      IsInvalid = true;
-    } else
-    IsInvalid = false;
-}
-    else {
+      // For free functions all struct/class kernel arguments are forward
+      // declared in integration header, that adds additional restrictions for
+      // kernel arguments.
+      NotForwardDeclarableReason NFDR =
+          isForwardDeclarable(RD, SemaSYCLRef, /*DiagForFreeFunction=*/true);
+      if (NFDR != NotForwardDeclarableReason::None) {
+        Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
+            << ParamTy;
+        Diag.Report(
+            PD->getLocation(),
+            diag::note_free_function_kernel_param_type_not_fwd_declarable)
+            << ParamTy;
+        IsInvalid = true;
+      } else
+        IsInvalid = false;
+    } else {
       Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
           << ParamTy;
       IsInvalid = true;
@@ -2170,8 +2173,7 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
     // experience.
     CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
     if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
-      Diag.Report(PD->getLocation(),
-                  diag::err_bad_kernel_param_type)
+      Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
           << ParamTy;
       Diag.Report(PD->getLocation(),
                   diag::note_free_function_kernel_param_type_not_supported)
@@ -2245,7 +2247,8 @@ class SyclKernelUnionChecker : public SyclKernelFieldHandler {
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
     // TODO
-    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) return true;
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
+      return true;
     unsupportedFreeFunctionParamType();
     return true;
   }
@@ -3043,7 +3046,7 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
       size_t ParamIndex = Params.size();
       for (const ParmVarDecl *Param : InitMethod->parameters()) {
         QualType ParamTy = Param->getType();
-        addParam(Param, ParamTy.getCanonicalType());
+        addParam(PD, ParamTy.getCanonicalType());
         // Propagate add_ir_attributes_kernel_parameter attribute.
         if (const auto *AddIRAttr =
                 Param->getAttr<SYCLAddIRAttributesKernelParameterAttr>())
@@ -3052,7 +3055,7 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
       LastParamIndex = ParamIndex;
     } else
       unsupportedFreeFunctionParamType();
-   return true;
+    return true;
   }
 
   RecordDecl *wrapField(FieldDecl *Field, QualType FieldTy) {
@@ -3640,9 +3643,6 @@ class SyclKernelBodyCreator : public SyclKernelFieldHandler {
 
     BodyStmts.insert(BodyStmts.end(), FinalizeStmts.begin(),
                      FinalizeStmts.end());
-    //CompoundStmt::Create(SemaSYCLRef.getASTContext(), BodyStmts,
-                         //       FPOptionsOverride(), {}, {})->dumpPretty(SemaSYCLRef.getASTContext());
-
     return CompoundStmt::Create(SemaSYCLRef.getASTContext(), BodyStmts,
                                 FPOptionsOverride(), {}, {});
   }
@@ -4159,7 +4159,6 @@ class SyclKernelBodyCreator : public SyclKernelFieldHandler {
     annotateHierarchicalParallelismAPICalls();
     CompoundStmt *KernelBody = createKernelBody();
     DeclCreator.setBody(KernelBody);
-    DeclCreator.getKernelDecl()->dump();
   }
 
   bool handleSyclSpecialType(FieldDecl *FD, QualType Ty) final {
@@ -4352,7 +4351,8 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
 
   // Creates a DeclRefExpr to the ParmVar given be PD
   Expr *createParamReferenceExpr(ParmVarDecl *PD = nullptr) {
-    ParmVarDecl *FreeFunctionParameter = PD ? PD : DeclCreator.getParamVarDeclsForCurrentField()[0];
+    ParmVarDecl *FreeFunctionParameter =
+        PD ? PD : DeclCreator.getParamVarDeclsForCurrentField()[0];
     Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
         FreeFunctionParameter, FreeFunctionParameter->getType(), VK_LValue,
         FreeFunctionSrcLoc);
@@ -4450,11 +4450,9 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
     auto CallExpr = CallExpr::Create(Context, Fn, ArgExprs, ResultTy, VK,
                                      FreeFunctionSrcLoc, FPOptionsOverride());
     BodyStmts.push_back(CallExpr);
-  //  CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
-    //                            {})->dumpPretty(SemaSYCLRef.getASTContext());
-return CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
-                                {}); 
- }
+    return CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
+                                {});
+  }
 
   MemberExpr *buildMemberExpr(Expr *Base, ValueDecl *Member) {
     DeclAccessPair MemberDAP = DeclAccessPair::make(Member, AS_none);
@@ -4509,7 +4507,6 @@ return CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
   ~FreeFunctionKernelBodyCreator() {
     CompoundStmt *KernelBody = createFreeFunctionKernelBody();
     DeclCreator.setBody(KernelBody);
-    DeclCreator.getKernelDecl()->dump();
   }
 
   bool handleSyclSpecialType(FieldDecl *FD, QualType Ty) final {
@@ -4523,10 +4520,10 @@ return CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
     if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
       const auto *RecordDecl = ParamTy->getAsCXXRecordDecl();
       QualType Ty = PD->getOriginalType();
-     ASTContext &Ctx = SemaSYCLRef.SemaRef.getASTContext();
+      ASTContext &Ctx = SemaSYCLRef.SemaRef.getASTContext();
       VarDecl *WorkGroupMemoryClone = VarDecl::Create(
-          Ctx, DeclCreator.getKernelDecl(), FreeFunctionSrcLoc, FreeFunctionSrcLoc, PD->getIdentifier(),
-          PD->getType(),
+          Ctx, DeclCreator.getKernelDecl(), FreeFunctionSrcLoc,
+          FreeFunctionSrcLoc, PD->getIdentifier(), PD->getType(),
           Ctx.getTrivialTypeSourceInfo(Ty), SC_None);
       InitializedEntity VarEntity =
           InitializedEntity::InitializeVariable(WorkGroupMemoryClone);
@@ -4539,18 +4536,16 @@ return CompoundStmt::Create(Context, BodyStmts, FPOptionsOverride(), {},
       WorkGroupMemoryClone->setInit(
           SemaSYCLRef.SemaRef.MaybeCreateExprWithCleanups(Init.get()));
       WorkGroupMemoryClone->setInitStyle(VarDecl::CallInit);
-    Stmt *DS = new (SemaSYCLRef.getASTContext())
-        DeclStmt(DeclGroupRef(WorkGroupMemoryClone), FreeFunctionSrcLoc,
-                 FreeFunctionSrcLoc);
-    BodyStmts.push_back(DS);
+      Stmt *DS = new (SemaSYCLRef.getASTContext())
+          DeclStmt(DeclGroupRef(WorkGroupMemoryClone), FreeFunctionSrcLoc,
+                   FreeFunctionSrcLoc);
+      BodyStmts.push_back(DS);
       Expr *MemberBaseExpr = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-          WorkGroupMemoryClone, Ty, VK_LValue, FreeFunctionSrcLoc);
-      //createSpecialMethodCall(RecordDecl, InitMethodName, MemberBaseExpr,
-                              //BodyStmts);
-      Expr *RvalueMemberBaseExpr =  SemaSYCLRef.SemaRef.BuildDeclRefExpr(
           WorkGroupMemoryClone, Ty, VK_PRValue, FreeFunctionSrcLoc);
+      createSpecialMethodCall(RecordDecl, InitMethodName, MemberBaseExpr,
+                              BodyStmts);
 
-      ArgExprs.push_back(RvalueMemberBaseExpr);
+      ArgExprs.push_back(MemberBaseExpr);
     } else
       unsupportedFreeFunctionParamType();
     return true;
@@ -4836,7 +4831,8 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
     // TODO
     if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
       addParam(PD, ParamTy, SYCLIntegrationHeader::kind_work_group_memory);
-    else unsupportedFreeFunctionParamType();
+    else
+      unsupportedFreeFunctionParamType();
     return true;
   }
 
@@ -6025,7 +6021,7 @@ class SYCLFwdDeclEmitter
   void Visit(QualType T) {
     if (T.isNull())
       return;
-InnerTypeVisitor::Visit(T.getTypePtr());
+    InnerTypeVisitor::Visit(T.getTypePtr());
   }
 
   void VisitReferenceType(const ReferenceType *RT) {
@@ -6049,7 +6045,7 @@ InnerTypeVisitor::Visit(T.getTypePtr());
   }
 
   void VisitTagType(const TagType *T) {
-TagDecl *TD = T->getDecl();
+    TagDecl *TD = T->getDecl();
     if (const auto *TSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
       // - first, recurse into template parameters and emit needed forward
       //   declarations
@@ -6129,13 +6125,13 @@ TagDecl *TD = T->getDecl();
     VisitTemplateArgs(TA.getPackAsArray());
   }
 
-  void VisitFunctionProtoType(const FunctionProtoType *T) {    
-for (const auto Ty : T->getParamTypes()) 
+  void VisitFunctionProtoType(const FunctionProtoType *T) {
+    for (const auto Ty : T->getParamTypes())
       Visit(Ty.getCanonicalType());
     // So far this visitor method is only used for free function kernels whose
     // return type is void anyway, so it is not visited. Otherwise, add if
     // required.
-}
+  }
 };
 
 class SYCLKernelNameTypePrinter
@@ -6449,7 +6445,6 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     EmitPragmaDiagnosticPop(O);
   }
 
-
   O << "// names of all kernels defined in the corresponding source\n";
   O << "static constexpr\n";
   O << "const char* const kernel_names[] = {\n";
@@ -6589,7 +6584,7 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     O << "\n";
     O << "// Forward declarations of kernel and its argument types:\n";
     FwdDeclEmitter.Visit(K.SyclKernel->getType());
-O << "\n";
+    O << "\n";
     if (K.SyclKernel->getLanguageLinkage() == CLanguageLinkage)
       O << "extern \"C\" ";
     std::string ParmList;
@@ -6934,7 +6929,7 @@ bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
   for (const VarDecl *VD : GlobalVars) {
     VD = VD->getCanonicalDecl();
 
-    // Skip if this isn't a SpecIdType, DeviceGlobal, or HostPipe.  This 
+    // Skip if this isn't a SpecIdType, DeviceGlobal, or HostPipe.  This
     // can happen if it was a deduced type.
     if (!SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::specialization_id) &&
         !SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::host_pipe) &&
@@ -6979,8 +6974,7 @@ bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
         VD->getNameForDiagnostic(HostPipesOS, Policy, true);
       }
       HostPipesOS << ", \"";
-      HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(),
-                                                         VD);
+      HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(), VD);
       HostPipesOS << "\");\n";
     } else {
       EmittedFirstSpecConstant = true;
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index cc7b316811a5b..935f9ea87764e 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -163,7 +163,6 @@ class pipe;
 
 namespace ext ::oneapi ::experimental {
 template <typename, typename> class work_group_memory;
-template<typename DataT> size_t getWorkGroupMemorySize();
 struct image_descriptor;
 } // namespace ext::oneapi::experimental
 
@@ -1950,8 +1949,8 @@ class __SYCL_EXPORT handler {
                                 ext::oneapi::experimental::empty_properties_t>
   void set_arg(
       int ArgIndex,
-      ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> Arg) {
-    addArg(detail::kernel_param_kind_t::kind_work_group_memory, nullptr, ext::oneapi::experimental::getWorkGroupMemorySize<DataT>(),
+      ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &Arg) {
+    addArg(detail::kernel_param_kind_t::kind_work_group_memory, std::make_shared<std::remove_reference_t<decltype(Arg)>>(Arg).get(), 0,
            ArgIndex);
   }
 

From 1b968df5ee2827d14f686649683b798e7344cfba Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 11 Oct 2024 17:41:55 +0200
Subject: [PATCH 057/107] merge latest upstream changes

---
 llvm-spirv/lib/SPIRV/SPIRVWriter.cpp                | 13 ++++---------
 llvm-spirv/lib/SPIRV/libSPIRV/SPIRVErrorEnum.h      |  1 -
 llvm-spirv/test/{negative => }/zero-length-array.ll |  7 +++++--
 3 files changed, 9 insertions(+), 12 deletions(-)
 rename llvm-spirv/test/{negative => }/zero-length-array.ll (84%)

diff --git a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
index b5ba78aec867a..ecd2539abd7ed 100644
--- a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
+++ b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
@@ -453,24 +453,19 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
   if (T->isArrayTy()) {
     // SPIR-V 1.3 s3.32.6: Length is the number of elements in the array.
     //                     It must be at least 1.
-    if (T->getArrayNumElements() < 1) {
-      std::string Str;
-      llvm::raw_string_ostream OS(Str);
-      OS << *T;
-      SPIRVCK(T->getArrayNumElements() >= 1, InvalidArraySize, OS.str());
-    }
+    const auto ArraySize =
+        T->getArrayNumElements() ? T->getArrayNumElements() : 1;
     Type *ElTy = T->getArrayElementType();
     SPIRVType *TransType = BM->addArrayType(
         transType(ElTy),
         static_cast<SPIRVConstant *>(transValue(
-            ConstantInt::get(getSizetType(), T->getArrayNumElements(), false),
-            nullptr)));
+            ConstantInt::get(getSizetType(), ArraySize, false), nullptr)));
     mapType(T, TransType);
     if (ElTy->isPointerTy()) {
       mapType(
           ArrayType::get(TypedPointerType::get(Type::getInt8Ty(*Ctx),
                                                ElTy->getPointerAddressSpace()),
-                         T->getArrayNumElements()),
+                         ArraySize),
           TransType);
     }
     return TransType;
diff --git a/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVErrorEnum.h b/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVErrorEnum.h
index 9273f01c6199a..147622a5202c9 100644
--- a/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVErrorEnum.h
+++ b/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVErrorEnum.h
@@ -10,7 +10,6 @@ _SPIRV_OP(InvalidMemoryModel, "Expects 0-3.")
 _SPIRV_OP(InvalidFunctionControlMask, "")
 _SPIRV_OP(InvalidBuiltinSetName, "Expects OpenCL.std.")
 _SPIRV_OP(InvalidFunctionCall, "Unexpected llvm intrinsic:\n")
-_SPIRV_OP(InvalidArraySize, "Array size must be at least 1:")
 _SPIRV_OP(InvalidBitWidth, "Invalid bit width in input:")
 _SPIRV_OP(InvalidModule, "Invalid SPIR-V module:")
 _SPIRV_OP(InvalidLlvmModule, "Invalid LLVM module:")
diff --git a/llvm-spirv/test/negative/zero-length-array.ll b/llvm-spirv/test/zero-length-array.ll
similarity index 84%
rename from llvm-spirv/test/negative/zero-length-array.ll
rename to llvm-spirv/test/zero-length-array.ll
index 3689093fa68fe..80a8166361c7d 100644
--- a/llvm-spirv/test/negative/zero-length-array.ll
+++ b/llvm-spirv/test/zero-length-array.ll
@@ -1,7 +1,10 @@
+; REQUIRES: spirv-dis
 ; RUN: llvm-as %s -o %t.bc
-; RUN: not llvm-spirv %t.bc -o %t.spv 2>&1 | FileCheck %s
+; RUN: llvm-spirv %t.bc -o %t.spv
+; RUN: spirv-dis %t.spv | FileCheck %s
 
-; CHECK: InvalidArraySize: Array size must be at least 1: [0 x i32]
+; CHECK: [[REGISTER:%[a-zA-Z0-9_]+]] = OpConstant %uint 1
+; CHECK: OpTypeArray %uint [[REGISTER]]
 
 source_filename = "test.cl"
 target datalayout = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024"

From e6b66c31c38018536b183765d3d501c8dba11dc2 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Fri, 11 Oct 2024 20:34:28 +0200
Subject: [PATCH 058/107] Apply suggestions

---
 .../oneapi/experimental/work_group_memory.hpp | 20 +++++--------------
 sycl/include/sycl/handler.hpp                 |  8 ++++----
 .../WorkGroupMemoryBackendArgument.cpp}       |  0
 3 files changed, 9 insertions(+), 19 deletions(-)
 rename sycl/{test-e2e/WorkGroupMemory/UR_argument_test.cpp => unittests/Extensions/WorkGroupMemoryBackendArgument.cpp} (100%)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 0af3ad47b2345..01f642ab57481 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -26,14 +26,13 @@ class work_group_memory_impl {
   work_group_memory_impl(const work_group_memory_impl &rhs) = default;
   work_group_memory_impl &
   operator=(const work_group_memory_impl &rhs) = default;
-  work_group_memory_impl(size_t buffer_size)
-      : buffer_size{buffer_size} {}
-  private:
+  work_group_memory_impl(size_t buffer_size) : buffer_size{buffer_size} {}
+
+private:
   size_t buffer_size;
   friend class sycl::handler;
 };
 
-
 } // namespace detail
 namespace ext::oneapi::experimental {
 #ifdef __SYCL_DEVICE_ONLY__
@@ -57,8 +56,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   template <typename T = DataT,
             typename = std::enable_if_t<!sycl::detail::is_unbounded_array_v<T>>>
   work_group_memory(handler &)
-      : sycl::detail::work_group_memory_impl(
-                                             sizeof(DataT)) {}
+      : sycl::detail::work_group_memory_impl(sizeof(DataT)) {}
   template <typename T = DataT,
             typename = std::enable_if_t<sycl::detail::is_unbounded_array_v<T>>>
   work_group_memory(size_t num, handler &)
@@ -71,7 +69,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
                                     IsDecorated, value_type>(ptr);
   }
   DataT *operator&() const { return reinterpret_cast<DataT *>(ptr); }
-  operator DataT &() const { return *(this->operator&()); }
+  operator DataT &() const { return *reinterpret_cast<DataT *>(ptr); }
   template <typename T = DataT,
             typename = std::enable_if_t<!std::is_array_v<T>>>
   const work_group_memory &operator=(const DataT &value) const {
@@ -83,15 +81,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
 #endif
 private:
   decoratedPtr ptr;
-  size_t bufferSize;
-  template <typename DataType>
-  friend size_t getWorkGroupMemorySize();
 };
-
-template <typename DataType>
-size_t getWorkGroupMemorySize() {
-    return work_group_memory<DataType, empty_properties_t>::bufferSize;
-}
 } // namespace ext::oneapi::experimental
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 935f9ea87764e..6867850aedbf5 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -561,8 +561,7 @@ class __SYCL_EXPORT handler {
             make_error_code(errc::kernel_argument),
             "A work group memory object must not be used in a SYCL kernel "
             "function that is invoked via single_task or via the simple form "
-            "of "
-            "parallel_for that takes a range parameter.");
+            "of parallel_for that takes a range parameter.");
     }
   }
 
@@ -1950,8 +1949,9 @@ class __SYCL_EXPORT handler {
   void set_arg(
       int ArgIndex,
       ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &Arg) {
-    addArg(detail::kernel_param_kind_t::kind_work_group_memory, std::make_shared<std::remove_reference_t<decltype(Arg)>>(Arg).get(), 0,
-           ArgIndex);
+    addArg(detail::kernel_param_kind_t::kind_work_group_memory,
+           std::make_shared<std::remove_reference_t<decltype(Arg)>>(Arg).get(),
+           0, ArgIndex);
   }
 
   // set_arg for graph dynamic_parameters
diff --git a/sycl/test-e2e/WorkGroupMemory/UR_argument_test.cpp b/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
similarity index 100%
rename from sycl/test-e2e/WorkGroupMemory/UR_argument_test.cpp
rename to sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp

From 7dfa80bf2b1a77a5c20ea51e1923143a1661378f Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Sun, 13 Oct 2024 22:35:46 -0700
Subject: [PATCH 059/107] Address reviews

---
 clang/lib/Sema/SemaSYCL.cpp                   | 289 ++++++------------
 sycl/source/handler.cpp                       |   4 +-
 sycl/unittests/Extensions/CMakeLists.txt      |   1 +
 .../WorkGroupMemoryBackendArgument.cpp        |  47 ++-
 4 files changed, 122 insertions(+), 219 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index e9370020cf842..f83f3ff94eaac 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 // This implements Semantic Analysis for SYCL constructs.
 //===----------------------------------------------------------------------===//
+
 #include "clang/Sema/SemaSYCL.h"
 #include "TreeTransform.h"
 #include "clang/AST/AST.h"
@@ -34,7 +35,6 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
-#include <iostream>
 
 #include <array>
 #include <functional>
@@ -394,7 +394,8 @@ bool SemaSYCL::isDeclAllowedInSYCLDeviceCode(const Decl *D) {
       return true;
 
     const DeclContext *DC = FD->getDeclContext();
-    if (II && II->isStr("__spirv_ocl_printf") && !FD->isDefined() &&
+    if (II && II->isStr("__spirv_ocl_printf") &&
+        !FD->isDefined() &&
         FD->getLanguageLinkage() == CXXLanguageLinkage &&
         DC->getEnclosingNamespaceContext()->isTranslationUnit())
       return true;
@@ -622,18 +623,19 @@ static void collectSYCLAttributes(SemaSYCL &S, FunctionDecl *FD,
   if (DirectlyCalled) {
     llvm::copy_if(FD->getAttrs(), std::back_inserter(Attrs), [](Attr *A) {
       // FIXME: Make this list self-adapt as new SYCL attributes are added.
-      return isa<
-          IntelReqdSubGroupSizeAttr, IntelNamedSubGroupSizeAttr,
-          SYCLReqdWorkGroupSizeAttr, SYCLWorkGroupSizeHintAttr,
-          SYCLIntelKernelArgsRestrictAttr, SYCLIntelNumSimdWorkItemsAttr,
-          SYCLIntelSchedulerTargetFmaxMhzAttr, SYCLIntelMaxWorkGroupSizeAttr,
-          SYCLIntelMaxGlobalWorkDimAttr,
-          SYCLIntelMinWorkGroupsPerComputeUnitAttr,
-          SYCLIntelMaxWorkGroupsPerMultiprocessorAttr,
-          SYCLIntelNoGlobalWorkOffsetAttr, SYCLSimdAttr, SYCLIntelLoopFuseAttr,
-          SYCLIntelMaxConcurrencyAttr, SYCLIntelDisableLoopPipeliningAttr,
-          SYCLIntelInitiationIntervalAttr, SYCLIntelUseStallEnableClustersAttr,
-          SYCLDeviceHasAttr, SYCLAddIRAttributesFunctionAttr>(A);
+      return isa<IntelReqdSubGroupSizeAttr, IntelNamedSubGroupSizeAttr,
+                 SYCLReqdWorkGroupSizeAttr, SYCLWorkGroupSizeHintAttr,
+                 SYCLIntelKernelArgsRestrictAttr, SYCLIntelNumSimdWorkItemsAttr,
+                 SYCLIntelSchedulerTargetFmaxMhzAttr,
+                 SYCLIntelMaxWorkGroupSizeAttr, SYCLIntelMaxGlobalWorkDimAttr,
+                 SYCLIntelMinWorkGroupsPerComputeUnitAttr,
+                 SYCLIntelMaxWorkGroupsPerMultiprocessorAttr,
+                 SYCLIntelNoGlobalWorkOffsetAttr, SYCLSimdAttr,
+                 SYCLIntelLoopFuseAttr, SYCLIntelMaxConcurrencyAttr,
+                 SYCLIntelDisableLoopPipeliningAttr,
+                 SYCLIntelInitiationIntervalAttr,
+                 SYCLIntelUseStallEnableClustersAttr, SYCLDeviceHasAttr,
+                 SYCLAddIRAttributesFunctionAttr>(A);
     });
   }
 }
@@ -722,7 +724,9 @@ class DiagDeviceFunction : public RecursiveASTVisitor<DiagDeviceFunction> {
 
   // Make sure we skip the condition of the case, since that is a constant
   // expression.
-  bool TraverseCaseStmt(CaseStmt *S) { return TraverseStmt(S->getSubStmt()); }
+  bool TraverseCaseStmt(CaseStmt *S) {
+    return TraverseStmt(S->getSubStmt());
+  }
 
   // Skip checking the size expr, since a constant array type loc's size expr is
   // a constant expression.
@@ -989,8 +993,7 @@ class SingleDeviceFunctionTracker {
         !KernelBody->hasAttr<AlwaysInlineAttr>() &&
         !KernelBody->hasAttr<SYCLSimdAttr>()) {
       KernelBody->addAttr(AlwaysInlineAttr::CreateImplicit(
-          KernelBody->getASTContext(), {},
-          AlwaysInlineAttr::Keyword_forceinline));
+          KernelBody->getASTContext(), {}, AlwaysInlineAttr::Keyword_forceinline));
     }
   }
 
@@ -1082,7 +1085,8 @@ class MarkWIScopeFnVisitor : public RecursiveASTVisitor<MarkWIScopeFnVisitor> {
       // not a member of sycl::group - continue search
       return true;
     auto Name = Callee->getName();
-    if (Name != "wait_for" || Callee->hasAttr<SYCLScopeAttr>())
+    if (Name != "wait_for" ||
+        Callee->hasAttr<SYCLScopeAttr>())
       return true;
     // it is a call to sycl::group::wait_for - mark the callee
     Callee->addAttr(
@@ -1301,21 +1305,15 @@ static bool isReadOnlyAccessor(const TemplateArgument &AccessModeArg) {
 // anonymous namespace so these don't get linkage.
 namespace {
 
-template <typename T> struct bind_param {
-  using type = T;
-};
+template <typename T> struct bind_param { using type = T; };
 
 template <> struct bind_param<CXXBaseSpecifier &> {
   using type = const CXXBaseSpecifier &;
 };
 
-template <> struct bind_param<FieldDecl *&> {
-  using type = FieldDecl *;
-};
+template <> struct bind_param<FieldDecl *&> { using type = FieldDecl *; };
 
-template <> struct bind_param<FieldDecl *const &> {
-  using type = FieldDecl *;
-};
+template <> struct bind_param<FieldDecl *const &> { using type = FieldDecl *; };
 
 template <typename T> using bind_param_t = typename bind_param<T>::type;
 
@@ -1324,7 +1322,7 @@ class KernelObjVisitor {
 
   template <typename ParentTy, typename... HandlerTys>
   void VisitUnionImpl(const CXXRecordDecl *Owner, ParentTy &Parent,
-                      const CXXRecordDecl *Wrapper, HandlerTys &...Handlers) {
+                      const CXXRecordDecl *Wrapper, HandlerTys &... Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.enterUnion(Owner, Parent), 0)...};
     VisitRecordHelper(Wrapper, Wrapper->fields(), Handlers...);
@@ -1334,13 +1332,13 @@ class KernelObjVisitor {
 
   // These enable handler execution only when previous Handlers succeed.
   template <typename... Tn>
-  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&...tn) {
+  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&... tn) {
     bool result = true;
     (void)std::initializer_list<int>{(result = result && tn(FD, FDTy), 0)...};
     return result;
   }
   template <typename... Tn>
-  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&...tn) {
+  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&... tn) {
     bool result = true;
     std::initializer_list<int>{(result = result && tn(BD, BDTy), 0)...};
     return result;
@@ -1356,7 +1354,7 @@ class KernelObjVisitor {
                 std::ref(Handlers), _1, _2)...)
 
   // The following simpler definition works with gcc 8.x and later.
-  // #define KF_FOR_EACH(FUNC) \
+  //#define KF_FOR_EACH(FUNC) \
 //  handleField(Field, FieldTy, ([&](FieldDecl *FD, QualType FDTy) { \
 //                return Handlers.f(FD, FDTy); \
 //              })...)
@@ -1385,7 +1383,7 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitComplexRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                           const CXXRecordDecl *Wrapper, QualType RecordTy,
-                          HandlerTys &...Handlers) {
+                          HandlerTys &... Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.enterStruct(Owner, Parent, RecordTy), 0)...};
     VisitRecordHelper(Wrapper, Wrapper->bases(), Handlers...);
@@ -1397,7 +1395,7 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitSimpleRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                          const CXXRecordDecl *Wrapper, QualType RecordTy,
-                         HandlerTys &...Handlers) {
+                         HandlerTys &... Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.handleNonDecompStruct(Owner, Parent, RecordTy), 0)...};
   }
@@ -1405,16 +1403,16 @@ class KernelObjVisitor {
   template <typename ParentTy, typename... HandlerTys>
   void visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                    const CXXRecordDecl *Wrapper, QualType RecordTy,
-                   HandlerTys &...Handlers);
+                   HandlerTys &... Handlers);
 
   template <typename ParentTy, typename... HandlerTys>
   void VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
-                  const CXXRecordDecl *Wrapper, HandlerTys &...Handlers);
+                  const CXXRecordDecl *Wrapper, HandlerTys &... Handlers);
 
   template <typename... HandlerTys>
   void VisitRecordHelper(const CXXRecordDecl *Owner,
                          clang::CXXRecordDecl::base_class_const_range Range,
-                         HandlerTys &...Handlers) {
+                         HandlerTys &... Handlers) {
     for (const auto &Base : Range) {
       QualType BaseTy = Base.getType();
       // Handle accessor class as base
@@ -1431,14 +1429,14 @@ class KernelObjVisitor {
   template <typename... HandlerTys>
   void VisitRecordHelper(const CXXRecordDecl *Owner,
                          RecordDecl::field_range Range,
-                         HandlerTys &...Handlers) {
+                         HandlerTys &... Handlers) {
     VisitRecordFields(Owner, Handlers...);
   }
 
   template <typename... HandlerTys>
   void visitArrayElementImpl(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
                              QualType ElementTy, uint64_t Index,
-                             HandlerTys &...Handlers) {
+                             HandlerTys &... Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.nextElement(ElementTy, Index), 0)...};
     visitField(Owner, ArrayField, ElementTy, Handlers...);
@@ -1446,24 +1444,24 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void visitFirstArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
-                              QualType ElementTy, HandlerTys &...Handlers) {
+                              QualType ElementTy, HandlerTys &... Handlers) {
     visitArrayElementImpl(Owner, ArrayField, ElementTy, 0, Handlers...);
   }
   template <typename... HandlerTys>
   void visitNthArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
                             QualType ElementTy, uint64_t Index,
-                            HandlerTys &...Handlers);
+                            HandlerTys &... Handlers);
 
   template <typename... HandlerTys>
   void visitSimpleArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                        QualType ArrayTy, HandlerTys &...Handlers) {
+                        QualType ArrayTy, HandlerTys &... Handlers) {
     (void)std::initializer_list<int>{
         (Handlers.handleSimpleArrayType(Field, ArrayTy), 0)...};
   }
 
   template <typename... HandlerTys>
   void visitComplexArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                         QualType ArrayTy, HandlerTys &...Handlers) {
+                         QualType ArrayTy, HandlerTys &... Handlers) {
     // Array workflow is:
     // handleArrayType
     // enterArray
@@ -1495,7 +1493,7 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void visitField(const CXXRecordDecl *Owner, FieldDecl *Field,
-                  QualType FieldTy, HandlerTys &...Handlers) {
+                  QualType FieldTy, HandlerTys &... Handlers) {
     if (isSyclSpecialType(FieldTy, SemaSYCLRef))
       KF_FOR_EACH(handleSyclSpecialType, Field, FieldTy);
     else if (FieldTy->isStructureOrClassType()) {
@@ -1523,9 +1521,9 @@ class KernelObjVisitor {
   template <typename... HandlerTys>
   void visitParam(ParmVarDecl *Param, QualType ParamTy,
                   HandlerTys &...Handlers) {
-    if (isSyclSpecialType(ParamTy, SemaSYCLRef)) {
-      KP_FOR_EACH(handleSyclSpecialType, Param, ParamTy);
-    } else if (ParamTy->isStructureOrClassType()) {
+    if (isSyclSpecialType(ParamTy, SemaSYCLRef))
+      KP_FOR_EACH(handleOtherType, Param, ParamTy);
+    else if (ParamTy->isStructureOrClassType()) {
       if (KP_FOR_EACH(handleStructType, Param, ParamTy)) {
         CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
         visitRecord(nullptr, Param, RD, ParamTy, Handlers...);
@@ -1570,14 +1568,14 @@ class KernelObjVisitor {
 
   template <typename... HandlerTys>
   void VisitRecordBases(const CXXRecordDecl *KernelFunctor,
-                        HandlerTys &...Handlers) {
+                        HandlerTys &... Handlers) {
     VisitRecordHelper(KernelFunctor, KernelFunctor->bases(), Handlers...);
   }
 
   // A visitor function that dispatches to functions as defined in
   // SyclKernelFieldHandler for the purposes of kernel generation.
   template <typename... HandlerTys>
-  void VisitRecordFields(const CXXRecordDecl *Owner, HandlerTys &...Handlers) {
+  void VisitRecordFields(const CXXRecordDecl *Owner, HandlerTys &... Handlers) {
     for (const auto Field : Owner->fields())
       visitField(Owner, Field, Field->getType(), Handlers...);
   }
@@ -1763,9 +1761,7 @@ template <typename H> struct HandlerFilter<false, H> {
 
 template <bool B, bool... Rest> struct AnyTrue;
 
-template <bool B> struct AnyTrue<B> {
-  static constexpr bool Value = B;
-};
+template <bool B> struct AnyTrue<B> { static constexpr bool Value = B; };
 
 template <bool B, bool... Rest> struct AnyTrue {
   static constexpr bool Value = B || AnyTrue<Rest...>::Value;
@@ -1773,9 +1769,7 @@ template <bool B, bool... Rest> struct AnyTrue {
 
 template <bool B, bool... Rest> struct AllTrue;
 
-template <bool B> struct AllTrue<B> {
-  static constexpr bool Value = B;
-};
+template <bool B> struct AllTrue<B> { static constexpr bool Value = B; };
 
 template <bool B, bool... Rest> struct AllTrue {
   static constexpr bool Value = B && AllTrue<Rest...>::Value;
@@ -1784,7 +1778,7 @@ template <bool B, bool... Rest> struct AllTrue {
 template <typename ParentTy, typename... Handlers>
 void KernelObjVisitor::VisitUnion(const CXXRecordDecl *Owner, ParentTy &Parent,
                                   const CXXRecordDecl *Wrapper,
-                                  Handlers &...handlers) {
+                                  Handlers &... handlers) {
   // Don't continue descending if none of the handlers 'care'. This could be 'if
   // constexpr' starting in C++17.  Until then, we have to count on the
   // optimizer to realize "if (false)" is a dead branch.
@@ -1798,7 +1792,7 @@ template <typename... Handlers>
 void KernelObjVisitor::visitNthArrayElement(const CXXRecordDecl *Owner,
                                             FieldDecl *ArrayField,
                                             QualType ElementTy, uint64_t Index,
-                                            Handlers &...handlers) {
+                                            Handlers &... handlers) {
   // Don't continue descending if none of the handlers 'care'. This could be 'if
   // constexpr' starting in C++17.  Until then, we have to count on the
   // optimizer to realize "if (false)" is a dead branch.
@@ -1812,7 +1806,8 @@ void KernelObjVisitor::visitNthArrayElement(const CXXRecordDecl *Owner,
 template <typename ParentTy, typename... HandlerTys>
 void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
                                    const CXXRecordDecl *Wrapper,
-                                   QualType RecordTy, HandlerTys &...Handlers) {
+                                   QualType RecordTy,
+                                   HandlerTys &... Handlers) {
   RecordDecl *RD = RecordTy->getAsRecordDecl();
   assert(RD && "should not be null.");
   if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
@@ -1857,7 +1852,7 @@ void KernelObjVisitor::visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
 
 template <typename... HandlerTys>
 void KernelObjVisitor::visitArray(const CXXRecordDecl *Owner, FieldDecl *Field,
-                                  QualType ArrayTy, HandlerTys &...Handlers) {
+                                  QualType ArrayTy, HandlerTys &... Handlers) {
 
   if (Field->hasAttr<SYCLRequiresDecompositionAttr>()) {
     visitComplexArray(Owner, Field, ArrayTy, Handlers...);
@@ -2052,7 +2047,8 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
     NotForwardDeclarableReason NFDR =
         isForwardDeclarable(RD, SemaSYCLRef, /*DiagForFreeFunction=*/true);
     if (NFDR != NotForwardDeclarableReason::None) {
-      Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
+      Diag.Report(PD->getLocation(),
+                  diag::err_bad_kernel_param_type)
           << ParamTy;
       Diag.Report(PD->getLocation(),
                   diag::note_free_function_kernel_param_type_not_fwd_declarable)
@@ -2074,28 +2070,8 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
   }
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
-      CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
-      // For free functions all struct/class kernel arguments are forward
-      // declared in integration header, that adds additional restrictions for
-      // kernel arguments.
-      NotForwardDeclarableReason NFDR =
-          isForwardDeclarable(RD, SemaSYCLRef, /*DiagForFreeFunction=*/true);
-      if (NFDR != NotForwardDeclarableReason::None) {
-        Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
-            << ParamTy;
-        Diag.Report(
-            PD->getLocation(),
-            diag::note_free_function_kernel_param_type_not_fwd_declarable)
-            << ParamTy;
-        IsInvalid = true;
-      } else
-        IsInvalid = false;
-    } else {
-      Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
-          << ParamTy;
-      IsInvalid = true;
-    }
+    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
+    IsInvalid = true;
     return isValid();
   }
 
@@ -2173,7 +2149,8 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
     // experience.
     CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
     if (RD->hasAttr<SYCLRequiresDecompositionAttr>()) {
-      Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
+      Diag.Report(PD->getLocation(),
+                  diag::err_bad_kernel_param_type)
           << ParamTy;
       Diag.Report(PD->getLocation(),
                   diag::note_free_function_kernel_param_type_not_supported)
@@ -2247,8 +2224,6 @@ class SyclKernelUnionChecker : public SyclKernelFieldHandler {
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
     // TODO
-    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
-      return true;
     unsupportedFreeFunctionParamType();
     return true;
   }
@@ -2287,7 +2262,7 @@ class SyclKernelDecompMarker : public SyclKernelFieldHandler {
     return true;
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *, QualType Ty) final {
+  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
     // TODO We don't support special types in free function kernel parameters,
     // but track them to diagnose the case properly.
     CollectionStack.back() = true;
@@ -3033,28 +3008,9 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
     return handleSpecialType(FD, FieldTy);
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
+  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
     // TODO
-    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
-      const auto *RecordDecl = ParamTy->getAsCXXRecordDecl();
-      assert(RecordDecl && "The type must be a RecordDecl");
-      CXXMethodDecl *InitMethod = getMethodByName(RecordDecl, InitMethodName);
-      assert(InitMethod && "The type must have the __init method");
-
-      // Don't do -1 here because we count on this to be the first parameter
-      // added (if any).
-      size_t ParamIndex = Params.size();
-      for (const ParmVarDecl *Param : InitMethod->parameters()) {
-        QualType ParamTy = Param->getType();
-        addParam(PD, ParamTy.getCanonicalType());
-        // Propagate add_ir_attributes_kernel_parameter attribute.
-        if (const auto *AddIRAttr =
-                Param->getAttr<SYCLAddIRAttributesKernelParameterAttr>())
-          Params.back()->addAttr(AddIRAttr->clone(SemaSYCLRef.getASTContext()));
-      }
-      LastParamIndex = ParamIndex;
-    } else
-      unsupportedFreeFunctionParamType();
+    unsupportedFreeFunctionParamType();
     return true;
   }
 
@@ -3330,7 +3286,9 @@ class SyclKernelArgsSizeChecker : public SyclKernelFieldHandler {
   }
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    return handleSpecialType(ParamTy);
+    // TODO
+    unsupportedFreeFunctionParamType();
+    return true;
   }
 
   bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
@@ -3643,6 +3601,7 @@ class SyclKernelBodyCreator : public SyclKernelFieldHandler {
 
     BodyStmts.insert(BodyStmts.end(), FinalizeStmts.begin(),
                      FinalizeStmts.end());
+
     return CompoundStmt::Create(SemaSYCLRef.getASTContext(), BodyStmts,
                                 FPOptionsOverride(), {}, {});
   }
@@ -4349,12 +4308,15 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
   SourceLocation FreeFunctionSrcLoc; // Free function source location.
   llvm::SmallVector<Expr *, 8> ArgExprs;
 
-  // Creates a DeclRefExpr to the ParmVar given be PD
-  Expr *createParamReferenceExpr(ParmVarDecl *PD = nullptr) {
+  // Creates a DeclRefExpr to the ParmVar that represents the current free
+  // function parameter.
+  Expr *createParamReferenceExpr() {
     ParmVarDecl *FreeFunctionParameter =
-        PD ? PD : DeclCreator.getParamVarDeclsForCurrentField()[0];
+        DeclCreator.getParamVarDeclsForCurrentField()[0];
+
+    QualType FreeFunctionParamType = FreeFunctionParameter->getOriginalType();
     Expr *DRE = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-        FreeFunctionParameter, FreeFunctionParameter->getType(), VK_LValue,
+        FreeFunctionParameter, FreeFunctionParamType, VK_LValue,
         FreeFunctionSrcLoc);
     DRE = SemaSYCLRef.SemaRef.DefaultLvalueConversion(DRE).get();
     return DRE;
@@ -4454,48 +4416,6 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
                                 {});
   }
 
-  MemberExpr *buildMemberExpr(Expr *Base, ValueDecl *Member) {
-    DeclAccessPair MemberDAP = DeclAccessPair::make(Member, AS_none);
-    MemberExpr *Result = SemaSYCLRef.SemaRef.BuildMemberExpr(
-        Base, /*IsArrow */ false, FreeFunctionSrcLoc, NestedNameSpecifierLoc(),
-        FreeFunctionSrcLoc, Member, MemberDAP,
-        /*HadMultipleCandidates*/ false,
-        DeclarationNameInfo(Member->getDeclName(), FreeFunctionSrcLoc),
-        Member->getType(), VK_LValue, OK_Ordinary);
-    return Result;
-  }
-
-  void createSpecialMethodCall(const CXXRecordDecl *RD, StringRef MethodName,
-                               Expr *MemberBaseExpr,
-                               SmallVectorImpl<Stmt *> &AddTo) {
-    CXXMethodDecl *Method = getMethodByName(RD, MethodName);
-    if (!Method)
-      return;
-
-    unsigned NumParams = Method->getNumParams();
-    llvm::SmallVector<Expr *, 4> ParamDREs(NumParams);
-    llvm::ArrayRef<ParmVarDecl *> KernelParameters =
-        DeclCreator.getParamVarDeclsForCurrentField();
-    for (size_t I = 0; I < NumParams; ++I) {
-      QualType ParamType = KernelParameters[I]->getOriginalType();
-      ParamDREs[I] = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-          KernelParameters[I], ParamType, VK_LValue, FreeFunctionSrcLoc);
-    }
-
-    MemberExpr *MethodME = buildMemberExpr(MemberBaseExpr, Method);
-
-    QualType ResultTy = Method->getReturnType();
-    ExprValueKind VK = Expr::getValueKindForType(ResultTy);
-    ResultTy = ResultTy.getNonLValueExprType(SemaSYCLRef.getASTContext());
-    llvm::SmallVector<Expr *, 4> ParamStmts;
-    const auto *Proto = cast<FunctionProtoType>(Method->getType());
-    SemaSYCLRef.SemaRef.GatherArgumentsForCall(FreeFunctionSrcLoc, Method,
-                                               Proto, 0, ParamDREs, ParamStmts);
-    AddTo.push_back(CXXMemberCallExpr::Create(
-        SemaSYCLRef.getASTContext(), MethodME, ParamStmts, ResultTy, VK,
-        FreeFunctionSrcLoc, FPOptionsOverride()));
-  }
-
 public:
   static constexpr const bool VisitInsideSimpleContainers = false;
 
@@ -4515,39 +4435,9 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
     return true;
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
+  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
     // TODO
-    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
-      const auto *RecordDecl = ParamTy->getAsCXXRecordDecl();
-      QualType Ty = PD->getOriginalType();
-      ASTContext &Ctx = SemaSYCLRef.SemaRef.getASTContext();
-      VarDecl *WorkGroupMemoryClone = VarDecl::Create(
-          Ctx, DeclCreator.getKernelDecl(), FreeFunctionSrcLoc,
-          FreeFunctionSrcLoc, PD->getIdentifier(), PD->getType(),
-          Ctx.getTrivialTypeSourceInfo(Ty), SC_None);
-      InitializedEntity VarEntity =
-          InitializedEntity::InitializeVariable(WorkGroupMemoryClone);
-      InitializationKind InitKind =
-          InitializationKind::CreateDefault(FreeFunctionSrcLoc);
-      InitializationSequence InitSeq(SemaSYCLRef.SemaRef, VarEntity, InitKind,
-                                     std::nullopt);
-      ExprResult Init = InitSeq.Perform(SemaSYCLRef.SemaRef, VarEntity,
-                                        InitKind, std::nullopt);
-      WorkGroupMemoryClone->setInit(
-          SemaSYCLRef.SemaRef.MaybeCreateExprWithCleanups(Init.get()));
-      WorkGroupMemoryClone->setInitStyle(VarDecl::CallInit);
-      Stmt *DS = new (SemaSYCLRef.getASTContext())
-          DeclStmt(DeclGroupRef(WorkGroupMemoryClone), FreeFunctionSrcLoc,
-                   FreeFunctionSrcLoc);
-      BodyStmts.push_back(DS);
-      Expr *MemberBaseExpr = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
-          WorkGroupMemoryClone, Ty, VK_PRValue, FreeFunctionSrcLoc);
-      createSpecialMethodCall(RecordDecl, InitMethodName, MemberBaseExpr,
-                              BodyStmts);
-
-      ArgExprs.push_back(MemberBaseExpr);
-    } else
-      unsupportedFreeFunctionParamType();
+    unsupportedFreeFunctionParamType();
     return true;
   }
 
@@ -4827,12 +4717,9 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
     return true;
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
+  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
     // TODO
-    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
-      addParam(PD, ParamTy, SYCLIntegrationHeader::kind_work_group_memory);
-    else
-      unsupportedFreeFunctionParamType();
+    unsupportedFreeFunctionParamType();
     return true;
   }
 
@@ -5020,6 +4907,7 @@ class SYCLKernelNameTypeVisitor
   void Visit(QualType T) {
     if (T.isNull())
       return;
+
     const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
     // If KernelNameType has template args visit each template arg via
     // ConstTemplateArgumentVisitor
@@ -5678,9 +5566,11 @@ void SemaSYCL::ProcessFreeFunction(FunctionDecl *FD) {
     KernelObjVisitor Visitor{*this};
 
     DiagnosingSYCLKernel = true;
+
     // Check parameters of free function.
     Visitor.VisitFunctionParameters(FD, DecompMarker, FieldChecker,
                                     UnionChecker);
+
     DiagnosingSYCLKernel = false;
 
     // Ignore the free function if any of the checkers fail validation.
@@ -5886,7 +5776,7 @@ static const char *paramKind2Str(KernelParamKind K) {
     CASE(stream);
     CASE(specialization_constants_buffer);
     CASE(pointer);
-    CASE(work_group_memory);
+    CASE(work_group_mmeory);
   }
   return "<ERROR>";
 
@@ -6306,16 +6196,6 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
   O << "#include <sycl/detail/defines_elementary.hpp>\n";
   O << "#include <sycl/detail/kernel_desc.hpp>\n";
   O << "#include <sycl/ext/oneapi/experimental/free_function_traits.hpp>\n";
-  O << "#include <sycl/ext/oneapi/properties/properties.hpp>\n";
-  O << "namespace sycl { inline namespace _V1 { namespace ext { namespace "
-       "oneapi { namespace experimental {\n"
-       "    template<typename DataT, typename PropertiesT = "
-       "properties<std::tuple<>>> class work_group_memory;\n"
-       "}\n"
-       "}\n"
-       "}\n"
-       "}\n"
-       "}\n";
 
   O << "\n";
 
@@ -6445,6 +6325,7 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     EmitPragmaDiagnosticPop(O);
   }
 
+
   O << "// names of all kernels defined in the corresponding source\n";
   O << "static constexpr\n";
   O << "const char* const kernel_names[] = {\n";
@@ -6585,6 +6466,7 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     O << "// Forward declarations of kernel and its argument types:\n";
     FwdDeclEmitter.Visit(K.SyclKernel->getType());
     O << "\n";
+
     if (K.SyclKernel->getLanguageLinkage() == CLanguageLinkage)
       O << "extern \"C\" ";
     std::string ParmList;
@@ -6929,7 +6811,7 @@ bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
   for (const VarDecl *VD : GlobalVars) {
     VD = VD->getCanonicalDecl();
 
-    // Skip if this isn't a SpecIdType, DeviceGlobal, or HostPipe.  This
+    // Skip if this isn't a SpecIdType, DeviceGlobal, or HostPipe.  This 
     // can happen if it was a deduced type.
     if (!SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::specialization_id) &&
         !SemaSYCL::isSyclType(VD->getType(), SYCLTypeAttr::host_pipe) &&
@@ -6974,7 +6856,8 @@ bool SYCLIntegrationFooter::emit(raw_ostream &OS) {
         VD->getNameForDiagnostic(HostPipesOS, Policy, true);
       }
       HostPipesOS << ", \"";
-      HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(), VD);
+      HostPipesOS << SYCLUniqueStableIdExpr::ComputeName(S.getASTContext(),
+                                                         VD);
       HostPipesOS << "\");\n";
     } else {
       EmittedFirstSpecConstant = true;
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index fffa09a3ccf25..3ed8fc2bb9e73 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -797,9 +797,7 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
     break;
   }
   case kernel_param_kind_t::kind_work_group_memory: {
-//std::cout << static_cast<detail::work_group_memory_impl *>(Ptr)->buffer_size <<std::endl;
-addArg(kernel_param_kind_t::kind_std_layout, nullptr,
-           Size,
+    addArg(kernel_param_kind_t::kind_std_layout, nullptr, Size,
            Index + IndexShift);
     break;
   }
diff --git a/sycl/unittests/Extensions/CMakeLists.txt b/sycl/unittests/Extensions/CMakeLists.txt
index 9f251c5ea5de5..0f7d4fe8c76b1 100644
--- a/sycl/unittests/Extensions/CMakeLists.txt
+++ b/sycl/unittests/Extensions/CMakeLists.txt
@@ -15,6 +15,7 @@ add_sycl_unittest(ExtensionsTests OBJECT
   ProfilingTag.cpp
   KernelProperties.cpp
   NoDeviceIPVersion.cpp
+  WorkGroupMemoryBackendArgument.cpp
 )
 
 add_subdirectory(CommandGraph)
diff --git a/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp b/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
index 82fa25cf62549..e6b4753b0f0cf 100644
--- a/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
+++ b/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
@@ -1,20 +1,41 @@
-// RUN: %{build} -o %t.out
-// RUN: env SYCL_UR_TRACE=2 %{run} %t.out | FileCheck %s
+//==--------------------- DefaultContext.cpp -------------------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
 
-#include <sycl/detail/core.hpp>
-#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
+#include <gtest/gtest.h>
+#include <helpers/TestKernel.hpp>
+#include <helpers/UrMock.hpp>
+#include <sycl/sycl.hpp>
 
 // Check that the work group memory object is mapped to exactly one backend
 // kernel argument.
 
-int main() {
-  sycl::queue q;
-  q.submit([&](sycl::handler &cgh) {
-    sycl::ext::oneapi::experimental::work_group_memory<int[2]> data{cgh};
-    cgh.parallel_for(sycl::nd_range<1>{1, 1},
-                     [=](sycl::nd_item<1> it) { data[0] = 42; });
-  });
+namespace syclext = sycl::ext::oneapi::experimental;
+using arg_type = syclext::work_group_memory<int, syclext::empty_properties_t>;
+
+static int urKernelSetArgLocalCalls = 0;
+inline ur_result_t redefined_urKernelSetArgLocal(void *) {
+  ++urKernelSetArgLocalCalls;
+  return UR_RESULT_SUCCESS;
 }
 
-// CHECK-COUNT-1: ---> urKernelSetArg
-// CHECK-NOT: ---> urKernelSetArg
+TEST(URArgumentTest, URArgumentTest) {
+  sycl::unittest::UrMock<> Mock;
+  mock::getCallbacks().set_replace_callback("urKernelSetArgLocal",
+                                            &redefined_urKernelSetArgLocal);
+  sycl::platform Platform = sycl::platform();
+  const sycl::device dev = Platform.get_devices()[0];
+  sycl::queue q{dev};
+  syclext::submit(q, [&](sycl::handler &cgh) {
+    arg_type data{cgh};
+    const auto mykernel = [=](sycl::nd_item<1> it) { data = 42; };
+    syclext::nd_launch<TestKernel<sizeof(mykernel)>>(
+        cgh, sycl::nd_range<1>{1, 1}, mykernel);
+  });
+  q.wait();
+  ASSERT_EQ(urKernelSetArgLocalCalls, 1);
+}

From 3957cb54dbab01492d2240c9ea7138a509670fdd Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Sun, 13 Oct 2024 22:45:49 -0700
Subject: [PATCH 060/107] Address reviews

---
 .../sycl/ext/oneapi/experimental/work_group_memory.hpp       | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 01f642ab57481..7870ebd3ca73e 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -35,11 +35,8 @@ class work_group_memory_impl {
 
 } // namespace detail
 namespace ext::oneapi::experimental {
-#ifdef __SYCL_DEVICE_ONLY__
+
 template <typename DataT, typename PropertyListT = empty_properties_t>
-#else
-template <typename DataT, typename PropertyListT>
-#endif
 class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     : sycl::detail::work_group_memory_impl {
 public:

From 91820d8d320f05b143ec87c2c6c3dd03fa7400dc Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Sun, 13 Oct 2024 22:46:56 -0700
Subject: [PATCH 061/107] Address reviews

---
 clang/lib/Sema/SemaSYCL.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index f83f3ff94eaac..d8925669b1ae3 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -5776,7 +5776,7 @@ static const char *paramKind2Str(KernelParamKind K) {
     CASE(stream);
     CASE(specialization_constants_buffer);
     CASE(pointer);
-    CASE(work_group_mmeory);
+    CASE(work_group_memory);
   }
   return "<ERROR>";
 

From 34bc23d7063c982f2e59335caecc0bc23760bb14 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Mon, 14 Oct 2024 01:54:28 -0400
Subject: [PATCH 062/107] Update WorkGroupMemoryBackendArgument.cpp

---
 sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp b/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
index e6b4753b0f0cf..b29cee9e5347e 100644
--- a/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
+++ b/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
@@ -1,4 +1,4 @@
-//==--------------------- DefaultContext.cpp -------------------------------==//
+//==--------------------- WorkGroupMemoryBackensArgument.cpp --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.

From 3acf835d0f1fd28ac60b5a6144e1015563b4c0c6 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Mon, 14 Oct 2024 01:54:55 -0400
Subject: [PATCH 063/107] Update WorkGroupMemoryBackendArgument.cpp

---
 sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp b/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
index b29cee9e5347e..09ebc78969c2b 100644
--- a/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
+++ b/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
@@ -1,4 +1,4 @@
-//==--------------------- WorkGroupMemoryBackensArgument.cpp --------------===//
+//==--------------------- WorkGroupMemoryBackendArgument.cpp --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.

From 604c6407a283f871ad4770c1b787b808168f2cbf Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 15 Oct 2024 09:40:51 -0700
Subject: [PATCH 064/107] Fix unit test implementation for backend kernel
 argument

---
 .../WorkGroupMemoryBackendArgument.cpp        | 37 ++++++++++++++++---
 1 file changed, 31 insertions(+), 6 deletions(-)

diff --git a/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp b/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
index e6b4753b0f0cf..510d1e9190b2a 100644
--- a/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
+++ b/sycl/unittests/Extensions/WorkGroupMemoryBackendArgument.cpp
@@ -7,15 +7,40 @@
 //===----------------------------------------------------------------------===//
 
 #include <gtest/gtest.h>
-#include <helpers/TestKernel.hpp>
+#include <helpers/UrImage.hpp>
 #include <helpers/UrMock.hpp>
 #include <sycl/sycl.hpp>
 
 // Check that the work group memory object is mapped to exactly one backend
 // kernel argument.
-
+class WorkGroupMemoryKernel;
 namespace syclext = sycl::ext::oneapi::experimental;
-using arg_type = syclext::work_group_memory<int, syclext::empty_properties_t>;
+using arg_type = syclext::work_group_memory<int>;
+
+namespace sycl {
+inline namespace _V1 {
+namespace detail {
+template <> struct KernelInfo<WorkGroupMemoryKernel> {
+  static constexpr unsigned getNumParams() { return 1; }
+  static const detail::kernel_param_desc_t &getParamDesc(int) {
+    static detail::kernel_param_desc_t WorkGroupMemory = {
+        detail::kernel_param_kind_t::kind_work_group_memory, 0, 0};
+    return WorkGroupMemory;
+  }
+  static constexpr bool isESIMD() { return false; }
+  static constexpr bool callsThisItem() { return false; }
+  static constexpr bool callsAnyThisFreeFunction() { return false; }
+  static constexpr int64_t getKernelSize() { return sizeof(arg_type); }
+  static constexpr const char *getName() { return "WorkGroupMemoryKernel"; }
+};
+
+} // namespace detail
+} // namespace _V1
+} // namespace sycl
+
+static sycl::unittest::UrImage Img =
+    sycl::unittest::generateDefaultImage({"WorkGroupMemoryKernel"});
+static sycl::unittest::UrImageArray<1> ImgArray{&Img};
 
 static int urKernelSetArgLocalCalls = 0;
 inline ur_result_t redefined_urKernelSetArgLocal(void *) {
@@ -32,9 +57,9 @@ TEST(URArgumentTest, URArgumentTest) {
   sycl::queue q{dev};
   syclext::submit(q, [&](sycl::handler &cgh) {
     arg_type data{cgh};
-    const auto mykernel = [=](sycl::nd_item<1> it) { data = 42; };
-    syclext::nd_launch<TestKernel<sizeof(mykernel)>>(
-        cgh, sycl::nd_range<1>{1, 1}, mykernel);
+    const auto kernel = [=](sycl::nd_item<1> it) { data = 42; };
+    syclext::nd_launch<WorkGroupMemoryKernel>(cgh, sycl::nd_range<1>{1, 1},
+                                              kernel);
   });
   q.wait();
   ASSERT_EQ(urKernelSetArgLocalCalls, 1);

From e90a3b73fdb7946bbb48b751a1aeb655633009c4 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 15 Oct 2024 12:22:54 -0700
Subject: [PATCH 065/107] Add frontend tests

---
 clang/test/CodeGenSYCL/Inputs/sycl.hpp       | 18 ++++++++++++
 clang/test/CodeGenSYCL/work_group_memory.cpp | 30 ++++++++++++++++++++
 2 files changed, 48 insertions(+)
 create mode 100644 clang/test/CodeGenSYCL/work_group_memory.cpp

diff --git a/clang/test/CodeGenSYCL/Inputs/sycl.hpp b/clang/test/CodeGenSYCL/Inputs/sycl.hpp
index 63b304535302f..9fbf260b0c350 100644
--- a/clang/test/CodeGenSYCL/Inputs/sycl.hpp
+++ b/clang/test/CodeGenSYCL/Inputs/sycl.hpp
@@ -649,6 +649,24 @@ const stream& operator<<(const stream &S, T&&) {
   return S;
 }
 
+// Dummy implementation of work_group_memory for use in CodeGenSYCL tests.
+template <typename DataT>
+class __attribute__((sycl_special_class))
+__SYCL_TYPE(work_group_memory) work_group_memory {
+public:
+  work_group_memory(handler &CGH) {}
+#ifdef __SYCL_DEVICE_ONLY__
+  // Default constructor for objects later initialized with __init member.
+  work_group_memory() = default;
+#endif
+
+  void __init(__attribute((opencl_local)) DataT *Ptr) { this->Ptr = Ptr; }
+  __attribute((opencl_local)) DataT *operator&() const { return Ptr; }
+
+private:
+  __attribute((opencl_local)) DataT *Ptr;
+};
+
 template <typename T, int dimensions = 1,
           typename AllocatorT = int /*fake type as AllocatorT is not used*/>
 class buffer {
diff --git a/clang/test/CodeGenSYCL/work_group_memory.cpp b/clang/test/CodeGenSYCL/work_group_memory.cpp
new file mode 100644
index 0000000000000..04e6ea5cc14c1
--- /dev/null
+++ b/clang/test/CodeGenSYCL/work_group_memory.cpp
@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -fsycl-is-device -triple spir64-unknown-unknown -disable-llvm-passes -emit-llvm %s -o %t.ll
+// RUN: FileCheck < %t.ll %s --check-prefix CHECK-IR
+// RUN: %clang_cc1 -fsycl-is-device -triple spir64-unknown-unknown -fsycl-int-header=%t.h %s
+// RUN: FileCheck < %t.h %s --check-prefix CHECK-INT-HEADER
+//
+// CHECK-IR: define dso_local spir_kernel void @
+// CHECK-IR-SAME: ptr addrspace(3) noundef align 4 [[PTR:%[a-zA-Z0-9_]+]]
+//
+// CHECK-IR: [[PTR]].addr = alloca ptr addrspace(3), align 8
+// CHECK-IR: [[PTR]].addr.ascast = addrspacecast ptr %_arg_mem.addr to ptr addrspace(4)
+// CHECK-IR: store ptr addrspace(3) [[PTR]], ptr addrspace(4) [[PTR]].addr.ascast, align 8
+// CHECK-IR: [[PTR_LOAD:%[a-zA-Z0-9_]+]] = load ptr addrspace(3), ptr addrspace(4) [[PTR]].addr.ascast, align 8
+//
+// CHECK-IR: call spir_func void @{{.*}}__init{{.*}}(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) %{{[a-zA-Z0-9_]+}}, ptr addrspace(3) noundef [[PTR_LOAD]])
+//
+// CHECK-INT-HEADER: const kernel_param_desc_t kernel_signatures[] = {
+// CHECK-INT-HEADER-NEXT: //{{.*}}
+// CHECK-INT-HEADER-NEXT: { kernel_param_kind_t::kind_work_group_memory, 8, 0 },
+
+#include "Inputs/sycl.hpp"
+
+int main() {
+  sycl::queue Q;
+  Q.submit([&](sycl::handler &CGH) {
+    sycl::work_group_memory<int> mem;
+    sycl::range<1> ndr;
+    CGH.parallel_for(ndr, [=](sycl::item<1> it) { int *ptr = &mem; });
+  });
+  return 0;
+}

From b9ed6f4033d1b9d8a08054d3eb786133d4fc7e6e Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 15 Oct 2024 15:25:59 -0400
Subject: [PATCH 066/107] Update work_group_memory.cpp

---
 clang/test/CodeGenSYCL/work_group_memory.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clang/test/CodeGenSYCL/work_group_memory.cpp b/clang/test/CodeGenSYCL/work_group_memory.cpp
index 04e6ea5cc14c1..1770a49eb2644 100644
--- a/clang/test/CodeGenSYCL/work_group_memory.cpp
+++ b/clang/test/CodeGenSYCL/work_group_memory.cpp
@@ -7,7 +7,7 @@
 // CHECK-IR-SAME: ptr addrspace(3) noundef align 4 [[PTR:%[a-zA-Z0-9_]+]]
 //
 // CHECK-IR: [[PTR]].addr = alloca ptr addrspace(3), align 8
-// CHECK-IR: [[PTR]].addr.ascast = addrspacecast ptr %_arg_mem.addr to ptr addrspace(4)
+// CHECK-IR: [[PTR]].addr.ascast = addrspacecast ptr [[PTR]].addr to ptr addrspace(4)
 // CHECK-IR: store ptr addrspace(3) [[PTR]], ptr addrspace(4) [[PTR]].addr.ascast, align 8
 // CHECK-IR: [[PTR_LOAD:%[a-zA-Z0-9_]+]] = load ptr addrspace(3), ptr addrspace(4) [[PTR]].addr.ascast, align 8
 //

From af08c1916d31057d9b11040f7db4c144a22a34e7 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 15 Oct 2024 14:13:59 -0700
Subject: [PATCH 067/107] Fix segmentation fault

---
 sycl/include/sycl/handler.hpp | 12 +++++++-----
 sycl/source/handler.cpp       |  3 ++-
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 28d9d8dcc7be8..fd6f794eb34b0 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -163,7 +163,6 @@ class pipe;
 }
 
 namespace ext ::oneapi ::experimental {
-template <typename, typename> class work_group_memory;
 struct image_descriptor;
 } // namespace ext::oneapi::experimental
 
@@ -172,6 +171,7 @@ class graph_impl;
 } // namespace ext::oneapi::experimental::detail
 namespace detail {
 
+class work_group_memory_impl;
 class handler_impl;
 class kernel_impl;
 class queue_impl;
@@ -1875,10 +1875,11 @@ class __SYCL_EXPORT handler {
                                 ext::oneapi::experimental::empty_properties_t>
   void set_arg(
       int ArgIndex,
-      ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &Arg) {
+      detail::work_group_memory_impl &Arg) {
+    MWorkGroupMemoryObjects.push_back(
+        std::make_shared<detail::work_group_memory_impl>(Arg));
     addArg(detail::kernel_param_kind_t::kind_work_group_memory,
-           std::make_shared<std::remove_reference_t<decltype(Arg)>>(Arg).get(),
-           0, ArgIndex);
+           MWorkGroupMemoryObjects.back().get(), 0, ArgIndex);
   }
 
   // set_arg for graph dynamic_parameters
@@ -3242,9 +3243,10 @@ class __SYCL_EXPORT handler {
 private:
   std::shared_ptr<detail::handler_impl> impl;
   std::shared_ptr<detail::queue_impl> MQueue;
-
+  
   std::vector<detail::LocalAccessorImplPtr> MLocalAccStorage;
   std::vector<std::shared_ptr<detail::stream_impl>> MStreamStorage;
+  std::vector<std::shared_ptr<detail::work_group_memory_impl>> MWorkGroupMemoryObjects;
   detail::string MKernelName;
   /// Storage for a sycl::kernel object.
   std::shared_ptr<detail::kernel_impl> MKernel;
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index a60900e86e427..8061e01dd5559 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -797,7 +797,8 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
     break;
   }
   case kernel_param_kind_t::kind_work_group_memory: {
-    addArg(kernel_param_kind_t::kind_std_layout, nullptr, Size,
+    addArg(kernel_param_kind_t::kind_std_layout, nullptr,
+           static_cast<detail::work_group_memory_impl *>(Ptr)->buffer_size,
            Index + IndexShift);
     break;
   }

From 77a6de1a3a61ff08a66c5c6c719fa8fcb2327363 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 15 Oct 2024 19:14:58 -0700
Subject: [PATCH 068/107] Move implementation details away from handler to
 handler_impl

---
 sycl/include/sycl/handler.hpp       | 12 +-----------
 sycl/source/detail/handler_impl.hpp |  4 ++++
 sycl/source/handler.cpp             |  8 +++++++-
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index fd6f794eb34b0..cd2015f1a9fff 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -1871,16 +1871,7 @@ class __SYCL_EXPORT handler {
     setArgHelper(ArgIndex, std::move(Arg));
   }
 
-  template <typename DataT, typename PropertyListT =
-                                ext::oneapi::experimental::empty_properties_t>
-  void set_arg(
-      int ArgIndex,
-      detail::work_group_memory_impl &Arg) {
-    MWorkGroupMemoryObjects.push_back(
-        std::make_shared<detail::work_group_memory_impl>(Arg));
-    addArg(detail::kernel_param_kind_t::kind_work_group_memory,
-           MWorkGroupMemoryObjects.back().get(), 0, ArgIndex);
-  }
+  void set_arg(int ArgIndex, detail::work_group_memory_impl &Arg);
 
   // set_arg for graph dynamic_parameters
   template <typename T>
@@ -3246,7 +3237,6 @@ class __SYCL_EXPORT handler {
   
   std::vector<detail::LocalAccessorImplPtr> MLocalAccStorage;
   std::vector<std::shared_ptr<detail::stream_impl>> MStreamStorage;
-  std::vector<std::shared_ptr<detail::work_group_memory_impl>> MWorkGroupMemoryObjects;
   detail::string MKernelName;
   /// Storage for a sycl::kernel object.
   std::shared_ptr<detail::kernel_impl> MKernel;
diff --git a/sycl/source/detail/handler_impl.hpp b/sycl/source/detail/handler_impl.hpp
index b34c22ad2777e..42174c944d14e 100644
--- a/sycl/source/detail/handler_impl.hpp
+++ b/sycl/source/detail/handler_impl.hpp
@@ -13,6 +13,7 @@
 #include <detail/kernel_bundle_impl.hpp>
 #include <memory>
 #include <sycl/ext/oneapi/experimental/graph.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 
 namespace sycl {
 inline namespace _V1 {
@@ -197,6 +198,9 @@ class handler_impl {
 
   /// True if MCodeLoc is sycl entry point code location
   bool MIsTopCodeLoc = true;
+
+  /// List of work group memory objects associated with this handler
+  std::vector<std::shared_ptr<detail::work_group_memory_impl>> MWorkGroupMemoryObjects;
 };
 
 } // namespace detail
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index 8061e01dd5559..cee69025eaf0c 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -34,7 +34,6 @@
 #include <sycl/stream.hpp>
 
 #include <sycl/ext/oneapi/bindless_images_memory.hpp>
-#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 #include <sycl/ext/oneapi/memcpy2d.hpp>
 
 namespace sycl {
@@ -819,6 +818,13 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
   }
 }
 
+void handler::set_arg(int ArgIndex, detail::work_group_memory_impl &Arg) {
+  impl->MWorkGroupMemoryObjects.push_back(
+      std::make_shared<detail::work_group_memory_impl>(Arg));
+  addArg(detail::kernel_param_kind_t::kind_work_group_memory,
+         impl->MWorkGroupMemoryObjects.back().get(), 0, ArgIndex);
+}
+
 // The argument can take up more space to store additional information about
 // MAccessRange, MMemoryRange, and MOffset added with addArgsForGlobalAccessor.
 // We use the worst-case estimate because the lifetime of the vector is short.

From 3cb0ba401422e40aa8cbab1b7e9d3035b20fcba8 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 15 Oct 2024 20:17:52 -0700
Subject: [PATCH 069/107] Fix ABI breakage

---
 sycl/include/sycl/handler.hpp       | 12 +++++++++++-
 sycl/source/detail/handler_impl.hpp |  1 -
 sycl/source/handler.cpp             |  3 ++-
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index cd2015f1a9fff..f96d3c04093c4 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -163,6 +163,8 @@ class pipe;
 }
 
 namespace ext ::oneapi ::experimental {
+template <typename, typename>
+class work_group_memory;
 struct image_descriptor;
 } // namespace ext::oneapi::experimental
 
@@ -636,6 +638,8 @@ class __SYCL_EXPORT handler {
 #endif
   }
 
+  void setArgHelper(int ArgIndex, detail::work_group_memory_impl &Arg);
+
   // setArgHelper for non local accessor argument.
   template <typename DataT, int Dims, access::mode AccessMode,
             access::target AccessTarget, access::placeholder IsPlaceholder>
@@ -1871,7 +1875,13 @@ class __SYCL_EXPORT handler {
     setArgHelper(ArgIndex, std::move(Arg));
   }
 
-  void set_arg(int ArgIndex, detail::work_group_memory_impl &Arg);
+  template <typename DataT, typename PropertyListT =
+                                ext::oneapi::experimental::empty_properties_t>
+  void set_arg(
+      int ArgIndex,
+      ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &Arg) {
+    setArgHelper(ArgIndex, Arg);
+  }
 
   // set_arg for graph dynamic_parameters
   template <typename T>
diff --git a/sycl/source/detail/handler_impl.hpp b/sycl/source/detail/handler_impl.hpp
index 42174c944d14e..2c2a4963bed98 100644
--- a/sycl/source/detail/handler_impl.hpp
+++ b/sycl/source/detail/handler_impl.hpp
@@ -13,7 +13,6 @@
 #include <detail/kernel_bundle_impl.hpp>
 #include <memory>
 #include <sycl/ext/oneapi/experimental/graph.hpp>
-#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 
 namespace sycl {
 inline namespace _V1 {
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index cee69025eaf0c..61ea7ee7be0a0 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -34,6 +34,7 @@
 #include <sycl/stream.hpp>
 
 #include <sycl/ext/oneapi/bindless_images_memory.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
 #include <sycl/ext/oneapi/memcpy2d.hpp>
 
 namespace sycl {
@@ -818,7 +819,7 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
   }
 }
 
-void handler::set_arg(int ArgIndex, detail::work_group_memory_impl &Arg) {
+void handler::setArgHelper(int ArgIndex, detail::work_group_memory_impl &Arg) {
   impl->MWorkGroupMemoryObjects.push_back(
       std::make_shared<detail::work_group_memory_impl>(Arg));
   addArg(detail::kernel_param_kind_t::kind_work_group_memory,

From 1783f75ffed1f8ce25a59b82df53ad9ffc46a55b Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 15 Oct 2024 23:19:49 -0400
Subject: [PATCH 070/107] Update handler.hpp

---
 sycl/include/sycl/handler.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index f96d3c04093c4..fa26761115cb7 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -3244,7 +3244,6 @@ class __SYCL_EXPORT handler {
 private:
   std::shared_ptr<detail::handler_impl> impl;
   std::shared_ptr<detail::queue_impl> MQueue;
-  
   std::vector<detail::LocalAccessorImplPtr> MLocalAccStorage;
   std::vector<std::shared_ptr<detail::stream_impl>> MStreamStorage;
   detail::string MKernelName;

From 6affbc3355284f0d1d557350f68ba3234c202769 Mon Sep 17 00:00:00 2001
From: "Bushi, Lorenc" <lorenc.bushi@intel.com>
Date: Wed, 16 Oct 2024 06:33:39 +0200
Subject: [PATCH 071/107] Add missing symbols to dumps

---
 sycl/test/abi/sycl_symbols_linux.dump   | 1 +
 sycl/test/abi/sycl_symbols_windows.dump | 1 +
 2 files changed, 2 insertions(+)

diff --git a/sycl/test/abi/sycl_symbols_linux.dump b/sycl/test/abi/sycl_symbols_linux.dump
index 2d1dcce2b68e2..11d85801727c7 100644
--- a/sycl/test/abi/sycl_symbols_linux.dump
+++ b/sycl/test/abi/sycl_symbols_linux.dump
@@ -3478,6 +3478,7 @@ _ZN4sycl3_V17handler11saveCodeLocENS0_6detail13code_locationE
 _ZN4sycl3_V17handler11saveCodeLocENS0_6detail13code_locationEb
 _ZN4sycl3_V17handler11storeRawArgEPKvm
 _ZN4sycl3_V17handler12addReductionERKSt10shared_ptrIKvE
+_ZN4sycl3_V17handler12setArgHelperEiRNS0_6detail22work_group_memory_implE
 _ZN4sycl3_V17handler13getKernelNameEv
 _ZN4sycl3_V17handler14addAccessorReqESt10shared_ptrINS0_6detail16AccessorImplHostEE
 _ZN4sycl3_V17handler14setNDRangeUsedEb
diff --git a/sycl/test/abi/sycl_symbols_windows.dump b/sycl/test/abi/sycl_symbols_windows.dump
index 33092af8477f5..fa1f641ccd45a 100644
--- a/sycl/test/abi/sycl_symbols_windows.dump
+++ b/sycl/test/abi/sycl_symbols_windows.dump
@@ -3683,6 +3683,7 @@
 ?addLifetimeSharedPtrStorage@handler@_V1@sycl@@AEAAXV?$shared_ptr@$$CBX@std@@@Z
 ?addOrReplaceAccessorProperties@buffer_plain@detail@_V1@sycl@@IEAAXAEBVproperty_list@34@@Z
 ?addReduction@handler@_V1@sycl@@AEAAXAEBV?$shared_ptr@$$CBX@std@@@Z
+?setArgHelper@handler@_V1@sycl@@AEAAXHAEAVwork_group_memory_impl@detail@23@@Z
 ?addStream@handler@_V1@sycl@@AEAAXAEBV?$shared_ptr@Vstream_impl@detail@_V1@sycl@@@std@@@Z
 ?alignedAlloc@OSUtil@detail@_V1@sycl@@SAPEAX_K0@Z
 ?alignedFree@OSUtil@detail@_V1@sycl@@SAXPEAX@Z

From fd89473b99e7543aa1b9af20cc51b3fc5c25c99a Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 17 Oct 2024 06:24:39 -0700
Subject: [PATCH 072/107] Fix compilation errors from changes in handler.hpp in
 another commit

---
 sycl/include/sycl/handler.hpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index b0c9d62e904f7..fd41d60dd90a5 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -1646,7 +1646,7 @@ class __SYCL_EXPORT handler {
     kernel_single_task_wrapper<NameT, KernelType, PropertiesT>(KernelFunc);
 #ifndef __SYCL_DEVICE_ONLY__
     throwIfActionIsCreated();
-    throwOnLocalAccessorMisuse<KernelName, KernelType>();
+    throwOnKernelParameterMisuse<KernelName, KernelType>();
     verifyUsedKernelBundleInternal(
         detail::string_view{detail::getKernelName<NameT>()});
     // No need to check if range is out of INT_MAX limits as it's compile-time
@@ -3565,7 +3565,7 @@ class __SYCL_EXPORT handler {
   /// must not be used in a SYCL kernel function that is invoked via single_task
   /// or via the simple form of parallel_for that takes a range parameter.
   template <typename KernelName, typename KernelType>
-  void throwOnLocalAccessorMisuse() const {
+  void throwOnKernelParameterMisuse() const {
     using NameT =
         typename detail::get_kernel_name_t<KernelName, KernelType>::name;
     for (unsigned I = 0; I < detail::getKernelNumParams<NameT>(); ++I) {
@@ -3581,6 +3581,12 @@ class __SYCL_EXPORT handler {
             "A local accessor must not be used in a SYCL kernel function "
             "that is invoked via single_task or via the simple form of "
             "parallel_for that takes a range parameter.");
+      if (Kind == detail::kernel_param_kind_t::kind_work_group_memory)
+        throw sycl::exception(
+            make_error_code(errc::kernel_argument),
+            "A local accessor must not be used in a SYCL kernel function "
+            "that is invoked via single_task or via the simple form of "
+            "parallel_for that takes a range parameter.");
     }
   }
 

From 3f8ced8e98a30550854e6520f350cba6227a949a Mon Sep 17 00:00:00 2001
From: "lorenc.bushi" <lbushi@smtp.igk.intel.com>
Date: Fri, 18 Oct 2024 15:55:39 +0200
Subject: [PATCH 073/107] Add free function kernel support

---
 clang/lib/Sema/SemaSYCL.cpp                   | 125 +++++++++++++++---
 .../oneapi/experimental/work_group_memory.hpp |   3 +-
 sycl/include/sycl/handler.hpp                 |  11 +-
 sycl/source/handler.cpp                       |   4 +-
 4 files changed, 116 insertions(+), 27 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index d8925669b1ae3..d1c706ba9c529 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -1522,7 +1522,7 @@ class KernelObjVisitor {
   void visitParam(ParmVarDecl *Param, QualType ParamTy,
                   HandlerTys &...Handlers) {
     if (isSyclSpecialType(ParamTy, SemaSYCLRef))
-      KP_FOR_EACH(handleOtherType, Param, ParamTy);
+      KP_FOR_EACH(handleSyclSpecialType, Param, ParamTy);
     else if (ParamTy->isStructureOrClassType()) {
       if (KP_FOR_EACH(handleStructType, Param, ParamTy)) {
         CXXRecordDecl *RD = ParamTy->getAsCXXRecordDecl();
@@ -2070,8 +2070,10 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
   }
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
-    IsInvalid = true;
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
+      IsInvalid = false;
+    else
+      IsInvalid |= checkSyclSpecialType(ParamTy, PD->getLocation());
     return isValid();
   }
 
@@ -2223,8 +2225,10 @@ class SyclKernelUnionChecker : public SyclKernelFieldHandler {
   }
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
+      IsInvalid = false;
+    else
+      unsupportedFreeFunctionParamType(); // TODO
     return true;
   }
 
@@ -3008,9 +3012,26 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
     return handleSpecialType(FD, FieldTy);
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
+  bool handleSyclSpecialType(ParmVarDecl * PD, QualType ParamTy) final {
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
+      const auto *RecordDecl = ParamTy->getAsCXXRecordDecl();
+      assert(RecordDecl && "The type must be a RecordDecl");
+      CXXMethodDecl *InitMethod = getMethodByName(RecordDecl, InitMethodName);
+      assert(InitMethod && "The type must have the __init method");
+      // Don't do -1 here because we count on this to be the first parameter
+      // added (if any).
+      size_t ParamIndex = Params.size();
+      for (const ParmVarDecl *Param : InitMethod->parameters()) {
+        QualType ParamTy = Param->getType();
+        addParam(Param, ParamTy.getCanonicalType());
+        // Propagate add_ir_attributes_kernel_parameter attribute.
+        if (const auto *AddIRAttr =
+                Param->getAttr<SYCLAddIRAttributesKernelParameterAttr>())
+          Params.back()->addAttr(AddIRAttr->clone(SemaSYCLRef.getASTContext()));
+      }
+      LastParamIndex = ParamIndex;
+    } else // TODO
+      unsupportedFreeFunctionParamType();
     return true;
   }
 
@@ -3286,9 +3307,7 @@ class SyclKernelArgsSizeChecker : public SyclKernelFieldHandler {
   }
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
-    return true;
+    return handleSpecialType(ParamTy);
   }
 
   bool handleSyclSpecialType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
@@ -4416,6 +4435,45 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
                                 {});
   }
 
+  MemberExpr *buildMemberExpr(Expr *Base, ValueDecl *Member) {
+    DeclAccessPair MemberDAP = DeclAccessPair::make(Member, AS_none);
+    MemberExpr *Result = SemaSYCLRef.SemaRef.BuildMemberExpr(
+        Base, /*IsArrow */ false, FreeFunctionSrcLoc, NestedNameSpecifierLoc(),
+        FreeFunctionSrcLoc, Member, MemberDAP,
+        /*HadMultipleCandidates*/ false,
+        DeclarationNameInfo(Member->getDeclName(), FreeFunctionSrcLoc),
+        Member->getType(), VK_LValue, OK_Ordinary);
+    return Result;
+  }
+
+  void createSpecialMethodCall(const CXXRecordDecl *RD, StringRef MethodName,
+                               Expr *MemberBaseExpr,
+                               SmallVectorImpl<Stmt *> &AddTo) {
+    CXXMethodDecl *Method = getMethodByName(RD, MethodName);
+    if (!Method)
+      return;
+    unsigned NumParams = Method->getNumParams();
+    llvm::SmallVector<Expr *, 4> ParamDREs(NumParams);
+    llvm::ArrayRef<ParmVarDecl *> KernelParameters =
+        DeclCreator.getParamVarDeclsForCurrentField();
+    for (size_t I = 0; I < NumParams; ++I) {
+      QualType ParamType = KernelParameters[I]->getOriginalType();
+      ParamDREs[I] = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+          KernelParameters[I], ParamType, VK_LValue, FreeFunctionSrcLoc);
+    }
+    MemberExpr *MethodME = buildMemberExpr(MemberBaseExpr, Method);
+    QualType ResultTy = Method->getReturnType();
+    ExprValueKind VK = Expr::getValueKindForType(ResultTy);
+    ResultTy = ResultTy.getNonLValueExprType(SemaSYCLRef.getASTContext());
+    llvm::SmallVector<Expr *, 4> ParamStmts;
+    const auto *Proto = cast<FunctionProtoType>(Method->getType());
+    SemaSYCLRef.SemaRef.GatherArgumentsForCall(FreeFunctionSrcLoc, Method,
+                                               Proto, 0, ParamDREs, ParamStmts);
+    AddTo.push_back(CXXMemberCallExpr::Create(
+        SemaSYCLRef.getASTContext(), MethodME, ParamStmts, ResultTy, VK,
+        FreeFunctionSrcLoc, FPOptionsOverride()));
+  }
+
 public:
   static constexpr const bool VisitInsideSimpleContainers = false;
 
@@ -4435,9 +4493,37 @@ class FreeFunctionKernelBodyCreator : public SyclKernelFieldHandler {
     return true;
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
+  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
+      const auto *RecordDecl = ParamTy->getAsCXXRecordDecl();
+      QualType Ty = PD->getOriginalType();
+      ASTContext &Ctx = SemaSYCLRef.SemaRef.getASTContext();
+      VarDecl *WorkGroupMemoryClone = VarDecl::Create(
+          Ctx, DeclCreator.getKernelDecl(), FreeFunctionSrcLoc,
+          FreeFunctionSrcLoc, PD->getIdentifier(), PD->getType(),
+          Ctx.getTrivialTypeSourceInfo(Ty), SC_None);
+      InitializedEntity VarEntity =
+          InitializedEntity::InitializeVariable(WorkGroupMemoryClone);
+      InitializationKind InitKind =
+          InitializationKind::CreateDefault(FreeFunctionSrcLoc);
+      InitializationSequence InitSeq(SemaSYCLRef.SemaRef, VarEntity, InitKind,
+                                     std::nullopt);
+      ExprResult Init = InitSeq.Perform(SemaSYCLRef.SemaRef, VarEntity,
+                                        InitKind, std::nullopt);
+      WorkGroupMemoryClone->setInit(
+          SemaSYCLRef.SemaRef.MaybeCreateExprWithCleanups(Init.get()));
+      WorkGroupMemoryClone->setInitStyle(VarDecl::CallInit);
+      Stmt *DS = new (SemaSYCLRef.getASTContext())
+          DeclStmt(DeclGroupRef(WorkGroupMemoryClone), FreeFunctionSrcLoc,
+                   FreeFunctionSrcLoc);
+      BodyStmts.push_back(DS);
+      Expr *MemberBaseExpr = SemaSYCLRef.SemaRef.BuildDeclRefExpr(
+          WorkGroupMemoryClone, Ty, VK_PRValue, FreeFunctionSrcLoc);
+      createSpecialMethodCall(RecordDecl, InitMethodName, MemberBaseExpr,
+                              BodyStmts);
+      ArgExprs.push_back(MemberBaseExpr);
+    } else // TODO
+      unsupportedFreeFunctionParamType();
     return true;
   }
 
@@ -4717,9 +4803,11 @@ class SyclKernelIntHeaderCreator : public SyclKernelFieldHandler {
     return true;
   }
 
-  bool handleSyclSpecialType(ParmVarDecl *, QualType) final {
-    // TODO
-    unsupportedFreeFunctionParamType();
+  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
+    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
+      addParam(PD, ParamTy, SYCLIntegrationHeader::kind_work_group_memory);
+    else
+      unsupportedFreeFunctionParamType(); // TODO
     return true;
   }
 
@@ -6196,7 +6284,8 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
   O << "#include <sycl/detail/defines_elementary.hpp>\n";
   O << "#include <sycl/detail/kernel_desc.hpp>\n";
   O << "#include <sycl/ext/oneapi/experimental/free_function_traits.hpp>\n";
-
+  O << "#include <sycl/ext/oneapi/properties/properties.hpp>\n";
+  O << "#include <sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>\n";
   O << "\n";
 
   LangOptions LO;
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 7870ebd3ca73e..8ca68e22073a8 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>
 #include <type_traits>
 
 namespace sycl {
@@ -36,7 +37,7 @@ class work_group_memory_impl {
 } // namespace detail
 namespace ext::oneapi::experimental {
 
-template <typename DataT, typename PropertyListT = empty_properties_t>
+template <typename DataT, typename PropertyListT>
 class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     : sycl::detail::work_group_memory_impl {
 public:
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index fd41d60dd90a5..ba230bab9e8fb 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #pragma once
-
+#include <iostream>
 #include <sycl/access/access.hpp>
 #include <sycl/accessor.hpp>
 #include <sycl/context.hpp>
@@ -567,7 +567,7 @@ class __SYCL_EXPORT handler {
   // The version for regular(standard layout) argument.
   template <typename T, typename... Ts>
   void setArgsHelper(int ArgIndex, T &&Arg, Ts &&...Args) {
-    set_arg(ArgIndex, std::forward<T>(Arg));
+set_arg(ArgIndex, std::forward<T>(Arg));
     setArgsHelper(++ArgIndex, std::forward<Ts>(Args)...);
   }
 
@@ -606,7 +606,7 @@ class __SYCL_EXPORT handler {
 #endif
   }
 
-  void setArgHelper(int ArgIndex, detail::work_group_memory_impl &Arg);
+  void setWorkGroupMemoryArg(int ArgIndex, detail::work_group_memory_impl &Arg);
 
   // setArgHelper for non local accessor argument.
   template <typename DataT, int Dims, access::mode AccessMode,
@@ -626,7 +626,6 @@ class __SYCL_EXPORT handler {
 
   template <typename T> void setArgHelper(int ArgIndex, T &&Arg) {
     void *StoredArg = storePlainArg(Arg);
-
     if (!std::is_same<cl_mem, T>::value && std::is_pointer<T>::value) {
       addArg(detail::kernel_param_kind_t::kind_pointer, StoredArg, sizeof(T),
              ArgIndex);
@@ -1850,7 +1849,7 @@ class __SYCL_EXPORT handler {
   void set_arg(
       int ArgIndex,
       ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &Arg) {
-    setArgHelper(ArgIndex, Arg);
+    setWorkGroupMemoryArg(ArgIndex, Arg);
   }
 
   // set_arg for graph dynamic_parameters
@@ -1871,7 +1870,7 @@ class __SYCL_EXPORT handler {
   ///
   /// \param Args are argument values to be set.
   template <typename... Ts> void set_args(Ts &&...Args) {
-    setArgsHelper(0, std::forward<Ts>(Args)...);
+  setArgsHelper(0, std::forward<Ts>(Args)...);
   }
   /// Defines and invokes a SYCL kernel function as a function object type.
   ///
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index 61ea7ee7be0a0..bb237407b65a4 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -819,8 +819,8 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
   }
 }
 
-void handler::setArgHelper(int ArgIndex, detail::work_group_memory_impl &Arg) {
-  impl->MWorkGroupMemoryObjects.push_back(
+void handler::setWorkGroupMemoryArg(int ArgIndex, detail::work_group_memory_impl &Arg) {
+ impl->MWorkGroupMemoryObjects.push_back(
       std::make_shared<detail::work_group_memory_impl>(Arg));
   addArg(detail::kernel_param_kind_t::kind_work_group_memory,
          impl->MWorkGroupMemoryObjects.back().get(), 0, ArgIndex);

From 084eb7d24ca86f942f94c2d5291a1c5f515c55b2 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 22 Oct 2024 17:31:26 +0200
Subject: [PATCH 074/107] Refactor handler.hpp

---
 .../sycl/ext/oneapi/experimental/work_group_memory.hpp        | 2 +-
 sycl/include/sycl/handler.hpp                                 | 4 ++--
 sycl/source/handler.cpp                                       | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 8ca68e22073a8..da4a9c69079ff 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -39,7 +39,7 @@ namespace ext::oneapi::experimental {
 
 template <typename DataT, typename PropertyListT>
 class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
-    : sycl::detail::work_group_memory_impl {
+    : public sycl::detail::work_group_memory_impl {
 public:
   using value_type = std::remove_all_extents_t<DataT>;
 
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index ba230bab9e8fb..e64e9c43d0127 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -606,7 +606,7 @@ set_arg(ArgIndex, std::forward<T>(Arg));
 #endif
   }
 
-  void setWorkGroupMemoryArg(int ArgIndex, detail::work_group_memory_impl &Arg);
+  void setArgHelper(int ArgIndex, detail::work_group_memory_impl &Arg);
 
   // setArgHelper for non local accessor argument.
   template <typename DataT, int Dims, access::mode AccessMode,
@@ -1849,7 +1849,7 @@ set_arg(ArgIndex, std::forward<T>(Arg));
   void set_arg(
       int ArgIndex,
       ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &Arg) {
-    setWorkGroupMemoryArg(ArgIndex, Arg);
+    setArgHelper(ArgIndex, static_cast<detail::work_group_memory_impl&>(Arg));
   }
 
   // set_arg for graph dynamic_parameters
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index bb237407b65a4..ba53b3983d0e4 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -819,7 +819,7 @@ void handler::processArg(void *Ptr, const detail::kernel_param_kind_t &Kind,
   }
 }
 
-void handler::setWorkGroupMemoryArg(int ArgIndex, detail::work_group_memory_impl &Arg) {
+void handler::setArgHelper(int ArgIndex, detail::work_group_memory_impl &Arg) {
  impl->MWorkGroupMemoryObjects.push_back(
       std::make_shared<detail::work_group_memory_impl>(Arg));
   addArg(detail::kernel_param_kind_t::kind_work_group_memory,

From 06a3c37a31c22f54906434186739ee5ce77febc7 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 16:42:47 +0200
Subject: [PATCH 075/107] Polish free function kernel implementation and
 improve test

---
 sycl/include/sycl/handler.hpp                 |  4 +-
 .../WorkGroupMemory/free_function_kernel.cpp  | 80 +++++++++++++++++++
 2 files changed, 83 insertions(+), 1 deletion(-)
 create mode 100644 sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index e64e9c43d0127..a1c05c75aadff 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -1849,7 +1849,9 @@ set_arg(ArgIndex, std::forward<T>(Arg));
   void set_arg(
       int ArgIndex,
       ext::oneapi::experimental::work_group_memory<DataT, PropertyListT> &Arg) {
-    setArgHelper(ArgIndex, static_cast<detail::work_group_memory_impl&>(Arg));
+    // slice the base class object out of Arg
+    detail::work_group_memory_impl &ArgImpl = Arg;
+    setArgHelper(ArgIndex, ArgImpl);
   }
 
   // set_arg for graph dynamic_parameters
diff --git a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
new file mode 100644
index 0000000000000..01a026c98f170
--- /dev/null
+++ b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
@@ -0,0 +1,80 @@
+#include <cassert>
+#include <sycl/detail/core.hpp>
+#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
+#include <sycl/ext/oneapi/free_function_queries.hpp>
+#include <sycl/group_barrier.hpp>
+#include <sycl/usm.hpp>
+
+using namespace sycl;
+
+constexpr size_t SIZE = 1024;
+size_t WGSIZE = SIZE;
+queue q;
+context ctx = q.get_context();
+
+int sum_helper(
+    sycl::ext::oneapi::experimental::work_group_memory<int[WGSIZE]> mem) {
+  int ret = 0;
+  for (int i = 0; i < WGSIZE; ++i) {
+    ret += mem[i];
+  }
+  return ret;
+}
+
+template <bool UseHelper>
+SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
+    (ext::oneapi::experimental::nd_range_kernel<1>))
+void sum(sycl::ext::oneapi::experimental::work_group_memory<int[WGSIZE]> mem,
+         int *buf, int *Result) {
+  const auto it = sycl::ext::oneapi::this_work_item::get_nd_item<1>();
+  size_t local_id = it.get_local_id();
+  mem[local_id] = buf[local_id];
+  group_barrier(it.get_group());
+  if (it.get_group().leader()) {
+    if constexpr (UseHelper) {
+      for (int i = 0; i < WGSIZE; ++i) {
+        *Result += mem[i];
+      }
+    } else {
+      *Result = sum_helper(mem);
+    }
+  }
+}
+
+template <bool UseHelper> void test() {
+  int *buf = malloc_shared<int>(WGSIZE, q);
+  assert(buf && "Shared allocation failed!");
+  int expected = 0;
+  for (int i = 0; i < WGSIZE; ++i) {
+    buf[i] = i + (int)UseHelper;
+    expected += buf[i];
+  }
+  int *result = malloc_shared<int>(1, q);
+  assert(result && "Shared allocation failed!");
+#ifndef __SYCL_DEVICE_ONLY__
+  // Get the kernel object for the "mykernel" kernel.
+  auto Bundle = get_kernel_bundle<sycl::bundle_state::executable>(ctx);
+  kernel_id sum_id = ext::oneapi::experimental::get_kernel_id<sum<UseHelper>>();
+  kernel k_sum = Bundle.get_kernel(sum_id);
+  q.submit([&](sycl::handler &cgh) {
+     ext::oneapi::experimental::work_group_memory<int[WGSIZE]> mem{cgh};
+     cgh.set_args(mem, buf, result);
+     nd_range ndr{{SIZE}, {WGSIZE}};
+     cgh.parallel_for(ndr, k_sum);
+   }).wait();
+#endif
+  assert(expected == *result);
+  free(buf, q);
+  free(result, q);
+}
+
+int main() {
+  test<true /* UseHelper */>();
+  test<false /* UseHelper */>();
+  // Test with more than one work group
+  WGSIZE = SIZE / 2;
+  test<false>();
+  WGSIZE = SIZE / 4;
+  test<false>();
+  return 0;
+}

From d96f2e1295066eb121fc27d8d322e4546c6a3280 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 19:59:38 +0200
Subject: [PATCH 076/107] Complete free function kernel support and add
 frontend tests

---
 .../CodeGenSYCL/free_function_int_header.cpp  | 40 ++++++++++++++++++-
 .../free_function_kernel_params.cpp           | 17 +++++++-
 clang/test/SemaSYCL/Inputs/sycl.hpp           | 17 ++++++++
 .../SemaSYCL/free_function_kernel_params.cpp  | 22 +++++++++-
 .../WorkGroupMemory/free_function_kernel.cpp  | 39 +++++++++---------
 5 files changed, 111 insertions(+), 24 deletions(-)

diff --git a/clang/test/CodeGenSYCL/free_function_int_header.cpp b/clang/test/CodeGenSYCL/free_function_int_header.cpp
index ccaf85aa897ca..6a196dedc2fc2 100644
--- a/clang/test/CodeGenSYCL/free_function_int_header.cpp
+++ b/clang/test/CodeGenSYCL/free_function_int_header.cpp
@@ -2,7 +2,7 @@
 // RUN: FileCheck -input-file=%t.h %s
 // 
 // This test checks integration header contents for free functions with scalar,
-// pointer and non-decomposed struct parameters.
+// pointer, non-decomposed struct parameters and work group memory parameters.
 
 #include "mock_properties.hpp"
 #include "sycl.hpp"
@@ -96,6 +96,12 @@ void ff_7(KArgWithPtrArray<ArrSize> KArg) {
 
 template void ff_7(KArgWithPtrArray<TestArrSize> KArg);
 
+__attribute__((sycl_device))
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 0)]] 
+void ff_8(sycl::work_group_memory<int>) {
+}
+
+
 // CHECK:      const char* const kernel_names[] = {
 // CHECK-NEXT:   {{.*}}__sycl_kernel_ff_2Piii
 // CHECK-NEXT:   {{.*}}__sycl_kernel_ff_2Piiii
@@ -105,6 +111,7 @@ template void ff_7(KArgWithPtrArray<TestArrSize> KArg);
 // CHECK-NEXT:   {{.*}}__sycl_kernel_ff_410NoPointers8Pointers3Agg
 // CHECK-NEXT:   {{.*}}__sycl_kernel_ff_6I3Agg7DerivedEvT_T0_i
 // CHECK-NEXT:   {{.*}}__sycl_kernel_ff_7ILi3EEv16KArgWithPtrArrayIXT_EE
+// CHECK-NEXT:   {{.*}}__sycl_kernel_ff_8N4sycl3_V117work_group_memoryIiEE
 // CHECK-NEXT:   ""
 // CHECK-NEXT: };
 
@@ -148,6 +155,9 @@ template void ff_7(KArgWithPtrArray<TestArrSize> KArg);
 // CHECK:  //--- _Z18__sycl_kernel_ff_7ILi3EEv16KArgWithPtrArrayIXT_EE
 // CHECK-NEXT:  { kernel_param_kind_t::kind_std_layout, 48, 0 },
 
+// CHECK:  //--- _Z18__sycl_kernel_ff_8N4sycl3_V117work_group_memoryIiEE
+// CHECK-NEXT:  { kernel_param_kind_t::kind_work_group_memory, 8, 0 },
+
 // CHECK:        { kernel_param_kind_t::kind_invalid, -987654321, -987654321 },
 // CHECK-NEXT: };
 
@@ -294,6 +304,26 @@ template void ff_7(KArgWithPtrArray<TestArrSize> KArg);
 // CHECK-NEXT: };
 // CHECK-NEXT: }
 
+// CHECK: Definition of _Z18__sycl_kernel_ff_8N4sycl3_V117work_group_memoryIiEE as a free function kernel
+
+// CHECK: Forward declarations of kernel and its argument types:
+// CHECK: template <typename DataT> class work_group_memory;
+
+// CHECK: void ff_8(sycl::work_group_memory<int>);
+// CHECK-NEXT: static constexpr auto __sycl_shim9() {
+// CHECK-NEXT: return (void (*)(class sycl::work_group_memory<int>))ff_8;
+// CHECK-NEXT: }
+// CHECK-NEXT: namespace sycl {
+// CHECK-NEXT: template <>
+// CHECK-NEXT: struct ext::oneapi::experimental::is_kernel<__sycl_shim9()> {
+// CHECK-NEXT: static constexpr bool value = true;
+// CHECK-NEXT: };
+// CHECK-NEXT: template <>
+// CHECK-NEXT: struct ext::oneapi::experimental::is_single_task_kernel<__sycl_shim9()> {
+// CHECK-NEXT: static constexpr bool value = true;
+// CHECK-NEXT: };
+// CHECK-NEXT: }
+
 // CHECK: #include <sycl/kernel_bundle.hpp>
 
 // CHECK: Definition of kernel_id of _Z18__sycl_kernel_ff_2Piii
@@ -359,3 +389,11 @@ template void ff_7(KArgWithPtrArray<TestArrSize> KArg);
 // CHECK-NEXT:   return sycl::detail::get_kernel_id_impl(std::string_view{"_Z18__sycl_kernel_ff_7ILi3EEv16KArgWithPtrArrayIXT_EE"});
 // CHECK-NEXT: }
 // CHECK-NEXT: }
+
+// CHECK: Definition of kernel_id of _Z18__sycl_kernel_ff_8N4sycl3_V117work_group_memoryIiEE
+// CHECK-NEXT: namespace sycl {
+// CHECK-NEXT: template <>
+// CHECK-NEXT: kernel_id ext::oneapi::experimental::get_kernel_id<__sycl_shim9()>() {
+// CHECK-NEXT: return sycl::detail::get_kernel_id_impl(std::string_view{"_Z18__sycl_kernel_ff_8N4sycl3_V117work_group_memoryIiEE"});
+// CHECK-NEXT: }
+// CHECK-NEXT: }
diff --git a/clang/test/CodeGenSYCL/free_function_kernel_params.cpp b/clang/test/CodeGenSYCL/free_function_kernel_params.cpp
index a11d55f483966..2e78116824ad2 100644
--- a/clang/test/CodeGenSYCL/free_function_kernel_params.cpp
+++ b/clang/test/CodeGenSYCL/free_function_kernel_params.cpp
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -internal-isystem %S/Inputs -fsycl-is-device -triple spir64 \
 // RUN: -emit-llvm %s -o - | FileCheck %s
 // This test checks parameter IR generation for free functions with parameters
-// of non-decomposed struct type.
+// of non-decomposed struct type and work group memory type.
 
 #include "sycl.hpp"
 
@@ -56,3 +56,18 @@ template void ff_6(KArgWithPtrArray<TestArrSize> KArg);
 // CHECK: %struct.KArgWithPtrArray = type { [3 x ptr addrspace(4)], [3 x i32], [3 x i32] }
 // CHECK: define dso_local spir_kernel void @{{.*}}__sycl_kernel{{.*}}(ptr noundef byval(%struct.NoPointers) align 4 %__arg_S1, ptr noundef byval(%struct.__generated_Pointers) align 8 %__arg_S2, ptr noundef byval(%struct.__generated_Agg) align 8 %__arg_S3)
 // CHECK: define dso_local spir_kernel void @{{.*}}__sycl_kernel_ff_6{{.*}}(ptr noundef byval(%struct.__generated_KArgWithPtrArray) align 8 %__arg_KArg)
+
+__attribute__((sycl_device))
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 0)]]
+void ff_7(sycl::work_group_memory<int> mem) {
+}
+
+// CHECK:  define dso_local spir_kernel void @{{.*}}__sycl_kernel_ff_7{{.*}}(ptr addrspace(3) noundef align 4 %__arg_Ptr)
+// CHECK:  %__arg_Ptr.addr = alloca ptr addrspace(3), align 8
+// CHECK-NEXT:  %mem = alloca %"class.sycl::_V1::work_group_memory", align 8
+// CHECK:  %__arg_Ptr.addr.ascast = addrspacecast ptr %__arg_Ptr.addr to ptr addrspace(4)
+// CHECK-NEXT:  %mem.ascast = addrspacecast ptr %mem to ptr addrspace(4)
+// CHECK:  store ptr addrspace(3) %__arg_Ptr, ptr addrspace(4) %__arg_Ptr.addr.ascast, align 8
+// CHECK-NEXT:  [[REGISTER:%[a-zA-Z0-9_]+]] = load ptr addrspace(3), ptr addrspace(4) %__arg_Ptr.addr.ascast, align 8
+// CHECK-NEXT:  call spir_func void @{{.*}}work_group_memory{{.*}}__init{{.*}}(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) %mem.ascast, ptr addrspace(3) noundef [[REGISTER]])
+
diff --git a/clang/test/SemaSYCL/Inputs/sycl.hpp b/clang/test/SemaSYCL/Inputs/sycl.hpp
index 337320764de2f..206c12eccf8c3 100644
--- a/clang/test/SemaSYCL/Inputs/sycl.hpp
+++ b/clang/test/SemaSYCL/Inputs/sycl.hpp
@@ -448,6 +448,23 @@ class __SYCL_TYPE(multi_ptr) multi_ptr<T, AS, access::decorated::legacy> {
   pointer_t m_Pointer;
 };
 
+// Dummy implementation of work_group_memory for use in SemaSYCL tests.
+template <typename DataT>
+class __attribute__((sycl_special_class))
+__SYCL_TYPE(work_group_memory) work_group_memory {
+public:
+  work_group_memory(handler &CGH) {}
+#ifdef __SYCL_DEVICE_ONLY__
+  // Default constructor for objects later initialized with __init member.
+  work_group_memory() = default;
+#endif
+
+  void __init(__attribute((opencl_local)) DataT *Ptr) { this->Ptr = Ptr; }
+
+private:
+  __attribute((opencl_local)) DataT *Ptr;
+};
+
 namespace ext {
 namespace oneapi {
 namespace experimental {
diff --git a/clang/test/SemaSYCL/free_function_kernel_params.cpp b/clang/test/SemaSYCL/free_function_kernel_params.cpp
index 2de4f896a1513..da229145a34ad 100644
--- a/clang/test/SemaSYCL/free_function_kernel_params.cpp
+++ b/clang/test/SemaSYCL/free_function_kernel_params.cpp
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -internal-isystem %S/Inputs -fsycl-is-device -ast-dump \
 // RUN: %s -o - | FileCheck %s
 // This test checks parameter rewriting for free functions with parameters
-// of type scalar, pointer and non-decomposed struct.
+// of type scalar, pointer, non-decomposed struct and work group memory.
 
 #include "sycl.hpp"
 
@@ -171,3 +171,23 @@ template void ff_6(Agg S1, Derived1 S2, int);
 // CHECK-NEXT: DeclRefExpr {{.*}} '__generated_Derived1' lvalue ParmVar {{.*}} '__arg_S2' '__generated_Derived1'
 // CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
 // CHECK-NEXT: DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} '__arg_end' 'int'
+
+__attribute__((sycl_device))
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 0)]]
+void ff_7(sycl::work_group_memory<int> mem) {
+}
+// CHECK: FunctionDecl {{.*}}__sycl_kernel{{.*}}'void (__local int *)'
+// CHECK-NEXT: ParmVarDecl {{.*}} used __arg_Ptr '__local int *'
+// CHECK-NEXT: CompoundStmt
+// CHECK-NEXT: DeclStmt
+// CHECK-NEXT: VarDecl {{.*}} used mem 'sycl::work_group_memory<int>' callinit
+// CHECK-NEXT: CXXConstructExpr {{.*}} 'sycl::work_group_memory<int>' 'void () noexcept'
+// CHECK-NEXT: CXXMemberCallExpr {{.*}} 'void'
+// CHECK-NEXT: MemberExpr {{.*}} 'void (__local int *)' lvalue .__init
+// CHECK-NEXT: DeclRefExpr {{.*}} 'sycl::work_group_memory<int>' Var {{.*}} 'mem' 'sycl::work_group_memory<int>'
+// CHECK-NEXT: ImplicitCastExpr {{.*}} '__local int *' <LValueToRValue>
+// CHECK-NEXT: DeclRefExpr {{.*}} '__local int *' lvalue ParmVar {{.*}} '__arg_Ptr' '__local int *'
+// CHECK-NEXT: CallExpr {{.*}} 'void'
+// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void (*)(sycl::work_group_memory<int>)' <FunctionToPointerDecay>
+// CHECK-NEXT: DeclRefExpr {{.*}} 'void (sycl::work_group_memory<int>)' lvalue Function {{.*}} 'ff_7' 'void (sycl::work_group_memory<int>)'
+// CHECK-NEXT: DeclRefExpr {{.*}} 'sycl::work_group_memory<int>' Var {{.*}} 'mem' 'sycl::work_group_memory<int>'
diff --git a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
index 01a026c98f170..42f36f9f89b6a 100644
--- a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
@@ -7,13 +7,11 @@
 
 using namespace sycl;
 
-constexpr size_t SIZE = 1024;
-size_t WGSIZE = SIZE;
 queue q;
 context ctx = q.get_context();
 
 int sum_helper(
-    sycl::ext::oneapi::experimental::work_group_memory<int[WGSIZE]> mem) {
+    sycl::ext::oneapi::experimental::work_group_memory<int[]> mem, size_t WGSIZE) {
   int ret = 0;
   for (int i = 0; i < WGSIZE; ++i) {
     ret += mem[i];
@@ -21,44 +19,44 @@ int sum_helper(
   return ret;
 }
 
-template <bool UseHelper>
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
     (ext::oneapi::experimental::nd_range_kernel<1>))
-void sum(sycl::ext::oneapi::experimental::work_group_memory<int[WGSIZE]> mem,
-         int *buf, int *Result) {
+void sum(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
+         int *buf, int *Result, size_t WGSIZE, bool UseHelper) {
   const auto it = sycl::ext::oneapi::this_work_item::get_nd_item<1>();
   size_t local_id = it.get_local_id();
   mem[local_id] = buf[local_id];
   group_barrier(it.get_group());
   if (it.get_group().leader()) {
-    if constexpr (UseHelper) {
+    if (!UseHelper) {
       for (int i = 0; i < WGSIZE; ++i) {
         *Result += mem[i];
       }
     } else {
-      *Result = sum_helper(mem);
+      *Result = sum_helper(mem, WGSIZE);
     }
   }
 }
 
-template <bool UseHelper> void test() {
+void test(size_t SIZE, size_t WGSIZE, bool UseHelper) {
   int *buf = malloc_shared<int>(WGSIZE, q);
-  assert(buf && "Shared allocation failed!");
+  assert(buf && "Shared USM allocation failed!");
   int expected = 0;
   for (int i = 0; i < WGSIZE; ++i) {
-    buf[i] = i + (int)UseHelper;
+    buf[i] = i;
     expected += buf[i];
   }
   int *result = malloc_shared<int>(1, q);
-  assert(result && "Shared allocation failed!");
+  assert(result && "Shared USM allocation failed!");
 #ifndef __SYCL_DEVICE_ONLY__
   // Get the kernel object for the "mykernel" kernel.
   auto Bundle = get_kernel_bundle<sycl::bundle_state::executable>(ctx);
-  kernel_id sum_id = ext::oneapi::experimental::get_kernel_id<sum<UseHelper>>();
+  kernel_id sum_id =
+      ext::oneapi::experimental::get_kernel_id<sum>();
   kernel k_sum = Bundle.get_kernel(sum_id);
   q.submit([&](sycl::handler &cgh) {
-     ext::oneapi::experimental::work_group_memory<int[WGSIZE]> mem{cgh};
-     cgh.set_args(mem, buf, result);
+     ext::oneapi::experimental::work_group_memory<int[]> mem{WGSIZE, cgh};
+     cgh.set_args(mem, buf, result, WGSIZE, UseHelper);
      nd_range ndr{{SIZE}, {WGSIZE}};
      cgh.parallel_for(ndr, k_sum);
    }).wait();
@@ -69,12 +67,11 @@ template <bool UseHelper> void test() {
 }
 
 int main() {
-  test<true /* UseHelper */>();
-  test<false /* UseHelper */>();
+  constexpr size_t SIZE = 1024;
+  test(SIZE, SIZE, true /* UseHelper */);
+  test(SIZE, SIZE, false);
   // Test with more than one work group
-  WGSIZE = SIZE / 2;
-  test<false>();
-  WGSIZE = SIZE / 4;
-  test<false>();
+  test(SIZE, SIZE / 2, false);
+  test(SIZE, SIZE / 4, false);
   return 0;
 }

From a2b44a2fb9eb8b6dcb2b75297d3d3d923cbc6f51 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 20:01:15 +0200
Subject: [PATCH 077/107] Formatting changes

---
 .../test-e2e/WorkGroupMemory/free_function_kernel.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
index 42f36f9f89b6a..0e90861c40d43 100644
--- a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
@@ -1,3 +1,7 @@
+// REQUIRES: aspect-usm_shared_allocations
+// RUN: %{build} -o %t.out
+// RUN: %{run} %t.out
+
 #include <cassert>
 #include <sycl/detail/core.hpp>
 #include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
@@ -10,8 +14,8 @@ using namespace sycl;
 queue q;
 context ctx = q.get_context();
 
-int sum_helper(
-    sycl::ext::oneapi::experimental::work_group_memory<int[]> mem, size_t WGSIZE) {
+int sum_helper(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
+               size_t WGSIZE) {
   int ret = 0;
   for (int i = 0; i < WGSIZE; ++i) {
     ret += mem[i];
@@ -51,8 +55,7 @@ void test(size_t SIZE, size_t WGSIZE, bool UseHelper) {
 #ifndef __SYCL_DEVICE_ONLY__
   // Get the kernel object for the "mykernel" kernel.
   auto Bundle = get_kernel_bundle<sycl::bundle_state::executable>(ctx);
-  kernel_id sum_id =
-      ext::oneapi::experimental::get_kernel_id<sum>();
+  kernel_id sum_id = ext::oneapi::experimental::get_kernel_id<sum>();
   kernel k_sum = Bundle.get_kernel(sum_id);
   q.submit([&](sycl::handler &cgh) {
      ext::oneapi::experimental::work_group_memory<int[]> mem{WGSIZE, cgh};

From 494870af880fce23ea9cc0dac6f5b5b6bdf8592a Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 20:05:17 +0200
Subject: [PATCH 078/107] Fix bug in tests

---
 sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
index 0e90861c40d43..667049a113cfa 100644
--- a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
@@ -32,6 +32,7 @@ void sum(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
   mem[local_id] = buf[local_id];
   group_barrier(it.get_group());
   if (it.get_group().leader()) {
+    *Result = 0;
     if (!UseHelper) {
       for (int i = 0; i < WGSIZE; ++i) {
         *Result += mem[i];

From 4be6df079d5063fed10a2fcbda09af2585fc0e92 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 21:07:53 +0200
Subject: [PATCH 079/107] Improve test and add comments

---
 clang/lib/Sema/SemaSYCL.cpp                          |  8 +++++++-
 sycl/include/sycl/handler.hpp                        |  1 -
 .../WorkGroupMemory/free_function_kernel.cpp         | 12 +++++++-----
 3 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index d1c706ba9c529..a4dd893cb80fb 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -6284,7 +6284,13 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
   O << "#include <sycl/detail/defines_elementary.hpp>\n";
   O << "#include <sycl/detail/kernel_desc.hpp>\n";
   O << "#include <sycl/ext/oneapi/experimental/free_function_traits.hpp>\n";
-  O << "#include <sycl/ext/oneapi/properties/properties.hpp>\n";
+  // When using work group memory parameters in free kernel functions, the
+  // integration header emits incorrect forward declarations for the work group
+  // memory type because it ignores default arguments. This means the user
+  // cannot use work group memory types with parameters omitted such as
+  // work_group_memory<int> where the hidden second parameter has a default
+  // value. To circumvent this, we include the correct forward declaration
+  // ourselves.
   O << "#include <sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>\n";
   O << "\n";
 
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index a891a52b0ae53..5031ca3e204d2 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #pragma once
-#include <iostream>
 #include <sycl/access/access.hpp>
 #include <sycl/accessor.hpp>
 #include <sycl/context.hpp>
diff --git a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
index 667049a113cfa..3c9a809b6e5ec 100644
--- a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
@@ -14,13 +14,13 @@ using namespace sycl;
 queue q;
 context ctx = q.get_context();
 
-int sum_helper(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
-               size_t WGSIZE) {
-  int ret = 0;
+void sum_helper(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
+                sycl::ext::oneapi::experimental::work_group_memory<int> ret,
+                size_t WGSIZE) {
+  ret = 0;
   for (int i = 0; i < WGSIZE; ++i) {
     ret += mem[i];
   }
-  return ret;
 }
 
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
@@ -38,7 +38,9 @@ void sum(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
         *Result += mem[i];
       }
     } else {
-      *Result = sum_helper(mem, WGSIZE);
+      sycl::ext::oneapi::experimental::work_group_memory<int> ret;
+      sum_helper(mem, ret, WGSIZE);
+      *Result = ret;
     }
   }
 }

From 42edb229c9db24a2b2ba5b8bd7dd644a58c22db9 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 21:11:07 +0200
Subject: [PATCH 080/107] Formatting changes

---
 clang/lib/Sema/SemaSYCL.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index a4dd893cb80fb..33849c8c7ad40 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -2072,8 +2072,11 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
     if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
       IsInvalid = false;
-    else
-      IsInvalid |= checkSyclSpecialType(ParamTy, PD->getLocation());
+    else {
+      Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
+          << ParamTy;
+      IsInvalid = true;
+    }
     return isValid();
   }
 

From 6bc951efb05af5cfdb73dc8ee0d0cb3e61c944ff Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 21:24:14 +0200
Subject: [PATCH 081/107] Formatting changes

---
 clang/lib/Sema/SemaSYCL.cpp | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index 33849c8c7ad40..9c3f40c0a5ec6 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -2070,9 +2070,7 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
   }
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
-      IsInvalid = false;
-    else {
+    if (!SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
       Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type)
           << ParamTy;
       IsInvalid = true;
@@ -2081,9 +2079,9 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
   }
 
   bool handleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    IsInvalid |= checkNotCopyableToKernel(FD, FieldTy);
-    return isValid();
-  }
+  IsInvalid |= checkNotCopyableToKernel(FD, FieldTy);
+  return isValid();
+}
 
   bool handleArrayType(ParmVarDecl *PD, QualType ParamTy) final {
     Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;
@@ -2228,9 +2226,7 @@ class SyclKernelUnionChecker : public SyclKernelFieldHandler {
   }
 
   bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
-    if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
-      IsInvalid = false;
-    else
+    if (!SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory))
       unsupportedFreeFunctionParamType(); // TODO
     return true;
   }
@@ -3015,7 +3011,7 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
     return handleSpecialType(FD, FieldTy);
   }
 
-  bool handleSyclSpecialType(ParmVarDecl * PD, QualType ParamTy) final {
+  bool handleSyclSpecialType(ParmVarDecl *PD, QualType ParamTy) final {
     if (SemaSYCL::isSyclType(ParamTy, SYCLTypeAttr::work_group_memory)) {
       const auto *RecordDecl = ParamTy->getAsCXXRecordDecl();
       assert(RecordDecl && "The type must be a RecordDecl");
@@ -6294,7 +6290,8 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
   // work_group_memory<int> where the hidden second parameter has a default
   // value. To circumvent this, we include the correct forward declaration
   // ourselves.
-  O << "#include <sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>\n";
+  O << "#include "
+       "<sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>\n";
   O << "\n";
 
   LangOptions LO;

From 5a91bfa1f17a8f8d1c1d06b571a2ca77fb180ab3 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 21:29:33 +0200
Subject: [PATCH 082/107] Add missing file

---
 .../work_group_memory_forward_decl.hpp             | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
new file mode 100644
index 0000000000000..5f3533caccd99
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
@@ -0,0 +1,14 @@
+#pragma once
+#include <sycl/ext/oneapi/properties/properties.hpp>
+namespace sycl {
+inline namespace _V1 {
+namespace ext {
+namespace oneapi {
+namespace experimental {
+template <typename DataT, typename PropertiesT = empty_properties_t>
+class work_group_memory;
+} // namespace experimental
+} // namespace oneapi
+} // namespace ext
+} // namespace _V1
+} // namespace sycl

From 6f356ea7bdf4589d7e3aa19fede7d9b43cb67042 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 15:35:24 -0400
Subject: [PATCH 083/107] Update handler.hpp

---
 sycl/include/sycl/handler.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 5031ca3e204d2..997727c3eac73 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #pragma once
+
 #include <sycl/access/access.hpp>
 #include <sycl/accessor.hpp>
 #include <sycl/context.hpp>
@@ -625,6 +626,7 @@ class __SYCL_EXPORT handler {
 
   template <typename T> void setArgHelper(int ArgIndex, T &&Arg) {
     void *StoredArg = storePlainArg(Arg);
+            
     if (!std::is_same<cl_mem, T>::value && std::is_pointer<T>::value) {
       addArg(detail::kernel_param_kind_t::kind_pointer, StoredArg, sizeof(T),
              ArgIndex);

From ca4b228cb2f964dca3facf3955e5b40f6e7879ce Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 15:36:24 -0400
Subject: [PATCH 084/107] Update handler.hpp

---
 sycl/include/sycl/handler.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 997727c3eac73..f18065f51b425 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -626,7 +626,7 @@ class __SYCL_EXPORT handler {
 
   template <typename T> void setArgHelper(int ArgIndex, T &&Arg) {
     void *StoredArg = storePlainArg(Arg);
-            
+
     if (!std::is_same<cl_mem, T>::value && std::is_pointer<T>::value) {
       addArg(detail::kernel_param_kind_t::kind_pointer, StoredArg, sizeof(T),
              ArgIndex);

From 98186a5e1232a0d686d96ce0c8b20c8691ebd416 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 21:42:00 +0200
Subject: [PATCH 085/107] move doc to experimental and update status

---
 .../sycl_ext_oneapi_work_group_memory.asciidoc         | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)
 rename sycl/doc/extensions/{proposed => experimental}/sycl_ext_oneapi_work_group_memory.asciidoc (98%)

diff --git a/sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc
similarity index 98%
rename from sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc
rename to sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc
index c142e66ec4c77..b2d6e3cea5000 100644
--- a/sycl/doc/extensions/proposed/sycl_ext_oneapi_work_group_memory.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_work_group_memory.asciidoc
@@ -49,12 +49,10 @@ This extension also depends on the following other SYCL extensions:
 
 == Status
 
-This is a proposed extension specification, intended to gather community
-feedback.
-Interfaces defined in this specification may not be implemented yet or may be
-in a preliminary state.
-The specification itself may also change in incompatible ways before it is
-finalized.
+This is an experimental extension specification, intended to provide early
+access to features and gather community feedback.  Interfaces defined in this
+specification are implemented in {dpcpp}, but they are not finalized and may
+change incompatibly in future versions of {dpcpp} without prior notice.
 *Shipping software products should not rely on APIs defined in this
 specification.*
 

From c00c1f777110096019a1411d8e2b37b9253621c1 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 21:43:52 +0200
Subject: [PATCH 086/107] Define feature macro

---
 sycl/source/feature_test.hpp.in | 1 +
 1 file changed, 1 insertion(+)

diff --git a/sycl/source/feature_test.hpp.in b/sycl/source/feature_test.hpp.in
index 8f4fb05752efc..c1e62f5492abe 100644
--- a/sycl/source/feature_test.hpp.in
+++ b/sycl/source/feature_test.hpp.in
@@ -109,6 +109,7 @@ inline namespace _V1 {
 #define SYCL_EXT_ONEAPI_PROFILING_TAG 1
 #define SYCL_EXT_ONEAPI_ENQUEUE_NATIVE_COMMAND 1
 #define SYCL_EXT_ONEAPI_GET_KERNEL_INFO 1
+#define SYCL_EXT_ONEAPI_WORK_GROUP_MEMORY 1
 // In progress yet
 #define SYCL_EXT_ONEAPI_ATOMIC16 0
 

From 5cb2d21f1b3ac495fd90bb76d885293a4704b914 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 22:13:13 +0200
Subject: [PATCH 087/107] more formatting

---
 clang/lib/Sema/SemaSYCL.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index 9c3f40c0a5ec6..7bc940c577e3a 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -2079,9 +2079,9 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
   }
 
   bool handleArrayType(FieldDecl *FD, QualType FieldTy) final {
-  IsInvalid |= checkNotCopyableToKernel(FD, FieldTy);
-  return isValid();
-}
+    IsInvalid |= checkNotCopyableToKernel(FD, FieldTy);
+    return isValid();
+  }
 
   bool handleArrayType(ParmVarDecl *PD, QualType ParamTy) final {
     Diag.Report(PD->getLocation(), diag::err_bad_kernel_param_type) << ParamTy;

From f4b9b1abd0bf7266897e1e5626da370b6e5afd87 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Fri, 25 Oct 2024 02:23:53 +0200
Subject: [PATCH 088/107] Fix undefined behavior in tests and add unsupported
 directive on cuda

---
 .../work_group_memory_forward_decl.hpp        | 14 ++++++++
 .../WorkGroupMemory/free_function_kernel.cpp  | 32 +++++++++++--------
 2 files changed, 33 insertions(+), 13 deletions(-)
 create mode 100644 clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp

diff --git a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
new file mode 100644
index 0000000000000..5f3533caccd99
--- /dev/null
+++ b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
@@ -0,0 +1,14 @@
+#pragma once
+#include <sycl/ext/oneapi/properties/properties.hpp>
+namespace sycl {
+inline namespace _V1 {
+namespace ext {
+namespace oneapi {
+namespace experimental {
+template <typename DataT, typename PropertiesT = empty_properties_t>
+class work_group_memory;
+} // namespace experimental
+} // namespace oneapi
+} // namespace ext
+} // namespace _V1
+} // namespace sycl
diff --git a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
index 3c9a809b6e5ec..4497e67c5e3d1 100644
--- a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
@@ -2,6 +2,9 @@
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out
 
+// The name mangling for free function kernels currently does not work with PTX.
+// UNSUPPORTED: cuda
+
 #include <cassert>
 #include <sycl/detail/core.hpp>
 #include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
@@ -17,7 +20,6 @@ context ctx = q.get_context();
 void sum_helper(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
                 sycl::ext::oneapi::experimental::work_group_memory<int> ret,
                 size_t WGSIZE) {
-  ret = 0;
   for (int i = 0; i < WGSIZE; ++i) {
     ret += mem[i];
   }
@@ -26,22 +28,23 @@ void sum_helper(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
     (ext::oneapi::experimental::nd_range_kernel<1>))
 void sum(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
-         int *buf, int *Result, size_t WGSIZE, bool UseHelper) {
+         int *buf,
+         sycl::ext::oneapi::experimental::work_group_memory<int> result,
+         int expected, size_t WGSIZE, bool UseHelper) {
   const auto it = sycl::ext::oneapi::this_work_item::get_nd_item<1>();
   size_t local_id = it.get_local_id();
   mem[local_id] = buf[local_id];
   group_barrier(it.get_group());
   if (it.get_group().leader()) {
-    *Result = 0;
+    result = 0;
     if (!UseHelper) {
       for (int i = 0; i < WGSIZE; ++i) {
-        *Result += mem[i];
+        result += mem[i];
       }
     } else {
-      sycl::ext::oneapi::experimental::work_group_memory<int> ret;
-      sum_helper(mem, ret, WGSIZE);
-      *Result = ret;
+      sum_helper(mem, result, WGSIZE);
     }
+    assert(result == expected);
   }
 }
 
@@ -53,23 +56,26 @@ void test(size_t SIZE, size_t WGSIZE, bool UseHelper) {
     buf[i] = i;
     expected += buf[i];
   }
-  int *result = malloc_shared<int>(1, q);
-  assert(result && "Shared USM allocation failed!");
+
+  // The following ifndef is required due to a number of limitations of free
+  // function kernels
+  // TODO: Remove it once these limitations are no longer there.
 #ifndef __SYCL_DEVICE_ONLY__
+
   // Get the kernel object for the "mykernel" kernel.
   auto Bundle = get_kernel_bundle<sycl::bundle_state::executable>(ctx);
   kernel_id sum_id = ext::oneapi::experimental::get_kernel_id<sum>();
   kernel k_sum = Bundle.get_kernel(sum_id);
   q.submit([&](sycl::handler &cgh) {
      ext::oneapi::experimental::work_group_memory<int[]> mem{WGSIZE, cgh};
-     cgh.set_args(mem, buf, result, WGSIZE, UseHelper);
+     ext::oneapi::experimental ::work_group_memory<int> result{cgh};
+     cgh.set_args(mem, buf, result, expected, WGSIZE, UseHelper);
      nd_range ndr{{SIZE}, {WGSIZE}};
      cgh.parallel_for(ndr, k_sum);
    }).wait();
-#endif
-  assert(expected == *result);
+
+#endif // __SYCL_DEVICE_ONLY
   free(buf, q);
-  free(result, q);
 }
 
 int main() {

From c3426d744f9c94980294b3089285dff046b9b0ff Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 20:36:19 -0400
Subject: [PATCH 089/107] Update work_group_memory_forward_decl.hpp

---
 .../ext/oneapi/experimental/work_group_memory_forward_decl.hpp  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
index 5f3533caccd99..fd03a6a6a823c 100644
--- a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+++ b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
@@ -5,7 +5,7 @@ inline namespace _V1 {
 namespace ext {
 namespace oneapi {
 namespace experimental {
-template <typename DataT, typename PropertiesT = empty_properties_t>
+template <typename DataT, typename PropertiesT = int>
 class work_group_memory;
 } // namespace experimental
 } // namespace oneapi

From 7a6516cd130d2fdfc556b1bd8da812ca22adc1a0 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 20:39:25 -0400
Subject: [PATCH 090/107] Update work_group_memory_forward_decl.hpp

---
 .../work_group_memory_forward_decl.hpp             | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
index fd03a6a6a823c..4c9f7e775b88c 100644
--- a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+++ b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
@@ -1,14 +1,2 @@
 #pragma once
-#include <sycl/ext/oneapi/properties/properties.hpp>
-namespace sycl {
-inline namespace _V1 {
-namespace ext {
-namespace oneapi {
-namespace experimental {
-template <typename DataT, typename PropertiesT = int>
-class work_group_memory;
-} // namespace experimental
-} // namespace oneapi
-} // namespace ext
-} // namespace _V1
-} // namespace sycl
+// Dummy header file to avoid integration-header #include errors.

From 872f67134a90602900092f9b76b28135068e23fb Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 20:45:38 -0400
Subject: [PATCH 091/107] Update work_group_memory_forward_decl.hpp

---
 .../work_group_memory_forward_decl.hpp             | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
index 4c9f7e775b88c..380d41011fb74 100644
--- a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+++ b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
@@ -1,2 +1,16 @@
 #pragma once
 // Dummy header file to avoid integration-header #include errors.
+// It shadows the file 
+// sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+namespace sycl {
+inline namespace _V1 {
+namespace ext {
+namespace oneapi {
+namespace experimental {
+template <typename DataT, typename PropertiesT = int>
+class work_group_memory;
+} // namespace experimental
+} // namespace oneapi
+} // namespace ext
+} // namespace _V1
+} // namespace sycl

From 805b00f4aa69cfa4accb4f2273985f09ded79e25 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 20:46:36 -0400
Subject: [PATCH 092/107] Update work_group_memory_forward_decl.hpp

---
 .../ext/oneapi/experimental/work_group_memory_forward_decl.hpp  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
index 380d41011fb74..79707f6498a3f 100644
--- a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+++ b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
@@ -1,5 +1,5 @@
 #pragma once
-// Dummy header file to avoid integration-header #include errors.
+// Dummy header file for the purpose of SemaSYCL testing.
 // It shadows the file 
 // sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
 namespace sycl {

From c3b494c4cfb55987fe470abc0f74b7a8345eee73 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 21:11:27 -0400
Subject: [PATCH 093/107] Update free_function_kernel.cpp

---
 sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
index 4497e67c5e3d1..ed0a72f34d018 100644
--- a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
@@ -58,7 +58,7 @@ void test(size_t SIZE, size_t WGSIZE, bool UseHelper) {
   }
 
   // The following ifndef is required due to a number of limitations of free
-  // function kernels
+  // function kernels. See CMPLRLLVM-61498.
   // TODO: Remove it once these limitations are no longer there.
 #ifndef __SYCL_DEVICE_ONLY__
 

From bff19f4fc3fdc9862de08b8cec29761997edd5da Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 24 Oct 2024 23:24:59 -0400
Subject: [PATCH 094/107] Update free_function_kernel.cpp

---
 sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
index ed0a72f34d018..de381003f50d7 100644
--- a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
@@ -79,7 +79,7 @@ void test(size_t SIZE, size_t WGSIZE, bool UseHelper) {
 }
 
 int main() {
-  constexpr size_t SIZE = 1024;
+  constexpr size_t SIZE = 512;
   test(SIZE, SIZE, true /* UseHelper */);
   test(SIZE, SIZE, false);
   // Test with more than one work group

From 9bab966ea4f64b223562c7e0bf3c08d87e38580b Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Fri, 25 Oct 2024 15:45:54 +0200
Subject: [PATCH 095/107] Make header files more lightweight

---
 .../oneapi/experimental/work_group_memory_forward_decl.hpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
index 5f3533caccd99..92d86bd386485 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
@@ -1,11 +1,14 @@
 #pragma once
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <tuple>
 namespace sycl {
 inline namespace _V1 {
 namespace ext {
 namespace oneapi {
 namespace experimental {
-template <typename DataT, typename PropertiesT = empty_properties_t>
+
+template <typename> class properties;
+
+template <typename DataT, typename PropertiesT = properties<std::tuple<>>>
 class work_group_memory;
 } // namespace experimental
 } // namespace oneapi

From 740f3890d8b42ce672835df72a1e257b6d010fcf Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Fri, 25 Oct 2024 19:03:52 +0200
Subject: [PATCH 096/107] Modify integration header changes

---
 clang/lib/Sema/SemaSYCL.cpp                                      | 1 +
 sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp  | 1 +
 .../ext/oneapi/experimental/work_group_memory_forward_decl.hpp   | 1 -
 3 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index 7bc940c577e3a..7f67c5e4bf6ae 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -6290,6 +6290,7 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
   // work_group_memory<int> where the hidden second parameter has a default
   // value. To circumvent this, we include the correct forward declaration
   // ourselves.
+  O << "#include <tuple>\n";
   O << "#include "
        "<sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>\n";
   O << "\n";
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index da4a9c69079ff..b2efb9dcebdb2 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <tuple>
 #include <sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>
 #include <type_traits>
 
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
index 92d86bd386485..3e72b81797605 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
@@ -1,5 +1,4 @@
 #pragma once
-#include <tuple>
 namespace sycl {
 inline namespace _V1 {
 namespace ext {

From 0fa7af48a39d5a6e0f01db095f51601819a27e86 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Mon, 28 Oct 2024 17:29:38 -0400
Subject: [PATCH 097/107] Update work_group_memory.cpp

---
 clang/test/CodeGenSYCL/work_group_memory.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clang/test/CodeGenSYCL/work_group_memory.cpp b/clang/test/CodeGenSYCL/work_group_memory.cpp
index fb8721debb48e..bd4f34c82331c 100644
--- a/clang/test/CodeGenSYCL/work_group_memory.cpp
+++ b/clang/test/CodeGenSYCL/work_group_memory.cpp
@@ -19,7 +19,7 @@
 //
 // CHECK-INT-HEADER: const kernel_param_desc_t kernel_signatures[] = {
 // CHECK-INT-HEADER-NEXT: //--- _ZTSZZ4mainENKUlRN4sycl3_V17handlerEE_clES2_EUlNS0_4itemILi1EEEE_
-// CHECK-INT-HEADER-NEXT: { kernel_param_kind_t::kind_work_group_memory, 8, 0 },
+// CHECK-INT-HEADER-NEXT: { kernel_param_kind_t::kind_work_group_memory, {{[4, 8]}}, 0 },
 // CHECK-INT-HEADER-EMPTY:
 // CHECK-INT-HEADER-NEXT: { kernel_param_kind_t::kind_invalid, -987654321, -987654321 },
 // CHECK-INT-HEADER-NEXT: };

From 883549a8445497d7f7065f6ef4198d72c400391a Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Mon, 28 Oct 2024 17:29:58 -0400
Subject: [PATCH 098/107] Update work_group_memory.cpp

---
 clang/test/CodeGenSYCL/work_group_memory.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clang/test/CodeGenSYCL/work_group_memory.cpp b/clang/test/CodeGenSYCL/work_group_memory.cpp
index bd4f34c82331c..a4ebb72ad862d 100644
--- a/clang/test/CodeGenSYCL/work_group_memory.cpp
+++ b/clang/test/CodeGenSYCL/work_group_memory.cpp
@@ -19,7 +19,7 @@
 //
 // CHECK-INT-HEADER: const kernel_param_desc_t kernel_signatures[] = {
 // CHECK-INT-HEADER-NEXT: //--- _ZTSZZ4mainENKUlRN4sycl3_V17handlerEE_clES2_EUlNS0_4itemILi1EEEE_
-// CHECK-INT-HEADER-NEXT: { kernel_param_kind_t::kind_work_group_memory, {{[4, 8]}}, 0 },
+// CHECK-INT-HEADER-NEXT: { kernel_param_kind_t::kind_work_group_memory, {{[4,8]}}, 0 },
 // CHECK-INT-HEADER-EMPTY:
 // CHECK-INT-HEADER-NEXT: { kernel_param_kind_t::kind_invalid, -987654321, -987654321 },
 // CHECK-INT-HEADER-NEXT: };

From 535890ab3b1465944810c3d72d6fbb1dbe0394a4 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Thu, 31 Oct 2024 12:33:02 -0700
Subject: [PATCH 099/107] Remove work_group_memory_forward_decl.hpp

---
 clang/lib/Sema/SemaSYCL.cpp                      | 10 ----------
 .../work_group_memory_forward_decl.hpp           | 16 ----------------
 .../oneapi/experimental/work_group_memory.hpp    |  4 +---
 .../work_group_memory_forward_decl.hpp           | 16 ----------------
 4 files changed, 1 insertion(+), 45 deletions(-)
 delete mode 100644 clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
 delete mode 100644 sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index db746ebce6a0a..5fc8018ca0198 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -6283,16 +6283,6 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
   O << "#include <sycl/detail/defines_elementary.hpp>\n";
   O << "#include <sycl/detail/kernel_desc.hpp>\n";
   O << "#include <sycl/ext/oneapi/experimental/free_function_traits.hpp>\n";
-  // When using work group memory parameters in free kernel functions, the
-  // integration header emits incorrect forward declarations for the work group
-  // memory type because it ignores default arguments. This means the user
-  // cannot use work group memory types with parameters omitted such as
-  // work_group_memory<int> where the hidden second parameter has a default
-  // value. To circumvent this, we include the correct forward declaration
-  // ourselves.
-  O << "#include <tuple>\n";
-  O << "#include "
-       "<sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>\n";
   O << "\n";
 
   LangOptions LO;
diff --git a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
deleted file mode 100644
index 79707f6498a3f..0000000000000
--- a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-// Dummy header file for the purpose of SemaSYCL testing.
-// It shadows the file 
-// sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
-namespace sycl {
-inline namespace _V1 {
-namespace ext {
-namespace oneapi {
-namespace experimental {
-template <typename DataT, typename PropertiesT = int>
-class work_group_memory;
-} // namespace experimental
-} // namespace oneapi
-} // namespace ext
-} // namespace _V1
-} // namespace sycl
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index b2efb9dcebdb2..bf8fe9d521ee8 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -8,8 +8,6 @@
 
 #pragma once
 
-#include <tuple>
-#include <sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>
 #include <type_traits>
 
 namespace sycl {
@@ -38,7 +36,7 @@ class work_group_memory_impl {
 } // namespace detail
 namespace ext::oneapi::experimental {
 
-template <typename DataT, typename PropertyListT>
+template <typename DataT, typename PropertyListT = empty_properties_t>
 class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     : public sycl::detail::work_group_memory_impl {
 public:
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
deleted file mode 100644
index 3e72b81797605..0000000000000
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-namespace sycl {
-inline namespace _V1 {
-namespace ext {
-namespace oneapi {
-namespace experimental {
-
-template <typename> class properties;
-
-template <typename DataT, typename PropertiesT = properties<std::tuple<>>>
-class work_group_memory;
-} // namespace experimental
-} // namespace oneapi
-} // namespace ext
-} // namespace _V1
-} // namespace sycl

From 4b2a148a2185869483a52823ba7aa38ab88bdbc6 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Fri, 1 Nov 2024 13:05:59 -0700
Subject: [PATCH 100/107] Revert "Remove work_group_memory_forward_decl.hpp"

This reverts commit 535890ab3b1465944810c3d72d6fbb1dbe0394a4.
---
 clang/lib/Sema/SemaSYCL.cpp                      | 10 ++++++++++
 .../work_group_memory_forward_decl.hpp           | 16 ++++++++++++++++
 .../oneapi/experimental/work_group_memory.hpp    |  4 +++-
 .../work_group_memory_forward_decl.hpp           | 16 ++++++++++++++++
 4 files changed, 45 insertions(+), 1 deletion(-)
 create mode 100644 clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
 create mode 100644 sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index 5fc8018ca0198..db746ebce6a0a 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -6283,6 +6283,16 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
   O << "#include <sycl/detail/defines_elementary.hpp>\n";
   O << "#include <sycl/detail/kernel_desc.hpp>\n";
   O << "#include <sycl/ext/oneapi/experimental/free_function_traits.hpp>\n";
+  // When using work group memory parameters in free kernel functions, the
+  // integration header emits incorrect forward declarations for the work group
+  // memory type because it ignores default arguments. This means the user
+  // cannot use work group memory types with parameters omitted such as
+  // work_group_memory<int> where the hidden second parameter has a default
+  // value. To circumvent this, we include the correct forward declaration
+  // ourselves.
+  O << "#include <tuple>\n";
+  O << "#include "
+       "<sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>\n";
   O << "\n";
 
   LangOptions LO;
diff --git a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
new file mode 100644
index 0000000000000..79707f6498a3f
--- /dev/null
+++ b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
@@ -0,0 +1,16 @@
+#pragma once
+// Dummy header file for the purpose of SemaSYCL testing.
+// It shadows the file 
+// sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+namespace sycl {
+inline namespace _V1 {
+namespace ext {
+namespace oneapi {
+namespace experimental {
+template <typename DataT, typename PropertiesT = int>
+class work_group_memory;
+} // namespace experimental
+} // namespace oneapi
+} // namespace ext
+} // namespace _V1
+} // namespace sycl
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index bf8fe9d521ee8..b2efb9dcebdb2 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -8,6 +8,8 @@
 
 #pragma once
 
+#include <tuple>
+#include <sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>
 #include <type_traits>
 
 namespace sycl {
@@ -36,7 +38,7 @@ class work_group_memory_impl {
 } // namespace detail
 namespace ext::oneapi::experimental {
 
-template <typename DataT, typename PropertyListT = empty_properties_t>
+template <typename DataT, typename PropertyListT>
 class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     : public sycl::detail::work_group_memory_impl {
 public:
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
new file mode 100644
index 0000000000000..3e72b81797605
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
@@ -0,0 +1,16 @@
+#pragma once
+namespace sycl {
+inline namespace _V1 {
+namespace ext {
+namespace oneapi {
+namespace experimental {
+
+template <typename> class properties;
+
+template <typename DataT, typename PropertiesT = properties<std::tuple<>>>
+class work_group_memory;
+} // namespace experimental
+} // namespace oneapi
+} // namespace ext
+} // namespace _V1
+} // namespace sycl

From 54ab379bf6d48b64cc3349d1ef04b7b773638e56 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Wed, 6 Nov 2024 21:20:02 -0800
Subject: [PATCH 101/107] Fix bug in integration header free function kernel
 declaration

---
 clang/lib/Sema/SemaSYCL.cpp                      | 16 +++++-----------
 .../oneapi/experimental/work_group_memory.hpp    |  6 +++---
 2 files changed, 8 insertions(+), 14 deletions(-)

diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index db746ebce6a0a..7cdf701ec0d1c 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -6283,16 +6283,6 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
   O << "#include <sycl/detail/defines_elementary.hpp>\n";
   O << "#include <sycl/detail/kernel_desc.hpp>\n";
   O << "#include <sycl/ext/oneapi/experimental/free_function_traits.hpp>\n";
-  // When using work group memory parameters in free kernel functions, the
-  // integration header emits incorrect forward declarations for the work group
-  // memory type because it ignores default arguments. This means the user
-  // cannot use work group memory types with parameters omitted such as
-  // work_group_memory<int> where the hidden second parameter has a default
-  // value. To circumvent this, we include the correct forward declaration
-  // ourselves.
-  O << "#include <tuple>\n";
-  O << "#include "
-       "<sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>\n";
   O << "\n";
 
   LangOptions LO;
@@ -6560,6 +6550,7 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
 
     O << "\n";
     O << "// Forward declarations of kernel and its argument types:\n";
+    Policy.SuppressDefaultTemplateArgs = false;
     FwdDeclEmitter.Visit(K.SyclKernel->getType());
     O << "\n";
 
@@ -6572,11 +6563,12 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
         FirstParam = false;
       else
         ParmList += ", ";
-      ParmList += Param->getType().getCanonicalType().getAsString();
+      ParmList += Param->getType().getCanonicalType().getAsString(Policy);
     }
     FunctionTemplateDecl *FTD = K.SyclKernel->getPrimaryTemplate();
     Policy.SuppressDefinition = true;
     Policy.PolishForDeclaration = true;
+    Policy.EnforceDefaultTemplateArgs = true;
     if (FTD) {
       FTD->print(O, Policy);
     } else {
@@ -6605,6 +6597,8 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     }
     O << ";\n";
     O << "}\n";
+    Policy.SuppressDefaultTemplateArgs = true;
+    Policy.EnforceDefaultTemplateArgs = false;
 
     // Generate is_kernel, is_single_task_kernel and nd_range_kernel functions.
     O << "namespace sycl {\n";
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index b2efb9dcebdb2..82721dcbc699a 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -1,5 +1,4 @@
 //===-------------------- work_group_memory.hpp ---------------------------===//
-//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -9,7 +8,6 @@
 #pragma once
 
 #include <tuple>
-#include <sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp>
 #include <type_traits>
 
 namespace sycl {
@@ -38,7 +36,9 @@ class work_group_memory_impl {
 } // namespace detail
 namespace ext::oneapi::experimental {
 
-template <typename DataT, typename PropertyListT>
+template <typename DataT,
+          typename PropertyListT =
+              sycl::ext::oneapi::experimental::properties<std::tuple<>>>
 class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
     : public sycl::detail::work_group_memory_impl {
 public:

From 336c90e887ce921956b76cd249eef83fc35e7292 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 12 Nov 2024 08:03:30 -0800
Subject: [PATCH 102/107] Refactor tests

---
 .../WorkGroupMemory/free_function_kernel.cpp        | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
index de381003f50d7..b13695471c62c 100644
--- a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
@@ -13,12 +13,13 @@
 #include <sycl/usm.hpp>
 
 using namespace sycl;
+namespace syclexp = sycl::ext::oneapi::experimental;
 
 queue q;
 context ctx = q.get_context();
 
-void sum_helper(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
-                sycl::ext::oneapi::experimental::work_group_memory<int> ret,
+void sum_helper(syclexp::work_group_memory<int[]> mem,
+                syclexp::work_group_memory<int> ret,
                 size_t WGSIZE) {
   for (int i = 0; i < WGSIZE; ++i) {
     ret += mem[i];
@@ -27,9 +28,9 @@ void sum_helper(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
 
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
     (ext::oneapi::experimental::nd_range_kernel<1>))
-void sum(sycl::ext::oneapi::experimental::work_group_memory<int[]> mem,
+void sum(syclexp::work_group_memory<int[]> mem,
          int *buf,
-         sycl::ext::oneapi::experimental::work_group_memory<int> result,
+         syclexp::work_group_memory<int> result,
          int expected, size_t WGSIZE, bool UseHelper) {
   const auto it = sycl::ext::oneapi::this_work_item::get_nd_item<1>();
   size_t local_id = it.get_local_id();
@@ -67,8 +68,8 @@ void test(size_t SIZE, size_t WGSIZE, bool UseHelper) {
   kernel_id sum_id = ext::oneapi::experimental::get_kernel_id<sum>();
   kernel k_sum = Bundle.get_kernel(sum_id);
   q.submit([&](sycl::handler &cgh) {
-     ext::oneapi::experimental::work_group_memory<int[]> mem{WGSIZE, cgh};
-     ext::oneapi::experimental ::work_group_memory<int> result{cgh};
+     syclexp::work_group_memory<int[]> mem{WGSIZE, cgh};
+     syclexp::work_group_memory<int> result{cgh};
      cgh.set_args(mem, buf, result, expected, WGSIZE, UseHelper);
      nd_range ndr{{SIZE}, {WGSIZE}};
      cgh.parallel_for(ndr, k_sum);

From 3d326a3294fdf8d7201ed60363845355aeaf76f3 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Mon, 18 Nov 2024 13:07:40 -0500
Subject: [PATCH 103/107] Delete
 sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp

---
 .../work_group_memory_forward_decl.hpp           | 16 ----------------
 1 file changed, 16 deletions(-)
 delete mode 100644 sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
deleted file mode 100644
index 3e72b81797605..0000000000000
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-namespace sycl {
-inline namespace _V1 {
-namespace ext {
-namespace oneapi {
-namespace experimental {
-
-template <typename> class properties;
-
-template <typename DataT, typename PropertiesT = properties<std::tuple<>>>
-class work_group_memory;
-} // namespace experimental
-} // namespace oneapi
-} // namespace ext
-} // namespace _V1
-} // namespace sycl

From dab03c5e658f4de96722efe6b90eb63dcc615684 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Mon, 18 Nov 2024 13:08:19 -0500
Subject: [PATCH 104/107] Delete
 clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp

---
 .../work_group_memory_forward_decl.hpp           | 16 ----------------
 1 file changed, 16 deletions(-)
 delete mode 100644 clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp

diff --git a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp b/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
deleted file mode 100644
index 79707f6498a3f..0000000000000
--- a/clang/test/SemaSYCL/Inputs/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-// Dummy header file for the purpose of SemaSYCL testing.
-// It shadows the file 
-// sycl/include/sycl/ext/oneapi/experimental/work_group_memory_forward_decl.hpp
-namespace sycl {
-inline namespace _V1 {
-namespace ext {
-namespace oneapi {
-namespace experimental {
-template <typename DataT, typename PropertiesT = int>
-class work_group_memory;
-} // namespace experimental
-} // namespace oneapi
-} // namespace ext
-} // namespace _V1
-} // namespace sycl

From ca4f2f31264f42b202d1840e60479173ccb04ef8 Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 19 Nov 2024 07:08:42 -0800
Subject: [PATCH 105/107] Make work group memory inheritance private

---
 .../sycl/ext/oneapi/experimental/work_group_memory.hpp       | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index f8f70a2291517..728d2f4bbc9f2 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -40,7 +40,7 @@ inline constexpr indeterminate_t indeterminate;
 
 template <typename DataT, typename PropertyListT = empty_properties_t>
 class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
-    : public sycl::detail::work_group_memory_impl {
+    : sycl::detail::work_group_memory_impl {
 public:
   using value_type = std::remove_all_extents_t<DataT>;
 
@@ -89,6 +89,9 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(work_group_memory) work_group_memory
   }
 
 private:
+  friend class sycl::handler; // needed in order for handler class to be aware
+                              // of the private inheritance with
+                              // work_group_memory_impl as base class
   decoratedPtr ptr = nullptr;
 };
 } // namespace ext::oneapi::experimental

From e3899f7b9b8ea28e28aaafcd2378de9563e937df Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 19 Nov 2024 07:38:13 -0800
Subject: [PATCH 106/107] Remove XFAIL from free function test

---
 .../WorkGroupMemory/free_function_kernel.cpp  | 90 -------------------
 .../reduction_free_function.cpp               |  3 -
 2 files changed, 93 deletions(-)
 delete mode 100644 sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp

diff --git a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp b/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
deleted file mode 100644
index 32a7459d34fbe..0000000000000
--- a/sycl/test-e2e/WorkGroupMemory/free_function_kernel.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-// REQUIRES: aspect-usm_shared_allocations
-// RUN: %{build} -o %t.out
-// RUN: %{run} %t.out
-
-// The name mangling for free function kernels currently does not work with PTX.
-// UNSUPPORTED: cuda
-// UNSUPPORTED-TRACKER: https://github.com/intel/llvm/issues/16004
-
-#include <cassert>
-#include <sycl/detail/core.hpp>
-#include <sycl/ext/oneapi/experimental/work_group_memory.hpp>
-#include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/group_barrier.hpp>
-#include <sycl/usm.hpp>
-
-using namespace sycl;
-namespace syclexp = sycl::ext::oneapi::experimental;
-queue q;
-context ctx = q.get_context();
-
-void sum_helper(syclexp::work_group_memory<int[]> mem,
-                syclexp::work_group_memory<int> ret,
-                size_t WGSIZE) {
-  for (int i = 0; i < WGSIZE; ++i) {
-    ret += mem[i];
-  }
-}
-
-SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
-    (ext::oneapi::experimental::nd_range_kernel<1>))
-void sum(syclexp::work_group_memory<int[]> mem,
-         int *buf,
-         syclexp::work_group_memory<int> result,
-         int expected, size_t WGSIZE, bool UseHelper) {
-  const auto it = sycl::ext::oneapi::this_work_item::get_nd_item<1>();
-  size_t local_id = it.get_local_id();
-  mem[local_id] = buf[local_id];
-  group_barrier(it.get_group());
-  if (it.get_group().leader()) {
-    result = 0;
-    if (!UseHelper) {
-      for (int i = 0; i < WGSIZE; ++i) {
-        result += mem[i];
-      }
-    } else {
-      sum_helper(mem, result, WGSIZE);
-    }
-    assert(result == expected);
-  }
-}
-
-void test(size_t SIZE, size_t WGSIZE, bool UseHelper) {
-  int *buf = malloc_shared<int>(WGSIZE, q);
-  assert(buf && "Shared USM allocation failed!");
-  int expected = 0;
-  for (int i = 0; i < WGSIZE; ++i) {
-    buf[i] = i;
-    expected += buf[i];
-  }
-
-  // The following ifndef is required due to a number of limitations of free
-  // function kernels. See CMPLRLLVM-61498.
-  // TODO: Remove it once these limitations are no longer there.
-#ifndef __SYCL_DEVICE_ONLY__
-
-  // Get the kernel object for the "mykernel" kernel.
-  auto Bundle = get_kernel_bundle<sycl::bundle_state::executable>(ctx);
-  kernel_id sum_id = ext::oneapi::experimental::get_kernel_id<sum>();
-  kernel k_sum = Bundle.get_kernel(sum_id);
-  q.submit([&](sycl::handler &cgh) {
-     syclexp::work_group_memory<int[]> mem{WGSIZE, cgh};
-     syclexp::work_group_memory<int> result{cgh};
-     cgh.set_args(mem, buf, result, expected, WGSIZE, UseHelper);
-     nd_range ndr{{SIZE}, {WGSIZE}};
-     cgh.parallel_for(ndr, k_sum);
-   }).wait();
-
-#endif // __SYCL_DEVICE_ONLY
-  free(buf, q);
-}
-
-int main() {
-  constexpr size_t SIZE = 512;
-  test(SIZE, SIZE, true /* UseHelper */);
-  test(SIZE, SIZE, false);
-  // Test with more than one work group
-  test(SIZE, SIZE / 2, false);
-  test(SIZE, SIZE / 4, false);
-  return 0;
-}
diff --git a/sycl/test-e2e/WorkGroupMemory/reduction_free_function.cpp b/sycl/test-e2e/WorkGroupMemory/reduction_free_function.cpp
index ff2aa8aa19385..1f2f5ccd0c5e1 100644
--- a/sycl/test-e2e/WorkGroupMemory/reduction_free_function.cpp
+++ b/sycl/test-e2e/WorkGroupMemory/reduction_free_function.cpp
@@ -5,9 +5,6 @@
 // UNSUPPORTED: cuda
 // UNSUPPORTED-TRACKER: https://github.com/intel/llvm/issues/16004
 
-// XFAIL: *
-// XFAIL-TRACKER: https://github.com/intel/llvm/issues/15927
-
 #include "common_free_function.hpp"
 
 // Basic usage reduction test using free function kernels.

From 7b3e5e356ce2ec4696d79e8b19f24d48f445487e Mon Sep 17 00:00:00 2001
From: Lorenc Bushi <lorenc.bushi@intel.com>
Date: Tue, 19 Nov 2024 07:40:12 -0800
Subject: [PATCH 107/107] Remove unnecessary includes

---
 sycl/test-e2e/WorkGroupMemory/common_free_function.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sycl/test-e2e/WorkGroupMemory/common_free_function.hpp b/sycl/test-e2e/WorkGroupMemory/common_free_function.hpp
index e13f50214593d..7cc1b6008bd78 100644
--- a/sycl/test-e2e/WorkGroupMemory/common_free_function.hpp
+++ b/sycl/test-e2e/WorkGroupMemory/common_free_function.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "common.hpp"
-#include "common_lambda.hpp"
 #include <cassert>
 #include <sycl/detail/core.hpp>
 #include <sycl/ext/oneapi/experimental/work_group_memory.hpp>