From 2b2a3d749a8eca7735f585fb07bb22b22bf0e31e Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 29 Mar 2024 09:58:36 -0700
Subject: [PATCH 01/79] Made preview-breaking-changes default

---
 .../include/sycl/detail/builtins/builtins.hpp | 245 +++++++
 .../sycl/detail/generic_type_traits.hpp       |   8 +-
 sycl/include/sycl/detail/vector_traits.hpp    |   7 -
 sycl/include/sycl/half_type.hpp               |  25 -
 sycl/include/sycl/types.hpp                   | 603 +-----------------
 .../Basic/sycl_2020_images/common.hpp         |   2 +-
 .../array/read_write_unsampled_array.cpp      |   4 +-
 .../bindless_images/bindless_helpers.hpp      |   4 +-
 .../bindless_images/image_get_info.cpp        |   4 +-
 .../bindless_images/mipmap/mipmap_read_1D.cpp |   4 +-
 .../bindless_images/mipmap/mipmap_read_2D.cpp |   4 +-
 .../bindless_images/mipmap/mipmap_read_3D.cpp |   4 +-
 sycl/test-e2e/bindless_images/read_1D.cpp     |   4 +-
 sycl/test-e2e/bindless_images/read_2D.cpp     |   4 +-
 .../bindless_images/read_2D_dynamic.cpp       |   4 +-
 sycl/test-e2e/bindless_images/read_3D.cpp     |   4 +-
 .../bindless_images/read_norm_types.cpp       |   4 +-
 .../test-e2e/bindless_images/read_sampled.cpp |   4 +-
 .../bindless_images/read_write_1D.cpp         |   4 +-
 .../read_write_1D_subregion.cpp               |   4 +-
 .../bindless_images/read_write_2D.cpp         |   4 +-
 .../read_write_2D_subregion.cpp               |   4 +-
 .../bindless_images/read_write_3D.cpp         |   4 +-
 .../read_write_3D_subregion.cpp               |   4 +-
 .../bindless_images/read_write_unsampled.cpp  |   4 +-
 sycl/test-e2e/bindless_images/sampling_2D.cpp |   5 +-
 .../sampling_2D_USM_shared.cpp                |   5 +-
 .../bindless_images/sampling_2D_half.cpp      |   5 +-
 sycl/test-e2e/bindless_images/sampling_3D.cpp |   4 +-
 .../sampling_unique_addr_modes.cpp            |   4 +-
 .../user_types/mipmap_read_user_type_2D.cpp   |   4 +-
 .../user_types/read_write_user_type.cpp       |   4 +-
 .../user_types/user_types_common.hpp          |   4 +-
 sycl/test/basic_tests/types.cpp               |  19 -
 sycl/test/conf.txt                            |   1 +
 .../annotated_ptr/annotated_ptr.cpp           |   4 -
 sycl/test_bfloat.cpp                          |  27 +
 37 files changed, 369 insertions(+), 683 deletions(-)
 create mode 100644 sycl/include/sycl/detail/builtins/builtins.hpp
 create mode 100644 sycl/test/conf.txt
 create mode 100644 sycl/test_bfloat.cpp

diff --git a/sycl/include/sycl/detail/builtins/builtins.hpp b/sycl/include/sycl/detail/builtins/builtins.hpp
new file mode 100644
index 0000000000000..6ba7b50f05226
--- /dev/null
+++ b/sycl/include/sycl/detail/builtins/builtins.hpp
@@ -0,0 +1,245 @@
+//==------------------- builtins.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
+//
+//===----------------------------------------------------------------------===//
+
+// Implement SYCL builtin functions. This implementation is mainly driven by the
+// requirement of not including <cmath> anywhere in the SYCL headers (i.e. from
+// within <sycl/sycl.hpp>), because it pollutes global namespace. Note that we
+// can avoid that using MSVC's STL as the pollution happens even from
+// <vector>/<string> and other headers that have to be included per the SYCL
+// specification. As such, an alternative approach might be to use math
+// intrinsics with GCC/clang-based compilers and use <cmath> when using MSVC as
+// a host compiler. That hasn't been tried/investigated.
+//
+// Current implementation splits builtins into several files following the SYCL
+// 2020 (revision 8) split into common/math/geometric/relational/etc. functions.
+// For each set, the implementation is split into a user-visible
+// include/sycl/detail/builtins/*_functions.hpp providing full device-side
+// implementation as well as defining user-visible APIs and defining ABI
+// implemented under source/builtins/*_functions.cpp for the host side. We
+// provide both scalar/vector overloads through symbols in the SYCL runtime
+// library due to the <cmath> limitation above (for scalars) and due to
+// performance reasons for vector overloads (to be able to benefit from
+// vectorization).
+//
+// Providing declaration for the host side symbols contained in the library
+// comes with its own challenges. One is compilation time - blindly providing
+// all those declarations takes significant time (about 10% slowdown for
+// "clang++ -fsycl" when compiling just "#include <sycl/sycl.hpp>"). Another
+// issue is that return type for templates is part of the mangling (and as such
+// SFINAE requirements too). To overcome that we structure host side
+// implementation roughly like this (in most cases):
+//
+// math_function.cpp exports:
+//   float sycl::__sin_impl(float);
+//   float1 sycl::__sin_impl(float1);
+//   float2 sycl::__sin_impl(float2);
+//   ...
+//   /* same for other types */
+//
+// math_functions.hpp provide an implementation based on the following idea (in
+// ::sycl namespace):
+//   float sin(float x) {
+//     extern __sin_impl(float);
+//     return __sin_impl(x);
+//   }
+//   template <typename T>
+//   enable_if_valid_type<T> sin(T x) {
+//     if constexpr (marray_or_swizzle) {
+//       ...
+//       call sycl::sin(vector_or_scalar)
+//     } else {
+//       extern T __sin_impl(T);
+//       return __sin_impl(x);
+//     }
+//   }
+// That way we avoid having the full set of explicit declaration for the symbols
+// in the library and instead only pay with compile time when those template
+// instantiations actually happen.
+
+#pragma once
+
+#include <sycl/builtins_utils_vec.hpp>
+
+namespace sycl {
+inline namespace _V1 {
+namespace detail {
+template <typename... Ts>
+inline constexpr bool builtin_same_shape_v =
+    ((... && is_scalar_arithmetic_v<Ts>) || (... && is_marray_v<Ts>) ||
+     (... && is_vec_or_swizzle_v<Ts>)) &&
+    (... && (num_elements<Ts>::value ==
+             num_elements<typename first_type<Ts...>::type>::value));
+
+template <typename... Ts>
+inline constexpr bool builtin_same_or_swizzle_v =
+    // Use builtin_same_shape_v to filter out types unrelated to builtins.
+    builtin_same_shape_v<Ts...> && all_same_v<simplify_if_swizzle_t<Ts>...>;
+
+namespace builtins {
+#ifdef __SYCL_DEVICE_ONLY__
+template <typename T> auto convert_arg(T &&x) {
+  using no_cv_ref = std::remove_cv_t<std::remove_reference_t<T>>;
+  if constexpr (is_vec_v<no_cv_ref>) {
+    using elem_type = get_elem_type_t<no_cv_ref>;
+    using converted_elem_type =
+        decltype(convert_arg(std::declval<elem_type>()));
+
+    constexpr auto N = no_cv_ref::size();
+    using result_type = std::conditional_t<N == 1, converted_elem_type,
+                                           converted_elem_type
+                                           __attribute__((ext_vector_type(N)))>;
+    // TODO: We should have this bit_cast impl inside vec::convert.
+    return bit_cast<result_type>(static_cast<typename no_cv_ref::vector_t>(x));
+  } else if constexpr (is_swizzle_v<no_cv_ref>) {
+    return convert_arg(simplify_if_swizzle_t<no_cv_ref>{x});
+  } else {
+    static_assert(is_scalar_arithmetic_v<no_cv_ref> ||
+                  is_multi_ptr_v<no_cv_ref> || std::is_pointer_v<no_cv_ref> ||
+                  std::is_same_v<no_cv_ref, half>);
+    return convertToOpenCLType(std::forward<T>(x));
+  }
+}
+
+template <typename RetTy, typename T> auto convert_result(T &&x) {
+  if constexpr (is_vec_v<RetTy>) {
+    return bit_cast<typename RetTy::vector_t>(x);
+  } else {
+    return std::forward<T>(x);
+  }
+}
+#endif
+} // namespace builtins
+
+template <typename FuncTy, typename... Ts>
+auto builtin_marray_impl(FuncTy F, const Ts &...x) {
+  using ret_elem_type = decltype(F(x[0]...));
+  using T = typename first_type<Ts...>::type;
+  marray<ret_elem_type, T::size()> Res;
+  constexpr auto N = T::size();
+  for (size_t I = 0; I < N / 2; ++I) {
+    auto PartialRes = [&]() {
+      using elem_ty = get_elem_type_t<T>;
+      if constexpr (std::is_integral_v<elem_ty>)
+        return F(to_vec2(x, I * 2)
+                     .template as<vec<get_fixed_sized_int_t<elem_ty>, 2>>()...);
+      else
+        return F(to_vec2(x, I * 2)...);
+    }();
+    std::memcpy(&Res[I * 2], &PartialRes, sizeof(decltype(PartialRes)));
+  }
+  if (N % 2)
+    Res[N - 1] = F(x[N - 1]...);
+  return Res;
+}
+
+template <typename FuncTy, typename... Ts>
+auto builtin_default_host_impl(FuncTy F, const Ts &...x) {
+  // We implement support for marray/swizzle in the headers and export symbols
+  // for scalars/vector from the library binary. The reason is that scalar
+  // implementations mostly depend on <cmath> which pollutes global namespace,
+  // so we can't unconditionally include it from the SYCL headers. Vector
+  // overloads have to be implemented in the library next to scalar overloads in
+  // order to be vectorizable.
+  if constexpr ((... || is_marray_v<Ts>)) {
+    return builtin_marray_impl(F, x...);
+  } else {
+    return F(simplify_if_swizzle_t<Ts>{x}...);
+  }
+}
+
+template <typename FuncTy, typename... Ts>
+auto builtin_delegate_to_scalar(FuncTy F, const Ts &...x) {
+  using T = typename first_type<Ts...>::type;
+  static_assert(is_vec_or_swizzle_v<T> || is_marray_v<T>);
+
+  constexpr auto Size = T::size();
+  using ret_elem_type = decltype(F(x[0]...));
+  std::conditional_t<is_marray_v<T>, marray<ret_elem_type, Size>,
+                     vec<ret_elem_type, Size>>
+      r{};
+
+  if constexpr (is_marray_v<T>) {
+    for (size_t i = 0; i < Size; ++i)
+      r[i] = F(x[i]...);
+  } else {
+    loop<Size>([&](auto idx) { r[idx] = F(x[idx]...); });
+  }
+
+  return r;
+}
+
+template <typename T>
+struct fp_elem_type
+    : std::bool_constant<
+          check_type_in_v<get_elem_type_t<T>, float, double, half>> {};
+template <typename T>
+struct float_elem_type
+    : std::bool_constant<check_type_in_v<get_elem_type_t<T>, float>> {};
+
+template <typename... Ts>
+struct same_basic_shape : std::bool_constant<builtin_same_shape_v<Ts...>> {};
+
+template <typename... Ts>
+struct same_elem_type : std::bool_constant<same_basic_shape<Ts...>::value &&
+                                           all_same_v<get_elem_type_t<Ts>...>> {
+};
+
+template <typename> struct any_shape : std::true_type {};
+
+template <typename T>
+struct scalar_only : std::bool_constant<is_scalar_arithmetic_v<T>> {};
+
+template <typename T>
+struct non_scalar_only : std::bool_constant<!is_scalar_arithmetic_v<T>> {};
+
+template <typename T> struct default_ret_type {
+  using type = T;
+};
+
+template <typename T> struct scalar_ret_type {
+  using type = get_elem_type_t<T>;
+};
+
+template <template <typename> typename RetTypeTrait,
+          template <typename> typename ElemTypeChecker,
+          template <typename> typename ShapeChecker,
+          template <typename...> typename ExtraConditions, typename... Ts>
+struct builtin_enable
+    : std::enable_if<
+          ElemTypeChecker<typename first_type<Ts...>::type>::value &&
+              ShapeChecker<typename first_type<Ts...>::type>::value &&
+              ExtraConditions<Ts...>::value,
+          typename RetTypeTrait<
+              simplify_if_swizzle_t<typename first_type<Ts...>::type>>::type> {
+};
+#define BUILTIN_CREATE_ENABLER(NAME, RET_TYPE_TRAIT, ELEM_TYPE_CHECKER,        \
+                               SHAPE_CHECKER, EXTRA_CONDITIONS)                \
+  namespace detail {                                                           \
+  template <typename... Ts>                                                    \
+  using NAME##_t =                                                             \
+      typename builtin_enable<RET_TYPE_TRAIT, ELEM_TYPE_CHECKER,               \
+                              SHAPE_CHECKER, EXTRA_CONDITIONS, Ts...>::type;   \
+  }
+} // namespace detail
+} // namespace _V1
+} // namespace sycl
+
+// The headers below are specifically implemented without including all the
+// necessary headers to allow preprocessing them on their own and providing
+// human-friendly result. One can use a command like this to achieve that:
+// clang++ -[DU]__SYCL_DEVICE_ONLY__ -x c++ math_functions.inc  \
+//         -I <..>/llvm/sycl/include -E -o - \
+//     | grep -v '^#' | clang-format > math_functions.{host|device}.ii
+
+#include <sycl/detail/builtins/common_functions.inc>
+#include <sycl/detail/builtins/geometric_functions.inc>
+#include <sycl/detail/builtins/half_precision_math_functions.inc>
+#include <sycl/detail/builtins/integer_functions.inc>
+#include <sycl/detail/builtins/math_functions.inc>
+#include <sycl/detail/builtins/native_math_functions.inc>
+#include <sycl/detail/builtins/relational_functions.inc>
diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 3d06502dee2d9..27c8affa626b1 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -429,8 +429,12 @@ template <typename To, typename From> auto convertFromOpenCLTypeFor(From &&x) {
     using OpenCLType = decltype(convertToOpenCLType(std::declval<To>()));
     static_assert(std::is_same_v<std::remove_reference_t<From>, OpenCLType>);
     static_assert(sizeof(OpenCLType) == sizeof(To));
-    if constexpr (is_vec_v<To> && is_vec_v<From>)
-      return x.template as<To>();
+    using To_noref = std::remove_reference_t<To>;
+    using From_noref = std::remove_reference_t<From>;
+    if constexpr (is_vec_v<To_noref> && is_vec_v<From_noref>)
+      return x.template as<To_noref>();
+    else if constexpr (is_vec_v<To_noref> && is_ext_vector_v<From_noref>)
+      return To_noref{bit_cast<typename To_noref::vector_t>(x)};
     else
       return static_cast<To>(x);
   }
diff --git a/sycl/include/sycl/detail/vector_traits.hpp b/sycl/include/sycl/detail/vector_traits.hpp
index 07fc4b284e104..86592b65c17a3 100644
--- a/sycl/include/sycl/detail/vector_traits.hpp
+++ b/sycl/include/sycl/detail/vector_traits.hpp
@@ -16,7 +16,6 @@ inline namespace _V1 {
 namespace detail {
 
 // 4.10.2.6 Memory layout and alignment
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 // due to MSVC the maximum alignment for sycl::vec is 64 and this proposed
 // change is being brought to the spec committee.
 constexpr size_t MaxVecAlignment = 64;
@@ -29,12 +28,6 @@ struct vector_alignment_impl
           std::integral_constant<size_t,
                                  (std::min)(sizeof(T) * N, MaxVecAlignment)>> {
 };
-#else
-template <typename T, size_t N>
-struct vector_alignment_impl
-    : std::conditional_t<N == 3, std::integral_constant<int, sizeof(T) * 4>,
-                         std::integral_constant<int, sizeof(T) * N>> {};
-#endif
 
 template <typename T, size_t N>
 struct vector_alignment
diff --git a/sycl/include/sycl/half_type.hpp b/sycl/include/sycl/half_type.hpp
index 3d95b582d2d0b..f3a04684c5f58 100644
--- a/sycl/include/sycl/half_type.hpp
+++ b/sycl/include/sycl/half_type.hpp
@@ -259,36 +259,11 @@ using BIsRepresentationT = half;
 // for vec because they are actually defined as an integer type under the
 // hood. As a result half values will be converted to the integer and passed
 // as a kernel argument which is expected to be floating point number.
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 using Vec2StorageT = std::array<StorageT, 2>;
 using Vec3StorageT = std::array<StorageT, 3>;
 using Vec4StorageT = std::array<StorageT, 4>;
 using Vec8StorageT = std::array<StorageT, 8>;
 using Vec16StorageT = std::array<StorageT, 16>;
-#else  // __INTEL_PREVIEW_BREAKING_CHANGES
-template <int NumElements> struct half_vec {
-  alignas(
-      vector_alignment<StorageT, NumElements>::value) StorageT s[NumElements];
-
-  __SYCL_CONSTEXPR_HALF half_vec() : s{0.0f} { initialize_data(); }
-  template <typename... Ts,
-            typename = std::enable_if_t<(sizeof...(Ts) == NumElements) &&
-                                        (std::is_same_v<half, Ts> && ...)>>
-  __SYCL_CONSTEXPR_HALF half_vec(const Ts &...hs) : s{hs...} {}
-
-  constexpr void initialize_data() {
-    for (size_t i = 0; i < NumElements; ++i) {
-      s[i] = StorageT(0.0f);
-    }
-  }
-};
-
-using Vec2StorageT = half_vec<2>;
-using Vec3StorageT = half_vec<3>;
-using Vec4StorageT = half_vec<4>;
-using Vec8StorageT = half_vec<8>;
-using Vec16StorageT = half_vec<16>;
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 #endif // SYCL_DEVICE_ONLY
 
 #ifndef __SYCL_DEVICE_ONLY__
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index d773b8cd1ff1c..58cb1ef10fb27 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -12,10 +12,6 @@
 
 #pragma once
 
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-#include <sycl/detail/generic_type_traits.hpp>
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
 // Check if Clang's ext_vector_type attribute is available. Host compiler
 // may not be Clang, and Clang may not be built with the extension.
 #ifdef __clang__
@@ -30,8 +26,6 @@
 #endif
 #endif // __clang__
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
 #if !defined(__HAS_EXT_VECTOR_TYPE__) && defined(__SYCL_DEVICE_ONLY__)
 #error "SYCL device compiler is built without ext_vector_type support"
 #endif
@@ -40,25 +34,6 @@
 #define __SYCL_USE_EXT_VECTOR_TYPE__
 #endif
 
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-#error "Undefine __SYCL_USE_EXT_VECTOR_TYPE__ macro"
-#endif
-#ifdef __HAS_EXT_VECTOR_TYPE__
-#if defined(__SYCL_DEVICE_ONLY__) || !defined(__NO_EXT_VECTOR_TYPE_ON_HOST__)
-#define __SYCL_USE_EXT_VECTOR_TYPE__
-#endif
-#elif defined(__SYCL_DEVICE_ONLY__)
-// This is a soft error. We expect the device compiler to have ext_vector_type
-// support, but that should not be a hard requirement.
-#error "SYCL device compiler is built without ext_vector_type support"
-#endif // __HAS_EXT_VECTOR_TYPE__
-
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
 #include <sycl/access/access.hpp>              // for decorated, address_space
 #include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
 #include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
@@ -90,15 +65,6 @@
 #include <utility>     // for index_sequence, make_...
 #include <variant>     // for tuple, variant
 
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#ifndef __SYCL_USE_EXT_VECTOR_TYPE__
-#include <sycl/detail/cl.h>
-#endif
-#include <cstring>
-
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
 // 4.10.1: Scalar data types
 // 4.10.2: SYCL vector types
 
@@ -315,30 +281,6 @@ template <typename T> using vec_data = detail::vec_helper<T>;
 template <typename T>
 using vec_data_t = typename detail::vec_helper<T>::RetType;
 
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if defined(_WIN32) && (_MSC_VER)
-// MSVC Compiler doesn't allow using of function arguments with alignment
-// requirements. MSVC Compiler Error C2719: 'parameter': formal parameter with
-// __declspec(align('#')) won't be aligned. The align __declspec modifier
-// is not permitted on function parameters. Function parameter alignment
-// is controlled by the calling convention used.
-// For more information, see Calling Conventions
-// (https://docs.microsoft.com/en-us/cpp/cpp/calling-conventions).
-// For information on calling conventions for x64 processors, see
-// Calling Convention
-// (https://docs.microsoft.com/en-us/cpp/build/x64-calling-convention).
-#pragma message("Alignment of class vec is not in accordance with SYCL \
-specification requirements, a limitation of the MSVC compiler(Error C2719).\
-Requested alignment applied, limited at 64.")
-#define __SYCL_ALIGNED_VAR(type, x, var)                                       \
-  type __declspec(align((x < 64) ? x : 64)) var
-#else
-#define __SYCL_ALIGNED_VAR(type, x, var) alignas(x) type var
-#endif
-
-#endif //! defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
 /// Provides a cross-patform vector class template that works efficiently on
 /// SYCL devices as well as in host C++ code.
 ///
@@ -358,8 +300,6 @@ template <typename Type, int NumElements> class vec {
   static constexpr bool IsBfloat16 =
       std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
   static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
   static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
   static constexpr bool IsSizeGreaterThanMaxAlign =
@@ -381,12 +321,6 @@ template <typename Type, int NumElements> class vec {
   static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
 #endif
 
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-  static constexpr bool IsUsingArrayOnDevice = IsHostHalf || IsBfloat16;
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
   static constexpr int getNumElements() { return NumElements; }
 
   // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
@@ -549,36 +483,16 @@ template <typename Type, int NumElements> class vec {
   using value_type = DataT;
   using rel_t = detail::rel_t<DataT>;
 #ifdef __SYCL_DEVICE_ONLY__
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
   using vector_t =
       typename detail::VecStorage<DataT, NumElements>::VectorDataType;
-#else
-  using vector_t = DataType;
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 #endif // __SYCL_DEVICE_ONLY__
 
   vec() = default;
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
   constexpr vec(const vec &Rhs) = default;
   constexpr vec(vec &&Rhs) = default;
 
   constexpr vec &operator=(const vec &Rhs) = default;
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-  // TODO Remove this difference between host and device side after
-  // when root cause of API incompatibility will be fixed
-#ifdef __SYCL_DEVICE_ONLY__
-  vec(const vec &Rhs) = default;
-  vec &operator=(const vec &Rhs) = default;
-#else
-  constexpr vec(const vec &Rhs) : m_Data(Rhs.m_Data) {}
-  constexpr vec &operator=(const vec &Rhs) = default;
-#endif
-
-  vec(vec &&Rhs) = default;
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
   // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
   template <typename Ty = DataT>
@@ -606,8 +520,6 @@ template <typename Type, int NumElements> class vec {
       typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
 #endif // __SYCL_USE_EXT_VECTOR_TYPE__
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
   template <typename T = void>
   using EnableIfUsingArray =
       typename std::enable_if_t<IsUsingArrayOnDevice || IsUsingArrayOnHost, T>;
@@ -616,7 +528,6 @@ template <typename Type, int NumElements> class vec {
   using EnableIfNotUsingArray =
       typename std::enable_if_t<!IsUsingArrayOnDevice && !IsUsingArrayOnHost,
                                 T>;
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
 #ifdef __SYCL_USE_EXT_VECTOR_TYPE__
 
@@ -729,8 +640,6 @@ template <typename Type, int NumElements> class vec {
       : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
             std::make_index_sequence<NumElements>()} {}
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
 #ifdef __SYCL_DEVICE_ONLY__
   template <typename vector_t_ = vector_t,
             typename =
@@ -754,21 +663,6 @@ template <typename Type, int NumElements> class vec {
   }
 #endif // __SYCL_DEVICE_ONLY__
 
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#ifdef __SYCL_DEVICE_ONLY__
-  template <typename vector_t_ = vector_t,
-            typename =
-                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
-                                          !std::is_same_v<vector_t_, DataT>>>
-  constexpr vec(vector_t openclVector) : m_Data(openclVector) {}
-  operator vector_t() const { return m_Data; }
-#endif
-
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
   // Available only when: NumElements == 1
   template <int N = NumElements>
   operator typename std::enable_if_t<N == 1, DataT>() const {
@@ -826,7 +720,7 @@ template <typename Type, int NumElements> class vec {
     using OpenCLR = detail::ConvertToOpenCLType_t<R>;
     vec<convertT, NumElements> Result;
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES) && defined(__SYCL_DEVICE_ONLY__)
+#if defined(__SYCL_DEVICE_ONLY__)
     using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
     using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
     // Whole vector conversion can only be done, if:
@@ -855,8 +749,7 @@ template <typename Type, int NumElements> class vec {
       Result.m_Data = detail::convertImpl<T, R, roundingMode, NumElements,
                                           OpenCLVecT, OpenCLVecR>(m_Data);
     } else
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES) &&
-       // defined(__SYCL_DEVICE_ONLY__)
+#endif // defined(__SYCL_DEVICE_ONLY__)
     {
       // Otherwise, we fallback to per-element conversion:
       for (size_t I = 0; I < NumElements; ++I) {
@@ -1022,7 +915,6 @@ template <typename Type, int NumElements> class vec {
 #endif
 
 #ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret;                                                                   \
@@ -1054,51 +946,9 @@ template <typename Type, int NumElements> class vec {
     Lhs = Lhs BINOP vec(Rhs);                                                  \
     return Lhs;                                                                \
   }
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
-  template <typename Ty = vec>                                                 \
-  vec operator BINOP(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) const {     \
-    vec Ret;                                                                   \
-    Ret.m_Data = m_Data BINOP Rhs.m_Data;                                      \
-    if constexpr (std::is_same_v<Type, bool> && CONVERT) {                     \
-      Ret.ConvertToDataT();                                                    \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  template <typename Ty = vec>                                                 \
-  vec operator BINOP(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {        \
-    vec Ret;                                                                   \
-    for (size_t I = 0; I < NumElements; ++I) {                                 \
-      Ret.setValue(I, (getValue(I) BINOP Rhs.getValue(I)));                    \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  template <typename T>                                                        \
-  typename std::enable_if_t<                                                   \
-      std::is_convertible_v<DataT, T> &&                                       \
-          (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
-      vec>                                                                     \
-  operator BINOP(const T & Rhs) const {                                        \
-    return *this BINOP vec(static_cast<const DataT &>(Rhs));                   \
-  }                                                                            \
-  vec &operator OPASSIGN(const vec & Rhs) {                                    \
-    *this = *this BINOP Rhs;                                                   \
-    return *this;                                                              \
-  }                                                                            \
-  template <int Num = NumElements>                                             \
-  typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(                \
-      const DataT & Rhs) {                                                     \
-    *this = *this BINOP vec(Rhs);                                              \
-    return *this;                                                              \
-  }
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
 #else // __SYCL_USE_EXT_VECTOR_TYPE__
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret{};                                                                 \
@@ -1126,37 +976,6 @@ template <typename Type, int NumElements> class vec {
     Lhs = Lhs BINOP vec(Rhs);                                                  \
     return Lhs;                                                                \
   }
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
-  vec operator BINOP(const vec &Rhs) const {                                   \
-    vec Ret;                                                                   \
-    for (size_t I = 0; I < NumElements; ++I) {                                 \
-      Ret.setValue(I, (getValue(I) BINOP Rhs.getValue(I)));                    \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  template <typename T>                                                        \
-  typename std::enable_if_t<                                                   \
-      std::is_convertible_v<DataT, T> &&                                       \
-          (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
-      vec>                                                                     \
-  operator BINOP(const T & Rhs) const {                                        \
-    return *this BINOP vec(static_cast<const DataT &>(Rhs));                   \
-  }                                                                            \
-  vec &operator OPASSIGN(const vec & Rhs) {                                    \
-    *this = *this BINOP Rhs;                                                   \
-    return *this;                                                              \
-  }                                                                            \
-  template <int Num = NumElements>                                             \
-  typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(                \
-      const DataT & Rhs) {                                                     \
-    *this = *this BINOP vec(Rhs);                                              \
-    return *this;                                                              \
-  }
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
 #endif // __SYCL_USE_EXT_VECTOR_TYPE__
 
@@ -1189,7 +1008,6 @@ template <typename Type, int NumElements> class vec {
 // Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
 // by SYCL device compiler only.
 #ifdef __SYCL_DEVICE_ONLY__
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 #define __SYCL_RELLOGOP(RELLOGOP)                                              \
   friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
                                                    const vec & Rhs) {          \
@@ -1222,43 +1040,8 @@ template <typename Type, int NumElements> class vec {
                                                    const vec & Rhs) {          \
     return vec(Lhs) RELLOGOP Rhs;                                              \
   }
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  vec<rel_t, NumElements> operator RELLOGOP(const vec & Rhs) const {           \
-    vec<rel_t, NumElements> Ret{};                                             \
-    /* This special case is needed since there are no standard operator||   */ \
-    /* or operator&& functions for std::array.                              */ \
-    if constexpr (IsUsingArrayOnDevice &&                                      \
-                  (std::string_view(#RELLOGOP) == "||" ||                      \
-                   std::string_view(#RELLOGOP) == "&&")) {                     \
-      for (size_t I = 0; I < NumElements; ++I) {                               \
-        /* We cannot use SetValue here as the operator is not a friend of*/    \
-        /* Ret on Windows. */                                                  \
-        Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                    \
-            getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));     \
-      }                                                                        \
-    } else {                                                                   \
-      Ret = vec<rel_t, NumElements>(                                           \
-          (typename vec<rel_t, NumElements>::vector_t)(                        \
-              m_Data RELLOGOP Rhs.m_Data));                                    \
-      if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
-        Ret *= -1;                                                             \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  template <typename T>                                                        \
-  typename std::enable_if_t<std::is_convertible_v<T, DataT> &&                 \
-                                (std::is_fundamental_v<vec_data_t<T>> ||       \
-                                 detail::is_half_or_bf16_v<T>),                \
-                            vec<rel_t, NumElements>>                           \
-  operator RELLOGOP(const T & Rhs) const {                                     \
-    return *this RELLOGOP vec(static_cast<const DataT &>(Rhs));                \
-  }
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 #else
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 #define __SYCL_RELLOGOP(RELLOGOP)                                              \
   friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
                                                    const vec & Rhs) {          \
@@ -1279,27 +1062,6 @@ template <typename Type, int NumElements> class vec {
                                                    const vec & Rhs) {          \
     return vec(Lhs) RELLOGOP Rhs;                                              \
   }
-#else // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  vec<rel_t, NumElements> operator RELLOGOP(const vec & Rhs) const {           \
-    vec<rel_t, NumElements> Ret{};                                             \
-    for (size_t I = 0; I < NumElements; ++I) {                                 \
-      /* We cannot use SetValue here as the operator is not a friend of*/      \
-      /* Ret on Windows. */                                                    \
-      Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                      \
-          getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));       \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  template <typename T>                                                        \
-  typename std::enable_if_t<std::is_convertible_v<T, DataT> &&                 \
-                                (std::is_fundamental_v<vec_data_t<T>> ||       \
-                                 detail::is_half_or_bf16_v<T>),                \
-                            vec<rel_t, NumElements>>                           \
-  operator RELLOGOP(const T & Rhs) const {                                     \
-    return *this RELLOGOP vec(static_cast<const DataT &>(Rhs));                \
-  }
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 #endif
 
   __SYCL_RELLOGOP(==)
@@ -1316,7 +1078,6 @@ template <typename Type, int NumElements> class vec {
 #ifdef __SYCL_UOP
 #error "Undefine __SYCL_UOP macro"
 #endif
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 #define __SYCL_UOP(UOP, OPASSIGN)                                              \
   friend vec &operator UOP(vec & Rhs) {                                        \
     Rhs OPASSIGN vec_data<DataT>::get(1);                                      \
@@ -1327,25 +1088,11 @@ template <typename Type, int NumElements> class vec {
     Lhs OPASSIGN vec_data<DataT>::get(1);                                      \
     return Ret;                                                                \
   }
-#else // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-#define __SYCL_UOP(UOP, OPASSIGN)                                              \
-  vec &operator UOP() {                                                        \
-    *this OPASSIGN vec_data<DataT>::get(1);                                    \
-    return *this;                                                              \
-  }                                                                            \
-  vec operator UOP(int) {                                                      \
-    vec Ret(*this);                                                            \
-    *this OPASSIGN vec_data<DataT>::get(1);                                    \
-    return Ret;                                                                \
-  }
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
   __SYCL_UOP(++, +=)
   __SYCL_UOP(--, -=)
 #undef __SYCL_UOP
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
   // operator~() available only when: dataT != float && dataT != double
   // && dataT != half
   friend vec operator~(const vec &Rhs) {
@@ -1427,110 +1174,6 @@ template <typename Type, int NumElements> class vec {
       return Ret;
     }
   }
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-  // Available only when: dataT != cl_float && dataT != cl_double
-  // && dataT != cl_half
-  template <typename T = DataT>
-  typename std::enable_if_t<std::is_integral_v<vec_data_t<T>>, vec>
-  operator~() const {
-// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
-// by SYCL device compiler only.
-#ifdef __SYCL_DEVICE_ONLY__
-    vec Ret{(typename vec::DataType) ~m_Data};
-    if constexpr (std::is_same_v<Type, bool>) {
-      Ret.ConvertToDataT();
-    }
-    return Ret;
-#else
-    vec Ret{};
-    for (size_t I = 0; I < NumElements; ++I) {
-      Ret.setValue(I, ~getValue(I));
-    }
-    return Ret;
-#endif
-  }
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-  template <typename T = DataT, int N = NumElements>
-  typename std::enable_if_t<std::is_same_v<std::byte, T>, vec<T, N>>
-  operator!() const {
-// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
-// by SYCL device compiler only.
-#ifdef __SYCL_DEVICE_ONLY__
-    return vec<T, N>{(typename vec<T, N>::DataType) !m_Data};
-#else
-    vec<T, N> Ret;
-    for (size_t I = 0; I < N; ++I) {
-      Ret.setValue(I, std::byte{!vec_data<DataT>::get(getValue(I))});
-    }
-    return Ret;
-#endif
-  }
-
-  template <typename T = DataT, int N = NumElements>
-  typename std::enable_if_t<!std::is_same_v<std::byte, T>, vec<T, N>>
-  operator!() const {
-// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
-// by SYCL device compiler only.
-#ifdef __SYCL_DEVICE_ONLY__
-    return vec<T, N>{(typename vec<T, N>::DataType) !m_Data}; // T, N
-#else
-    vec<T, N> Ret;
-    for (size_t I = 0; I < N; ++I) {
-      Ret.setValue(I, !vec_data<DataT>::get(getValue(I)));
-    }
-    return Ret;
-#endif
-  }
-#else // no std::byte
-  template <typename T = DataT, int N = NumElements>
-  vec<T, N> operator!() const {
-#ifdef __SYCL_DEVICE_ONLY__
-    return vec<T, N>{(typename vec<T, N>::DataType) !m_Data}; // T, N
-#else
-    vec<T, N> Ret;
-    for (size_t I = 0; I < N; ++I) {
-      Ret.setValue(I, !vec_data<DataT>::get(getValue(I)));
-    }
-    return Ret;
-#endif
-  }
-#endif // std::byte check
-
-  vec operator+() const {
-// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
-// by SYCL device compiler only.
-#ifdef __SYCL_DEVICE_ONLY__
-    return vec{+m_Data};
-#else
-    vec Ret{};
-    for (size_t I = 0; I < NumElements; ++I)
-      Ret.setValue(I, vec_data<DataT>::get(+vec_data<DataT>::get(getValue(I))));
-    return Ret;
-#endif
-  }
-
-  vec operator-() const {
-// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
-// by SYCL device compiler only.
-#ifdef __SYCL_DEVICE_ONLY__
-    vec Ret{-m_Data};
-    if constexpr (std::is_same_v<Type, bool>) {
-      Ret.ConvertToDataT();
-    }
-    return Ret;
-#else
-    vec Ret{};
-    for (size_t I = 0; I < NumElements; ++I)
-      Ret.setValue(I, vec_data<DataT>::get(-vec_data<DataT>::get(getValue(I))));
-    return Ret;
-#endif
-  }
-
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
   // OP is: &&, ||
   // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
@@ -1609,21 +1252,13 @@ template <typename Type, int NumElements> class vec {
   template <int Num = NumElements,
             typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(int Index, const DataT &Value, int) {
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
     m_Data[Index] = vec_data<DataT>::set(Value);
-#else
-    m_Data.s[Index] = vec_data<DataT>::set(Value);
-#endif
   }
 
   template <int Num = NumElements,
             typename = typename std::enable_if_t<1 != Num>>
   constexpr DataT getValue(int Index, int) const {
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
     return vec_data<DataT>::get(m_Data[Index]);
-#else
-    return vec_data<DataT>::get(m_Data.s[Index]);
-#endif
   }
 #endif // __SYCL_USE_EXT_VECTOR_TYPE__
 
@@ -1655,31 +1290,12 @@ template <typename Type, int NumElements> class vec {
     return (NumElements == 1) ? getValue(Index, 0) : getValue(Index, 0.f);
   }
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
   // fields
 
   // Alignment is the same as size, to a maximum size of 64.
   // detail::vector_alignment will return that value.
   alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
 
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-  // fields
-
-  // Used "__SYCL_ALIGNED_VAR" instead "alignas" to handle MSVC compiler.
-  // For MSVC compiler max alignment is 64, e.g. vec<double, 16> required
-  // alignment of 128 and MSVC compiler cann't align a parameter with requested
-  // alignment of 128. For alignment request larger than 64, 64-alignment
-  // is applied
-  __SYCL_ALIGNED_VAR(DataType,
-                     (detail::vector_alignment<DataT, NumElements>::value),
-                     m_Data);
-
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
   // friends
   template <typename T1, typename T2, typename T3, template <typename> class T4,
             int... T5>
@@ -1895,7 +1511,6 @@ class SwizzleOp {
   __SYCL_UOP(--, -=)
 #undef __SYCL_UOP
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
   template <typename T = DataT>
   friend typename std::enable_if_t<
       std::is_same_v<T, DataT> && std::is_integral_v<vec_data_t<T>>, vec_t>
@@ -1918,31 +1533,7 @@ class SwizzleOp {
     vec_t Tmp = Rhs;
     return -Tmp;
   }
-#else  // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-  template <typename T = DataT>
-  typename std::enable_if_t<std::is_integral_v<vec_data_t<T>>, vec_t>
-  operator~() {
-    vec_t Tmp = *this;
-    return ~Tmp;
-  }
-
-  vec_rel_t operator!() {
-    vec_t Tmp = *this;
-    return !Tmp;
-  }
 
-  vec_t operator+() {
-    vec_t Tmp = *this;
-    return +Tmp;
-  }
-
-  vec_t operator-() {
-    vec_t Tmp = *this;
-    return -Tmp;
-  }
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 // scalar BINOP vec<>
 // scalar BINOP SwizzleOp
 // vec<> BINOP SwizzleOp
@@ -2013,7 +1604,6 @@ class SwizzleOp {
   __SYCL_RELLOGOP(&&)
   __SYCL_RELLOGOP(||)
 #undef __SYCL_RELLOGOP
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
   template <int IdxNum = getNumElements(),
             typename = EnableIfMultipleIndexes<IdxNum>>
@@ -2447,118 +2037,6 @@ class SwizzleOp {
 };
 } // namespace detail
 
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-// scalar BINOP vec<>
-// scalar BINOP SwizzleOp
-// vec<> BINOP SwizzleOp
-#ifdef __SYCL_BINOP
-#error "Undefine __SYCL_BINOP macro"
-#endif
-#define __SYCL_BINOP(BINOP)                                                    \
-  template <typename T, int Num>                                               \
-  typename std::enable_if_t<                                                   \
-      std::is_fundamental_v<vec_data_t<T>> ||                                  \
-          detail::is_half_or_bf16_v<typename std::remove_const_t<T>>,          \
-      vec<T, Num>>                                                             \
-  operator BINOP(const T & Lhs, const vec<T, Num> &Rhs) {                      \
-    return vec<T, Num>(Lhs) BINOP Rhs;                                         \
-  }                                                                            \
-  template <typename VecT, typename OperationLeftT, typename OperationRightT,  \
-            template <typename> class OperationCurrentT, int... Indexes,       \
-            typename T, typename T1 = typename VecT::element_type,             \
-            int Num = sizeof...(Indexes)>                                      \
-  typename std::enable_if_t<                                                   \
-      std::is_convertible_v<T, T1> &&                                          \
-          (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
-      vec<T1, Num>>                                                            \
-  operator BINOP(                                                              \
-      const T & Lhs,                                                           \
-      const detail::SwizzleOp<VecT, OperationLeftT, OperationRightT,           \
-                              OperationCurrentT, Indexes...> &Rhs) {           \
-    vec<T1, Num> Tmp = Rhs;                                                    \
-    return Lhs BINOP Tmp;                                                      \
-  }                                                                            \
-  template <typename VecT, typename OperationLeftT, typename OperationRightT,  \
-            template <typename> class OperationCurrentT, int... Indexes,       \
-            typename T = typename VecT::element_type,                          \
-            int Num = sizeof...(Indexes)>                                      \
-  vec<T, Num> operator BINOP(                                                  \
-      const vec<T, Num> &Lhs,                                                  \
-      const detail::SwizzleOp<VecT, OperationLeftT, OperationRightT,           \
-                              OperationCurrentT, Indexes...> &Rhs) {           \
-    vec<T, Num> Tmp = Rhs;                                                     \
-    return Lhs BINOP Tmp;                                                      \
-  }
-
-__SYCL_BINOP(+)
-__SYCL_BINOP(-)
-__SYCL_BINOP(*)
-__SYCL_BINOP(/)
-__SYCL_BINOP(%)
-__SYCL_BINOP(&)
-__SYCL_BINOP(|)
-__SYCL_BINOP(^)
-__SYCL_BINOP(>>)
-__SYCL_BINOP(<<)
-#undef __SYCL_BINOP
-
-// scalar RELLOGOP vec<>
-// scalar RELLOGOP SwizzleOp
-// vec<> RELLOGOP SwizzleOp
-#ifdef __SYCL_RELLOGOP
-#error "Undefine __SYCL_RELLOGOP macro"
-#endif
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  template <typename T, typename DataT, int Num>                               \
-  typename std::enable_if_t<                                                   \
-      std::is_convertible_v<T, DataT> &&                                       \
-          (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
-      vec<detail::rel_t<DataT>, Num>>                                          \
-  operator RELLOGOP(const T & Lhs, const vec<DataT, Num> &Rhs) {               \
-    return vec<T, Num>(static_cast<T>(Lhs)) RELLOGOP Rhs;                      \
-  }                                                                            \
-  template <typename VecT, typename OperationLeftT, typename OperationRightT,  \
-            template <typename> class OperationCurrentT, int... Indexes,       \
-            typename T, typename T1 = typename VecT::element_type,             \
-            int Num = sizeof...(Indexes)>                                      \
-  typename std::enable_if_t<                                                   \
-      std::is_convertible_v<T, T1> &&                                          \
-          (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
-      vec<detail::rel_t<T1>, Num>>                                             \
-  operator RELLOGOP(                                                           \
-      const T & Lhs,                                                           \
-      const detail::SwizzleOp<VecT, OperationLeftT, OperationRightT,           \
-                              OperationCurrentT, Indexes...> &Rhs) {           \
-    vec<T1, Num> Tmp = Rhs;                                                    \
-    return Lhs RELLOGOP Tmp;                                                   \
-  }                                                                            \
-  template <typename VecT, typename OperationLeftT, typename OperationRightT,  \
-            template <typename> class OperationCurrentT, int... Indexes,       \
-            typename T = typename VecT::element_type,                          \
-            int Num = sizeof...(Indexes)>                                      \
-  vec<detail::rel_t<T>, Num> operator RELLOGOP(                                \
-      const vec<T, Num> &Lhs,                                                  \
-      const detail::SwizzleOp<VecT, OperationLeftT, OperationRightT,           \
-                              OperationCurrentT, Indexes...> &Rhs) {           \
-    vec<T, Num> Tmp = Rhs;                                                     \
-    return Lhs RELLOGOP Tmp;                                                   \
-  }
-
-__SYCL_RELLOGOP(==)
-__SYCL_RELLOGOP(!=)
-__SYCL_RELLOGOP(>)
-__SYCL_RELLOGOP(<)
-__SYCL_RELLOGOP(>=)
-__SYCL_RELLOGOP(<=)
-// TODO: limit to integral types.
-__SYCL_RELLOGOP(&&)
-__SYCL_RELLOGOP(||)
-#undef __SYCL_RELLOGOP
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
 namespace detail {
 
 // Vectors of size 1 are handled separately and therefore 1 is not included in
@@ -2574,8 +2052,6 @@ template <typename T, int N, typename V> struct VecStorage {
   static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
 };
 
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
 #ifdef __SYCL_DEVICE_ONLY__
 // device always has ext vector support, but for huge vectors
 // we switch to std::array, so that we can use a smaller alignment (64)
@@ -2593,56 +2069,13 @@ template <typename T, int N> struct VecStorageImpl {
   using DataType = std::array<T, (N == 3) ? 4 : N>;
 };
 #endif // __SYCL_DEVICE_ONLY__
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-template <typename T, int N> struct VecStorageImpl {
-  using DataType = T __attribute__((ext_vector_type(N)));
-};
-#else
-// When ext_vector_type is not available, we rely on cl_* types from CL/cl.h
-// to represent vec storage.
-template <typename T, int N> struct VecStorageImpl;
-#define __SYCL_DEFINE_VECSTORAGE_IMPL(type, cl_type, num)                      \
-  template <> struct VecStorageImpl<type, num> {                               \
-    using DataType = ::cl_##cl_type##num;                                      \
-  };
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-#ifndef __SYCL_USE_EXT_VECTOR_TYPE__
-#define __SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(type, cl_type)                  \
-  __SYCL_DEFINE_VECSTORAGE_IMPL(type, cl_type, 2)                              \
-  __SYCL_DEFINE_VECSTORAGE_IMPL(type, cl_type, 3)                              \
-  __SYCL_DEFINE_VECSTORAGE_IMPL(type, cl_type, 4)                              \
-  __SYCL_DEFINE_VECSTORAGE_IMPL(type, cl_type, 8)                              \
-  __SYCL_DEFINE_VECSTORAGE_IMPL(type, cl_type, 16)
-
-__SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(std::int8_t, char)
-__SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(std::int16_t, short)
-__SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(std::int32_t, int)
-__SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(std::int64_t, long)
-__SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(std::uint8_t, uchar)
-__SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(std::uint16_t, ushort)
-__SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(std::uint32_t, uint)
-__SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(std::uint64_t, ulong)
-__SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(float, float)
-__SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE(double, double)
-
-#undef __SYCL_DEFINE_VECSTORAGE_IMPL_FOR_TYPE
-#undef __SYCL_DEFINE_VECSTORAGE_IMPL
-#endif // ifndef __SYCL_USE_EXT_VECTOR_TYPE__
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
 // Single element bool
 template <> struct VecStorage<bool, 1, void> {
   using DataType = bool;
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #ifdef __SYCL_DEVICE_ONLY__
   using VectorDataType = bool;
 #endif // __SYCL_DEVICE_ONLY__
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 };
 
 // Multiple element bool
@@ -2652,14 +2085,12 @@ struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
       typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
                                                 std::int32_t, std::int64_t>,
                               N>::DataType;
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #ifdef __SYCL_DEVICE_ONLY__
   using VectorDataType =
       typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
                                                 std::int32_t, std::int64_t>,
                               N>::VectorDataType;
 #endif // __SYCL_DEVICE_ONLY__
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 };
 
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
@@ -2667,40 +2098,28 @@ struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
 // specialization.
 template <> struct VecStorage<std::byte, 1, void> {
   using DataType = std::int8_t;
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #ifdef __SYCL_DEVICE_ONLY__
   using VectorDataType = std::int8_t;
 #endif // __SYCL_DEVICE_ONLY__
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 };
 #endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
 
 // Single element signed integers
 template <typename T>
 struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-  using DataType = select_apply_cl_t<T, std::int8_t, std::int16_t, std::int32_t,
-                                     std::int64_t>;
-#else // __INTEL_PREVIEW_BREAKING_CHANGES
   using DataType = T;
 #ifdef __SYCL_DEVICE_ONLY__
   using VectorDataType = DataType;
 #endif // __SYCL_DEVICE_ONLY__
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 };
 
 // Single element unsigned integers
 template <typename T>
 struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-  using DataType = select_apply_cl_t<T, std::uint8_t, std::uint16_t,
-                                     std::uint32_t, std::uint64_t>;
-#else // __INTEL_PREVIEW_BREAKING_CHANGES
   using DataType = T;
 #ifdef __SYCL_DEVICE_ONLY__
   using VectorDataType = DataType;
 #endif // __SYCL_DEVICE_ONLY__
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 };
 
 // Single element floating-point (except half/bfloat16)
@@ -2709,11 +2128,9 @@ struct VecStorage<
     T, 1,
     typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
   using DataType = T;
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #ifdef __SYCL_DEVICE_ONLY__
   using VectorDataType = DataType;
 #endif // __SYCL_DEVICE_ONLY__
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 };
 // Multiple elements signed/unsigned integers and floating-point (except
 // half/bfloat16)
@@ -2725,40 +2142,34 @@ struct VecStorage<
                                (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
   using DataType =
       typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #ifdef __SYCL_DEVICE_ONLY__
   using VectorDataType =
       typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
                               N>::VectorDataType;
 #endif // __SYCL_DEVICE_ONLY__
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 };
 
 // Single element half
 template <> struct VecStorage<half, 1, void> {
   using DataType = sycl::detail::half_impl::StorageT;
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #ifdef __SYCL_DEVICE_ONLY__
   using VectorDataType = sycl::detail::half_impl::StorageT;
 #endif // __SYCL_DEVICE_ONLY__
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 };
 
 // Multiple elements half
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES) && defined(__SYCL_DEVICE_ONLY__)
+#if defined(__SYCL_DEVICE_ONLY__)
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
     using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
     using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
   };
-#else // defined(__INTEL_PREVIEW_BREAKING_CHANGES) &&
-      // defined(__SYCL_DEVICE_ONLY__)
+#else // defined(__SYCL_DEVICE_ONLY__)
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
     using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
   };
-#endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES) &&
-       // defined(__SYCL_DEVICE_ONLY__)
+#endif // defined(__SYCL_DEVICE_ONLY__)
 
 __SYCL_DEFINE_HALF_VECSTORAGE(2)
 __SYCL_DEFINE_HALF_VECSTORAGE(3)
@@ -2936,7 +2347,3 @@ struct CheckDeviceCopyable<
 
 } // namespace _V1
 } // namespace sycl
-
-#if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-#undef __SYCL_ALIGNED_VAR
-#endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
diff --git a/sycl/test-e2e/Basic/sycl_2020_images/common.hpp b/sycl/test-e2e/Basic/sycl_2020_images/common.hpp
index 875a3199ca15c..47c75235fbc3b 100644
--- a/sycl/test-e2e/Basic/sycl_2020_images/common.hpp
+++ b/sycl/test-e2e/Basic/sycl_2020_images/common.hpp
@@ -266,7 +266,7 @@ template <typename T, int Dims> bool AllTrue(const vec<T, Dims> &Vec) {
 
 template <typename T, int Dims>
 bool ApproxEq(const vec<T, Dims> &LHS, const vec<T, Dims> &RHS,
-              float Precision = 0.1) {
+              T Precision = 0.1) {
   return AllTrue(sycl::abs(LHS - RHS) <= Precision);
 }
 
diff --git a/sycl/test-e2e/bindless_images/array/read_write_unsampled_array.cpp b/sycl/test-e2e/bindless_images/array/read_write_unsampled_array.cpp
index 48bed3956d4ec..336f1e2e0d6b9 100644
--- a/sycl/test-e2e/bindless_images/array/read_write_unsampled_array.cpp
+++ b/sycl/test-e2e/bindless_images/array/read_write_unsampled_array.cpp
@@ -6,7 +6,9 @@
 #include "../bindless_helpers.hpp"
 #include <iostream>
 #include <random>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 #include <type_traits>
 
 static sycl::device dev;
diff --git a/sycl/test-e2e/bindless_images/bindless_helpers.hpp b/sycl/test-e2e/bindless_images/bindless_helpers.hpp
index 29770196ff2d0..3a89016181bbe 100644
--- a/sycl/test-e2e/bindless_images/bindless_helpers.hpp
+++ b/sycl/test-e2e/bindless_images/bindless_helpers.hpp
@@ -1,6 +1,8 @@
 #pragma once
 #include <random>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 namespace bindless_helpers {
 
diff --git a/sycl/test-e2e/bindless_images/image_get_info.cpp b/sycl/test-e2e/bindless_images/image_get_info.cpp
index 931332b928cb4..75b58c51b4bee 100644
--- a/sycl/test-e2e/bindless_images/image_get_info.cpp
+++ b/sycl/test-e2e/bindless_images/image_get_info.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/mipmap/mipmap_read_1D.cpp b/sycl/test-e2e/bindless_images/mipmap/mipmap_read_1D.cpp
index cc896e36dd0c5..1060fc317974a 100644
--- a/sycl/test-e2e/bindless_images/mipmap/mipmap_read_1D.cpp
+++ b/sycl/test-e2e/bindless_images/mipmap/mipmap_read_1D.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/mipmap/mipmap_read_2D.cpp b/sycl/test-e2e/bindless_images/mipmap/mipmap_read_2D.cpp
index 5b24e5a170c72..615b5a58aaf2e 100644
--- a/sycl/test-e2e/bindless_images/mipmap/mipmap_read_2D.cpp
+++ b/sycl/test-e2e/bindless_images/mipmap/mipmap_read_2D.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/mipmap/mipmap_read_3D.cpp b/sycl/test-e2e/bindless_images/mipmap/mipmap_read_3D.cpp
index 289f1d7c95486..d328816c2c35b 100644
--- a/sycl/test-e2e/bindless_images/mipmap/mipmap_read_3D.cpp
+++ b/sycl/test-e2e/bindless_images/mipmap/mipmap_read_3D.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_1D.cpp b/sycl/test-e2e/bindless_images/read_1D.cpp
index 95260f6daa773..f1e06c1f31039 100644
--- a/sycl/test-e2e/bindless_images/read_1D.cpp
+++ b/sycl/test-e2e/bindless_images/read_1D.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_2D.cpp b/sycl/test-e2e/bindless_images/read_2D.cpp
index 835a83cb7a28a..16172689db604 100644
--- a/sycl/test-e2e/bindless_images/read_2D.cpp
+++ b/sycl/test-e2e/bindless_images/read_2D.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_2D_dynamic.cpp b/sycl/test-e2e/bindless_images/read_2D_dynamic.cpp
index e7e3b436bd677..1894a55baf403 100644
--- a/sycl/test-e2e/bindless_images/read_2D_dynamic.cpp
+++ b/sycl/test-e2e/bindless_images/read_2D_dynamic.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_3D.cpp b/sycl/test-e2e/bindless_images/read_3D.cpp
index 009ec83351cd1..d607929fcc21d 100644
--- a/sycl/test-e2e/bindless_images/read_3D.cpp
+++ b/sycl/test-e2e/bindless_images/read_3D.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_norm_types.cpp b/sycl/test-e2e/bindless_images/read_norm_types.cpp
index 646fe6918b694..a92ffa248a5ac 100644
--- a/sycl/test-e2e/bindless_images/read_norm_types.cpp
+++ b/sycl/test-e2e/bindless_images/read_norm_types.cpp
@@ -6,7 +6,9 @@
 
 #include <iostream>
 #include <limits>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_sampled.cpp b/sycl/test-e2e/bindless_images/read_sampled.cpp
index d07403f2f69ff..7fd65efd0c034 100644
--- a/sycl/test-e2e/bindless_images/read_sampled.cpp
+++ b/sycl/test-e2e/bindless_images/read_sampled.cpp
@@ -18,7 +18,9 @@
 #include <cassert>
 #include <iostream>
 #include <random>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 namespace syclexp = sycl::ext::oneapi::experimental;
 
diff --git a/sycl/test-e2e/bindless_images/read_write_1D.cpp b/sycl/test-e2e/bindless_images/read_write_1D.cpp
index e1ab02ba9f995..0b9fb7cb396bd 100644
--- a/sycl/test-e2e/bindless_images/read_write_1D.cpp
+++ b/sycl/test-e2e/bindless_images/read_write_1D.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_write_1D_subregion.cpp b/sycl/test-e2e/bindless_images/read_write_1D_subregion.cpp
index 3c1a9e964c775..ac902daf5587c 100644
--- a/sycl/test-e2e/bindless_images/read_write_1D_subregion.cpp
+++ b/sycl/test-e2e/bindless_images/read_write_1D_subregion.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_write_2D.cpp b/sycl/test-e2e/bindless_images/read_write_2D.cpp
index 6320288e8f373..eb8b4d3e71adb 100644
--- a/sycl/test-e2e/bindless_images/read_write_2D.cpp
+++ b/sycl/test-e2e/bindless_images/read_write_2D.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_write_2D_subregion.cpp b/sycl/test-e2e/bindless_images/read_write_2D_subregion.cpp
index 49def4bce9d4a..0c56f1779527c 100644
--- a/sycl/test-e2e/bindless_images/read_write_2D_subregion.cpp
+++ b/sycl/test-e2e/bindless_images/read_write_2D_subregion.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_write_3D.cpp b/sycl/test-e2e/bindless_images/read_write_3D.cpp
index 75f9f8e916df7..3c404aed23962 100644
--- a/sycl/test-e2e/bindless_images/read_write_3D.cpp
+++ b/sycl/test-e2e/bindless_images/read_write_3D.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_write_3D_subregion.cpp b/sycl/test-e2e/bindless_images/read_write_3D_subregion.cpp
index dd00fdc26e2b2..ab86ec1ecf20a 100644
--- a/sycl/test-e2e/bindless_images/read_write_3D_subregion.cpp
+++ b/sycl/test-e2e/bindless_images/read_write_3D_subregion.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/read_write_unsampled.cpp b/sycl/test-e2e/bindless_images/read_write_unsampled.cpp
index 22955f3ba3c88..c717c5795bf51 100644
--- a/sycl/test-e2e/bindless_images/read_write_unsampled.cpp
+++ b/sycl/test-e2e/bindless_images/read_write_unsampled.cpp
@@ -6,7 +6,9 @@
 
 #include "bindless_helpers.hpp"
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 #include <type_traits>
 
 static sycl::device dev;
diff --git a/sycl/test-e2e/bindless_images/sampling_2D.cpp b/sycl/test-e2e/bindless_images/sampling_2D.cpp
index ac340a654f135..4dbd8418b7a0b 100644
--- a/sycl/test-e2e/bindless_images/sampling_2D.cpp
+++ b/sycl/test-e2e/bindless_images/sampling_2D.cpp
@@ -5,7 +5,10 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
+#include <sycl/usm.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/sampling_2D_USM_shared.cpp b/sycl/test-e2e/bindless_images/sampling_2D_USM_shared.cpp
index bd7401598dd3e..be5989eeff072 100644
--- a/sycl/test-e2e/bindless_images/sampling_2D_USM_shared.cpp
+++ b/sycl/test-e2e/bindless_images/sampling_2D_USM_shared.cpp
@@ -7,7 +7,10 @@
 
 #include <cmath>
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
+#include <sycl/usm.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/sampling_2D_half.cpp b/sycl/test-e2e/bindless_images/sampling_2D_half.cpp
index 07d364229702c..2576444df6bfe 100644
--- a/sycl/test-e2e/bindless_images/sampling_2D_half.cpp
+++ b/sycl/test-e2e/bindless_images/sampling_2D_half.cpp
@@ -6,7 +6,10 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
+#include <sycl/usm.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/sampling_3D.cpp b/sycl/test-e2e/bindless_images/sampling_3D.cpp
index 63dd1d930157e..35b0096111673 100644
--- a/sycl/test-e2e/bindless_images/sampling_3D.cpp
+++ b/sycl/test-e2e/bindless_images/sampling_3D.cpp
@@ -5,7 +5,9 @@
 // RUN: %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/sampling_unique_addr_modes.cpp b/sycl/test-e2e/bindless_images/sampling_unique_addr_modes.cpp
index 431e22869d055..5356f4fa1d129 100644
--- a/sycl/test-e2e/bindless_images/sampling_unique_addr_modes.cpp
+++ b/sycl/test-e2e/bindless_images/sampling_unique_addr_modes.cpp
@@ -5,7 +5,9 @@
 // RUN: %{run} %t.out
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Uncomment to print additional test information
 // #define VERBOSE_PRINT
diff --git a/sycl/test-e2e/bindless_images/user_types/mipmap_read_user_type_2D.cpp b/sycl/test-e2e/bindless_images/user_types/mipmap_read_user_type_2D.cpp
index 3d2e863c5048e..b8a17e99c3bef 100644
--- a/sycl/test-e2e/bindless_images/user_types/mipmap_read_user_type_2D.cpp
+++ b/sycl/test-e2e/bindless_images/user_types/mipmap_read_user_type_2D.cpp
@@ -9,7 +9,9 @@
 
 #include "user_types_common.hpp"
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 // Returns true if test case was passed and validated
 template <typename MyType, int NElems, typename OutType,
diff --git a/sycl/test-e2e/bindless_images/user_types/read_write_user_type.cpp b/sycl/test-e2e/bindless_images/user_types/read_write_user_type.cpp
index 11bfcbf91d19c..a96dd42496ccb 100644
--- a/sycl/test-e2e/bindless_images/user_types/read_write_user_type.cpp
+++ b/sycl/test-e2e/bindless_images/user_types/read_write_user_type.cpp
@@ -9,7 +9,9 @@
 
 #include "user_types_common.hpp"
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 template <typename MyType, int NElems, typename OutType,
           sycl::image_channel_order ChannelOrder,
diff --git a/sycl/test-e2e/bindless_images/user_types/user_types_common.hpp b/sycl/test-e2e/bindless_images/user_types/user_types_common.hpp
index 8fa9c1538ae86..fde9860d1c03c 100644
--- a/sycl/test-e2e/bindless_images/user_types/user_types_common.hpp
+++ b/sycl/test-e2e/bindless_images/user_types/user_types_common.hpp
@@ -2,7 +2,9 @@
 // multiple tests that use user-defined types
 
 #include <iostream>
-#include <sycl/sycl.hpp>
+#include <sycl/detail/core.hpp>
+
+#include <sycl/ext/oneapi/bindless_images.hpp>
 
 void printTestName(std::string name) {
 #ifdef VERBOSE_PRINT
diff --git a/sycl/test/basic_tests/types.cpp b/sycl/test/basic_tests/types.cpp
index 14a1070567274..8b7488a6b1d5c 100644
--- a/sycl/test/basic_tests/types.cpp
+++ b/sycl/test/basic_tests/types.cpp
@@ -22,7 +22,6 @@ template <typename T, int N> inline void checkVectorSizeAndAlignment() {
   using VectorT = s::vec<T, N>;
   constexpr auto RealLength = (N != 3 ? N : 4);
   static_assert(sizeof(VectorT) == (sizeof(T) * RealLength), "");
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 
   // SYCL 2020 spec says that alignment is supposed to be same as size,
   // but MSVC won't allow an alignment of anything larger than 64 for
@@ -34,19 +33,6 @@ template <typename T, int N> inline void checkVectorSizeAndAlignment() {
   else
     static_assert(alignof(VectorT) == 64,
                   "huge vectors should have a maximum alignment of 64");
-
-#else // __INTEL_PREVIEW_BREAKING_CHANGES
-
-#if defined(_WIN32) && (_MSC_VER) &&                                           \
-    defined(__NO_EXT_VECTOR_TYPE_ON_HOST__) && !defined(__SYCL_DEVICE_ONLY__)
-  // See comments around __SYCL_ALIGNED_VAR macro definition in types.hpp
-  // We can't enforce proper alignment of "huge" vectors (>64 bytes) on Windows
-  // and the test exposes this limitation.
-  if constexpr (alignof(T) * RealLength < 64)
-#endif
-    static_assert(alignof(VectorT) == (alignof(T) * RealLength), "");
-
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 }
 
 template <typename T> inline void checkVectorsWithN() {
@@ -132,13 +118,8 @@ std::string vec2string(const sycl::vec<vecType, numOfElems> &vec) {
 template <typename T, typename Expected> inline void checkVecNotReturnType() {
   constexpr int N = 4;
   using Vector = sycl::vec<T, N>;
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
   using ExpectedVector = sycl::vec<Expected, N>;
   using OpNotResult = decltype(operator!(std::declval<Vector>()));
-#else
-  using ExpectedVector = sycl::vec<T, N>;
-  using OpNotResult = decltype(std::declval<Vector>().operator!());
-#endif
   static_assert(std::is_same_v<OpNotResult, ExpectedVector>,
                 "Incorrect operator! return type");
 }
diff --git a/sycl/test/conf.txt b/sycl/test/conf.txt
new file mode 100644
index 0000000000000..9446e0fad62b2
--- /dev/null
+++ b/sycl/test/conf.txt
@@ -0,0 +1 @@
+SYCL_PRINT_EXECUTION_GRAPH=after_addCopyBack #comment
diff --git a/sycl/test/extensions/annotated_ptr/annotated_ptr.cpp b/sycl/test/extensions/annotated_ptr/annotated_ptr.cpp
index 66002408c3d19..d010278535493 100644
--- a/sycl/test/extensions/annotated_ptr/annotated_ptr.cpp
+++ b/sycl/test/extensions/annotated_ptr/annotated_ptr.cpp
@@ -175,10 +175,6 @@ void TestVectorAddWithAnnotatedMMHosts() {
     int a;
   };
   g g0, g1;
-  // TODO: these notes shouldn't be emitted
-  // expected-note@sycl/types.hpp:* {{candidate template ignored: could not match 'vec<T, Num>'}}
-  // expected-note@sycl/types.hpp:* {{candidate template ignored: could not match 'detail::SwizzleOp}}
-  // expected-note@sycl/types.hpp:* {{candidate template ignored: could not match 'vec<T, Num>'}}
   // expected-error@+1 {{invalid operands to binary expression}}
   auto g2 = g0 + g1;
 
diff --git a/sycl/test_bfloat.cpp b/sycl/test_bfloat.cpp
new file mode 100644
index 0000000000000..d143ac5caf899
--- /dev/null
+++ b/sycl/test_bfloat.cpp
@@ -0,0 +1,27 @@
+#include <sycl/sycl.hpp>
+
+int main() {
+    // Create a SYCL queue
+    cl::sycl::queue queue;
+
+    sycl::vec<sycl::ext::oneapi::bfloat16, 1> data{1};
+
+    // Create a buffer from the vector
+    cl::sycl::buffer<float, 1> buffer(data.data(), data.size());
+
+    // Submit a command group to the queue
+    queue.submit(& {
+        // Get access to the buffer
+        auto accessor = buffer.get_access<cl::sycl::access::mode::read_write>(cgh);
+
+        // Define the kernel
+        cgh.parallel_for<class bfloat16_vector>(cl::sycl::range<1>(data.size()), = {
+            accessor[i] += 2.0f;
+        });
+    });
+
+    // Wait for all operations to complete
+    queue.wait_and_throw();
+
+    return 0;
+}

From 459e66d5e215e19b5348a26ce4a5826fc16aa565 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 3 Apr 2024 08:54:41 -0700
Subject: [PATCH 02/79] Initial cleanup

---
 .../sycl/detail/generic_type_traits.hpp       |  11 +-
 sycl/include/sycl/half_type.hpp               |   6 +
 sycl/include/sycl/types.hpp                   | 128 +++++++-----------
 sycl/test/abi/layout_vec.cpp                  |   6 +-
 4 files changed, 64 insertions(+), 87 deletions(-)

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 27c8affa626b1..31a0b59dee6fa 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -367,11 +367,12 @@ template <typename T> auto convertToOpenCLType(T &&x) {
     // TODO: for some mysterious reasons on NonUniformGroups E2E tests fail if
     // we use the "else" version only. I suspect that's an issues with
     // non-uniform groups implementation.
-    if constexpr (std::is_same_v<MatchingVec, no_ref>)
-      return static_cast<typename MatchingVec::vector_t>(x);
-    else
-      return static_cast<typename MatchingVec::vector_t>(
-          x.template as<MatchingVec>());
+    if constexpr (std::is_same_v<MatchingVec, no_ref>) {
+      return bit_cast<typename no_ref::vector_t>(x);
+    }
+    else {
+      return bit_cast<typename MatchingVec::vector_t>(x);
+    }
 #else
     return x.template as<MatchingVec>();
 #endif
diff --git a/sycl/include/sycl/half_type.hpp b/sycl/include/sycl/half_type.hpp
index f3a04684c5f58..0c22f309bd4e0 100644
--- a/sycl/include/sycl/half_type.hpp
+++ b/sycl/include/sycl/half_type.hpp
@@ -249,6 +249,12 @@ using Vec3StorageT = StorageT __attribute__((ext_vector_type(3)));
 using Vec4StorageT = StorageT __attribute__((ext_vector_type(4)));
 using Vec8StorageT = StorageT __attribute__((ext_vector_type(8)));
 using Vec16StorageT = StorageT __attribute__((ext_vector_type(16)));
+
+using Vec2DeviceStorageT = std::array<StorageT, 2>;
+using Vec3DeviceStorageT = std::array<StorageT, 4>;
+using Vec4DeviceStorageT = std::array<StorageT, 4>;
+using Vec8DeviceStorageT = std::array<StorageT, 8>;
+using Vec16DeviceStorageT = std::array<StorageT, 16>;
 #else // SYCL_DEVICE_ONLY
 using StorageT = detail::host_half_impl::half;
 // No need to extract underlying data type for built-in functions operating on
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 58cb1ef10fb27..159fcefaa4aa3 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -30,10 +30,6 @@
 #error "SYCL device compiler is built without ext_vector_type support"
 #endif
 
-#if defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_USE_EXT_VECTOR_TYPE__
-#endif
-
 #include <sycl/access/access.hpp>              // for decorated, address_space
 #include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
 #include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
@@ -310,14 +306,12 @@ template <typename Type, int NumElements> class vec {
   // vector extension. This is for MSVC compatibility, which has a max alignment
   // of 64 for direct params. If we drop MSVC, we can have alignment the same as
   // size and use vector extensions for all sizes.
-  static constexpr bool IsUsingArrayOnDevice =
-      (IsHostHalf || IsBfloat16 || IsSizeGreaterThanMaxAlign);
+  static constexpr bool IsUsingArrayOnDevice = true;
 
+  static constexpr bool NativeVec = false;
 #if defined(__SYCL_DEVICE_ONLY__)
-  static constexpr bool NativeVec = NumElements > 1 && !IsUsingArrayOnDevice;
   static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
 #else
-  static constexpr bool NativeVec = false;
   static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
 #endif
 
@@ -504,13 +498,12 @@ template <typename Type, int NumElements> class vec {
     return *this;
   }
 
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+#ifdef __SYCL_DEVICE_ONLY__
+  // This should always be true for device code using sycl::half.
+  // TODO: We should remove this and its uses.
   template <typename T = void>
   using EnableIfNotHostHalf = typename std::enable_if_t<!IsHostHalf, T>;
 
-  template <typename T = void>
-  using EnableIfHostHalf = typename std::enable_if_t<IsHostHalf, T>;
-
   template <typename T = void>
   using EnableIfUsingArrayOnDevice =
       typename std::enable_if_t<IsUsingArrayOnDevice, T>;
@@ -518,18 +511,6 @@ template <typename Type, int NumElements> class vec {
   template <typename T = void>
   using EnableIfNotUsingArrayOnDevice =
       typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  template <typename T = void>
-  using EnableIfUsingArray =
-      typename std::enable_if_t<IsUsingArrayOnDevice || IsUsingArrayOnHost, T>;
-
-  template <typename T = void>
-  using EnableIfNotUsingArray =
-      typename std::enable_if_t<!IsUsingArrayOnDevice && !IsUsingArrayOnHost,
-                                T>;
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
 
   template <typename Ty = DataT>
   explicit constexpr vec(const EnableIfNotUsingArrayOnDevice<Ty> &arg)
@@ -556,13 +537,14 @@ template <typename Type, int NumElements> class vec {
       std::is_fundamental_v<vec_data_t<Ty>> ||
           detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
+  // TODO: Can we use std::fill or something similar to vectorize assignment operation?
   operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
     }
     return *this;
   }
-#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+#else  // __SYCL_DEVICE_ONLY__
   explicit constexpr vec(const DataT &arg)
       : vec{detail::RepeatValue<NumElements>(
                 static_cast<vec_data_t<DataT>>(arg)),
@@ -579,9 +561,9 @@ template <typename Type, int NumElements> class vec {
     }
     return *this;
   }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+#endif // __SYCL_DEVICE_ONLY__
 
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+#ifdef __SYCL_DEVICE_ONLY__
   // Optimized naive constructors with NumElements of DataT values.
   // We don't expect compilers to optimize vararg recursive functions well.
 
@@ -630,7 +612,7 @@ template <typename Type, int NumElements> class vec {
                vec_data<Ty>::get(ArgA), vec_data<Ty>::get(ArgB),
                vec_data<Ty>::get(ArgC), vec_data<Ty>::get(ArgD),
                vec_data<Ty>::get(ArgE), vec_data<Ty>::get(ArgF)} {}
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+#endif // __SYCL_DEVICE_ONLY__
 
   // Constructor from values of base type or vec of base type. Checks that
   // base types are match and that the NumElements == sum of lengths of args.
@@ -646,18 +628,21 @@ template <typename Type, int NumElements> class vec {
                 typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
                                           !std::is_same_v<vector_t_, DataT>>>
   constexpr vec(vector_t openclVector) {
-    if constexpr (!IsUsingArrayOnDevice) {
-      m_Data = openclVector;
-    } else {
+      static_assert(sizeof(vector_t) == sizeof(DataType),
+                    "Size of OpenCL vector type doesn't match size of vec");
       m_Data = bit_cast<DataType>(openclVector);
-    }
   }
 
+  /* @SYCL2020
+   * Available only when: compiled for the device.
+   * Converts this SYCL vec instance to the underlying backend-native vector type
+   * defined by vector_t.
+   */
   operator vector_t() const {
-    if constexpr (!IsUsingArrayOnDevice) {
+    if constexpr (NumElements == 1) {
       return m_Data;
     } else {
-      auto ptr = bit_cast<const vector_t *>((&m_Data)->data());
+      auto ptr = bit_cast<const vector_t *>(m_Data.data());
       return *ptr;
     }
   }
@@ -914,16 +899,21 @@ template <typename Type, int NumElements> class vec {
 #error "Undefine __SYCL_BINOP macro"
 #endif
 
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+#ifdef __SYCL_DEVICE_ONLY__
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret;                                                                   \
-    if constexpr (IsUsingArrayOnDevice) {                                      \
+    if constexpr (IsBfloat16 || std::is_same_v<DataT, sycl::detail::half_impl::half>) {                                      \
       for (size_t I = 0; I < NumElements; ++I) {                               \
         Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
       }                                                                        \
     } else {                                                                   \
-      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+      vector_t ExtVecLhs = bit_cast<vector_t>(Lhs.m_Data);                     \
+      vector_t ExtVecRhs = bit_cast<vector_t>(Rhs.m_Data);                     \
+      Ret = vec<DataT, NumElements>(                                           \
+          (typename vec<DataT, NumElements>::vector_t)(                        \
+              ExtVecLhs BINOP ExtVecRhs));                                     \
+      /*[Udit] Do we still need this? */                                       \
       if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
         Ret.ConvertToDataT();                                                  \
       }                                                                        \
@@ -947,7 +937,7 @@ template <typename Type, int NumElements> class vec {
     return Lhs;                                                                \
   }
 
-#else // __SYCL_USE_EXT_VECTOR_TYPE__
+#else // __SYCL_DEVICE_ONLY__
 
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
@@ -977,7 +967,7 @@ template <typename Type, int NumElements> class vec {
     return Lhs;                                                                \
   }
 
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+#endif // __SYCL_DEVICE_ONLY__
 
   __SYCL_BINOP(+, +=, true)
   __SYCL_BINOP(-, -=, true)
@@ -1012,11 +1002,9 @@ template <typename Type, int NumElements> class vec {
   friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
                                                    const vec & Rhs) {          \
     vec<rel_t, NumElements> Ret{};                                             \
-    /* This special case is needed since there are no standard operator||   */ \
-    /* or operator&& functions for std::array.                              */ \
-    if constexpr (IsUsingArrayOnDevice &&                                      \
-                  (std::string_view(#RELLOGOP) == "||" ||                      \
-                   std::string_view(#RELLOGOP) == "&&")) {                     \
+    /* ext_vector_type does not support bfloat16 or half, so for these   */    \
+    /* we do element-by-element operation on the underlying std::array.  */    \
+    if constexpr (IsBfloat16 || std::is_same_v<DataT, sycl::detail::half_impl::half>) {                                  \
       for (size_t I = 0; I < NumElements; ++I) {                               \
         /* We cannot use SetValue here as the operator is not a friend of*/    \
         /* Ret on Windows. */                                                  \
@@ -1024,9 +1012,11 @@ template <typename Type, int NumElements> class vec {
             Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
       }                                                                        \
     } else {                                                                   \
+      vector_t ExtVecLhs = bit_cast<vector_t>(Lhs.m_Data);                     \
+      vector_t ExtVecRhs = bit_cast<vector_t>(Rhs.m_Data);                     \
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
-              Lhs.m_Data RELLOGOP Rhs.m_Data));                                \
+              ExtVecLhs RELLOGOP ExtVecRhs));                                  \
       if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
         Ret *= -1;                                                             \
     }                                                                          \
@@ -1185,29 +1175,18 @@ template <typename Type, int NumElements> class vec {
 private:
   // Generic method that execute "Operation" on underlying values.
 
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  template <template <typename> class Operation,
-            typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements>
-  operatorHelper(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataType> Op;
-    Result.m_Data = Op(m_Data, Rhs.m_Data);
-    return Result;
-  }
-
+#ifdef __SYCL_DEVICE_ONLY__
   template <template <typename> class Operation,
             typename Ty = vec<DataT, NumElements>>
   vec<DataT, NumElements>
   operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
     vec<DataT, NumElements> Result;
     Operation<DataT> Op;
-    for (size_t I = 0; I < NumElements; ++I) {
-      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
-    }
+    auto OpResult = Op(bit_cast<vector_t>(m_Data), bit_cast<vector_t>(Rhs.m_Data));
+    Result.m_Data = bit_cast<DataType>(OpResult);
     return Result;
   }
-#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+#else  // __SYCL_DEVICE_ONLY__
   template <template <typename> class Operation>
   vec<DataT, NumElements>
   operatorHelper(const vec<DataT, NumElements> &Rhs) const {
@@ -1218,12 +1197,12 @@ template <typename Type, int NumElements> class vec {
     }
     return Result;
   }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+#endif // __SYCL_DEVICE_ONLY__
 
   // setValue and getValue should be able to operate on different underlying
   // types: enum cl_float#N , builtin vector float#N, builtin type float.
   // These versions are for N > 1.
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+#ifdef __SYCL_DEVICE_ONLY__
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
@@ -1236,19 +1215,7 @@ template <typename Type, int NumElements> class vec {
   constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
     return vec_data<DataT>::get(m_Data[Index]);
   }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
-    m_Data.s[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
-    return vec_data<DataT>::get(m_Data.s[Index]);
-  }
-#else // __SYCL_USE_EXT_VECTOR_TYPE__
+#else // __SYCL_DEVICE_ONLY__
   template <int Num = NumElements,
             typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(int Index, const DataT &Value, int) {
@@ -1260,7 +1227,7 @@ template <typename Type, int NumElements> class vec {
   constexpr DataT getValue(int Index, int) const {
     return vec_data<DataT>::get(m_Data[Index]);
   }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+#endif // __SYCL_DEVICE_ONLY__
 
   // N==1 versions, used by host and device. Shouldn't trailing type be int?
   template <int Num = NumElements,
@@ -2059,9 +2026,10 @@ template <typename T, int N, typename V> struct VecStorage {
 template <typename T, int N> struct VecStorageImpl {
   static constexpr size_t Num = (N == 3) ? 4 : N;
   static constexpr size_t Sz = Num * sizeof(T);
-  using DataType =
-      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
-                                std::array<T, Num>>::type;
+  // using DataType =
+  //     typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
+  //                               std::array<T, Num>>::type;
+  using DataType = std::array<T, (N == 3) ? 4 : N>;
   using VectorDataType = T __attribute__((ext_vector_type(N)));
 };
 #else // __SYCL_DEVICE_ONLY__
@@ -2161,7 +2129,7 @@ template <> struct VecStorage<half, 1, void> {
 #if defined(__SYCL_DEVICE_ONLY__)
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+    using DataType = sycl::detail::half_impl::Vec##Num##DeviceStorageT;              \
     using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
   };
 #else // defined(__SYCL_DEVICE_ONLY__)
diff --git a/sycl/test/abi/layout_vec.cpp b/sycl/test/abi/layout_vec.cpp
index 8f70f2835bf72..dac3e00e2d72a 100644
--- a/sycl/test/abi/layout_vec.cpp
+++ b/sycl/test/abi/layout_vec.cpp
@@ -10,7 +10,8 @@
 SYCL_EXTERNAL void foo(sycl::vec<int, 4>) {}
 
 // CHECK: 0 | class sycl::vec<int, 4>
-// CHECK-NEXT: 0 |   DataType m_Data
+// CHECK-NEXT: 0 | struct std::array<int, 4> m_Data
+// CHECK-NEXT: 0 | typename _AT_Type::_Type _M_elems
 // CHECK-NEXT: | [sizeof=16, dsize=16, align=16,
 // CHECK-NEXT: |  nvsize=16, nvalign=16]
 
@@ -19,6 +20,7 @@ SYCL_EXTERNAL void foo(sycl::vec<int, 4>) {}
 SYCL_EXTERNAL void foo(sycl::vec<bool, 16>) {}
 
 // CHECK: 0 | class sycl::vec<_Bool, 16>
-// CHECK-NEXT: 0 |   DataType m_Data
+// CHECK-NEXT: 0 | struct std::array<signed char, 16> m_Data
+// CHECK-NEXT: 0 | typename _AT_Type::_Type _M_elems
 // CHECK-NEXT: | [sizeof=16, dsize=16, align=16,
 // CHECK-NEXT: |  nvsize=16, nvalign=16]

From 706547211b8c36d440f579c55d9c7a95df86f195 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 3 Apr 2024 10:04:57 -0700
Subject: [PATCH 03/79] Fix

---
 sycl/test-e2e/bindless_images/bindless_helpers.hpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/sycl/test-e2e/bindless_images/bindless_helpers.hpp b/sycl/test-e2e/bindless_images/bindless_helpers.hpp
index 61e7e0113d348..f8668d054e0ae 100644
--- a/sycl/test-e2e/bindless_images/bindless_helpers.hpp
+++ b/sycl/test-e2e/bindless_images/bindless_helpers.hpp
@@ -3,8 +3,6 @@
 #include <sycl/detail/core.hpp>
 
 #include <sycl/ext/oneapi/bindless_images.hpp>
-<<<<<<< HEAD
-=======
 
 template <typename DType, int NChannels>
 std::ostream &operator<<(std::ostream &os,
@@ -17,7 +15,6 @@ std::ostream &operator<<(std::ostream &os,
   os << str;
   return os;
 }
->>>>>>> origin/sycl
 
 namespace bindless_helpers {
 

From 0ca00e2972283849203e29ed1f091ef56239c039 Mon Sep 17 00:00:00 2001
From: Udit Agarwal <dev.madaari@gmail.com>
Date: Wed, 3 Apr 2024 10:21:32 -0700
Subject: [PATCH 04/79] Delete sycl/test_bfloat.cpp

---
 sycl/test_bfloat.cpp | 27 ---------------------------
 1 file changed, 27 deletions(-)
 delete mode 100644 sycl/test_bfloat.cpp

diff --git a/sycl/test_bfloat.cpp b/sycl/test_bfloat.cpp
deleted file mode 100644
index d143ac5caf899..0000000000000
--- a/sycl/test_bfloat.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <sycl/sycl.hpp>
-
-int main() {
-    // Create a SYCL queue
-    cl::sycl::queue queue;
-
-    sycl::vec<sycl::ext::oneapi::bfloat16, 1> data{1};
-
-    // Create a buffer from the vector
-    cl::sycl::buffer<float, 1> buffer(data.data(), data.size());
-
-    // Submit a command group to the queue
-    queue.submit(& {
-        // Get access to the buffer
-        auto accessor = buffer.get_access<cl::sycl::access::mode::read_write>(cgh);
-
-        // Define the kernel
-        cgh.parallel_for<class bfloat16_vector>(cl::sycl::range<1>(data.size()), = {
-            accessor[i] += 2.0f;
-        });
-    });
-
-    // Wait for all operations to complete
-    queue.wait_and_throw();
-
-    return 0;
-}

From b3881f0e210d2c06ed91cdc9ffcd6973e70d24b8 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 3 Apr 2024 16:26:39 -0700
Subject: [PATCH 05/79] Cleanup

---
 sycl/include/sycl/types.hpp | 79 +++++++++++++++++++++----------------
 1 file changed, 44 insertions(+), 35 deletions(-)

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 18ff5b10cb563..b3f0273d827a5 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -99,6 +99,29 @@ using select_apply_cl_t = std::conditional_t<
     std::conditional_t<sizeof(_IN) == 2, T16,
                        std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
 
+// Helper function to bit_cast one type to another.
+template <typename FromType, typename ToType>
+static constexpr ToType BitCast(const FromType &Value) {
+
+  static_assert(sizeof(FromType) == sizeof(ToType),
+                "BitCast: sizes of types are different");
+
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+  return sycl::bit_cast<ToType>(Value);
+#else
+  // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+  // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+  // but neither available yet.
+  union {
+    const FromType from;
+    ToType to;
+  } result = {};
+  result.from = Value;
+  return result.to;
+#endif
+}
+
+/* Heper functions to get and set values in vec, depdending on the underlying data type. */
 template <typename T> struct vec_helper {
   using RetType = T;
   static constexpr RetType get(T value) { return value; }
@@ -114,35 +137,14 @@ template <> struct vec_helper<bool> {
 template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
   using RetType = sycl::ext::oneapi::bfloat16;
   using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
+
   static constexpr RetType get(BFloat16StorageT value) {
-#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
-    return sycl::bit_cast<RetType>(value);
-#else
-    // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
-    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
-    // but neither available yet.
-    union {
-      sycl::ext::oneapi::bfloat16 bf16;
-      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
-    } result = {};
-    result.storage = value;
-    return result.bf16;
-#endif
+    return BitCast<BFloat16StorageT, RetType>(value);
   }
-
   static constexpr RetType get(RetType value) { return value; }
 
   static constexpr BFloat16StorageT set(RetType value) {
-#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
-    return sycl::bit_cast<BFloat16StorageT>(value);
-#else
-    union {
-      sycl::ext::oneapi::bfloat16 bf16;
-      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
-    } result = {};
-    result.bf16 = value;
-    return result.storage;
-#endif
+    return BitCast<RetType, BFloat16StorageT>(value);
   }
 };
 
@@ -284,6 +286,9 @@ template <typename Type, int NumElements> class vec {
   // in the class, so vec<float, 16> should be equal to float16 in memory.
   using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
 
+  // Are we using half on the host? For device, sycl::half uses Float16 as
+  // storage data type but for the host, we use a custom data type
+  // (detail::host_half_impl::half).
   static constexpr bool IsHostHalf =
       std::is_same_v<DataT, sycl::detail::half_impl::half> &&
       std::is_same_v<sycl::detail::half_impl::StorageT,
@@ -302,8 +307,11 @@ template <typename Type, int NumElements> class vec {
   // vector extension. This is for MSVC compatibility, which has a max alignment
   // of 64 for direct params. If we drop MSVC, we can have alignment the same as
   // size and use vector extensions for all sizes.
+  // TODO: Inline this ans we are now always using array on device, irrespective of
+  // the data type.
   static constexpr bool IsUsingArrayOnDevice = true;
 
+  // TODO: Remove NativeVec - inline usages.
   static constexpr bool NativeVec = false;
 #if defined(__SYCL_DEVICE_ONLY__)
   static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
@@ -473,6 +481,7 @@ template <typename Type, int NumElements> class vec {
   using value_type = DataT;
   using rel_t = detail::rel_t<DataT>;
 #ifdef __SYCL_DEVICE_ONLY__
+  // Type used for passing sycl::vec to SPIRV builtins.
   using vector_t =
       typename detail::VecStorage<DataT, NumElements>::VectorDataType;
 #endif // __SYCL_DEVICE_ONLY__
@@ -624,9 +633,7 @@ template <typename Type, int NumElements> class vec {
                 typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
                                           !std::is_same_v<vector_t_, DataT>>>
   constexpr vec(vector_t openclVector) {
-      static_assert(sizeof(vector_t) == sizeof(DataType),
-                    "Size of OpenCL vector type doesn't match size of vec");
-      m_Data = bit_cast<DataType>(openclVector);
+    m_Data = detail::BitCast<vector_t, DataType>(openclVector);
   }
 
   /* @SYCL2020
@@ -638,8 +645,7 @@ template <typename Type, int NumElements> class vec {
     if constexpr (NumElements == 1) {
       return m_Data;
     } else {
-      auto ptr = bit_cast<const vector_t *>(m_Data.data());
-      return *ptr;
+      return detail::BitCast<DataType, vector_t>(m_Data);
     }
   }
 #endif // __SYCL_DEVICE_ONLY__
@@ -904,8 +910,8 @@ template <typename Type, int NumElements> class vec {
         Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = bit_cast<vector_t>(Lhs.m_Data);                     \
-      vector_t ExtVecRhs = bit_cast<vector_t>(Rhs.m_Data);                     \
+      vector_t ExtVecLhs = detail::BitCast<DataType, vector_t>(Lhs.m_Data);    \
+      vector_t ExtVecRhs = detail::BitCast<DataType, vector_t>(Rhs.m_Data);    \
       Ret = vec<DataT, NumElements>(                                           \
           (typename vec<DataT, NumElements>::vector_t)(                        \
               ExtVecLhs BINOP ExtVecRhs));                                     \
@@ -1006,8 +1012,8 @@ template <typename Type, int NumElements> class vec {
             Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = bit_cast<vector_t>(Lhs.m_Data);                     \
-      vector_t ExtVecRhs = bit_cast<vector_t>(Rhs.m_Data);                     \
+      vector_t ExtVecLhs = detail::BitCast<DataType, vector_t>(Lhs.m_Data);    \
+      vector_t ExtVecRhs = detail::BitCast<DataType, vector_t>(Rhs.m_Data);    \
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
               ExtVecLhs RELLOGOP ExtVecRhs));                                  \
@@ -1176,8 +1182,11 @@ template <typename Type, int NumElements> class vec {
   operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
     vec<DataT, NumElements> Result;
     Operation<DataT> Op;
-    auto OpResult = Op(bit_cast<vector_t>(m_Data), bit_cast<vector_t>(Rhs.m_Data));
-    Result.m_Data = bit_cast<DataType>(OpResult);
+    // Typecast to ext_vector_type, carryout the operation, and type cast back.
+    // Compiler optimizations will remove redundant casts.
+    auto OpResult = Op(detail::BitCast<DataType, vector_t>(m_Data),
+                       detail::BitCast<DataType, vector_t>(Rhs.m_Data));
+    Result.m_Data = detail::BitCast<vector_t, DataType>(OpResult);
     return Result;
   }
 #else  // __SYCL_DEVICE_ONLY__

From d77d5376cd0d9ece0faa425bc6c13f9de1403681 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 10 Apr 2024 11:44:06 -0700
Subject: [PATCH 06/79] Cleanup

---
 sycl/include/sycl/types.hpp | 86 ++++++-------------------------------
 sycl/test/conf.txt          |  1 -
 2 files changed, 12 insertions(+), 75 deletions(-)
 delete mode 100644 sycl/test/conf.txt

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index b3f0273d827a5..21abed35fdeeb 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -311,8 +311,6 @@ template <typename Type, int NumElements> class vec {
   // the data type.
   static constexpr bool IsUsingArrayOnDevice = true;
 
-  // TODO: Remove NativeVec - inline usages.
-  static constexpr bool NativeVec = false;
 #if defined(__SYCL_DEVICE_ONLY__)
   static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
 #else
@@ -513,24 +511,6 @@ template <typename Type, int NumElements> class vec {
   using EnableIfUsingArrayOnDevice =
       typename std::enable_if_t<IsUsingArrayOnDevice, T>;
 
-  template <typename T = void>
-  using EnableIfNotUsingArrayOnDevice =
-      typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
-
-  template <typename Ty = DataT>
-  explicit constexpr vec(const EnableIfNotUsingArrayOnDevice<Ty> &arg)
-      : m_Data{DataType(vec_data<Ty>::get(arg))} {}
-
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) {
-    m_Data = (DataType)vec_data<Ty>::get(Rhs);
-    return *this;
-  }
-
   template <typename Ty = DataT>
   explicit constexpr vec(const EnableIfUsingArrayOnDevice<Ty> &arg)
       : vec{detail::RepeatValue<NumElements>(
@@ -577,46 +557,6 @@ template <typename Type, int NumElements> class vec {
   template <int IdxNum, typename T = void>
   using EnableIfMultipleElems = typename std::enable_if_t<
       std::is_convertible_v<T, DataT> && NumElements == IdxNum, DataT>;
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<2, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<3, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<4, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const Ty Arg3)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<8, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const DataT Arg3, const DataT Arg4, const DataT Arg5,
-                const DataT Arg6, const DataT Arg7)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
-               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
-               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<16, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const DataT Arg3, const DataT Arg4, const DataT Arg5,
-                const DataT Arg6, const DataT Arg7, const DataT Arg8,
-                const DataT Arg9, const DataT ArgA, const DataT ArgB,
-                const DataT ArgC, const DataT ArgD, const DataT ArgE,
-                const DataT ArgF)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
-               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
-               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7),
-               vec_data<Ty>::get(Arg8), vec_data<Ty>::get(Arg9),
-               vec_data<Ty>::get(ArgA), vec_data<Ty>::get(ArgB),
-               vec_data<Ty>::get(ArgC), vec_data<Ty>::get(ArgD),
-               vec_data<Ty>::get(ArgE), vec_data<Ty>::get(ArgF)} {}
 #endif // __SYCL_DEVICE_ONLY__
 
   // Constructor from values of base type or vec of base type. Checks that
@@ -710,19 +650,21 @@ template <typename Type, int NumElements> class vec {
 #if defined(__SYCL_DEVICE_ONLY__)
     using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
     using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
+
+    auto extVecType = detail::BitCast<DataType, vector_t>(m_Data);
+    using ConvertTVecType = typename vec<convertT, NumElements>::vector_t;
+
     // Whole vector conversion can only be done, if:
     constexpr bool canUseNativeVectorConvert =
 #ifdef __NVPTX__
         // - we are not on CUDA, see intel/llvm#11840
         false &&
 #endif
-        // - both vectors are represented using native vector types;
-        NativeVec && vec<convertT, NumElements>::NativeVec &&
         // - vec storage has an equivalent OpenCL native vector it is implicitly
         //   convertible to. There are some corner cases where it is not the
         //   case with char, long and long long types.
-        std::is_convertible_v<decltype(m_Data), OpenCLVecT> &&
-        std::is_convertible_v<decltype(Result.m_Data), OpenCLVecR> &&
+        std::is_convertible_v<vector_t, OpenCLVecT> &&
+        std::is_convertible_v<ConvertTVecType, OpenCLVecR> &&
         // - it is not a signed to unsigned (or vice versa) conversion
         //   see comments within 'convertImpl' for more details;
         !detail::is_sint_to_from_uint<T, R>::value &&
@@ -733,8 +675,9 @@ template <typename Type, int NumElements> class vec {
         //   right results here;
         !std::is_same_v<convertT, bool>;
     if constexpr (canUseNativeVectorConvert) {
-      Result.m_Data = detail::convertImpl<T, R, roundingMode, NumElements,
-                                          OpenCLVecT, OpenCLVecR>(m_Data);
+      Result.m_Data = detail::BitCast<ConvertTVecType, decltype(Result.m_Data)>(
+                        detail::convertImpl<T, R, roundingMode, NumElements,
+                        OpenCLVecT, OpenCLVecR>(extVecType));
     } else
 #endif // defined(__SYCL_DEVICE_ONLY__)
     {
@@ -783,8 +726,6 @@ template <typename Type, int NumElements> class vec {
   // not changed.
   //
   // Implement operator [] in the same way for host and device.
-  // TODO: change host side implementation when underlying type for host side
-  // will be changed to std::array.
   // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
   // aggressively optimized. Specializing with noinline to avoid as workaround.
 
@@ -943,12 +884,9 @@ template <typename Type, int NumElements> class vec {
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret{};                                                                 \
-    if constexpr (NativeVec)                                                   \
-      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
-    else                                                                       \
-      for (size_t I = 0; I < NumElements; ++I)                                 \
-        Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(             \
-                            I)) BINOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+    for (size_t I = 0; I < NumElements; ++I)                                   \
+      Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(               \
+                          I)) BINOP vec_data<DataT>::get(Rhs.getValue(I))));   \
     return Ret;                                                                \
   }                                                                            \
   friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
diff --git a/sycl/test/conf.txt b/sycl/test/conf.txt
deleted file mode 100644
index 9446e0fad62b2..0000000000000
--- a/sycl/test/conf.txt
+++ /dev/null
@@ -1 +0,0 @@
-SYCL_PRINT_EXECUTION_GRAPH=after_addCopyBack #comment

From 1fe41c216b72db64ddcdbd8fd43226d9c280643b Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 10 Apr 2024 13:54:06 -0700
Subject: [PATCH 07/79] More cleanup

---
 sycl/include/sycl/types.hpp | 98 +++++++++++++++++--------------------
 1 file changed, 46 insertions(+), 52 deletions(-)

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 21abed35fdeeb..4f54d9237bf3f 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -548,17 +548,6 @@ template <typename Type, int NumElements> class vec {
   }
 #endif // __SYCL_DEVICE_ONLY__
 
-#ifdef __SYCL_DEVICE_ONLY__
-  // Optimized naive constructors with NumElements of DataT values.
-  // We don't expect compilers to optimize vararg recursive functions well.
-
-  // Helper type to make specific constructors available only for specific
-  // number of elements.
-  template <int IdxNum, typename T = void>
-  using EnableIfMultipleElems = typename std::enable_if_t<
-      std::is_convertible_v<T, DataT> && NumElements == IdxNum, DataT>;
-#endif // __SYCL_DEVICE_ONLY__
-
   // Constructor from values of base type or vec of base type. Checks that
   // base types are match and that the NumElements == sum of lengths of args.
   template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
@@ -1024,55 +1013,58 @@ template <typename Type, int NumElements> class vec {
   // operator~() available only when: dataT != float && dataT != double
   // && dataT != half
   friend vec operator~(const vec &Rhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I) {
-        Ret.setValue(I, ~Rhs.getValue(I));
-      }
-      return Ret;
-    } else {
-      vec Ret{(typename vec::DataType) ~Rhs.m_Data};
-      if constexpr (std::is_same_v<Type, bool>) {
-        Ret.ConvertToDataT();
-      }
-      return Ret;
+#ifdef __SYCL_DEVICE_ONLY__
+    auto extVec = detail::BitCast<DataType, vector_t>(Rhs.m_Data);
+    vec Ret{~extVec};
+    if constexpr (std::is_same_v<Type, bool>) {
+      Ret.ConvertToDataT();
     }
+    return Ret;
+#else
+    vec Ret{};
+    for (size_t I = 0; I < NumElements; ++I) {
+      Ret.setValue(I, ~Rhs.getValue(I));
+    }
+    return Ret;
+#endif
   }
 
   // operator!
   friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I) {
+    vec Ret{};
+#ifndef __SYCL_DEVICE_ONLY__
+    for (size_t I = 0; I < NumElements; ++I) {
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-        // std::byte neither supports ! unary op or casting, so special handling
-        // is needed. And, worse, Windows has a conflict with 'byte'.
-        if constexpr (std::is_same_v<std::byte, DataT>) {
-          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
-        } else
+      // std::byte neither supports ! unary op or casting, so special handling
+      // is needed. And, worse, Windows has a conflict with 'byte'.
+      if constexpr (std::is_same_v<std::byte, DataT>) {
+        Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
+      } else
 #endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-        {
-          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
-        }
+      {
+        Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
       }
-      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
-    } else {
-      return vec{(typename vec<DataT, NumElements>::DataType) !Rhs.m_Data}
-          .template as<vec<detail::rel_t<DataT>, NumElements>>();
     }
+    return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
+#else
+    auto extVec = detail::BitCast<DataType, vector_t>(Rhs.m_Data);
+    return vec{!extVec}
+        .template as<vec<detail::rel_t<DataT>, NumElements>>();
+#endif
   }
 
   // operator +
   friend vec operator+(const vec &Lhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I)
-        Ret.setValue(
-            I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
-      return Ret;
-    } else {
-      return vec{+Lhs.m_Data};
-    }
+#ifdef __SYCL_DEVICE_ONLY__
+    auto extVec = detail::BitCast<DataType, vector_t>(Lhs.m_Data);
+    return vec{+extVec};
+#else
+    vec Ret{};
+    for (size_t I = 0; I < NumElements; ++I)
+      Ret.setValue(
+          I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
+    return Ret;
+#endif
   }
 
   // operator -
@@ -1089,18 +1081,20 @@ template <typename Type, int NumElements> class vec {
         oneapi::bfloat16 w = -v;
         Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
       }
-    } else if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+    } else {
+#ifndef __SYCL_DEVICE_ONLY__
       for (size_t I = 0; I < NumElements; ++I)
         Ret.setValue(
             I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
-      return Ret;
-    } else {
-      Ret = vec{-Lhs.m_Data};
+#else
+      auto extVec = detail::BitCast<DataType, vector_t>(Lhs.m_Data);
+      Ret = vec{-extVec};
       if constexpr (std::is_same_v<Type, bool>) {
         Ret.ConvertToDataT();
       }
-      return Ret;
+#endif
     }
+    return Ret;
   }
 
   // OP is: &&, ||

From a75a93babedce82a48910f17c3ce262cda682cd7 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 11 Apr 2024 09:06:04 -0700
Subject: [PATCH 08/79] Fix failures

---
 sycl/include/sycl/ext/oneapi/bfloat16.hpp     |  6 +++
 sycl/include/sycl/types.hpp                   | 49 ++++++++++++-------
 .../vec_binary_scalar_order_relational.cpp    |  3 --
 3 files changed, 38 insertions(+), 20 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/bfloat16.hpp b/sycl/include/sycl/ext/oneapi/bfloat16.hpp
index 3a0e1259a1ff8..e2d6beb8b9b4c 100644
--- a/sycl/include/sycl/ext/oneapi/bfloat16.hpp
+++ b/sycl/include/sycl/ext/oneapi/bfloat16.hpp
@@ -38,6 +38,12 @@ using Vec3StorageT = Bfloat16StorageT __attribute__((ext_vector_type(3)));
 using Vec4StorageT = Bfloat16StorageT __attribute__((ext_vector_type(4)));
 using Vec8StorageT = Bfloat16StorageT __attribute__((ext_vector_type(8)));
 using Vec16StorageT = Bfloat16StorageT __attribute__((ext_vector_type(16)));
+
+using Vec2DeviceStorageT = std::array<Bfloat16StorageT, 2>;
+using Vec3DeviceStorageT = std::array<Bfloat16StorageT, 3>;
+using Vec4DeviceStorageT = std::array<Bfloat16StorageT, 4>;
+using Vec8DeviceStorageT = std::array<Bfloat16StorageT, 8>;
+using Vec16DeviceStorageT = std::array<Bfloat16StorageT, 16>;
 #else
 using Vec2StorageT = std::array<Bfloat16StorageT, 2>;
 using Vec3StorageT = std::array<Bfloat16StorageT, 3>;
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 4f54d9237bf3f..bba53438037e9 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -1032,25 +1032,34 @@ template <typename Type, int NumElements> class vec {
   // operator!
   friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
     vec Ret{};
-#ifndef __SYCL_DEVICE_ONLY__
-    for (size_t I = 0; I < NumElements; ++I) {
+#ifdef __SYCL_DEVICE_ONLY__
+    if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
+                  !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-      // std::byte neither supports ! unary op or casting, so special handling
-      // is needed. And, worse, Windows has a conflict with 'byte'.
-      if constexpr (std::is_same_v<std::byte, DataT>) {
-        Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
-      } else
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-      {
-        Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
-      }
-    }
-    return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
+                  !std::is_same_v<DataT, std::byte>)   
 #else
+                  1)
+#endif         
+  {
     auto extVec = detail::BitCast<DataType, vector_t>(Rhs.m_Data);
-    return vec{!extVec}
-        .template as<vec<detail::rel_t<DataT>, NumElements>>();
+    return vec<detail::rel_t<DataT>, NumElements>{!extVec};
+  } else
 #endif
+    {
+      for (size_t I = 0; I < NumElements; ++I) {
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        // std::byte neither supports ! unary op or casting, so special handling
+        // is needed. And, worse, Windows has a conflict with 'byte'.
+        if constexpr (std::is_same_v<std::byte, DataT>) {
+          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
+        } else
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        {
+          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
+        }
+      }
+      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
+    }
   }
 
   // operator +
@@ -2088,12 +2097,18 @@ template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
   using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
 };
 // Multiple elements bfloat16
+#ifndef __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
     using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
-    using VectorDataType =                                                     \
-        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
   };
+#else
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##DeviceStorageT; \
+    using VectorDataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;  \
+  };
+#endif
 __SYCL_DEFINE_BF16_VECSTORAGE(2)
 __SYCL_DEFINE_BF16_VECSTORAGE(3)
 __SYCL_DEFINE_BF16_VECSTORAGE(4)
diff --git a/sycl/test-e2e/Basic/vector/vec_binary_scalar_order_relational.cpp b/sycl/test-e2e/Basic/vector/vec_binary_scalar_order_relational.cpp
index 2ba7ff130bf72..e07e2548a840c 100644
--- a/sycl/test-e2e/Basic/vector/vec_binary_scalar_order_relational.cpp
+++ b/sycl/test-e2e/Basic/vector/vec_binary_scalar_order_relational.cpp
@@ -2,9 +2,6 @@
 // RUN: %{build} -fpreview-breaking-changes -o %t.out
 // RUN: %{run} %t.out
 
-// This test currently fails on AMD HIP due to an unresolved memcmp function.
-// XFAIL: hip_amd
-
 // Checks scalar/vec relational operator ordering.
 
 #include "vec_binary_scalar_order.hpp"

From c78b57d4db41d99d0fc50741e78aee8ea841fc65 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 11 Apr 2024 09:38:44 -0700
Subject: [PATCH 09/79] Fiox formatting

---
 .../sycl/detail/generic_type_traits.hpp       |  3 +-
 sycl/include/sycl/types.hpp                   | 54 +++++++++++--------
 2 files changed, 32 insertions(+), 25 deletions(-)

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index ab83086758a03..fae82268c1d98 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -330,8 +330,7 @@ template <typename T> auto convertToOpenCLType(T &&x) {
     // non-uniform groups implementation.
     if constexpr (std::is_same_v<MatchingVec, no_ref>) {
       return bit_cast<typename no_ref::vector_t>(x);
-    }
-    else {
+    } else {
       return bit_cast<typename MatchingVec::vector_t>(x);
     }
 #else
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index bba53438037e9..679b9ba258383 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -121,7 +121,8 @@ static constexpr ToType BitCast(const FromType &Value) {
 #endif
 }
 
-/* Heper functions to get and set values in vec, depdending on the underlying data type. */
+/* Heper functions to get and set values in vec, depdending on the underlying
+ * data type. */
 template <typename T> struct vec_helper {
   using RetType = T;
   static constexpr RetType get(T value) { return value; }
@@ -307,8 +308,8 @@ template <typename Type, int NumElements> class vec {
   // vector extension. This is for MSVC compatibility, which has a max alignment
   // of 64 for direct params. If we drop MSVC, we can have alignment the same as
   // size and use vector extensions for all sizes.
-  // TODO: Inline this ans we are now always using array on device, irrespective of
-  // the data type.
+  // TODO: Inline this ans we are now always using array on device, irrespective
+  // of the data type.
   static constexpr bool IsUsingArrayOnDevice = true;
 
 #if defined(__SYCL_DEVICE_ONLY__)
@@ -522,7 +523,8 @@ template <typename Type, int NumElements> class vec {
       std::is_fundamental_v<vec_data_t<Ty>> ||
           detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
-  // TODO: Can we use std::fill or something similar to vectorize assignment operation?
+  // TODO: Can we use std::fill or something similar to vectorize assignment
+  // operation?
   operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
@@ -567,8 +569,8 @@ template <typename Type, int NumElements> class vec {
 
   /* @SYCL2020
    * Available only when: compiled for the device.
-   * Converts this SYCL vec instance to the underlying backend-native vector type
-   * defined by vector_t.
+   * Converts this SYCL vec instance to the underlying backend-native vector
+   * type defined by vector_t.
    */
   operator vector_t() const {
     if constexpr (NumElements == 1) {
@@ -665,8 +667,8 @@ template <typename Type, int NumElements> class vec {
         !std::is_same_v<convertT, bool>;
     if constexpr (canUseNativeVectorConvert) {
       Result.m_Data = detail::BitCast<ConvertTVecType, decltype(Result.m_Data)>(
-                        detail::convertImpl<T, R, roundingMode, NumElements,
-                        OpenCLVecT, OpenCLVecR>(extVecType));
+          detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
+                              OpenCLVecR>(extVecType));
     } else
 #endif // defined(__SYCL_DEVICE_ONLY__)
     {
@@ -835,7 +837,8 @@ template <typename Type, int NumElements> class vec {
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret;                                                                   \
-    if constexpr (IsBfloat16 || std::is_same_v<DataT, sycl::detail::half_impl::half>) {                                      \
+    if constexpr (IsBfloat16 ||                                                \
+                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
       for (size_t I = 0; I < NumElements; ++I) {                               \
         Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
       }                                                                        \
@@ -874,8 +877,9 @@ template <typename Type, int NumElements> class vec {
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret{};                                                                 \
     for (size_t I = 0; I < NumElements; ++I)                                   \
-      Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(               \
-                          I)) BINOP vec_data<DataT>::get(Rhs.getValue(I))));   \
+      Ret.setValue(I,                                                          \
+                   (DataT)(vec_data<DataT>::get(Lhs.getValue(I))               \
+                               BINOP vec_data<DataT>::get(Rhs.getValue(I))));  \
     return Ret;                                                                \
   }                                                                            \
   friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
@@ -931,7 +935,8 @@ template <typename Type, int NumElements> class vec {
     vec<rel_t, NumElements> Ret{};                                             \
     /* ext_vector_type does not support bfloat16 or half, so for these   */    \
     /* we do element-by-element operation on the underlying std::array.  */    \
-    if constexpr (IsBfloat16 || std::is_same_v<DataT, sycl::detail::half_impl::half>) {                                  \
+    if constexpr (IsBfloat16 ||                                                \
+                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
       for (size_t I = 0; I < NumElements; ++I) {                               \
         /* We cannot use SetValue here as the operator is not a friend of*/    \
         /* Ret on Windows. */                                                  \
@@ -1036,14 +1041,14 @@ template <typename Type, int NumElements> class vec {
     if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
                   !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-                  !std::is_same_v<DataT, std::byte>)   
+                  !std::is_same_v<DataT, std::byte>)
 #else
                   1)
-#endif         
-  {
-    auto extVec = detail::BitCast<DataType, vector_t>(Rhs.m_Data);
-    return vec<detail::rel_t<DataT>, NumElements>{!extVec};
-  } else
+#endif
+    {
+      auto extVec = detail::BitCast<DataType, vector_t>(Rhs.m_Data);
+      return vec<detail::rel_t<DataT>, NumElements>{!extVec};
+    } else
 #endif
     {
       for (size_t I = 0; I < NumElements; ++I) {
@@ -1159,7 +1164,7 @@ template <typename Type, int NumElements> class vec {
   constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
     return vec_data<DataT>::get(m_Data[Index]);
   }
-#else // __SYCL_DEVICE_ONLY__
+#else  // __SYCL_DEVICE_ONLY__
   template <int Num = NumElements,
             typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(int Index, const DataT &Value, int) {
@@ -1971,7 +1976,8 @@ template <typename T, int N> struct VecStorageImpl {
   static constexpr size_t Num = (N == 3) ? 4 : N;
   static constexpr size_t Sz = Num * sizeof(T);
   // using DataType =
-  //     typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
+  //     typename std::conditional<Sz <= 64, T
+  //     __attribute__((ext_vector_type(N))),
   //                               std::array<T, Num>>::type;
   using DataType = std::array<T, (N == 3) ? 4 : N>;
   using VectorDataType = T __attribute__((ext_vector_type(N)));
@@ -2073,7 +2079,7 @@ template <> struct VecStorage<half, 1, void> {
 #if defined(__SYCL_DEVICE_ONLY__)
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##DeviceStorageT;              \
+    using DataType = sycl::detail::half_impl::Vec##Num##DeviceStorageT;        \
     using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
   };
 #else // defined(__SYCL_DEVICE_ONLY__)
@@ -2105,8 +2111,10 @@ template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
 #else
 #define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##DeviceStorageT; \
-    using VectorDataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;  \
+    using DataType =                                                           \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##DeviceStorageT;             \
+    using VectorDataType =                                                     \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
   };
 #endif
 __SYCL_DEFINE_BF16_VECSTORAGE(2)

From ca85863f5bc9870b96588d49210b5e5167443c44 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 12 Apr 2024 13:20:12 -0700
Subject: [PATCH 10/79] Add a test for checking dveice code.

---
 sycl/include/sycl/ext/oneapi/bfloat16.hpp     |  2 +-
 sycl/include/sycl/types.hpp                   | 14 ++--
 .../math-builtins/vector.cpp                  | 82 +++++++++++++++++++
 3 files changed, 90 insertions(+), 8 deletions(-)
 create mode 100644 sycl/test/check_device_code/math-builtins/vector.cpp

diff --git a/sycl/include/sycl/ext/oneapi/bfloat16.hpp b/sycl/include/sycl/ext/oneapi/bfloat16.hpp
index e2d6beb8b9b4c..0a47b0e85bc09 100644
--- a/sycl/include/sycl/ext/oneapi/bfloat16.hpp
+++ b/sycl/include/sycl/ext/oneapi/bfloat16.hpp
@@ -40,7 +40,7 @@ using Vec8StorageT = Bfloat16StorageT __attribute__((ext_vector_type(8)));
 using Vec16StorageT = Bfloat16StorageT __attribute__((ext_vector_type(16)));
 
 using Vec2DeviceStorageT = std::array<Bfloat16StorageT, 2>;
-using Vec3DeviceStorageT = std::array<Bfloat16StorageT, 3>;
+using Vec3DeviceStorageT = std::array<Bfloat16StorageT, 4>;
 using Vec4DeviceStorageT = std::array<Bfloat16StorageT, 4>;
 using Vec8DeviceStorageT = std::array<Bfloat16StorageT, 8>;
 using Vec16DeviceStorageT = std::array<Bfloat16StorageT, 16>;
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 679b9ba258383..28cf5920415a4 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -106,7 +106,7 @@ static constexpr ToType BitCast(const FromType &Value) {
   static_assert(sizeof(FromType) == sizeof(ToType),
                 "BitCast: sizes of types are different");
 
-#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+#ifdef __SYCL_BITCAST_IS_CONSTEXPR
   return sycl::bit_cast<ToType>(Value);
 #else
   // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
@@ -312,7 +312,7 @@ template <typename Type, int NumElements> class vec {
   // of the data type.
   static constexpr bool IsUsingArrayOnDevice = true;
 
-#if defined(__SYCL_DEVICE_ONLY__)
+#ifdef __SYCL_DEVICE_ONLY__
   static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
 #else
   static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
@@ -638,7 +638,7 @@ template <typename Type, int NumElements> class vec {
     using OpenCLR = detail::ConvertToOpenCLType_t<R>;
     vec<convertT, NumElements> Result;
 
-#if defined(__SYCL_DEVICE_ONLY__)
+#ifdef __SYCL_DEVICE_ONLY__
     using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
     using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
 
@@ -670,7 +670,7 @@ template <typename Type, int NumElements> class vec {
           detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
                               OpenCLVecR>(extVecType));
     } else
-#endif // defined(__SYCL_DEVICE_ONLY__)
+#endif // __SYCL_DEVICE_ONLY__
     {
       // Otherwise, we fallback to per-element conversion:
       for (size_t I = 0; I < NumElements; ++I) {
@@ -2076,18 +2076,18 @@ template <> struct VecStorage<half, 1, void> {
 };
 
 // Multiple elements half
-#if defined(__SYCL_DEVICE_ONLY__)
+#ifdef __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
     using DataType = sycl::detail::half_impl::Vec##Num##DeviceStorageT;        \
     using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
   };
-#else // defined(__SYCL_DEVICE_ONLY__)
+#else // __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
     using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
   };
-#endif // defined(__SYCL_DEVICE_ONLY__)
+#endif // __SYCL_DEVICE_ONLY__
 
 __SYCL_DEFINE_HALF_VECSTORAGE(2)
 __SYCL_DEFINE_HALF_VECSTORAGE(3)
diff --git a/sycl/test/check_device_code/math-builtins/vector.cpp b/sycl/test/check_device_code/math-builtins/vector.cpp
new file mode 100644
index 0000000000000..33a85916cc0f5
--- /dev/null
+++ b/sycl/test/check_device_code/math-builtins/vector.cpp
@@ -0,0 +1,82 @@
+// RUN: %clangxx -fsycl-device-only -S -O0 -Xclang -emit-llvm -o - %s | FileCheck %s --dump-input=always
+
+// This test checks that sycl::vec uses std::array as storage type on device for all
+// data types.
+#include <sycl/sycl.hpp>
+
+using namespace sycl;
+
+// Create sycl::vec for each type and verify the storage
+// type on device side.
+#define CHECK(Q, T, N)                                                            \
+  {                                                                            \
+      T Result;                                                                \
+      {                                                                        \
+        Q.submit([&](handler &CGH) {                                           \
+          CGH.single_task([=]() {                                              \
+            vec<T, 2> InVec##N##2{static_cast<T>(5)};                                \
+            vec<T, 3> InVec##N##3{static_cast<T>(5)};                                \
+            vec<T, 4> InVec##N##4{static_cast<T>(5)};                      \
+            vec<T, 8> InVec##N##8{static_cast<T>(5)};                      \
+            vec<T, 16> InVec##N##16{static_cast<T>(5)};                    \
+          });                                                                  \
+        });                                                                    \                                                                       
+      }                                                                        \
+  }
+
+int main() {
+
+    queue q;
+
+    // CHECK: {{.*}}InVecINT2 = {{.*}} %"struct.std::array{{.*}}" { [2 x i32] {{.*}}
+    // CHECK: {{.*}}InVecINT3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i32] {{.*}}
+    // CHECK: {{.*}}InVecINT4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i32] {{.*}}
+    // CHECK: {{.*}}InVecINT8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i32] {{.*}}
+    // CHECK: {{.*}}InVecINT16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i32] {{.*}}
+    CHECK(q, int, INT)
+
+    // CHECK: {{.*}}InVecFLOAT2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x float] {{.*}}
+    // CHECK: {{.*}}InVecFLOAT3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x float] {{.*}}
+    // CHECK: {{.*}}InVecFLOAT4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x float] {{.*}}
+    // CHECK: {{.*}}InVecFLOAT8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x float] {{.*}}
+    // CHECK: {{.*}}InVecFLOAT16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x float] {{.*}}
+    CHECK(q, float, FLOAT)
+
+    // CHECK: {{.*}}InVecCHAR2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
+    // CHECK: {{.*}}InVecCHAR3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+    // CHECK: {{.*}}InVecCHAR4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+    // CHECK: {{.*}}InVecCHAR8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
+    // CHECK: {{.*}}InVecCHAR16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
+    CHECK(q, char, CHAR)
+
+    // CHECK: {{.*}}InVecBOOL2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
+    // CHECK: {{.*}}InVecBOOL3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+    // CHECK: {{.*}}InVecBOOL4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+    // CHECK: {{.*}}InVecBOOL8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
+    // CHECK: {{.*}}InVecBOOL16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
+    CHECK(q, bool, BOOL)
+
+    // CHECK: {{.*}}InVecHALF2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x half] {{.*}}
+    // CHECK: {{.*}}InVecHALF3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x half] {{.*}}
+    // CHECK: {{.*}}InVecHALF4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x half] {{.*}}
+    // CHECK: {{.*}}InVecHALF8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x half] {{.*}}
+    // CHECK: {{.*}}InVecHALF16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x half] {{.*}}
+    CHECK(q, half, HALF)
+
+    // CHECK: {{.*}}InVecBYTE2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
+    // CHECK: {{.*}}InVecBYTE3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+    // CHECK: {{.*}}InVecBYTE4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+    // CHECK: {{.*}}InVecBYTE8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
+    // CHECK: {{.*}}InVecBYTE16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
+    CHECK(q, std::byte, BYTE)
+
+    // CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
+    // CHECK: %"struct.std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+    // CHECK: %"struct.std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+    // CHECK: %"struct.std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+    // CHECK: %"struct.std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+    // CHECK: %"struct.std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+    CHECK(q, ext::oneapi::bfloat16, BF)
+   
+  return 0;
+};

From 8af05a206540b7576b3541963acba067531ee8fa Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 12 Apr 2024 13:22:18 -0700
Subject: [PATCH 11/79] Fix formating

---
 sycl/test/check_device_code/math-builtins/vector.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/sycl/test/check_device_code/math-builtins/vector.cpp b/sycl/test/check_device_code/math-builtins/vector.cpp
index 33a85916cc0f5..b29f4a3d230f4 100644
--- a/sycl/test/check_device_code/math-builtins/vector.cpp
+++ b/sycl/test/check_device_code/math-builtins/vector.cpp
@@ -8,17 +8,17 @@ using namespace sycl;
 
 // Create sycl::vec for each type and verify the storage
 // type on device side.
-#define CHECK(Q, T, N)                                                            \
+#define CHECK(Q, T, N)                                                         \
   {                                                                            \
       T Result;                                                                \
       {                                                                        \
         Q.submit([&](handler &CGH) {                                           \
           CGH.single_task([=]() {                                              \
-            vec<T, 2> InVec##N##2{static_cast<T>(5)};                                \
-            vec<T, 3> InVec##N##3{static_cast<T>(5)};                                \
-            vec<T, 4> InVec##N##4{static_cast<T>(5)};                      \
-            vec<T, 8> InVec##N##8{static_cast<T>(5)};                      \
-            vec<T, 16> InVec##N##16{static_cast<T>(5)};                    \
+            vec<T, 2> InVec##N##2{static_cast<T>(5)};                          \
+            vec<T, 3> InVec##N##3{static_cast<T>(5)};                          \
+            vec<T, 4> InVec##N##4{static_cast<T>(5)};                          \
+            vec<T, 8> InVec##N##8{static_cast<T>(5)};                          \
+            vec<T, 16> InVec##N##16{static_cast<T>(5)};                        \
           });                                                                  \
         });                                                                    \                                                                       
       }                                                                        \

From c1763a048472da41d3e37ddbaffe4d7e4acc764b Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 12 Apr 2024 13:32:59 -0700
Subject: [PATCH 12/79] Fix test

---
 sycl/include/sycl/detail/generic_type_traits.hpp |  9 +--------
 .../check_device_code/math-builtins/vector.cpp   | 16 ++++++++--------
 2 files changed, 9 insertions(+), 16 deletions(-)

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index fae82268c1d98..961e0fdf3072b 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -325,14 +325,7 @@ template <typename T> auto convertToOpenCLType(T &&x) {
                                                    std::declval<ElemTy>()))>,
                             no_ref::size()>;
 #ifdef __SYCL_DEVICE_ONLY__
-    // TODO: for some mysterious reasons on NonUniformGroups E2E tests fail if
-    // we use the "else" version only. I suspect that's an issues with
-    // non-uniform groups implementation.
-    if constexpr (std::is_same_v<MatchingVec, no_ref>) {
-      return bit_cast<typename no_ref::vector_t>(x);
-    } else {
-      return bit_cast<typename MatchingVec::vector_t>(x);
-    }
+    return bit_cast<typename MatchingVec::vector_t>(x);
 #else
     return x.template as<MatchingVec>();
 #endif
diff --git a/sycl/test/check_device_code/math-builtins/vector.cpp b/sycl/test/check_device_code/math-builtins/vector.cpp
index b29f4a3d230f4..a8dbfba855569 100644
--- a/sycl/test/check_device_code/math-builtins/vector.cpp
+++ b/sycl/test/check_device_code/math-builtins/vector.cpp
@@ -28,6 +28,14 @@ int main() {
 
     queue q;
 
+    // CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
+    // CHECK: %"struct.std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+    // CHECK: %"struct.std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+    // CHECK: %"struct.std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+    // CHECK: %"struct.std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+    // CHECK: %"struct.std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+    CHECK(q, ext::oneapi::bfloat16, BF)
+
     // CHECK: {{.*}}InVecINT2 = {{.*}} %"struct.std::array{{.*}}" { [2 x i32] {{.*}}
     // CHECK: {{.*}}InVecINT3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i32] {{.*}}
     // CHECK: {{.*}}InVecINT4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i32] {{.*}}
@@ -69,14 +77,6 @@ int main() {
     // CHECK: {{.*}}InVecBYTE8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
     // CHECK: {{.*}}InVecBYTE16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
     CHECK(q, std::byte, BYTE)
-
-    // CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
-    // CHECK: %"struct.std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-    // CHECK: %"struct.std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-    // CHECK: %"struct.std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-    // CHECK: %"struct.std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-    // CHECK: %"struct.std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-    CHECK(q, ext::oneapi::bfloat16, BF)
    
   return 0;
 };

From 209e9f0eef8428b8db130376836a50e31801f3ca Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 12 Apr 2024 15:40:02 -0700
Subject: [PATCH 13/79] Remove HostHalf

---
 sycl/include/sycl/types.hpp                   |  19 +--
 .../math-builtins/vector.cpp                  | 113 +++++++++---------
 2 files changed, 58 insertions(+), 74 deletions(-)

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 28cf5920415a4..5130f2ce5c971 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -109,7 +109,7 @@ static constexpr ToType BitCast(const FromType &Value) {
 #ifdef __SYCL_BITCAST_IS_CONSTEXPR
   return sycl::bit_cast<ToType>(Value);
 #else
-  // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+  // Awkward workaround. sycl::bit_cast isn't constexpr in older GCC
   // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
   // but neither available yet.
   union {
@@ -287,14 +287,6 @@ template <typename Type, int NumElements> class vec {
   // in the class, so vec<float, 16> should be equal to float16 in memory.
   using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
 
-  // Are we using half on the host? For device, sycl::half uses Float16 as
-  // storage data type but for the host, we use a custom data type
-  // (detail::host_half_impl::half).
-  static constexpr bool IsHostHalf =
-      std::is_same_v<DataT, sycl::detail::half_impl::half> &&
-      std::is_same_v<sycl::detail::half_impl::StorageT,
-                     sycl::detail::host_half_impl::half>;
-
   static constexpr bool IsBfloat16 =
       std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
 
@@ -503,11 +495,6 @@ template <typename Type, int NumElements> class vec {
   }
 
 #ifdef __SYCL_DEVICE_ONLY__
-  // This should always be true for device code using sycl::half.
-  // TODO: We should remove this and its uses.
-  template <typename T = void>
-  using EnableIfNotHostHalf = typename std::enable_if_t<!IsHostHalf, T>;
-
   template <typename T = void>
   using EnableIfUsingArrayOnDevice =
       typename std::enable_if_t<IsUsingArrayOnDevice, T>;
@@ -1154,14 +1141,14 @@ template <typename Type, int NumElements> class vec {
 #ifdef __SYCL_DEVICE_ONLY__
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
+  constexpr void setValue(Ty Index, const DataT &Value,
                           int) {
     m_Data[Index] = vec_data<DataT>::set(Value);
   }
 
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
+  constexpr DataT getValue(Ty Index, int) const {
     return vec_data<DataT>::get(m_Data[Index]);
   }
 #else  // __SYCL_DEVICE_ONLY__
diff --git a/sycl/test/check_device_code/math-builtins/vector.cpp b/sycl/test/check_device_code/math-builtins/vector.cpp
index a8dbfba855569..be72b3ff36037 100644
--- a/sycl/test/check_device_code/math-builtins/vector.cpp
+++ b/sycl/test/check_device_code/math-builtins/vector.cpp
@@ -8,75 +8,72 @@ using namespace sycl;
 
 // Create sycl::vec for each type and verify the storage
 // type on device side.
-#define CHECK(Q, T, N)                                                         \
-  {                                                                            \
-      T Result;                                                                \
-      {                                                                        \
-        Q.submit([&](handler &CGH) {                                           \
-          CGH.single_task([=]() {                                              \
-            vec<T, 2> InVec##N##2{static_cast<T>(5)};                          \
-            vec<T, 3> InVec##N##3{static_cast<T>(5)};                          \
-            vec<T, 4> InVec##N##4{static_cast<T>(5)};                          \
-            vec<T, 8> InVec##N##8{static_cast<T>(5)};                          \
-            vec<T, 16> InVec##N##16{static_cast<T>(5)};                        \
-          });                                                                  \
-        });                                                                    \                                                                       
-      }                                                                        \
+#define CHECK(Q, T, N)                                                     \
+  {                                                                        \
+    Q.submit([&](handler &CGH) {                                           \
+      CGH.single_task([=]() {                                              \
+        vec<T, 2> InVec##N##2{static_cast<T>(5)};                          \
+        vec<T, 3> InVec##N##3{static_cast<T>(5)};                          \
+        vec<T, 4> InVec##N##4{static_cast<T>(5)};                          \
+        vec<T, 8> InVec##N##8{static_cast<T>(5)};                          \
+        vec<T, 16> InVec##N##16{static_cast<T>(5)};                        \
+      });                                                                  \
+    });                                                                    \   
   }
 
 int main() {
 
-    queue q;
+  queue q;
 
-    // CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
-    // CHECK: %"struct.std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-    // CHECK: %"struct.std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-    // CHECK: %"struct.std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-    // CHECK: %"struct.std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-    // CHECK: %"struct.std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-    CHECK(q, ext::oneapi::bfloat16, BF)
+  // CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
+  // CHECK: %"struct.std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: %"struct.std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: %"struct.std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: %"struct.std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: %"struct.std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  CHECK(q, ext::oneapi::bfloat16, BF)
 
-    // CHECK: {{.*}}InVecINT2 = {{.*}} %"struct.std::array{{.*}}" { [2 x i32] {{.*}}
-    // CHECK: {{.*}}InVecINT3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i32] {{.*}}
-    // CHECK: {{.*}}InVecINT4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i32] {{.*}}
-    // CHECK: {{.*}}InVecINT8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i32] {{.*}}
-    // CHECK: {{.*}}InVecINT16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i32] {{.*}}
-    CHECK(q, int, INT)
+  // CHECK: {{.*}}InVecINT2 = {{.*}} %"struct.std::array{{.*}}" { [2 x i32] {{.*}}
+  // CHECK: {{.*}}InVecINT3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i32] {{.*}}
+  // CHECK: {{.*}}InVecINT4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i32] {{.*}}
+  // CHECK: {{.*}}InVecINT8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i32] {{.*}}
+  // CHECK: {{.*}}InVecINT16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i32] {{.*}}
+  CHECK(q, int, INT)
 
-    // CHECK: {{.*}}InVecFLOAT2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x float] {{.*}}
-    // CHECK: {{.*}}InVecFLOAT3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x float] {{.*}}
-    // CHECK: {{.*}}InVecFLOAT4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x float] {{.*}}
-    // CHECK: {{.*}}InVecFLOAT8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x float] {{.*}}
-    // CHECK: {{.*}}InVecFLOAT16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x float] {{.*}}
-    CHECK(q, float, FLOAT)
+  // CHECK: {{.*}}InVecFLOAT2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x float] {{.*}}
+  // CHECK: {{.*}}InVecFLOAT3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x float] {{.*}}
+  // CHECK: {{.*}}InVecFLOAT4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x float] {{.*}}
+  // CHECK: {{.*}}InVecFLOAT8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x float] {{.*}}
+  // CHECK: {{.*}}InVecFLOAT16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x float] {{.*}}
+  CHECK(q, float, FLOAT)
 
-    // CHECK: {{.*}}InVecCHAR2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
-    // CHECK: {{.*}}InVecCHAR3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-    // CHECK: {{.*}}InVecCHAR4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-    // CHECK: {{.*}}InVecCHAR8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
-    // CHECK: {{.*}}InVecCHAR16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
-    CHECK(q, char, CHAR)
+  // CHECK: {{.*}}InVecCHAR2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
+  // CHECK: {{.*}}InVecCHAR3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecCHAR4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecCHAR8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
+  // CHECK: {{.*}}InVecCHAR16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
+  CHECK(q, char, CHAR)
 
-    // CHECK: {{.*}}InVecBOOL2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
-    // CHECK: {{.*}}InVecBOOL3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-    // CHECK: {{.*}}InVecBOOL4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-    // CHECK: {{.*}}InVecBOOL8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
-    // CHECK: {{.*}}InVecBOOL16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
-    CHECK(q, bool, BOOL)
+  // CHECK: {{.*}}InVecBOOL2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBOOL3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBOOL4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBOOL8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBOOL16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
+  CHECK(q, bool, BOOL)
 
-    // CHECK: {{.*}}InVecHALF2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x half] {{.*}}
-    // CHECK: {{.*}}InVecHALF3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x half] {{.*}}
-    // CHECK: {{.*}}InVecHALF4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x half] {{.*}}
-    // CHECK: {{.*}}InVecHALF8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x half] {{.*}}
-    // CHECK: {{.*}}InVecHALF16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x half] {{.*}}
-    CHECK(q, half, HALF)
+  // CHECK: {{.*}}InVecHALF2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x half] {{.*}}
+  // CHECK: {{.*}}InVecHALF3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x half] {{.*}}
+  // CHECK: {{.*}}InVecHALF4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x half] {{.*}}
+  // CHECK: {{.*}}InVecHALF8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x half] {{.*}}
+  // CHECK: {{.*}}InVecHALF16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x half] {{.*}}
+  CHECK(q, half, HALF)
 
-    // CHECK: {{.*}}InVecBYTE2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
-    // CHECK: {{.*}}InVecBYTE3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-    // CHECK: {{.*}}InVecBYTE4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-    // CHECK: {{.*}}InVecBYTE8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
-    // CHECK: {{.*}}InVecBYTE16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
-    CHECK(q, std::byte, BYTE)
+  // CHECK: {{.*}}InVecBYTE2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBYTE3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBYTE4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBYTE8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBYTE16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
+  CHECK(q, std::byte, BYTE)
    
   return 0;
 };

From 4cda13a300ac8936bd754dcda47fd5c93ccba183 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 12 Apr 2024 16:19:44 -0700
Subject: [PATCH 14/79] Adress reviews

---
 sycl/include/sycl/types.hpp | 49 ++++++++++++++-----------------------
 1 file changed, 18 insertions(+), 31 deletions(-)

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 5130f2ce5c971..89f211c11e7ad 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -295,15 +295,6 @@ template <typename Type, int NumElements> class vec {
   static constexpr bool IsSizeGreaterThanMaxAlign =
       (Sz > detail::MaxVecAlignment);
 
-  // TODO: There is no support for vector half type on host yet.
-  // Also, when Sz is greater than alignment, we use std::array instead of
-  // vector extension. This is for MSVC compatibility, which has a max alignment
-  // of 64 for direct params. If we drop MSVC, we can have alignment the same as
-  // size and use vector extensions for all sizes.
-  // TODO: Inline this ans we are now always using array on device, irrespective
-  // of the data type.
-  static constexpr bool IsUsingArrayOnDevice = true;
-
 #ifdef __SYCL_DEVICE_ONLY__
   static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
 #else
@@ -495,12 +486,8 @@ template <typename Type, int NumElements> class vec {
   }
 
 #ifdef __SYCL_DEVICE_ONLY__
-  template <typename T = void>
-  using EnableIfUsingArrayOnDevice =
-      typename std::enable_if_t<IsUsingArrayOnDevice, T>;
-
   template <typename Ty = DataT>
-  explicit constexpr vec(const EnableIfUsingArrayOnDevice<Ty> &arg)
+  explicit constexpr vec(const Ty &arg)
       : vec{detail::RepeatValue<NumElements>(
                 static_cast<vec_data_t<DataT>>(arg)),
             std::make_index_sequence<NumElements>()} {}
@@ -512,7 +499,7 @@ template <typename Type, int NumElements> class vec {
       vec &>
   // TODO: Can we use std::fill or something similar to vectorize assignment
   // operation?
-  operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
+  operator=(const Ty &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
     }
@@ -563,7 +550,7 @@ template <typename Type, int NumElements> class vec {
     if constexpr (NumElements == 1) {
       return m_Data;
     } else {
-      return detail::BitCast<DataType, vector_t>(m_Data);
+      return sycl::bit_cast<vector_t>(m_Data);
     }
   }
 #endif // __SYCL_DEVICE_ONLY__
@@ -629,7 +616,7 @@ template <typename Type, int NumElements> class vec {
     using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
     using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
 
-    auto extVecType = detail::BitCast<DataType, vector_t>(m_Data);
+    auto NativeVector = sycl::bit_cast<vector_t>(m_Data);
     using ConvertTVecType = typename vec<convertT, NumElements>::vector_t;
 
     // Whole vector conversion can only be done, if:
@@ -653,9 +640,9 @@ template <typename Type, int NumElements> class vec {
         //   right results here;
         !std::is_same_v<convertT, bool>;
     if constexpr (canUseNativeVectorConvert) {
-      Result.m_Data = detail::BitCast<ConvertTVecType, decltype(Result.m_Data)>(
+      Result.m_Data = sycl::bit_cast<decltype(Result.m_Data)>(
           detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
-                              OpenCLVecR>(extVecType));
+                              OpenCLVecR>(NativeVector));
     } else
 #endif // __SYCL_DEVICE_ONLY__
     {
@@ -830,8 +817,8 @@ template <typename Type, int NumElements> class vec {
         Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = detail::BitCast<DataType, vector_t>(Lhs.m_Data);    \
-      vector_t ExtVecRhs = detail::BitCast<DataType, vector_t>(Rhs.m_Data);    \
+      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
+      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
       Ret = vec<DataT, NumElements>(                                           \
           (typename vec<DataT, NumElements>::vector_t)(                        \
               ExtVecLhs BINOP ExtVecRhs));                                     \
@@ -931,8 +918,8 @@ template <typename Type, int NumElements> class vec {
             Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = detail::BitCast<DataType, vector_t>(Lhs.m_Data);    \
-      vector_t ExtVecRhs = detail::BitCast<DataType, vector_t>(Rhs.m_Data);    \
+      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
+      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
               ExtVecLhs RELLOGOP ExtVecRhs));                                  \
@@ -1006,7 +993,7 @@ template <typename Type, int NumElements> class vec {
   // && dataT != half
   friend vec operator~(const vec &Rhs) {
 #ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = detail::BitCast<DataType, vector_t>(Rhs.m_Data);
+    auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
     vec Ret{~extVec};
     if constexpr (std::is_same_v<Type, bool>) {
       Ret.ConvertToDataT();
@@ -1033,7 +1020,7 @@ template <typename Type, int NumElements> class vec {
                   1)
 #endif
     {
-      auto extVec = detail::BitCast<DataType, vector_t>(Rhs.m_Data);
+      auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
       return vec<detail::rel_t<DataT>, NumElements>{!extVec};
     } else
 #endif
@@ -1057,7 +1044,7 @@ template <typename Type, int NumElements> class vec {
   // operator +
   friend vec operator+(const vec &Lhs) {
 #ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = detail::BitCast<DataType, vector_t>(Lhs.m_Data);
+    auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
     return vec{+extVec};
 #else
     vec Ret{};
@@ -1088,7 +1075,7 @@ template <typename Type, int NumElements> class vec {
         Ret.setValue(
             I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
 #else
-      auto extVec = detail::BitCast<DataType, vector_t>(Lhs.m_Data);
+      auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
       Ret = vec{-extVec};
       if constexpr (std::is_same_v<Type, bool>) {
         Ret.ConvertToDataT();
@@ -1112,14 +1099,14 @@ template <typename Type, int NumElements> class vec {
   template <template <typename> class Operation,
             typename Ty = vec<DataT, NumElements>>
   vec<DataT, NumElements>
-  operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
+  operatorHelper(const Ty &Rhs) const {
     vec<DataT, NumElements> Result;
     Operation<DataT> Op;
     // Typecast to ext_vector_type, carryout the operation, and type cast back.
     // Compiler optimizations will remove redundant casts.
-    auto OpResult = Op(detail::BitCast<DataType, vector_t>(m_Data),
-                       detail::BitCast<DataType, vector_t>(Rhs.m_Data));
-    Result.m_Data = detail::BitCast<vector_t, DataType>(OpResult);
+    auto OpResult = Op(sycl::bit_cast<vector_t>(m_Data),
+                       sycl::bit_cast<vector_t>(Rhs.m_Data));
+    Result.m_Data = sycl::bit_cast<DataType>(OpResult);
     return Result;
   }
 #else  // __SYCL_DEVICE_ONLY__

From 91301c38d15324b6d8ec2891f3b8197a52d490c7 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Sun, 14 Apr 2024 10:07:25 -0700
Subject: [PATCH 15/79] Fix failures

---
 sycl/include/sycl/types.hpp                   |  3 +-
 .../math-builtins/vector.cpp                  | 70 +++++++++----------
 2 files changed, 36 insertions(+), 37 deletions(-)

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 89f211c11e7ad..a4a3fd5652b08 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -486,8 +486,7 @@ template <typename Type, int NumElements> class vec {
   }
 
 #ifdef __SYCL_DEVICE_ONLY__
-  template <typename Ty = DataT>
-  explicit constexpr vec(const Ty &arg)
+  explicit constexpr vec(const DataT &arg)
       : vec{detail::RepeatValue<NumElements>(
                 static_cast<vec_data_t<DataT>>(arg)),
             std::make_index_sequence<NumElements>()} {}
diff --git a/sycl/test/check_device_code/math-builtins/vector.cpp b/sycl/test/check_device_code/math-builtins/vector.cpp
index be72b3ff36037..50d0ffca85161 100644
--- a/sycl/test/check_device_code/math-builtins/vector.cpp
+++ b/sycl/test/check_device_code/math-builtins/vector.cpp
@@ -26,53 +26,53 @@ int main() {
   queue q;
 
   // CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
-  // CHECK: %"struct.std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: %"struct.std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: %"struct.std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: %"struct.std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: %"struct.std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: {{.*}}std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: {{.*}}std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: {{.*}}std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: {{.*}}std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: {{.*}}std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
   CHECK(q, ext::oneapi::bfloat16, BF)
 
-  // CHECK: {{.*}}InVecINT2 = {{.*}} %"struct.std::array{{.*}}" { [2 x i32] {{.*}}
-  // CHECK: {{.*}}InVecINT3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i32] {{.*}}
-  // CHECK: {{.*}}InVecINT4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i32] {{.*}}
-  // CHECK: {{.*}}InVecINT8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i32] {{.*}}
-  // CHECK: {{.*}}InVecINT16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i32] {{.*}}
+  // CHECK: {{.*}}InVecINT2 = {{.*}}std::array{{.*}}" { [2 x i32] {{.*}}
+  // CHECK: {{.*}}InVecINT3 = {{.*}}std::array.{{.*}}" { [4 x i32] {{.*}}
+  // CHECK: {{.*}}InVecINT4 = {{.*}}std::array.{{.*}}" { [4 x i32] {{.*}}
+  // CHECK: {{.*}}InVecINT8 = {{.*}}std::array.{{.*}}" { [8 x i32] {{.*}}
+  // CHECK: {{.*}}InVecINT16 = {{.*}}std::array.{{.*}}" { [16 x i32] {{.*}}
   CHECK(q, int, INT)
 
-  // CHECK: {{.*}}InVecFLOAT2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x float] {{.*}}
-  // CHECK: {{.*}}InVecFLOAT3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x float] {{.*}}
-  // CHECK: {{.*}}InVecFLOAT4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x float] {{.*}}
-  // CHECK: {{.*}}InVecFLOAT8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x float] {{.*}}
-  // CHECK: {{.*}}InVecFLOAT16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x float] {{.*}}
+  // CHECK: {{.*}}InVecFLOAT2 = {{.*}}std::array.{{.*}}" { [2 x float] {{.*}}
+  // CHECK: {{.*}}InVecFLOAT3 = {{.*}}std::array.{{.*}}" { [4 x float] {{.*}}
+  // CHECK: {{.*}}InVecFLOAT4 = {{.*}}std::array.{{.*}}" { [4 x float] {{.*}}
+  // CHECK: {{.*}}InVecFLOAT8 = {{.*}}std::array.{{.*}}" { [8 x float] {{.*}}
+  // CHECK: {{.*}}InVecFLOAT16 = {{.*}}std::array.{{.*}}" { [16 x float] {{.*}}
   CHECK(q, float, FLOAT)
 
-  // CHECK: {{.*}}InVecCHAR2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
-  // CHECK: {{.*}}InVecCHAR3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecCHAR4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecCHAR8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
-  // CHECK: {{.*}}InVecCHAR16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
+  // CHECK: {{.*}}InVecCHAR2 = {{.*}}std::array.{{.*}}" { [2 x i8] {{.*}}
+  // CHECK: {{.*}}InVecCHAR3 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecCHAR4 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecCHAR8 = {{.*}}std::array.{{.*}}" { [8 x i8] {{.*}}
+  // CHECK: {{.*}}InVecCHAR16 = {{.*}}std::array.{{.*}}" { [16 x i8] {{.*}}
   CHECK(q, char, CHAR)
 
-  // CHECK: {{.*}}InVecBOOL2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBOOL3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBOOL4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBOOL8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBOOL16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBOOL2 = {{.*}}std::array.{{.*}}" { [2 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBOOL3 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBOOL4 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBOOL8 = {{.*}}std::array.{{.*}}" { [8 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBOOL16 = {{.*}}std::array.{{.*}}" { [16 x i8] {{.*}}
   CHECK(q, bool, BOOL)
 
-  // CHECK: {{.*}}InVecHALF2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x half] {{.*}}
-  // CHECK: {{.*}}InVecHALF3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x half] {{.*}}
-  // CHECK: {{.*}}InVecHALF4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x half] {{.*}}
-  // CHECK: {{.*}}InVecHALF8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x half] {{.*}}
-  // CHECK: {{.*}}InVecHALF16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x half] {{.*}}
+  // CHECK: {{.*}}InVecHALF2 = {{.*}}std::array.{{.*}}" { [2 x half] {{.*}}
+  // CHECK: {{.*}}InVecHALF3 = {{.*}}std::array.{{.*}}" { [4 x half] {{.*}}
+  // CHECK: {{.*}}InVecHALF4 = {{.*}}std::array.{{.*}}" { [4 x half] {{.*}}
+  // CHECK: {{.*}}InVecHALF8 = {{.*}}std::array.{{.*}}" { [8 x half] {{.*}}
+  // CHECK: {{.*}}InVecHALF16 = {{.*}}std::array.{{.*}}" { [16 x half] {{.*}}
   CHECK(q, half, HALF)
 
-  // CHECK: {{.*}}InVecBYTE2 = {{.*}} %"struct.std::array.{{.*}}" { [2 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBYTE3 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBYTE4 = {{.*}} %"struct.std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBYTE8 = {{.*}} %"struct.std::array.{{.*}}" { [8 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBYTE16 = {{.*}} %"struct.std::array.{{.*}}" { [16 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBYTE2 = {{.*}}std::array.{{.*}}" { [2 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBYTE3 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBYTE4 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBYTE8 = {{.*}}std::array.{{.*}}" { [8 x i8] {{.*}}
+  // CHECK: {{.*}}InVecBYTE16 = {{.*}}std::array.{{.*}}" { [16 x i8] {{.*}}
   CHECK(q, std::byte, BYTE)
    
   return 0;

From 7305e3b7248869b65af08a86da5a60287d394b9c Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 16 Apr 2024 08:00:55 -0700
Subject: [PATCH 16/79] Fix

---
 sycl/include/sycl/detail/generic_type_traits.hpp |  2 +-
 sycl/include/sycl/half_type.hpp                  | 10 +++++-----
 sycl/include/sycl/types.hpp                      |  4 ++--
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 961e0fdf3072b..967d35eb69871 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -325,7 +325,7 @@ template <typename T> auto convertToOpenCLType(T &&x) {
                                                    std::declval<ElemTy>()))>,
                             no_ref::size()>;
 #ifdef __SYCL_DEVICE_ONLY__
-    return bit_cast<typename MatchingVec::vector_t>(x);
+    return sycl::bit_cast<typename MatchingVec::vector_t>(x);
 #else
     return x.template as<MatchingVec>();
 #endif
diff --git a/sycl/include/sycl/half_type.hpp b/sycl/include/sycl/half_type.hpp
index 0c22f309bd4e0..b55efd234b97c 100644
--- a/sycl/include/sycl/half_type.hpp
+++ b/sycl/include/sycl/half_type.hpp
@@ -250,11 +250,11 @@ using Vec4StorageT = StorageT __attribute__((ext_vector_type(4)));
 using Vec8StorageT = StorageT __attribute__((ext_vector_type(8)));
 using Vec16StorageT = StorageT __attribute__((ext_vector_type(16)));
 
-using Vec2DeviceStorageT = std::array<StorageT, 2>;
-using Vec3DeviceStorageT = std::array<StorageT, 4>;
-using Vec4DeviceStorageT = std::array<StorageT, 4>;
-using Vec8DeviceStorageT = std::array<StorageT, 8>;
-using Vec16DeviceStorageT = std::array<StorageT, 16>;
+using Vec2DeviceStorageT = std::array<sycl::half, 2>;
+using Vec3DeviceStorageT = std::array<sycl::half, 4>;
+using Vec4DeviceStorageT = std::array<sycl::half, 4>;
+using Vec8DeviceStorageT = std::array<sycl::half, 8>;
+using Vec16DeviceStorageT = std::array<sycl::half, 16>;
 #else // SYCL_DEVICE_ONLY
 using StorageT = detail::host_half_impl::half;
 // No need to extract underlying data type for built-in functions operating on
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index a4a3fd5652b08..dcc4f01fa9970 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -121,7 +121,7 @@ static constexpr ToType BitCast(const FromType &Value) {
 #endif
 }
 
-/* Heper functions to get and set values in vec, depdending on the underlying
+/* Helper functions to get and set values in vec, depdending on the underlying
  * data type. */
 template <typename T> struct vec_helper {
   using RetType = T;
@@ -536,7 +536,7 @@ template <typename Type, int NumElements> class vec {
             typename =
                 typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
                                           !std::is_same_v<vector_t_, DataT>>>
-  constexpr vec(vector_t openclVector) {
+  constexpr vec(vector_t_ openclVector) {
     m_Data = detail::BitCast<vector_t, DataType>(openclVector);
   }
 

From f8840c2b4cae83b29f1a230eb1932fb7ee02a23a Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 16 Apr 2024 09:00:19 -0700
Subject: [PATCH 17/79] Fix formatting and device code check test case.

---
 sycl/include/sycl/types.hpp                   |  8 ++--
 .../math-builtins/vector.cpp                  | 38 +++++++++----------
 2 files changed, 22 insertions(+), 24 deletions(-)

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index dcc4f01fa9970..003e743fb181f 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -498,7 +498,7 @@ template <typename Type, int NumElements> class vec {
       vec &>
   // TODO: Can we use std::fill or something similar to vectorize assignment
   // operation?
-  operator=(const Ty &Rhs) {
+  operator=(const Ty & Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
     }
@@ -1097,8 +1097,7 @@ template <typename Type, int NumElements> class vec {
 #ifdef __SYCL_DEVICE_ONLY__
   template <template <typename> class Operation,
             typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements>
-  operatorHelper(const Ty &Rhs) const {
+  vec<DataT, NumElements> operatorHelper(const Ty &Rhs) const {
     vec<DataT, NumElements> Result;
     Operation<DataT> Op;
     // Typecast to ext_vector_type, carryout the operation, and type cast back.
@@ -1127,8 +1126,7 @@ template <typename Type, int NumElements> class vec {
 #ifdef __SYCL_DEVICE_ONLY__
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(Ty Index, const DataT &Value,
-                          int) {
+  constexpr void setValue(Ty Index, const DataT &Value, int) {
     m_Data[Index] = vec_data<DataT>::set(Value);
   }
 
diff --git a/sycl/test/check_device_code/math-builtins/vector.cpp b/sycl/test/check_device_code/math-builtins/vector.cpp
index 50d0ffca85161..71190f4cd2480 100644
--- a/sycl/test/check_device_code/math-builtins/vector.cpp
+++ b/sycl/test/check_device_code/math-builtins/vector.cpp
@@ -1,24 +1,24 @@
 // RUN: %clangxx -fsycl-device-only -S -O0 -Xclang -emit-llvm -o - %s | FileCheck %s --dump-input=always
 
-// This test checks that sycl::vec uses std::array as storage type on device for all
-// data types.
+// This test checks that sycl::vec uses std::array as storage type on device for
+// all data types.
 #include <sycl/sycl.hpp>
 
 using namespace sycl;
 
 // Create sycl::vec for each type and verify the storage
 // type on device side.
-#define CHECK(Q, T, N)                                                     \
-  {                                                                        \
-    Q.submit([&](handler &CGH) {                                           \
-      CGH.single_task([=]() {                                              \
-        vec<T, 2> InVec##N##2{static_cast<T>(5)};                          \
-        vec<T, 3> InVec##N##3{static_cast<T>(5)};                          \
-        vec<T, 4> InVec##N##4{static_cast<T>(5)};                          \
-        vec<T, 8> InVec##N##8{static_cast<T>(5)};                          \
-        vec<T, 16> InVec##N##16{static_cast<T>(5)};                        \
-      });                                                                  \
-    });                                                                    \   
+#define CHECK(Q, T, N)                                                       \
+  {                                                                          \
+    Q.submit([&](handler &CGH) {                                             \
+      CGH.single_task([=]() {                                                \
+        vec<T, 2> InVec##N##2{static_cast<T>(5)};                            \
+        vec<T, 3> InVec##N##3{static_cast<T>(5)};                            \
+        vec<T, 4> InVec##N##4{static_cast<T>(5)};                            \
+        vec<T, 8> InVec##N##8{static_cast<T>(5)};                            \
+        vec<T, 16> InVec##N##16{static_cast<T>(5)};                          \
+      });                                                                    \
+    });                                                                      \
   }
 
 int main() {
@@ -61,11 +61,11 @@ int main() {
   // CHECK: {{.*}}InVecBOOL16 = {{.*}}std::array.{{.*}}" { [16 x i8] {{.*}}
   CHECK(q, bool, BOOL)
 
-  // CHECK: {{.*}}InVecHALF2 = {{.*}}std::array.{{.*}}" { [2 x half] {{.*}}
-  // CHECK: {{.*}}InVecHALF3 = {{.*}}std::array.{{.*}}" { [4 x half] {{.*}}
-  // CHECK: {{.*}}InVecHALF4 = {{.*}}std::array.{{.*}}" { [4 x half] {{.*}}
-  // CHECK: {{.*}}InVecHALF8 = {{.*}}std::array.{{.*}}" { [8 x half] {{.*}}
-  // CHECK: {{.*}}InVecHALF16 = {{.*}}std::array.{{.*}}" { [16 x half] {{.*}}
+  // CHECK: {{.*}}InVecHALF2 = {{.*}}std::array.{{.*}}" { [2 x %"class.sycl::_V1::detail::half_impl::half"] {{.*}}
+  // CHECK: {{.*}}InVecHALF3 = {{.*}}std::array.{{.*}}" { [4 x %"class.sycl::_V1::detail::half_impl::half"] {{.*}}
+  // CHECK: {{.*}}InVecHALF4 = {{.*}}std::array.{{.*}}" { [4 x %"class.sycl::_V1::detail::half_impl::half"] {{.*}}
+  // CHECK: {{.*}}InVecHALF8 = {{.*}}std::array.{{.*}}" { [8 x %"class.sycl::_V1::detail::half_impl::half"] {{.*}}
+  // CHECK: {{.*}}InVecHALF16 = {{.*}}std::array.{{.*}}" { [16 x %"class.sycl::_V1::detail::half_impl::half"] {{.*}}
   CHECK(q, half, HALF)
 
   // CHECK: {{.*}}InVecBYTE2 = {{.*}}std::array.{{.*}}" { [2 x i8] {{.*}}
@@ -74,6 +74,6 @@ int main() {
   // CHECK: {{.*}}InVecBYTE8 = {{.*}}std::array.{{.*}}" { [8 x i8] {{.*}}
   // CHECK: {{.*}}InVecBYTE16 = {{.*}}std::array.{{.*}}" { [16 x i8] {{.*}}
   CHECK(q, std::byte, BYTE)
-   
+
   return 0;
 };

From ea6f828ae2f55a41f51e480007057f6aaccb312f Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 16 Apr 2024 09:09:12 -0700
Subject: [PATCH 18/79] Fix formatting

---
 .../math-builtins/vector.cpp                  | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/sycl/test/check_device_code/math-builtins/vector.cpp b/sycl/test/check_device_code/math-builtins/vector.cpp
index 71190f4cd2480..bf0c4b8b71bec 100644
--- a/sycl/test/check_device_code/math-builtins/vector.cpp
+++ b/sycl/test/check_device_code/math-builtins/vector.cpp
@@ -8,17 +8,17 @@ using namespace sycl;
 
 // Create sycl::vec for each type and verify the storage
 // type on device side.
-#define CHECK(Q, T, N)                                                       \
-  {                                                                          \
-    Q.submit([&](handler &CGH) {                                             \
-      CGH.single_task([=]() {                                                \
-        vec<T, 2> InVec##N##2{static_cast<T>(5)};                            \
-        vec<T, 3> InVec##N##3{static_cast<T>(5)};                            \
-        vec<T, 4> InVec##N##4{static_cast<T>(5)};                            \
-        vec<T, 8> InVec##N##8{static_cast<T>(5)};                            \
-        vec<T, 16> InVec##N##16{static_cast<T>(5)};                          \
-      });                                                                    \
-    });                                                                      \
+#define CHECK(Q, T, N)                                                         \
+  {                                                                            \
+    Q.submit([&](handler &CGH) {                                               \
+      CGH.single_task([=]() {                                                  \
+        vec<T, 2> InVec##N##2{static_cast<T>(5)};                              \
+        vec<T, 3> InVec##N##3{static_cast<T>(5)};                              \
+        vec<T, 4> InVec##N##4{static_cast<T>(5)};                              \
+        vec<T, 8> InVec##N##8{static_cast<T>(5)};                              \
+        vec<T, 16> InVec##N##16{static_cast<T>(5)};                            \
+      });                                                                      \
+    });                                                                        \
   }
 
 int main() {

From 686b9fcf9d5478847d9a8015e20ed38ca591d157 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 16 Apr 2024 09:15:54 -0700
Subject: [PATCH 19/79] More formatting

---
 sycl/test/check_device_code/math-builtins/vector.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/sycl/test/check_device_code/math-builtins/vector.cpp b/sycl/test/check_device_code/math-builtins/vector.cpp
index bf0c4b8b71bec..a02e20f609594 100644
--- a/sycl/test/check_device_code/math-builtins/vector.cpp
+++ b/sycl/test/check_device_code/math-builtins/vector.cpp
@@ -12,11 +12,11 @@ using namespace sycl;
   {                                                                            \
     Q.submit([&](handler &CGH) {                                               \
       CGH.single_task([=]() {                                                  \
-        vec<T, 2> InVec##N##2{static_cast<T>(5)};                              \
-        vec<T, 3> InVec##N##3{static_cast<T>(5)};                              \
-        vec<T, 4> InVec##N##4{static_cast<T>(5)};                              \
-        vec<T, 8> InVec##N##8{static_cast<T>(5)};                              \
-        vec<T, 16> InVec##N##16{static_cast<T>(5)};                            \
+        vec<T, 2> InVec##N##2 {static_cast<T>(5)};                             \
+        vec<T, 3> InVec##N##3 {static_cast<T>(5)};                             \
+        vec<T, 4> InVec##N##4 {static_cast<T>(5)};                             \
+        vec<T, 8> InVec##N##8 {static_cast<T>(5)};                             \
+        vec<T, 16> InVec##N##16 {static_cast<T>(5)};                           \
       });                                                                      \
     });                                                                        \
   }

From 7af74daf5556042979af06c1e3e5093b9ad40472 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 17 Apr 2024 09:36:33 -0700
Subject: [PATCH 20/79] Remove comments

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

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 003e743fb181f..44681919c64c7 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -496,8 +496,7 @@ template <typename Type, int NumElements> class vec {
       std::is_fundamental_v<vec_data_t<Ty>> ||
           detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
-  // TODO: Can we use std::fill or something similar to vectorize assignment
-  // operation?
+
   operator=(const Ty & Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
@@ -821,7 +820,6 @@ template <typename Type, int NumElements> class vec {
       Ret = vec<DataT, NumElements>(                                           \
           (typename vec<DataT, NumElements>::vector_t)(                        \
               ExtVecLhs BINOP ExtVecRhs));                                     \
-      /*[Udit] Do we still need this? */                                       \
       if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
         Ret.ConvertToDataT();                                                  \
       }                                                                        \

From 88ae8af53befdcfcc440cb6951b1a3fc9626c8fc Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 17 Apr 2024 16:14:41 -0700
Subject: [PATCH 21/79] Fix SYCL-CTS

---
 sycl/include/sycl/types.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 44681919c64c7..3a120b0ebb3f3 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -623,6 +623,7 @@ template <typename Type, int NumElements> class vec {
         // - we are not on CUDA, see intel/llvm#11840
         false &&
 #endif
+        NumElements > 1 &&
         // - vec storage has an equivalent OpenCL native vector it is implicitly
         //   convertible to. There are some corner cases where it is not the
         //   case with char, long and long long types.

From 2c33af141fdbd91499354238a85c131d71660738 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 18 Apr 2024 11:25:20 -0700
Subject: [PATCH 22/79] Wrap changes in PREVIEW_BREAKING_FLAG

---
 .../sycl/detail/generic_type_traits.hpp       |   13 +
 sycl/include/sycl/ext/oneapi/bfloat16.hpp     |    3 +
 sycl/include/sycl/half_type.hpp               |    3 +
 sycl/include/sycl/types.hpp                   |  412 +--
 sycl/include/sycl/types_preview.hpp           | 2245 +++++++++++++++++
 sycl/test/abi/layout_vec.cpp                  |   21 +-
 .../math-builtins/vector.cpp                  |    2 +-
 7 files changed, 2541 insertions(+), 158 deletions(-)
 create mode 100644 sycl/include/sycl/types_preview.hpp

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 967d35eb69871..31560715a45f1 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -325,7 +325,20 @@ template <typename T> auto convertToOpenCLType(T &&x) {
                                                    std::declval<ElemTy>()))>,
                             no_ref::size()>;
 #ifdef __SYCL_DEVICE_ONLY__
+
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
+    // TODO: for some mysterious reasons on NonUniformGroups E2E tests fail if
+    // we use the "else" version only. I suspect that's an issues with
+    // non-uniform groups implementation.
+    if constexpr (std::is_same_v<MatchingVec, no_ref>)
+      return static_cast<typename MatchingVec::vector_t>(x);
+    else
+      return static_cast<typename MatchingVec::vector_t>(
+          x.template as<MatchingVec>());
+#else // __INTEL_PREVIEW_BREAKING_CHANGES
     return sycl::bit_cast<typename MatchingVec::vector_t>(x);
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
+
 #else
     return x.template as<MatchingVec>();
 #endif
diff --git a/sycl/include/sycl/ext/oneapi/bfloat16.hpp b/sycl/include/sycl/ext/oneapi/bfloat16.hpp
index fe20f8c799cb1..cfa6cf8814462 100644
--- a/sycl/include/sycl/ext/oneapi/bfloat16.hpp
+++ b/sycl/include/sycl/ext/oneapi/bfloat16.hpp
@@ -39,11 +39,14 @@ using Vec4StorageT = Bfloat16StorageT __attribute__((ext_vector_type(4)));
 using Vec8StorageT = Bfloat16StorageT __attribute__((ext_vector_type(8)));
 using Vec16StorageT = Bfloat16StorageT __attribute__((ext_vector_type(16)));
 
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 using Vec2DeviceStorageT = std::array<Bfloat16StorageT, 2>;
 using Vec3DeviceStorageT = std::array<Bfloat16StorageT, 4>;
 using Vec4DeviceStorageT = std::array<Bfloat16StorageT, 4>;
 using Vec8DeviceStorageT = std::array<Bfloat16StorageT, 8>;
 using Vec16DeviceStorageT = std::array<Bfloat16StorageT, 16>;
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
+
 #else
 using Vec2StorageT = std::array<Bfloat16StorageT, 2>;
 using Vec3StorageT = std::array<Bfloat16StorageT, 3>;
diff --git a/sycl/include/sycl/half_type.hpp b/sycl/include/sycl/half_type.hpp
index b55efd234b97c..07b4b93db060a 100644
--- a/sycl/include/sycl/half_type.hpp
+++ b/sycl/include/sycl/half_type.hpp
@@ -250,11 +250,14 @@ using Vec4StorageT = StorageT __attribute__((ext_vector_type(4)));
 using Vec8StorageT = StorageT __attribute__((ext_vector_type(8)));
 using Vec16StorageT = StorageT __attribute__((ext_vector_type(16)));
 
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 using Vec2DeviceStorageT = std::array<sycl::half, 2>;
 using Vec3DeviceStorageT = std::array<sycl::half, 4>;
 using Vec4DeviceStorageT = std::array<sycl::half, 4>;
 using Vec8DeviceStorageT = std::array<sycl::half, 8>;
 using Vec16DeviceStorageT = std::array<sycl::half, 16>;
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
+
 #else // SYCL_DEVICE_ONLY
 using StorageT = detail::host_half_impl::half;
 // No need to extract underlying data type for built-in functions operating on
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 3a120b0ebb3f3..4382b71c4b375 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -8,6 +8,10 @@
 
 #pragma once
 
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+#include <sycl/types_preview.hpp>
+#else // __INTEL_PREVIEW_BREAKING_CHANGES
+
 // Check if Clang's ext_vector_type attribute is available. Host compiler
 // may not be Clang, and Clang may not be built with the extension.
 #ifdef __clang__
@@ -26,6 +30,10 @@
 #error "SYCL device compiler is built without ext_vector_type support"
 #endif
 
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_USE_EXT_VECTOR_TYPE__
+#endif
+
 #include <sycl/access/access.hpp>              // for decorated, address_space
 #include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
 #include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
@@ -99,30 +107,6 @@ using select_apply_cl_t = std::conditional_t<
     std::conditional_t<sizeof(_IN) == 2, T16,
                        std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
 
-// Helper function to bit_cast one type to another.
-template <typename FromType, typename ToType>
-static constexpr ToType BitCast(const FromType &Value) {
-
-  static_assert(sizeof(FromType) == sizeof(ToType),
-                "BitCast: sizes of types are different");
-
-#ifdef __SYCL_BITCAST_IS_CONSTEXPR
-  return sycl::bit_cast<ToType>(Value);
-#else
-  // Awkward workaround. sycl::bit_cast isn't constexpr in older GCC
-  // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
-  // but neither available yet.
-  union {
-    const FromType from;
-    ToType to;
-  } result = {};
-  result.from = Value;
-  return result.to;
-#endif
-}
-
-/* Helper functions to get and set values in vec, depdending on the underlying
- * data type. */
 template <typename T> struct vec_helper {
   using RetType = T;
   static constexpr RetType get(T value) { return value; }
@@ -138,14 +122,35 @@ template <> struct vec_helper<bool> {
 template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
   using RetType = sycl::ext::oneapi::bfloat16;
   using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
-
   static constexpr RetType get(BFloat16StorageT value) {
-    return BitCast<BFloat16StorageT, RetType>(value);
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<RetType>(value);
+#else
+    // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+    // but neither available yet.
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.storage = value;
+    return result.bf16;
+#endif
   }
+
   static constexpr RetType get(RetType value) { return value; }
 
   static constexpr BFloat16StorageT set(RetType value) {
-    return BitCast<RetType, BFloat16StorageT>(value);
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<BFloat16StorageT>(value);
+#else
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.bf16 = value;
+    return result.storage;
+#endif
   }
 };
 
@@ -287,6 +292,11 @@ template <typename Type, int NumElements> class vec {
   // in the class, so vec<float, 16> should be equal to float16 in memory.
   using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
 
+  static constexpr bool IsHostHalf =
+      std::is_same_v<DataT, sycl::detail::half_impl::half> &&
+      std::is_same_v<sycl::detail::half_impl::StorageT,
+                     sycl::detail::host_half_impl::half>;
+
   static constexpr bool IsBfloat16 =
       std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
 
@@ -295,9 +305,19 @@ template <typename Type, int NumElements> class vec {
   static constexpr bool IsSizeGreaterThanMaxAlign =
       (Sz > detail::MaxVecAlignment);
 
-#ifdef __SYCL_DEVICE_ONLY__
+  // TODO: There is no support for vector half type on host yet.
+  // Also, when Sz is greater than alignment, we use std::array instead of
+  // vector extension. This is for MSVC compatibility, which has a max alignment
+  // of 64 for direct params. If we drop MSVC, we can have alignment the same as
+  // size and use vector extensions for all sizes.
+  static constexpr bool IsUsingArrayOnDevice =
+      (IsHostHalf || IsBfloat16 || IsSizeGreaterThanMaxAlign);
+
+#if defined(__SYCL_DEVICE_ONLY__)
+  static constexpr bool NativeVec = NumElements > 1 && !IsUsingArrayOnDevice;
   static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
 #else
+  static constexpr bool NativeVec = false;
   static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
 #endif
 
@@ -463,7 +483,6 @@ template <typename Type, int NumElements> class vec {
   using value_type = DataT;
   using rel_t = detail::rel_t<DataT>;
 #ifdef __SYCL_DEVICE_ONLY__
-  // Type used for passing sycl::vec to SPIRV builtins.
   using vector_t =
       typename detail::VecStorage<DataT, NumElements>::VectorDataType;
 #endif // __SYCL_DEVICE_ONLY__
@@ -485,8 +504,49 @@ template <typename Type, int NumElements> class vec {
     return *this;
   }
 
-#ifdef __SYCL_DEVICE_ONLY__
-  explicit constexpr vec(const DataT &arg)
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <typename T = void>
+  using EnableIfNotHostHalf = typename std::enable_if_t<!IsHostHalf, T>;
+
+  template <typename T = void>
+  using EnableIfHostHalf = typename std::enable_if_t<IsHostHalf, T>;
+
+  template <typename T = void>
+  using EnableIfUsingArrayOnDevice =
+      typename std::enable_if_t<IsUsingArrayOnDevice, T>;
+
+  template <typename T = void>
+  using EnableIfNotUsingArrayOnDevice =
+      typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  template <typename T = void>
+  using EnableIfUsingArray =
+      typename std::enable_if_t<IsUsingArrayOnDevice || IsUsingArrayOnHost, T>;
+
+  template <typename T = void>
+  using EnableIfNotUsingArray =
+      typename std::enable_if_t<!IsUsingArrayOnDevice && !IsUsingArrayOnHost,
+                                T>;
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+
+  template <typename Ty = DataT>
+  explicit constexpr vec(const EnableIfNotUsingArrayOnDevice<Ty> &arg)
+      : m_Data{DataType(vec_data<Ty>::get(arg))} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) {
+    m_Data = (DataType)vec_data<Ty>::get(Rhs);
+    return *this;
+  }
+
+  template <typename Ty = DataT>
+  explicit constexpr vec(const EnableIfUsingArrayOnDevice<Ty> &arg)
       : vec{detail::RepeatValue<NumElements>(
                 static_cast<vec_data_t<DataT>>(arg)),
             std::make_index_sequence<NumElements>()} {}
@@ -496,14 +556,13 @@ template <typename Type, int NumElements> class vec {
       std::is_fundamental_v<vec_data_t<Ty>> ||
           detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
-
-  operator=(const Ty & Rhs) {
+  operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
     }
     return *this;
   }
-#else  // __SYCL_DEVICE_ONLY__
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
   explicit constexpr vec(const DataT &arg)
       : vec{detail::RepeatValue<NumElements>(
                 static_cast<vec_data_t<DataT>>(arg)),
@@ -520,7 +579,58 @@ template <typename Type, int NumElements> class vec {
     }
     return *this;
   }
-#endif // __SYCL_DEVICE_ONLY__
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  // Optimized naive constructors with NumElements of DataT values.
+  // We don't expect compilers to optimize vararg recursive functions well.
+
+  // Helper type to make specific constructors available only for specific
+  // number of elements.
+  template <int IdxNum, typename T = void>
+  using EnableIfMultipleElems = typename std::enable_if_t<
+      std::is_convertible_v<T, DataT> && NumElements == IdxNum, DataT>;
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<2, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<3, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<4, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const Ty Arg3)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<8, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const DataT Arg3, const DataT Arg4, const DataT Arg5,
+                const DataT Arg6, const DataT Arg7)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
+               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
+               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<16, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const DataT Arg3, const DataT Arg4, const DataT Arg5,
+                const DataT Arg6, const DataT Arg7, const DataT Arg8,
+                const DataT Arg9, const DataT ArgA, const DataT ArgB,
+                const DataT ArgC, const DataT ArgD, const DataT ArgE,
+                const DataT ArgF)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
+               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
+               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7),
+               vec_data<Ty>::get(Arg8), vec_data<Ty>::get(Arg9),
+               vec_data<Ty>::get(ArgA), vec_data<Ty>::get(ArgB),
+               vec_data<Ty>::get(ArgC), vec_data<Ty>::get(ArgD),
+               vec_data<Ty>::get(ArgE), vec_data<Ty>::get(ArgF)} {}
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
 
   // Constructor from values of base type or vec of base type. Checks that
   // base types are match and that the NumElements == sum of lengths of args.
@@ -535,20 +645,20 @@ template <typename Type, int NumElements> class vec {
             typename =
                 typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
                                           !std::is_same_v<vector_t_, DataT>>>
-  constexpr vec(vector_t_ openclVector) {
-    m_Data = detail::BitCast<vector_t, DataType>(openclVector);
+  constexpr vec(vector_t openclVector) {
+    if constexpr (!IsUsingArrayOnDevice) {
+      m_Data = openclVector;
+    } else {
+      m_Data = bit_cast<DataType>(openclVector);
+    }
   }
 
-  /* @SYCL2020
-   * Available only when: compiled for the device.
-   * Converts this SYCL vec instance to the underlying backend-native vector
-   * type defined by vector_t.
-   */
   operator vector_t() const {
-    if constexpr (NumElements == 1) {
+    if constexpr (!IsUsingArrayOnDevice) {
       return m_Data;
     } else {
-      return sycl::bit_cast<vector_t>(m_Data);
+      auto ptr = bit_cast<const vector_t *>((&m_Data)->data());
+      return *ptr;
     }
   }
 #endif // __SYCL_DEVICE_ONLY__
@@ -610,25 +720,22 @@ template <typename Type, int NumElements> class vec {
     using OpenCLR = detail::ConvertToOpenCLType_t<R>;
     vec<convertT, NumElements> Result;
 
-#ifdef __SYCL_DEVICE_ONLY__
+#if defined(__SYCL_DEVICE_ONLY__)
     using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
     using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
-
-    auto NativeVector = sycl::bit_cast<vector_t>(m_Data);
-    using ConvertTVecType = typename vec<convertT, NumElements>::vector_t;
-
     // Whole vector conversion can only be done, if:
     constexpr bool canUseNativeVectorConvert =
 #ifdef __NVPTX__
         // - we are not on CUDA, see intel/llvm#11840
         false &&
 #endif
-        NumElements > 1 &&
+        // - both vectors are represented using native vector types;
+        NativeVec && vec<convertT, NumElements>::NativeVec &&
         // - vec storage has an equivalent OpenCL native vector it is implicitly
         //   convertible to. There are some corner cases where it is not the
         //   case with char, long and long long types.
-        std::is_convertible_v<vector_t, OpenCLVecT> &&
-        std::is_convertible_v<ConvertTVecType, OpenCLVecR> &&
+        std::is_convertible_v<decltype(m_Data), OpenCLVecT> &&
+        std::is_convertible_v<decltype(Result.m_Data), OpenCLVecR> &&
         // - it is not a signed to unsigned (or vice versa) conversion
         //   see comments within 'convertImpl' for more details;
         !detail::is_sint_to_from_uint<T, R>::value &&
@@ -639,11 +746,10 @@ template <typename Type, int NumElements> class vec {
         //   right results here;
         !std::is_same_v<convertT, bool>;
     if constexpr (canUseNativeVectorConvert) {
-      Result.m_Data = sycl::bit_cast<decltype(Result.m_Data)>(
-          detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
-                              OpenCLVecR>(NativeVector));
+      Result.m_Data = detail::convertImpl<T, R, roundingMode, NumElements,
+                                          OpenCLVecT, OpenCLVecR>(m_Data);
     } else
-#endif // __SYCL_DEVICE_ONLY__
+#endif // defined(__SYCL_DEVICE_ONLY__)
     {
       // Otherwise, we fallback to per-element conversion:
       for (size_t I = 0; I < NumElements; ++I) {
@@ -690,6 +796,8 @@ template <typename Type, int NumElements> class vec {
   // not changed.
   //
   // Implement operator [] in the same way for host and device.
+  // TODO: change host side implementation when underlying type for host side
+  // will be changed to std::array.
   // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
   // aggressively optimized. Specializing with noinline to avoid as workaround.
 
@@ -806,21 +914,16 @@ template <typename Type, int NumElements> class vec {
 #error "Undefine __SYCL_BINOP macro"
 #endif
 
-#ifdef __SYCL_DEVICE_ONLY__
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret;                                                                   \
-    if constexpr (IsBfloat16 ||                                                \
-                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
+    if constexpr (IsUsingArrayOnDevice) {                                      \
       for (size_t I = 0; I < NumElements; ++I) {                               \
         Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
-      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
-      Ret = vec<DataT, NumElements>(                                           \
-          (typename vec<DataT, NumElements>::vector_t)(                        \
-              ExtVecLhs BINOP ExtVecRhs));                                     \
+      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
       if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
         Ret.ConvertToDataT();                                                  \
       }                                                                        \
@@ -843,15 +946,18 @@ template <typename Type, int NumElements> class vec {
     Lhs = Lhs BINOP vec(Rhs);                                                  \
     return Lhs;                                                                \
   }
-#else // __SYCL_DEVICE_ONLY__
+
+#else // __SYCL_USE_EXT_VECTOR_TYPE__
 
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret{};                                                                 \
-    for (size_t I = 0; I < NumElements; ++I)                                   \
-      Ret.setValue(I,                                                          \
-                   (DataT)(vec_data<DataT>::get(Lhs.getValue(I))               \
-                               BINOP vec_data<DataT>::get(Rhs.getValue(I))));  \
+    if constexpr (NativeVec)                                                   \
+      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+    else                                                                       \
+      for (size_t I = 0; I < NumElements; ++I)                                 \
+        Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(             \
+                            I)) BINOP vec_data<DataT>::get(Rhs.getValue(I)))); \
     return Ret;                                                                \
   }                                                                            \
   friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
@@ -870,7 +976,8 @@ template <typename Type, int NumElements> class vec {
     Lhs = Lhs BINOP vec(Rhs);                                                  \
     return Lhs;                                                                \
   }
-#endif // __SYCL_DEVICE_ONLY__
+
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
 
   __SYCL_BINOP(+, +=, true)
   __SYCL_BINOP(-, -=, true)
@@ -905,10 +1012,11 @@ template <typename Type, int NumElements> class vec {
   friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
                                                    const vec & Rhs) {          \
     vec<rel_t, NumElements> Ret{};                                             \
-    /* ext_vector_type does not support bfloat16 or half, so for these   */    \
-    /* we do element-by-element operation on the underlying std::array.  */    \
-    if constexpr (IsBfloat16 ||                                                \
-                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
+    /* This special case is needed since there are no standard operator||   */ \
+    /* or operator&& functions for std::array.                              */ \
+    if constexpr (IsUsingArrayOnDevice &&                                      \
+                  (std::string_view(#RELLOGOP) == "||" ||                      \
+                   std::string_view(#RELLOGOP) == "&&")) {                     \
       for (size_t I = 0; I < NumElements; ++I) {                               \
         /* We cannot use SetValue here as the operator is not a friend of*/    \
         /* Ret on Windows. */                                                  \
@@ -916,11 +1024,9 @@ template <typename Type, int NumElements> class vec {
             Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
-      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
-              ExtVecLhs RELLOGOP ExtVecRhs));                                  \
+              Lhs.m_Data RELLOGOP Rhs.m_Data));                                \
       if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
         Ret *= -1;                                                             \
     }                                                                          \
@@ -990,39 +1096,25 @@ template <typename Type, int NumElements> class vec {
   // operator~() available only when: dataT != float && dataT != double
   // && dataT != half
   friend vec operator~(const vec &Rhs) {
-#ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
-    vec Ret{~extVec};
-    if constexpr (std::is_same_v<Type, bool>) {
-      Ret.ConvertToDataT();
-    }
-    return Ret;
-#else
-    vec Ret{};
-    for (size_t I = 0; I < NumElements; ++I) {
-      Ret.setValue(I, ~Rhs.getValue(I));
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I) {
+        Ret.setValue(I, ~Rhs.getValue(I));
+      }
+      return Ret;
+    } else {
+      vec Ret{(typename vec::DataType) ~Rhs.m_Data};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+      return Ret;
     }
-    return Ret;
-#endif
   }
 
   // operator!
   friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
-    vec Ret{};
-#ifdef __SYCL_DEVICE_ONLY__
-    if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
-                  !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-                  !std::is_same_v<DataT, std::byte>)
-#else
-                  1)
-#endif
-    {
-      auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
-      return vec<detail::rel_t<DataT>, NumElements>{!extVec};
-    } else
-#endif
-    {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
       for (size_t I = 0; I < NumElements; ++I) {
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
         // std::byte neither supports ! unary op or casting, so special handling
@@ -1036,21 +1128,23 @@ template <typename Type, int NumElements> class vec {
         }
       }
       return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
+    } else {
+      return vec{(typename vec<DataT, NumElements>::DataType) !Rhs.m_Data}
+          .template as<vec<detail::rel_t<DataT>, NumElements>>();
     }
   }
 
   // operator +
   friend vec operator+(const vec &Lhs) {
-#ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
-    return vec{+extVec};
-#else
-    vec Ret{};
-    for (size_t I = 0; I < NumElements; ++I)
-      Ret.setValue(
-          I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
-    return Ret;
-#endif
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(
+            I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
+      return Ret;
+    } else {
+      return vec{+Lhs.m_Data};
+    }
   }
 
   // operator -
@@ -1067,20 +1161,18 @@ template <typename Type, int NumElements> class vec {
         oneapi::bfloat16 w = -v;
         Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
       }
-    } else {
-#ifndef __SYCL_DEVICE_ONLY__
+    } else if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
       for (size_t I = 0; I < NumElements; ++I)
         Ret.setValue(
             I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
-#else
-      auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
-      Ret = vec{-extVec};
+      return Ret;
+    } else {
+      Ret = vec{-Lhs.m_Data};
       if constexpr (std::is_same_v<Type, bool>) {
         Ret.ConvertToDataT();
       }
-#endif
+      return Ret;
     }
-    return Ret;
   }
 
   // OP is: &&, ||
@@ -1093,20 +1185,29 @@ template <typename Type, int NumElements> class vec {
 private:
   // Generic method that execute "Operation" on underlying values.
 
-#ifdef __SYCL_DEVICE_ONLY__
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <template <typename> class Operation,
+            typename Ty = vec<DataT, NumElements>>
+  vec<DataT, NumElements>
+  operatorHelper(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataType> Op;
+    Result.m_Data = Op(m_Data, Rhs.m_Data);
+    return Result;
+  }
+
   template <template <typename> class Operation,
             typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements> operatorHelper(const Ty &Rhs) const {
+  vec<DataT, NumElements>
+  operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
     vec<DataT, NumElements> Result;
     Operation<DataT> Op;
-    // Typecast to ext_vector_type, carryout the operation, and type cast back.
-    // Compiler optimizations will remove redundant casts.
-    auto OpResult = Op(sycl::bit_cast<vector_t>(m_Data),
-                       sycl::bit_cast<vector_t>(Rhs.m_Data));
-    Result.m_Data = sycl::bit_cast<DataType>(OpResult);
+    for (size_t I = 0; I < NumElements; ++I) {
+      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
+    }
     return Result;
   }
-#else  // __SYCL_DEVICE_ONLY__
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
   template <template <typename> class Operation>
   vec<DataT, NumElements>
   operatorHelper(const vec<DataT, NumElements> &Rhs) const {
@@ -1117,24 +1218,37 @@ template <typename Type, int NumElements> class vec {
     }
     return Result;
   }
-#endif // __SYCL_DEVICE_ONLY__
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
 
   // setValue and getValue should be able to operate on different underlying
   // types: enum cl_float#N , builtin vector float#N, builtin type float.
   // These versions are for N > 1.
-#ifdef __SYCL_DEVICE_ONLY__
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(Ty Index, const DataT &Value, int) {
+  constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
+                          int) {
     m_Data[Index] = vec_data<DataT>::set(Value);
   }
 
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(Ty Index, int) const {
+  constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
     return vec_data<DataT>::get(m_Data[Index]);
   }
-#else  // __SYCL_DEVICE_ONLY__
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
+    m_Data.s[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
+    return vec_data<DataT>::get(m_Data.s[Index]);
+  }
+#else // __SYCL_USE_EXT_VECTOR_TYPE__
   template <int Num = NumElements,
             typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(int Index, const DataT &Value, int) {
@@ -1146,7 +1260,7 @@ template <typename Type, int NumElements> class vec {
   constexpr DataT getValue(int Index, int) const {
     return vec_data<DataT>::get(m_Data[Index]);
   }
-#endif // __SYCL_DEVICE_ONLY__
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
 
   // N==1 versions, used by host and device. Shouldn't trailing type be int?
   template <int Num = NumElements,
@@ -1945,11 +2059,9 @@ template <typename T, int N, typename V> struct VecStorage {
 template <typename T, int N> struct VecStorageImpl {
   static constexpr size_t Num = (N == 3) ? 4 : N;
   static constexpr size_t Sz = Num * sizeof(T);
-  // using DataType =
-  //     typename std::conditional<Sz <= 64, T
-  //     __attribute__((ext_vector_type(N))),
-  //                               std::array<T, Num>>::type;
-  using DataType = std::array<T, (N == 3) ? 4 : N>;
+  using DataType =
+      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
+                                std::array<T, Num>>::type;
   using VectorDataType = T __attribute__((ext_vector_type(N)));
 };
 #else // __SYCL_DEVICE_ONLY__
@@ -2046,18 +2158,18 @@ template <> struct VecStorage<half, 1, void> {
 };
 
 // Multiple elements half
-#ifdef __SYCL_DEVICE_ONLY__
+#if defined(__SYCL_DEVICE_ONLY__)
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##DeviceStorageT;        \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
     using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
   };
-#else // __SYCL_DEVICE_ONLY__
+#else // defined(__SYCL_DEVICE_ONLY__)
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
     using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
   };
-#endif // __SYCL_DEVICE_ONLY__
+#endif // defined(__SYCL_DEVICE_ONLY__)
 
 __SYCL_DEFINE_HALF_VECSTORAGE(2)
 __SYCL_DEFINE_HALF_VECSTORAGE(3)
@@ -2073,20 +2185,12 @@ template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
   using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
 };
 // Multiple elements bfloat16
-#ifndef __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
     using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
-  };
-#else
-#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType =                                                           \
-        sycl::ext::oneapi::detail::bf16::Vec##Num##DeviceStorageT;             \
     using VectorDataType =                                                     \
         sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
   };
-#endif
 __SYCL_DEFINE_BF16_VECSTORAGE(2)
 __SYCL_DEFINE_BF16_VECSTORAGE(3)
 __SYCL_DEFINE_BF16_VECSTORAGE(4)
@@ -2243,3 +2347,5 @@ struct CheckDeviceCopyable<
 
 } // namespace _V1
 } // namespace sycl
+
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
\ No newline at end of file
diff --git a/sycl/include/sycl/types_preview.hpp b/sycl/include/sycl/types_preview.hpp
new file mode 100644
index 0000000000000..3a120b0ebb3f3
--- /dev/null
+++ b/sycl/include/sycl/types_preview.hpp
@@ -0,0 +1,2245 @@
+//==---------------- types.hpp --- SYCL types ------------------------------==//
+//
+// 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
+
+// Check if Clang's ext_vector_type attribute is available. Host compiler
+// may not be Clang, and Clang may not be built with the extension.
+#ifdef __clang__
+#ifndef __has_extension
+#define __has_extension(x) 0
+#endif
+#ifdef __HAS_EXT_VECTOR_TYPE__
+#error "Undefine __HAS_EXT_VECTOR_TYPE__ macro"
+#endif
+#if __has_extension(attribute_ext_vector_type)
+#define __HAS_EXT_VECTOR_TYPE__
+#endif
+#endif // __clang__
+
+#if !defined(__HAS_EXT_VECTOR_TYPE__) && defined(__SYCL_DEVICE_ONLY__)
+#error "SYCL device compiler is built without ext_vector_type support"
+#endif
+
+#include <sycl/access/access.hpp>              // for decorated, address_space
+#include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
+#include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
+#include <sycl/detail/defines_elementary.hpp>  // for __SYCL2020_DEPRECATED
+#include <sycl/detail/generic_type_lists.hpp>  // for vector_basic_list
+#include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
+#include <sycl/detail/memcpy.hpp>              // for memcpy
+#include <sycl/detail/type_list.hpp>           // for is_contained
+#include <sycl/detail/type_traits.hpp>         // for is_floating_point
+#include <sycl/detail/vector_convert.hpp>      // for convertImpl
+#include <sycl/detail/vector_traits.hpp>       // for vector_alignment
+#include <sycl/exception.hpp>                  // for make_error_code, errc
+#include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
+#include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
+#include <sycl/multi_ptr.hpp>                  // for multi_ptr
+
+#include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
+
+#include <array>       // for array
+#include <assert.h>    // for assert
+#include <cstddef>     // for size_t, NULL, byte
+#include <cstdint>     // for uint8_t, int16_t, int...
+#include <functional>  // for divides, multiplies
+#include <iterator>    // for pair
+#include <optional>    // for optional
+#include <ostream>     // for operator<<, basic_ost...
+#include <tuple>       // for tuple
+#include <type_traits> // for enable_if_t, is_same
+#include <utility>     // for index_sequence, make_...
+#include <variant>     // for tuple, variant
+
+// 4.10.1: Scalar data types
+// 4.10.2: SYCL vector types
+
+namespace sycl {
+inline namespace _V1 {
+
+struct elem {
+  static constexpr int x = 0;
+  static constexpr int y = 1;
+  static constexpr int z = 2;
+  static constexpr int w = 3;
+  static constexpr int r = 0;
+  static constexpr int g = 1;
+  static constexpr int b = 2;
+  static constexpr int a = 3;
+  static constexpr int s0 = 0;
+  static constexpr int s1 = 1;
+  static constexpr int s2 = 2;
+  static constexpr int s3 = 3;
+  static constexpr int s4 = 4;
+  static constexpr int s5 = 5;
+  static constexpr int s6 = 6;
+  static constexpr int s7 = 7;
+  static constexpr int s8 = 8;
+  static constexpr int s9 = 9;
+  static constexpr int sA = 10;
+  static constexpr int sB = 11;
+  static constexpr int sC = 12;
+  static constexpr int sD = 13;
+  static constexpr int sE = 14;
+  static constexpr int sF = 15;
+};
+
+namespace detail {
+// select_apply_cl_t selects from T8/T16/T32/T64 basing on
+// sizeof(_IN).  expected to handle scalar types in _IN.
+template <typename _IN, typename T8, typename T16, typename T32, typename T64>
+using select_apply_cl_t = std::conditional_t<
+    sizeof(_IN) == 1, T8,
+    std::conditional_t<sizeof(_IN) == 2, T16,
+                       std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
+
+// Helper function to bit_cast one type to another.
+template <typename FromType, typename ToType>
+static constexpr ToType BitCast(const FromType &Value) {
+
+  static_assert(sizeof(FromType) == sizeof(ToType),
+                "BitCast: sizes of types are different");
+
+#ifdef __SYCL_BITCAST_IS_CONSTEXPR
+  return sycl::bit_cast<ToType>(Value);
+#else
+  // Awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+  // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+  // but neither available yet.
+  union {
+    const FromType from;
+    ToType to;
+  } result = {};
+  result.from = Value;
+  return result.to;
+#endif
+}
+
+/* Helper functions to get and set values in vec, depdending on the underlying
+ * data type. */
+template <typename T> struct vec_helper {
+  using RetType = T;
+  static constexpr RetType get(T value) { return value; }
+  static constexpr RetType set(T value) { return value; }
+};
+template <> struct vec_helper<bool> {
+  using RetType = select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                    std::int32_t, std::int64_t>;
+  static constexpr RetType get(bool value) { return value; }
+  static constexpr RetType set(bool value) { return value; }
+};
+
+template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
+  using RetType = sycl::ext::oneapi::bfloat16;
+  using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
+
+  static constexpr RetType get(BFloat16StorageT value) {
+    return BitCast<BFloat16StorageT, RetType>(value);
+  }
+  static constexpr RetType get(RetType value) { return value; }
+
+  static constexpr BFloat16StorageT set(RetType value) {
+    return BitCast<RetType, BFloat16StorageT>(value);
+  }
+};
+
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+template <> struct vec_helper<std::byte> {
+  using RetType = std::uint8_t;
+  static constexpr RetType get(std::byte value) { return (RetType)value; }
+  static constexpr RetType set(std::byte value) { return (RetType)value; }
+  static constexpr std::byte get(std::uint8_t value) {
+    return (std::byte)value;
+  }
+  static constexpr std::byte set(std::uint8_t value) {
+    return (std::byte)value;
+  }
+};
+#endif
+
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp;
+
+template <typename T, int N, typename V = void> struct VecStorage;
+
+// Element type for relational operator return value.
+template <typename DataT>
+using rel_t = typename std::conditional_t<
+    sizeof(DataT) == sizeof(opencl::cl_char), opencl::cl_char,
+    typename std::conditional_t<
+        sizeof(DataT) == sizeof(opencl::cl_short), opencl::cl_short,
+        typename std::conditional_t<
+            sizeof(DataT) == sizeof(opencl::cl_int), opencl::cl_int,
+            typename std::conditional_t<sizeof(DataT) ==
+                                            sizeof(opencl::cl_long),
+                                        opencl::cl_long, bool>>>>;
+
+// Special type indicating that SwizzleOp should just read value from vector -
+// not trying to perform any operations. Should not be called.
+template <typename T> class GetOp {
+public:
+  using DataT = T;
+  DataT getValue(size_t) const { return (DataT)0; }
+  DataT operator()(DataT, DataT) { return (DataT)0; }
+};
+
+// Special type for working SwizzleOp with scalars, stores a scalar and gives
+// the scalar at any index. Provides interface is compatible with SwizzleOp
+// operations
+template <typename T> class GetScalarOp {
+public:
+  using DataT = T;
+  GetScalarOp(DataT Data) : m_Data(Data) {}
+  DataT getValue(size_t) const { return m_Data; }
+
+private:
+  DataT m_Data;
+};
+
+template <typename T> struct EqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs == Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct NotEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs != Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs >= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs <= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs > Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs < Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalAnd {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs && Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalOr {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs || Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct RShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs >> Rhs;
+  }
+};
+
+template <typename T> struct LShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs << Rhs;
+  }
+};
+
+// Forward declarations
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernel;
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernelWithKH;
+
+} // namespace detail
+
+template <typename T> using vec_data = detail::vec_helper<T>;
+
+template <typename T>
+using vec_data_t = typename detail::vec_helper<T>::RetType;
+
+/// Provides a cross-patform vector class template that works efficiently on
+/// SYCL devices as well as in host C++ code.
+///
+/// \ingroup sycl_api
+template <typename Type, int NumElements> class vec {
+  using DataT = Type;
+
+  // This represent type of underlying value. There should be only one field
+  // in the class, so vec<float, 16> should be equal to float16 in memory.
+  using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
+
+  static constexpr bool IsBfloat16 =
+      std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
+
+  static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
+  static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
+  static constexpr bool IsSizeGreaterThanMaxAlign =
+      (Sz > detail::MaxVecAlignment);
+
+#ifdef __SYCL_DEVICE_ONLY__
+  static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
+#else
+  static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
+#endif
+
+  static constexpr int getNumElements() { return NumElements; }
+
+  // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
+  template <int Counter, int MaxValue, class...>
+  struct SizeChecker : std::conditional_t<Counter == MaxValue, std::true_type,
+                                          std::false_type> {};
+
+  template <int Counter, int MaxValue, typename DataT_, class... tail>
+  struct SizeChecker<Counter, MaxValue, DataT_, tail...>
+      : std::conditional_t<Counter + 1 <= MaxValue,
+                           SizeChecker<Counter + 1, MaxValue, tail...>,
+                           std::false_type> {};
+
+  // Utility trait for creating an std::array from an vector argument.
+  template <typename DataT_, typename T, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const vec<T, sizeof...(Is)> &V, std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &V,
+             std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &V,
+             std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N>
+  static constexpr std::array<DataT_, N>
+  FlattenVecArgHelper(const vec<T, N> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<N>());
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5>
+  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
+      const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5>
+  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
+      const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
+  }
+  template <typename DataT_, typename T>
+  static constexpr auto FlattenVecArgHelper(const T &A) {
+    return std::array<DataT_, 1>{vec_data<DataT_>::get(static_cast<DataT_>(A))};
+  }
+  template <typename DataT_, typename T> struct FlattenVecArg {
+    constexpr auto operator()(const T &A) const {
+      return FlattenVecArgHelper<DataT_>(A);
+    }
+  };
+
+  // Alias for shortening the vec arguments to array converter.
+  template <typename DataT_, typename... ArgTN>
+  using VecArgArrayCreator =
+      detail::ArrayCreator<DataT_, FlattenVecArg, ArgTN...>;
+
+#define __SYCL_ALLOW_VECTOR_SIZES(num_elements)                                \
+  template <int Counter, int MaxValue, typename DataT_, class... tail>         \
+  struct SizeChecker<Counter, MaxValue, vec<DataT_, num_elements>, tail...>    \
+      : std::conditional_t<                                                    \
+            Counter + (num_elements) <= MaxValue,                              \
+            SizeChecker<Counter + (num_elements), MaxValue, tail...>,          \
+            std::false_type> {};                                               \
+  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
+            typename T3, template <typename> class T4, int... T5,              \
+            class... tail>                                                     \
+  struct SizeChecker<                                                          \
+      Counter, MaxValue,                                                       \
+      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>,         \
+      tail...>                                                                 \
+      : std::conditional_t<                                                    \
+            Counter + sizeof...(T5) <= MaxValue,                               \
+            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
+            std::false_type> {};                                               \
+  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
+            typename T3, template <typename> class T4, int... T5,              \
+            class... tail>                                                     \
+  struct SizeChecker<                                                          \
+      Counter, MaxValue,                                                       \
+      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
+      tail...>                                                                 \
+      : std::conditional_t<                                                    \
+            Counter + sizeof...(T5) <= MaxValue,                               \
+            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
+            std::false_type> {};
+
+  __SYCL_ALLOW_VECTOR_SIZES(1)
+  __SYCL_ALLOW_VECTOR_SIZES(2)
+  __SYCL_ALLOW_VECTOR_SIZES(3)
+  __SYCL_ALLOW_VECTOR_SIZES(4)
+  __SYCL_ALLOW_VECTOR_SIZES(8)
+  __SYCL_ALLOW_VECTOR_SIZES(16)
+#undef __SYCL_ALLOW_VECTOR_SIZES
+
+  // TypeChecker is needed for vec(const argTN &... args) ctor to validate args.
+  template <typename T, typename DataT_>
+  struct TypeChecker : std::is_convertible<T, DataT_> {};
+#define __SYCL_ALLOW_VECTOR_TYPES(num_elements)                                \
+  template <typename DataT_>                                                   \
+  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {};   \
+  template <typename DataT_, typename T2, typename T3,                         \
+            template <typename> class T4, int... T5>                           \
+  struct TypeChecker<                                                          \
+      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
+      : std::true_type {};                                                     \
+  template <typename DataT_, typename T2, typename T3,                         \
+            template <typename> class T4, int... T5>                           \
+  struct TypeChecker<                                                          \
+      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
+      DataT_> : std::true_type {};
+
+  __SYCL_ALLOW_VECTOR_TYPES(1)
+  __SYCL_ALLOW_VECTOR_TYPES(2)
+  __SYCL_ALLOW_VECTOR_TYPES(3)
+  __SYCL_ALLOW_VECTOR_TYPES(4)
+  __SYCL_ALLOW_VECTOR_TYPES(8)
+  __SYCL_ALLOW_VECTOR_TYPES(16)
+#undef __SYCL_ALLOW_VECTOR_TYPES
+
+  template <int... Indexes>
+  using Swizzle =
+      detail::SwizzleOp<vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
+                        detail::GetOp, Indexes...>;
+
+  template <int... Indexes>
+  using ConstSwizzle =
+      detail::SwizzleOp<const vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
+                        detail::GetOp, Indexes...>;
+
+  // Shortcuts for args validation in vec(const argTN &... args) ctor.
+  template <typename... argTN>
+  using EnableIfSuitableTypes = typename std::enable_if_t<
+      std::conjunction_v<TypeChecker<argTN, DataT>...>>;
+
+  template <typename... argTN>
+  using EnableIfSuitableNumElements =
+      typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
+
+  template <size_t... Is>
+  constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
+                std::index_sequence<Is...>)
+      : m_Data{([&](vec_data_t<DataT> v) constexpr {
+          if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
+            return v.value;
+          else
+            return vec_data_t<DataT>(static_cast<DataT>(v));
+        })(Arr[Is])...} {}
+
+public:
+  using element_type = DataT;
+  using value_type = DataT;
+  using rel_t = detail::rel_t<DataT>;
+#ifdef __SYCL_DEVICE_ONLY__
+  // Type used for passing sycl::vec to SPIRV builtins.
+  using vector_t =
+      typename detail::VecStorage<DataT, NumElements>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+
+  vec() = default;
+
+  constexpr vec(const vec &Rhs) = default;
+  constexpr vec(vec &&Rhs) = default;
+
+  constexpr vec &operator=(const vec &Rhs) = default;
+
+  // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
+  template <typename Ty = DataT>
+  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
+                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
+                            vec &>
+  operator=(const vec<rel_t, NumElements> &Rhs) {
+    *this = Rhs.template as<vec>();
+    return *this;
+  }
+
+#ifdef __SYCL_DEVICE_ONLY__
+  explicit constexpr vec(const DataT &arg)
+      : vec{detail::RepeatValue<NumElements>(
+                static_cast<vec_data_t<DataT>>(arg)),
+            std::make_index_sequence<NumElements>()} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+
+  operator=(const Ty & Rhs) {
+    for (int i = 0; i < NumElements; ++i) {
+      setValue(i, Rhs);
+    }
+    return *this;
+  }
+#else  // __SYCL_DEVICE_ONLY__
+  explicit constexpr vec(const DataT &arg)
+      : vec{detail::RepeatValue<NumElements>(
+                static_cast<vec_data_t<DataT>>(arg)),
+            std::make_index_sequence<NumElements>()} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const DataT &Rhs) {
+    for (int i = 0; i < NumElements; ++i) {
+      setValue(i, Rhs);
+    }
+    return *this;
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
+  // Constructor from values of base type or vec of base type. Checks that
+  // base types are match and that the NumElements == sum of lengths of args.
+  template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
+            typename = EnableIfSuitableNumElements<argTN...>>
+  constexpr vec(const argTN &...args)
+      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
+            std::make_index_sequence<NumElements>()} {}
+
+#ifdef __SYCL_DEVICE_ONLY__
+  template <typename vector_t_ = vector_t,
+            typename =
+                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
+                                          !std::is_same_v<vector_t_, DataT>>>
+  constexpr vec(vector_t_ openclVector) {
+    m_Data = detail::BitCast<vector_t, DataType>(openclVector);
+  }
+
+  /* @SYCL2020
+   * Available only when: compiled for the device.
+   * Converts this SYCL vec instance to the underlying backend-native vector
+   * type defined by vector_t.
+   */
+  operator vector_t() const {
+    if constexpr (NumElements == 1) {
+      return m_Data;
+    } else {
+      return sycl::bit_cast<vector_t>(m_Data);
+    }
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
+  // Available only when: NumElements == 1
+  template <int N = NumElements>
+  operator typename std::enable_if_t<N == 1, DataT>() const {
+    return vec_data<DataT>::get(m_Data);
+  }
+
+  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
+  static constexpr size_t get_count() { return size(); }
+  static constexpr size_t size() noexcept { return NumElements; }
+  __SYCL2020_DEPRECATED(
+      "get_size() is deprecated, please use byte_size() instead")
+  static constexpr size_t get_size() { return byte_size(); }
+  static constexpr size_t byte_size() noexcept { return sizeof(m_Data); }
+
+  // convertImpl can't be called with the same From and To types and therefore
+  // we need this version of convert which is mostly no-op.
+  template <typename convertT,
+            rounding_mode roundingMode = rounding_mode::automatic>
+  std::enable_if_t<
+      std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> ||
+          std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
+                         detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      vec<convertT, NumElements>>
+  convert() const {
+    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+                      detail::is_floating_point<convertT>::value,
+                  "Unsupported convertT");
+    if constexpr (!std::is_same_v<DataT, convertT>) {
+      // Dummy conversion for cases like vec<signed char> -> vec<char>
+      vec<convertT, NumElements> Result;
+      for (size_t I = 0; I < NumElements; ++I)
+        Result.setValue(I, static_cast<convertT>(getValue(I)));
+
+      return Result;
+    } else {
+      // No conversion necessary
+      return *this;
+    }
+  }
+
+  template <typename convertT,
+            rounding_mode roundingMode = rounding_mode::automatic>
+  std::enable_if_t<
+      !std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> &&
+          !std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
+                          detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      vec<convertT, NumElements>>
+  convert() const {
+    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+                      detail::is_floating_point<convertT>::value,
+                  "Unsupported convertT");
+    using T = vec_data_t<DataT>;
+    using R = vec_data_t<convertT>;
+    using OpenCLT = detail::ConvertToOpenCLType_t<T>;
+    using OpenCLR = detail::ConvertToOpenCLType_t<R>;
+    vec<convertT, NumElements> Result;
+
+#ifdef __SYCL_DEVICE_ONLY__
+    using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
+    using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
+
+    auto NativeVector = sycl::bit_cast<vector_t>(m_Data);
+    using ConvertTVecType = typename vec<convertT, NumElements>::vector_t;
+
+    // Whole vector conversion can only be done, if:
+    constexpr bool canUseNativeVectorConvert =
+#ifdef __NVPTX__
+        // - we are not on CUDA, see intel/llvm#11840
+        false &&
+#endif
+        NumElements > 1 &&
+        // - vec storage has an equivalent OpenCL native vector it is implicitly
+        //   convertible to. There are some corner cases where it is not the
+        //   case with char, long and long long types.
+        std::is_convertible_v<vector_t, OpenCLVecT> &&
+        std::is_convertible_v<ConvertTVecType, OpenCLVecR> &&
+        // - it is not a signed to unsigned (or vice versa) conversion
+        //   see comments within 'convertImpl' for more details;
+        !detail::is_sint_to_from_uint<T, R>::value &&
+        // - destination type is not bool. bool is stored as integer under the
+        //   hood and therefore conversion to bool looks like conversion between
+        //   two integer types. Since bit pattern for true and false is not
+        //   defined, there is no guarantee that integer conversion yields
+        //   right results here;
+        !std::is_same_v<convertT, bool>;
+    if constexpr (canUseNativeVectorConvert) {
+      Result.m_Data = sycl::bit_cast<decltype(Result.m_Data)>(
+          detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
+                              OpenCLVecR>(NativeVector));
+    } else
+#endif // __SYCL_DEVICE_ONLY__
+    {
+      // Otherwise, we fallback to per-element conversion:
+      for (size_t I = 0; I < NumElements; ++I) {
+        Result.setValue(
+            I, vec_data<convertT>::get(
+                   detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
+                       vec_data<DataT>::get(getValue(I)))));
+      }
+    }
+
+    return Result;
+  }
+
+  template <typename asT> asT as() const {
+    static_assert((sizeof(*this) == sizeof(asT)),
+                  "The new SYCL vec type must have the same storage size in "
+                  "bytes as this SYCL vec");
+    static_assert(
+        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
+            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
+        "asT must be SYCL vec of a different element type and "
+        "number of elements specified by asT");
+    asT Result;
+    detail::memcpy(&Result.m_Data, &m_Data, sizeof(decltype(Result.m_Data)));
+    return Result;
+  }
+
+  template <int... SwizzleIndexes> Swizzle<SwizzleIndexes...> swizzle() {
+    return this;
+  }
+
+  template <int... SwizzleIndexes>
+  ConstSwizzle<SwizzleIndexes...> swizzle() const {
+    return this;
+  }
+
+  // ext_vector_type is used as an underlying type for sycl::vec on device.
+  // The problem is that for clang vector types the return of operator[] is a
+  // temporary and not a reference to the element in the vector. In practice
+  // reinterpret_cast<DataT *>(&m_Data)[i]; is working. According to
+  // http://llvm.org/docs/GetElementPtr.html#can-gep-index-into-vector-elements
+  // this is not disallowed now. But could probably be disallowed in the future.
+  // That is why tests are added to check that behavior of the compiler has
+  // not changed.
+  //
+  // Implement operator [] in the same way for host and device.
+  // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
+  // aggressively optimized. Specializing with noinline to avoid as workaround.
+
+  template <typename T = DataT>
+  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                            const DataT &>
+  operator[](int i) const {
+    return reinterpret_cast<const DataT *>(&m_Data)[i];
+  }
+
+  template <typename T = DataT>
+  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                            DataT &>
+  operator[](int i) {
+    return reinterpret_cast<DataT *>(&m_Data)[i];
+  }
+
+#ifdef _MSC_VER
+#define __SYCL_NOINLINE_BF16 __declspec(noinline)
+#else
+#define __SYCL_NOINLINE_BF16 __attribute__((noinline))
+#endif
+
+  template <typename T = DataT>
+  __SYCL_NOINLINE_BF16
+      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                const DataT &>
+      operator[](int i) const {
+    return reinterpret_cast<const DataT *>(&m_Data)[i];
+  }
+
+  template <typename T = DataT>
+  __SYCL_NOINLINE_BF16
+      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                DataT &>
+      operator[](int i) {
+    return reinterpret_cast<DataT *>(&m_Data)[i];
+  }
+
+#undef __SYCL_NOINLINE_BF16
+
+  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
+private:
+  // Indexer used in the swizzles.def
+  // Currently it is defined as a template struct. Replacing it with a constexpr
+  // function would activate a bug in MSVC that is fixed only in v19.20.
+  // Until then MSVC does not recognize such constexpr functions as const and
+  // thus does not let using them in template parameters inside swizzle.def.
+  template <int Index> struct Indexer {
+    static constexpr int value = Index;
+  };
+
+public:
+#ifdef __SYCL_ACCESS_RETURN
+#error "Undefine __SYCL_ACCESS_RETURN macro"
+#endif
+#define __SYCL_ACCESS_RETURN this
+#include "swizzles.def"
+#undef __SYCL_ACCESS_RETURN
+  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
+
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t Offset, multi_ptr<const DataT, Space, DecorateAddress> Ptr) {
+    for (int I = 0; I < NumElements; I++) {
+      setValue(I, *multi_ptr<const DataT, Space, DecorateAddress>(
+                      Ptr + Offset * NumElements + I));
+    }
+  }
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t Offset, multi_ptr<DataT, Space, DecorateAddress> Ptr) {
+    multi_ptr<const DataT, Space, DecorateAddress> ConstPtr(Ptr);
+    load(Offset, ConstPtr);
+  }
+  template <int Dimensions, access::mode Mode,
+            access::placeholder IsPlaceholder, access::target Target,
+            typename PropertyListT>
+  void
+  load(size_t Offset,
+       accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
+           Acc) {
+    multi_ptr<const DataT, detail::TargetToAS<Target>::AS,
+              access::decorated::yes>
+        MultiPtr(Acc);
+    load(Offset, MultiPtr);
+  }
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void store(size_t Offset,
+             multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
+    for (int I = 0; I < NumElements; I++) {
+      *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
+                                                I) = getValue(I);
+    }
+  }
+  template <int Dimensions, access::mode Mode,
+            access::placeholder IsPlaceholder, access::target Target,
+            typename PropertyListT>
+  void
+  store(size_t Offset,
+        accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
+            Acc) {
+    multi_ptr<DataT, detail::TargetToAS<Target>::AS, access::decorated::yes>
+        MultiPtr(Acc);
+    store(Offset, MultiPtr);
+  }
+
+  void ConvertToDataT() {
+    for (size_t i = 0; i < NumElements; ++i) {
+      DataT tmp = getValue(i);
+      setValue(i, tmp);
+    }
+  }
+
+#ifdef __SYCL_BINOP
+#error "Undefine __SYCL_BINOP macro"
+#endif
+
+#ifdef __SYCL_DEVICE_ONLY__
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
+  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+    vec Ret;                                                                   \
+    if constexpr (IsBfloat16 ||                                                \
+                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
+      for (size_t I = 0; I < NumElements; ++I) {                               \
+        Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
+      }                                                                        \
+    } else {                                                                   \
+      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
+      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
+      Ret = vec<DataT, NumElements>(                                           \
+          (typename vec<DataT, NumElements>::vector_t)(                        \
+              ExtVecLhs BINOP ExtVecRhs));                                     \
+      if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
+        Ret.ConvertToDataT();                                                  \
+      }                                                                        \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+    return Lhs BINOP vec(Rhs);                                                 \
+  }                                                                            \
+  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+    return vec(Lhs) BINOP Rhs;                                                 \
+  }                                                                            \
+  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+    Lhs = Lhs BINOP Rhs;                                                       \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <int Num = NumElements>                                             \
+  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
+      vec & Lhs, const DataT & Rhs) {                                          \
+    Lhs = Lhs BINOP vec(Rhs);                                                  \
+    return Lhs;                                                                \
+  }
+#else // __SYCL_DEVICE_ONLY__
+
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
+  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+    vec Ret{};                                                                 \
+    for (size_t I = 0; I < NumElements; ++I)                                   \
+      Ret.setValue(I,                                                          \
+                   (DataT)(vec_data<DataT>::get(Lhs.getValue(I))               \
+                               BINOP vec_data<DataT>::get(Rhs.getValue(I))));  \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+    return Lhs BINOP vec(Rhs);                                                 \
+  }                                                                            \
+  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+    return vec(Lhs) BINOP Rhs;                                                 \
+  }                                                                            \
+  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+    Lhs = Lhs BINOP Rhs;                                                       \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <int Num = NumElements>                                             \
+  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
+      vec & Lhs, const DataT & Rhs) {                                          \
+    Lhs = Lhs BINOP vec(Rhs);                                                  \
+    return Lhs;                                                                \
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
+  __SYCL_BINOP(+, +=, true)
+  __SYCL_BINOP(-, -=, true)
+  __SYCL_BINOP(*, *=, false)
+  __SYCL_BINOP(/, /=, false)
+
+  // TODO: The following OPs are available only when: DataT != cl_float &&
+  // DataT != cl_double && DataT != cl_half
+  __SYCL_BINOP(%, %=, false)
+  __SYCL_BINOP(|, |=, false)
+  __SYCL_BINOP(&, &=, false)
+  __SYCL_BINOP(^, ^=, false)
+  __SYCL_BINOP(>>, >>=, false)
+  __SYCL_BINOP(<<, <<=, true)
+#undef __SYCL_BINOP
+#undef __SYCL_BINOP_HELP
+
+  // Note: vec<>/SwizzleOp logical value is 0/-1 logic, as opposed to 0/1 logic.
+  // As far as CTS validation is concerned, 0/-1 logic also applies when
+  // NumElements is equal to one, which is somewhat inconsistent with being
+  // transparent with scalar data.
+  // TODO: Determine if vec<, NumElements=1> is needed at all, remove this
+  // inconsistency if not by disallowing one-element vectors (as in OpenCL)
+
+#ifdef __SYCL_RELLOGOP
+#error "Undefine __SYCL_RELLOGOP macro"
+#endif
+// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
+// by SYCL device compiler only.
+#ifdef __SYCL_DEVICE_ONLY__
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const vec & Rhs) {          \
+    vec<rel_t, NumElements> Ret{};                                             \
+    /* ext_vector_type does not support bfloat16 or half, so for these   */    \
+    /* we do element-by-element operation on the underlying std::array.  */    \
+    if constexpr (IsBfloat16 ||                                                \
+                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
+      for (size_t I = 0; I < NumElements; ++I) {                               \
+        /* We cannot use SetValue here as the operator is not a friend of*/    \
+        /* Ret on Windows. */                                                  \
+        Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                    \
+            Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+      }                                                                        \
+    } else {                                                                   \
+      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
+      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
+      Ret = vec<rel_t, NumElements>(                                           \
+          (typename vec<rel_t, NumElements>::vector_t)(                        \
+              ExtVecLhs RELLOGOP ExtVecRhs));                                  \
+      if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
+        Ret *= -1;                                                             \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const DataT & Rhs) {        \
+    return Lhs RELLOGOP vec(Rhs);                                              \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
+                                                   const vec & Rhs) {          \
+    return vec(Lhs) RELLOGOP Rhs;                                              \
+  }
+
+#else
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const vec & Rhs) {          \
+    vec<rel_t, NumElements> Ret{};                                             \
+    for (size_t I = 0; I < NumElements; ++I) {                                 \
+      /* We cannot use SetValue here as the operator is not a friend of*/      \
+      /* Ret on Windows. */                                                    \
+      Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                      \
+          Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));   \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const DataT & Rhs) {        \
+    return Lhs RELLOGOP vec(Rhs);                                              \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
+                                                   const vec & Rhs) {          \
+    return vec(Lhs) RELLOGOP Rhs;                                              \
+  }
+#endif
+
+  __SYCL_RELLOGOP(==)
+  __SYCL_RELLOGOP(!=)
+  __SYCL_RELLOGOP(>)
+  __SYCL_RELLOGOP(<)
+  __SYCL_RELLOGOP(>=)
+  __SYCL_RELLOGOP(<=)
+  // TODO: limit to integral types.
+  __SYCL_RELLOGOP(&&)
+  __SYCL_RELLOGOP(||)
+#undef __SYCL_RELLOGOP
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  friend vec &operator UOP(vec & Rhs) {                                        \
+    Rhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    return Rhs;                                                                \
+  }                                                                            \
+  friend vec operator UOP(vec &Lhs, int) {                                     \
+    vec Ret(Lhs);                                                              \
+    Lhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  // operator~() available only when: dataT != float && dataT != double
+  // && dataT != half
+  friend vec operator~(const vec &Rhs) {
+#ifdef __SYCL_DEVICE_ONLY__
+    auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
+    vec Ret{~extVec};
+    if constexpr (std::is_same_v<Type, bool>) {
+      Ret.ConvertToDataT();
+    }
+    return Ret;
+#else
+    vec Ret{};
+    for (size_t I = 0; I < NumElements; ++I) {
+      Ret.setValue(I, ~Rhs.getValue(I));
+    }
+    return Ret;
+#endif
+  }
+
+  // operator!
+  friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
+    vec Ret{};
+#ifdef __SYCL_DEVICE_ONLY__
+    if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
+                  !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+                  !std::is_same_v<DataT, std::byte>)
+#else
+                  1)
+#endif
+    {
+      auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
+      return vec<detail::rel_t<DataT>, NumElements>{!extVec};
+    } else
+#endif
+    {
+      for (size_t I = 0; I < NumElements; ++I) {
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        // std::byte neither supports ! unary op or casting, so special handling
+        // is needed. And, worse, Windows has a conflict with 'byte'.
+        if constexpr (std::is_same_v<std::byte, DataT>) {
+          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
+        } else
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        {
+          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
+        }
+      }
+      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
+    }
+  }
+
+  // operator +
+  friend vec operator+(const vec &Lhs) {
+#ifdef __SYCL_DEVICE_ONLY__
+    auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
+    return vec{+extVec};
+#else
+    vec Ret{};
+    for (size_t I = 0; I < NumElements; ++I)
+      Ret.setValue(
+          I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
+    return Ret;
+#endif
+  }
+
+  // operator -
+  friend vec operator-(const vec &Lhs) {
+    namespace oneapi = sycl::ext::oneapi;
+    vec Ret{};
+    if constexpr (IsBfloat16 && NumElements == 1) {
+      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data);
+      oneapi::bfloat16 w = -v;
+      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
+    } else if constexpr (IsBfloat16) {
+      for (size_t I = 0; I < NumElements; I++) {
+        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[I]);
+        oneapi::bfloat16 w = -v;
+        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
+      }
+    } else {
+#ifndef __SYCL_DEVICE_ONLY__
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(
+            I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
+#else
+      auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
+      Ret = vec{-extVec};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+#endif
+    }
+    return Ret;
+  }
+
+  // OP is: &&, ||
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
+
+  // OP is: ==, !=, <, >, <=, >=
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
+private:
+  // Generic method that execute "Operation" on underlying values.
+
+#ifdef __SYCL_DEVICE_ONLY__
+  template <template <typename> class Operation,
+            typename Ty = vec<DataT, NumElements>>
+  vec<DataT, NumElements> operatorHelper(const Ty &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataT> Op;
+    // Typecast to ext_vector_type, carryout the operation, and type cast back.
+    // Compiler optimizations will remove redundant casts.
+    auto OpResult = Op(sycl::bit_cast<vector_t>(m_Data),
+                       sycl::bit_cast<vector_t>(Rhs.m_Data));
+    Result.m_Data = sycl::bit_cast<DataType>(OpResult);
+    return Result;
+  }
+#else  // __SYCL_DEVICE_ONLY__
+  template <template <typename> class Operation>
+  vec<DataT, NumElements>
+  operatorHelper(const vec<DataT, NumElements> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataT> Op;
+    for (size_t I = 0; I < NumElements; ++I) {
+      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
+    }
+    return Result;
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
+  // setValue and getValue should be able to operate on different underlying
+  // types: enum cl_float#N , builtin vector float#N, builtin type float.
+  // These versions are for N > 1.
+#ifdef __SYCL_DEVICE_ONLY__
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(Ty Index, const DataT &Value, int) {
+    m_Data[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(Ty Index, int) const {
+    return vec_data<DataT>::get(m_Data[Index]);
+  }
+#else  // __SYCL_DEVICE_ONLY__
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(int Index, const DataT &Value, int) {
+    m_Data[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(int Index, int) const {
+    return vec_data<DataT>::get(m_Data[Index]);
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
+  // N==1 versions, used by host and device. Shouldn't trailing type be int?
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 == Num>>
+  constexpr void setValue(int, const DataT &Value, float) {
+    m_Data = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 == Num>>
+  DataT getValue(int, float) const {
+    return vec_data<DataT>::get(m_Data);
+  }
+
+  // setValue and getValue.
+  // The "api" functions used by BINOP etc.  These versions just dispatch
+  // using additional int or float arg to disambiguate vec<1> vs. vec<N>
+  // Special proxies as specialization is not allowed in class scope.
+  constexpr void setValue(int Index, const DataT &Value) {
+    if (NumElements == 1)
+      setValue(Index, Value, 0);
+    else
+      setValue(Index, Value, 0.f);
+  }
+
+  DataT getValue(int Index) const {
+    return (NumElements == 1) ? getValue(Index, 0) : getValue(Index, 0.f);
+  }
+
+  // fields
+
+  // Alignment is the same as size, to a maximum size of 64.
+  // detail::vector_alignment will return that value.
+  alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
+
+  // friends
+  template <typename T1, typename T2, typename T3, template <typename> class T4,
+            int... T5>
+  friend class detail::SwizzleOp;
+  template <typename T1, int T2> friend class vec;
+};
+
+#ifdef __cpp_deduction_guides
+// all compilers supporting deduction guides also support fold expressions
+template <class T, class... U,
+          class = std::enable_if_t<(std::is_same_v<T, U> && ...)>>
+vec(T, U...) -> vec<T, sizeof...(U) + 1>;
+#endif
+
+namespace detail {
+
+// SwizzleOP represents expression templates that operate on vec.
+// Actual computation performed on conversion or assignment operators.
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp {
+  using DataT = typename VecT::element_type;
+  // Certain operators return a vector with a different element type. Also, the
+  // left and right operand types may differ. CommonDataT selects a result type
+  // based on these types to ensure that the result value can be represented.
+  //
+  // Example 1:
+  //   sycl::vec<unsigned char, 4> vec{...};
+  //   auto result = 300u + vec.x();
+  //
+  // CommonDataT is std::common_type_t<OperationLeftT, OperationRightT> since
+  // it's larger than unsigned char.
+  //
+  // Example 2:
+  //   sycl::vec<bool, 1> vec{...};
+  //   auto result = vec.template swizzle<sycl::elem::s0>() && vec;
+  //
+  // CommonDataT is DataT since operator&& returns a vector with element type
+  // int8_t, which is larger than bool.
+  //
+  // Example 3:
+  //   sycl::vec<std::byte, 4> vec{...}; auto swlo = vec.lo();
+  //   auto result = swlo == swlo;
+  //
+  // CommonDataT is DataT since operator== returns a vector with element type
+  // int8_t, which is the same size as std::byte. std::common_type_t<DataT, ...>
+  // can't be used here since there's no type that int8_t and std::byte can both
+  // be implicitly converted to.
+  using OpLeftDataT = typename OperationLeftT::DataT;
+  using OpRightDataT = typename OperationRightT::DataT;
+  using CommonDataT = std::conditional_t<
+      sizeof(DataT) >= sizeof(std::common_type_t<OpLeftDataT, OpRightDataT>),
+      DataT, std::common_type_t<OpLeftDataT, OpRightDataT>>;
+  static constexpr int getNumElements() { return sizeof...(Indexes); }
+
+  using rel_t = detail::rel_t<DataT>;
+  using vec_t = vec<DataT, sizeof...(Indexes)>;
+  using vec_rel_t = vec<rel_t, sizeof...(Indexes)>;
+
+  template <typename OperationRightT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewLHOp = SwizzleOp<VecT,
+                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                      OperationCurrentT, Indexes...>,
+                            OperationRightT_, OperationCurrentT_, Idx_...>;
+
+  template <typename OperationRightT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewRelOp = SwizzleOp<vec<rel_t, VecT::getNumElements()>,
+                             SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                       OperationCurrentT, Indexes...>,
+                             OperationRightT_, OperationCurrentT_, Idx_...>;
+
+  template <typename OperationLeftT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewRHOp = SwizzleOp<VecT, OperationLeftT_,
+                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                      OperationCurrentT, Indexes...>,
+                            OperationCurrentT_, Idx_...>;
+
+  template <int IdxNum, typename T = void>
+  using EnableIfOneIndex = typename std::enable_if_t<
+      1 == IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+
+  template <int IdxNum, typename T = void>
+  using EnableIfMultipleIndexes = typename std::enable_if_t<
+      1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+
+  template <typename T>
+  using EnableIfScalarType = typename std::enable_if_t<
+      std::is_convertible_v<DataT, T> &&
+      (std::is_fundamental_v<vec_data_t<T>> ||
+       detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+
+  template <typename T>
+  using EnableIfNoScalarType = typename std::enable_if_t<
+      !std::is_convertible_v<DataT, T> ||
+      !(std::is_fundamental_v<vec_data_t<T>> ||
+        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+
+  template <int... Indices>
+  using Swizzle =
+      SwizzleOp<VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
+
+  template <int... Indices>
+  using ConstSwizzle =
+      SwizzleOp<const VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
+
+public:
+  using element_type = DataT;
+  using value_type = DataT;
+
+#ifdef __SYCL_DEVICE_ONLY__
+  using vector_t = typename vec_t::vector_t;
+#endif // __SYCL_DEVICE_ONLY__
+
+  const DataT &operator[](int i) const {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    return (*m_Vector)[Idxs[i]];
+  }
+
+  template <typename _T = VecT>
+  std::enable_if_t<!std::is_const_v<_T>, DataT> &operator[](int i) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    return (*m_Vector)[Idxs[i]];
+  }
+
+  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
+  size_t get_count() const { return size(); }
+  static constexpr size_t size() noexcept { return getNumElements(); }
+
+  template <int Num = getNumElements()>
+  __SYCL2020_DEPRECATED(
+      "get_size() is deprecated, please use byte_size() instead")
+  size_t get_size() const {
+    return byte_size<Num>();
+  }
+
+  template <int Num = getNumElements()> size_t byte_size() const noexcept {
+    return sizeof(DataT) * (Num == 3 ? 4 : Num);
+  }
+
+  template <typename T, int IdxNum = getNumElements(),
+            typename = EnableIfOneIndex<IdxNum>,
+            typename = EnableIfScalarType<T>>
+  operator T() const {
+    return getValue(0);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>
+  operator*(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::plus, Indexes...>
+  operator+(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::plus, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::divides, Indexes...>
+  operator/(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::divides, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  // TODO: Check that Rhs arg is suitable.
+#ifdef __SYCL_OPASSIGN
+#error "Undefine __SYCL_OPASSIGN macro."
+#endif
+#define __SYCL_OPASSIGN(OPASSIGN, OP)                                          \
+  SwizzleOp &operator OPASSIGN(const DataT & Rhs) {                            \
+    operatorHelper<OP>(vec_t(Rhs));                                            \
+    return *this;                                                              \
+  }                                                                            \
+  template <typename RhsOperation>                                             \
+  SwizzleOp &operator OPASSIGN(const RhsOperation & Rhs) {                     \
+    operatorHelper<OP>(Rhs);                                                   \
+    return *this;                                                              \
+  }
+
+  __SYCL_OPASSIGN(+=, std::plus)
+  __SYCL_OPASSIGN(-=, std::minus)
+  __SYCL_OPASSIGN(*=, std::multiplies)
+  __SYCL_OPASSIGN(/=, std::divides)
+  __SYCL_OPASSIGN(%=, std::modulus)
+  __SYCL_OPASSIGN(&=, std::bit_and)
+  __SYCL_OPASSIGN(|=, std::bit_or)
+  __SYCL_OPASSIGN(^=, std::bit_xor)
+  __SYCL_OPASSIGN(>>=, RShift)
+  __SYCL_OPASSIGN(<<=, LShift)
+#undef __SYCL_OPASSIGN
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  SwizzleOp &operator UOP() {                                                  \
+    *this OPASSIGN static_cast<DataT>(1);                                      \
+    return *this;                                                              \
+  }                                                                            \
+  vec_t operator UOP(int) {                                                    \
+    vec_t Ret = *this;                                                         \
+    *this OPASSIGN static_cast<DataT>(1);                                      \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  template <typename T = DataT>
+  friend typename std::enable_if_t<
+      std::is_same_v<T, DataT> && std::is_integral_v<vec_data_t<T>>, vec_t>
+  operator~(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return ~Tmp;
+  }
+
+  friend vec_rel_t operator!(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return !Tmp;
+  }
+
+  friend vec_t operator+(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return +Tmp;
+  }
+
+  friend vec_t operator-(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return -Tmp;
+  }
+
+// scalar BINOP vec<>
+// scalar BINOP SwizzleOp
+// vec<> BINOP SwizzleOp
+#ifdef __SYCL_BINOP
+#error "Undefine __SYCL_BINOP macro"
+#endif
+#define __SYCL_BINOP(BINOP)                                                    \
+  friend vec_t operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {        \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs BINOP Tmp;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {        \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp BINOP Rhs;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {        \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs BINOP Tmp;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {        \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp BINOP Rhs;                                                      \
+  }
+
+  __SYCL_BINOP(+)
+  __SYCL_BINOP(-)
+  __SYCL_BINOP(*)
+  __SYCL_BINOP(/)
+  __SYCL_BINOP(%)
+  __SYCL_BINOP(&)
+  __SYCL_BINOP(|)
+  __SYCL_BINOP(^)
+  __SYCL_BINOP(>>)
+  __SYCL_BINOP(<<)
+#undef __SYCL_BINOP
+
+// scalar RELLOGOP vec<>
+// scalar RELLOGOP SwizzleOp
+// vec<> RELLOGOP SwizzleOp
+#ifdef __SYCL_RELLOGOP
+#error "Undefine __SYCL_RELLOGOP macro"
+#endif
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec_rel_t operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs RELLOGOP Tmp;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp RELLOGOP Rhs;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs RELLOGOP Tmp;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp RELLOGOP Rhs;                                                   \
+  }
+
+  __SYCL_RELLOGOP(==)
+  __SYCL_RELLOGOP(!=)
+  __SYCL_RELLOGOP(>)
+  __SYCL_RELLOGOP(<)
+  __SYCL_RELLOGOP(>=)
+  __SYCL_RELLOGOP(<=)
+  // TODO: limit to integral types.
+  __SYCL_RELLOGOP(&&)
+  __SYCL_RELLOGOP(||)
+#undef __SYCL_RELLOGOP
+
+  template <int IdxNum = getNumElements(),
+            typename = EnableIfMultipleIndexes<IdxNum>>
+  SwizzleOp &operator=(const vec<DataT, IdxNum> &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
+  SwizzleOp &operator=(const DataT &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    m_Vector->setValue(Idxs[0], Rhs);
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(),
+            EnableIfMultipleIndexes<IdxNum, bool> = true>
+  SwizzleOp &operator=(const DataT &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    for (auto Idx : Idxs) {
+      m_Vector->setValue(Idx, Rhs);
+    }
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
+  SwizzleOp &operator=(DataT &&Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    m_Vector->setValue(Idxs[0], Rhs);
+    return *this;
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>
+  operator*(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::multiplies, Indexes...>
+  operator*(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::multiplies, Indexes...>(m_Vector, *this,
+                                                              Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::plus, Indexes...> operator+(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::plus, Indexes...>(m_Vector, *this,
+                                                          GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::plus, Indexes...>
+  operator+(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::plus, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::minus, Indexes...>
+  operator-(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::minus, Indexes...>(m_Vector, *this,
+                                                           GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::minus, Indexes...>
+  operator-(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::minus, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::divides, Indexes...>
+  operator/(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::divides, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::divides, Indexes...>
+  operator/(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::divides, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>
+  operator%(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::modulus, Indexes...>
+  operator%(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::modulus, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>
+  operator&(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_and, Indexes...>
+  operator&(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_and, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>
+  operator|(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_or, Indexes...>
+  operator|(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_or, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>
+  operator^(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_xor, Indexes...>
+  operator^(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_xor, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, RShift, Indexes...> operator>>(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, RShift, Indexes...>(m_Vector, *this,
+                                                       GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, RShift, Indexes...>
+  operator>>(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, RShift, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, LShift, Indexes...> operator<<(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, LShift, Indexes...>(m_Vector, *this,
+                                                       GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, LShift, Indexes...>
+  operator<<(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, LShift, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  SwizzleOp &operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  SwizzleOp &operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, EqualTo, Indexes...> operator==(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, EqualTo, Indexes...>(NULL, *this,
+                                                         GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, EqualTo, Indexes...>
+  operator==(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, EqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>
+  operator!=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, NotEqualTo, Indexes...>
+  operator!=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, NotEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>
+  operator>=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>
+  operator>=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>
+  operator<=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LessEqualTo, Indexes...>
+  operator<=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LessEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>
+  operator>(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, GreaterThan, Indexes...>
+  operator>(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, GreaterThan, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LessThan, Indexes...> operator<(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LessThan, Indexes...>(NULL, *this,
+                                                          GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LessThan, Indexes...>
+  operator<(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LessThan, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>
+  operator&&(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LogicalAnd, Indexes...>
+  operator&&(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LogicalAnd, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>
+  operator||(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>(NULL, *this,
+                                                           GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LogicalOr, Indexes...>
+  operator||(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LogicalOr, Indexes...>(NULL, *this, Rhs);
+  }
+
+  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
+private:
+  // Indexer used in the swizzles.def.
+  // Currently it is defined as a template struct. Replacing it with a constexpr
+  // function would activate a bug in MSVC that is fixed only in v19.20.
+  // Until then MSVC does not recognize such constexpr functions as const and
+  // thus does not let using them in template parameters inside swizzle.def.
+  template <int Index> struct Indexer {
+    static constexpr int IDXs[sizeof...(Indexes)] = {Indexes...};
+    static constexpr int value = IDXs[Index >= getNumElements() ? 0 : Index];
+  };
+
+public:
+#ifdef __SYCL_ACCESS_RETURN
+#error "Undefine __SYCL_ACCESS_RETURN macro"
+#endif
+#define __SYCL_ACCESS_RETURN m_Vector
+#include "swizzles.def"
+#undef __SYCL_ACCESS_RETURN
+  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
+
+  // Leave store() interface to automatic conversion to vec<>.
+  // Load to vec_t and then assign to swizzle.
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t offset, multi_ptr<DataT, Space, DecorateAddress> ptr) {
+    vec_t Tmp;
+    Tmp.template load(offset, ptr);
+    *this = Tmp;
+  }
+
+  template <typename convertT, rounding_mode roundingMode>
+  vec<convertT, sizeof...(Indexes)> convert() const {
+    // First materialize the swizzle to vec_t and then apply convert() to it.
+    vec_t Tmp = *this;
+    return Tmp.template convert<convertT, roundingMode>();
+  }
+
+  template <typename asT> asT as() const {
+    // First materialize the swizzle to vec_t and then apply as() to it.
+    vec_t Tmp = *this;
+    static_assert((sizeof(Tmp) == sizeof(asT)),
+                  "The new SYCL vec type must have the same storage size in "
+                  "bytes as this SYCL swizzled vec");
+    static_assert(
+        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
+            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
+        "asT must be SYCL vec of a different element type and "
+        "number of elements specified by asT");
+    return Tmp.template as<asT>();
+  }
+
+private:
+  SwizzleOp(const SwizzleOp &Rhs)
+      : m_Vector(Rhs.m_Vector), m_LeftOperation(Rhs.m_LeftOperation),
+        m_RightOperation(Rhs.m_RightOperation) {}
+
+  SwizzleOp(VecT *Vector, OperationLeftT LeftOperation,
+            OperationRightT RightOperation)
+      : m_Vector(Vector), m_LeftOperation(LeftOperation),
+        m_RightOperation(RightOperation) {}
+
+  SwizzleOp(VecT *Vector) : m_Vector(Vector) {}
+
+  SwizzleOp(SwizzleOp &&Rhs)
+      : m_Vector(Rhs.m_Vector), m_LeftOperation(std::move(Rhs.m_LeftOperation)),
+        m_RightOperation(std::move(Rhs.m_RightOperation)) {}
+
+  // Either performing CurrentOperation on results of left and right operands
+  // or reading values from actual vector. Perform implicit type conversion when
+  // the number of elements == 1
+
+  template <int IdxNum = getNumElements()>
+  CommonDataT getValue(EnableIfOneIndex<IdxNum, size_t> Index) const {
+    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
+      std::array<int, getNumElements()> Idxs{Indexes...};
+      return m_Vector->getValue(Idxs[Index]);
+    }
+    auto Op = OperationCurrentT<vec_data_t<CommonDataT>>();
+    return vec_data<CommonDataT>::get(
+        Op(vec_data<CommonDataT>::get(m_LeftOperation.getValue(Index)),
+           vec_data<CommonDataT>::get(m_RightOperation.getValue(Index))));
+  }
+
+  template <int IdxNum = getNumElements()>
+  DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
+    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
+      std::array<int, getNumElements()> Idxs{Indexes...};
+      return m_Vector->getValue(Idxs[Index]);
+    }
+    auto Op = OperationCurrentT<vec_data_t<DataT>>();
+    return vec_data<DataT>::get(
+        Op(vec_data<DataT>::get(m_LeftOperation.getValue(Index)),
+           vec_data<DataT>::get(m_RightOperation.getValue(Index))));
+  }
+
+  template <template <typename> class Operation, typename RhsOperation>
+  void operatorHelper(const RhsOperation &Rhs) {
+    Operation<vec_data_t<DataT>> Op;
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      DataT Res = vec_data<DataT>::get(
+          Op(vec_data<DataT>::get(m_Vector->getValue(Idxs[I])),
+             vec_data<DataT>::get(Rhs.getValue(I))));
+      m_Vector->setValue(Idxs[I], Res);
+    }
+  }
+
+  // fields
+  VecT *m_Vector;
+
+  OperationLeftT m_LeftOperation;
+  OperationRightT m_RightOperation;
+
+  // friends
+  template <typename T1, int T2> friend class sycl::vec;
+
+  template <typename T1, typename T2, typename T3, template <typename> class T4,
+            int... T5>
+  friend class SwizzleOp;
+};
+} // namespace detail
+
+namespace detail {
+
+// Vectors of size 1 are handled separately and therefore 1 is not included in
+// the check below.
+constexpr bool isValidVectorSize(int N) {
+  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
+}
+template <typename T, int N, typename V> struct VecStorage {
+  static_assert(
+      isValidVectorSize(N) || N == 1,
+      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
+      "or 16 are supported");
+  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
+};
+
+#ifdef __SYCL_DEVICE_ONLY__
+// device always has ext vector support, but for huge vectors
+// we switch to std::array, so that we can use a smaller alignment (64)
+// this is to support MSVC, which has a max of 64 for direct params.
+template <typename T, int N> struct VecStorageImpl {
+  static constexpr size_t Num = (N == 3) ? 4 : N;
+  static constexpr size_t Sz = Num * sizeof(T);
+  // using DataType =
+  //     typename std::conditional<Sz <= 64, T
+  //     __attribute__((ext_vector_type(N))),
+  //                               std::array<T, Num>>::type;
+  using DataType = std::array<T, (N == 3) ? 4 : N>;
+  using VectorDataType = T __attribute__((ext_vector_type(N)));
+};
+#else // __SYCL_DEVICE_ONLY__
+template <typename T, int N> struct VecStorageImpl {
+  using DataType = std::array<T, (N == 3) ? 4 : N>;
+};
+#endif // __SYCL_DEVICE_ONLY__
+
+// Single element bool
+template <> struct VecStorage<bool, 1, void> {
+  using DataType = bool;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = bool;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Multiple element bool
+template <int N>
+struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
+  using DataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+// Single element byte. Multiple elements will propagate through a later
+// specialization.
+template <> struct VecStorage<std::byte, 1, void> {
+  using DataType = std::int8_t;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = std::int8_t;
+#endif // __SYCL_DEVICE_ONLY__
+};
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+
+// Single element signed integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element unsigned integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element floating-point (except half/bfloat16)
+template <typename T>
+struct VecStorage<
+    T, 1,
+    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+// Multiple elements signed/unsigned integers and floating-point (except
+// half/bfloat16)
+template <typename T, int N>
+struct VecStorage<
+    T, N,
+    typename std::enable_if_t<isValidVectorSize(N) &&
+                              (is_sgeninteger_v<T> ||
+                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
+  using DataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element half
+template <> struct VecStorage<half, 1, void> {
+  using DataType = sycl::detail::half_impl::StorageT;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = sycl::detail::half_impl::StorageT;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Multiple elements half
+#ifdef __SYCL_DEVICE_ONLY__
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##DeviceStorageT;        \
+    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
+  };
+#else // __SYCL_DEVICE_ONLY__
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+  };
+#endif // __SYCL_DEVICE_ONLY__
+
+__SYCL_DEFINE_HALF_VECSTORAGE(2)
+__SYCL_DEFINE_HALF_VECSTORAGE(3)
+__SYCL_DEFINE_HALF_VECSTORAGE(4)
+__SYCL_DEFINE_HALF_VECSTORAGE(8)
+__SYCL_DEFINE_HALF_VECSTORAGE(16)
+#undef __SYCL_DEFINE_HALF_VECSTORAGE
+
+// Single element bfloat16
+template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
+  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  // using VectorDataType = sycl::ext::oneapi::bfloat16;
+  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+};
+// Multiple elements bfloat16
+#ifndef __SYCL_DEVICE_ONLY__
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
+  };
+#else
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType =                                                           \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##DeviceStorageT;             \
+    using VectorDataType =                                                     \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
+  };
+#endif
+__SYCL_DEFINE_BF16_VECSTORAGE(2)
+__SYCL_DEFINE_BF16_VECSTORAGE(3)
+__SYCL_DEFINE_BF16_VECSTORAGE(4)
+__SYCL_DEFINE_BF16_VECSTORAGE(8)
+__SYCL_DEFINE_BF16_VECSTORAGE(16)
+#undef __SYCL_DEFINE_BF16_VECSTORAGE
+} // namespace detail
+
+/// This macro must be defined to 1 when SYCL implementation allows user
+/// applications to explicitly declare certain class types as device copyable
+/// by adding specializations of is_device_copyable type trait class.
+#define SYCL_DEVICE_COPYABLE 1
+
+/// is_device_copyable is a user specializable class template to indicate
+/// that a type T is device copyable, which means that SYCL implementation
+/// may copy objects of the type T between host and device or between two
+/// devices.
+/// Specializing is_device_copyable such a way that
+/// is_device_copyable_v<T> == true on a T that does not satisfy all
+/// the requirements of a device copyable type is undefined behavior.
+template <typename T> struct is_device_copyable;
+
+namespace detail {
+template <typename T, typename = void>
+struct is_device_copyable_impl : std::is_trivially_copyable<T> {};
+
+template <typename T>
+struct is_device_copyable_impl<
+    T, std::enable_if_t<!std::is_same_v<T, std::remove_cv_t<T>>>>
+    // Cannot express this "recursion" (to take user's partial non-cv
+    // specializations into account) without this helper struct.
+    : is_device_copyable<std::remove_cv_t<T>> {};
+} // namespace detail
+
+template <typename T>
+struct is_device_copyable : detail::is_device_copyable_impl<T> {};
+
+// std::array<T, 0> is implicitly device copyable type.
+template <typename T>
+struct is_device_copyable<std::array<T, 0>> : std::true_type {};
+
+// std::array<T, N> is implicitly device copyable type if T is device copyable.
+template <typename T, std::size_t N>
+struct is_device_copyable<std::array<T, N>> : is_device_copyable<T> {};
+
+// std::optional<T> is implicitly device copyable type if T is device copyable.
+template <typename T>
+struct is_device_copyable<std::optional<T>> : is_device_copyable<T> {};
+
+// std::pair<T1, T2> is implicitly device copyable type if T1 and T2 are device
+// copyable.
+template <typename T1, typename T2>
+struct is_device_copyable<std::pair<T1, T2>>
+    : std::bool_constant<is_device_copyable<T1>::value &&
+                         is_device_copyable<T2>::value> {};
+
+// std::tuple<Ts...> is implicitly device copyable type if each type T of Ts...
+// is device copyable.
+template <typename... Ts>
+struct is_device_copyable<std::tuple<Ts...>>
+    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
+
+// std::variant<Ts...> is implicitly device copyable type if each type T of
+// Ts... is device copyable.
+template <typename... Ts>
+struct is_device_copyable<std::variant<Ts...>>
+    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
+
+// marray is device copyable if element type is device copyable.
+template <typename T, std::size_t N>
+struct is_device_copyable<sycl::marray<T, N>> : is_device_copyable<T> {};
+
+// array is device copyable if element type is device copyable.
+template <typename T, std::size_t N>
+struct is_device_copyable<T[N]> : is_device_copyable<T> {};
+
+template <typename T>
+inline constexpr bool is_device_copyable_v = is_device_copyable<T>::value;
+
+namespace detail {
+template <typename T, typename = void>
+struct IsDeprecatedDeviceCopyable : std::false_type {};
+
+// TODO: using C++ attribute [[deprecated]] or the macro __SYCL2020_DEPRECATED
+// does not produce expected warning message for the type 'T'.
+template <typename T>
+struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
+    IsDeprecatedDeviceCopyable<
+        T, std::enable_if_t<std::is_trivially_copy_constructible_v<T> &&
+                            std::is_trivially_destructible_v<T> &&
+                            !is_device_copyable_v<T>>> : std::true_type {};
+
+template <typename T, int N>
+struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
+    IsDeprecatedDeviceCopyable<T[N]> : IsDeprecatedDeviceCopyable<T> {};
+
+#ifdef __SYCL_DEVICE_ONLY__
+// Checks that the fields of the type T with indices 0 to (NumFieldsToCheck -
+// 1) are device copyable.
+template <typename T, unsigned NumFieldsToCheck>
+struct CheckFieldsAreDeviceCopyable
+    : CheckFieldsAreDeviceCopyable<T, NumFieldsToCheck - 1> {
+  using FieldT = decltype(__builtin_field_type(T, NumFieldsToCheck - 1));
+  static_assert(is_device_copyable_v<FieldT> ||
+                    detail::IsDeprecatedDeviceCopyable<FieldT>::value,
+                "The specified type is not device copyable");
+};
+
+template <typename T> struct CheckFieldsAreDeviceCopyable<T, 0> {};
+
+// Checks that the base classes of the type T with indices 0 to
+// (NumFieldsToCheck - 1) are device copyable.
+template <typename T, unsigned NumBasesToCheck>
+struct CheckBasesAreDeviceCopyable
+    : CheckBasesAreDeviceCopyable<T, NumBasesToCheck - 1> {
+  using BaseT = decltype(__builtin_base_type(T, NumBasesToCheck - 1));
+  static_assert(is_device_copyable_v<BaseT> ||
+                    detail::IsDeprecatedDeviceCopyable<BaseT>::value,
+                "The specified type is not device copyable");
+};
+
+template <typename T> struct CheckBasesAreDeviceCopyable<T, 0> {};
+
+// All the captures of a lambda or functor of type FuncT passed to a kernel
+// must be is_device_copyable, which extends to bases and fields of FuncT.
+// Fields are captures of lambda/functors and bases are possible base classes
+// of functors also allowed by SYCL.
+// The SYCL-2020 implementation must check each of the fields & bases of the
+// type FuncT, only one level deep, which is enough to see if they are all
+// device copyable by using the result of is_device_copyable returned for them.
+// At this moment though the check also allowes using types for which
+// (is_trivially_copy_constructible && is_trivially_destructible) returns true
+// and (is_device_copyable) returns false. That is the deprecated behavior and
+// is currently/temporarily supported only to not break older SYCL programs.
+template <typename FuncT>
+struct CheckDeviceCopyable
+    : CheckFieldsAreDeviceCopyable<FuncT, __builtin_num_fields(FuncT)>,
+      CheckBasesAreDeviceCopyable<FuncT, __builtin_num_bases(FuncT)> {};
+
+// Below are two specializations for CheckDeviceCopyable when a kernel lambda
+// is wrapped after range rounding optimization.
+template <typename TransformedArgType, int Dims, typename KernelType>
+struct CheckDeviceCopyable<
+    RoundedRangeKernel<TransformedArgType, Dims, KernelType>>
+    : CheckDeviceCopyable<KernelType> {};
+
+template <typename TransformedArgType, int Dims, typename KernelType>
+struct CheckDeviceCopyable<
+    RoundedRangeKernelWithKH<TransformedArgType, Dims, KernelType>>
+    : CheckDeviceCopyable<KernelType> {};
+
+#endif // __SYCL_DEVICE_ONLY__
+} // namespace detail
+
+} // namespace _V1
+} // namespace sycl
diff --git a/sycl/test/abi/layout_vec.cpp b/sycl/test/abi/layout_vec.cpp
index dac3e00e2d72a..e0928ce364a81 100644
--- a/sycl/test/abi/layout_vec.cpp
+++ b/sycl/test/abi/layout_vec.cpp
@@ -1,5 +1,8 @@
 // RUN: %clangxx -fsycl -c -fno-color-diagnostics -Xclang -fdump-record-layouts %s -o %t.out | FileCheck %s
 // RUN: %clangxx -fsycl -fsycl-device-only -c -fno-color-diagnostics -Xclang -fdump-record-layouts %s -o %t.out | FileCheck %s
+// RUN: %if preview-breaking-changes-supported %{ %clangxx -fsycl -c -fpreview-breaking-changes -fno-color-diagnostics -Xclang -fdump-record-layouts %s -o %t.out | FileCheck %s -check-prefix FSYCL-PREVIEW-BREAKING-CHANGES-CHECK %}
+// RUN: %if preview-breaking-changes-supported %{ %clangxx -fsycl -fsycl-device-only -c -fpreview-breaking-changes -fno-color-diagnostics -Xclang -fdump-record-layouts %s -o %t.out | FileCheck %s -check-prefix FSYCL-PREVIEW-BREAKING-CHANGES-CHECK %}
+
 // REQUIRES: linux
 // UNSUPPORTED: libcxx
 
@@ -10,17 +13,27 @@
 SYCL_EXTERNAL void foo(sycl::vec<int, 4>) {}
 
 // CHECK: 0 | class sycl::vec<int, 4>
-// CHECK-NEXT: 0 | struct std::array<int, 4> m_Data
-// CHECK-NEXT: 0 | typename _AT_Type::_Type _M_elems
+// CHECK-NEXT: 0 |   DataType m_Data
 // CHECK-NEXT: | [sizeof=16, dsize=16, align=16,
 // CHECK-NEXT: |  nvsize=16, nvalign=16]
 
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK: 0 | class sycl::vec<int, 4>
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: 0 | struct std::array<int, 4> m_Data
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: 0 | typename _AT_Type::_Type _M_elems
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: | [sizeof=16, dsize=16, align=16,
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: |  nvsize=16, nvalign=16]
+
 //--------------------------------------
 
 SYCL_EXTERNAL void foo(sycl::vec<bool, 16>) {}
 
 // CHECK: 0 | class sycl::vec<_Bool, 16>
-// CHECK-NEXT: 0 | struct std::array<signed char, 16> m_Data
-// CHECK-NEXT: 0 | typename _AT_Type::_Type _M_elems
+// CHECK-NEXT: 0 |   DataType m_Data
 // CHECK-NEXT: | [sizeof=16, dsize=16, align=16,
 // CHECK-NEXT: |  nvsize=16, nvalign=16]
+
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK: 0 | class sycl::vec<_Bool, 16>
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: 0 | struct std::array<signed char, 16> m_Data
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: 0 | typename _AT_Type::_Type _M_elems
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: | [sizeof=16, dsize=16, align=16,
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: |  nvsize=16, nvalign=16]
diff --git a/sycl/test/check_device_code/math-builtins/vector.cpp b/sycl/test/check_device_code/math-builtins/vector.cpp
index a02e20f609594..f7bfd511f0c1a 100644
--- a/sycl/test/check_device_code/math-builtins/vector.cpp
+++ b/sycl/test/check_device_code/math-builtins/vector.cpp
@@ -1,4 +1,4 @@
-// RUN: %clangxx -fsycl-device-only -S -O0 -Xclang -emit-llvm -o - %s | FileCheck %s --dump-input=always
+// RUN: %if preview-breaking-changes-supported %{ %clangxx -fpreview-breaking-changes -fsycl-device-only -S -O0 -Xclang -emit-llvm -o - %s | FileCheck %s %}
 
 // This test checks that sycl::vec uses std::array as storage type on device for
 // all data types.

From efef1049466a5bce72291ec9ec9e9b93b9e19a06 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 18 Apr 2024 12:21:45 -0700
Subject: [PATCH 23/79] Fix formating

---
 sycl/include/sycl/detail/generic_type_traits.hpp | 2 +-
 sycl/include/sycl/types_preview.hpp              | 9 +++------
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 31560715a45f1..287fb6de06b79 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -335,7 +335,7 @@ template <typename T> auto convertToOpenCLType(T &&x) {
     else
       return static_cast<typename MatchingVec::vector_t>(
           x.template as<MatchingVec>());
-#else // __INTEL_PREVIEW_BREAKING_CHANGES
+#else  // __INTEL_PREVIEW_BREAKING_CHANGES
     return sycl::bit_cast<typename MatchingVec::vector_t>(x);
 #endif // __INTEL_PREVIEW_BREAKING_CHANGES
 
diff --git a/sycl/include/sycl/types_preview.hpp b/sycl/include/sycl/types_preview.hpp
index 3a120b0ebb3f3..28d3a6de193b6 100644
--- a/sycl/include/sycl/types_preview.hpp
+++ b/sycl/include/sycl/types_preview.hpp
@@ -497,7 +497,7 @@ template <typename Type, int NumElements> class vec {
           detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
 
-  operator=(const Ty & Rhs) {
+  operator=(const Ty &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
     }
@@ -1945,14 +1945,11 @@ template <typename T, int N, typename V> struct VecStorage {
 template <typename T, int N> struct VecStorageImpl {
   static constexpr size_t Num = (N == 3) ? 4 : N;
   static constexpr size_t Sz = Num * sizeof(T);
-  // using DataType =
-  //     typename std::conditional<Sz <= 64, T
-  //     __attribute__((ext_vector_type(N))),
-  //                               std::array<T, Num>>::type;
+
   using DataType = std::array<T, (N == 3) ? 4 : N>;
   using VectorDataType = T __attribute__((ext_vector_type(N)));
 };
-#else // __SYCL_DEVICE_ONLY__
+#else  // __SYCL_DEVICE_ONLY__
 template <typename T, int N> struct VecStorageImpl {
   using DataType = std::array<T, (N == 3) ? 4 : N>;
 };

From 49d83f30f4d0fa1de4c21354fc3c17f59afb680e Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 23 Apr 2024 16:13:35 -0700
Subject: [PATCH 24/79] Create a new header for vector

---
 sycl/include/sycl/vector.hpp | 2345 ++++++++++++++++++++++++++++++++++
 1 file changed, 2345 insertions(+)
 create mode 100644 sycl/include/sycl/vector.hpp

diff --git a/sycl/include/sycl/vector.hpp b/sycl/include/sycl/vector.hpp
new file mode 100644
index 0000000000000..056012fd08cf1
--- /dev/null
+++ b/sycl/include/sycl/vector.hpp
@@ -0,0 +1,2345 @@
+//==---------------- types.hpp --- SYCL types ------------------------------==//
+//
+// 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
+
+// Check if Clang's ext_vector_type attribute is available. Host compiler
+// may not be Clang, and Clang may not be built with the extension.
+#ifdef __clang__
+#ifndef __has_extension
+#define __has_extension(x) 0
+#endif
+#ifdef __HAS_EXT_VECTOR_TYPE__
+#error "Undefine __HAS_EXT_VECTOR_TYPE__ macro"
+#endif
+#if __has_extension(attribute_ext_vector_type)
+#define __HAS_EXT_VECTOR_TYPE__
+#endif
+#endif // __clang__
+
+#if !defined(__HAS_EXT_VECTOR_TYPE__) && defined(__SYCL_DEVICE_ONLY__)
+#error "SYCL device compiler is built without ext_vector_type support"
+#endif
+
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_USE_EXT_VECTOR_TYPE__
+#endif
+
+#include <sycl/access/access.hpp>              // for decorated, address_space
+#include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
+#include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
+#include <sycl/detail/defines_elementary.hpp>  // for __SYCL2020_DEPRECATED
+#include <sycl/detail/generic_type_lists.hpp>  // for vector_basic_list
+#include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
+#include <sycl/detail/memcpy.hpp>              // for memcpy
+#include <sycl/detail/type_list.hpp>           // for is_contained
+#include <sycl/detail/type_traits.hpp>         // for is_floating_point
+#include <sycl/detail/vector_convert.hpp>      // for convertImpl
+#include <sycl/detail/vector_traits.hpp>       // for vector_alignment
+#include <sycl/exception.hpp>                  // for make_error_code, errc
+#include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
+#include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
+#include <sycl/multi_ptr.hpp>                  // for multi_ptr
+
+#include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
+
+#include <array>       // for array
+#include <assert.h>    // for assert
+#include <cstddef>     // for size_t, NULL, byte
+#include <cstdint>     // for uint8_t, int16_t, int...
+#include <functional>  // for divides, multiplies
+#include <iterator>    // for pair
+#include <optional>    // for optional
+#include <ostream>     // for operator<<, basic_ost...
+#include <tuple>       // for tuple
+#include <type_traits> // for enable_if_t, is_same
+#include <utility>     // for index_sequence, make_...
+#include <variant>     // for tuple, variant
+
+// 4.10.1: Scalar data types
+// 4.10.2: SYCL vector types
+
+namespace sycl {
+inline namespace _V1 {
+
+struct elem {
+  static constexpr int x = 0;
+  static constexpr int y = 1;
+  static constexpr int z = 2;
+  static constexpr int w = 3;
+  static constexpr int r = 0;
+  static constexpr int g = 1;
+  static constexpr int b = 2;
+  static constexpr int a = 3;
+  static constexpr int s0 = 0;
+  static constexpr int s1 = 1;
+  static constexpr int s2 = 2;
+  static constexpr int s3 = 3;
+  static constexpr int s4 = 4;
+  static constexpr int s5 = 5;
+  static constexpr int s6 = 6;
+  static constexpr int s7 = 7;
+  static constexpr int s8 = 8;
+  static constexpr int s9 = 9;
+  static constexpr int sA = 10;
+  static constexpr int sB = 11;
+  static constexpr int sC = 12;
+  static constexpr int sD = 13;
+  static constexpr int sE = 14;
+  static constexpr int sF = 15;
+};
+
+namespace detail {
+// select_apply_cl_t selects from T8/T16/T32/T64 basing on
+// sizeof(_IN).  expected to handle scalar types in _IN.
+template <typename _IN, typename T8, typename T16, typename T32, typename T64>
+using select_apply_cl_t = std::conditional_t<
+    sizeof(_IN) == 1, T8,
+    std::conditional_t<sizeof(_IN) == 2, T16,
+                       std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
+
+template <typename T> struct vec_helper {
+  using RetType = T;
+  static constexpr RetType get(T value) { return value; }
+  static constexpr RetType set(T value) { return value; }
+};
+template <> struct vec_helper<bool> {
+  using RetType = select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                    std::int32_t, std::int64_t>;
+  static constexpr RetType get(bool value) { return value; }
+  static constexpr RetType set(bool value) { return value; }
+};
+
+template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
+  using RetType = sycl::ext::oneapi::bfloat16;
+  using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  static constexpr RetType get(BFloat16StorageT value) {
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<RetType>(value);
+#else
+    // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+    // but neither available yet.
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.storage = value;
+    return result.bf16;
+#endif
+  }
+
+  static constexpr RetType get(RetType value) { return value; }
+
+  static constexpr BFloat16StorageT set(RetType value) {
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<BFloat16StorageT>(value);
+#else
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.bf16 = value;
+    return result.storage;
+#endif
+  }
+};
+
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+template <> struct vec_helper<std::byte> {
+  using RetType = std::uint8_t;
+  static constexpr RetType get(std::byte value) { return (RetType)value; }
+  static constexpr RetType set(std::byte value) { return (RetType)value; }
+  static constexpr std::byte get(std::uint8_t value) {
+    return (std::byte)value;
+  }
+  static constexpr std::byte set(std::uint8_t value) {
+    return (std::byte)value;
+  }
+};
+#endif
+
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp;
+
+template <typename T, int N, typename V = void> struct VecStorage;
+
+// Element type for relational operator return value.
+template <typename DataT>
+using rel_t = typename std::conditional_t<
+    sizeof(DataT) == sizeof(opencl::cl_char), opencl::cl_char,
+    typename std::conditional_t<
+        sizeof(DataT) == sizeof(opencl::cl_short), opencl::cl_short,
+        typename std::conditional_t<
+            sizeof(DataT) == sizeof(opencl::cl_int), opencl::cl_int,
+            typename std::conditional_t<sizeof(DataT) ==
+                                            sizeof(opencl::cl_long),
+                                        opencl::cl_long, bool>>>>;
+
+// Special type indicating that SwizzleOp should just read value from vector -
+// not trying to perform any operations. Should not be called.
+template <typename T> class GetOp {
+public:
+  using DataT = T;
+  DataT getValue(size_t) const { return (DataT)0; }
+  DataT operator()(DataT, DataT) { return (DataT)0; }
+};
+
+// Special type for working SwizzleOp with scalars, stores a scalar and gives
+// the scalar at any index. Provides interface is compatible with SwizzleOp
+// operations
+template <typename T> class GetScalarOp {
+public:
+  using DataT = T;
+  GetScalarOp(DataT Data) : m_Data(Data) {}
+  DataT getValue(size_t) const { return m_Data; }
+
+private:
+  DataT m_Data;
+};
+
+template <typename T> struct EqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs == Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct NotEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs != Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs >= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs <= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs > Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs < Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalAnd {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs && Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalOr {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs || Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct RShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs >> Rhs;
+  }
+};
+
+template <typename T> struct LShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs << Rhs;
+  }
+};
+
+// Forward declarations
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernel;
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernelWithKH;
+
+} // namespace detail
+
+template <typename T> using vec_data = detail::vec_helper<T>;
+
+template <typename T>
+using vec_data_t = typename detail::vec_helper<T>::RetType;
+
+/// Provides a cross-patform vector class template that works efficiently on
+/// SYCL devices as well as in host C++ code.
+///
+/// \ingroup sycl_api
+template <typename Type, int NumElements> class vec {
+  using DataT = Type;
+
+  // This represent type of underlying value. There should be only one field
+  // in the class, so vec<float, 16> should be equal to float16 in memory.
+  using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
+
+  static constexpr bool IsHostHalf =
+      std::is_same_v<DataT, sycl::detail::half_impl::half> &&
+      std::is_same_v<sycl::detail::half_impl::StorageT,
+                     sycl::detail::host_half_impl::half>;
+
+  static constexpr bool IsBfloat16 =
+      std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
+
+  static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
+  static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
+  static constexpr bool IsSizeGreaterThanMaxAlign =
+      (Sz > detail::MaxVecAlignment);
+
+  // TODO: There is no support for vector half type on host yet.
+  // Also, when Sz is greater than alignment, we use std::array instead of
+  // vector extension. This is for MSVC compatibility, which has a max alignment
+  // of 64 for direct params. If we drop MSVC, we can have alignment the same as
+  // size and use vector extensions for all sizes.
+  static constexpr bool IsUsingArrayOnDevice =
+      (IsHostHalf || IsBfloat16 || IsSizeGreaterThanMaxAlign);
+
+#if defined(__SYCL_DEVICE_ONLY__)
+  static constexpr bool NativeVec = NumElements > 1 && !IsUsingArrayOnDevice;
+  static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
+#else
+  static constexpr bool NativeVec = false;
+  static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
+#endif
+
+  static constexpr int getNumElements() { return NumElements; }
+
+  // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
+  template <int Counter, int MaxValue, class...>
+  struct SizeChecker : std::conditional_t<Counter == MaxValue, std::true_type,
+                                          std::false_type> {};
+
+  template <int Counter, int MaxValue, typename DataT_, class... tail>
+  struct SizeChecker<Counter, MaxValue, DataT_, tail...>
+      : std::conditional_t<Counter + 1 <= MaxValue,
+                           SizeChecker<Counter + 1, MaxValue, tail...>,
+                           std::false_type> {};
+
+  // Utility trait for creating an std::array from an vector argument.
+  template <typename DataT_, typename T, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const vec<T, sizeof...(Is)> &V, std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &V,
+             std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &V,
+             std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N>
+  static constexpr std::array<DataT_, N>
+  FlattenVecArgHelper(const vec<T, N> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<N>());
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5>
+  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
+      const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5>
+  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
+      const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
+  }
+  template <typename DataT_, typename T>
+  static constexpr auto FlattenVecArgHelper(const T &A) {
+    return std::array<DataT_, 1>{vec_data<DataT_>::get(static_cast<DataT_>(A))};
+  }
+  template <typename DataT_, typename T> struct FlattenVecArg {
+    constexpr auto operator()(const T &A) const {
+      return FlattenVecArgHelper<DataT_>(A);
+    }
+  };
+
+  // Alias for shortening the vec arguments to array converter.
+  template <typename DataT_, typename... ArgTN>
+  using VecArgArrayCreator =
+      detail::ArrayCreator<DataT_, FlattenVecArg, ArgTN...>;
+
+#define __SYCL_ALLOW_VECTOR_SIZES(num_elements)                                \
+  template <int Counter, int MaxValue, typename DataT_, class... tail>         \
+  struct SizeChecker<Counter, MaxValue, vec<DataT_, num_elements>, tail...>    \
+      : std::conditional_t<                                                    \
+            Counter + (num_elements) <= MaxValue,                              \
+            SizeChecker<Counter + (num_elements), MaxValue, tail...>,          \
+            std::false_type> {};                                               \
+  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
+            typename T3, template <typename> class T4, int... T5,              \
+            class... tail>                                                     \
+  struct SizeChecker<                                                          \
+      Counter, MaxValue,                                                       \
+      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>,         \
+      tail...>                                                                 \
+      : std::conditional_t<                                                    \
+            Counter + sizeof...(T5) <= MaxValue,                               \
+            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
+            std::false_type> {};                                               \
+  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
+            typename T3, template <typename> class T4, int... T5,              \
+            class... tail>                                                     \
+  struct SizeChecker<                                                          \
+      Counter, MaxValue,                                                       \
+      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
+      tail...>                                                                 \
+      : std::conditional_t<                                                    \
+            Counter + sizeof...(T5) <= MaxValue,                               \
+            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
+            std::false_type> {};
+
+  __SYCL_ALLOW_VECTOR_SIZES(1)
+  __SYCL_ALLOW_VECTOR_SIZES(2)
+  __SYCL_ALLOW_VECTOR_SIZES(3)
+  __SYCL_ALLOW_VECTOR_SIZES(4)
+  __SYCL_ALLOW_VECTOR_SIZES(8)
+  __SYCL_ALLOW_VECTOR_SIZES(16)
+#undef __SYCL_ALLOW_VECTOR_SIZES
+
+  // TypeChecker is needed for vec(const argTN &... args) ctor to validate args.
+  template <typename T, typename DataT_>
+  struct TypeChecker : std::is_convertible<T, DataT_> {};
+#define __SYCL_ALLOW_VECTOR_TYPES(num_elements)                                \
+  template <typename DataT_>                                                   \
+  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {};   \
+  template <typename DataT_, typename T2, typename T3,                         \
+            template <typename> class T4, int... T5>                           \
+  struct TypeChecker<                                                          \
+      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
+      : std::true_type {};                                                     \
+  template <typename DataT_, typename T2, typename T3,                         \
+            template <typename> class T4, int... T5>                           \
+  struct TypeChecker<                                                          \
+      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
+      DataT_> : std::true_type {};
+
+  __SYCL_ALLOW_VECTOR_TYPES(1)
+  __SYCL_ALLOW_VECTOR_TYPES(2)
+  __SYCL_ALLOW_VECTOR_TYPES(3)
+  __SYCL_ALLOW_VECTOR_TYPES(4)
+  __SYCL_ALLOW_VECTOR_TYPES(8)
+  __SYCL_ALLOW_VECTOR_TYPES(16)
+#undef __SYCL_ALLOW_VECTOR_TYPES
+
+  template <int... Indexes>
+  using Swizzle =
+      detail::SwizzleOp<vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
+                        detail::GetOp, Indexes...>;
+
+  template <int... Indexes>
+  using ConstSwizzle =
+      detail::SwizzleOp<const vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
+                        detail::GetOp, Indexes...>;
+
+  // Shortcuts for args validation in vec(const argTN &... args) ctor.
+  template <typename... argTN>
+  using EnableIfSuitableTypes = typename std::enable_if_t<
+      std::conjunction_v<TypeChecker<argTN, DataT>...>>;
+
+  template <typename... argTN>
+  using EnableIfSuitableNumElements =
+      typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
+
+  template <size_t... Is>
+  constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
+                std::index_sequence<Is...>)
+      : m_Data{([&](vec_data_t<DataT> v) constexpr {
+          if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
+            return v.value;
+          else
+            return vec_data_t<DataT>(static_cast<DataT>(v));
+        })(Arr[Is])...} {}
+
+public:
+  using element_type = DataT;
+  using value_type = DataT;
+  using rel_t = detail::rel_t<DataT>;
+#ifdef __SYCL_DEVICE_ONLY__
+  using vector_t =
+      typename detail::VecStorage<DataT, NumElements>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+
+  vec() = default;
+
+  constexpr vec(const vec &Rhs) = default;
+  constexpr vec(vec &&Rhs) = default;
+
+  constexpr vec &operator=(const vec &Rhs) = default;
+
+  // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
+  template <typename Ty = DataT>
+  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
+                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
+                            vec &>
+  operator=(const vec<rel_t, NumElements> &Rhs) {
+    *this = Rhs.template as<vec>();
+    return *this;
+  }
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <typename T = void>
+  using EnableIfNotHostHalf = typename std::enable_if_t<!IsHostHalf, T>;
+
+  template <typename T = void>
+  using EnableIfHostHalf = typename std::enable_if_t<IsHostHalf, T>;
+
+  template <typename T = void>
+  using EnableIfUsingArrayOnDevice =
+      typename std::enable_if_t<IsUsingArrayOnDevice, T>;
+
+  template <typename T = void>
+  using EnableIfNotUsingArrayOnDevice =
+      typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  template <typename T = void>
+  using EnableIfUsingArray =
+      typename std::enable_if_t<IsUsingArrayOnDevice || IsUsingArrayOnHost, T>;
+
+  template <typename T = void>
+  using EnableIfNotUsingArray =
+      typename std::enable_if_t<!IsUsingArrayOnDevice && !IsUsingArrayOnHost,
+                                T>;
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+
+  template <typename Ty = DataT>
+  explicit constexpr vec(const EnableIfNotUsingArrayOnDevice<Ty> &arg)
+      : m_Data{DataType(vec_data<Ty>::get(arg))} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) {
+    m_Data = (DataType)vec_data<Ty>::get(Rhs);
+    return *this;
+  }
+
+  template <typename Ty = DataT>
+  explicit constexpr vec(const EnableIfUsingArrayOnDevice<Ty> &arg)
+      : vec{detail::RepeatValue<NumElements>(
+                static_cast<vec_data_t<DataT>>(arg)),
+            std::make_index_sequence<NumElements>()} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
+    for (int i = 0; i < NumElements; ++i) {
+      setValue(i, Rhs);
+    }
+    return *this;
+  }
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+  explicit constexpr vec(const DataT &arg)
+      : vec{detail::RepeatValue<NumElements>(
+                static_cast<vec_data_t<DataT>>(arg)),
+            std::make_index_sequence<NumElements>()} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const DataT &Rhs) {
+    for (int i = 0; i < NumElements; ++i) {
+      setValue(i, Rhs);
+    }
+    return *this;
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  // Optimized naive constructors with NumElements of DataT values.
+  // We don't expect compilers to optimize vararg recursive functions well.
+
+  // Helper type to make specific constructors available only for specific
+  // number of elements.
+  template <int IdxNum, typename T = void>
+  using EnableIfMultipleElems = typename std::enable_if_t<
+      std::is_convertible_v<T, DataT> && NumElements == IdxNum, DataT>;
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<2, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<3, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<4, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const Ty Arg3)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<8, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const DataT Arg3, const DataT Arg4, const DataT Arg5,
+                const DataT Arg6, const DataT Arg7)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
+               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
+               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<16, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const DataT Arg3, const DataT Arg4, const DataT Arg5,
+                const DataT Arg6, const DataT Arg7, const DataT Arg8,
+                const DataT Arg9, const DataT ArgA, const DataT ArgB,
+                const DataT ArgC, const DataT ArgD, const DataT ArgE,
+                const DataT ArgF)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
+               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
+               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7),
+               vec_data<Ty>::get(Arg8), vec_data<Ty>::get(Arg9),
+               vec_data<Ty>::get(ArgA), vec_data<Ty>::get(ArgB),
+               vec_data<Ty>::get(ArgC), vec_data<Ty>::get(ArgD),
+               vec_data<Ty>::get(ArgE), vec_data<Ty>::get(ArgF)} {}
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // Constructor from values of base type or vec of base type. Checks that
+  // base types are match and that the NumElements == sum of lengths of args.
+  template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
+            typename = EnableIfSuitableNumElements<argTN...>>
+  constexpr vec(const argTN &...args)
+      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
+            std::make_index_sequence<NumElements>()} {}
+
+#ifdef __SYCL_DEVICE_ONLY__
+  template <typename vector_t_ = vector_t,
+            typename =
+                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
+                                          !std::is_same_v<vector_t_, DataT>>>
+  constexpr vec(vector_t openclVector) {
+    if constexpr (!IsUsingArrayOnDevice) {
+      m_Data = openclVector;
+    } else {
+      m_Data = bit_cast<DataType>(openclVector);
+    }
+  }
+
+  operator vector_t() const {
+    if constexpr (!IsUsingArrayOnDevice) {
+      return m_Data;
+    } else {
+      auto ptr = bit_cast<const vector_t *>((&m_Data)->data());
+      return *ptr;
+    }
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
+  // Available only when: NumElements == 1
+  template <int N = NumElements>
+  operator typename std::enable_if_t<N == 1, DataT>() const {
+    return vec_data<DataT>::get(m_Data);
+  }
+
+  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
+  static constexpr size_t get_count() { return size(); }
+  static constexpr size_t size() noexcept { return NumElements; }
+  __SYCL2020_DEPRECATED(
+      "get_size() is deprecated, please use byte_size() instead")
+  static constexpr size_t get_size() { return byte_size(); }
+  static constexpr size_t byte_size() noexcept { return sizeof(m_Data); }
+
+  // convertImpl can't be called with the same From and To types and therefore
+  // we need this version of convert which is mostly no-op.
+  template <typename convertT,
+            rounding_mode roundingMode = rounding_mode::automatic>
+  std::enable_if_t<
+      std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> ||
+          std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
+                         detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      vec<convertT, NumElements>>
+  convert() const {
+    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+                      detail::is_floating_point<convertT>::value,
+                  "Unsupported convertT");
+    if constexpr (!std::is_same_v<DataT, convertT>) {
+      // Dummy conversion for cases like vec<signed char> -> vec<char>
+      vec<convertT, NumElements> Result;
+      for (size_t I = 0; I < NumElements; ++I)
+        Result.setValue(I, static_cast<convertT>(getValue(I)));
+
+      return Result;
+    } else {
+      // No conversion necessary
+      return *this;
+    }
+  }
+
+  template <typename convertT,
+            rounding_mode roundingMode = rounding_mode::automatic>
+  std::enable_if_t<
+      !std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> &&
+          !std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
+                          detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      vec<convertT, NumElements>>
+  convert() const {
+    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+                      detail::is_floating_point<convertT>::value,
+                  "Unsupported convertT");
+    using T = vec_data_t<DataT>;
+    using R = vec_data_t<convertT>;
+    using OpenCLT = detail::ConvertToOpenCLType_t<T>;
+    using OpenCLR = detail::ConvertToOpenCLType_t<R>;
+    vec<convertT, NumElements> Result;
+
+#if defined(__SYCL_DEVICE_ONLY__)
+    using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
+    using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
+    // Whole vector conversion can only be done, if:
+    constexpr bool canUseNativeVectorConvert =
+#ifdef __NVPTX__
+        // - we are not on CUDA, see intel/llvm#11840
+        false &&
+#endif
+        // - both vectors are represented using native vector types;
+        NativeVec && vec<convertT, NumElements>::NativeVec &&
+        // - vec storage has an equivalent OpenCL native vector it is implicitly
+        //   convertible to. There are some corner cases where it is not the
+        //   case with char, long and long long types.
+        std::is_convertible_v<decltype(m_Data), OpenCLVecT> &&
+        std::is_convertible_v<decltype(Result.m_Data), OpenCLVecR> &&
+        // - it is not a signed to unsigned (or vice versa) conversion
+        //   see comments within 'convertImpl' for more details;
+        !detail::is_sint_to_from_uint<T, R>::value &&
+        // - destination type is not bool. bool is stored as integer under the
+        //   hood and therefore conversion to bool looks like conversion between
+        //   two integer types. Since bit pattern for true and false is not
+        //   defined, there is no guarantee that integer conversion yields
+        //   right results here;
+        !std::is_same_v<convertT, bool>;
+    if constexpr (canUseNativeVectorConvert) {
+      Result.m_Data = detail::convertImpl<T, R, roundingMode, NumElements,
+                                          OpenCLVecT, OpenCLVecR>(m_Data);
+    } else
+#endif // defined(__SYCL_DEVICE_ONLY__)
+    {
+      // Otherwise, we fallback to per-element conversion:
+      for (size_t I = 0; I < NumElements; ++I) {
+        Result.setValue(
+            I, vec_data<convertT>::get(
+                   detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
+                       vec_data<DataT>::get(getValue(I)))));
+      }
+    }
+
+    return Result;
+  }
+
+  template <typename asT> asT as() const {
+    static_assert((sizeof(*this) == sizeof(asT)),
+                  "The new SYCL vec type must have the same storage size in "
+                  "bytes as this SYCL vec");
+    static_assert(
+        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
+            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
+        "asT must be SYCL vec of a different element type and "
+        "number of elements specified by asT");
+    asT Result;
+    detail::memcpy(&Result.m_Data, &m_Data, sizeof(decltype(Result.m_Data)));
+    return Result;
+  }
+
+  template <int... SwizzleIndexes> Swizzle<SwizzleIndexes...> swizzle() {
+    return this;
+  }
+
+  template <int... SwizzleIndexes>
+  ConstSwizzle<SwizzleIndexes...> swizzle() const {
+    return this;
+  }
+
+  // ext_vector_type is used as an underlying type for sycl::vec on device.
+  // The problem is that for clang vector types the return of operator[] is a
+  // temporary and not a reference to the element in the vector. In practice
+  // reinterpret_cast<DataT *>(&m_Data)[i]; is working. According to
+  // http://llvm.org/docs/GetElementPtr.html#can-gep-index-into-vector-elements
+  // this is not disallowed now. But could probably be disallowed in the future.
+  // That is why tests are added to check that behavior of the compiler has
+  // not changed.
+  //
+  // Implement operator [] in the same way for host and device.
+  // TODO: change host side implementation when underlying type for host side
+  // will be changed to std::array.
+  // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
+  // aggressively optimized. Specializing with noinline to avoid as workaround.
+
+  template <typename T = DataT>
+  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                            const DataT &>
+  operator[](int i) const {
+    return reinterpret_cast<const DataT *>(&m_Data)[i];
+  }
+
+  template <typename T = DataT>
+  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                            DataT &>
+  operator[](int i) {
+    return reinterpret_cast<DataT *>(&m_Data)[i];
+  }
+
+#ifdef _MSC_VER
+#define __SYCL_NOINLINE_BF16 __declspec(noinline)
+#else
+#define __SYCL_NOINLINE_BF16 __attribute__((noinline))
+#endif
+
+  template <typename T = DataT>
+  __SYCL_NOINLINE_BF16
+      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                const DataT &>
+      operator[](int i) const {
+    return reinterpret_cast<const DataT *>(&m_Data)[i];
+  }
+
+  template <typename T = DataT>
+  __SYCL_NOINLINE_BF16
+      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                DataT &>
+      operator[](int i) {
+    return reinterpret_cast<DataT *>(&m_Data)[i];
+  }
+
+#undef __SYCL_NOINLINE_BF16
+
+  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
+private:
+  // Indexer used in the swizzles.def
+  // Currently it is defined as a template struct. Replacing it with a constexpr
+  // function would activate a bug in MSVC that is fixed only in v19.20.
+  // Until then MSVC does not recognize such constexpr functions as const and
+  // thus does not let using them in template parameters inside swizzle.def.
+  template <int Index> struct Indexer {
+    static constexpr int value = Index;
+  };
+
+public:
+#ifdef __SYCL_ACCESS_RETURN
+#error "Undefine __SYCL_ACCESS_RETURN macro"
+#endif
+#define __SYCL_ACCESS_RETURN this
+#include "swizzles.def"
+#undef __SYCL_ACCESS_RETURN
+  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
+
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t Offset, multi_ptr<const DataT, Space, DecorateAddress> Ptr) {
+    for (int I = 0; I < NumElements; I++) {
+      setValue(I, *multi_ptr<const DataT, Space, DecorateAddress>(
+                      Ptr + Offset * NumElements + I));
+    }
+  }
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t Offset, multi_ptr<DataT, Space, DecorateAddress> Ptr) {
+    multi_ptr<const DataT, Space, DecorateAddress> ConstPtr(Ptr);
+    load(Offset, ConstPtr);
+  }
+  template <int Dimensions, access::mode Mode,
+            access::placeholder IsPlaceholder, access::target Target,
+            typename PropertyListT>
+  void
+  load(size_t Offset,
+       accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
+           Acc) {
+    multi_ptr<const DataT, detail::TargetToAS<Target>::AS,
+              access::decorated::yes>
+        MultiPtr(Acc);
+    load(Offset, MultiPtr);
+  }
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void store(size_t Offset,
+             multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
+    for (int I = 0; I < NumElements; I++) {
+      *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
+                                                I) = getValue(I);
+    }
+  }
+  template <int Dimensions, access::mode Mode,
+            access::placeholder IsPlaceholder, access::target Target,
+            typename PropertyListT>
+  void
+  store(size_t Offset,
+        accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
+            Acc) {
+    multi_ptr<DataT, detail::TargetToAS<Target>::AS, access::decorated::yes>
+        MultiPtr(Acc);
+    store(Offset, MultiPtr);
+  }
+
+  void ConvertToDataT() {
+    for (size_t i = 0; i < NumElements; ++i) {
+      DataT tmp = getValue(i);
+      setValue(i, tmp);
+    }
+  }
+
+#ifdef __SYCL_BINOP
+#error "Undefine __SYCL_BINOP macro"
+#endif
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
+  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+    vec Ret;                                                                   \
+    if constexpr (IsUsingArrayOnDevice) {                                      \
+      for (size_t I = 0; I < NumElements; ++I) {                               \
+        Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
+      }                                                                        \
+    } else {                                                                   \
+      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+      if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
+        Ret.ConvertToDataT();                                                  \
+      }                                                                        \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+    return Lhs BINOP vec(Rhs);                                                 \
+  }                                                                            \
+  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+    return vec(Lhs) BINOP Rhs;                                                 \
+  }                                                                            \
+  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+    Lhs = Lhs BINOP Rhs;                                                       \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <int Num = NumElements>                                             \
+  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
+      vec & Lhs, const DataT & Rhs) {                                          \
+    Lhs = Lhs BINOP vec(Rhs);                                                  \
+    return Lhs;                                                                \
+  }
+
+#else // __SYCL_USE_EXT_VECTOR_TYPE__
+
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
+  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+    vec Ret{};                                                                 \
+    if constexpr (NativeVec)                                                   \
+      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+    else                                                                       \
+      for (size_t I = 0; I < NumElements; ++I)                                 \
+        Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(             \
+                            I)) BINOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+    return Lhs BINOP vec(Rhs);                                                 \
+  }                                                                            \
+  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+    return vec(Lhs) BINOP Rhs;                                                 \
+  }                                                                            \
+  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+    Lhs = Lhs BINOP Rhs;                                                       \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <int Num = NumElements>                                             \
+  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
+      vec & Lhs, const DataT & Rhs) {                                          \
+    Lhs = Lhs BINOP vec(Rhs);                                                  \
+    return Lhs;                                                                \
+  }
+
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  __SYCL_BINOP(+, +=, true)
+  __SYCL_BINOP(-, -=, true)
+  __SYCL_BINOP(*, *=, false)
+  __SYCL_BINOP(/, /=, false)
+
+  // TODO: The following OPs are available only when: DataT != cl_float &&
+  // DataT != cl_double && DataT != cl_half
+  __SYCL_BINOP(%, %=, false)
+  __SYCL_BINOP(|, |=, false)
+  __SYCL_BINOP(&, &=, false)
+  __SYCL_BINOP(^, ^=, false)
+  __SYCL_BINOP(>>, >>=, false)
+  __SYCL_BINOP(<<, <<=, true)
+#undef __SYCL_BINOP
+#undef __SYCL_BINOP_HELP
+
+  // Note: vec<>/SwizzleOp logical value is 0/-1 logic, as opposed to 0/1 logic.
+  // As far as CTS validation is concerned, 0/-1 logic also applies when
+  // NumElements is equal to one, which is somewhat inconsistent with being
+  // transparent with scalar data.
+  // TODO: Determine if vec<, NumElements=1> is needed at all, remove this
+  // inconsistency if not by disallowing one-element vectors (as in OpenCL)
+
+#ifdef __SYCL_RELLOGOP
+#error "Undefine __SYCL_RELLOGOP macro"
+#endif
+// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
+// by SYCL device compiler only.
+#ifdef __SYCL_DEVICE_ONLY__
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const vec & Rhs) {          \
+    vec<rel_t, NumElements> Ret{};                                             \
+    /* This special case is needed since there are no standard operator||   */ \
+    /* or operator&& functions for std::array.                              */ \
+    if constexpr (IsUsingArrayOnDevice &&                                      \
+                  (std::string_view(#RELLOGOP) == "||" ||                      \
+                   std::string_view(#RELLOGOP) == "&&")) {                     \
+      for (size_t I = 0; I < NumElements; ++I) {                               \
+        /* We cannot use SetValue here as the operator is not a friend of*/    \
+        /* Ret on Windows. */                                                  \
+        Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                    \
+            Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+      }                                                                        \
+    } else {                                                                   \
+      Ret = vec<rel_t, NumElements>(                                           \
+          (typename vec<rel_t, NumElements>::vector_t)(                        \
+              Lhs.m_Data RELLOGOP Rhs.m_Data));                                \
+      if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
+        Ret *= -1;                                                             \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const DataT & Rhs) {        \
+    return Lhs RELLOGOP vec(Rhs);                                              \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
+                                                   const vec & Rhs) {          \
+    return vec(Lhs) RELLOGOP Rhs;                                              \
+  }
+
+#else
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const vec & Rhs) {          \
+    vec<rel_t, NumElements> Ret{};                                             \
+    for (size_t I = 0; I < NumElements; ++I) {                                 \
+      /* We cannot use SetValue here as the operator is not a friend of*/      \
+      /* Ret on Windows. */                                                    \
+      Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                      \
+          Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));   \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const DataT & Rhs) {        \
+    return Lhs RELLOGOP vec(Rhs);                                              \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
+                                                   const vec & Rhs) {          \
+    return vec(Lhs) RELLOGOP Rhs;                                              \
+  }
+#endif
+
+  __SYCL_RELLOGOP(==)
+  __SYCL_RELLOGOP(!=)
+  __SYCL_RELLOGOP(>)
+  __SYCL_RELLOGOP(<)
+  __SYCL_RELLOGOP(>=)
+  __SYCL_RELLOGOP(<=)
+  // TODO: limit to integral types.
+  __SYCL_RELLOGOP(&&)
+  __SYCL_RELLOGOP(||)
+#undef __SYCL_RELLOGOP
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  friend vec &operator UOP(vec & Rhs) {                                        \
+    Rhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    return Rhs;                                                                \
+  }                                                                            \
+  friend vec operator UOP(vec &Lhs, int) {                                     \
+    vec Ret(Lhs);                                                              \
+    Lhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  // operator~() available only when: dataT != float && dataT != double
+  // && dataT != half
+  friend vec operator~(const vec &Rhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I) {
+        Ret.setValue(I, ~Rhs.getValue(I));
+      }
+      return Ret;
+    } else {
+      vec Ret{(typename vec::DataType) ~Rhs.m_Data};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+      return Ret;
+    }
+  }
+
+  // operator!
+  friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I) {
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        // std::byte neither supports ! unary op or casting, so special handling
+        // is needed. And, worse, Windows has a conflict with 'byte'.
+        if constexpr (std::is_same_v<std::byte, DataT>) {
+          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
+        } else
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        {
+          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
+        }
+      }
+      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
+    } else {
+      return vec{(typename vec<DataT, NumElements>::DataType) !Rhs.m_Data}
+          .template as<vec<detail::rel_t<DataT>, NumElements>>();
+    }
+  }
+
+  // operator +
+  friend vec operator+(const vec &Lhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(
+            I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
+      return Ret;
+    } else {
+      return vec{+Lhs.m_Data};
+    }
+  }
+
+  // operator -
+  friend vec operator-(const vec &Lhs) {
+    namespace oneapi = sycl::ext::oneapi;
+    vec Ret{};
+    if constexpr (IsBfloat16 && NumElements == 1) {
+      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data);
+      oneapi::bfloat16 w = -v;
+      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
+    } else if constexpr (IsBfloat16) {
+      for (size_t I = 0; I < NumElements; I++) {
+        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[I]);
+        oneapi::bfloat16 w = -v;
+        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
+      }
+    } else if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(
+            I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
+      return Ret;
+    } else {
+      Ret = vec{-Lhs.m_Data};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+      return Ret;
+    }
+  }
+
+  // OP is: &&, ||
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
+
+  // OP is: ==, !=, <, >, <=, >=
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
+private:
+  // Generic method that execute "Operation" on underlying values.
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <template <typename> class Operation,
+            typename Ty = vec<DataT, NumElements>>
+  vec<DataT, NumElements>
+  operatorHelper(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataType> Op;
+    Result.m_Data = Op(m_Data, Rhs.m_Data);
+    return Result;
+  }
+
+  template <template <typename> class Operation,
+            typename Ty = vec<DataT, NumElements>>
+  vec<DataT, NumElements>
+  operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataT> Op;
+    for (size_t I = 0; I < NumElements; ++I) {
+      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
+    }
+    return Result;
+  }
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+  template <template <typename> class Operation>
+  vec<DataT, NumElements>
+  operatorHelper(const vec<DataT, NumElements> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataT> Op;
+    for (size_t I = 0; I < NumElements; ++I) {
+      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
+    }
+    return Result;
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // setValue and getValue should be able to operate on different underlying
+  // types: enum cl_float#N , builtin vector float#N, builtin type float.
+  // These versions are for N > 1.
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
+                          int) {
+    m_Data[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
+    return vec_data<DataT>::get(m_Data[Index]);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
+    m_Data.s[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
+    return vec_data<DataT>::get(m_Data.s[Index]);
+  }
+#else // __SYCL_USE_EXT_VECTOR_TYPE__
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(int Index, const DataT &Value, int) {
+    m_Data[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(int Index, int) const {
+    return vec_data<DataT>::get(m_Data[Index]);
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // N==1 versions, used by host and device. Shouldn't trailing type be int?
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 == Num>>
+  constexpr void setValue(int, const DataT &Value, float) {
+    m_Data = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 == Num>>
+  DataT getValue(int, float) const {
+    return vec_data<DataT>::get(m_Data);
+  }
+
+  // setValue and getValue.
+  // The "api" functions used by BINOP etc.  These versions just dispatch
+  // using additional int or float arg to disambiguate vec<1> vs. vec<N>
+  // Special proxies as specialization is not allowed in class scope.
+  constexpr void setValue(int Index, const DataT &Value) {
+    if (NumElements == 1)
+      setValue(Index, Value, 0);
+    else
+      setValue(Index, Value, 0.f);
+  }
+
+  DataT getValue(int Index) const {
+    return (NumElements == 1) ? getValue(Index, 0) : getValue(Index, 0.f);
+  }
+
+  // fields
+
+  // Alignment is the same as size, to a maximum size of 64.
+  // detail::vector_alignment will return that value.
+  alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
+
+  // friends
+  template <typename T1, typename T2, typename T3, template <typename> class T4,
+            int... T5>
+  friend class detail::SwizzleOp;
+  template <typename T1, int T2> friend class vec;
+};
+
+#ifdef __cpp_deduction_guides
+// all compilers supporting deduction guides also support fold expressions
+template <class T, class... U,
+          class = std::enable_if_t<(std::is_same_v<T, U> && ...)>>
+vec(T, U...) -> vec<T, sizeof...(U) + 1>;
+#endif
+
+namespace detail {
+
+// SwizzleOP represents expression templates that operate on vec.
+// Actual computation performed on conversion or assignment operators.
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp {
+  using DataT = typename VecT::element_type;
+  // Certain operators return a vector with a different element type. Also, the
+  // left and right operand types may differ. CommonDataT selects a result type
+  // based on these types to ensure that the result value can be represented.
+  //
+  // Example 1:
+  //   sycl::vec<unsigned char, 4> vec{...};
+  //   auto result = 300u + vec.x();
+  //
+  // CommonDataT is std::common_type_t<OperationLeftT, OperationRightT> since
+  // it's larger than unsigned char.
+  //
+  // Example 2:
+  //   sycl::vec<bool, 1> vec{...};
+  //   auto result = vec.template swizzle<sycl::elem::s0>() && vec;
+  //
+  // CommonDataT is DataT since operator&& returns a vector with element type
+  // int8_t, which is larger than bool.
+  //
+  // Example 3:
+  //   sycl::vec<std::byte, 4> vec{...}; auto swlo = vec.lo();
+  //   auto result = swlo == swlo;
+  //
+  // CommonDataT is DataT since operator== returns a vector with element type
+  // int8_t, which is the same size as std::byte. std::common_type_t<DataT, ...>
+  // can't be used here since there's no type that int8_t and std::byte can both
+  // be implicitly converted to.
+  using OpLeftDataT = typename OperationLeftT::DataT;
+  using OpRightDataT = typename OperationRightT::DataT;
+  using CommonDataT = std::conditional_t<
+      sizeof(DataT) >= sizeof(std::common_type_t<OpLeftDataT, OpRightDataT>),
+      DataT, std::common_type_t<OpLeftDataT, OpRightDataT>>;
+  static constexpr int getNumElements() { return sizeof...(Indexes); }
+
+  using rel_t = detail::rel_t<DataT>;
+  using vec_t = vec<DataT, sizeof...(Indexes)>;
+  using vec_rel_t = vec<rel_t, sizeof...(Indexes)>;
+
+  template <typename OperationRightT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewLHOp = SwizzleOp<VecT,
+                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                      OperationCurrentT, Indexes...>,
+                            OperationRightT_, OperationCurrentT_, Idx_...>;
+
+  template <typename OperationRightT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewRelOp = SwizzleOp<vec<rel_t, VecT::getNumElements()>,
+                             SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                       OperationCurrentT, Indexes...>,
+                             OperationRightT_, OperationCurrentT_, Idx_...>;
+
+  template <typename OperationLeftT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewRHOp = SwizzleOp<VecT, OperationLeftT_,
+                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                      OperationCurrentT, Indexes...>,
+                            OperationCurrentT_, Idx_...>;
+
+  template <int IdxNum, typename T = void>
+  using EnableIfOneIndex = typename std::enable_if_t<
+      1 == IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+
+  template <int IdxNum, typename T = void>
+  using EnableIfMultipleIndexes = typename std::enable_if_t<
+      1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+
+  template <typename T>
+  using EnableIfScalarType = typename std::enable_if_t<
+      std::is_convertible_v<DataT, T> &&
+      (std::is_fundamental_v<vec_data_t<T>> ||
+       detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+
+  template <typename T>
+  using EnableIfNoScalarType = typename std::enable_if_t<
+      !std::is_convertible_v<DataT, T> ||
+      !(std::is_fundamental_v<vec_data_t<T>> ||
+        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+
+  template <int... Indices>
+  using Swizzle =
+      SwizzleOp<VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
+
+  template <int... Indices>
+  using ConstSwizzle =
+      SwizzleOp<const VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
+
+public:
+  using element_type = DataT;
+  using value_type = DataT;
+
+#ifdef __SYCL_DEVICE_ONLY__
+  using vector_t = typename vec_t::vector_t;
+#endif // __SYCL_DEVICE_ONLY__
+
+  const DataT &operator[](int i) const {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    return (*m_Vector)[Idxs[i]];
+  }
+
+  template <typename _T = VecT>
+  std::enable_if_t<!std::is_const_v<_T>, DataT> &operator[](int i) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    return (*m_Vector)[Idxs[i]];
+  }
+
+  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
+  size_t get_count() const { return size(); }
+  static constexpr size_t size() noexcept { return getNumElements(); }
+
+  template <int Num = getNumElements()>
+  __SYCL2020_DEPRECATED(
+      "get_size() is deprecated, please use byte_size() instead")
+  size_t get_size() const {
+    return byte_size<Num>();
+  }
+
+  template <int Num = getNumElements()> size_t byte_size() const noexcept {
+    return sizeof(DataT) * (Num == 3 ? 4 : Num);
+  }
+
+  template <typename T, int IdxNum = getNumElements(),
+            typename = EnableIfOneIndex<IdxNum>,
+            typename = EnableIfScalarType<T>>
+  operator T() const {
+    return getValue(0);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>
+  operator*(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::plus, Indexes...>
+  operator+(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::plus, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::divides, Indexes...>
+  operator/(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::divides, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  // TODO: Check that Rhs arg is suitable.
+#ifdef __SYCL_OPASSIGN
+#error "Undefine __SYCL_OPASSIGN macro."
+#endif
+#define __SYCL_OPASSIGN(OPASSIGN, OP)                                          \
+  SwizzleOp &operator OPASSIGN(const DataT & Rhs) {                            \
+    operatorHelper<OP>(vec_t(Rhs));                                            \
+    return *this;                                                              \
+  }                                                                            \
+  template <typename RhsOperation>                                             \
+  SwizzleOp &operator OPASSIGN(const RhsOperation & Rhs) {                     \
+    operatorHelper<OP>(Rhs);                                                   \
+    return *this;                                                              \
+  }
+
+  __SYCL_OPASSIGN(+=, std::plus)
+  __SYCL_OPASSIGN(-=, std::minus)
+  __SYCL_OPASSIGN(*=, std::multiplies)
+  __SYCL_OPASSIGN(/=, std::divides)
+  __SYCL_OPASSIGN(%=, std::modulus)
+  __SYCL_OPASSIGN(&=, std::bit_and)
+  __SYCL_OPASSIGN(|=, std::bit_or)
+  __SYCL_OPASSIGN(^=, std::bit_xor)
+  __SYCL_OPASSIGN(>>=, RShift)
+  __SYCL_OPASSIGN(<<=, LShift)
+#undef __SYCL_OPASSIGN
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  SwizzleOp &operator UOP() {                                                  \
+    *this OPASSIGN static_cast<DataT>(1);                                      \
+    return *this;                                                              \
+  }                                                                            \
+  vec_t operator UOP(int) {                                                    \
+    vec_t Ret = *this;                                                         \
+    *this OPASSIGN static_cast<DataT>(1);                                      \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  template <typename T = DataT>
+  friend typename std::enable_if_t<
+      std::is_same_v<T, DataT> && std::is_integral_v<vec_data_t<T>>, vec_t>
+  operator~(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return ~Tmp;
+  }
+
+  friend vec_rel_t operator!(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return !Tmp;
+  }
+
+  friend vec_t operator+(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return +Tmp;
+  }
+
+  friend vec_t operator-(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return -Tmp;
+  }
+
+// scalar BINOP vec<>
+// scalar BINOP SwizzleOp
+// vec<> BINOP SwizzleOp
+#ifdef __SYCL_BINOP
+#error "Undefine __SYCL_BINOP macro"
+#endif
+#define __SYCL_BINOP(BINOP)                                                    \
+  friend vec_t operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {        \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs BINOP Tmp;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {        \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp BINOP Rhs;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {        \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs BINOP Tmp;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {        \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp BINOP Rhs;                                                      \
+  }
+
+  __SYCL_BINOP(+)
+  __SYCL_BINOP(-)
+  __SYCL_BINOP(*)
+  __SYCL_BINOP(/)
+  __SYCL_BINOP(%)
+  __SYCL_BINOP(&)
+  __SYCL_BINOP(|)
+  __SYCL_BINOP(^)
+  __SYCL_BINOP(>>)
+  __SYCL_BINOP(<<)
+#undef __SYCL_BINOP
+
+// scalar RELLOGOP vec<>
+// scalar RELLOGOP SwizzleOp
+// vec<> RELLOGOP SwizzleOp
+#ifdef __SYCL_RELLOGOP
+#error "Undefine __SYCL_RELLOGOP macro"
+#endif
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec_rel_t operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs RELLOGOP Tmp;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp RELLOGOP Rhs;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs RELLOGOP Tmp;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp RELLOGOP Rhs;                                                   \
+  }
+
+  __SYCL_RELLOGOP(==)
+  __SYCL_RELLOGOP(!=)
+  __SYCL_RELLOGOP(>)
+  __SYCL_RELLOGOP(<)
+  __SYCL_RELLOGOP(>=)
+  __SYCL_RELLOGOP(<=)
+  // TODO: limit to integral types.
+  __SYCL_RELLOGOP(&&)
+  __SYCL_RELLOGOP(||)
+#undef __SYCL_RELLOGOP
+
+  template <int IdxNum = getNumElements(),
+            typename = EnableIfMultipleIndexes<IdxNum>>
+  SwizzleOp &operator=(const vec<DataT, IdxNum> &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
+  SwizzleOp &operator=(const DataT &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    m_Vector->setValue(Idxs[0], Rhs);
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(),
+            EnableIfMultipleIndexes<IdxNum, bool> = true>
+  SwizzleOp &operator=(const DataT &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    for (auto Idx : Idxs) {
+      m_Vector->setValue(Idx, Rhs);
+    }
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
+  SwizzleOp &operator=(DataT &&Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    m_Vector->setValue(Idxs[0], Rhs);
+    return *this;
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>
+  operator*(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::multiplies, Indexes...>
+  operator*(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::multiplies, Indexes...>(m_Vector, *this,
+                                                              Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::plus, Indexes...> operator+(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::plus, Indexes...>(m_Vector, *this,
+                                                          GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::plus, Indexes...>
+  operator+(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::plus, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::minus, Indexes...>
+  operator-(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::minus, Indexes...>(m_Vector, *this,
+                                                           GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::minus, Indexes...>
+  operator-(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::minus, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::divides, Indexes...>
+  operator/(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::divides, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::divides, Indexes...>
+  operator/(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::divides, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>
+  operator%(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::modulus, Indexes...>
+  operator%(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::modulus, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>
+  operator&(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_and, Indexes...>
+  operator&(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_and, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>
+  operator|(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_or, Indexes...>
+  operator|(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_or, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>
+  operator^(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_xor, Indexes...>
+  operator^(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_xor, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, RShift, Indexes...> operator>>(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, RShift, Indexes...>(m_Vector, *this,
+                                                       GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, RShift, Indexes...>
+  operator>>(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, RShift, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, LShift, Indexes...> operator<<(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, LShift, Indexes...>(m_Vector, *this,
+                                                       GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, LShift, Indexes...>
+  operator<<(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, LShift, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  SwizzleOp &operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  SwizzleOp &operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, EqualTo, Indexes...> operator==(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, EqualTo, Indexes...>(NULL, *this,
+                                                         GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, EqualTo, Indexes...>
+  operator==(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, EqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>
+  operator!=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, NotEqualTo, Indexes...>
+  operator!=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, NotEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>
+  operator>=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>
+  operator>=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>
+  operator<=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LessEqualTo, Indexes...>
+  operator<=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LessEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>
+  operator>(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, GreaterThan, Indexes...>
+  operator>(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, GreaterThan, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LessThan, Indexes...> operator<(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LessThan, Indexes...>(NULL, *this,
+                                                          GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LessThan, Indexes...>
+  operator<(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LessThan, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>
+  operator&&(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LogicalAnd, Indexes...>
+  operator&&(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LogicalAnd, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>
+  operator||(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>(NULL, *this,
+                                                           GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LogicalOr, Indexes...>
+  operator||(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LogicalOr, Indexes...>(NULL, *this, Rhs);
+  }
+
+  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
+private:
+  // Indexer used in the swizzles.def.
+  // Currently it is defined as a template struct. Replacing it with a constexpr
+  // function would activate a bug in MSVC that is fixed only in v19.20.
+  // Until then MSVC does not recognize such constexpr functions as const and
+  // thus does not let using them in template parameters inside swizzle.def.
+  template <int Index> struct Indexer {
+    static constexpr int IDXs[sizeof...(Indexes)] = {Indexes...};
+    static constexpr int value = IDXs[Index >= getNumElements() ? 0 : Index];
+  };
+
+public:
+#ifdef __SYCL_ACCESS_RETURN
+#error "Undefine __SYCL_ACCESS_RETURN macro"
+#endif
+#define __SYCL_ACCESS_RETURN m_Vector
+#include "swizzles.def"
+#undef __SYCL_ACCESS_RETURN
+  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
+
+  // Leave store() interface to automatic conversion to vec<>.
+  // Load to vec_t and then assign to swizzle.
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t offset, multi_ptr<DataT, Space, DecorateAddress> ptr) {
+    vec_t Tmp;
+    Tmp.template load(offset, ptr);
+    *this = Tmp;
+  }
+
+  template <typename convertT, rounding_mode roundingMode>
+  vec<convertT, sizeof...(Indexes)> convert() const {
+    // First materialize the swizzle to vec_t and then apply convert() to it.
+    vec_t Tmp = *this;
+    return Tmp.template convert<convertT, roundingMode>();
+  }
+
+  template <typename asT> asT as() const {
+    // First materialize the swizzle to vec_t and then apply as() to it.
+    vec_t Tmp = *this;
+    static_assert((sizeof(Tmp) == sizeof(asT)),
+                  "The new SYCL vec type must have the same storage size in "
+                  "bytes as this SYCL swizzled vec");
+    static_assert(
+        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
+            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
+        "asT must be SYCL vec of a different element type and "
+        "number of elements specified by asT");
+    return Tmp.template as<asT>();
+  }
+
+private:
+  SwizzleOp(const SwizzleOp &Rhs)
+      : m_Vector(Rhs.m_Vector), m_LeftOperation(Rhs.m_LeftOperation),
+        m_RightOperation(Rhs.m_RightOperation) {}
+
+  SwizzleOp(VecT *Vector, OperationLeftT LeftOperation,
+            OperationRightT RightOperation)
+      : m_Vector(Vector), m_LeftOperation(LeftOperation),
+        m_RightOperation(RightOperation) {}
+
+  SwizzleOp(VecT *Vector) : m_Vector(Vector) {}
+
+  SwizzleOp(SwizzleOp &&Rhs)
+      : m_Vector(Rhs.m_Vector), m_LeftOperation(std::move(Rhs.m_LeftOperation)),
+        m_RightOperation(std::move(Rhs.m_RightOperation)) {}
+
+  // Either performing CurrentOperation on results of left and right operands
+  // or reading values from actual vector. Perform implicit type conversion when
+  // the number of elements == 1
+
+  template <int IdxNum = getNumElements()>
+  CommonDataT getValue(EnableIfOneIndex<IdxNum, size_t> Index) const {
+    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
+      std::array<int, getNumElements()> Idxs{Indexes...};
+      return m_Vector->getValue(Idxs[Index]);
+    }
+    auto Op = OperationCurrentT<vec_data_t<CommonDataT>>();
+    return vec_data<CommonDataT>::get(
+        Op(vec_data<CommonDataT>::get(m_LeftOperation.getValue(Index)),
+           vec_data<CommonDataT>::get(m_RightOperation.getValue(Index))));
+  }
+
+  template <int IdxNum = getNumElements()>
+  DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
+    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
+      std::array<int, getNumElements()> Idxs{Indexes...};
+      return m_Vector->getValue(Idxs[Index]);
+    }
+    auto Op = OperationCurrentT<vec_data_t<DataT>>();
+    return vec_data<DataT>::get(
+        Op(vec_data<DataT>::get(m_LeftOperation.getValue(Index)),
+           vec_data<DataT>::get(m_RightOperation.getValue(Index))));
+  }
+
+  template <template <typename> class Operation, typename RhsOperation>
+  void operatorHelper(const RhsOperation &Rhs) {
+    Operation<vec_data_t<DataT>> Op;
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      DataT Res = vec_data<DataT>::get(
+          Op(vec_data<DataT>::get(m_Vector->getValue(Idxs[I])),
+             vec_data<DataT>::get(Rhs.getValue(I))));
+      m_Vector->setValue(Idxs[I], Res);
+    }
+  }
+
+  // fields
+  VecT *m_Vector;
+
+  OperationLeftT m_LeftOperation;
+  OperationRightT m_RightOperation;
+
+  // friends
+  template <typename T1, int T2> friend class sycl::vec;
+
+  template <typename T1, typename T2, typename T3, template <typename> class T4,
+            int... T5>
+  friend class SwizzleOp;
+};
+} // namespace detail
+
+namespace detail {
+
+// Vectors of size 1 are handled separately and therefore 1 is not included in
+// the check below.
+constexpr bool isValidVectorSize(int N) {
+  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
+}
+template <typename T, int N, typename V> struct VecStorage {
+  static_assert(
+      isValidVectorSize(N) || N == 1,
+      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
+      "or 16 are supported");
+  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
+};
+
+#ifdef __SYCL_DEVICE_ONLY__
+// device always has ext vector support, but for huge vectors
+// we switch to std::array, so that we can use a smaller alignment (64)
+// this is to support MSVC, which has a max of 64 for direct params.
+template <typename T, int N> struct VecStorageImpl {
+  static constexpr size_t Num = (N == 3) ? 4 : N;
+  static constexpr size_t Sz = Num * sizeof(T);
+  using DataType =
+      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
+                                std::array<T, Num>>::type;
+  using VectorDataType = T __attribute__((ext_vector_type(N)));
+};
+#else // __SYCL_DEVICE_ONLY__
+template <typename T, int N> struct VecStorageImpl {
+  using DataType = std::array<T, (N == 3) ? 4 : N>;
+};
+#endif // __SYCL_DEVICE_ONLY__
+
+// Single element bool
+template <> struct VecStorage<bool, 1, void> {
+  using DataType = bool;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = bool;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Multiple element bool
+template <int N>
+struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
+  using DataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+// Single element byte. Multiple elements will propagate through a later
+// specialization.
+template <> struct VecStorage<std::byte, 1, void> {
+  using DataType = std::int8_t;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = std::int8_t;
+#endif // __SYCL_DEVICE_ONLY__
+};
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+
+// Single element signed integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element unsigned integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element floating-point (except half/bfloat16)
+template <typename T>
+struct VecStorage<
+    T, 1,
+    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+// Multiple elements signed/unsigned integers and floating-point (except
+// half/bfloat16)
+template <typename T, int N>
+struct VecStorage<
+    T, N,
+    typename std::enable_if_t<isValidVectorSize(N) &&
+                              (is_sgeninteger_v<T> ||
+                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
+  using DataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element half
+template <> struct VecStorage<half, 1, void> {
+  using DataType = sycl::detail::half_impl::StorageT;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = sycl::detail::half_impl::StorageT;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Multiple elements half
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
+  };
+#else // defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+  };
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+__SYCL_DEFINE_HALF_VECSTORAGE(2)
+__SYCL_DEFINE_HALF_VECSTORAGE(3)
+__SYCL_DEFINE_HALF_VECSTORAGE(4)
+__SYCL_DEFINE_HALF_VECSTORAGE(8)
+__SYCL_DEFINE_HALF_VECSTORAGE(16)
+#undef __SYCL_DEFINE_HALF_VECSTORAGE
+
+// Single element bfloat16
+template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
+  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  // using VectorDataType = sycl::ext::oneapi::bfloat16;
+  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+};
+// Multiple elements bfloat16
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
+    using VectorDataType =                                                     \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
+  };
+__SYCL_DEFINE_BF16_VECSTORAGE(2)
+__SYCL_DEFINE_BF16_VECSTORAGE(3)
+__SYCL_DEFINE_BF16_VECSTORAGE(4)
+__SYCL_DEFINE_BF16_VECSTORAGE(8)
+__SYCL_DEFINE_BF16_VECSTORAGE(16)
+#undef __SYCL_DEFINE_BF16_VECSTORAGE
+} // namespace detail
+
+/// This macro must be defined to 1 when SYCL implementation allows user
+/// applications to explicitly declare certain class types as device copyable
+/// by adding specializations of is_device_copyable type trait class.
+#define SYCL_DEVICE_COPYABLE 1
+
+/// is_device_copyable is a user specializable class template to indicate
+/// that a type T is device copyable, which means that SYCL implementation
+/// may copy objects of the type T between host and device or between two
+/// devices.
+/// Specializing is_device_copyable such a way that
+/// is_device_copyable_v<T> == true on a T that does not satisfy all
+/// the requirements of a device copyable type is undefined behavior.
+template <typename T> struct is_device_copyable;
+
+namespace detail {
+template <typename T, typename = void>
+struct is_device_copyable_impl : std::is_trivially_copyable<T> {};
+
+template <typename T>
+struct is_device_copyable_impl<
+    T, std::enable_if_t<!std::is_same_v<T, std::remove_cv_t<T>>>>
+    // Cannot express this "recursion" (to take user's partial non-cv
+    // specializations into account) without this helper struct.
+    : is_device_copyable<std::remove_cv_t<T>> {};
+} // namespace detail
+
+template <typename T>
+struct is_device_copyable : detail::is_device_copyable_impl<T> {};
+
+// std::array<T, 0> is implicitly device copyable type.
+template <typename T>
+struct is_device_copyable<std::array<T, 0>> : std::true_type {};
+
+// std::array<T, N> is implicitly device copyable type if T is device copyable.
+template <typename T, std::size_t N>
+struct is_device_copyable<std::array<T, N>> : is_device_copyable<T> {};
+
+// std::optional<T> is implicitly device copyable type if T is device copyable.
+template <typename T>
+struct is_device_copyable<std::optional<T>> : is_device_copyable<T> {};
+
+// std::pair<T1, T2> is implicitly device copyable type if T1 and T2 are device
+// copyable.
+template <typename T1, typename T2>
+struct is_device_copyable<std::pair<T1, T2>>
+    : std::bool_constant<is_device_copyable<T1>::value &&
+                         is_device_copyable<T2>::value> {};
+
+// std::tuple<Ts...> is implicitly device copyable type if each type T of Ts...
+// is device copyable.
+template <typename... Ts>
+struct is_device_copyable<std::tuple<Ts...>>
+    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
+
+// std::variant<Ts...> is implicitly device copyable type if each type T of
+// Ts... is device copyable.
+template <typename... Ts>
+struct is_device_copyable<std::variant<Ts...>>
+    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
+
+// marray is device copyable if element type is device copyable.
+template <typename T, std::size_t N>
+struct is_device_copyable<sycl::marray<T, N>> : is_device_copyable<T> {};
+
+// array is device copyable if element type is device copyable.
+template <typename T, std::size_t N>
+struct is_device_copyable<T[N]> : is_device_copyable<T> {};
+
+template <typename T>
+inline constexpr bool is_device_copyable_v = is_device_copyable<T>::value;
+
+namespace detail {
+template <typename T, typename = void>
+struct IsDeprecatedDeviceCopyable : std::false_type {};
+
+// TODO: using C++ attribute [[deprecated]] or the macro __SYCL2020_DEPRECATED
+// does not produce expected warning message for the type 'T'.
+template <typename T>
+struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
+    IsDeprecatedDeviceCopyable<
+        T, std::enable_if_t<std::is_trivially_copy_constructible_v<T> &&
+                            std::is_trivially_destructible_v<T> &&
+                            !is_device_copyable_v<T>>> : std::true_type {};
+
+template <typename T, int N>
+struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
+    IsDeprecatedDeviceCopyable<T[N]> : IsDeprecatedDeviceCopyable<T> {};
+
+#ifdef __SYCL_DEVICE_ONLY__
+// Checks that the fields of the type T with indices 0 to (NumFieldsToCheck -
+// 1) are device copyable.
+template <typename T, unsigned NumFieldsToCheck>
+struct CheckFieldsAreDeviceCopyable
+    : CheckFieldsAreDeviceCopyable<T, NumFieldsToCheck - 1> {
+  using FieldT = decltype(__builtin_field_type(T, NumFieldsToCheck - 1));
+  static_assert(is_device_copyable_v<FieldT> ||
+                    detail::IsDeprecatedDeviceCopyable<FieldT>::value,
+                "The specified type is not device copyable");
+};
+
+template <typename T> struct CheckFieldsAreDeviceCopyable<T, 0> {};
+
+// Checks that the base classes of the type T with indices 0 to
+// (NumFieldsToCheck - 1) are device copyable.
+template <typename T, unsigned NumBasesToCheck>
+struct CheckBasesAreDeviceCopyable
+    : CheckBasesAreDeviceCopyable<T, NumBasesToCheck - 1> {
+  using BaseT = decltype(__builtin_base_type(T, NumBasesToCheck - 1));
+  static_assert(is_device_copyable_v<BaseT> ||
+                    detail::IsDeprecatedDeviceCopyable<BaseT>::value,
+                "The specified type is not device copyable");
+};
+
+template <typename T> struct CheckBasesAreDeviceCopyable<T, 0> {};
+
+// All the captures of a lambda or functor of type FuncT passed to a kernel
+// must be is_device_copyable, which extends to bases and fields of FuncT.
+// Fields are captures of lambda/functors and bases are possible base classes
+// of functors also allowed by SYCL.
+// The SYCL-2020 implementation must check each of the fields & bases of the
+// type FuncT, only one level deep, which is enough to see if they are all
+// device copyable by using the result of is_device_copyable returned for them.
+// At this moment though the check also allowes using types for which
+// (is_trivially_copy_constructible && is_trivially_destructible) returns true
+// and (is_device_copyable) returns false. That is the deprecated behavior and
+// is currently/temporarily supported only to not break older SYCL programs.
+template <typename FuncT>
+struct CheckDeviceCopyable
+    : CheckFieldsAreDeviceCopyable<FuncT, __builtin_num_fields(FuncT)>,
+      CheckBasesAreDeviceCopyable<FuncT, __builtin_num_bases(FuncT)> {};
+
+// Below are two specializations for CheckDeviceCopyable when a kernel lambda
+// is wrapped after range rounding optimization.
+template <typename TransformedArgType, int Dims, typename KernelType>
+struct CheckDeviceCopyable<
+    RoundedRangeKernel<TransformedArgType, Dims, KernelType>>
+    : CheckDeviceCopyable<KernelType> {};
+
+template <typename TransformedArgType, int Dims, typename KernelType>
+struct CheckDeviceCopyable<
+    RoundedRangeKernelWithKH<TransformedArgType, Dims, KernelType>>
+    : CheckDeviceCopyable<KernelType> {};
+
+#endif // __SYCL_DEVICE_ONLY__
+} // namespace detail
+
+} // namespace _V1
+} // namespace sycl

From b22b47b08328551428cbd026e1783181a1bc3b3a Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 24 Apr 2024 07:45:39 -0700
Subject: [PATCH 25/79] Refactor sycl::vec into a header of its own.

---
 sycl/include/sycl/types.hpp  | 2171 +---------------------------------
 sycl/include/sycl/vector.hpp |  596 ++++------
 2 files changed, 221 insertions(+), 2546 deletions(-)

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index cbc125f213a58..f13910d04c33d 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -8,28 +8,6 @@
 
 #pragma once
 
-// Check if Clang's ext_vector_type attribute is available. Host compiler
-// may not be Clang, and Clang may not be built with the extension.
-#ifdef __clang__
-#ifndef __has_extension
-#define __has_extension(x) 0
-#endif
-#ifdef __HAS_EXT_VECTOR_TYPE__
-#error "Undefine __HAS_EXT_VECTOR_TYPE__ macro"
-#endif
-#if __has_extension(attribute_ext_vector_type)
-#define __HAS_EXT_VECTOR_TYPE__
-#endif
-#endif // __clang__
-
-#if !defined(__HAS_EXT_VECTOR_TYPE__) && defined(__SYCL_DEVICE_ONLY__)
-#error "SYCL device compiler is built without ext_vector_type support"
-#endif
-
-#if defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_USE_EXT_VECTOR_TYPE__
-#endif
-
 #include <sycl/access/access.hpp>              // for decorated, address_space
 #include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
 #include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
@@ -37,2166 +15,20 @@
 #include <sycl/detail/generic_type_lists.hpp>  // for vector_basic_list
 #include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
 #include <sycl/detail/is_device_copyable.hpp>
-#include <sycl/detail/memcpy.hpp>              // for memcpy
 #include <sycl/detail/type_list.hpp>           // for is_contained
 #include <sycl/detail/type_traits.hpp>         // for is_floating_point
-#include <sycl/detail/vector_convert.hpp>      // for convertImpl
-#include <sycl/detail/vector_traits.hpp>       // for vector_alignment
 #include <sycl/exception.hpp>                  // for make_error_code, errc
 #include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
 #include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
 #include <sycl/multi_ptr.hpp>                  // for multi_ptr
+#include <sycl/vector.hpp>                     // for sycl::vec and swizzles
 
 #include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
 
-#include <array>       // for array
-#include <assert.h>    // for assert
-#include <cstddef>     // for size_t, NULL, byte
-#include <cstdint>     // for uint8_t, int16_t, int...
-#include <functional>  // for divides, multiplies
-#include <iterator>    // for pair
-#include <optional>    // for optional
-#include <ostream>     // for operator<<, basic_ost...
-#include <tuple>       // for tuple
-#include <type_traits> // for enable_if_t, is_same
-#include <utility>     // for index_sequence, make_...
-#include <variant>     // for tuple, variant
-
-// 4.10.1: Scalar data types
-// 4.10.2: SYCL vector types
-
 namespace sycl {
 inline namespace _V1 {
-
-struct elem {
-  static constexpr int x = 0;
-  static constexpr int y = 1;
-  static constexpr int z = 2;
-  static constexpr int w = 3;
-  static constexpr int r = 0;
-  static constexpr int g = 1;
-  static constexpr int b = 2;
-  static constexpr int a = 3;
-  static constexpr int s0 = 0;
-  static constexpr int s1 = 1;
-  static constexpr int s2 = 2;
-  static constexpr int s3 = 3;
-  static constexpr int s4 = 4;
-  static constexpr int s5 = 5;
-  static constexpr int s6 = 6;
-  static constexpr int s7 = 7;
-  static constexpr int s8 = 8;
-  static constexpr int s9 = 9;
-  static constexpr int sA = 10;
-  static constexpr int sB = 11;
-  static constexpr int sC = 12;
-  static constexpr int sD = 13;
-  static constexpr int sE = 14;
-  static constexpr int sF = 15;
-};
-
 namespace detail {
-// select_apply_cl_t selects from T8/T16/T32/T64 basing on
-// sizeof(_IN).  expected to handle scalar types in _IN.
-template <typename _IN, typename T8, typename T16, typename T32, typename T64>
-using select_apply_cl_t = std::conditional_t<
-    sizeof(_IN) == 1, T8,
-    std::conditional_t<sizeof(_IN) == 2, T16,
-                       std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
-
-template <typename T> struct vec_helper {
-  using RetType = T;
-  static constexpr RetType get(T value) { return value; }
-  static constexpr RetType set(T value) { return value; }
-};
-template <> struct vec_helper<bool> {
-  using RetType = select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                    std::int32_t, std::int64_t>;
-  static constexpr RetType get(bool value) { return value; }
-  static constexpr RetType set(bool value) { return value; }
-};
-
-template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
-  using RetType = sycl::ext::oneapi::bfloat16;
-  using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
-  static constexpr RetType get(BFloat16StorageT value) {
-#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
-    return sycl::bit_cast<RetType>(value);
-#else
-    // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
-    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
-    // but neither available yet.
-    union {
-      sycl::ext::oneapi::bfloat16 bf16;
-      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
-    } result = {};
-    result.storage = value;
-    return result.bf16;
-#endif
-  }
-
-  static constexpr RetType get(RetType value) { return value; }
-
-  static constexpr BFloat16StorageT set(RetType value) {
-#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
-    return sycl::bit_cast<BFloat16StorageT>(value);
-#else
-    union {
-      sycl::ext::oneapi::bfloat16 bf16;
-      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
-    } result = {};
-    result.bf16 = value;
-    return result.storage;
-#endif
-  }
-};
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-template <> struct vec_helper<std::byte> {
-  using RetType = std::uint8_t;
-  static constexpr RetType get(std::byte value) { return (RetType)value; }
-  static constexpr RetType set(std::byte value) { return (RetType)value; }
-  static constexpr std::byte get(std::uint8_t value) {
-    return (std::byte)value;
-  }
-  static constexpr std::byte set(std::uint8_t value) {
-    return (std::byte)value;
-  }
-};
-#endif
-
-template <typename VecT, typename OperationLeftT, typename OperationRightT,
-          template <typename> class OperationCurrentT, int... Indexes>
-class SwizzleOp;
-
-template <typename T, int N, typename V = void> struct VecStorage;
-
-// Element type for relational operator return value.
-template <typename DataT>
-using rel_t = typename std::conditional_t<
-    sizeof(DataT) == sizeof(opencl::cl_char), opencl::cl_char,
-    typename std::conditional_t<
-        sizeof(DataT) == sizeof(opencl::cl_short), opencl::cl_short,
-        typename std::conditional_t<
-            sizeof(DataT) == sizeof(opencl::cl_int), opencl::cl_int,
-            typename std::conditional_t<sizeof(DataT) ==
-                                            sizeof(opencl::cl_long),
-                                        opencl::cl_long, bool>>>>;
-
-// Special type indicating that SwizzleOp should just read value from vector -
-// not trying to perform any operations. Should not be called.
-template <typename T> class GetOp {
-public:
-  using DataT = T;
-  DataT getValue(size_t) const { return (DataT)0; }
-  DataT operator()(DataT, DataT) { return (DataT)0; }
-};
-
-// Special type for working SwizzleOp with scalars, stores a scalar and gives
-// the scalar at any index. Provides interface is compatible with SwizzleOp
-// operations
-template <typename T> class GetScalarOp {
-public:
-  using DataT = T;
-  GetScalarOp(DataT Data) : m_Data(Data) {}
-  DataT getValue(size_t) const { return m_Data; }
-
-private:
-  DataT m_Data;
-};
-
-template <typename T> struct EqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs == Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct NotEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs != Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct GreaterEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs >= Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LessEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs <= Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct GreaterThan {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs > Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LessThan {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs < Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LogicalAnd {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs && Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LogicalOr {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs || Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct RShift {
-  constexpr T operator()(const T &Lhs, const T &Rhs) const {
-    return Lhs >> Rhs;
-  }
-};
-
-template <typename T> struct LShift {
-  constexpr T operator()(const T &Lhs, const T &Rhs) const {
-    return Lhs << Rhs;
-  }
-};
-
-// Forward declarations
-template <typename TransformedArgType, int Dims, typename KernelType>
-class RoundedRangeKernel;
-template <typename TransformedArgType, int Dims, typename KernelType>
-class RoundedRangeKernelWithKH;
-
-} // namespace detail
-
-template <typename T> using vec_data = detail::vec_helper<T>;
-
-template <typename T>
-using vec_data_t = typename detail::vec_helper<T>::RetType;
-
-/// Provides a cross-patform vector class template that works efficiently on
-/// SYCL devices as well as in host C++ code.
-///
-/// \ingroup sycl_api
-template <typename Type, int NumElements> class vec {
-  using DataT = Type;
-
-  // This represent type of underlying value. There should be only one field
-  // in the class, so vec<float, 16> should be equal to float16 in memory.
-  using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
-
-  static constexpr bool IsHostHalf =
-      std::is_same_v<DataT, sycl::detail::half_impl::half> &&
-      std::is_same_v<sycl::detail::half_impl::StorageT,
-                     sycl::detail::host_half_impl::half>;
-
-  static constexpr bool IsBfloat16 =
-      std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
-
-  static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
-  static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
-  static constexpr bool IsSizeGreaterThanMaxAlign =
-      (Sz > detail::MaxVecAlignment);
-
-  // TODO: There is no support for vector half type on host yet.
-  // Also, when Sz is greater than alignment, we use std::array instead of
-  // vector extension. This is for MSVC compatibility, which has a max alignment
-  // of 64 for direct params. If we drop MSVC, we can have alignment the same as
-  // size and use vector extensions for all sizes.
-  static constexpr bool IsUsingArrayOnDevice =
-      (IsHostHalf || IsBfloat16 || IsSizeGreaterThanMaxAlign);
-
-#if defined(__SYCL_DEVICE_ONLY__)
-  static constexpr bool NativeVec = NumElements > 1 && !IsUsingArrayOnDevice;
-  static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
-#else
-  static constexpr bool NativeVec = false;
-  static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
-#endif
-
-  static constexpr int getNumElements() { return NumElements; }
-
-  // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
-  template <int Counter, int MaxValue, class...>
-  struct SizeChecker : std::conditional_t<Counter == MaxValue, std::true_type,
-                                          std::false_type> {};
-
-  template <int Counter, int MaxValue, typename DataT_, class... tail>
-  struct SizeChecker<Counter, MaxValue, DataT_, tail...>
-      : std::conditional_t<Counter + 1 <= MaxValue,
-                           SizeChecker<Counter + 1, MaxValue, tail...>,
-                           std::false_type> {};
-
-  // Utility trait for creating an std::array from an vector argument.
-  template <typename DataT_, typename T, std::size_t... Is>
-  static constexpr std::array<DataT_, sizeof...(Is)>
-  VecToArray(const vec<T, sizeof...(Is)> &V, std::index_sequence<Is...>) {
-    return {static_cast<DataT_>(V.getValue(Is))...};
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5, std::size_t... Is>
-  static constexpr std::array<DataT_, sizeof...(Is)>
-  VecToArray(const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &V,
-             std::index_sequence<Is...>) {
-    return {static_cast<DataT_>(V.getValue(Is))...};
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5, std::size_t... Is>
-  static constexpr std::array<DataT_, sizeof...(Is)>
-  VecToArray(const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &V,
-             std::index_sequence<Is...>) {
-    return {static_cast<DataT_>(V.getValue(Is))...};
-  }
-  template <typename DataT_, typename T, int N>
-  static constexpr std::array<DataT_, N>
-  FlattenVecArgHelper(const vec<T, N> &A) {
-    return VecToArray<DataT_>(A, std::make_index_sequence<N>());
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5>
-  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
-      const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &A) {
-    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5>
-  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
-      const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &A) {
-    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
-  }
-  template <typename DataT_, typename T>
-  static constexpr auto FlattenVecArgHelper(const T &A) {
-    return std::array<DataT_, 1>{vec_data<DataT_>::get(static_cast<DataT_>(A))};
-  }
-  template <typename DataT_, typename T> struct FlattenVecArg {
-    constexpr auto operator()(const T &A) const {
-      return FlattenVecArgHelper<DataT_>(A);
-    }
-  };
-
-  // Alias for shortening the vec arguments to array converter.
-  template <typename DataT_, typename... ArgTN>
-  using VecArgArrayCreator =
-      detail::ArrayCreator<DataT_, FlattenVecArg, ArgTN...>;
-
-#define __SYCL_ALLOW_VECTOR_SIZES(num_elements)                                \
-  template <int Counter, int MaxValue, typename DataT_, class... tail>         \
-  struct SizeChecker<Counter, MaxValue, vec<DataT_, num_elements>, tail...>    \
-      : std::conditional_t<                                                    \
-            Counter + (num_elements) <= MaxValue,                              \
-            SizeChecker<Counter + (num_elements), MaxValue, tail...>,          \
-            std::false_type> {};                                               \
-  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
-            typename T3, template <typename> class T4, int... T5,              \
-            class... tail>                                                     \
-  struct SizeChecker<                                                          \
-      Counter, MaxValue,                                                       \
-      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>,         \
-      tail...>                                                                 \
-      : std::conditional_t<                                                    \
-            Counter + sizeof...(T5) <= MaxValue,                               \
-            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
-            std::false_type> {};                                               \
-  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
-            typename T3, template <typename> class T4, int... T5,              \
-            class... tail>                                                     \
-  struct SizeChecker<                                                          \
-      Counter, MaxValue,                                                       \
-      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
-      tail...>                                                                 \
-      : std::conditional_t<                                                    \
-            Counter + sizeof...(T5) <= MaxValue,                               \
-            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
-            std::false_type> {};
-
-  __SYCL_ALLOW_VECTOR_SIZES(1)
-  __SYCL_ALLOW_VECTOR_SIZES(2)
-  __SYCL_ALLOW_VECTOR_SIZES(3)
-  __SYCL_ALLOW_VECTOR_SIZES(4)
-  __SYCL_ALLOW_VECTOR_SIZES(8)
-  __SYCL_ALLOW_VECTOR_SIZES(16)
-#undef __SYCL_ALLOW_VECTOR_SIZES
-
-  // TypeChecker is needed for vec(const argTN &... args) ctor to validate args.
-  template <typename T, typename DataT_>
-  struct TypeChecker : std::is_convertible<T, DataT_> {};
-#define __SYCL_ALLOW_VECTOR_TYPES(num_elements)                                \
-  template <typename DataT_>                                                   \
-  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {};   \
-  template <typename DataT_, typename T2, typename T3,                         \
-            template <typename> class T4, int... T5>                           \
-  struct TypeChecker<                                                          \
-      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
-      : std::true_type {};                                                     \
-  template <typename DataT_, typename T2, typename T3,                         \
-            template <typename> class T4, int... T5>                           \
-  struct TypeChecker<                                                          \
-      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
-      DataT_> : std::true_type {};
-
-  __SYCL_ALLOW_VECTOR_TYPES(1)
-  __SYCL_ALLOW_VECTOR_TYPES(2)
-  __SYCL_ALLOW_VECTOR_TYPES(3)
-  __SYCL_ALLOW_VECTOR_TYPES(4)
-  __SYCL_ALLOW_VECTOR_TYPES(8)
-  __SYCL_ALLOW_VECTOR_TYPES(16)
-#undef __SYCL_ALLOW_VECTOR_TYPES
-
-  template <int... Indexes>
-  using Swizzle =
-      detail::SwizzleOp<vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
-                        detail::GetOp, Indexes...>;
-
-  template <int... Indexes>
-  using ConstSwizzle =
-      detail::SwizzleOp<const vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
-                        detail::GetOp, Indexes...>;
-
-  // Shortcuts for args validation in vec(const argTN &... args) ctor.
-  template <typename... argTN>
-  using EnableIfSuitableTypes = typename std::enable_if_t<
-      std::conjunction_v<TypeChecker<argTN, DataT>...>>;
-
-  template <typename... argTN>
-  using EnableIfSuitableNumElements =
-      typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
-
-  template <size_t... Is>
-  constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
-                std::index_sequence<Is...>)
-      : m_Data{([&](vec_data_t<DataT> v) constexpr {
-          if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
-            return v.value;
-          else
-            return vec_data_t<DataT>(static_cast<DataT>(v));
-        })(Arr[Is])...} {}
-
-public:
-  using element_type = DataT;
-  using value_type = DataT;
-  using rel_t = detail::rel_t<DataT>;
-#ifdef __SYCL_DEVICE_ONLY__
-  using vector_t =
-      typename detail::VecStorage<DataT, NumElements>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-
-  vec() = default;
-
-  constexpr vec(const vec &Rhs) = default;
-  constexpr vec(vec &&Rhs) = default;
-
-  constexpr vec &operator=(const vec &Rhs) = default;
-
-  // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
-  template <typename Ty = DataT>
-  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
-                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
-                            vec &>
-  operator=(const vec<rel_t, NumElements> &Rhs) {
-    *this = Rhs.template as<vec>();
-    return *this;
-  }
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  template <typename T = void>
-  using EnableIfNotHostHalf = typename std::enable_if_t<!IsHostHalf, T>;
-
-  template <typename T = void>
-  using EnableIfHostHalf = typename std::enable_if_t<IsHostHalf, T>;
-
-  template <typename T = void>
-  using EnableIfUsingArrayOnDevice =
-      typename std::enable_if_t<IsUsingArrayOnDevice, T>;
-
-  template <typename T = void>
-  using EnableIfNotUsingArrayOnDevice =
-      typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  template <typename T = void>
-  using EnableIfUsingArray =
-      typename std::enable_if_t<IsUsingArrayOnDevice || IsUsingArrayOnHost, T>;
-
-  template <typename T = void>
-  using EnableIfNotUsingArray =
-      typename std::enable_if_t<!IsUsingArrayOnDevice && !IsUsingArrayOnHost,
-                                T>;
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-
-  template <typename Ty = DataT>
-  explicit constexpr vec(const EnableIfNotUsingArrayOnDevice<Ty> &arg)
-      : m_Data{DataType(vec_data<Ty>::get(arg))} {}
-
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) {
-    m_Data = (DataType)vec_data<Ty>::get(Rhs);
-    return *this;
-  }
-
-  template <typename Ty = DataT>
-  explicit constexpr vec(const EnableIfUsingArrayOnDevice<Ty> &arg)
-      : vec{detail::RepeatValue<NumElements>(
-                static_cast<vec_data_t<DataT>>(arg)),
-            std::make_index_sequence<NumElements>()} {}
-
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
-    for (int i = 0; i < NumElements; ++i) {
-      setValue(i, Rhs);
-    }
-    return *this;
-  }
-#else  // __SYCL_USE_EXT_VECTOR_TYPE__
-  explicit constexpr vec(const DataT &arg)
-      : vec{detail::RepeatValue<NumElements>(
-                static_cast<vec_data_t<DataT>>(arg)),
-            std::make_index_sequence<NumElements>()} {}
-
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const DataT &Rhs) {
-    for (int i = 0; i < NumElements; ++i) {
-      setValue(i, Rhs);
-    }
-    return *this;
-  }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  // Optimized naive constructors with NumElements of DataT values.
-  // We don't expect compilers to optimize vararg recursive functions well.
-
-  // Helper type to make specific constructors available only for specific
-  // number of elements.
-  template <int IdxNum, typename T = void>
-  using EnableIfMultipleElems = typename std::enable_if_t<
-      std::is_convertible_v<T, DataT> && NumElements == IdxNum, DataT>;
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<2, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<3, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<4, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const Ty Arg3)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<8, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const DataT Arg3, const DataT Arg4, const DataT Arg5,
-                const DataT Arg6, const DataT Arg7)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
-               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
-               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<16, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const DataT Arg3, const DataT Arg4, const DataT Arg5,
-                const DataT Arg6, const DataT Arg7, const DataT Arg8,
-                const DataT Arg9, const DataT ArgA, const DataT ArgB,
-                const DataT ArgC, const DataT ArgD, const DataT ArgE,
-                const DataT ArgF)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
-               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
-               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7),
-               vec_data<Ty>::get(Arg8), vec_data<Ty>::get(Arg9),
-               vec_data<Ty>::get(ArgA), vec_data<Ty>::get(ArgB),
-               vec_data<Ty>::get(ArgC), vec_data<Ty>::get(ArgD),
-               vec_data<Ty>::get(ArgE), vec_data<Ty>::get(ArgF)} {}
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  // Constructor from values of base type or vec of base type. Checks that
-  // base types are match and that the NumElements == sum of lengths of args.
-  template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
-            typename = EnableIfSuitableNumElements<argTN...>>
-  constexpr vec(const argTN &...args)
-      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
-            std::make_index_sequence<NumElements>()} {}
-
-#ifdef __SYCL_DEVICE_ONLY__
-  template <typename vector_t_ = vector_t,
-            typename =
-                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
-                                          !std::is_same_v<vector_t_, DataT>>>
-  constexpr vec(vector_t openclVector) {
-    if constexpr (!IsUsingArrayOnDevice) {
-      m_Data = openclVector;
-    } else {
-      m_Data = bit_cast<DataType>(openclVector);
-    }
-  }
-
-  operator vector_t() const {
-    if constexpr (!IsUsingArrayOnDevice) {
-      return m_Data;
-    } else {
-      auto ptr = bit_cast<const vector_t *>((&m_Data)->data());
-      return *ptr;
-    }
-  }
-#endif // __SYCL_DEVICE_ONLY__
-
-  // Available only when: NumElements == 1
-  template <int N = NumElements>
-  operator typename std::enable_if_t<N == 1, DataT>() const {
-    return vec_data<DataT>::get(m_Data);
-  }
-
-  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
-  static constexpr size_t get_count() { return size(); }
-  static constexpr size_t size() noexcept { return NumElements; }
-  __SYCL2020_DEPRECATED(
-      "get_size() is deprecated, please use byte_size() instead")
-  static constexpr size_t get_size() { return byte_size(); }
-  static constexpr size_t byte_size() noexcept { return sizeof(m_Data); }
-
-  // convertImpl can't be called with the same From and To types and therefore
-  // we need this version of convert which is mostly no-op.
-  template <typename convertT,
-            rounding_mode roundingMode = rounding_mode::automatic>
-  std::enable_if_t<
-      std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> ||
-          std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
-                         detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
-      vec<convertT, NumElements>>
-  convert() const {
-    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
-                      detail::is_floating_point<convertT>::value,
-                  "Unsupported convertT");
-    if constexpr (!std::is_same_v<DataT, convertT>) {
-      // Dummy conversion for cases like vec<signed char> -> vec<char>
-      vec<convertT, NumElements> Result;
-      for (size_t I = 0; I < NumElements; ++I)
-        Result.setValue(I, static_cast<convertT>(getValue(I)));
-
-      return Result;
-    } else {
-      // No conversion necessary
-      return *this;
-    }
-  }
-
-  template <typename convertT,
-            rounding_mode roundingMode = rounding_mode::automatic>
-  std::enable_if_t<
-      !std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> &&
-          !std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
-                          detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
-      vec<convertT, NumElements>>
-  convert() const {
-    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
-                      detail::is_floating_point<convertT>::value,
-                  "Unsupported convertT");
-    using T = vec_data_t<DataT>;
-    using R = vec_data_t<convertT>;
-    using OpenCLT = detail::ConvertToOpenCLType_t<T>;
-    using OpenCLR = detail::ConvertToOpenCLType_t<R>;
-    vec<convertT, NumElements> Result;
-
-#if defined(__SYCL_DEVICE_ONLY__)
-    using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
-    using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
-    // Whole vector conversion can only be done, if:
-    constexpr bool canUseNativeVectorConvert =
-#ifdef __NVPTX__
-        // - we are not on CUDA, see intel/llvm#11840
-        false &&
-#endif
-        // - both vectors are represented using native vector types;
-        NativeVec && vec<convertT, NumElements>::NativeVec &&
-        // - vec storage has an equivalent OpenCL native vector it is implicitly
-        //   convertible to. There are some corner cases where it is not the
-        //   case with char, long and long long types.
-        std::is_convertible_v<decltype(m_Data), OpenCLVecT> &&
-        std::is_convertible_v<decltype(Result.m_Data), OpenCLVecR> &&
-        // - it is not a signed to unsigned (or vice versa) conversion
-        //   see comments within 'convertImpl' for more details;
-        !detail::is_sint_to_from_uint<T, R>::value &&
-        // - destination type is not bool. bool is stored as integer under the
-        //   hood and therefore conversion to bool looks like conversion between
-        //   two integer types. Since bit pattern for true and false is not
-        //   defined, there is no guarantee that integer conversion yields
-        //   right results here;
-        !std::is_same_v<convertT, bool>;
-    if constexpr (canUseNativeVectorConvert) {
-      Result.m_Data = detail::convertImpl<T, R, roundingMode, NumElements,
-                                          OpenCLVecT, OpenCLVecR>(m_Data);
-    } else
-#endif // defined(__SYCL_DEVICE_ONLY__)
-    {
-      // Otherwise, we fallback to per-element conversion:
-      for (size_t I = 0; I < NumElements; ++I) {
-        Result.setValue(
-            I, vec_data<convertT>::get(
-                   detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
-                       vec_data<DataT>::get(getValue(I)))));
-      }
-    }
-
-    return Result;
-  }
-
-  template <typename asT> asT as() const {
-    static_assert((sizeof(*this) == sizeof(asT)),
-                  "The new SYCL vec type must have the same storage size in "
-                  "bytes as this SYCL vec");
-    static_assert(
-        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
-            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
-        "asT must be SYCL vec of a different element type and "
-        "number of elements specified by asT");
-    asT Result;
-    detail::memcpy(&Result.m_Data, &m_Data, sizeof(decltype(Result.m_Data)));
-    return Result;
-  }
-
-  template <int... SwizzleIndexes> Swizzle<SwizzleIndexes...> swizzle() {
-    return this;
-  }
-
-  template <int... SwizzleIndexes>
-  ConstSwizzle<SwizzleIndexes...> swizzle() const {
-    return this;
-  }
-
-  // ext_vector_type is used as an underlying type for sycl::vec on device.
-  // The problem is that for clang vector types the return of operator[] is a
-  // temporary and not a reference to the element in the vector. In practice
-  // reinterpret_cast<DataT *>(&m_Data)[i]; is working. According to
-  // http://llvm.org/docs/GetElementPtr.html#can-gep-index-into-vector-elements
-  // this is not disallowed now. But could probably be disallowed in the future.
-  // That is why tests are added to check that behavior of the compiler has
-  // not changed.
-  //
-  // Implement operator [] in the same way for host and device.
-  // TODO: change host side implementation when underlying type for host side
-  // will be changed to std::array.
-  // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
-  // aggressively optimized. Specializing with noinline to avoid as workaround.
-
-  template <typename T = DataT>
-  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                            const DataT &>
-  operator[](int i) const {
-    return reinterpret_cast<const DataT *>(&m_Data)[i];
-  }
-
-  template <typename T = DataT>
-  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                            DataT &>
-  operator[](int i) {
-    return reinterpret_cast<DataT *>(&m_Data)[i];
-  }
-
-#ifdef _MSC_VER
-#define __SYCL_NOINLINE_BF16 __declspec(noinline)
-#else
-#define __SYCL_NOINLINE_BF16 __attribute__((noinline))
-#endif
-
-  template <typename T = DataT>
-  __SYCL_NOINLINE_BF16
-      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                                const DataT &>
-      operator[](int i) const {
-    return reinterpret_cast<const DataT *>(&m_Data)[i];
-  }
-
-  template <typename T = DataT>
-  __SYCL_NOINLINE_BF16
-      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                                DataT &>
-      operator[](int i) {
-    return reinterpret_cast<DataT *>(&m_Data)[i];
-  }
-
-#undef __SYCL_NOINLINE_BF16
-
-  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
-private:
-  // Indexer used in the swizzles.def
-  // Currently it is defined as a template struct. Replacing it with a constexpr
-  // function would activate a bug in MSVC that is fixed only in v19.20.
-  // Until then MSVC does not recognize such constexpr functions as const and
-  // thus does not let using them in template parameters inside swizzle.def.
-  template <int Index> struct Indexer {
-    static constexpr int value = Index;
-  };
-
-public:
-#ifdef __SYCL_ACCESS_RETURN
-#error "Undefine __SYCL_ACCESS_RETURN macro"
-#endif
-#define __SYCL_ACCESS_RETURN this
-#include "swizzles.def"
-#undef __SYCL_ACCESS_RETURN
-  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
-
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void load(size_t Offset, multi_ptr<const DataT, Space, DecorateAddress> Ptr) {
-    for (int I = 0; I < NumElements; I++) {
-      setValue(I, *multi_ptr<const DataT, Space, DecorateAddress>(
-                      Ptr + Offset * NumElements + I));
-    }
-  }
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void load(size_t Offset, multi_ptr<DataT, Space, DecorateAddress> Ptr) {
-    multi_ptr<const DataT, Space, DecorateAddress> ConstPtr(Ptr);
-    load(Offset, ConstPtr);
-  }
-  template <int Dimensions, access::mode Mode,
-            access::placeholder IsPlaceholder, access::target Target,
-            typename PropertyListT>
-  void
-  load(size_t Offset,
-       accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
-           Acc) {
-    multi_ptr<const DataT, detail::TargetToAS<Target>::AS,
-              access::decorated::yes>
-        MultiPtr(Acc);
-    load(Offset, MultiPtr);
-  }
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void store(size_t Offset,
-             multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
-    for (int I = 0; I < NumElements; I++) {
-      *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
-                                                I) = getValue(I);
-    }
-  }
-  template <int Dimensions, access::mode Mode,
-            access::placeholder IsPlaceholder, access::target Target,
-            typename PropertyListT>
-  void
-  store(size_t Offset,
-        accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
-            Acc) {
-    multi_ptr<DataT, detail::TargetToAS<Target>::AS, access::decorated::yes>
-        MultiPtr(Acc);
-    store(Offset, MultiPtr);
-  }
-
-  void ConvertToDataT() {
-    for (size_t i = 0; i < NumElements; ++i) {
-      DataT tmp = getValue(i);
-      setValue(i, tmp);
-    }
-  }
-
-#ifdef __SYCL_BINOP
-#error "Undefine __SYCL_BINOP macro"
-#endif
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
-  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
-    vec Ret;                                                                   \
-    if constexpr (IsUsingArrayOnDevice) {                                      \
-      for (size_t I = 0; I < NumElements; ++I) {                               \
-        Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
-      }                                                                        \
-    } else {                                                                   \
-      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
-      if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
-        Ret.ConvertToDataT();                                                  \
-      }                                                                        \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
-    return Lhs BINOP vec(Rhs);                                                 \
-  }                                                                            \
-  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
-    return vec(Lhs) BINOP Rhs;                                                 \
-  }                                                                            \
-  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
-    Lhs = Lhs BINOP Rhs;                                                       \
-    return Lhs;                                                                \
-  }                                                                            \
-  template <int Num = NumElements>                                             \
-  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
-      vec & Lhs, const DataT & Rhs) {                                          \
-    Lhs = Lhs BINOP vec(Rhs);                                                  \
-    return Lhs;                                                                \
-  }
-
-#else // __SYCL_USE_EXT_VECTOR_TYPE__
-
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
-  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
-    vec Ret{};                                                                 \
-    if constexpr (NativeVec)                                                   \
-      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
-    else                                                                       \
-      for (size_t I = 0; I < NumElements; ++I)                                 \
-        Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(             \
-                            I)) BINOP vec_data<DataT>::get(Rhs.getValue(I)))); \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
-    return Lhs BINOP vec(Rhs);                                                 \
-  }                                                                            \
-  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
-    return vec(Lhs) BINOP Rhs;                                                 \
-  }                                                                            \
-  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
-    Lhs = Lhs BINOP Rhs;                                                       \
-    return Lhs;                                                                \
-  }                                                                            \
-  template <int Num = NumElements>                                             \
-  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
-      vec & Lhs, const DataT & Rhs) {                                          \
-    Lhs = Lhs BINOP vec(Rhs);                                                  \
-    return Lhs;                                                                \
-  }
-
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  __SYCL_BINOP(+, +=, true)
-  __SYCL_BINOP(-, -=, true)
-  __SYCL_BINOP(*, *=, false)
-  __SYCL_BINOP(/, /=, false)
-
-  // TODO: The following OPs are available only when: DataT != cl_float &&
-  // DataT != cl_double && DataT != cl_half
-  __SYCL_BINOP(%, %=, false)
-  __SYCL_BINOP(|, |=, false)
-  __SYCL_BINOP(&, &=, false)
-  __SYCL_BINOP(^, ^=, false)
-  __SYCL_BINOP(>>, >>=, false)
-  __SYCL_BINOP(<<, <<=, true)
-#undef __SYCL_BINOP
-#undef __SYCL_BINOP_HELP
-
-  // Note: vec<>/SwizzleOp logical value is 0/-1 logic, as opposed to 0/1 logic.
-  // As far as CTS validation is concerned, 0/-1 logic also applies when
-  // NumElements is equal to one, which is somewhat inconsistent with being
-  // transparent with scalar data.
-  // TODO: Determine if vec<, NumElements=1> is needed at all, remove this
-  // inconsistency if not by disallowing one-element vectors (as in OpenCL)
-
-#ifdef __SYCL_RELLOGOP
-#error "Undefine __SYCL_RELLOGOP macro"
-#endif
-// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
-// by SYCL device compiler only.
-#ifdef __SYCL_DEVICE_ONLY__
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const vec & Rhs) {          \
-    vec<rel_t, NumElements> Ret{};                                             \
-    /* This special case is needed since there are no standard operator||   */ \
-    /* or operator&& functions for std::array.                              */ \
-    if constexpr (IsUsingArrayOnDevice &&                                      \
-                  (std::string_view(#RELLOGOP) == "||" ||                      \
-                   std::string_view(#RELLOGOP) == "&&")) {                     \
-      for (size_t I = 0; I < NumElements; ++I) {                               \
-        /* We cannot use SetValue here as the operator is not a friend of*/    \
-        /* Ret on Windows. */                                                  \
-        Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                    \
-            Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
-      }                                                                        \
-    } else {                                                                   \
-      Ret = vec<rel_t, NumElements>(                                           \
-          (typename vec<rel_t, NumElements>::vector_t)(                        \
-              Lhs.m_Data RELLOGOP Rhs.m_Data));                                \
-      if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
-        Ret *= -1;                                                             \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const DataT & Rhs) {        \
-    return Lhs RELLOGOP vec(Rhs);                                              \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
-                                                   const vec & Rhs) {          \
-    return vec(Lhs) RELLOGOP Rhs;                                              \
-  }
-
-#else
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const vec & Rhs) {          \
-    vec<rel_t, NumElements> Ret{};                                             \
-    for (size_t I = 0; I < NumElements; ++I) {                                 \
-      /* We cannot use SetValue here as the operator is not a friend of*/      \
-      /* Ret on Windows. */                                                    \
-      Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                      \
-          Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));   \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const DataT & Rhs) {        \
-    return Lhs RELLOGOP vec(Rhs);                                              \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
-                                                   const vec & Rhs) {          \
-    return vec(Lhs) RELLOGOP Rhs;                                              \
-  }
-#endif
-
-  __SYCL_RELLOGOP(==)
-  __SYCL_RELLOGOP(!=)
-  __SYCL_RELLOGOP(>)
-  __SYCL_RELLOGOP(<)
-  __SYCL_RELLOGOP(>=)
-  __SYCL_RELLOGOP(<=)
-  // TODO: limit to integral types.
-  __SYCL_RELLOGOP(&&)
-  __SYCL_RELLOGOP(||)
-#undef __SYCL_RELLOGOP
-
-#ifdef __SYCL_UOP
-#error "Undefine __SYCL_UOP macro"
-#endif
-#define __SYCL_UOP(UOP, OPASSIGN)                                              \
-  friend vec &operator UOP(vec & Rhs) {                                        \
-    Rhs OPASSIGN vec_data<DataT>::get(1);                                      \
-    return Rhs;                                                                \
-  }                                                                            \
-  friend vec operator UOP(vec &Lhs, int) {                                     \
-    vec Ret(Lhs);                                                              \
-    Lhs OPASSIGN vec_data<DataT>::get(1);                                      \
-    return Ret;                                                                \
-  }
-
-  __SYCL_UOP(++, +=)
-  __SYCL_UOP(--, -=)
-#undef __SYCL_UOP
-
-  // operator~() available only when: dataT != float && dataT != double
-  // && dataT != half
-  friend vec operator~(const vec &Rhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I) {
-        Ret.setValue(I, ~Rhs.getValue(I));
-      }
-      return Ret;
-    } else {
-      vec Ret{(typename vec::DataType) ~Rhs.m_Data};
-      if constexpr (std::is_same_v<Type, bool>) {
-        Ret.ConvertToDataT();
-      }
-      return Ret;
-    }
-  }
-
-  // operator!
-  friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I) {
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-        // std::byte neither supports ! unary op or casting, so special handling
-        // is needed. And, worse, Windows has a conflict with 'byte'.
-        if constexpr (std::is_same_v<std::byte, DataT>) {
-          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
-        } else
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-        {
-          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
-        }
-      }
-      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
-    } else {
-      return vec{(typename vec<DataT, NumElements>::DataType) !Rhs.m_Data}
-          .template as<vec<detail::rel_t<DataT>, NumElements>>();
-    }
-  }
-
-  // operator +
-  friend vec operator+(const vec &Lhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I)
-        Ret.setValue(
-            I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
-      return Ret;
-    } else {
-      return vec{+Lhs.m_Data};
-    }
-  }
-
-  // operator -
-  friend vec operator-(const vec &Lhs) {
-    namespace oneapi = sycl::ext::oneapi;
-    vec Ret{};
-    if constexpr (IsBfloat16 && NumElements == 1) {
-      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data);
-      oneapi::bfloat16 w = -v;
-      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
-    } else if constexpr (IsBfloat16) {
-      for (size_t I = 0; I < NumElements; I++) {
-        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[I]);
-        oneapi::bfloat16 w = -v;
-        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
-      }
-    } else if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      for (size_t I = 0; I < NumElements; ++I)
-        Ret.setValue(
-            I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
-      return Ret;
-    } else {
-      Ret = vec{-Lhs.m_Data};
-      if constexpr (std::is_same_v<Type, bool>) {
-        Ret.ConvertToDataT();
-      }
-      return Ret;
-    }
-  }
-
-  // OP is: &&, ||
-  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
-  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
-
-  // OP is: ==, !=, <, >, <=, >=
-  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
-  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
-private:
-  // Generic method that execute "Operation" on underlying values.
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  template <template <typename> class Operation,
-            typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements>
-  operatorHelper(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataType> Op;
-    Result.m_Data = Op(m_Data, Rhs.m_Data);
-    return Result;
-  }
-
-  template <template <typename> class Operation,
-            typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements>
-  operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataT> Op;
-    for (size_t I = 0; I < NumElements; ++I) {
-      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
-    }
-    return Result;
-  }
-#else  // __SYCL_USE_EXT_VECTOR_TYPE__
-  template <template <typename> class Operation>
-  vec<DataT, NumElements>
-  operatorHelper(const vec<DataT, NumElements> &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataT> Op;
-    for (size_t I = 0; I < NumElements; ++I) {
-      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
-    }
-    return Result;
-  }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  // setValue and getValue should be able to operate on different underlying
-  // types: enum cl_float#N , builtin vector float#N, builtin type float.
-  // These versions are for N > 1.
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
-                          int) {
-    m_Data[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
-    return vec_data<DataT>::get(m_Data[Index]);
-  }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
-    m_Data.s[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
-    return vec_data<DataT>::get(m_Data.s[Index]);
-  }
-#else // __SYCL_USE_EXT_VECTOR_TYPE__
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(int Index, const DataT &Value, int) {
-    m_Data[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(int Index, int) const {
-    return vec_data<DataT>::get(m_Data[Index]);
-  }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  // N==1 versions, used by host and device. Shouldn't trailing type be int?
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 == Num>>
-  constexpr void setValue(int, const DataT &Value, float) {
-    m_Data = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 == Num>>
-  DataT getValue(int, float) const {
-    return vec_data<DataT>::get(m_Data);
-  }
-
-  // setValue and getValue.
-  // The "api" functions used by BINOP etc.  These versions just dispatch
-  // using additional int or float arg to disambiguate vec<1> vs. vec<N>
-  // Special proxies as specialization is not allowed in class scope.
-  constexpr void setValue(int Index, const DataT &Value) {
-    if (NumElements == 1)
-      setValue(Index, Value, 0);
-    else
-      setValue(Index, Value, 0.f);
-  }
-
-  DataT getValue(int Index) const {
-    return (NumElements == 1) ? getValue(Index, 0) : getValue(Index, 0.f);
-  }
-
-  // fields
-
-  // Alignment is the same as size, to a maximum size of 64.
-  // detail::vector_alignment will return that value.
-  alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
 
-  // friends
-  template <typename T1, typename T2, typename T3, template <typename> class T4,
-            int... T5>
-  friend class detail::SwizzleOp;
-  template <typename T1, int T2> friend class vec;
-};
-
-#ifdef __cpp_deduction_guides
-// all compilers supporting deduction guides also support fold expressions
-template <class T, class... U,
-          class = std::enable_if_t<(std::is_same_v<T, U> && ...)>>
-vec(T, U...) -> vec<T, sizeof...(U) + 1>;
-#endif
-
-namespace detail {
-
-// SwizzleOP represents expression templates that operate on vec.
-// Actual computation performed on conversion or assignment operators.
-template <typename VecT, typename OperationLeftT, typename OperationRightT,
-          template <typename> class OperationCurrentT, int... Indexes>
-class SwizzleOp {
-  using DataT = typename VecT::element_type;
-  // Certain operators return a vector with a different element type. Also, the
-  // left and right operand types may differ. CommonDataT selects a result type
-  // based on these types to ensure that the result value can be represented.
-  //
-  // Example 1:
-  //   sycl::vec<unsigned char, 4> vec{...};
-  //   auto result = 300u + vec.x();
-  //
-  // CommonDataT is std::common_type_t<OperationLeftT, OperationRightT> since
-  // it's larger than unsigned char.
-  //
-  // Example 2:
-  //   sycl::vec<bool, 1> vec{...};
-  //   auto result = vec.template swizzle<sycl::elem::s0>() && vec;
-  //
-  // CommonDataT is DataT since operator&& returns a vector with element type
-  // int8_t, which is larger than bool.
-  //
-  // Example 3:
-  //   sycl::vec<std::byte, 4> vec{...}; auto swlo = vec.lo();
-  //   auto result = swlo == swlo;
-  //
-  // CommonDataT is DataT since operator== returns a vector with element type
-  // int8_t, which is the same size as std::byte. std::common_type_t<DataT, ...>
-  // can't be used here since there's no type that int8_t and std::byte can both
-  // be implicitly converted to.
-  using OpLeftDataT = typename OperationLeftT::DataT;
-  using OpRightDataT = typename OperationRightT::DataT;
-  using CommonDataT = std::conditional_t<
-      sizeof(DataT) >= sizeof(std::common_type_t<OpLeftDataT, OpRightDataT>),
-      DataT, std::common_type_t<OpLeftDataT, OpRightDataT>>;
-  static constexpr int getNumElements() { return sizeof...(Indexes); }
-
-  using rel_t = detail::rel_t<DataT>;
-  using vec_t = vec<DataT, sizeof...(Indexes)>;
-  using vec_rel_t = vec<rel_t, sizeof...(Indexes)>;
-
-  template <typename OperationRightT_,
-            template <typename> class OperationCurrentT_, int... Idx_>
-  using NewLHOp = SwizzleOp<VecT,
-                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                                      OperationCurrentT, Indexes...>,
-                            OperationRightT_, OperationCurrentT_, Idx_...>;
-
-  template <typename OperationRightT_,
-            template <typename> class OperationCurrentT_, int... Idx_>
-  using NewRelOp = SwizzleOp<vec<rel_t, VecT::getNumElements()>,
-                             SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                                       OperationCurrentT, Indexes...>,
-                             OperationRightT_, OperationCurrentT_, Idx_...>;
-
-  template <typename OperationLeftT_,
-            template <typename> class OperationCurrentT_, int... Idx_>
-  using NewRHOp = SwizzleOp<VecT, OperationLeftT_,
-                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                                      OperationCurrentT, Indexes...>,
-                            OperationCurrentT_, Idx_...>;
-
-  template <int IdxNum, typename T = void>
-  using EnableIfOneIndex = typename std::enable_if_t<
-      1 == IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
-
-  template <int IdxNum, typename T = void>
-  using EnableIfMultipleIndexes = typename std::enable_if_t<
-      1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
-
-  template <typename T>
-  using EnableIfScalarType = typename std::enable_if_t<
-      std::is_convertible_v<DataT, T> &&
-      (std::is_fundamental_v<vec_data_t<T>> ||
-       detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
-
-  template <typename T>
-  using EnableIfNoScalarType = typename std::enable_if_t<
-      !std::is_convertible_v<DataT, T> ||
-      !(std::is_fundamental_v<vec_data_t<T>> ||
-        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
-
-  template <int... Indices>
-  using Swizzle =
-      SwizzleOp<VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
-
-  template <int... Indices>
-  using ConstSwizzle =
-      SwizzleOp<const VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
-
-public:
-  using element_type = DataT;
-  using value_type = DataT;
-
-#ifdef __SYCL_DEVICE_ONLY__
-  using vector_t = typename vec_t::vector_t;
-#endif // __SYCL_DEVICE_ONLY__
-
-  const DataT &operator[](int i) const {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    return (*m_Vector)[Idxs[i]];
-  }
-
-  template <typename _T = VecT>
-  std::enable_if_t<!std::is_const_v<_T>, DataT> &operator[](int i) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    return (*m_Vector)[Idxs[i]];
-  }
-
-  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
-  size_t get_count() const { return size(); }
-  static constexpr size_t size() noexcept { return getNumElements(); }
-
-  template <int Num = getNumElements()>
-  __SYCL2020_DEPRECATED(
-      "get_size() is deprecated, please use byte_size() instead")
-  size_t get_size() const {
-    return byte_size<Num>();
-  }
-
-  template <int Num = getNumElements()> size_t byte_size() const noexcept {
-    return sizeof(DataT) * (Num == 3 ? 4 : Num);
-  }
-
-  template <typename T, int IdxNum = getNumElements(),
-            typename = EnableIfOneIndex<IdxNum>,
-            typename = EnableIfScalarType<T>>
-  operator T() const {
-    return getValue(0);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  friend NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>
-  operator*(const T &Lhs, const SwizzleOp &Rhs) {
-    return NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
-        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  friend NewRHOp<GetScalarOp<T>, std::plus, Indexes...>
-  operator+(const T &Lhs, const SwizzleOp &Rhs) {
-    return NewRHOp<GetScalarOp<T>, std::plus, Indexes...>(
-        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  friend NewRHOp<GetScalarOp<T>, std::divides, Indexes...>
-  operator/(const T &Lhs, const SwizzleOp &Rhs) {
-    return NewRHOp<GetScalarOp<T>, std::divides, Indexes...>(
-        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
-  }
-
-  // TODO: Check that Rhs arg is suitable.
-#ifdef __SYCL_OPASSIGN
-#error "Undefine __SYCL_OPASSIGN macro."
-#endif
-#define __SYCL_OPASSIGN(OPASSIGN, OP)                                          \
-  SwizzleOp &operator OPASSIGN(const DataT & Rhs) {                            \
-    operatorHelper<OP>(vec_t(Rhs));                                            \
-    return *this;                                                              \
-  }                                                                            \
-  template <typename RhsOperation>                                             \
-  SwizzleOp &operator OPASSIGN(const RhsOperation & Rhs) {                     \
-    operatorHelper<OP>(Rhs);                                                   \
-    return *this;                                                              \
-  }
-
-  __SYCL_OPASSIGN(+=, std::plus)
-  __SYCL_OPASSIGN(-=, std::minus)
-  __SYCL_OPASSIGN(*=, std::multiplies)
-  __SYCL_OPASSIGN(/=, std::divides)
-  __SYCL_OPASSIGN(%=, std::modulus)
-  __SYCL_OPASSIGN(&=, std::bit_and)
-  __SYCL_OPASSIGN(|=, std::bit_or)
-  __SYCL_OPASSIGN(^=, std::bit_xor)
-  __SYCL_OPASSIGN(>>=, RShift)
-  __SYCL_OPASSIGN(<<=, LShift)
-#undef __SYCL_OPASSIGN
-
-#ifdef __SYCL_UOP
-#error "Undefine __SYCL_UOP macro"
-#endif
-#define __SYCL_UOP(UOP, OPASSIGN)                                              \
-  SwizzleOp &operator UOP() {                                                  \
-    *this OPASSIGN static_cast<DataT>(1);                                      \
-    return *this;                                                              \
-  }                                                                            \
-  vec_t operator UOP(int) {                                                    \
-    vec_t Ret = *this;                                                         \
-    *this OPASSIGN static_cast<DataT>(1);                                      \
-    return Ret;                                                                \
-  }
-
-  __SYCL_UOP(++, +=)
-  __SYCL_UOP(--, -=)
-#undef __SYCL_UOP
-
-  template <typename T = DataT>
-  friend typename std::enable_if_t<
-      std::is_same_v<T, DataT> && std::is_integral_v<vec_data_t<T>>, vec_t>
-  operator~(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return ~Tmp;
-  }
-
-  friend vec_rel_t operator!(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return !Tmp;
-  }
-
-  friend vec_t operator+(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return +Tmp;
-  }
-
-  friend vec_t operator-(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return -Tmp;
-  }
-
-// scalar BINOP vec<>
-// scalar BINOP SwizzleOp
-// vec<> BINOP SwizzleOp
-#ifdef __SYCL_BINOP
-#error "Undefine __SYCL_BINOP macro"
-#endif
-#define __SYCL_BINOP(BINOP)                                                    \
-  friend vec_t operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {        \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs BINOP Tmp;                                                      \
-  }                                                                            \
-  friend vec_t operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {        \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp BINOP Rhs;                                                      \
-  }                                                                            \
-  friend vec_t operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {        \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs BINOP Tmp;                                                      \
-  }                                                                            \
-  friend vec_t operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {        \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp BINOP Rhs;                                                      \
-  }
-
-  __SYCL_BINOP(+)
-  __SYCL_BINOP(-)
-  __SYCL_BINOP(*)
-  __SYCL_BINOP(/)
-  __SYCL_BINOP(%)
-  __SYCL_BINOP(&)
-  __SYCL_BINOP(|)
-  __SYCL_BINOP(^)
-  __SYCL_BINOP(>>)
-  __SYCL_BINOP(<<)
-#undef __SYCL_BINOP
-
-// scalar RELLOGOP vec<>
-// scalar RELLOGOP SwizzleOp
-// vec<> RELLOGOP SwizzleOp
-#ifdef __SYCL_RELLOGOP
-#error "Undefine __SYCL_RELLOGOP macro"
-#endif
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec_rel_t operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs RELLOGOP Tmp;                                                   \
-  }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp RELLOGOP Rhs;                                                   \
-  }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs RELLOGOP Tmp;                                                   \
-  }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp RELLOGOP Rhs;                                                   \
-  }
-
-  __SYCL_RELLOGOP(==)
-  __SYCL_RELLOGOP(!=)
-  __SYCL_RELLOGOP(>)
-  __SYCL_RELLOGOP(<)
-  __SYCL_RELLOGOP(>=)
-  __SYCL_RELLOGOP(<=)
-  // TODO: limit to integral types.
-  __SYCL_RELLOGOP(&&)
-  __SYCL_RELLOGOP(||)
-#undef __SYCL_RELLOGOP
-
-  template <int IdxNum = getNumElements(),
-            typename = EnableIfMultipleIndexes<IdxNum>>
-  SwizzleOp &operator=(const vec<DataT, IdxNum> &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
-    }
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
-  SwizzleOp &operator=(const DataT &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    m_Vector->setValue(Idxs[0], Rhs);
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(),
-            EnableIfMultipleIndexes<IdxNum, bool> = true>
-  SwizzleOp &operator=(const DataT &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    for (auto Idx : Idxs) {
-      m_Vector->setValue(Idx, Rhs);
-    }
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
-  SwizzleOp &operator=(DataT &&Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    m_Vector->setValue(Idxs[0], Rhs);
-    return *this;
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>
-  operator*(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::multiplies, Indexes...>
-  operator*(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::multiplies, Indexes...>(m_Vector, *this,
-                                                              Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::plus, Indexes...> operator+(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::plus, Indexes...>(m_Vector, *this,
-                                                          GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::plus, Indexes...>
-  operator+(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::plus, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::minus, Indexes...>
-  operator-(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::minus, Indexes...>(m_Vector, *this,
-                                                           GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::minus, Indexes...>
-  operator-(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::minus, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::divides, Indexes...>
-  operator/(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::divides, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::divides, Indexes...>
-  operator/(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::divides, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>
-  operator%(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::modulus, Indexes...>
-  operator%(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::modulus, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>
-  operator&(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::bit_and, Indexes...>
-  operator&(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::bit_and, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>
-  operator|(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::bit_or, Indexes...>
-  operator|(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::bit_or, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>
-  operator^(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::bit_xor, Indexes...>
-  operator^(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::bit_xor, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, RShift, Indexes...> operator>>(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, RShift, Indexes...>(m_Vector, *this,
-                                                       GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, RShift, Indexes...>
-  operator>>(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, RShift, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, LShift, Indexes...> operator<<(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, LShift, Indexes...>(m_Vector, *this,
-                                                       GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, LShift, Indexes...>
-  operator<<(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, LShift, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <
-      typename T1, typename T2, typename T3, template <typename> class T4,
-      int... T5,
-      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
-  SwizzleOp &operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
-    }
-    return *this;
-  }
-
-  template <
-      typename T1, typename T2, typename T3, template <typename> class T4,
-      int... T5,
-      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
-  SwizzleOp &operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
-    }
-    return *this;
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, EqualTo, Indexes...> operator==(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, EqualTo, Indexes...>(NULL, *this,
-                                                         GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, EqualTo, Indexes...>
-  operator==(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, EqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>
-  operator!=(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, NotEqualTo, Indexes...>
-  operator!=(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, NotEqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>
-  operator>=(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>
-  operator>=(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>
-  operator<=(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LessEqualTo, Indexes...>
-  operator<=(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LessEqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>
-  operator>(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, GreaterThan, Indexes...>
-  operator>(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, GreaterThan, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LessThan, Indexes...> operator<(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LessThan, Indexes...>(NULL, *this,
-                                                          GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LessThan, Indexes...>
-  operator<(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LessThan, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>
-  operator&&(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LogicalAnd, Indexes...>
-  operator&&(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LogicalAnd, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>
-  operator||(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>(NULL, *this,
-                                                           GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LogicalOr, Indexes...>
-  operator||(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LogicalOr, Indexes...>(NULL, *this, Rhs);
-  }
-
-  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
-private:
-  // Indexer used in the swizzles.def.
-  // Currently it is defined as a template struct. Replacing it with a constexpr
-  // function would activate a bug in MSVC that is fixed only in v19.20.
-  // Until then MSVC does not recognize such constexpr functions as const and
-  // thus does not let using them in template parameters inside swizzle.def.
-  template <int Index> struct Indexer {
-    static constexpr int IDXs[sizeof...(Indexes)] = {Indexes...};
-    static constexpr int value = IDXs[Index >= getNumElements() ? 0 : Index];
-  };
-
-public:
-#ifdef __SYCL_ACCESS_RETURN
-#error "Undefine __SYCL_ACCESS_RETURN macro"
-#endif
-#define __SYCL_ACCESS_RETURN m_Vector
-#include "swizzles.def"
-#undef __SYCL_ACCESS_RETURN
-  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
-
-  // Leave store() interface to automatic conversion to vec<>.
-  // Load to vec_t and then assign to swizzle.
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void load(size_t offset, multi_ptr<DataT, Space, DecorateAddress> ptr) {
-    vec_t Tmp;
-    Tmp.template load(offset, ptr);
-    *this = Tmp;
-  }
-
-  template <typename convertT, rounding_mode roundingMode>
-  vec<convertT, sizeof...(Indexes)> convert() const {
-    // First materialize the swizzle to vec_t and then apply convert() to it.
-    vec_t Tmp = *this;
-    return Tmp.template convert<convertT, roundingMode>();
-  }
-
-  template <typename asT> asT as() const {
-    // First materialize the swizzle to vec_t and then apply as() to it.
-    vec_t Tmp = *this;
-    static_assert((sizeof(Tmp) == sizeof(asT)),
-                  "The new SYCL vec type must have the same storage size in "
-                  "bytes as this SYCL swizzled vec");
-    static_assert(
-        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
-            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
-        "asT must be SYCL vec of a different element type and "
-        "number of elements specified by asT");
-    return Tmp.template as<asT>();
-  }
-
-private:
-  SwizzleOp(const SwizzleOp &Rhs)
-      : m_Vector(Rhs.m_Vector), m_LeftOperation(Rhs.m_LeftOperation),
-        m_RightOperation(Rhs.m_RightOperation) {}
-
-  SwizzleOp(VecT *Vector, OperationLeftT LeftOperation,
-            OperationRightT RightOperation)
-      : m_Vector(Vector), m_LeftOperation(LeftOperation),
-        m_RightOperation(RightOperation) {}
-
-  SwizzleOp(VecT *Vector) : m_Vector(Vector) {}
-
-  SwizzleOp(SwizzleOp &&Rhs)
-      : m_Vector(Rhs.m_Vector), m_LeftOperation(std::move(Rhs.m_LeftOperation)),
-        m_RightOperation(std::move(Rhs.m_RightOperation)) {}
-
-  // Either performing CurrentOperation on results of left and right operands
-  // or reading values from actual vector. Perform implicit type conversion when
-  // the number of elements == 1
-
-  template <int IdxNum = getNumElements()>
-  CommonDataT getValue(EnableIfOneIndex<IdxNum, size_t> Index) const {
-    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
-      std::array<int, getNumElements()> Idxs{Indexes...};
-      return m_Vector->getValue(Idxs[Index]);
-    }
-    auto Op = OperationCurrentT<vec_data_t<CommonDataT>>();
-    return vec_data<CommonDataT>::get(
-        Op(vec_data<CommonDataT>::get(m_LeftOperation.getValue(Index)),
-           vec_data<CommonDataT>::get(m_RightOperation.getValue(Index))));
-  }
-
-  template <int IdxNum = getNumElements()>
-  DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
-    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
-      std::array<int, getNumElements()> Idxs{Indexes...};
-      return m_Vector->getValue(Idxs[Index]);
-    }
-    auto Op = OperationCurrentT<vec_data_t<DataT>>();
-    return vec_data<DataT>::get(
-        Op(vec_data<DataT>::get(m_LeftOperation.getValue(Index)),
-           vec_data<DataT>::get(m_RightOperation.getValue(Index))));
-  }
-
-  template <template <typename> class Operation, typename RhsOperation>
-  void operatorHelper(const RhsOperation &Rhs) {
-    Operation<vec_data_t<DataT>> Op;
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      DataT Res = vec_data<DataT>::get(
-          Op(vec_data<DataT>::get(m_Vector->getValue(Idxs[I])),
-             vec_data<DataT>::get(Rhs.getValue(I))));
-      m_Vector->setValue(Idxs[I], Res);
-    }
-  }
-
-  // fields
-  VecT *m_Vector;
-
-  OperationLeftT m_LeftOperation;
-  OperationRightT m_RightOperation;
-
-  // friends
-  template <typename T1, int T2> friend class sycl::vec;
-
-  template <typename T1, typename T2, typename T3, template <typename> class T4,
-            int... T5>
-  friend class SwizzleOp;
-};
-} // namespace detail
-
-namespace detail {
-
-// Vectors of size 1 are handled separately and therefore 1 is not included in
-// the check below.
-constexpr bool isValidVectorSize(int N) {
-  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
-}
-template <typename T, int N, typename V> struct VecStorage {
-  static_assert(
-      isValidVectorSize(N) || N == 1,
-      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
-      "or 16 are supported");
-  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
-};
-
-#ifdef __SYCL_DEVICE_ONLY__
-// device always has ext vector support, but for huge vectors
-// we switch to std::array, so that we can use a smaller alignment (64)
-// this is to support MSVC, which has a max of 64 for direct params.
-template <typename T, int N> struct VecStorageImpl {
-  static constexpr size_t Num = (N == 3) ? 4 : N;
-  static constexpr size_t Sz = Num * sizeof(T);
-  using DataType =
-      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
-                                std::array<T, Num>>::type;
-  using VectorDataType = T __attribute__((ext_vector_type(N)));
-};
-#else // __SYCL_DEVICE_ONLY__
-template <typename T, int N> struct VecStorageImpl {
-  using DataType = std::array<T, (N == 3) ? 4 : N>;
-};
-#endif // __SYCL_DEVICE_ONLY__
-
-// Single element bool
-template <> struct VecStorage<bool, 1, void> {
-  using DataType = bool;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = bool;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple element bool
-template <int N>
-struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
-  using DataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-// Single element byte. Multiple elements will propagate through a later
-// specialization.
-template <> struct VecStorage<std::byte, 1, void> {
-  using DataType = std::int8_t;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = std::int8_t;
-#endif // __SYCL_DEVICE_ONLY__
-};
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-
-// Single element signed integers
-template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element unsigned integers
-template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element floating-point (except half/bfloat16)
-template <typename T>
-struct VecStorage<
-    T, 1,
-    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-// Multiple elements signed/unsigned integers and floating-point (except
-// half/bfloat16)
-template <typename T, int N>
-struct VecStorage<
-    T, N,
-    typename std::enable_if_t<isValidVectorSize(N) &&
-                              (is_sgeninteger_v<T> ||
-                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
-  using DataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element half
-template <> struct VecStorage<half, 1, void> {
-  using DataType = sycl::detail::half_impl::StorageT;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = sycl::detail::half_impl::StorageT;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple elements half
-#if defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
-    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
-  };
-#else // defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
-  };
-#endif // defined(__SYCL_DEVICE_ONLY__)
-
-__SYCL_DEFINE_HALF_VECSTORAGE(2)
-__SYCL_DEFINE_HALF_VECSTORAGE(3)
-__SYCL_DEFINE_HALF_VECSTORAGE(4)
-__SYCL_DEFINE_HALF_VECSTORAGE(8)
-__SYCL_DEFINE_HALF_VECSTORAGE(16)
-#undef __SYCL_DEFINE_HALF_VECSTORAGE
-
-// Single element bfloat16
-template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
-  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-  // using VectorDataType = sycl::ext::oneapi::bfloat16;
-  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-};
-// Multiple elements bfloat16
-#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
-    using VectorDataType =                                                     \
-        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
-  };
-__SYCL_DEFINE_BF16_VECSTORAGE(2)
-__SYCL_DEFINE_BF16_VECSTORAGE(3)
-__SYCL_DEFINE_BF16_VECSTORAGE(4)
-__SYCL_DEFINE_BF16_VECSTORAGE(8)
-__SYCL_DEFINE_BF16_VECSTORAGE(16)
-#undef __SYCL_DEFINE_BF16_VECSTORAGE
-} // namespace detail
-
-namespace detail {
 template <typename T, typename = void>
 struct IsDeprecatedDeviceCopyable : std::false_type {};
 
@@ -2270,6 +102,5 @@ struct CheckDeviceCopyable<
 
 #endif // __SYCL_DEVICE_ONLY__
 } // namespace detail
-
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/include/sycl/vector.hpp b/sycl/include/sycl/vector.hpp
index 056012fd08cf1..9958ac55ae125 100644
--- a/sycl/include/sycl/vector.hpp
+++ b/sycl/include/sycl/vector.hpp
@@ -1,4 +1,4 @@
-//==---------------- types.hpp --- SYCL types ------------------------------==//
+//==---------------- vector.hpp --- Implements sycl::vec -------------------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -41,10 +41,7 @@
 #include <sycl/detail/type_traits.hpp>         // for is_floating_point
 #include <sycl/detail/vector_convert.hpp>      // for convertImpl
 #include <sycl/detail/vector_traits.hpp>       // for vector_alignment
-#include <sycl/exception.hpp>                  // for make_error_code, errc
 #include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
-#include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
-#include <sycl/multi_ptr.hpp>                  // for multi_ptr
 
 #include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
 
@@ -54,15 +51,9 @@
 #include <cstdint>     // for uint8_t, int16_t, int...
 #include <functional>  // for divides, multiplies
 #include <iterator>    // for pair
-#include <optional>    // for optional
 #include <ostream>     // for operator<<, basic_ost...
-#include <tuple>       // for tuple
 #include <type_traits> // for enable_if_t, is_same
 #include <utility>     // for index_sequence, make_...
-#include <variant>     // for tuple, variant
-
-// 4.10.1: Scalar data types
-// 4.10.2: SYCL vector types
 
 namespace sycl {
 inline namespace _V1 {
@@ -191,85 +182,170 @@ template <typename T> class GetOp {
   DataT operator()(DataT, DataT) { return (DataT)0; }
 };
 
-// Special type for working SwizzleOp with scalars, stores a scalar and gives
-// the scalar at any index. Provides interface is compatible with SwizzleOp
-// operations
-template <typename T> class GetScalarOp {
-public:
-  using DataT = T;
-  GetScalarOp(DataT Data) : m_Data(Data) {}
-  DataT getValue(size_t) const { return m_Data; }
+// Forward declarations
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernel;
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernelWithKH;
 
-private:
-  DataT m_Data;
+// Vectors of size 1 are handled separately and therefore 1 is not included in
+// the check below.
+constexpr bool isValidVectorSize(int N) {
+  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
+}
+template <typename T, int N, typename V> struct VecStorage {
+  static_assert(
+      isValidVectorSize(N) || N == 1,
+      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
+      "or 16 are supported");
+  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
 };
 
-template <typename T> struct EqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs == Rhs) ? -1 : 0;
-  }
+#ifdef __SYCL_DEVICE_ONLY__
+// device always has ext vector support, but for huge vectors
+// we switch to std::array, so that we can use a smaller alignment (64)
+// this is to support MSVC, which has a max of 64 for direct params.
+template <typename T, int N> struct VecStorageImpl {
+  static constexpr size_t Num = (N == 3) ? 4 : N;
+  static constexpr size_t Sz = Num * sizeof(T);
+  using DataType =
+      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
+                                std::array<T, Num>>::type;
+  using VectorDataType = T __attribute__((ext_vector_type(N)));
 };
-
-template <typename T> struct NotEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs != Rhs) ? -1 : 0;
-  }
+#else // __SYCL_DEVICE_ONLY__
+template <typename T, int N> struct VecStorageImpl {
+  using DataType = std::array<T, (N == 3) ? 4 : N>;
 };
+#endif // __SYCL_DEVICE_ONLY__
 
-template <typename T> struct GreaterEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs >= Rhs) ? -1 : 0;
-  }
+// Single element bool
+template <> struct VecStorage<bool, 1, void> {
+  using DataType = bool;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = bool;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-template <typename T> struct LessEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs <= Rhs) ? -1 : 0;
-  }
+// Multiple element bool
+template <int N>
+struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
+  using DataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-template <typename T> struct GreaterThan {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs > Rhs) ? -1 : 0;
-  }
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+// Single element byte. Multiple elements will propagate through a later
+// specialization.
+template <> struct VecStorage<std::byte, 1, void> {
+  using DataType = std::int8_t;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = std::int8_t;
+#endif // __SYCL_DEVICE_ONLY__
 };
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
 
-template <typename T> struct LessThan {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs < Rhs) ? -1 : 0;
-  }
+// Single element signed integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-template <typename T> struct LogicalAnd {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs && Rhs) ? -1 : 0;
-  }
+// Single element unsigned integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-template <typename T> struct LogicalOr {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs || Rhs) ? -1 : 0;
-  }
+// Single element floating-point (except half/bfloat16)
+template <typename T>
+struct VecStorage<
+    T, 1,
+    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
 };
-
-template <typename T> struct RShift {
-  constexpr T operator()(const T &Lhs, const T &Rhs) const {
-    return Lhs >> Rhs;
-  }
+// Multiple elements signed/unsigned integers and floating-point (except
+// half/bfloat16)
+template <typename T, int N>
+struct VecStorage<
+    T, N,
+    typename std::enable_if_t<isValidVectorSize(N) &&
+                              (is_sgeninteger_v<T> ||
+                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
+  using DataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-template <typename T> struct LShift {
-  constexpr T operator()(const T &Lhs, const T &Rhs) const {
-    return Lhs << Rhs;
-  }
+// Single element half
+template <> struct VecStorage<half, 1, void> {
+  using DataType = sycl::detail::half_impl::StorageT;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = sycl::detail::half_impl::StorageT;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-// Forward declarations
-template <typename TransformedArgType, int Dims, typename KernelType>
-class RoundedRangeKernel;
-template <typename TransformedArgType, int Dims, typename KernelType>
-class RoundedRangeKernelWithKH;
+// Multiple elements half
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
+  };
+#else // defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+  };
+#endif // defined(__SYCL_DEVICE_ONLY__)
 
+__SYCL_DEFINE_HALF_VECSTORAGE(2)
+__SYCL_DEFINE_HALF_VECSTORAGE(3)
+__SYCL_DEFINE_HALF_VECSTORAGE(4)
+__SYCL_DEFINE_HALF_VECSTORAGE(8)
+__SYCL_DEFINE_HALF_VECSTORAGE(16)
+#undef __SYCL_DEFINE_HALF_VECSTORAGE
+
+// Single element bfloat16
+template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
+  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  // using VectorDataType = sycl::ext::oneapi::bfloat16;
+  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+};
+// Multiple elements bfloat16
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
+    using VectorDataType =                                                     \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
+  };
+__SYCL_DEFINE_BF16_VECSTORAGE(2)
+__SYCL_DEFINE_BF16_VECSTORAGE(3)
+__SYCL_DEFINE_BF16_VECSTORAGE(4)
+__SYCL_DEFINE_BF16_VECSTORAGE(8)
+__SYCL_DEFINE_BF16_VECSTORAGE(16)
+#undef __SYCL_DEFINE_BF16_VECSTORAGE
 } // namespace detail
 
 template <typename T> using vec_data = detail::vec_helper<T>;
@@ -277,6 +353,7 @@ template <typename T> using vec_data = detail::vec_helper<T>;
 template <typename T>
 using vec_data_t = typename detail::vec_helper<T>::RetType;
 
+///////////////////////// class sycl::vec /////////////////////////
 /// Provides a cross-patform vector class template that works efficiently on
 /// SYCL devices as well as in host C++ code.
 ///
@@ -1298,6 +1375,7 @@ template <typename Type, int NumElements> class vec {
   friend class detail::SwizzleOp;
   template <typename T1, int T2> friend class vec;
 };
+///////////////////////// class sycl::vec /////////////////////////
 
 #ifdef __cpp_deduction_guides
 // all compilers supporting deduction guides also support fold expressions
@@ -1308,6 +1386,80 @@ vec(T, U...) -> vec<T, sizeof...(U) + 1>;
 
 namespace detail {
 
+// Special type for working SwizzleOp with scalars, stores a scalar and gives
+// the scalar at any index. Provides interface is compatible with SwizzleOp
+// operations
+template <typename T> class GetScalarOp {
+public:
+  using DataT = T;
+  GetScalarOp(DataT Data) : m_Data(Data) {}
+  DataT getValue(size_t) const { return m_Data; }
+
+private:
+  DataT m_Data;
+};
+
+template <typename T> struct EqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs == Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct NotEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs != Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs >= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs <= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs > Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs < Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalAnd {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs && Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalOr {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs || Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct RShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs >> Rhs;
+  }
+};
+
+template <typename T> struct LShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs << Rhs;
+  }
+};
+
+///////////////////////// class SwizzleOp /////////////////////////
 // SwizzleOP represents expression templates that operate on vec.
 // Actual computation performed on conversion or assignment operators.
 template <typename VecT, typename OperationLeftT, typename OperationRightT,
@@ -2031,315 +2183,7 @@ class SwizzleOp {
             int... T5>
   friend class SwizzleOp;
 };
+///////////////////////// class SwizzleOp /////////////////////////
 } // namespace detail
-
-namespace detail {
-
-// Vectors of size 1 are handled separately and therefore 1 is not included in
-// the check below.
-constexpr bool isValidVectorSize(int N) {
-  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
-}
-template <typename T, int N, typename V> struct VecStorage {
-  static_assert(
-      isValidVectorSize(N) || N == 1,
-      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
-      "or 16 are supported");
-  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
-};
-
-#ifdef __SYCL_DEVICE_ONLY__
-// device always has ext vector support, but for huge vectors
-// we switch to std::array, so that we can use a smaller alignment (64)
-// this is to support MSVC, which has a max of 64 for direct params.
-template <typename T, int N> struct VecStorageImpl {
-  static constexpr size_t Num = (N == 3) ? 4 : N;
-  static constexpr size_t Sz = Num * sizeof(T);
-  using DataType =
-      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
-                                std::array<T, Num>>::type;
-  using VectorDataType = T __attribute__((ext_vector_type(N)));
-};
-#else // __SYCL_DEVICE_ONLY__
-template <typename T, int N> struct VecStorageImpl {
-  using DataType = std::array<T, (N == 3) ? 4 : N>;
-};
-#endif // __SYCL_DEVICE_ONLY__
-
-// Single element bool
-template <> struct VecStorage<bool, 1, void> {
-  using DataType = bool;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = bool;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple element bool
-template <int N>
-struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
-  using DataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-// Single element byte. Multiple elements will propagate through a later
-// specialization.
-template <> struct VecStorage<std::byte, 1, void> {
-  using DataType = std::int8_t;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = std::int8_t;
-#endif // __SYCL_DEVICE_ONLY__
-};
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-
-// Single element signed integers
-template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element unsigned integers
-template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element floating-point (except half/bfloat16)
-template <typename T>
-struct VecStorage<
-    T, 1,
-    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-// Multiple elements signed/unsigned integers and floating-point (except
-// half/bfloat16)
-template <typename T, int N>
-struct VecStorage<
-    T, N,
-    typename std::enable_if_t<isValidVectorSize(N) &&
-                              (is_sgeninteger_v<T> ||
-                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
-  using DataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element half
-template <> struct VecStorage<half, 1, void> {
-  using DataType = sycl::detail::half_impl::StorageT;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = sycl::detail::half_impl::StorageT;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple elements half
-#if defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
-    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
-  };
-#else // defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
-  };
-#endif // defined(__SYCL_DEVICE_ONLY__)
-
-__SYCL_DEFINE_HALF_VECSTORAGE(2)
-__SYCL_DEFINE_HALF_VECSTORAGE(3)
-__SYCL_DEFINE_HALF_VECSTORAGE(4)
-__SYCL_DEFINE_HALF_VECSTORAGE(8)
-__SYCL_DEFINE_HALF_VECSTORAGE(16)
-#undef __SYCL_DEFINE_HALF_VECSTORAGE
-
-// Single element bfloat16
-template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
-  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-  // using VectorDataType = sycl::ext::oneapi::bfloat16;
-  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-};
-// Multiple elements bfloat16
-#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
-    using VectorDataType =                                                     \
-        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
-  };
-__SYCL_DEFINE_BF16_VECSTORAGE(2)
-__SYCL_DEFINE_BF16_VECSTORAGE(3)
-__SYCL_DEFINE_BF16_VECSTORAGE(4)
-__SYCL_DEFINE_BF16_VECSTORAGE(8)
-__SYCL_DEFINE_BF16_VECSTORAGE(16)
-#undef __SYCL_DEFINE_BF16_VECSTORAGE
-} // namespace detail
-
-/// This macro must be defined to 1 when SYCL implementation allows user
-/// applications to explicitly declare certain class types as device copyable
-/// by adding specializations of is_device_copyable type trait class.
-#define SYCL_DEVICE_COPYABLE 1
-
-/// is_device_copyable is a user specializable class template to indicate
-/// that a type T is device copyable, which means that SYCL implementation
-/// may copy objects of the type T between host and device or between two
-/// devices.
-/// Specializing is_device_copyable such a way that
-/// is_device_copyable_v<T> == true on a T that does not satisfy all
-/// the requirements of a device copyable type is undefined behavior.
-template <typename T> struct is_device_copyable;
-
-namespace detail {
-template <typename T, typename = void>
-struct is_device_copyable_impl : std::is_trivially_copyable<T> {};
-
-template <typename T>
-struct is_device_copyable_impl<
-    T, std::enable_if_t<!std::is_same_v<T, std::remove_cv_t<T>>>>
-    // Cannot express this "recursion" (to take user's partial non-cv
-    // specializations into account) without this helper struct.
-    : is_device_copyable<std::remove_cv_t<T>> {};
-} // namespace detail
-
-template <typename T>
-struct is_device_copyable : detail::is_device_copyable_impl<T> {};
-
-// std::array<T, 0> is implicitly device copyable type.
-template <typename T>
-struct is_device_copyable<std::array<T, 0>> : std::true_type {};
-
-// std::array<T, N> is implicitly device copyable type if T is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<std::array<T, N>> : is_device_copyable<T> {};
-
-// std::optional<T> is implicitly device copyable type if T is device copyable.
-template <typename T>
-struct is_device_copyable<std::optional<T>> : is_device_copyable<T> {};
-
-// std::pair<T1, T2> is implicitly device copyable type if T1 and T2 are device
-// copyable.
-template <typename T1, typename T2>
-struct is_device_copyable<std::pair<T1, T2>>
-    : std::bool_constant<is_device_copyable<T1>::value &&
-                         is_device_copyable<T2>::value> {};
-
-// std::tuple<Ts...> is implicitly device copyable type if each type T of Ts...
-// is device copyable.
-template <typename... Ts>
-struct is_device_copyable<std::tuple<Ts...>>
-    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
-
-// std::variant<Ts...> is implicitly device copyable type if each type T of
-// Ts... is device copyable.
-template <typename... Ts>
-struct is_device_copyable<std::variant<Ts...>>
-    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
-
-// marray is device copyable if element type is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<sycl::marray<T, N>> : is_device_copyable<T> {};
-
-// array is device copyable if element type is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<T[N]> : is_device_copyable<T> {};
-
-template <typename T>
-inline constexpr bool is_device_copyable_v = is_device_copyable<T>::value;
-
-namespace detail {
-template <typename T, typename = void>
-struct IsDeprecatedDeviceCopyable : std::false_type {};
-
-// TODO: using C++ attribute [[deprecated]] or the macro __SYCL2020_DEPRECATED
-// does not produce expected warning message for the type 'T'.
-template <typename T>
-struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
-    IsDeprecatedDeviceCopyable<
-        T, std::enable_if_t<std::is_trivially_copy_constructible_v<T> &&
-                            std::is_trivially_destructible_v<T> &&
-                            !is_device_copyable_v<T>>> : std::true_type {};
-
-template <typename T, int N>
-struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
-    IsDeprecatedDeviceCopyable<T[N]> : IsDeprecatedDeviceCopyable<T> {};
-
-#ifdef __SYCL_DEVICE_ONLY__
-// Checks that the fields of the type T with indices 0 to (NumFieldsToCheck -
-// 1) are device copyable.
-template <typename T, unsigned NumFieldsToCheck>
-struct CheckFieldsAreDeviceCopyable
-    : CheckFieldsAreDeviceCopyable<T, NumFieldsToCheck - 1> {
-  using FieldT = decltype(__builtin_field_type(T, NumFieldsToCheck - 1));
-  static_assert(is_device_copyable_v<FieldT> ||
-                    detail::IsDeprecatedDeviceCopyable<FieldT>::value,
-                "The specified type is not device copyable");
-};
-
-template <typename T> struct CheckFieldsAreDeviceCopyable<T, 0> {};
-
-// Checks that the base classes of the type T with indices 0 to
-// (NumFieldsToCheck - 1) are device copyable.
-template <typename T, unsigned NumBasesToCheck>
-struct CheckBasesAreDeviceCopyable
-    : CheckBasesAreDeviceCopyable<T, NumBasesToCheck - 1> {
-  using BaseT = decltype(__builtin_base_type(T, NumBasesToCheck - 1));
-  static_assert(is_device_copyable_v<BaseT> ||
-                    detail::IsDeprecatedDeviceCopyable<BaseT>::value,
-                "The specified type is not device copyable");
-};
-
-template <typename T> struct CheckBasesAreDeviceCopyable<T, 0> {};
-
-// All the captures of a lambda or functor of type FuncT passed to a kernel
-// must be is_device_copyable, which extends to bases and fields of FuncT.
-// Fields are captures of lambda/functors and bases are possible base classes
-// of functors also allowed by SYCL.
-// The SYCL-2020 implementation must check each of the fields & bases of the
-// type FuncT, only one level deep, which is enough to see if they are all
-// device copyable by using the result of is_device_copyable returned for them.
-// At this moment though the check also allowes using types for which
-// (is_trivially_copy_constructible && is_trivially_destructible) returns true
-// and (is_device_copyable) returns false. That is the deprecated behavior and
-// is currently/temporarily supported only to not break older SYCL programs.
-template <typename FuncT>
-struct CheckDeviceCopyable
-    : CheckFieldsAreDeviceCopyable<FuncT, __builtin_num_fields(FuncT)>,
-      CheckBasesAreDeviceCopyable<FuncT, __builtin_num_bases(FuncT)> {};
-
-// Below are two specializations for CheckDeviceCopyable when a kernel lambda
-// is wrapped after range rounding optimization.
-template <typename TransformedArgType, int Dims, typename KernelType>
-struct CheckDeviceCopyable<
-    RoundedRangeKernel<TransformedArgType, Dims, KernelType>>
-    : CheckDeviceCopyable<KernelType> {};
-
-template <typename TransformedArgType, int Dims, typename KernelType>
-struct CheckDeviceCopyable<
-    RoundedRangeKernelWithKH<TransformedArgType, Dims, KernelType>>
-    : CheckDeviceCopyable<KernelType> {};
-
-#endif // __SYCL_DEVICE_ONLY__
-} // namespace detail
-
 } // namespace _V1
 } // namespace sycl

From b0dc2f9dd02cd334f0b90f59ade1486c180929fb Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 24 Apr 2024 10:19:54 -0700
Subject: [PATCH 26/79] Fix formatting and LIT tests

---
 sycl/include/sycl/vector.hpp                    | 4 ++--
 sycl/test/include_deps/sycl_accessor.hpp.cpp    | 3 ++-
 sycl/test/include_deps/sycl_detail_core.hpp.cpp | 3 ++-
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/sycl/include/sycl/vector.hpp b/sycl/include/sycl/vector.hpp
index 9958ac55ae125..f1bf7fcfcc24d 100644
--- a/sycl/include/sycl/vector.hpp
+++ b/sycl/include/sycl/vector.hpp
@@ -213,7 +213,7 @@ template <typename T, int N> struct VecStorageImpl {
                                 std::array<T, Num>>::type;
   using VectorDataType = T __attribute__((ext_vector_type(N)));
 };
-#else // __SYCL_DEVICE_ONLY__
+#else  // __SYCL_DEVICE_ONLY__
 template <typename T, int N> struct VecStorageImpl {
   using DataType = std::array<T, (N == 3) ? 4 : N>;
 };
@@ -1321,7 +1321,7 @@ template <typename Type, int NumElements> class vec {
   constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
     return vec_data<DataT>::get(m_Data.s[Index]);
   }
-#else // __SYCL_USE_EXT_VECTOR_TYPE__
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
   template <int Num = NumElements,
             typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(int Index, const DataT &Value, int) {
diff --git a/sycl/test/include_deps/sycl_accessor.hpp.cpp b/sycl/test/include_deps/sycl_accessor.hpp.cpp
index 1b4606d57cafc..7bab1f08b2678 100644
--- a/sycl/test/include_deps/sycl_accessor.hpp.cpp
+++ b/sycl/test/include_deps/sycl_accessor.hpp.cpp
@@ -120,9 +120,10 @@
 // CHECK-NEXT: detail/backend_traits.hpp
 // CHECK-NEXT: sampler.hpp
 // CHECK-NEXT: types.hpp
+// CHECK-NEXT: marray.hpp
+// CHECK-NEXT: vector.hpp
 // CHECK-NEXT: detail/memcpy.hpp
 // CHECK-NEXT: detail/vector_convert.hpp
-// CHECK-NEXT: marray.hpp
 // CHECK-NEXT: swizzles.def
 // CHECK-NEXT: pointers.hpp
 // CHECK-NEXT: properties/accessor_properties.hpp
diff --git a/sycl/test/include_deps/sycl_detail_core.hpp.cpp b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
index 7bd3b9d9392e2..77dd3853138d6 100644
--- a/sycl/test/include_deps/sycl_detail_core.hpp.cpp
+++ b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
@@ -121,9 +121,10 @@
 // CHECK-NEXT: detail/backend_traits.hpp
 // CHECK-NEXT: sampler.hpp
 // CHECK-NEXT: types.hpp
+// CHECK-NEXT: marray.hpp
+// CHECK-NEXT: vector.hpp
 // CHECK-NEXT: detail/memcpy.hpp
 // CHECK-NEXT: detail/vector_convert.hpp
-// CHECK-NEXT: marray.hpp
 // CHECK-NEXT: swizzles.def
 // CHECK-NEXT: pointers.hpp
 // CHECK-NEXT: properties/accessor_properties.hpp

From aa43da10718ebdb84c9e022728372f53775e6beb Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 24 Apr 2024 10:40:01 -0700
Subject: [PATCH 27/79] Create a seperate header for ABI breaking changes.

---
 sycl/include/sycl/types.hpp          |    4 +
 sycl/include/sycl/vector_preview.hpp | 2189 ++++++++++++++++++++++++++
 2 files changed, 2193 insertions(+)
 create mode 100644 sycl/include/sycl/vector_preview.hpp

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index f13910d04c33d..677be2bf35ceb 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -21,7 +21,11 @@
 #include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
 #include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
 #include <sycl/multi_ptr.hpp>                  // for multi_ptr
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+#include <sycl/vector_preview.hpp>             // for sycl::vec and swizzles
+#else
 #include <sycl/vector.hpp>                     // for sycl::vec and swizzles
+#endif
 
 #include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
 
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
new file mode 100644
index 0000000000000..f1bf7fcfcc24d
--- /dev/null
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -0,0 +1,2189 @@
+//==---------------- vector.hpp --- Implements sycl::vec -------------------==//
+//
+// 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
+
+// Check if Clang's ext_vector_type attribute is available. Host compiler
+// may not be Clang, and Clang may not be built with the extension.
+#ifdef __clang__
+#ifndef __has_extension
+#define __has_extension(x) 0
+#endif
+#ifdef __HAS_EXT_VECTOR_TYPE__
+#error "Undefine __HAS_EXT_VECTOR_TYPE__ macro"
+#endif
+#if __has_extension(attribute_ext_vector_type)
+#define __HAS_EXT_VECTOR_TYPE__
+#endif
+#endif // __clang__
+
+#if !defined(__HAS_EXT_VECTOR_TYPE__) && defined(__SYCL_DEVICE_ONLY__)
+#error "SYCL device compiler is built without ext_vector_type support"
+#endif
+
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_USE_EXT_VECTOR_TYPE__
+#endif
+
+#include <sycl/access/access.hpp>              // for decorated, address_space
+#include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
+#include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
+#include <sycl/detail/defines_elementary.hpp>  // for __SYCL2020_DEPRECATED
+#include <sycl/detail/generic_type_lists.hpp>  // for vector_basic_list
+#include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
+#include <sycl/detail/memcpy.hpp>              // for memcpy
+#include <sycl/detail/type_list.hpp>           // for is_contained
+#include <sycl/detail/type_traits.hpp>         // for is_floating_point
+#include <sycl/detail/vector_convert.hpp>      // for convertImpl
+#include <sycl/detail/vector_traits.hpp>       // for vector_alignment
+#include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
+
+#include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
+
+#include <array>       // for array
+#include <assert.h>    // for assert
+#include <cstddef>     // for size_t, NULL, byte
+#include <cstdint>     // for uint8_t, int16_t, int...
+#include <functional>  // for divides, multiplies
+#include <iterator>    // for pair
+#include <ostream>     // for operator<<, basic_ost...
+#include <type_traits> // for enable_if_t, is_same
+#include <utility>     // for index_sequence, make_...
+
+namespace sycl {
+inline namespace _V1 {
+
+struct elem {
+  static constexpr int x = 0;
+  static constexpr int y = 1;
+  static constexpr int z = 2;
+  static constexpr int w = 3;
+  static constexpr int r = 0;
+  static constexpr int g = 1;
+  static constexpr int b = 2;
+  static constexpr int a = 3;
+  static constexpr int s0 = 0;
+  static constexpr int s1 = 1;
+  static constexpr int s2 = 2;
+  static constexpr int s3 = 3;
+  static constexpr int s4 = 4;
+  static constexpr int s5 = 5;
+  static constexpr int s6 = 6;
+  static constexpr int s7 = 7;
+  static constexpr int s8 = 8;
+  static constexpr int s9 = 9;
+  static constexpr int sA = 10;
+  static constexpr int sB = 11;
+  static constexpr int sC = 12;
+  static constexpr int sD = 13;
+  static constexpr int sE = 14;
+  static constexpr int sF = 15;
+};
+
+namespace detail {
+// select_apply_cl_t selects from T8/T16/T32/T64 basing on
+// sizeof(_IN).  expected to handle scalar types in _IN.
+template <typename _IN, typename T8, typename T16, typename T32, typename T64>
+using select_apply_cl_t = std::conditional_t<
+    sizeof(_IN) == 1, T8,
+    std::conditional_t<sizeof(_IN) == 2, T16,
+                       std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
+
+template <typename T> struct vec_helper {
+  using RetType = T;
+  static constexpr RetType get(T value) { return value; }
+  static constexpr RetType set(T value) { return value; }
+};
+template <> struct vec_helper<bool> {
+  using RetType = select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                    std::int32_t, std::int64_t>;
+  static constexpr RetType get(bool value) { return value; }
+  static constexpr RetType set(bool value) { return value; }
+};
+
+template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
+  using RetType = sycl::ext::oneapi::bfloat16;
+  using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  static constexpr RetType get(BFloat16StorageT value) {
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<RetType>(value);
+#else
+    // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+    // but neither available yet.
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.storage = value;
+    return result.bf16;
+#endif
+  }
+
+  static constexpr RetType get(RetType value) { return value; }
+
+  static constexpr BFloat16StorageT set(RetType value) {
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<BFloat16StorageT>(value);
+#else
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.bf16 = value;
+    return result.storage;
+#endif
+  }
+};
+
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+template <> struct vec_helper<std::byte> {
+  using RetType = std::uint8_t;
+  static constexpr RetType get(std::byte value) { return (RetType)value; }
+  static constexpr RetType set(std::byte value) { return (RetType)value; }
+  static constexpr std::byte get(std::uint8_t value) {
+    return (std::byte)value;
+  }
+  static constexpr std::byte set(std::uint8_t value) {
+    return (std::byte)value;
+  }
+};
+#endif
+
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp;
+
+template <typename T, int N, typename V = void> struct VecStorage;
+
+// Element type for relational operator return value.
+template <typename DataT>
+using rel_t = typename std::conditional_t<
+    sizeof(DataT) == sizeof(opencl::cl_char), opencl::cl_char,
+    typename std::conditional_t<
+        sizeof(DataT) == sizeof(opencl::cl_short), opencl::cl_short,
+        typename std::conditional_t<
+            sizeof(DataT) == sizeof(opencl::cl_int), opencl::cl_int,
+            typename std::conditional_t<sizeof(DataT) ==
+                                            sizeof(opencl::cl_long),
+                                        opencl::cl_long, bool>>>>;
+
+// Special type indicating that SwizzleOp should just read value from vector -
+// not trying to perform any operations. Should not be called.
+template <typename T> class GetOp {
+public:
+  using DataT = T;
+  DataT getValue(size_t) const { return (DataT)0; }
+  DataT operator()(DataT, DataT) { return (DataT)0; }
+};
+
+// Forward declarations
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernel;
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernelWithKH;
+
+// Vectors of size 1 are handled separately and therefore 1 is not included in
+// the check below.
+constexpr bool isValidVectorSize(int N) {
+  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
+}
+template <typename T, int N, typename V> struct VecStorage {
+  static_assert(
+      isValidVectorSize(N) || N == 1,
+      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
+      "or 16 are supported");
+  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
+};
+
+#ifdef __SYCL_DEVICE_ONLY__
+// device always has ext vector support, but for huge vectors
+// we switch to std::array, so that we can use a smaller alignment (64)
+// this is to support MSVC, which has a max of 64 for direct params.
+template <typename T, int N> struct VecStorageImpl {
+  static constexpr size_t Num = (N == 3) ? 4 : N;
+  static constexpr size_t Sz = Num * sizeof(T);
+  using DataType =
+      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
+                                std::array<T, Num>>::type;
+  using VectorDataType = T __attribute__((ext_vector_type(N)));
+};
+#else  // __SYCL_DEVICE_ONLY__
+template <typename T, int N> struct VecStorageImpl {
+  using DataType = std::array<T, (N == 3) ? 4 : N>;
+};
+#endif // __SYCL_DEVICE_ONLY__
+
+// Single element bool
+template <> struct VecStorage<bool, 1, void> {
+  using DataType = bool;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = bool;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Multiple element bool
+template <int N>
+struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
+  using DataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+// Single element byte. Multiple elements will propagate through a later
+// specialization.
+template <> struct VecStorage<std::byte, 1, void> {
+  using DataType = std::int8_t;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = std::int8_t;
+#endif // __SYCL_DEVICE_ONLY__
+};
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+
+// Single element signed integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element unsigned integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element floating-point (except half/bfloat16)
+template <typename T>
+struct VecStorage<
+    T, 1,
+    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+// Multiple elements signed/unsigned integers and floating-point (except
+// half/bfloat16)
+template <typename T, int N>
+struct VecStorage<
+    T, N,
+    typename std::enable_if_t<isValidVectorSize(N) &&
+                              (is_sgeninteger_v<T> ||
+                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
+  using DataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element half
+template <> struct VecStorage<half, 1, void> {
+  using DataType = sycl::detail::half_impl::StorageT;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = sycl::detail::half_impl::StorageT;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Multiple elements half
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
+  };
+#else // defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+  };
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+__SYCL_DEFINE_HALF_VECSTORAGE(2)
+__SYCL_DEFINE_HALF_VECSTORAGE(3)
+__SYCL_DEFINE_HALF_VECSTORAGE(4)
+__SYCL_DEFINE_HALF_VECSTORAGE(8)
+__SYCL_DEFINE_HALF_VECSTORAGE(16)
+#undef __SYCL_DEFINE_HALF_VECSTORAGE
+
+// Single element bfloat16
+template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
+  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  // using VectorDataType = sycl::ext::oneapi::bfloat16;
+  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+};
+// Multiple elements bfloat16
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
+    using VectorDataType =                                                     \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
+  };
+__SYCL_DEFINE_BF16_VECSTORAGE(2)
+__SYCL_DEFINE_BF16_VECSTORAGE(3)
+__SYCL_DEFINE_BF16_VECSTORAGE(4)
+__SYCL_DEFINE_BF16_VECSTORAGE(8)
+__SYCL_DEFINE_BF16_VECSTORAGE(16)
+#undef __SYCL_DEFINE_BF16_VECSTORAGE
+} // namespace detail
+
+template <typename T> using vec_data = detail::vec_helper<T>;
+
+template <typename T>
+using vec_data_t = typename detail::vec_helper<T>::RetType;
+
+///////////////////////// class sycl::vec /////////////////////////
+/// Provides a cross-patform vector class template that works efficiently on
+/// SYCL devices as well as in host C++ code.
+///
+/// \ingroup sycl_api
+template <typename Type, int NumElements> class vec {
+  using DataT = Type;
+
+  // This represent type of underlying value. There should be only one field
+  // in the class, so vec<float, 16> should be equal to float16 in memory.
+  using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
+
+  static constexpr bool IsHostHalf =
+      std::is_same_v<DataT, sycl::detail::half_impl::half> &&
+      std::is_same_v<sycl::detail::half_impl::StorageT,
+                     sycl::detail::host_half_impl::half>;
+
+  static constexpr bool IsBfloat16 =
+      std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
+
+  static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
+  static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
+  static constexpr bool IsSizeGreaterThanMaxAlign =
+      (Sz > detail::MaxVecAlignment);
+
+  // TODO: There is no support for vector half type on host yet.
+  // Also, when Sz is greater than alignment, we use std::array instead of
+  // vector extension. This is for MSVC compatibility, which has a max alignment
+  // of 64 for direct params. If we drop MSVC, we can have alignment the same as
+  // size and use vector extensions for all sizes.
+  static constexpr bool IsUsingArrayOnDevice =
+      (IsHostHalf || IsBfloat16 || IsSizeGreaterThanMaxAlign);
+
+#if defined(__SYCL_DEVICE_ONLY__)
+  static constexpr bool NativeVec = NumElements > 1 && !IsUsingArrayOnDevice;
+  static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
+#else
+  static constexpr bool NativeVec = false;
+  static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
+#endif
+
+  static constexpr int getNumElements() { return NumElements; }
+
+  // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
+  template <int Counter, int MaxValue, class...>
+  struct SizeChecker : std::conditional_t<Counter == MaxValue, std::true_type,
+                                          std::false_type> {};
+
+  template <int Counter, int MaxValue, typename DataT_, class... tail>
+  struct SizeChecker<Counter, MaxValue, DataT_, tail...>
+      : std::conditional_t<Counter + 1 <= MaxValue,
+                           SizeChecker<Counter + 1, MaxValue, tail...>,
+                           std::false_type> {};
+
+  // Utility trait for creating an std::array from an vector argument.
+  template <typename DataT_, typename T, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const vec<T, sizeof...(Is)> &V, std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &V,
+             std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &V,
+             std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N>
+  static constexpr std::array<DataT_, N>
+  FlattenVecArgHelper(const vec<T, N> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<N>());
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5>
+  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
+      const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5>
+  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
+      const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
+  }
+  template <typename DataT_, typename T>
+  static constexpr auto FlattenVecArgHelper(const T &A) {
+    return std::array<DataT_, 1>{vec_data<DataT_>::get(static_cast<DataT_>(A))};
+  }
+  template <typename DataT_, typename T> struct FlattenVecArg {
+    constexpr auto operator()(const T &A) const {
+      return FlattenVecArgHelper<DataT_>(A);
+    }
+  };
+
+  // Alias for shortening the vec arguments to array converter.
+  template <typename DataT_, typename... ArgTN>
+  using VecArgArrayCreator =
+      detail::ArrayCreator<DataT_, FlattenVecArg, ArgTN...>;
+
+#define __SYCL_ALLOW_VECTOR_SIZES(num_elements)                                \
+  template <int Counter, int MaxValue, typename DataT_, class... tail>         \
+  struct SizeChecker<Counter, MaxValue, vec<DataT_, num_elements>, tail...>    \
+      : std::conditional_t<                                                    \
+            Counter + (num_elements) <= MaxValue,                              \
+            SizeChecker<Counter + (num_elements), MaxValue, tail...>,          \
+            std::false_type> {};                                               \
+  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
+            typename T3, template <typename> class T4, int... T5,              \
+            class... tail>                                                     \
+  struct SizeChecker<                                                          \
+      Counter, MaxValue,                                                       \
+      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>,         \
+      tail...>                                                                 \
+      : std::conditional_t<                                                    \
+            Counter + sizeof...(T5) <= MaxValue,                               \
+            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
+            std::false_type> {};                                               \
+  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
+            typename T3, template <typename> class T4, int... T5,              \
+            class... tail>                                                     \
+  struct SizeChecker<                                                          \
+      Counter, MaxValue,                                                       \
+      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
+      tail...>                                                                 \
+      : std::conditional_t<                                                    \
+            Counter + sizeof...(T5) <= MaxValue,                               \
+            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
+            std::false_type> {};
+
+  __SYCL_ALLOW_VECTOR_SIZES(1)
+  __SYCL_ALLOW_VECTOR_SIZES(2)
+  __SYCL_ALLOW_VECTOR_SIZES(3)
+  __SYCL_ALLOW_VECTOR_SIZES(4)
+  __SYCL_ALLOW_VECTOR_SIZES(8)
+  __SYCL_ALLOW_VECTOR_SIZES(16)
+#undef __SYCL_ALLOW_VECTOR_SIZES
+
+  // TypeChecker is needed for vec(const argTN &... args) ctor to validate args.
+  template <typename T, typename DataT_>
+  struct TypeChecker : std::is_convertible<T, DataT_> {};
+#define __SYCL_ALLOW_VECTOR_TYPES(num_elements)                                \
+  template <typename DataT_>                                                   \
+  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {};   \
+  template <typename DataT_, typename T2, typename T3,                         \
+            template <typename> class T4, int... T5>                           \
+  struct TypeChecker<                                                          \
+      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
+      : std::true_type {};                                                     \
+  template <typename DataT_, typename T2, typename T3,                         \
+            template <typename> class T4, int... T5>                           \
+  struct TypeChecker<                                                          \
+      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
+      DataT_> : std::true_type {};
+
+  __SYCL_ALLOW_VECTOR_TYPES(1)
+  __SYCL_ALLOW_VECTOR_TYPES(2)
+  __SYCL_ALLOW_VECTOR_TYPES(3)
+  __SYCL_ALLOW_VECTOR_TYPES(4)
+  __SYCL_ALLOW_VECTOR_TYPES(8)
+  __SYCL_ALLOW_VECTOR_TYPES(16)
+#undef __SYCL_ALLOW_VECTOR_TYPES
+
+  template <int... Indexes>
+  using Swizzle =
+      detail::SwizzleOp<vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
+                        detail::GetOp, Indexes...>;
+
+  template <int... Indexes>
+  using ConstSwizzle =
+      detail::SwizzleOp<const vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
+                        detail::GetOp, Indexes...>;
+
+  // Shortcuts for args validation in vec(const argTN &... args) ctor.
+  template <typename... argTN>
+  using EnableIfSuitableTypes = typename std::enable_if_t<
+      std::conjunction_v<TypeChecker<argTN, DataT>...>>;
+
+  template <typename... argTN>
+  using EnableIfSuitableNumElements =
+      typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
+
+  template <size_t... Is>
+  constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
+                std::index_sequence<Is...>)
+      : m_Data{([&](vec_data_t<DataT> v) constexpr {
+          if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
+            return v.value;
+          else
+            return vec_data_t<DataT>(static_cast<DataT>(v));
+        })(Arr[Is])...} {}
+
+public:
+  using element_type = DataT;
+  using value_type = DataT;
+  using rel_t = detail::rel_t<DataT>;
+#ifdef __SYCL_DEVICE_ONLY__
+  using vector_t =
+      typename detail::VecStorage<DataT, NumElements>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+
+  vec() = default;
+
+  constexpr vec(const vec &Rhs) = default;
+  constexpr vec(vec &&Rhs) = default;
+
+  constexpr vec &operator=(const vec &Rhs) = default;
+
+  // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
+  template <typename Ty = DataT>
+  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
+                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
+                            vec &>
+  operator=(const vec<rel_t, NumElements> &Rhs) {
+    *this = Rhs.template as<vec>();
+    return *this;
+  }
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <typename T = void>
+  using EnableIfNotHostHalf = typename std::enable_if_t<!IsHostHalf, T>;
+
+  template <typename T = void>
+  using EnableIfHostHalf = typename std::enable_if_t<IsHostHalf, T>;
+
+  template <typename T = void>
+  using EnableIfUsingArrayOnDevice =
+      typename std::enable_if_t<IsUsingArrayOnDevice, T>;
+
+  template <typename T = void>
+  using EnableIfNotUsingArrayOnDevice =
+      typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  template <typename T = void>
+  using EnableIfUsingArray =
+      typename std::enable_if_t<IsUsingArrayOnDevice || IsUsingArrayOnHost, T>;
+
+  template <typename T = void>
+  using EnableIfNotUsingArray =
+      typename std::enable_if_t<!IsUsingArrayOnDevice && !IsUsingArrayOnHost,
+                                T>;
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+
+  template <typename Ty = DataT>
+  explicit constexpr vec(const EnableIfNotUsingArrayOnDevice<Ty> &arg)
+      : m_Data{DataType(vec_data<Ty>::get(arg))} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) {
+    m_Data = (DataType)vec_data<Ty>::get(Rhs);
+    return *this;
+  }
+
+  template <typename Ty = DataT>
+  explicit constexpr vec(const EnableIfUsingArrayOnDevice<Ty> &arg)
+      : vec{detail::RepeatValue<NumElements>(
+                static_cast<vec_data_t<DataT>>(arg)),
+            std::make_index_sequence<NumElements>()} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
+    for (int i = 0; i < NumElements; ++i) {
+      setValue(i, Rhs);
+    }
+    return *this;
+  }
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+  explicit constexpr vec(const DataT &arg)
+      : vec{detail::RepeatValue<NumElements>(
+                static_cast<vec_data_t<DataT>>(arg)),
+            std::make_index_sequence<NumElements>()} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const DataT &Rhs) {
+    for (int i = 0; i < NumElements; ++i) {
+      setValue(i, Rhs);
+    }
+    return *this;
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  // Optimized naive constructors with NumElements of DataT values.
+  // We don't expect compilers to optimize vararg recursive functions well.
+
+  // Helper type to make specific constructors available only for specific
+  // number of elements.
+  template <int IdxNum, typename T = void>
+  using EnableIfMultipleElems = typename std::enable_if_t<
+      std::is_convertible_v<T, DataT> && NumElements == IdxNum, DataT>;
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<2, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<3, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<4, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const Ty Arg3)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<8, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const DataT Arg3, const DataT Arg4, const DataT Arg5,
+                const DataT Arg6, const DataT Arg7)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
+               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
+               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<16, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const DataT Arg3, const DataT Arg4, const DataT Arg5,
+                const DataT Arg6, const DataT Arg7, const DataT Arg8,
+                const DataT Arg9, const DataT ArgA, const DataT ArgB,
+                const DataT ArgC, const DataT ArgD, const DataT ArgE,
+                const DataT ArgF)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
+               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
+               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7),
+               vec_data<Ty>::get(Arg8), vec_data<Ty>::get(Arg9),
+               vec_data<Ty>::get(ArgA), vec_data<Ty>::get(ArgB),
+               vec_data<Ty>::get(ArgC), vec_data<Ty>::get(ArgD),
+               vec_data<Ty>::get(ArgE), vec_data<Ty>::get(ArgF)} {}
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // Constructor from values of base type or vec of base type. Checks that
+  // base types are match and that the NumElements == sum of lengths of args.
+  template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
+            typename = EnableIfSuitableNumElements<argTN...>>
+  constexpr vec(const argTN &...args)
+      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
+            std::make_index_sequence<NumElements>()} {}
+
+#ifdef __SYCL_DEVICE_ONLY__
+  template <typename vector_t_ = vector_t,
+            typename =
+                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
+                                          !std::is_same_v<vector_t_, DataT>>>
+  constexpr vec(vector_t openclVector) {
+    if constexpr (!IsUsingArrayOnDevice) {
+      m_Data = openclVector;
+    } else {
+      m_Data = bit_cast<DataType>(openclVector);
+    }
+  }
+
+  operator vector_t() const {
+    if constexpr (!IsUsingArrayOnDevice) {
+      return m_Data;
+    } else {
+      auto ptr = bit_cast<const vector_t *>((&m_Data)->data());
+      return *ptr;
+    }
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
+  // Available only when: NumElements == 1
+  template <int N = NumElements>
+  operator typename std::enable_if_t<N == 1, DataT>() const {
+    return vec_data<DataT>::get(m_Data);
+  }
+
+  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
+  static constexpr size_t get_count() { return size(); }
+  static constexpr size_t size() noexcept { return NumElements; }
+  __SYCL2020_DEPRECATED(
+      "get_size() is deprecated, please use byte_size() instead")
+  static constexpr size_t get_size() { return byte_size(); }
+  static constexpr size_t byte_size() noexcept { return sizeof(m_Data); }
+
+  // convertImpl can't be called with the same From and To types and therefore
+  // we need this version of convert which is mostly no-op.
+  template <typename convertT,
+            rounding_mode roundingMode = rounding_mode::automatic>
+  std::enable_if_t<
+      std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> ||
+          std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
+                         detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      vec<convertT, NumElements>>
+  convert() const {
+    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+                      detail::is_floating_point<convertT>::value,
+                  "Unsupported convertT");
+    if constexpr (!std::is_same_v<DataT, convertT>) {
+      // Dummy conversion for cases like vec<signed char> -> vec<char>
+      vec<convertT, NumElements> Result;
+      for (size_t I = 0; I < NumElements; ++I)
+        Result.setValue(I, static_cast<convertT>(getValue(I)));
+
+      return Result;
+    } else {
+      // No conversion necessary
+      return *this;
+    }
+  }
+
+  template <typename convertT,
+            rounding_mode roundingMode = rounding_mode::automatic>
+  std::enable_if_t<
+      !std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> &&
+          !std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
+                          detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      vec<convertT, NumElements>>
+  convert() const {
+    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+                      detail::is_floating_point<convertT>::value,
+                  "Unsupported convertT");
+    using T = vec_data_t<DataT>;
+    using R = vec_data_t<convertT>;
+    using OpenCLT = detail::ConvertToOpenCLType_t<T>;
+    using OpenCLR = detail::ConvertToOpenCLType_t<R>;
+    vec<convertT, NumElements> Result;
+
+#if defined(__SYCL_DEVICE_ONLY__)
+    using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
+    using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
+    // Whole vector conversion can only be done, if:
+    constexpr bool canUseNativeVectorConvert =
+#ifdef __NVPTX__
+        // - we are not on CUDA, see intel/llvm#11840
+        false &&
+#endif
+        // - both vectors are represented using native vector types;
+        NativeVec && vec<convertT, NumElements>::NativeVec &&
+        // - vec storage has an equivalent OpenCL native vector it is implicitly
+        //   convertible to. There are some corner cases where it is not the
+        //   case with char, long and long long types.
+        std::is_convertible_v<decltype(m_Data), OpenCLVecT> &&
+        std::is_convertible_v<decltype(Result.m_Data), OpenCLVecR> &&
+        // - it is not a signed to unsigned (or vice versa) conversion
+        //   see comments within 'convertImpl' for more details;
+        !detail::is_sint_to_from_uint<T, R>::value &&
+        // - destination type is not bool. bool is stored as integer under the
+        //   hood and therefore conversion to bool looks like conversion between
+        //   two integer types. Since bit pattern for true and false is not
+        //   defined, there is no guarantee that integer conversion yields
+        //   right results here;
+        !std::is_same_v<convertT, bool>;
+    if constexpr (canUseNativeVectorConvert) {
+      Result.m_Data = detail::convertImpl<T, R, roundingMode, NumElements,
+                                          OpenCLVecT, OpenCLVecR>(m_Data);
+    } else
+#endif // defined(__SYCL_DEVICE_ONLY__)
+    {
+      // Otherwise, we fallback to per-element conversion:
+      for (size_t I = 0; I < NumElements; ++I) {
+        Result.setValue(
+            I, vec_data<convertT>::get(
+                   detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
+                       vec_data<DataT>::get(getValue(I)))));
+      }
+    }
+
+    return Result;
+  }
+
+  template <typename asT> asT as() const {
+    static_assert((sizeof(*this) == sizeof(asT)),
+                  "The new SYCL vec type must have the same storage size in "
+                  "bytes as this SYCL vec");
+    static_assert(
+        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
+            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
+        "asT must be SYCL vec of a different element type and "
+        "number of elements specified by asT");
+    asT Result;
+    detail::memcpy(&Result.m_Data, &m_Data, sizeof(decltype(Result.m_Data)));
+    return Result;
+  }
+
+  template <int... SwizzleIndexes> Swizzle<SwizzleIndexes...> swizzle() {
+    return this;
+  }
+
+  template <int... SwizzleIndexes>
+  ConstSwizzle<SwizzleIndexes...> swizzle() const {
+    return this;
+  }
+
+  // ext_vector_type is used as an underlying type for sycl::vec on device.
+  // The problem is that for clang vector types the return of operator[] is a
+  // temporary and not a reference to the element in the vector. In practice
+  // reinterpret_cast<DataT *>(&m_Data)[i]; is working. According to
+  // http://llvm.org/docs/GetElementPtr.html#can-gep-index-into-vector-elements
+  // this is not disallowed now. But could probably be disallowed in the future.
+  // That is why tests are added to check that behavior of the compiler has
+  // not changed.
+  //
+  // Implement operator [] in the same way for host and device.
+  // TODO: change host side implementation when underlying type for host side
+  // will be changed to std::array.
+  // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
+  // aggressively optimized. Specializing with noinline to avoid as workaround.
+
+  template <typename T = DataT>
+  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                            const DataT &>
+  operator[](int i) const {
+    return reinterpret_cast<const DataT *>(&m_Data)[i];
+  }
+
+  template <typename T = DataT>
+  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                            DataT &>
+  operator[](int i) {
+    return reinterpret_cast<DataT *>(&m_Data)[i];
+  }
+
+#ifdef _MSC_VER
+#define __SYCL_NOINLINE_BF16 __declspec(noinline)
+#else
+#define __SYCL_NOINLINE_BF16 __attribute__((noinline))
+#endif
+
+  template <typename T = DataT>
+  __SYCL_NOINLINE_BF16
+      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                const DataT &>
+      operator[](int i) const {
+    return reinterpret_cast<const DataT *>(&m_Data)[i];
+  }
+
+  template <typename T = DataT>
+  __SYCL_NOINLINE_BF16
+      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                DataT &>
+      operator[](int i) {
+    return reinterpret_cast<DataT *>(&m_Data)[i];
+  }
+
+#undef __SYCL_NOINLINE_BF16
+
+  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
+private:
+  // Indexer used in the swizzles.def
+  // Currently it is defined as a template struct. Replacing it with a constexpr
+  // function would activate a bug in MSVC that is fixed only in v19.20.
+  // Until then MSVC does not recognize such constexpr functions as const and
+  // thus does not let using them in template parameters inside swizzle.def.
+  template <int Index> struct Indexer {
+    static constexpr int value = Index;
+  };
+
+public:
+#ifdef __SYCL_ACCESS_RETURN
+#error "Undefine __SYCL_ACCESS_RETURN macro"
+#endif
+#define __SYCL_ACCESS_RETURN this
+#include "swizzles.def"
+#undef __SYCL_ACCESS_RETURN
+  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
+
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t Offset, multi_ptr<const DataT, Space, DecorateAddress> Ptr) {
+    for (int I = 0; I < NumElements; I++) {
+      setValue(I, *multi_ptr<const DataT, Space, DecorateAddress>(
+                      Ptr + Offset * NumElements + I));
+    }
+  }
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t Offset, multi_ptr<DataT, Space, DecorateAddress> Ptr) {
+    multi_ptr<const DataT, Space, DecorateAddress> ConstPtr(Ptr);
+    load(Offset, ConstPtr);
+  }
+  template <int Dimensions, access::mode Mode,
+            access::placeholder IsPlaceholder, access::target Target,
+            typename PropertyListT>
+  void
+  load(size_t Offset,
+       accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
+           Acc) {
+    multi_ptr<const DataT, detail::TargetToAS<Target>::AS,
+              access::decorated::yes>
+        MultiPtr(Acc);
+    load(Offset, MultiPtr);
+  }
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void store(size_t Offset,
+             multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
+    for (int I = 0; I < NumElements; I++) {
+      *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
+                                                I) = getValue(I);
+    }
+  }
+  template <int Dimensions, access::mode Mode,
+            access::placeholder IsPlaceholder, access::target Target,
+            typename PropertyListT>
+  void
+  store(size_t Offset,
+        accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
+            Acc) {
+    multi_ptr<DataT, detail::TargetToAS<Target>::AS, access::decorated::yes>
+        MultiPtr(Acc);
+    store(Offset, MultiPtr);
+  }
+
+  void ConvertToDataT() {
+    for (size_t i = 0; i < NumElements; ++i) {
+      DataT tmp = getValue(i);
+      setValue(i, tmp);
+    }
+  }
+
+#ifdef __SYCL_BINOP
+#error "Undefine __SYCL_BINOP macro"
+#endif
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
+  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+    vec Ret;                                                                   \
+    if constexpr (IsUsingArrayOnDevice) {                                      \
+      for (size_t I = 0; I < NumElements; ++I) {                               \
+        Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
+      }                                                                        \
+    } else {                                                                   \
+      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+      if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
+        Ret.ConvertToDataT();                                                  \
+      }                                                                        \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+    return Lhs BINOP vec(Rhs);                                                 \
+  }                                                                            \
+  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+    return vec(Lhs) BINOP Rhs;                                                 \
+  }                                                                            \
+  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+    Lhs = Lhs BINOP Rhs;                                                       \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <int Num = NumElements>                                             \
+  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
+      vec & Lhs, const DataT & Rhs) {                                          \
+    Lhs = Lhs BINOP vec(Rhs);                                                  \
+    return Lhs;                                                                \
+  }
+
+#else // __SYCL_USE_EXT_VECTOR_TYPE__
+
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
+  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+    vec Ret{};                                                                 \
+    if constexpr (NativeVec)                                                   \
+      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+    else                                                                       \
+      for (size_t I = 0; I < NumElements; ++I)                                 \
+        Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(             \
+                            I)) BINOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+    return Lhs BINOP vec(Rhs);                                                 \
+  }                                                                            \
+  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+    return vec(Lhs) BINOP Rhs;                                                 \
+  }                                                                            \
+  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+    Lhs = Lhs BINOP Rhs;                                                       \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <int Num = NumElements>                                             \
+  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
+      vec & Lhs, const DataT & Rhs) {                                          \
+    Lhs = Lhs BINOP vec(Rhs);                                                  \
+    return Lhs;                                                                \
+  }
+
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  __SYCL_BINOP(+, +=, true)
+  __SYCL_BINOP(-, -=, true)
+  __SYCL_BINOP(*, *=, false)
+  __SYCL_BINOP(/, /=, false)
+
+  // TODO: The following OPs are available only when: DataT != cl_float &&
+  // DataT != cl_double && DataT != cl_half
+  __SYCL_BINOP(%, %=, false)
+  __SYCL_BINOP(|, |=, false)
+  __SYCL_BINOP(&, &=, false)
+  __SYCL_BINOP(^, ^=, false)
+  __SYCL_BINOP(>>, >>=, false)
+  __SYCL_BINOP(<<, <<=, true)
+#undef __SYCL_BINOP
+#undef __SYCL_BINOP_HELP
+
+  // Note: vec<>/SwizzleOp logical value is 0/-1 logic, as opposed to 0/1 logic.
+  // As far as CTS validation is concerned, 0/-1 logic also applies when
+  // NumElements is equal to one, which is somewhat inconsistent with being
+  // transparent with scalar data.
+  // TODO: Determine if vec<, NumElements=1> is needed at all, remove this
+  // inconsistency if not by disallowing one-element vectors (as in OpenCL)
+
+#ifdef __SYCL_RELLOGOP
+#error "Undefine __SYCL_RELLOGOP macro"
+#endif
+// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
+// by SYCL device compiler only.
+#ifdef __SYCL_DEVICE_ONLY__
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const vec & Rhs) {          \
+    vec<rel_t, NumElements> Ret{};                                             \
+    /* This special case is needed since there are no standard operator||   */ \
+    /* or operator&& functions for std::array.                              */ \
+    if constexpr (IsUsingArrayOnDevice &&                                      \
+                  (std::string_view(#RELLOGOP) == "||" ||                      \
+                   std::string_view(#RELLOGOP) == "&&")) {                     \
+      for (size_t I = 0; I < NumElements; ++I) {                               \
+        /* We cannot use SetValue here as the operator is not a friend of*/    \
+        /* Ret on Windows. */                                                  \
+        Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                    \
+            Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+      }                                                                        \
+    } else {                                                                   \
+      Ret = vec<rel_t, NumElements>(                                           \
+          (typename vec<rel_t, NumElements>::vector_t)(                        \
+              Lhs.m_Data RELLOGOP Rhs.m_Data));                                \
+      if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
+        Ret *= -1;                                                             \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const DataT & Rhs) {        \
+    return Lhs RELLOGOP vec(Rhs);                                              \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
+                                                   const vec & Rhs) {          \
+    return vec(Lhs) RELLOGOP Rhs;                                              \
+  }
+
+#else
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const vec & Rhs) {          \
+    vec<rel_t, NumElements> Ret{};                                             \
+    for (size_t I = 0; I < NumElements; ++I) {                                 \
+      /* We cannot use SetValue here as the operator is not a friend of*/      \
+      /* Ret on Windows. */                                                    \
+      Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                      \
+          Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));   \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const DataT & Rhs) {        \
+    return Lhs RELLOGOP vec(Rhs);                                              \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
+                                                   const vec & Rhs) {          \
+    return vec(Lhs) RELLOGOP Rhs;                                              \
+  }
+#endif
+
+  __SYCL_RELLOGOP(==)
+  __SYCL_RELLOGOP(!=)
+  __SYCL_RELLOGOP(>)
+  __SYCL_RELLOGOP(<)
+  __SYCL_RELLOGOP(>=)
+  __SYCL_RELLOGOP(<=)
+  // TODO: limit to integral types.
+  __SYCL_RELLOGOP(&&)
+  __SYCL_RELLOGOP(||)
+#undef __SYCL_RELLOGOP
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  friend vec &operator UOP(vec & Rhs) {                                        \
+    Rhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    return Rhs;                                                                \
+  }                                                                            \
+  friend vec operator UOP(vec &Lhs, int) {                                     \
+    vec Ret(Lhs);                                                              \
+    Lhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  // operator~() available only when: dataT != float && dataT != double
+  // && dataT != half
+  friend vec operator~(const vec &Rhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I) {
+        Ret.setValue(I, ~Rhs.getValue(I));
+      }
+      return Ret;
+    } else {
+      vec Ret{(typename vec::DataType) ~Rhs.m_Data};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+      return Ret;
+    }
+  }
+
+  // operator!
+  friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I) {
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        // std::byte neither supports ! unary op or casting, so special handling
+        // is needed. And, worse, Windows has a conflict with 'byte'.
+        if constexpr (std::is_same_v<std::byte, DataT>) {
+          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
+        } else
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        {
+          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
+        }
+      }
+      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
+    } else {
+      return vec{(typename vec<DataT, NumElements>::DataType) !Rhs.m_Data}
+          .template as<vec<detail::rel_t<DataT>, NumElements>>();
+    }
+  }
+
+  // operator +
+  friend vec operator+(const vec &Lhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(
+            I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
+      return Ret;
+    } else {
+      return vec{+Lhs.m_Data};
+    }
+  }
+
+  // operator -
+  friend vec operator-(const vec &Lhs) {
+    namespace oneapi = sycl::ext::oneapi;
+    vec Ret{};
+    if constexpr (IsBfloat16 && NumElements == 1) {
+      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data);
+      oneapi::bfloat16 w = -v;
+      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
+    } else if constexpr (IsBfloat16) {
+      for (size_t I = 0; I < NumElements; I++) {
+        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[I]);
+        oneapi::bfloat16 w = -v;
+        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
+      }
+    } else if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(
+            I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
+      return Ret;
+    } else {
+      Ret = vec{-Lhs.m_Data};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+      return Ret;
+    }
+  }
+
+  // OP is: &&, ||
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
+
+  // OP is: ==, !=, <, >, <=, >=
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
+private:
+  // Generic method that execute "Operation" on underlying values.
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <template <typename> class Operation,
+            typename Ty = vec<DataT, NumElements>>
+  vec<DataT, NumElements>
+  operatorHelper(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataType> Op;
+    Result.m_Data = Op(m_Data, Rhs.m_Data);
+    return Result;
+  }
+
+  template <template <typename> class Operation,
+            typename Ty = vec<DataT, NumElements>>
+  vec<DataT, NumElements>
+  operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataT> Op;
+    for (size_t I = 0; I < NumElements; ++I) {
+      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
+    }
+    return Result;
+  }
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+  template <template <typename> class Operation>
+  vec<DataT, NumElements>
+  operatorHelper(const vec<DataT, NumElements> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataT> Op;
+    for (size_t I = 0; I < NumElements; ++I) {
+      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
+    }
+    return Result;
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // setValue and getValue should be able to operate on different underlying
+  // types: enum cl_float#N , builtin vector float#N, builtin type float.
+  // These versions are for N > 1.
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
+                          int) {
+    m_Data[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
+    return vec_data<DataT>::get(m_Data[Index]);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
+    m_Data.s[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
+    return vec_data<DataT>::get(m_Data.s[Index]);
+  }
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(int Index, const DataT &Value, int) {
+    m_Data[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(int Index, int) const {
+    return vec_data<DataT>::get(m_Data[Index]);
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // N==1 versions, used by host and device. Shouldn't trailing type be int?
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 == Num>>
+  constexpr void setValue(int, const DataT &Value, float) {
+    m_Data = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 == Num>>
+  DataT getValue(int, float) const {
+    return vec_data<DataT>::get(m_Data);
+  }
+
+  // setValue and getValue.
+  // The "api" functions used by BINOP etc.  These versions just dispatch
+  // using additional int or float arg to disambiguate vec<1> vs. vec<N>
+  // Special proxies as specialization is not allowed in class scope.
+  constexpr void setValue(int Index, const DataT &Value) {
+    if (NumElements == 1)
+      setValue(Index, Value, 0);
+    else
+      setValue(Index, Value, 0.f);
+  }
+
+  DataT getValue(int Index) const {
+    return (NumElements == 1) ? getValue(Index, 0) : getValue(Index, 0.f);
+  }
+
+  // fields
+
+  // Alignment is the same as size, to a maximum size of 64.
+  // detail::vector_alignment will return that value.
+  alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
+
+  // friends
+  template <typename T1, typename T2, typename T3, template <typename> class T4,
+            int... T5>
+  friend class detail::SwizzleOp;
+  template <typename T1, int T2> friend class vec;
+};
+///////////////////////// class sycl::vec /////////////////////////
+
+#ifdef __cpp_deduction_guides
+// all compilers supporting deduction guides also support fold expressions
+template <class T, class... U,
+          class = std::enable_if_t<(std::is_same_v<T, U> && ...)>>
+vec(T, U...) -> vec<T, sizeof...(U) + 1>;
+#endif
+
+namespace detail {
+
+// Special type for working SwizzleOp with scalars, stores a scalar and gives
+// the scalar at any index. Provides interface is compatible with SwizzleOp
+// operations
+template <typename T> class GetScalarOp {
+public:
+  using DataT = T;
+  GetScalarOp(DataT Data) : m_Data(Data) {}
+  DataT getValue(size_t) const { return m_Data; }
+
+private:
+  DataT m_Data;
+};
+
+template <typename T> struct EqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs == Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct NotEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs != Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs >= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs <= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs > Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs < Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalAnd {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs && Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalOr {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs || Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct RShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs >> Rhs;
+  }
+};
+
+template <typename T> struct LShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs << Rhs;
+  }
+};
+
+///////////////////////// class SwizzleOp /////////////////////////
+// SwizzleOP represents expression templates that operate on vec.
+// Actual computation performed on conversion or assignment operators.
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp {
+  using DataT = typename VecT::element_type;
+  // Certain operators return a vector with a different element type. Also, the
+  // left and right operand types may differ. CommonDataT selects a result type
+  // based on these types to ensure that the result value can be represented.
+  //
+  // Example 1:
+  //   sycl::vec<unsigned char, 4> vec{...};
+  //   auto result = 300u + vec.x();
+  //
+  // CommonDataT is std::common_type_t<OperationLeftT, OperationRightT> since
+  // it's larger than unsigned char.
+  //
+  // Example 2:
+  //   sycl::vec<bool, 1> vec{...};
+  //   auto result = vec.template swizzle<sycl::elem::s0>() && vec;
+  //
+  // CommonDataT is DataT since operator&& returns a vector with element type
+  // int8_t, which is larger than bool.
+  //
+  // Example 3:
+  //   sycl::vec<std::byte, 4> vec{...}; auto swlo = vec.lo();
+  //   auto result = swlo == swlo;
+  //
+  // CommonDataT is DataT since operator== returns a vector with element type
+  // int8_t, which is the same size as std::byte. std::common_type_t<DataT, ...>
+  // can't be used here since there's no type that int8_t and std::byte can both
+  // be implicitly converted to.
+  using OpLeftDataT = typename OperationLeftT::DataT;
+  using OpRightDataT = typename OperationRightT::DataT;
+  using CommonDataT = std::conditional_t<
+      sizeof(DataT) >= sizeof(std::common_type_t<OpLeftDataT, OpRightDataT>),
+      DataT, std::common_type_t<OpLeftDataT, OpRightDataT>>;
+  static constexpr int getNumElements() { return sizeof...(Indexes); }
+
+  using rel_t = detail::rel_t<DataT>;
+  using vec_t = vec<DataT, sizeof...(Indexes)>;
+  using vec_rel_t = vec<rel_t, sizeof...(Indexes)>;
+
+  template <typename OperationRightT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewLHOp = SwizzleOp<VecT,
+                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                      OperationCurrentT, Indexes...>,
+                            OperationRightT_, OperationCurrentT_, Idx_...>;
+
+  template <typename OperationRightT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewRelOp = SwizzleOp<vec<rel_t, VecT::getNumElements()>,
+                             SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                       OperationCurrentT, Indexes...>,
+                             OperationRightT_, OperationCurrentT_, Idx_...>;
+
+  template <typename OperationLeftT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewRHOp = SwizzleOp<VecT, OperationLeftT_,
+                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                      OperationCurrentT, Indexes...>,
+                            OperationCurrentT_, Idx_...>;
+
+  template <int IdxNum, typename T = void>
+  using EnableIfOneIndex = typename std::enable_if_t<
+      1 == IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+
+  template <int IdxNum, typename T = void>
+  using EnableIfMultipleIndexes = typename std::enable_if_t<
+      1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+
+  template <typename T>
+  using EnableIfScalarType = typename std::enable_if_t<
+      std::is_convertible_v<DataT, T> &&
+      (std::is_fundamental_v<vec_data_t<T>> ||
+       detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+
+  template <typename T>
+  using EnableIfNoScalarType = typename std::enable_if_t<
+      !std::is_convertible_v<DataT, T> ||
+      !(std::is_fundamental_v<vec_data_t<T>> ||
+        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+
+  template <int... Indices>
+  using Swizzle =
+      SwizzleOp<VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
+
+  template <int... Indices>
+  using ConstSwizzle =
+      SwizzleOp<const VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
+
+public:
+  using element_type = DataT;
+  using value_type = DataT;
+
+#ifdef __SYCL_DEVICE_ONLY__
+  using vector_t = typename vec_t::vector_t;
+#endif // __SYCL_DEVICE_ONLY__
+
+  const DataT &operator[](int i) const {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    return (*m_Vector)[Idxs[i]];
+  }
+
+  template <typename _T = VecT>
+  std::enable_if_t<!std::is_const_v<_T>, DataT> &operator[](int i) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    return (*m_Vector)[Idxs[i]];
+  }
+
+  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
+  size_t get_count() const { return size(); }
+  static constexpr size_t size() noexcept { return getNumElements(); }
+
+  template <int Num = getNumElements()>
+  __SYCL2020_DEPRECATED(
+      "get_size() is deprecated, please use byte_size() instead")
+  size_t get_size() const {
+    return byte_size<Num>();
+  }
+
+  template <int Num = getNumElements()> size_t byte_size() const noexcept {
+    return sizeof(DataT) * (Num == 3 ? 4 : Num);
+  }
+
+  template <typename T, int IdxNum = getNumElements(),
+            typename = EnableIfOneIndex<IdxNum>,
+            typename = EnableIfScalarType<T>>
+  operator T() const {
+    return getValue(0);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>
+  operator*(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::plus, Indexes...>
+  operator+(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::plus, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::divides, Indexes...>
+  operator/(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::divides, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  // TODO: Check that Rhs arg is suitable.
+#ifdef __SYCL_OPASSIGN
+#error "Undefine __SYCL_OPASSIGN macro."
+#endif
+#define __SYCL_OPASSIGN(OPASSIGN, OP)                                          \
+  SwizzleOp &operator OPASSIGN(const DataT & Rhs) {                            \
+    operatorHelper<OP>(vec_t(Rhs));                                            \
+    return *this;                                                              \
+  }                                                                            \
+  template <typename RhsOperation>                                             \
+  SwizzleOp &operator OPASSIGN(const RhsOperation & Rhs) {                     \
+    operatorHelper<OP>(Rhs);                                                   \
+    return *this;                                                              \
+  }
+
+  __SYCL_OPASSIGN(+=, std::plus)
+  __SYCL_OPASSIGN(-=, std::minus)
+  __SYCL_OPASSIGN(*=, std::multiplies)
+  __SYCL_OPASSIGN(/=, std::divides)
+  __SYCL_OPASSIGN(%=, std::modulus)
+  __SYCL_OPASSIGN(&=, std::bit_and)
+  __SYCL_OPASSIGN(|=, std::bit_or)
+  __SYCL_OPASSIGN(^=, std::bit_xor)
+  __SYCL_OPASSIGN(>>=, RShift)
+  __SYCL_OPASSIGN(<<=, LShift)
+#undef __SYCL_OPASSIGN
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  SwizzleOp &operator UOP() {                                                  \
+    *this OPASSIGN static_cast<DataT>(1);                                      \
+    return *this;                                                              \
+  }                                                                            \
+  vec_t operator UOP(int) {                                                    \
+    vec_t Ret = *this;                                                         \
+    *this OPASSIGN static_cast<DataT>(1);                                      \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  template <typename T = DataT>
+  friend typename std::enable_if_t<
+      std::is_same_v<T, DataT> && std::is_integral_v<vec_data_t<T>>, vec_t>
+  operator~(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return ~Tmp;
+  }
+
+  friend vec_rel_t operator!(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return !Tmp;
+  }
+
+  friend vec_t operator+(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return +Tmp;
+  }
+
+  friend vec_t operator-(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return -Tmp;
+  }
+
+// scalar BINOP vec<>
+// scalar BINOP SwizzleOp
+// vec<> BINOP SwizzleOp
+#ifdef __SYCL_BINOP
+#error "Undefine __SYCL_BINOP macro"
+#endif
+#define __SYCL_BINOP(BINOP)                                                    \
+  friend vec_t operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {        \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs BINOP Tmp;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {        \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp BINOP Rhs;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {        \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs BINOP Tmp;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {        \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp BINOP Rhs;                                                      \
+  }
+
+  __SYCL_BINOP(+)
+  __SYCL_BINOP(-)
+  __SYCL_BINOP(*)
+  __SYCL_BINOP(/)
+  __SYCL_BINOP(%)
+  __SYCL_BINOP(&)
+  __SYCL_BINOP(|)
+  __SYCL_BINOP(^)
+  __SYCL_BINOP(>>)
+  __SYCL_BINOP(<<)
+#undef __SYCL_BINOP
+
+// scalar RELLOGOP vec<>
+// scalar RELLOGOP SwizzleOp
+// vec<> RELLOGOP SwizzleOp
+#ifdef __SYCL_RELLOGOP
+#error "Undefine __SYCL_RELLOGOP macro"
+#endif
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec_rel_t operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs RELLOGOP Tmp;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp RELLOGOP Rhs;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs RELLOGOP Tmp;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp RELLOGOP Rhs;                                                   \
+  }
+
+  __SYCL_RELLOGOP(==)
+  __SYCL_RELLOGOP(!=)
+  __SYCL_RELLOGOP(>)
+  __SYCL_RELLOGOP(<)
+  __SYCL_RELLOGOP(>=)
+  __SYCL_RELLOGOP(<=)
+  // TODO: limit to integral types.
+  __SYCL_RELLOGOP(&&)
+  __SYCL_RELLOGOP(||)
+#undef __SYCL_RELLOGOP
+
+  template <int IdxNum = getNumElements(),
+            typename = EnableIfMultipleIndexes<IdxNum>>
+  SwizzleOp &operator=(const vec<DataT, IdxNum> &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
+  SwizzleOp &operator=(const DataT &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    m_Vector->setValue(Idxs[0], Rhs);
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(),
+            EnableIfMultipleIndexes<IdxNum, bool> = true>
+  SwizzleOp &operator=(const DataT &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    for (auto Idx : Idxs) {
+      m_Vector->setValue(Idx, Rhs);
+    }
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
+  SwizzleOp &operator=(DataT &&Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    m_Vector->setValue(Idxs[0], Rhs);
+    return *this;
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>
+  operator*(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::multiplies, Indexes...>
+  operator*(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::multiplies, Indexes...>(m_Vector, *this,
+                                                              Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::plus, Indexes...> operator+(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::plus, Indexes...>(m_Vector, *this,
+                                                          GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::plus, Indexes...>
+  operator+(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::plus, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::minus, Indexes...>
+  operator-(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::minus, Indexes...>(m_Vector, *this,
+                                                           GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::minus, Indexes...>
+  operator-(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::minus, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::divides, Indexes...>
+  operator/(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::divides, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::divides, Indexes...>
+  operator/(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::divides, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>
+  operator%(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::modulus, Indexes...>
+  operator%(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::modulus, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>
+  operator&(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_and, Indexes...>
+  operator&(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_and, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>
+  operator|(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_or, Indexes...>
+  operator|(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_or, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>
+  operator^(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_xor, Indexes...>
+  operator^(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_xor, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, RShift, Indexes...> operator>>(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, RShift, Indexes...>(m_Vector, *this,
+                                                       GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, RShift, Indexes...>
+  operator>>(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, RShift, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, LShift, Indexes...> operator<<(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, LShift, Indexes...>(m_Vector, *this,
+                                                       GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, LShift, Indexes...>
+  operator<<(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, LShift, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  SwizzleOp &operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  SwizzleOp &operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, EqualTo, Indexes...> operator==(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, EqualTo, Indexes...>(NULL, *this,
+                                                         GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, EqualTo, Indexes...>
+  operator==(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, EqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>
+  operator!=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, NotEqualTo, Indexes...>
+  operator!=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, NotEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>
+  operator>=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>
+  operator>=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>
+  operator<=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LessEqualTo, Indexes...>
+  operator<=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LessEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>
+  operator>(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, GreaterThan, Indexes...>
+  operator>(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, GreaterThan, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LessThan, Indexes...> operator<(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LessThan, Indexes...>(NULL, *this,
+                                                          GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LessThan, Indexes...>
+  operator<(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LessThan, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>
+  operator&&(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LogicalAnd, Indexes...>
+  operator&&(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LogicalAnd, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>
+  operator||(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>(NULL, *this,
+                                                           GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LogicalOr, Indexes...>
+  operator||(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LogicalOr, Indexes...>(NULL, *this, Rhs);
+  }
+
+  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
+private:
+  // Indexer used in the swizzles.def.
+  // Currently it is defined as a template struct. Replacing it with a constexpr
+  // function would activate a bug in MSVC that is fixed only in v19.20.
+  // Until then MSVC does not recognize such constexpr functions as const and
+  // thus does not let using them in template parameters inside swizzle.def.
+  template <int Index> struct Indexer {
+    static constexpr int IDXs[sizeof...(Indexes)] = {Indexes...};
+    static constexpr int value = IDXs[Index >= getNumElements() ? 0 : Index];
+  };
+
+public:
+#ifdef __SYCL_ACCESS_RETURN
+#error "Undefine __SYCL_ACCESS_RETURN macro"
+#endif
+#define __SYCL_ACCESS_RETURN m_Vector
+#include "swizzles.def"
+#undef __SYCL_ACCESS_RETURN
+  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
+
+  // Leave store() interface to automatic conversion to vec<>.
+  // Load to vec_t and then assign to swizzle.
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t offset, multi_ptr<DataT, Space, DecorateAddress> ptr) {
+    vec_t Tmp;
+    Tmp.template load(offset, ptr);
+    *this = Tmp;
+  }
+
+  template <typename convertT, rounding_mode roundingMode>
+  vec<convertT, sizeof...(Indexes)> convert() const {
+    // First materialize the swizzle to vec_t and then apply convert() to it.
+    vec_t Tmp = *this;
+    return Tmp.template convert<convertT, roundingMode>();
+  }
+
+  template <typename asT> asT as() const {
+    // First materialize the swizzle to vec_t and then apply as() to it.
+    vec_t Tmp = *this;
+    static_assert((sizeof(Tmp) == sizeof(asT)),
+                  "The new SYCL vec type must have the same storage size in "
+                  "bytes as this SYCL swizzled vec");
+    static_assert(
+        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
+            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
+        "asT must be SYCL vec of a different element type and "
+        "number of elements specified by asT");
+    return Tmp.template as<asT>();
+  }
+
+private:
+  SwizzleOp(const SwizzleOp &Rhs)
+      : m_Vector(Rhs.m_Vector), m_LeftOperation(Rhs.m_LeftOperation),
+        m_RightOperation(Rhs.m_RightOperation) {}
+
+  SwizzleOp(VecT *Vector, OperationLeftT LeftOperation,
+            OperationRightT RightOperation)
+      : m_Vector(Vector), m_LeftOperation(LeftOperation),
+        m_RightOperation(RightOperation) {}
+
+  SwizzleOp(VecT *Vector) : m_Vector(Vector) {}
+
+  SwizzleOp(SwizzleOp &&Rhs)
+      : m_Vector(Rhs.m_Vector), m_LeftOperation(std::move(Rhs.m_LeftOperation)),
+        m_RightOperation(std::move(Rhs.m_RightOperation)) {}
+
+  // Either performing CurrentOperation on results of left and right operands
+  // or reading values from actual vector. Perform implicit type conversion when
+  // the number of elements == 1
+
+  template <int IdxNum = getNumElements()>
+  CommonDataT getValue(EnableIfOneIndex<IdxNum, size_t> Index) const {
+    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
+      std::array<int, getNumElements()> Idxs{Indexes...};
+      return m_Vector->getValue(Idxs[Index]);
+    }
+    auto Op = OperationCurrentT<vec_data_t<CommonDataT>>();
+    return vec_data<CommonDataT>::get(
+        Op(vec_data<CommonDataT>::get(m_LeftOperation.getValue(Index)),
+           vec_data<CommonDataT>::get(m_RightOperation.getValue(Index))));
+  }
+
+  template <int IdxNum = getNumElements()>
+  DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
+    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
+      std::array<int, getNumElements()> Idxs{Indexes...};
+      return m_Vector->getValue(Idxs[Index]);
+    }
+    auto Op = OperationCurrentT<vec_data_t<DataT>>();
+    return vec_data<DataT>::get(
+        Op(vec_data<DataT>::get(m_LeftOperation.getValue(Index)),
+           vec_data<DataT>::get(m_RightOperation.getValue(Index))));
+  }
+
+  template <template <typename> class Operation, typename RhsOperation>
+  void operatorHelper(const RhsOperation &Rhs) {
+    Operation<vec_data_t<DataT>> Op;
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      DataT Res = vec_data<DataT>::get(
+          Op(vec_data<DataT>::get(m_Vector->getValue(Idxs[I])),
+             vec_data<DataT>::get(Rhs.getValue(I))));
+      m_Vector->setValue(Idxs[I], Res);
+    }
+  }
+
+  // fields
+  VecT *m_Vector;
+
+  OperationLeftT m_LeftOperation;
+  OperationRightT m_RightOperation;
+
+  // friends
+  template <typename T1, int T2> friend class sycl::vec;
+
+  template <typename T1, typename T2, typename T3, template <typename> class T4,
+            int... T5>
+  friend class SwizzleOp;
+};
+///////////////////////// class SwizzleOp /////////////////////////
+} // namespace detail
+} // namespace _V1
+} // namespace sycl

From e45b3c6b81df19e3dcf3d419fee2c534585ef26c Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 23 Apr 2024 16:13:35 -0700
Subject: [PATCH 28/79] Create a new header for vector

---
 sycl/include/sycl/vector.hpp | 2345 ++++++++++++++++++++++++++++++++++
 1 file changed, 2345 insertions(+)
 create mode 100644 sycl/include/sycl/vector.hpp

diff --git a/sycl/include/sycl/vector.hpp b/sycl/include/sycl/vector.hpp
new file mode 100644
index 0000000000000..056012fd08cf1
--- /dev/null
+++ b/sycl/include/sycl/vector.hpp
@@ -0,0 +1,2345 @@
+//==---------------- types.hpp --- SYCL types ------------------------------==//
+//
+// 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
+
+// Check if Clang's ext_vector_type attribute is available. Host compiler
+// may not be Clang, and Clang may not be built with the extension.
+#ifdef __clang__
+#ifndef __has_extension
+#define __has_extension(x) 0
+#endif
+#ifdef __HAS_EXT_VECTOR_TYPE__
+#error "Undefine __HAS_EXT_VECTOR_TYPE__ macro"
+#endif
+#if __has_extension(attribute_ext_vector_type)
+#define __HAS_EXT_VECTOR_TYPE__
+#endif
+#endif // __clang__
+
+#if !defined(__HAS_EXT_VECTOR_TYPE__) && defined(__SYCL_DEVICE_ONLY__)
+#error "SYCL device compiler is built without ext_vector_type support"
+#endif
+
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_USE_EXT_VECTOR_TYPE__
+#endif
+
+#include <sycl/access/access.hpp>              // for decorated, address_space
+#include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
+#include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
+#include <sycl/detail/defines_elementary.hpp>  // for __SYCL2020_DEPRECATED
+#include <sycl/detail/generic_type_lists.hpp>  // for vector_basic_list
+#include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
+#include <sycl/detail/memcpy.hpp>              // for memcpy
+#include <sycl/detail/type_list.hpp>           // for is_contained
+#include <sycl/detail/type_traits.hpp>         // for is_floating_point
+#include <sycl/detail/vector_convert.hpp>      // for convertImpl
+#include <sycl/detail/vector_traits.hpp>       // for vector_alignment
+#include <sycl/exception.hpp>                  // for make_error_code, errc
+#include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
+#include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
+#include <sycl/multi_ptr.hpp>                  // for multi_ptr
+
+#include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
+
+#include <array>       // for array
+#include <assert.h>    // for assert
+#include <cstddef>     // for size_t, NULL, byte
+#include <cstdint>     // for uint8_t, int16_t, int...
+#include <functional>  // for divides, multiplies
+#include <iterator>    // for pair
+#include <optional>    // for optional
+#include <ostream>     // for operator<<, basic_ost...
+#include <tuple>       // for tuple
+#include <type_traits> // for enable_if_t, is_same
+#include <utility>     // for index_sequence, make_...
+#include <variant>     // for tuple, variant
+
+// 4.10.1: Scalar data types
+// 4.10.2: SYCL vector types
+
+namespace sycl {
+inline namespace _V1 {
+
+struct elem {
+  static constexpr int x = 0;
+  static constexpr int y = 1;
+  static constexpr int z = 2;
+  static constexpr int w = 3;
+  static constexpr int r = 0;
+  static constexpr int g = 1;
+  static constexpr int b = 2;
+  static constexpr int a = 3;
+  static constexpr int s0 = 0;
+  static constexpr int s1 = 1;
+  static constexpr int s2 = 2;
+  static constexpr int s3 = 3;
+  static constexpr int s4 = 4;
+  static constexpr int s5 = 5;
+  static constexpr int s6 = 6;
+  static constexpr int s7 = 7;
+  static constexpr int s8 = 8;
+  static constexpr int s9 = 9;
+  static constexpr int sA = 10;
+  static constexpr int sB = 11;
+  static constexpr int sC = 12;
+  static constexpr int sD = 13;
+  static constexpr int sE = 14;
+  static constexpr int sF = 15;
+};
+
+namespace detail {
+// select_apply_cl_t selects from T8/T16/T32/T64 basing on
+// sizeof(_IN).  expected to handle scalar types in _IN.
+template <typename _IN, typename T8, typename T16, typename T32, typename T64>
+using select_apply_cl_t = std::conditional_t<
+    sizeof(_IN) == 1, T8,
+    std::conditional_t<sizeof(_IN) == 2, T16,
+                       std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
+
+template <typename T> struct vec_helper {
+  using RetType = T;
+  static constexpr RetType get(T value) { return value; }
+  static constexpr RetType set(T value) { return value; }
+};
+template <> struct vec_helper<bool> {
+  using RetType = select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                    std::int32_t, std::int64_t>;
+  static constexpr RetType get(bool value) { return value; }
+  static constexpr RetType set(bool value) { return value; }
+};
+
+template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
+  using RetType = sycl::ext::oneapi::bfloat16;
+  using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  static constexpr RetType get(BFloat16StorageT value) {
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<RetType>(value);
+#else
+    // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+    // but neither available yet.
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.storage = value;
+    return result.bf16;
+#endif
+  }
+
+  static constexpr RetType get(RetType value) { return value; }
+
+  static constexpr BFloat16StorageT set(RetType value) {
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<BFloat16StorageT>(value);
+#else
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.bf16 = value;
+    return result.storage;
+#endif
+  }
+};
+
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+template <> struct vec_helper<std::byte> {
+  using RetType = std::uint8_t;
+  static constexpr RetType get(std::byte value) { return (RetType)value; }
+  static constexpr RetType set(std::byte value) { return (RetType)value; }
+  static constexpr std::byte get(std::uint8_t value) {
+    return (std::byte)value;
+  }
+  static constexpr std::byte set(std::uint8_t value) {
+    return (std::byte)value;
+  }
+};
+#endif
+
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp;
+
+template <typename T, int N, typename V = void> struct VecStorage;
+
+// Element type for relational operator return value.
+template <typename DataT>
+using rel_t = typename std::conditional_t<
+    sizeof(DataT) == sizeof(opencl::cl_char), opencl::cl_char,
+    typename std::conditional_t<
+        sizeof(DataT) == sizeof(opencl::cl_short), opencl::cl_short,
+        typename std::conditional_t<
+            sizeof(DataT) == sizeof(opencl::cl_int), opencl::cl_int,
+            typename std::conditional_t<sizeof(DataT) ==
+                                            sizeof(opencl::cl_long),
+                                        opencl::cl_long, bool>>>>;
+
+// Special type indicating that SwizzleOp should just read value from vector -
+// not trying to perform any operations. Should not be called.
+template <typename T> class GetOp {
+public:
+  using DataT = T;
+  DataT getValue(size_t) const { return (DataT)0; }
+  DataT operator()(DataT, DataT) { return (DataT)0; }
+};
+
+// Special type for working SwizzleOp with scalars, stores a scalar and gives
+// the scalar at any index. Provides interface is compatible with SwizzleOp
+// operations
+template <typename T> class GetScalarOp {
+public:
+  using DataT = T;
+  GetScalarOp(DataT Data) : m_Data(Data) {}
+  DataT getValue(size_t) const { return m_Data; }
+
+private:
+  DataT m_Data;
+};
+
+template <typename T> struct EqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs == Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct NotEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs != Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs >= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs <= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs > Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs < Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalAnd {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs && Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalOr {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs || Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct RShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs >> Rhs;
+  }
+};
+
+template <typename T> struct LShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs << Rhs;
+  }
+};
+
+// Forward declarations
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernel;
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernelWithKH;
+
+} // namespace detail
+
+template <typename T> using vec_data = detail::vec_helper<T>;
+
+template <typename T>
+using vec_data_t = typename detail::vec_helper<T>::RetType;
+
+/// Provides a cross-patform vector class template that works efficiently on
+/// SYCL devices as well as in host C++ code.
+///
+/// \ingroup sycl_api
+template <typename Type, int NumElements> class vec {
+  using DataT = Type;
+
+  // This represent type of underlying value. There should be only one field
+  // in the class, so vec<float, 16> should be equal to float16 in memory.
+  using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
+
+  static constexpr bool IsHostHalf =
+      std::is_same_v<DataT, sycl::detail::half_impl::half> &&
+      std::is_same_v<sycl::detail::half_impl::StorageT,
+                     sycl::detail::host_half_impl::half>;
+
+  static constexpr bool IsBfloat16 =
+      std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
+
+  static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
+  static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
+  static constexpr bool IsSizeGreaterThanMaxAlign =
+      (Sz > detail::MaxVecAlignment);
+
+  // TODO: There is no support for vector half type on host yet.
+  // Also, when Sz is greater than alignment, we use std::array instead of
+  // vector extension. This is for MSVC compatibility, which has a max alignment
+  // of 64 for direct params. If we drop MSVC, we can have alignment the same as
+  // size and use vector extensions for all sizes.
+  static constexpr bool IsUsingArrayOnDevice =
+      (IsHostHalf || IsBfloat16 || IsSizeGreaterThanMaxAlign);
+
+#if defined(__SYCL_DEVICE_ONLY__)
+  static constexpr bool NativeVec = NumElements > 1 && !IsUsingArrayOnDevice;
+  static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
+#else
+  static constexpr bool NativeVec = false;
+  static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
+#endif
+
+  static constexpr int getNumElements() { return NumElements; }
+
+  // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
+  template <int Counter, int MaxValue, class...>
+  struct SizeChecker : std::conditional_t<Counter == MaxValue, std::true_type,
+                                          std::false_type> {};
+
+  template <int Counter, int MaxValue, typename DataT_, class... tail>
+  struct SizeChecker<Counter, MaxValue, DataT_, tail...>
+      : std::conditional_t<Counter + 1 <= MaxValue,
+                           SizeChecker<Counter + 1, MaxValue, tail...>,
+                           std::false_type> {};
+
+  // Utility trait for creating an std::array from an vector argument.
+  template <typename DataT_, typename T, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const vec<T, sizeof...(Is)> &V, std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &V,
+             std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &V,
+             std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N>
+  static constexpr std::array<DataT_, N>
+  FlattenVecArgHelper(const vec<T, N> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<N>());
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5>
+  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
+      const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5>
+  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
+      const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
+  }
+  template <typename DataT_, typename T>
+  static constexpr auto FlattenVecArgHelper(const T &A) {
+    return std::array<DataT_, 1>{vec_data<DataT_>::get(static_cast<DataT_>(A))};
+  }
+  template <typename DataT_, typename T> struct FlattenVecArg {
+    constexpr auto operator()(const T &A) const {
+      return FlattenVecArgHelper<DataT_>(A);
+    }
+  };
+
+  // Alias for shortening the vec arguments to array converter.
+  template <typename DataT_, typename... ArgTN>
+  using VecArgArrayCreator =
+      detail::ArrayCreator<DataT_, FlattenVecArg, ArgTN...>;
+
+#define __SYCL_ALLOW_VECTOR_SIZES(num_elements)                                \
+  template <int Counter, int MaxValue, typename DataT_, class... tail>         \
+  struct SizeChecker<Counter, MaxValue, vec<DataT_, num_elements>, tail...>    \
+      : std::conditional_t<                                                    \
+            Counter + (num_elements) <= MaxValue,                              \
+            SizeChecker<Counter + (num_elements), MaxValue, tail...>,          \
+            std::false_type> {};                                               \
+  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
+            typename T3, template <typename> class T4, int... T5,              \
+            class... tail>                                                     \
+  struct SizeChecker<                                                          \
+      Counter, MaxValue,                                                       \
+      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>,         \
+      tail...>                                                                 \
+      : std::conditional_t<                                                    \
+            Counter + sizeof...(T5) <= MaxValue,                               \
+            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
+            std::false_type> {};                                               \
+  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
+            typename T3, template <typename> class T4, int... T5,              \
+            class... tail>                                                     \
+  struct SizeChecker<                                                          \
+      Counter, MaxValue,                                                       \
+      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
+      tail...>                                                                 \
+      : std::conditional_t<                                                    \
+            Counter + sizeof...(T5) <= MaxValue,                               \
+            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
+            std::false_type> {};
+
+  __SYCL_ALLOW_VECTOR_SIZES(1)
+  __SYCL_ALLOW_VECTOR_SIZES(2)
+  __SYCL_ALLOW_VECTOR_SIZES(3)
+  __SYCL_ALLOW_VECTOR_SIZES(4)
+  __SYCL_ALLOW_VECTOR_SIZES(8)
+  __SYCL_ALLOW_VECTOR_SIZES(16)
+#undef __SYCL_ALLOW_VECTOR_SIZES
+
+  // TypeChecker is needed for vec(const argTN &... args) ctor to validate args.
+  template <typename T, typename DataT_>
+  struct TypeChecker : std::is_convertible<T, DataT_> {};
+#define __SYCL_ALLOW_VECTOR_TYPES(num_elements)                                \
+  template <typename DataT_>                                                   \
+  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {};   \
+  template <typename DataT_, typename T2, typename T3,                         \
+            template <typename> class T4, int... T5>                           \
+  struct TypeChecker<                                                          \
+      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
+      : std::true_type {};                                                     \
+  template <typename DataT_, typename T2, typename T3,                         \
+            template <typename> class T4, int... T5>                           \
+  struct TypeChecker<                                                          \
+      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
+      DataT_> : std::true_type {};
+
+  __SYCL_ALLOW_VECTOR_TYPES(1)
+  __SYCL_ALLOW_VECTOR_TYPES(2)
+  __SYCL_ALLOW_VECTOR_TYPES(3)
+  __SYCL_ALLOW_VECTOR_TYPES(4)
+  __SYCL_ALLOW_VECTOR_TYPES(8)
+  __SYCL_ALLOW_VECTOR_TYPES(16)
+#undef __SYCL_ALLOW_VECTOR_TYPES
+
+  template <int... Indexes>
+  using Swizzle =
+      detail::SwizzleOp<vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
+                        detail::GetOp, Indexes...>;
+
+  template <int... Indexes>
+  using ConstSwizzle =
+      detail::SwizzleOp<const vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
+                        detail::GetOp, Indexes...>;
+
+  // Shortcuts for args validation in vec(const argTN &... args) ctor.
+  template <typename... argTN>
+  using EnableIfSuitableTypes = typename std::enable_if_t<
+      std::conjunction_v<TypeChecker<argTN, DataT>...>>;
+
+  template <typename... argTN>
+  using EnableIfSuitableNumElements =
+      typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
+
+  template <size_t... Is>
+  constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
+                std::index_sequence<Is...>)
+      : m_Data{([&](vec_data_t<DataT> v) constexpr {
+          if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
+            return v.value;
+          else
+            return vec_data_t<DataT>(static_cast<DataT>(v));
+        })(Arr[Is])...} {}
+
+public:
+  using element_type = DataT;
+  using value_type = DataT;
+  using rel_t = detail::rel_t<DataT>;
+#ifdef __SYCL_DEVICE_ONLY__
+  using vector_t =
+      typename detail::VecStorage<DataT, NumElements>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+
+  vec() = default;
+
+  constexpr vec(const vec &Rhs) = default;
+  constexpr vec(vec &&Rhs) = default;
+
+  constexpr vec &operator=(const vec &Rhs) = default;
+
+  // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
+  template <typename Ty = DataT>
+  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
+                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
+                            vec &>
+  operator=(const vec<rel_t, NumElements> &Rhs) {
+    *this = Rhs.template as<vec>();
+    return *this;
+  }
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <typename T = void>
+  using EnableIfNotHostHalf = typename std::enable_if_t<!IsHostHalf, T>;
+
+  template <typename T = void>
+  using EnableIfHostHalf = typename std::enable_if_t<IsHostHalf, T>;
+
+  template <typename T = void>
+  using EnableIfUsingArrayOnDevice =
+      typename std::enable_if_t<IsUsingArrayOnDevice, T>;
+
+  template <typename T = void>
+  using EnableIfNotUsingArrayOnDevice =
+      typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  template <typename T = void>
+  using EnableIfUsingArray =
+      typename std::enable_if_t<IsUsingArrayOnDevice || IsUsingArrayOnHost, T>;
+
+  template <typename T = void>
+  using EnableIfNotUsingArray =
+      typename std::enable_if_t<!IsUsingArrayOnDevice && !IsUsingArrayOnHost,
+                                T>;
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+
+  template <typename Ty = DataT>
+  explicit constexpr vec(const EnableIfNotUsingArrayOnDevice<Ty> &arg)
+      : m_Data{DataType(vec_data<Ty>::get(arg))} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) {
+    m_Data = (DataType)vec_data<Ty>::get(Rhs);
+    return *this;
+  }
+
+  template <typename Ty = DataT>
+  explicit constexpr vec(const EnableIfUsingArrayOnDevice<Ty> &arg)
+      : vec{detail::RepeatValue<NumElements>(
+                static_cast<vec_data_t<DataT>>(arg)),
+            std::make_index_sequence<NumElements>()} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
+    for (int i = 0; i < NumElements; ++i) {
+      setValue(i, Rhs);
+    }
+    return *this;
+  }
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+  explicit constexpr vec(const DataT &arg)
+      : vec{detail::RepeatValue<NumElements>(
+                static_cast<vec_data_t<DataT>>(arg)),
+            std::make_index_sequence<NumElements>()} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const DataT &Rhs) {
+    for (int i = 0; i < NumElements; ++i) {
+      setValue(i, Rhs);
+    }
+    return *this;
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  // Optimized naive constructors with NumElements of DataT values.
+  // We don't expect compilers to optimize vararg recursive functions well.
+
+  // Helper type to make specific constructors available only for specific
+  // number of elements.
+  template <int IdxNum, typename T = void>
+  using EnableIfMultipleElems = typename std::enable_if_t<
+      std::is_convertible_v<T, DataT> && NumElements == IdxNum, DataT>;
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<2, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<3, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<4, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const Ty Arg3)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<8, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const DataT Arg3, const DataT Arg4, const DataT Arg5,
+                const DataT Arg6, const DataT Arg7)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
+               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
+               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<16, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const DataT Arg3, const DataT Arg4, const DataT Arg5,
+                const DataT Arg6, const DataT Arg7, const DataT Arg8,
+                const DataT Arg9, const DataT ArgA, const DataT ArgB,
+                const DataT ArgC, const DataT ArgD, const DataT ArgE,
+                const DataT ArgF)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
+               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
+               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7),
+               vec_data<Ty>::get(Arg8), vec_data<Ty>::get(Arg9),
+               vec_data<Ty>::get(ArgA), vec_data<Ty>::get(ArgB),
+               vec_data<Ty>::get(ArgC), vec_data<Ty>::get(ArgD),
+               vec_data<Ty>::get(ArgE), vec_data<Ty>::get(ArgF)} {}
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // Constructor from values of base type or vec of base type. Checks that
+  // base types are match and that the NumElements == sum of lengths of args.
+  template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
+            typename = EnableIfSuitableNumElements<argTN...>>
+  constexpr vec(const argTN &...args)
+      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
+            std::make_index_sequence<NumElements>()} {}
+
+#ifdef __SYCL_DEVICE_ONLY__
+  template <typename vector_t_ = vector_t,
+            typename =
+                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
+                                          !std::is_same_v<vector_t_, DataT>>>
+  constexpr vec(vector_t openclVector) {
+    if constexpr (!IsUsingArrayOnDevice) {
+      m_Data = openclVector;
+    } else {
+      m_Data = bit_cast<DataType>(openclVector);
+    }
+  }
+
+  operator vector_t() const {
+    if constexpr (!IsUsingArrayOnDevice) {
+      return m_Data;
+    } else {
+      auto ptr = bit_cast<const vector_t *>((&m_Data)->data());
+      return *ptr;
+    }
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
+  // Available only when: NumElements == 1
+  template <int N = NumElements>
+  operator typename std::enable_if_t<N == 1, DataT>() const {
+    return vec_data<DataT>::get(m_Data);
+  }
+
+  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
+  static constexpr size_t get_count() { return size(); }
+  static constexpr size_t size() noexcept { return NumElements; }
+  __SYCL2020_DEPRECATED(
+      "get_size() is deprecated, please use byte_size() instead")
+  static constexpr size_t get_size() { return byte_size(); }
+  static constexpr size_t byte_size() noexcept { return sizeof(m_Data); }
+
+  // convertImpl can't be called with the same From and To types and therefore
+  // we need this version of convert which is mostly no-op.
+  template <typename convertT,
+            rounding_mode roundingMode = rounding_mode::automatic>
+  std::enable_if_t<
+      std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> ||
+          std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
+                         detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      vec<convertT, NumElements>>
+  convert() const {
+    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+                      detail::is_floating_point<convertT>::value,
+                  "Unsupported convertT");
+    if constexpr (!std::is_same_v<DataT, convertT>) {
+      // Dummy conversion for cases like vec<signed char> -> vec<char>
+      vec<convertT, NumElements> Result;
+      for (size_t I = 0; I < NumElements; ++I)
+        Result.setValue(I, static_cast<convertT>(getValue(I)));
+
+      return Result;
+    } else {
+      // No conversion necessary
+      return *this;
+    }
+  }
+
+  template <typename convertT,
+            rounding_mode roundingMode = rounding_mode::automatic>
+  std::enable_if_t<
+      !std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> &&
+          !std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
+                          detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      vec<convertT, NumElements>>
+  convert() const {
+    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+                      detail::is_floating_point<convertT>::value,
+                  "Unsupported convertT");
+    using T = vec_data_t<DataT>;
+    using R = vec_data_t<convertT>;
+    using OpenCLT = detail::ConvertToOpenCLType_t<T>;
+    using OpenCLR = detail::ConvertToOpenCLType_t<R>;
+    vec<convertT, NumElements> Result;
+
+#if defined(__SYCL_DEVICE_ONLY__)
+    using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
+    using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
+    // Whole vector conversion can only be done, if:
+    constexpr bool canUseNativeVectorConvert =
+#ifdef __NVPTX__
+        // - we are not on CUDA, see intel/llvm#11840
+        false &&
+#endif
+        // - both vectors are represented using native vector types;
+        NativeVec && vec<convertT, NumElements>::NativeVec &&
+        // - vec storage has an equivalent OpenCL native vector it is implicitly
+        //   convertible to. There are some corner cases where it is not the
+        //   case with char, long and long long types.
+        std::is_convertible_v<decltype(m_Data), OpenCLVecT> &&
+        std::is_convertible_v<decltype(Result.m_Data), OpenCLVecR> &&
+        // - it is not a signed to unsigned (or vice versa) conversion
+        //   see comments within 'convertImpl' for more details;
+        !detail::is_sint_to_from_uint<T, R>::value &&
+        // - destination type is not bool. bool is stored as integer under the
+        //   hood and therefore conversion to bool looks like conversion between
+        //   two integer types. Since bit pattern for true and false is not
+        //   defined, there is no guarantee that integer conversion yields
+        //   right results here;
+        !std::is_same_v<convertT, bool>;
+    if constexpr (canUseNativeVectorConvert) {
+      Result.m_Data = detail::convertImpl<T, R, roundingMode, NumElements,
+                                          OpenCLVecT, OpenCLVecR>(m_Data);
+    } else
+#endif // defined(__SYCL_DEVICE_ONLY__)
+    {
+      // Otherwise, we fallback to per-element conversion:
+      for (size_t I = 0; I < NumElements; ++I) {
+        Result.setValue(
+            I, vec_data<convertT>::get(
+                   detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
+                       vec_data<DataT>::get(getValue(I)))));
+      }
+    }
+
+    return Result;
+  }
+
+  template <typename asT> asT as() const {
+    static_assert((sizeof(*this) == sizeof(asT)),
+                  "The new SYCL vec type must have the same storage size in "
+                  "bytes as this SYCL vec");
+    static_assert(
+        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
+            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
+        "asT must be SYCL vec of a different element type and "
+        "number of elements specified by asT");
+    asT Result;
+    detail::memcpy(&Result.m_Data, &m_Data, sizeof(decltype(Result.m_Data)));
+    return Result;
+  }
+
+  template <int... SwizzleIndexes> Swizzle<SwizzleIndexes...> swizzle() {
+    return this;
+  }
+
+  template <int... SwizzleIndexes>
+  ConstSwizzle<SwizzleIndexes...> swizzle() const {
+    return this;
+  }
+
+  // ext_vector_type is used as an underlying type for sycl::vec on device.
+  // The problem is that for clang vector types the return of operator[] is a
+  // temporary and not a reference to the element in the vector. In practice
+  // reinterpret_cast<DataT *>(&m_Data)[i]; is working. According to
+  // http://llvm.org/docs/GetElementPtr.html#can-gep-index-into-vector-elements
+  // this is not disallowed now. But could probably be disallowed in the future.
+  // That is why tests are added to check that behavior of the compiler has
+  // not changed.
+  //
+  // Implement operator [] in the same way for host and device.
+  // TODO: change host side implementation when underlying type for host side
+  // will be changed to std::array.
+  // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
+  // aggressively optimized. Specializing with noinline to avoid as workaround.
+
+  template <typename T = DataT>
+  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                            const DataT &>
+  operator[](int i) const {
+    return reinterpret_cast<const DataT *>(&m_Data)[i];
+  }
+
+  template <typename T = DataT>
+  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                            DataT &>
+  operator[](int i) {
+    return reinterpret_cast<DataT *>(&m_Data)[i];
+  }
+
+#ifdef _MSC_VER
+#define __SYCL_NOINLINE_BF16 __declspec(noinline)
+#else
+#define __SYCL_NOINLINE_BF16 __attribute__((noinline))
+#endif
+
+  template <typename T = DataT>
+  __SYCL_NOINLINE_BF16
+      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                const DataT &>
+      operator[](int i) const {
+    return reinterpret_cast<const DataT *>(&m_Data)[i];
+  }
+
+  template <typename T = DataT>
+  __SYCL_NOINLINE_BF16
+      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                DataT &>
+      operator[](int i) {
+    return reinterpret_cast<DataT *>(&m_Data)[i];
+  }
+
+#undef __SYCL_NOINLINE_BF16
+
+  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
+private:
+  // Indexer used in the swizzles.def
+  // Currently it is defined as a template struct. Replacing it with a constexpr
+  // function would activate a bug in MSVC that is fixed only in v19.20.
+  // Until then MSVC does not recognize such constexpr functions as const and
+  // thus does not let using them in template parameters inside swizzle.def.
+  template <int Index> struct Indexer {
+    static constexpr int value = Index;
+  };
+
+public:
+#ifdef __SYCL_ACCESS_RETURN
+#error "Undefine __SYCL_ACCESS_RETURN macro"
+#endif
+#define __SYCL_ACCESS_RETURN this
+#include "swizzles.def"
+#undef __SYCL_ACCESS_RETURN
+  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
+
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t Offset, multi_ptr<const DataT, Space, DecorateAddress> Ptr) {
+    for (int I = 0; I < NumElements; I++) {
+      setValue(I, *multi_ptr<const DataT, Space, DecorateAddress>(
+                      Ptr + Offset * NumElements + I));
+    }
+  }
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t Offset, multi_ptr<DataT, Space, DecorateAddress> Ptr) {
+    multi_ptr<const DataT, Space, DecorateAddress> ConstPtr(Ptr);
+    load(Offset, ConstPtr);
+  }
+  template <int Dimensions, access::mode Mode,
+            access::placeholder IsPlaceholder, access::target Target,
+            typename PropertyListT>
+  void
+  load(size_t Offset,
+       accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
+           Acc) {
+    multi_ptr<const DataT, detail::TargetToAS<Target>::AS,
+              access::decorated::yes>
+        MultiPtr(Acc);
+    load(Offset, MultiPtr);
+  }
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void store(size_t Offset,
+             multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
+    for (int I = 0; I < NumElements; I++) {
+      *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
+                                                I) = getValue(I);
+    }
+  }
+  template <int Dimensions, access::mode Mode,
+            access::placeholder IsPlaceholder, access::target Target,
+            typename PropertyListT>
+  void
+  store(size_t Offset,
+        accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
+            Acc) {
+    multi_ptr<DataT, detail::TargetToAS<Target>::AS, access::decorated::yes>
+        MultiPtr(Acc);
+    store(Offset, MultiPtr);
+  }
+
+  void ConvertToDataT() {
+    for (size_t i = 0; i < NumElements; ++i) {
+      DataT tmp = getValue(i);
+      setValue(i, tmp);
+    }
+  }
+
+#ifdef __SYCL_BINOP
+#error "Undefine __SYCL_BINOP macro"
+#endif
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
+  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+    vec Ret;                                                                   \
+    if constexpr (IsUsingArrayOnDevice) {                                      \
+      for (size_t I = 0; I < NumElements; ++I) {                               \
+        Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
+      }                                                                        \
+    } else {                                                                   \
+      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+      if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
+        Ret.ConvertToDataT();                                                  \
+      }                                                                        \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+    return Lhs BINOP vec(Rhs);                                                 \
+  }                                                                            \
+  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+    return vec(Lhs) BINOP Rhs;                                                 \
+  }                                                                            \
+  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+    Lhs = Lhs BINOP Rhs;                                                       \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <int Num = NumElements>                                             \
+  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
+      vec & Lhs, const DataT & Rhs) {                                          \
+    Lhs = Lhs BINOP vec(Rhs);                                                  \
+    return Lhs;                                                                \
+  }
+
+#else // __SYCL_USE_EXT_VECTOR_TYPE__
+
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
+  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+    vec Ret{};                                                                 \
+    if constexpr (NativeVec)                                                   \
+      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+    else                                                                       \
+      for (size_t I = 0; I < NumElements; ++I)                                 \
+        Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(             \
+                            I)) BINOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+    return Lhs BINOP vec(Rhs);                                                 \
+  }                                                                            \
+  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+    return vec(Lhs) BINOP Rhs;                                                 \
+  }                                                                            \
+  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+    Lhs = Lhs BINOP Rhs;                                                       \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <int Num = NumElements>                                             \
+  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
+      vec & Lhs, const DataT & Rhs) {                                          \
+    Lhs = Lhs BINOP vec(Rhs);                                                  \
+    return Lhs;                                                                \
+  }
+
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  __SYCL_BINOP(+, +=, true)
+  __SYCL_BINOP(-, -=, true)
+  __SYCL_BINOP(*, *=, false)
+  __SYCL_BINOP(/, /=, false)
+
+  // TODO: The following OPs are available only when: DataT != cl_float &&
+  // DataT != cl_double && DataT != cl_half
+  __SYCL_BINOP(%, %=, false)
+  __SYCL_BINOP(|, |=, false)
+  __SYCL_BINOP(&, &=, false)
+  __SYCL_BINOP(^, ^=, false)
+  __SYCL_BINOP(>>, >>=, false)
+  __SYCL_BINOP(<<, <<=, true)
+#undef __SYCL_BINOP
+#undef __SYCL_BINOP_HELP
+
+  // Note: vec<>/SwizzleOp logical value is 0/-1 logic, as opposed to 0/1 logic.
+  // As far as CTS validation is concerned, 0/-1 logic also applies when
+  // NumElements is equal to one, which is somewhat inconsistent with being
+  // transparent with scalar data.
+  // TODO: Determine if vec<, NumElements=1> is needed at all, remove this
+  // inconsistency if not by disallowing one-element vectors (as in OpenCL)
+
+#ifdef __SYCL_RELLOGOP
+#error "Undefine __SYCL_RELLOGOP macro"
+#endif
+// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
+// by SYCL device compiler only.
+#ifdef __SYCL_DEVICE_ONLY__
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const vec & Rhs) {          \
+    vec<rel_t, NumElements> Ret{};                                             \
+    /* This special case is needed since there are no standard operator||   */ \
+    /* or operator&& functions for std::array.                              */ \
+    if constexpr (IsUsingArrayOnDevice &&                                      \
+                  (std::string_view(#RELLOGOP) == "||" ||                      \
+                   std::string_view(#RELLOGOP) == "&&")) {                     \
+      for (size_t I = 0; I < NumElements; ++I) {                               \
+        /* We cannot use SetValue here as the operator is not a friend of*/    \
+        /* Ret on Windows. */                                                  \
+        Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                    \
+            Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+      }                                                                        \
+    } else {                                                                   \
+      Ret = vec<rel_t, NumElements>(                                           \
+          (typename vec<rel_t, NumElements>::vector_t)(                        \
+              Lhs.m_Data RELLOGOP Rhs.m_Data));                                \
+      if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
+        Ret *= -1;                                                             \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const DataT & Rhs) {        \
+    return Lhs RELLOGOP vec(Rhs);                                              \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
+                                                   const vec & Rhs) {          \
+    return vec(Lhs) RELLOGOP Rhs;                                              \
+  }
+
+#else
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const vec & Rhs) {          \
+    vec<rel_t, NumElements> Ret{};                                             \
+    for (size_t I = 0; I < NumElements; ++I) {                                 \
+      /* We cannot use SetValue here as the operator is not a friend of*/      \
+      /* Ret on Windows. */                                                    \
+      Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                      \
+          Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));   \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const DataT & Rhs) {        \
+    return Lhs RELLOGOP vec(Rhs);                                              \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
+                                                   const vec & Rhs) {          \
+    return vec(Lhs) RELLOGOP Rhs;                                              \
+  }
+#endif
+
+  __SYCL_RELLOGOP(==)
+  __SYCL_RELLOGOP(!=)
+  __SYCL_RELLOGOP(>)
+  __SYCL_RELLOGOP(<)
+  __SYCL_RELLOGOP(>=)
+  __SYCL_RELLOGOP(<=)
+  // TODO: limit to integral types.
+  __SYCL_RELLOGOP(&&)
+  __SYCL_RELLOGOP(||)
+#undef __SYCL_RELLOGOP
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  friend vec &operator UOP(vec & Rhs) {                                        \
+    Rhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    return Rhs;                                                                \
+  }                                                                            \
+  friend vec operator UOP(vec &Lhs, int) {                                     \
+    vec Ret(Lhs);                                                              \
+    Lhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  // operator~() available only when: dataT != float && dataT != double
+  // && dataT != half
+  friend vec operator~(const vec &Rhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I) {
+        Ret.setValue(I, ~Rhs.getValue(I));
+      }
+      return Ret;
+    } else {
+      vec Ret{(typename vec::DataType) ~Rhs.m_Data};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+      return Ret;
+    }
+  }
+
+  // operator!
+  friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I) {
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        // std::byte neither supports ! unary op or casting, so special handling
+        // is needed. And, worse, Windows has a conflict with 'byte'.
+        if constexpr (std::is_same_v<std::byte, DataT>) {
+          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
+        } else
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        {
+          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
+        }
+      }
+      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
+    } else {
+      return vec{(typename vec<DataT, NumElements>::DataType) !Rhs.m_Data}
+          .template as<vec<detail::rel_t<DataT>, NumElements>>();
+    }
+  }
+
+  // operator +
+  friend vec operator+(const vec &Lhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(
+            I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
+      return Ret;
+    } else {
+      return vec{+Lhs.m_Data};
+    }
+  }
+
+  // operator -
+  friend vec operator-(const vec &Lhs) {
+    namespace oneapi = sycl::ext::oneapi;
+    vec Ret{};
+    if constexpr (IsBfloat16 && NumElements == 1) {
+      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data);
+      oneapi::bfloat16 w = -v;
+      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
+    } else if constexpr (IsBfloat16) {
+      for (size_t I = 0; I < NumElements; I++) {
+        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[I]);
+        oneapi::bfloat16 w = -v;
+        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
+      }
+    } else if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(
+            I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
+      return Ret;
+    } else {
+      Ret = vec{-Lhs.m_Data};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+      return Ret;
+    }
+  }
+
+  // OP is: &&, ||
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
+
+  // OP is: ==, !=, <, >, <=, >=
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
+private:
+  // Generic method that execute "Operation" on underlying values.
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <template <typename> class Operation,
+            typename Ty = vec<DataT, NumElements>>
+  vec<DataT, NumElements>
+  operatorHelper(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataType> Op;
+    Result.m_Data = Op(m_Data, Rhs.m_Data);
+    return Result;
+  }
+
+  template <template <typename> class Operation,
+            typename Ty = vec<DataT, NumElements>>
+  vec<DataT, NumElements>
+  operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataT> Op;
+    for (size_t I = 0; I < NumElements; ++I) {
+      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
+    }
+    return Result;
+  }
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+  template <template <typename> class Operation>
+  vec<DataT, NumElements>
+  operatorHelper(const vec<DataT, NumElements> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataT> Op;
+    for (size_t I = 0; I < NumElements; ++I) {
+      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
+    }
+    return Result;
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // setValue and getValue should be able to operate on different underlying
+  // types: enum cl_float#N , builtin vector float#N, builtin type float.
+  // These versions are for N > 1.
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
+                          int) {
+    m_Data[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
+    return vec_data<DataT>::get(m_Data[Index]);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
+    m_Data.s[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
+    return vec_data<DataT>::get(m_Data.s[Index]);
+  }
+#else // __SYCL_USE_EXT_VECTOR_TYPE__
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(int Index, const DataT &Value, int) {
+    m_Data[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(int Index, int) const {
+    return vec_data<DataT>::get(m_Data[Index]);
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // N==1 versions, used by host and device. Shouldn't trailing type be int?
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 == Num>>
+  constexpr void setValue(int, const DataT &Value, float) {
+    m_Data = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 == Num>>
+  DataT getValue(int, float) const {
+    return vec_data<DataT>::get(m_Data);
+  }
+
+  // setValue and getValue.
+  // The "api" functions used by BINOP etc.  These versions just dispatch
+  // using additional int or float arg to disambiguate vec<1> vs. vec<N>
+  // Special proxies as specialization is not allowed in class scope.
+  constexpr void setValue(int Index, const DataT &Value) {
+    if (NumElements == 1)
+      setValue(Index, Value, 0);
+    else
+      setValue(Index, Value, 0.f);
+  }
+
+  DataT getValue(int Index) const {
+    return (NumElements == 1) ? getValue(Index, 0) : getValue(Index, 0.f);
+  }
+
+  // fields
+
+  // Alignment is the same as size, to a maximum size of 64.
+  // detail::vector_alignment will return that value.
+  alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
+
+  // friends
+  template <typename T1, typename T2, typename T3, template <typename> class T4,
+            int... T5>
+  friend class detail::SwizzleOp;
+  template <typename T1, int T2> friend class vec;
+};
+
+#ifdef __cpp_deduction_guides
+// all compilers supporting deduction guides also support fold expressions
+template <class T, class... U,
+          class = std::enable_if_t<(std::is_same_v<T, U> && ...)>>
+vec(T, U...) -> vec<T, sizeof...(U) + 1>;
+#endif
+
+namespace detail {
+
+// SwizzleOP represents expression templates that operate on vec.
+// Actual computation performed on conversion or assignment operators.
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp {
+  using DataT = typename VecT::element_type;
+  // Certain operators return a vector with a different element type. Also, the
+  // left and right operand types may differ. CommonDataT selects a result type
+  // based on these types to ensure that the result value can be represented.
+  //
+  // Example 1:
+  //   sycl::vec<unsigned char, 4> vec{...};
+  //   auto result = 300u + vec.x();
+  //
+  // CommonDataT is std::common_type_t<OperationLeftT, OperationRightT> since
+  // it's larger than unsigned char.
+  //
+  // Example 2:
+  //   sycl::vec<bool, 1> vec{...};
+  //   auto result = vec.template swizzle<sycl::elem::s0>() && vec;
+  //
+  // CommonDataT is DataT since operator&& returns a vector with element type
+  // int8_t, which is larger than bool.
+  //
+  // Example 3:
+  //   sycl::vec<std::byte, 4> vec{...}; auto swlo = vec.lo();
+  //   auto result = swlo == swlo;
+  //
+  // CommonDataT is DataT since operator== returns a vector with element type
+  // int8_t, which is the same size as std::byte. std::common_type_t<DataT, ...>
+  // can't be used here since there's no type that int8_t and std::byte can both
+  // be implicitly converted to.
+  using OpLeftDataT = typename OperationLeftT::DataT;
+  using OpRightDataT = typename OperationRightT::DataT;
+  using CommonDataT = std::conditional_t<
+      sizeof(DataT) >= sizeof(std::common_type_t<OpLeftDataT, OpRightDataT>),
+      DataT, std::common_type_t<OpLeftDataT, OpRightDataT>>;
+  static constexpr int getNumElements() { return sizeof...(Indexes); }
+
+  using rel_t = detail::rel_t<DataT>;
+  using vec_t = vec<DataT, sizeof...(Indexes)>;
+  using vec_rel_t = vec<rel_t, sizeof...(Indexes)>;
+
+  template <typename OperationRightT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewLHOp = SwizzleOp<VecT,
+                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                      OperationCurrentT, Indexes...>,
+                            OperationRightT_, OperationCurrentT_, Idx_...>;
+
+  template <typename OperationRightT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewRelOp = SwizzleOp<vec<rel_t, VecT::getNumElements()>,
+                             SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                       OperationCurrentT, Indexes...>,
+                             OperationRightT_, OperationCurrentT_, Idx_...>;
+
+  template <typename OperationLeftT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewRHOp = SwizzleOp<VecT, OperationLeftT_,
+                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                      OperationCurrentT, Indexes...>,
+                            OperationCurrentT_, Idx_...>;
+
+  template <int IdxNum, typename T = void>
+  using EnableIfOneIndex = typename std::enable_if_t<
+      1 == IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+
+  template <int IdxNum, typename T = void>
+  using EnableIfMultipleIndexes = typename std::enable_if_t<
+      1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+
+  template <typename T>
+  using EnableIfScalarType = typename std::enable_if_t<
+      std::is_convertible_v<DataT, T> &&
+      (std::is_fundamental_v<vec_data_t<T>> ||
+       detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+
+  template <typename T>
+  using EnableIfNoScalarType = typename std::enable_if_t<
+      !std::is_convertible_v<DataT, T> ||
+      !(std::is_fundamental_v<vec_data_t<T>> ||
+        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+
+  template <int... Indices>
+  using Swizzle =
+      SwizzleOp<VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
+
+  template <int... Indices>
+  using ConstSwizzle =
+      SwizzleOp<const VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
+
+public:
+  using element_type = DataT;
+  using value_type = DataT;
+
+#ifdef __SYCL_DEVICE_ONLY__
+  using vector_t = typename vec_t::vector_t;
+#endif // __SYCL_DEVICE_ONLY__
+
+  const DataT &operator[](int i) const {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    return (*m_Vector)[Idxs[i]];
+  }
+
+  template <typename _T = VecT>
+  std::enable_if_t<!std::is_const_v<_T>, DataT> &operator[](int i) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    return (*m_Vector)[Idxs[i]];
+  }
+
+  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
+  size_t get_count() const { return size(); }
+  static constexpr size_t size() noexcept { return getNumElements(); }
+
+  template <int Num = getNumElements()>
+  __SYCL2020_DEPRECATED(
+      "get_size() is deprecated, please use byte_size() instead")
+  size_t get_size() const {
+    return byte_size<Num>();
+  }
+
+  template <int Num = getNumElements()> size_t byte_size() const noexcept {
+    return sizeof(DataT) * (Num == 3 ? 4 : Num);
+  }
+
+  template <typename T, int IdxNum = getNumElements(),
+            typename = EnableIfOneIndex<IdxNum>,
+            typename = EnableIfScalarType<T>>
+  operator T() const {
+    return getValue(0);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>
+  operator*(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::plus, Indexes...>
+  operator+(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::plus, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::divides, Indexes...>
+  operator/(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::divides, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  // TODO: Check that Rhs arg is suitable.
+#ifdef __SYCL_OPASSIGN
+#error "Undefine __SYCL_OPASSIGN macro."
+#endif
+#define __SYCL_OPASSIGN(OPASSIGN, OP)                                          \
+  SwizzleOp &operator OPASSIGN(const DataT & Rhs) {                            \
+    operatorHelper<OP>(vec_t(Rhs));                                            \
+    return *this;                                                              \
+  }                                                                            \
+  template <typename RhsOperation>                                             \
+  SwizzleOp &operator OPASSIGN(const RhsOperation & Rhs) {                     \
+    operatorHelper<OP>(Rhs);                                                   \
+    return *this;                                                              \
+  }
+
+  __SYCL_OPASSIGN(+=, std::plus)
+  __SYCL_OPASSIGN(-=, std::minus)
+  __SYCL_OPASSIGN(*=, std::multiplies)
+  __SYCL_OPASSIGN(/=, std::divides)
+  __SYCL_OPASSIGN(%=, std::modulus)
+  __SYCL_OPASSIGN(&=, std::bit_and)
+  __SYCL_OPASSIGN(|=, std::bit_or)
+  __SYCL_OPASSIGN(^=, std::bit_xor)
+  __SYCL_OPASSIGN(>>=, RShift)
+  __SYCL_OPASSIGN(<<=, LShift)
+#undef __SYCL_OPASSIGN
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  SwizzleOp &operator UOP() {                                                  \
+    *this OPASSIGN static_cast<DataT>(1);                                      \
+    return *this;                                                              \
+  }                                                                            \
+  vec_t operator UOP(int) {                                                    \
+    vec_t Ret = *this;                                                         \
+    *this OPASSIGN static_cast<DataT>(1);                                      \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  template <typename T = DataT>
+  friend typename std::enable_if_t<
+      std::is_same_v<T, DataT> && std::is_integral_v<vec_data_t<T>>, vec_t>
+  operator~(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return ~Tmp;
+  }
+
+  friend vec_rel_t operator!(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return !Tmp;
+  }
+
+  friend vec_t operator+(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return +Tmp;
+  }
+
+  friend vec_t operator-(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return -Tmp;
+  }
+
+// scalar BINOP vec<>
+// scalar BINOP SwizzleOp
+// vec<> BINOP SwizzleOp
+#ifdef __SYCL_BINOP
+#error "Undefine __SYCL_BINOP macro"
+#endif
+#define __SYCL_BINOP(BINOP)                                                    \
+  friend vec_t operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {        \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs BINOP Tmp;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {        \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp BINOP Rhs;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {        \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs BINOP Tmp;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {        \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp BINOP Rhs;                                                      \
+  }
+
+  __SYCL_BINOP(+)
+  __SYCL_BINOP(-)
+  __SYCL_BINOP(*)
+  __SYCL_BINOP(/)
+  __SYCL_BINOP(%)
+  __SYCL_BINOP(&)
+  __SYCL_BINOP(|)
+  __SYCL_BINOP(^)
+  __SYCL_BINOP(>>)
+  __SYCL_BINOP(<<)
+#undef __SYCL_BINOP
+
+// scalar RELLOGOP vec<>
+// scalar RELLOGOP SwizzleOp
+// vec<> RELLOGOP SwizzleOp
+#ifdef __SYCL_RELLOGOP
+#error "Undefine __SYCL_RELLOGOP macro"
+#endif
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec_rel_t operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs RELLOGOP Tmp;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp RELLOGOP Rhs;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs RELLOGOP Tmp;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp RELLOGOP Rhs;                                                   \
+  }
+
+  __SYCL_RELLOGOP(==)
+  __SYCL_RELLOGOP(!=)
+  __SYCL_RELLOGOP(>)
+  __SYCL_RELLOGOP(<)
+  __SYCL_RELLOGOP(>=)
+  __SYCL_RELLOGOP(<=)
+  // TODO: limit to integral types.
+  __SYCL_RELLOGOP(&&)
+  __SYCL_RELLOGOP(||)
+#undef __SYCL_RELLOGOP
+
+  template <int IdxNum = getNumElements(),
+            typename = EnableIfMultipleIndexes<IdxNum>>
+  SwizzleOp &operator=(const vec<DataT, IdxNum> &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
+  SwizzleOp &operator=(const DataT &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    m_Vector->setValue(Idxs[0], Rhs);
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(),
+            EnableIfMultipleIndexes<IdxNum, bool> = true>
+  SwizzleOp &operator=(const DataT &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    for (auto Idx : Idxs) {
+      m_Vector->setValue(Idx, Rhs);
+    }
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
+  SwizzleOp &operator=(DataT &&Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    m_Vector->setValue(Idxs[0], Rhs);
+    return *this;
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>
+  operator*(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::multiplies, Indexes...>
+  operator*(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::multiplies, Indexes...>(m_Vector, *this,
+                                                              Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::plus, Indexes...> operator+(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::plus, Indexes...>(m_Vector, *this,
+                                                          GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::plus, Indexes...>
+  operator+(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::plus, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::minus, Indexes...>
+  operator-(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::minus, Indexes...>(m_Vector, *this,
+                                                           GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::minus, Indexes...>
+  operator-(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::minus, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::divides, Indexes...>
+  operator/(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::divides, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::divides, Indexes...>
+  operator/(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::divides, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>
+  operator%(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::modulus, Indexes...>
+  operator%(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::modulus, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>
+  operator&(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_and, Indexes...>
+  operator&(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_and, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>
+  operator|(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_or, Indexes...>
+  operator|(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_or, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>
+  operator^(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_xor, Indexes...>
+  operator^(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_xor, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, RShift, Indexes...> operator>>(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, RShift, Indexes...>(m_Vector, *this,
+                                                       GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, RShift, Indexes...>
+  operator>>(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, RShift, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, LShift, Indexes...> operator<<(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, LShift, Indexes...>(m_Vector, *this,
+                                                       GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, LShift, Indexes...>
+  operator<<(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, LShift, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  SwizzleOp &operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  SwizzleOp &operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, EqualTo, Indexes...> operator==(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, EqualTo, Indexes...>(NULL, *this,
+                                                         GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, EqualTo, Indexes...>
+  operator==(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, EqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>
+  operator!=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, NotEqualTo, Indexes...>
+  operator!=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, NotEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>
+  operator>=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>
+  operator>=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>
+  operator<=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LessEqualTo, Indexes...>
+  operator<=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LessEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>
+  operator>(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, GreaterThan, Indexes...>
+  operator>(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, GreaterThan, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LessThan, Indexes...> operator<(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LessThan, Indexes...>(NULL, *this,
+                                                          GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LessThan, Indexes...>
+  operator<(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LessThan, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>
+  operator&&(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LogicalAnd, Indexes...>
+  operator&&(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LogicalAnd, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>
+  operator||(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>(NULL, *this,
+                                                           GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LogicalOr, Indexes...>
+  operator||(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LogicalOr, Indexes...>(NULL, *this, Rhs);
+  }
+
+  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
+private:
+  // Indexer used in the swizzles.def.
+  // Currently it is defined as a template struct. Replacing it with a constexpr
+  // function would activate a bug in MSVC that is fixed only in v19.20.
+  // Until then MSVC does not recognize such constexpr functions as const and
+  // thus does not let using them in template parameters inside swizzle.def.
+  template <int Index> struct Indexer {
+    static constexpr int IDXs[sizeof...(Indexes)] = {Indexes...};
+    static constexpr int value = IDXs[Index >= getNumElements() ? 0 : Index];
+  };
+
+public:
+#ifdef __SYCL_ACCESS_RETURN
+#error "Undefine __SYCL_ACCESS_RETURN macro"
+#endif
+#define __SYCL_ACCESS_RETURN m_Vector
+#include "swizzles.def"
+#undef __SYCL_ACCESS_RETURN
+  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
+
+  // Leave store() interface to automatic conversion to vec<>.
+  // Load to vec_t and then assign to swizzle.
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t offset, multi_ptr<DataT, Space, DecorateAddress> ptr) {
+    vec_t Tmp;
+    Tmp.template load(offset, ptr);
+    *this = Tmp;
+  }
+
+  template <typename convertT, rounding_mode roundingMode>
+  vec<convertT, sizeof...(Indexes)> convert() const {
+    // First materialize the swizzle to vec_t and then apply convert() to it.
+    vec_t Tmp = *this;
+    return Tmp.template convert<convertT, roundingMode>();
+  }
+
+  template <typename asT> asT as() const {
+    // First materialize the swizzle to vec_t and then apply as() to it.
+    vec_t Tmp = *this;
+    static_assert((sizeof(Tmp) == sizeof(asT)),
+                  "The new SYCL vec type must have the same storage size in "
+                  "bytes as this SYCL swizzled vec");
+    static_assert(
+        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
+            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
+        "asT must be SYCL vec of a different element type and "
+        "number of elements specified by asT");
+    return Tmp.template as<asT>();
+  }
+
+private:
+  SwizzleOp(const SwizzleOp &Rhs)
+      : m_Vector(Rhs.m_Vector), m_LeftOperation(Rhs.m_LeftOperation),
+        m_RightOperation(Rhs.m_RightOperation) {}
+
+  SwizzleOp(VecT *Vector, OperationLeftT LeftOperation,
+            OperationRightT RightOperation)
+      : m_Vector(Vector), m_LeftOperation(LeftOperation),
+        m_RightOperation(RightOperation) {}
+
+  SwizzleOp(VecT *Vector) : m_Vector(Vector) {}
+
+  SwizzleOp(SwizzleOp &&Rhs)
+      : m_Vector(Rhs.m_Vector), m_LeftOperation(std::move(Rhs.m_LeftOperation)),
+        m_RightOperation(std::move(Rhs.m_RightOperation)) {}
+
+  // Either performing CurrentOperation on results of left and right operands
+  // or reading values from actual vector. Perform implicit type conversion when
+  // the number of elements == 1
+
+  template <int IdxNum = getNumElements()>
+  CommonDataT getValue(EnableIfOneIndex<IdxNum, size_t> Index) const {
+    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
+      std::array<int, getNumElements()> Idxs{Indexes...};
+      return m_Vector->getValue(Idxs[Index]);
+    }
+    auto Op = OperationCurrentT<vec_data_t<CommonDataT>>();
+    return vec_data<CommonDataT>::get(
+        Op(vec_data<CommonDataT>::get(m_LeftOperation.getValue(Index)),
+           vec_data<CommonDataT>::get(m_RightOperation.getValue(Index))));
+  }
+
+  template <int IdxNum = getNumElements()>
+  DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
+    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
+      std::array<int, getNumElements()> Idxs{Indexes...};
+      return m_Vector->getValue(Idxs[Index]);
+    }
+    auto Op = OperationCurrentT<vec_data_t<DataT>>();
+    return vec_data<DataT>::get(
+        Op(vec_data<DataT>::get(m_LeftOperation.getValue(Index)),
+           vec_data<DataT>::get(m_RightOperation.getValue(Index))));
+  }
+
+  template <template <typename> class Operation, typename RhsOperation>
+  void operatorHelper(const RhsOperation &Rhs) {
+    Operation<vec_data_t<DataT>> Op;
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      DataT Res = vec_data<DataT>::get(
+          Op(vec_data<DataT>::get(m_Vector->getValue(Idxs[I])),
+             vec_data<DataT>::get(Rhs.getValue(I))));
+      m_Vector->setValue(Idxs[I], Res);
+    }
+  }
+
+  // fields
+  VecT *m_Vector;
+
+  OperationLeftT m_LeftOperation;
+  OperationRightT m_RightOperation;
+
+  // friends
+  template <typename T1, int T2> friend class sycl::vec;
+
+  template <typename T1, typename T2, typename T3, template <typename> class T4,
+            int... T5>
+  friend class SwizzleOp;
+};
+} // namespace detail
+
+namespace detail {
+
+// Vectors of size 1 are handled separately and therefore 1 is not included in
+// the check below.
+constexpr bool isValidVectorSize(int N) {
+  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
+}
+template <typename T, int N, typename V> struct VecStorage {
+  static_assert(
+      isValidVectorSize(N) || N == 1,
+      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
+      "or 16 are supported");
+  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
+};
+
+#ifdef __SYCL_DEVICE_ONLY__
+// device always has ext vector support, but for huge vectors
+// we switch to std::array, so that we can use a smaller alignment (64)
+// this is to support MSVC, which has a max of 64 for direct params.
+template <typename T, int N> struct VecStorageImpl {
+  static constexpr size_t Num = (N == 3) ? 4 : N;
+  static constexpr size_t Sz = Num * sizeof(T);
+  using DataType =
+      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
+                                std::array<T, Num>>::type;
+  using VectorDataType = T __attribute__((ext_vector_type(N)));
+};
+#else // __SYCL_DEVICE_ONLY__
+template <typename T, int N> struct VecStorageImpl {
+  using DataType = std::array<T, (N == 3) ? 4 : N>;
+};
+#endif // __SYCL_DEVICE_ONLY__
+
+// Single element bool
+template <> struct VecStorage<bool, 1, void> {
+  using DataType = bool;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = bool;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Multiple element bool
+template <int N>
+struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
+  using DataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+// Single element byte. Multiple elements will propagate through a later
+// specialization.
+template <> struct VecStorage<std::byte, 1, void> {
+  using DataType = std::int8_t;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = std::int8_t;
+#endif // __SYCL_DEVICE_ONLY__
+};
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+
+// Single element signed integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element unsigned integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element floating-point (except half/bfloat16)
+template <typename T>
+struct VecStorage<
+    T, 1,
+    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+// Multiple elements signed/unsigned integers and floating-point (except
+// half/bfloat16)
+template <typename T, int N>
+struct VecStorage<
+    T, N,
+    typename std::enable_if_t<isValidVectorSize(N) &&
+                              (is_sgeninteger_v<T> ||
+                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
+  using DataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element half
+template <> struct VecStorage<half, 1, void> {
+  using DataType = sycl::detail::half_impl::StorageT;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = sycl::detail::half_impl::StorageT;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Multiple elements half
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
+  };
+#else // defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+  };
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+__SYCL_DEFINE_HALF_VECSTORAGE(2)
+__SYCL_DEFINE_HALF_VECSTORAGE(3)
+__SYCL_DEFINE_HALF_VECSTORAGE(4)
+__SYCL_DEFINE_HALF_VECSTORAGE(8)
+__SYCL_DEFINE_HALF_VECSTORAGE(16)
+#undef __SYCL_DEFINE_HALF_VECSTORAGE
+
+// Single element bfloat16
+template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
+  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  // using VectorDataType = sycl::ext::oneapi::bfloat16;
+  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+};
+// Multiple elements bfloat16
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
+    using VectorDataType =                                                     \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
+  };
+__SYCL_DEFINE_BF16_VECSTORAGE(2)
+__SYCL_DEFINE_BF16_VECSTORAGE(3)
+__SYCL_DEFINE_BF16_VECSTORAGE(4)
+__SYCL_DEFINE_BF16_VECSTORAGE(8)
+__SYCL_DEFINE_BF16_VECSTORAGE(16)
+#undef __SYCL_DEFINE_BF16_VECSTORAGE
+} // namespace detail
+
+/// This macro must be defined to 1 when SYCL implementation allows user
+/// applications to explicitly declare certain class types as device copyable
+/// by adding specializations of is_device_copyable type trait class.
+#define SYCL_DEVICE_COPYABLE 1
+
+/// is_device_copyable is a user specializable class template to indicate
+/// that a type T is device copyable, which means that SYCL implementation
+/// may copy objects of the type T between host and device or between two
+/// devices.
+/// Specializing is_device_copyable such a way that
+/// is_device_copyable_v<T> == true on a T that does not satisfy all
+/// the requirements of a device copyable type is undefined behavior.
+template <typename T> struct is_device_copyable;
+
+namespace detail {
+template <typename T, typename = void>
+struct is_device_copyable_impl : std::is_trivially_copyable<T> {};
+
+template <typename T>
+struct is_device_copyable_impl<
+    T, std::enable_if_t<!std::is_same_v<T, std::remove_cv_t<T>>>>
+    // Cannot express this "recursion" (to take user's partial non-cv
+    // specializations into account) without this helper struct.
+    : is_device_copyable<std::remove_cv_t<T>> {};
+} // namespace detail
+
+template <typename T>
+struct is_device_copyable : detail::is_device_copyable_impl<T> {};
+
+// std::array<T, 0> is implicitly device copyable type.
+template <typename T>
+struct is_device_copyable<std::array<T, 0>> : std::true_type {};
+
+// std::array<T, N> is implicitly device copyable type if T is device copyable.
+template <typename T, std::size_t N>
+struct is_device_copyable<std::array<T, N>> : is_device_copyable<T> {};
+
+// std::optional<T> is implicitly device copyable type if T is device copyable.
+template <typename T>
+struct is_device_copyable<std::optional<T>> : is_device_copyable<T> {};
+
+// std::pair<T1, T2> is implicitly device copyable type if T1 and T2 are device
+// copyable.
+template <typename T1, typename T2>
+struct is_device_copyable<std::pair<T1, T2>>
+    : std::bool_constant<is_device_copyable<T1>::value &&
+                         is_device_copyable<T2>::value> {};
+
+// std::tuple<Ts...> is implicitly device copyable type if each type T of Ts...
+// is device copyable.
+template <typename... Ts>
+struct is_device_copyable<std::tuple<Ts...>>
+    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
+
+// std::variant<Ts...> is implicitly device copyable type if each type T of
+// Ts... is device copyable.
+template <typename... Ts>
+struct is_device_copyable<std::variant<Ts...>>
+    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
+
+// marray is device copyable if element type is device copyable.
+template <typename T, std::size_t N>
+struct is_device_copyable<sycl::marray<T, N>> : is_device_copyable<T> {};
+
+// array is device copyable if element type is device copyable.
+template <typename T, std::size_t N>
+struct is_device_copyable<T[N]> : is_device_copyable<T> {};
+
+template <typename T>
+inline constexpr bool is_device_copyable_v = is_device_copyable<T>::value;
+
+namespace detail {
+template <typename T, typename = void>
+struct IsDeprecatedDeviceCopyable : std::false_type {};
+
+// TODO: using C++ attribute [[deprecated]] or the macro __SYCL2020_DEPRECATED
+// does not produce expected warning message for the type 'T'.
+template <typename T>
+struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
+    IsDeprecatedDeviceCopyable<
+        T, std::enable_if_t<std::is_trivially_copy_constructible_v<T> &&
+                            std::is_trivially_destructible_v<T> &&
+                            !is_device_copyable_v<T>>> : std::true_type {};
+
+template <typename T, int N>
+struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
+    IsDeprecatedDeviceCopyable<T[N]> : IsDeprecatedDeviceCopyable<T> {};
+
+#ifdef __SYCL_DEVICE_ONLY__
+// Checks that the fields of the type T with indices 0 to (NumFieldsToCheck -
+// 1) are device copyable.
+template <typename T, unsigned NumFieldsToCheck>
+struct CheckFieldsAreDeviceCopyable
+    : CheckFieldsAreDeviceCopyable<T, NumFieldsToCheck - 1> {
+  using FieldT = decltype(__builtin_field_type(T, NumFieldsToCheck - 1));
+  static_assert(is_device_copyable_v<FieldT> ||
+                    detail::IsDeprecatedDeviceCopyable<FieldT>::value,
+                "The specified type is not device copyable");
+};
+
+template <typename T> struct CheckFieldsAreDeviceCopyable<T, 0> {};
+
+// Checks that the base classes of the type T with indices 0 to
+// (NumFieldsToCheck - 1) are device copyable.
+template <typename T, unsigned NumBasesToCheck>
+struct CheckBasesAreDeviceCopyable
+    : CheckBasesAreDeviceCopyable<T, NumBasesToCheck - 1> {
+  using BaseT = decltype(__builtin_base_type(T, NumBasesToCheck - 1));
+  static_assert(is_device_copyable_v<BaseT> ||
+                    detail::IsDeprecatedDeviceCopyable<BaseT>::value,
+                "The specified type is not device copyable");
+};
+
+template <typename T> struct CheckBasesAreDeviceCopyable<T, 0> {};
+
+// All the captures of a lambda or functor of type FuncT passed to a kernel
+// must be is_device_copyable, which extends to bases and fields of FuncT.
+// Fields are captures of lambda/functors and bases are possible base classes
+// of functors also allowed by SYCL.
+// The SYCL-2020 implementation must check each of the fields & bases of the
+// type FuncT, only one level deep, which is enough to see if they are all
+// device copyable by using the result of is_device_copyable returned for them.
+// At this moment though the check also allowes using types for which
+// (is_trivially_copy_constructible && is_trivially_destructible) returns true
+// and (is_device_copyable) returns false. That is the deprecated behavior and
+// is currently/temporarily supported only to not break older SYCL programs.
+template <typename FuncT>
+struct CheckDeviceCopyable
+    : CheckFieldsAreDeviceCopyable<FuncT, __builtin_num_fields(FuncT)>,
+      CheckBasesAreDeviceCopyable<FuncT, __builtin_num_bases(FuncT)> {};
+
+// Below are two specializations for CheckDeviceCopyable when a kernel lambda
+// is wrapped after range rounding optimization.
+template <typename TransformedArgType, int Dims, typename KernelType>
+struct CheckDeviceCopyable<
+    RoundedRangeKernel<TransformedArgType, Dims, KernelType>>
+    : CheckDeviceCopyable<KernelType> {};
+
+template <typename TransformedArgType, int Dims, typename KernelType>
+struct CheckDeviceCopyable<
+    RoundedRangeKernelWithKH<TransformedArgType, Dims, KernelType>>
+    : CheckDeviceCopyable<KernelType> {};
+
+#endif // __SYCL_DEVICE_ONLY__
+} // namespace detail
+
+} // namespace _V1
+} // namespace sycl

From d7adc6ebd828213c862c69a0add0c3c2bf1e09b5 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 24 Apr 2024 10:40:01 -0700
Subject: [PATCH 29/79] Create a seperate header for ABI breaking changes.

---
 sycl/include/sycl/types.hpp          |    5 +
 sycl/include/sycl/vector_preview.hpp | 2189 ++++++++++++++++++++++++++
 2 files changed, 2194 insertions(+)
 create mode 100644 sycl/include/sycl/vector_preview.hpp

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 4382b71c4b375..aa4059d2af203 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -49,6 +49,11 @@
 #include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
 #include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
 #include <sycl/multi_ptr.hpp>                  // for multi_ptr
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+#include <sycl/vector_preview.hpp>             // for sycl::vec and swizzles
+#else
+#include <sycl/vector.hpp>                     // for sycl::vec and swizzles
+#endif
 
 #include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
 
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
new file mode 100644
index 0000000000000..f1bf7fcfcc24d
--- /dev/null
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -0,0 +1,2189 @@
+//==---------------- vector.hpp --- Implements sycl::vec -------------------==//
+//
+// 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
+
+// Check if Clang's ext_vector_type attribute is available. Host compiler
+// may not be Clang, and Clang may not be built with the extension.
+#ifdef __clang__
+#ifndef __has_extension
+#define __has_extension(x) 0
+#endif
+#ifdef __HAS_EXT_VECTOR_TYPE__
+#error "Undefine __HAS_EXT_VECTOR_TYPE__ macro"
+#endif
+#if __has_extension(attribute_ext_vector_type)
+#define __HAS_EXT_VECTOR_TYPE__
+#endif
+#endif // __clang__
+
+#if !defined(__HAS_EXT_VECTOR_TYPE__) && defined(__SYCL_DEVICE_ONLY__)
+#error "SYCL device compiler is built without ext_vector_type support"
+#endif
+
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_USE_EXT_VECTOR_TYPE__
+#endif
+
+#include <sycl/access/access.hpp>              // for decorated, address_space
+#include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
+#include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
+#include <sycl/detail/defines_elementary.hpp>  // for __SYCL2020_DEPRECATED
+#include <sycl/detail/generic_type_lists.hpp>  // for vector_basic_list
+#include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
+#include <sycl/detail/memcpy.hpp>              // for memcpy
+#include <sycl/detail/type_list.hpp>           // for is_contained
+#include <sycl/detail/type_traits.hpp>         // for is_floating_point
+#include <sycl/detail/vector_convert.hpp>      // for convertImpl
+#include <sycl/detail/vector_traits.hpp>       // for vector_alignment
+#include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
+
+#include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
+
+#include <array>       // for array
+#include <assert.h>    // for assert
+#include <cstddef>     // for size_t, NULL, byte
+#include <cstdint>     // for uint8_t, int16_t, int...
+#include <functional>  // for divides, multiplies
+#include <iterator>    // for pair
+#include <ostream>     // for operator<<, basic_ost...
+#include <type_traits> // for enable_if_t, is_same
+#include <utility>     // for index_sequence, make_...
+
+namespace sycl {
+inline namespace _V1 {
+
+struct elem {
+  static constexpr int x = 0;
+  static constexpr int y = 1;
+  static constexpr int z = 2;
+  static constexpr int w = 3;
+  static constexpr int r = 0;
+  static constexpr int g = 1;
+  static constexpr int b = 2;
+  static constexpr int a = 3;
+  static constexpr int s0 = 0;
+  static constexpr int s1 = 1;
+  static constexpr int s2 = 2;
+  static constexpr int s3 = 3;
+  static constexpr int s4 = 4;
+  static constexpr int s5 = 5;
+  static constexpr int s6 = 6;
+  static constexpr int s7 = 7;
+  static constexpr int s8 = 8;
+  static constexpr int s9 = 9;
+  static constexpr int sA = 10;
+  static constexpr int sB = 11;
+  static constexpr int sC = 12;
+  static constexpr int sD = 13;
+  static constexpr int sE = 14;
+  static constexpr int sF = 15;
+};
+
+namespace detail {
+// select_apply_cl_t selects from T8/T16/T32/T64 basing on
+// sizeof(_IN).  expected to handle scalar types in _IN.
+template <typename _IN, typename T8, typename T16, typename T32, typename T64>
+using select_apply_cl_t = std::conditional_t<
+    sizeof(_IN) == 1, T8,
+    std::conditional_t<sizeof(_IN) == 2, T16,
+                       std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
+
+template <typename T> struct vec_helper {
+  using RetType = T;
+  static constexpr RetType get(T value) { return value; }
+  static constexpr RetType set(T value) { return value; }
+};
+template <> struct vec_helper<bool> {
+  using RetType = select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                    std::int32_t, std::int64_t>;
+  static constexpr RetType get(bool value) { return value; }
+  static constexpr RetType set(bool value) { return value; }
+};
+
+template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
+  using RetType = sycl::ext::oneapi::bfloat16;
+  using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  static constexpr RetType get(BFloat16StorageT value) {
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<RetType>(value);
+#else
+    // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+    // but neither available yet.
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.storage = value;
+    return result.bf16;
+#endif
+  }
+
+  static constexpr RetType get(RetType value) { return value; }
+
+  static constexpr BFloat16StorageT set(RetType value) {
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<BFloat16StorageT>(value);
+#else
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.bf16 = value;
+    return result.storage;
+#endif
+  }
+};
+
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+template <> struct vec_helper<std::byte> {
+  using RetType = std::uint8_t;
+  static constexpr RetType get(std::byte value) { return (RetType)value; }
+  static constexpr RetType set(std::byte value) { return (RetType)value; }
+  static constexpr std::byte get(std::uint8_t value) {
+    return (std::byte)value;
+  }
+  static constexpr std::byte set(std::uint8_t value) {
+    return (std::byte)value;
+  }
+};
+#endif
+
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp;
+
+template <typename T, int N, typename V = void> struct VecStorage;
+
+// Element type for relational operator return value.
+template <typename DataT>
+using rel_t = typename std::conditional_t<
+    sizeof(DataT) == sizeof(opencl::cl_char), opencl::cl_char,
+    typename std::conditional_t<
+        sizeof(DataT) == sizeof(opencl::cl_short), opencl::cl_short,
+        typename std::conditional_t<
+            sizeof(DataT) == sizeof(opencl::cl_int), opencl::cl_int,
+            typename std::conditional_t<sizeof(DataT) ==
+                                            sizeof(opencl::cl_long),
+                                        opencl::cl_long, bool>>>>;
+
+// Special type indicating that SwizzleOp should just read value from vector -
+// not trying to perform any operations. Should not be called.
+template <typename T> class GetOp {
+public:
+  using DataT = T;
+  DataT getValue(size_t) const { return (DataT)0; }
+  DataT operator()(DataT, DataT) { return (DataT)0; }
+};
+
+// Forward declarations
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernel;
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernelWithKH;
+
+// Vectors of size 1 are handled separately and therefore 1 is not included in
+// the check below.
+constexpr bool isValidVectorSize(int N) {
+  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
+}
+template <typename T, int N, typename V> struct VecStorage {
+  static_assert(
+      isValidVectorSize(N) || N == 1,
+      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
+      "or 16 are supported");
+  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
+};
+
+#ifdef __SYCL_DEVICE_ONLY__
+// device always has ext vector support, but for huge vectors
+// we switch to std::array, so that we can use a smaller alignment (64)
+// this is to support MSVC, which has a max of 64 for direct params.
+template <typename T, int N> struct VecStorageImpl {
+  static constexpr size_t Num = (N == 3) ? 4 : N;
+  static constexpr size_t Sz = Num * sizeof(T);
+  using DataType =
+      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
+                                std::array<T, Num>>::type;
+  using VectorDataType = T __attribute__((ext_vector_type(N)));
+};
+#else  // __SYCL_DEVICE_ONLY__
+template <typename T, int N> struct VecStorageImpl {
+  using DataType = std::array<T, (N == 3) ? 4 : N>;
+};
+#endif // __SYCL_DEVICE_ONLY__
+
+// Single element bool
+template <> struct VecStorage<bool, 1, void> {
+  using DataType = bool;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = bool;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Multiple element bool
+template <int N>
+struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
+  using DataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+// Single element byte. Multiple elements will propagate through a later
+// specialization.
+template <> struct VecStorage<std::byte, 1, void> {
+  using DataType = std::int8_t;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = std::int8_t;
+#endif // __SYCL_DEVICE_ONLY__
+};
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+
+// Single element signed integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element unsigned integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element floating-point (except half/bfloat16)
+template <typename T>
+struct VecStorage<
+    T, 1,
+    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+// Multiple elements signed/unsigned integers and floating-point (except
+// half/bfloat16)
+template <typename T, int N>
+struct VecStorage<
+    T, N,
+    typename std::enable_if_t<isValidVectorSize(N) &&
+                              (is_sgeninteger_v<T> ||
+                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
+  using DataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Single element half
+template <> struct VecStorage<half, 1, void> {
+  using DataType = sycl::detail::half_impl::StorageT;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = sycl::detail::half_impl::StorageT;
+#endif // __SYCL_DEVICE_ONLY__
+};
+
+// Multiple elements half
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
+  };
+#else // defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+  };
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+__SYCL_DEFINE_HALF_VECSTORAGE(2)
+__SYCL_DEFINE_HALF_VECSTORAGE(3)
+__SYCL_DEFINE_HALF_VECSTORAGE(4)
+__SYCL_DEFINE_HALF_VECSTORAGE(8)
+__SYCL_DEFINE_HALF_VECSTORAGE(16)
+#undef __SYCL_DEFINE_HALF_VECSTORAGE
+
+// Single element bfloat16
+template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
+  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  // using VectorDataType = sycl::ext::oneapi::bfloat16;
+  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+};
+// Multiple elements bfloat16
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
+    using VectorDataType =                                                     \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
+  };
+__SYCL_DEFINE_BF16_VECSTORAGE(2)
+__SYCL_DEFINE_BF16_VECSTORAGE(3)
+__SYCL_DEFINE_BF16_VECSTORAGE(4)
+__SYCL_DEFINE_BF16_VECSTORAGE(8)
+__SYCL_DEFINE_BF16_VECSTORAGE(16)
+#undef __SYCL_DEFINE_BF16_VECSTORAGE
+} // namespace detail
+
+template <typename T> using vec_data = detail::vec_helper<T>;
+
+template <typename T>
+using vec_data_t = typename detail::vec_helper<T>::RetType;
+
+///////////////////////// class sycl::vec /////////////////////////
+/// Provides a cross-patform vector class template that works efficiently on
+/// SYCL devices as well as in host C++ code.
+///
+/// \ingroup sycl_api
+template <typename Type, int NumElements> class vec {
+  using DataT = Type;
+
+  // This represent type of underlying value. There should be only one field
+  // in the class, so vec<float, 16> should be equal to float16 in memory.
+  using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
+
+  static constexpr bool IsHostHalf =
+      std::is_same_v<DataT, sycl::detail::half_impl::half> &&
+      std::is_same_v<sycl::detail::half_impl::StorageT,
+                     sycl::detail::host_half_impl::half>;
+
+  static constexpr bool IsBfloat16 =
+      std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
+
+  static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
+  static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
+  static constexpr bool IsSizeGreaterThanMaxAlign =
+      (Sz > detail::MaxVecAlignment);
+
+  // TODO: There is no support for vector half type on host yet.
+  // Also, when Sz is greater than alignment, we use std::array instead of
+  // vector extension. This is for MSVC compatibility, which has a max alignment
+  // of 64 for direct params. If we drop MSVC, we can have alignment the same as
+  // size and use vector extensions for all sizes.
+  static constexpr bool IsUsingArrayOnDevice =
+      (IsHostHalf || IsBfloat16 || IsSizeGreaterThanMaxAlign);
+
+#if defined(__SYCL_DEVICE_ONLY__)
+  static constexpr bool NativeVec = NumElements > 1 && !IsUsingArrayOnDevice;
+  static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
+#else
+  static constexpr bool NativeVec = false;
+  static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
+#endif
+
+  static constexpr int getNumElements() { return NumElements; }
+
+  // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
+  template <int Counter, int MaxValue, class...>
+  struct SizeChecker : std::conditional_t<Counter == MaxValue, std::true_type,
+                                          std::false_type> {};
+
+  template <int Counter, int MaxValue, typename DataT_, class... tail>
+  struct SizeChecker<Counter, MaxValue, DataT_, tail...>
+      : std::conditional_t<Counter + 1 <= MaxValue,
+                           SizeChecker<Counter + 1, MaxValue, tail...>,
+                           std::false_type> {};
+
+  // Utility trait for creating an std::array from an vector argument.
+  template <typename DataT_, typename T, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const vec<T, sizeof...(Is)> &V, std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &V,
+             std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5, std::size_t... Is>
+  static constexpr std::array<DataT_, sizeof...(Is)>
+  VecToArray(const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &V,
+             std::index_sequence<Is...>) {
+    return {static_cast<DataT_>(V.getValue(Is))...};
+  }
+  template <typename DataT_, typename T, int N>
+  static constexpr std::array<DataT_, N>
+  FlattenVecArgHelper(const vec<T, N> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<N>());
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5>
+  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
+      const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
+  }
+  template <typename DataT_, typename T, int N, typename T2, typename T3,
+            template <typename> class T4, int... T5>
+  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
+      const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &A) {
+    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
+  }
+  template <typename DataT_, typename T>
+  static constexpr auto FlattenVecArgHelper(const T &A) {
+    return std::array<DataT_, 1>{vec_data<DataT_>::get(static_cast<DataT_>(A))};
+  }
+  template <typename DataT_, typename T> struct FlattenVecArg {
+    constexpr auto operator()(const T &A) const {
+      return FlattenVecArgHelper<DataT_>(A);
+    }
+  };
+
+  // Alias for shortening the vec arguments to array converter.
+  template <typename DataT_, typename... ArgTN>
+  using VecArgArrayCreator =
+      detail::ArrayCreator<DataT_, FlattenVecArg, ArgTN...>;
+
+#define __SYCL_ALLOW_VECTOR_SIZES(num_elements)                                \
+  template <int Counter, int MaxValue, typename DataT_, class... tail>         \
+  struct SizeChecker<Counter, MaxValue, vec<DataT_, num_elements>, tail...>    \
+      : std::conditional_t<                                                    \
+            Counter + (num_elements) <= MaxValue,                              \
+            SizeChecker<Counter + (num_elements), MaxValue, tail...>,          \
+            std::false_type> {};                                               \
+  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
+            typename T3, template <typename> class T4, int... T5,              \
+            class... tail>                                                     \
+  struct SizeChecker<                                                          \
+      Counter, MaxValue,                                                       \
+      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>,         \
+      tail...>                                                                 \
+      : std::conditional_t<                                                    \
+            Counter + sizeof...(T5) <= MaxValue,                               \
+            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
+            std::false_type> {};                                               \
+  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
+            typename T3, template <typename> class T4, int... T5,              \
+            class... tail>                                                     \
+  struct SizeChecker<                                                          \
+      Counter, MaxValue,                                                       \
+      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
+      tail...>                                                                 \
+      : std::conditional_t<                                                    \
+            Counter + sizeof...(T5) <= MaxValue,                               \
+            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
+            std::false_type> {};
+
+  __SYCL_ALLOW_VECTOR_SIZES(1)
+  __SYCL_ALLOW_VECTOR_SIZES(2)
+  __SYCL_ALLOW_VECTOR_SIZES(3)
+  __SYCL_ALLOW_VECTOR_SIZES(4)
+  __SYCL_ALLOW_VECTOR_SIZES(8)
+  __SYCL_ALLOW_VECTOR_SIZES(16)
+#undef __SYCL_ALLOW_VECTOR_SIZES
+
+  // TypeChecker is needed for vec(const argTN &... args) ctor to validate args.
+  template <typename T, typename DataT_>
+  struct TypeChecker : std::is_convertible<T, DataT_> {};
+#define __SYCL_ALLOW_VECTOR_TYPES(num_elements)                                \
+  template <typename DataT_>                                                   \
+  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {};   \
+  template <typename DataT_, typename T2, typename T3,                         \
+            template <typename> class T4, int... T5>                           \
+  struct TypeChecker<                                                          \
+      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
+      : std::true_type {};                                                     \
+  template <typename DataT_, typename T2, typename T3,                         \
+            template <typename> class T4, int... T5>                           \
+  struct TypeChecker<                                                          \
+      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
+      DataT_> : std::true_type {};
+
+  __SYCL_ALLOW_VECTOR_TYPES(1)
+  __SYCL_ALLOW_VECTOR_TYPES(2)
+  __SYCL_ALLOW_VECTOR_TYPES(3)
+  __SYCL_ALLOW_VECTOR_TYPES(4)
+  __SYCL_ALLOW_VECTOR_TYPES(8)
+  __SYCL_ALLOW_VECTOR_TYPES(16)
+#undef __SYCL_ALLOW_VECTOR_TYPES
+
+  template <int... Indexes>
+  using Swizzle =
+      detail::SwizzleOp<vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
+                        detail::GetOp, Indexes...>;
+
+  template <int... Indexes>
+  using ConstSwizzle =
+      detail::SwizzleOp<const vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
+                        detail::GetOp, Indexes...>;
+
+  // Shortcuts for args validation in vec(const argTN &... args) ctor.
+  template <typename... argTN>
+  using EnableIfSuitableTypes = typename std::enable_if_t<
+      std::conjunction_v<TypeChecker<argTN, DataT>...>>;
+
+  template <typename... argTN>
+  using EnableIfSuitableNumElements =
+      typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
+
+  template <size_t... Is>
+  constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
+                std::index_sequence<Is...>)
+      : m_Data{([&](vec_data_t<DataT> v) constexpr {
+          if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
+            return v.value;
+          else
+            return vec_data_t<DataT>(static_cast<DataT>(v));
+        })(Arr[Is])...} {}
+
+public:
+  using element_type = DataT;
+  using value_type = DataT;
+  using rel_t = detail::rel_t<DataT>;
+#ifdef __SYCL_DEVICE_ONLY__
+  using vector_t =
+      typename detail::VecStorage<DataT, NumElements>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
+
+  vec() = default;
+
+  constexpr vec(const vec &Rhs) = default;
+  constexpr vec(vec &&Rhs) = default;
+
+  constexpr vec &operator=(const vec &Rhs) = default;
+
+  // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
+  template <typename Ty = DataT>
+  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
+                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
+                            vec &>
+  operator=(const vec<rel_t, NumElements> &Rhs) {
+    *this = Rhs.template as<vec>();
+    return *this;
+  }
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <typename T = void>
+  using EnableIfNotHostHalf = typename std::enable_if_t<!IsHostHalf, T>;
+
+  template <typename T = void>
+  using EnableIfHostHalf = typename std::enable_if_t<IsHostHalf, T>;
+
+  template <typename T = void>
+  using EnableIfUsingArrayOnDevice =
+      typename std::enable_if_t<IsUsingArrayOnDevice, T>;
+
+  template <typename T = void>
+  using EnableIfNotUsingArrayOnDevice =
+      typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  template <typename T = void>
+  using EnableIfUsingArray =
+      typename std::enable_if_t<IsUsingArrayOnDevice || IsUsingArrayOnHost, T>;
+
+  template <typename T = void>
+  using EnableIfNotUsingArray =
+      typename std::enable_if_t<!IsUsingArrayOnDevice && !IsUsingArrayOnHost,
+                                T>;
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+
+  template <typename Ty = DataT>
+  explicit constexpr vec(const EnableIfNotUsingArrayOnDevice<Ty> &arg)
+      : m_Data{DataType(vec_data<Ty>::get(arg))} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) {
+    m_Data = (DataType)vec_data<Ty>::get(Rhs);
+    return *this;
+  }
+
+  template <typename Ty = DataT>
+  explicit constexpr vec(const EnableIfUsingArrayOnDevice<Ty> &arg)
+      : vec{detail::RepeatValue<NumElements>(
+                static_cast<vec_data_t<DataT>>(arg)),
+            std::make_index_sequence<NumElements>()} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
+    for (int i = 0; i < NumElements; ++i) {
+      setValue(i, Rhs);
+    }
+    return *this;
+  }
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+  explicit constexpr vec(const DataT &arg)
+      : vec{detail::RepeatValue<NumElements>(
+                static_cast<vec_data_t<DataT>>(arg)),
+            std::make_index_sequence<NumElements>()} {}
+
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<vec_data_t<Ty>> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const DataT &Rhs) {
+    for (int i = 0; i < NumElements; ++i) {
+      setValue(i, Rhs);
+    }
+    return *this;
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  // Optimized naive constructors with NumElements of DataT values.
+  // We don't expect compilers to optimize vararg recursive functions well.
+
+  // Helper type to make specific constructors available only for specific
+  // number of elements.
+  template <int IdxNum, typename T = void>
+  using EnableIfMultipleElems = typename std::enable_if_t<
+      std::is_convertible_v<T, DataT> && NumElements == IdxNum, DataT>;
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<2, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<3, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<4, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const Ty Arg3)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<8, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const DataT Arg3, const DataT Arg4, const DataT Arg5,
+                const DataT Arg6, const DataT Arg7)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
+               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
+               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7)} {}
+  template <typename Ty = DataT>
+  constexpr vec(const EnableIfMultipleElems<16, Ty> Arg0,
+                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
+                const DataT Arg3, const DataT Arg4, const DataT Arg5,
+                const DataT Arg6, const DataT Arg7, const DataT Arg8,
+                const DataT Arg9, const DataT ArgA, const DataT ArgB,
+                const DataT ArgC, const DataT ArgD, const DataT ArgE,
+                const DataT ArgF)
+      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
+               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
+               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
+               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7),
+               vec_data<Ty>::get(Arg8), vec_data<Ty>::get(Arg9),
+               vec_data<Ty>::get(ArgA), vec_data<Ty>::get(ArgB),
+               vec_data<Ty>::get(ArgC), vec_data<Ty>::get(ArgD),
+               vec_data<Ty>::get(ArgE), vec_data<Ty>::get(ArgF)} {}
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // Constructor from values of base type or vec of base type. Checks that
+  // base types are match and that the NumElements == sum of lengths of args.
+  template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
+            typename = EnableIfSuitableNumElements<argTN...>>
+  constexpr vec(const argTN &...args)
+      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
+            std::make_index_sequence<NumElements>()} {}
+
+#ifdef __SYCL_DEVICE_ONLY__
+  template <typename vector_t_ = vector_t,
+            typename =
+                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
+                                          !std::is_same_v<vector_t_, DataT>>>
+  constexpr vec(vector_t openclVector) {
+    if constexpr (!IsUsingArrayOnDevice) {
+      m_Data = openclVector;
+    } else {
+      m_Data = bit_cast<DataType>(openclVector);
+    }
+  }
+
+  operator vector_t() const {
+    if constexpr (!IsUsingArrayOnDevice) {
+      return m_Data;
+    } else {
+      auto ptr = bit_cast<const vector_t *>((&m_Data)->data());
+      return *ptr;
+    }
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
+  // Available only when: NumElements == 1
+  template <int N = NumElements>
+  operator typename std::enable_if_t<N == 1, DataT>() const {
+    return vec_data<DataT>::get(m_Data);
+  }
+
+  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
+  static constexpr size_t get_count() { return size(); }
+  static constexpr size_t size() noexcept { return NumElements; }
+  __SYCL2020_DEPRECATED(
+      "get_size() is deprecated, please use byte_size() instead")
+  static constexpr size_t get_size() { return byte_size(); }
+  static constexpr size_t byte_size() noexcept { return sizeof(m_Data); }
+
+  // convertImpl can't be called with the same From and To types and therefore
+  // we need this version of convert which is mostly no-op.
+  template <typename convertT,
+            rounding_mode roundingMode = rounding_mode::automatic>
+  std::enable_if_t<
+      std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> ||
+          std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
+                         detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      vec<convertT, NumElements>>
+  convert() const {
+    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+                      detail::is_floating_point<convertT>::value,
+                  "Unsupported convertT");
+    if constexpr (!std::is_same_v<DataT, convertT>) {
+      // Dummy conversion for cases like vec<signed char> -> vec<char>
+      vec<convertT, NumElements> Result;
+      for (size_t I = 0; I < NumElements; ++I)
+        Result.setValue(I, static_cast<convertT>(getValue(I)));
+
+      return Result;
+    } else {
+      // No conversion necessary
+      return *this;
+    }
+  }
+
+  template <typename convertT,
+            rounding_mode roundingMode = rounding_mode::automatic>
+  std::enable_if_t<
+      !std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> &&
+          !std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
+                          detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      vec<convertT, NumElements>>
+  convert() const {
+    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+                      detail::is_floating_point<convertT>::value,
+                  "Unsupported convertT");
+    using T = vec_data_t<DataT>;
+    using R = vec_data_t<convertT>;
+    using OpenCLT = detail::ConvertToOpenCLType_t<T>;
+    using OpenCLR = detail::ConvertToOpenCLType_t<R>;
+    vec<convertT, NumElements> Result;
+
+#if defined(__SYCL_DEVICE_ONLY__)
+    using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
+    using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
+    // Whole vector conversion can only be done, if:
+    constexpr bool canUseNativeVectorConvert =
+#ifdef __NVPTX__
+        // - we are not on CUDA, see intel/llvm#11840
+        false &&
+#endif
+        // - both vectors are represented using native vector types;
+        NativeVec && vec<convertT, NumElements>::NativeVec &&
+        // - vec storage has an equivalent OpenCL native vector it is implicitly
+        //   convertible to. There are some corner cases where it is not the
+        //   case with char, long and long long types.
+        std::is_convertible_v<decltype(m_Data), OpenCLVecT> &&
+        std::is_convertible_v<decltype(Result.m_Data), OpenCLVecR> &&
+        // - it is not a signed to unsigned (or vice versa) conversion
+        //   see comments within 'convertImpl' for more details;
+        !detail::is_sint_to_from_uint<T, R>::value &&
+        // - destination type is not bool. bool is stored as integer under the
+        //   hood and therefore conversion to bool looks like conversion between
+        //   two integer types. Since bit pattern for true and false is not
+        //   defined, there is no guarantee that integer conversion yields
+        //   right results here;
+        !std::is_same_v<convertT, bool>;
+    if constexpr (canUseNativeVectorConvert) {
+      Result.m_Data = detail::convertImpl<T, R, roundingMode, NumElements,
+                                          OpenCLVecT, OpenCLVecR>(m_Data);
+    } else
+#endif // defined(__SYCL_DEVICE_ONLY__)
+    {
+      // Otherwise, we fallback to per-element conversion:
+      for (size_t I = 0; I < NumElements; ++I) {
+        Result.setValue(
+            I, vec_data<convertT>::get(
+                   detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
+                       vec_data<DataT>::get(getValue(I)))));
+      }
+    }
+
+    return Result;
+  }
+
+  template <typename asT> asT as() const {
+    static_assert((sizeof(*this) == sizeof(asT)),
+                  "The new SYCL vec type must have the same storage size in "
+                  "bytes as this SYCL vec");
+    static_assert(
+        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
+            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
+        "asT must be SYCL vec of a different element type and "
+        "number of elements specified by asT");
+    asT Result;
+    detail::memcpy(&Result.m_Data, &m_Data, sizeof(decltype(Result.m_Data)));
+    return Result;
+  }
+
+  template <int... SwizzleIndexes> Swizzle<SwizzleIndexes...> swizzle() {
+    return this;
+  }
+
+  template <int... SwizzleIndexes>
+  ConstSwizzle<SwizzleIndexes...> swizzle() const {
+    return this;
+  }
+
+  // ext_vector_type is used as an underlying type for sycl::vec on device.
+  // The problem is that for clang vector types the return of operator[] is a
+  // temporary and not a reference to the element in the vector. In practice
+  // reinterpret_cast<DataT *>(&m_Data)[i]; is working. According to
+  // http://llvm.org/docs/GetElementPtr.html#can-gep-index-into-vector-elements
+  // this is not disallowed now. But could probably be disallowed in the future.
+  // That is why tests are added to check that behavior of the compiler has
+  // not changed.
+  //
+  // Implement operator [] in the same way for host and device.
+  // TODO: change host side implementation when underlying type for host side
+  // will be changed to std::array.
+  // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
+  // aggressively optimized. Specializing with noinline to avoid as workaround.
+
+  template <typename T = DataT>
+  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                            const DataT &>
+  operator[](int i) const {
+    return reinterpret_cast<const DataT *>(&m_Data)[i];
+  }
+
+  template <typename T = DataT>
+  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                            DataT &>
+  operator[](int i) {
+    return reinterpret_cast<DataT *>(&m_Data)[i];
+  }
+
+#ifdef _MSC_VER
+#define __SYCL_NOINLINE_BF16 __declspec(noinline)
+#else
+#define __SYCL_NOINLINE_BF16 __attribute__((noinline))
+#endif
+
+  template <typename T = DataT>
+  __SYCL_NOINLINE_BF16
+      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                const DataT &>
+      operator[](int i) const {
+    return reinterpret_cast<const DataT *>(&m_Data)[i];
+  }
+
+  template <typename T = DataT>
+  __SYCL_NOINLINE_BF16
+      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                DataT &>
+      operator[](int i) {
+    return reinterpret_cast<DataT *>(&m_Data)[i];
+  }
+
+#undef __SYCL_NOINLINE_BF16
+
+  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
+private:
+  // Indexer used in the swizzles.def
+  // Currently it is defined as a template struct. Replacing it with a constexpr
+  // function would activate a bug in MSVC that is fixed only in v19.20.
+  // Until then MSVC does not recognize such constexpr functions as const and
+  // thus does not let using them in template parameters inside swizzle.def.
+  template <int Index> struct Indexer {
+    static constexpr int value = Index;
+  };
+
+public:
+#ifdef __SYCL_ACCESS_RETURN
+#error "Undefine __SYCL_ACCESS_RETURN macro"
+#endif
+#define __SYCL_ACCESS_RETURN this
+#include "swizzles.def"
+#undef __SYCL_ACCESS_RETURN
+  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
+
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t Offset, multi_ptr<const DataT, Space, DecorateAddress> Ptr) {
+    for (int I = 0; I < NumElements; I++) {
+      setValue(I, *multi_ptr<const DataT, Space, DecorateAddress>(
+                      Ptr + Offset * NumElements + I));
+    }
+  }
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t Offset, multi_ptr<DataT, Space, DecorateAddress> Ptr) {
+    multi_ptr<const DataT, Space, DecorateAddress> ConstPtr(Ptr);
+    load(Offset, ConstPtr);
+  }
+  template <int Dimensions, access::mode Mode,
+            access::placeholder IsPlaceholder, access::target Target,
+            typename PropertyListT>
+  void
+  load(size_t Offset,
+       accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
+           Acc) {
+    multi_ptr<const DataT, detail::TargetToAS<Target>::AS,
+              access::decorated::yes>
+        MultiPtr(Acc);
+    load(Offset, MultiPtr);
+  }
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void store(size_t Offset,
+             multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
+    for (int I = 0; I < NumElements; I++) {
+      *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
+                                                I) = getValue(I);
+    }
+  }
+  template <int Dimensions, access::mode Mode,
+            access::placeholder IsPlaceholder, access::target Target,
+            typename PropertyListT>
+  void
+  store(size_t Offset,
+        accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
+            Acc) {
+    multi_ptr<DataT, detail::TargetToAS<Target>::AS, access::decorated::yes>
+        MultiPtr(Acc);
+    store(Offset, MultiPtr);
+  }
+
+  void ConvertToDataT() {
+    for (size_t i = 0; i < NumElements; ++i) {
+      DataT tmp = getValue(i);
+      setValue(i, tmp);
+    }
+  }
+
+#ifdef __SYCL_BINOP
+#error "Undefine __SYCL_BINOP macro"
+#endif
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
+  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+    vec Ret;                                                                   \
+    if constexpr (IsUsingArrayOnDevice) {                                      \
+      for (size_t I = 0; I < NumElements; ++I) {                               \
+        Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
+      }                                                                        \
+    } else {                                                                   \
+      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+      if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
+        Ret.ConvertToDataT();                                                  \
+      }                                                                        \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+    return Lhs BINOP vec(Rhs);                                                 \
+  }                                                                            \
+  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+    return vec(Lhs) BINOP Rhs;                                                 \
+  }                                                                            \
+  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+    Lhs = Lhs BINOP Rhs;                                                       \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <int Num = NumElements>                                             \
+  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
+      vec & Lhs, const DataT & Rhs) {                                          \
+    Lhs = Lhs BINOP vec(Rhs);                                                  \
+    return Lhs;                                                                \
+  }
+
+#else // __SYCL_USE_EXT_VECTOR_TYPE__
+
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
+  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+    vec Ret{};                                                                 \
+    if constexpr (NativeVec)                                                   \
+      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+    else                                                                       \
+      for (size_t I = 0; I < NumElements; ++I)                                 \
+        Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(             \
+                            I)) BINOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+    return Lhs BINOP vec(Rhs);                                                 \
+  }                                                                            \
+  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+    return vec(Lhs) BINOP Rhs;                                                 \
+  }                                                                            \
+  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+    Lhs = Lhs BINOP Rhs;                                                       \
+    return Lhs;                                                                \
+  }                                                                            \
+  template <int Num = NumElements>                                             \
+  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
+      vec & Lhs, const DataT & Rhs) {                                          \
+    Lhs = Lhs BINOP vec(Rhs);                                                  \
+    return Lhs;                                                                \
+  }
+
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  __SYCL_BINOP(+, +=, true)
+  __SYCL_BINOP(-, -=, true)
+  __SYCL_BINOP(*, *=, false)
+  __SYCL_BINOP(/, /=, false)
+
+  // TODO: The following OPs are available only when: DataT != cl_float &&
+  // DataT != cl_double && DataT != cl_half
+  __SYCL_BINOP(%, %=, false)
+  __SYCL_BINOP(|, |=, false)
+  __SYCL_BINOP(&, &=, false)
+  __SYCL_BINOP(^, ^=, false)
+  __SYCL_BINOP(>>, >>=, false)
+  __SYCL_BINOP(<<, <<=, true)
+#undef __SYCL_BINOP
+#undef __SYCL_BINOP_HELP
+
+  // Note: vec<>/SwizzleOp logical value is 0/-1 logic, as opposed to 0/1 logic.
+  // As far as CTS validation is concerned, 0/-1 logic also applies when
+  // NumElements is equal to one, which is somewhat inconsistent with being
+  // transparent with scalar data.
+  // TODO: Determine if vec<, NumElements=1> is needed at all, remove this
+  // inconsistency if not by disallowing one-element vectors (as in OpenCL)
+
+#ifdef __SYCL_RELLOGOP
+#error "Undefine __SYCL_RELLOGOP macro"
+#endif
+// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
+// by SYCL device compiler only.
+#ifdef __SYCL_DEVICE_ONLY__
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const vec & Rhs) {          \
+    vec<rel_t, NumElements> Ret{};                                             \
+    /* This special case is needed since there are no standard operator||   */ \
+    /* or operator&& functions for std::array.                              */ \
+    if constexpr (IsUsingArrayOnDevice &&                                      \
+                  (std::string_view(#RELLOGOP) == "||" ||                      \
+                   std::string_view(#RELLOGOP) == "&&")) {                     \
+      for (size_t I = 0; I < NumElements; ++I) {                               \
+        /* We cannot use SetValue here as the operator is not a friend of*/    \
+        /* Ret on Windows. */                                                  \
+        Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                    \
+            Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+      }                                                                        \
+    } else {                                                                   \
+      Ret = vec<rel_t, NumElements>(                                           \
+          (typename vec<rel_t, NumElements>::vector_t)(                        \
+              Lhs.m_Data RELLOGOP Rhs.m_Data));                                \
+      if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
+        Ret *= -1;                                                             \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const DataT & Rhs) {        \
+    return Lhs RELLOGOP vec(Rhs);                                              \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
+                                                   const vec & Rhs) {          \
+    return vec(Lhs) RELLOGOP Rhs;                                              \
+  }
+
+#else
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const vec & Rhs) {          \
+    vec<rel_t, NumElements> Ret{};                                             \
+    for (size_t I = 0; I < NumElements; ++I) {                                 \
+      /* We cannot use SetValue here as the operator is not a friend of*/      \
+      /* Ret on Windows. */                                                    \
+      Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                      \
+          Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));   \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
+                                                   const DataT & Rhs) {        \
+    return Lhs RELLOGOP vec(Rhs);                                              \
+  }                                                                            \
+  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
+                                                   const vec & Rhs) {          \
+    return vec(Lhs) RELLOGOP Rhs;                                              \
+  }
+#endif
+
+  __SYCL_RELLOGOP(==)
+  __SYCL_RELLOGOP(!=)
+  __SYCL_RELLOGOP(>)
+  __SYCL_RELLOGOP(<)
+  __SYCL_RELLOGOP(>=)
+  __SYCL_RELLOGOP(<=)
+  // TODO: limit to integral types.
+  __SYCL_RELLOGOP(&&)
+  __SYCL_RELLOGOP(||)
+#undef __SYCL_RELLOGOP
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  friend vec &operator UOP(vec & Rhs) {                                        \
+    Rhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    return Rhs;                                                                \
+  }                                                                            \
+  friend vec operator UOP(vec &Lhs, int) {                                     \
+    vec Ret(Lhs);                                                              \
+    Lhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  // operator~() available only when: dataT != float && dataT != double
+  // && dataT != half
+  friend vec operator~(const vec &Rhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I) {
+        Ret.setValue(I, ~Rhs.getValue(I));
+      }
+      return Ret;
+    } else {
+      vec Ret{(typename vec::DataType) ~Rhs.m_Data};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+      return Ret;
+    }
+  }
+
+  // operator!
+  friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I) {
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        // std::byte neither supports ! unary op or casting, so special handling
+        // is needed. And, worse, Windows has a conflict with 'byte'.
+        if constexpr (std::is_same_v<std::byte, DataT>) {
+          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
+        } else
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+        {
+          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
+        }
+      }
+      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
+    } else {
+      return vec{(typename vec<DataT, NumElements>::DataType) !Rhs.m_Data}
+          .template as<vec<detail::rel_t<DataT>, NumElements>>();
+    }
+  }
+
+  // operator +
+  friend vec operator+(const vec &Lhs) {
+    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(
+            I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
+      return Ret;
+    } else {
+      return vec{+Lhs.m_Data};
+    }
+  }
+
+  // operator -
+  friend vec operator-(const vec &Lhs) {
+    namespace oneapi = sycl::ext::oneapi;
+    vec Ret{};
+    if constexpr (IsBfloat16 && NumElements == 1) {
+      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data);
+      oneapi::bfloat16 w = -v;
+      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
+    } else if constexpr (IsBfloat16) {
+      for (size_t I = 0; I < NumElements; I++) {
+        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[I]);
+        oneapi::bfloat16 w = -v;
+        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
+      }
+    } else if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(
+            I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
+      return Ret;
+    } else {
+      Ret = vec{-Lhs.m_Data};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+      return Ret;
+    }
+  }
+
+  // OP is: &&, ||
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
+
+  // OP is: ==, !=, <, >, <=, >=
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
+private:
+  // Generic method that execute "Operation" on underlying values.
+
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <template <typename> class Operation,
+            typename Ty = vec<DataT, NumElements>>
+  vec<DataT, NumElements>
+  operatorHelper(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataType> Op;
+    Result.m_Data = Op(m_Data, Rhs.m_Data);
+    return Result;
+  }
+
+  template <template <typename> class Operation,
+            typename Ty = vec<DataT, NumElements>>
+  vec<DataT, NumElements>
+  operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataT> Op;
+    for (size_t I = 0; I < NumElements; ++I) {
+      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
+    }
+    return Result;
+  }
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+  template <template <typename> class Operation>
+  vec<DataT, NumElements>
+  operatorHelper(const vec<DataT, NumElements> &Rhs) const {
+    vec<DataT, NumElements> Result;
+    Operation<DataT> Op;
+    for (size_t I = 0; I < NumElements; ++I) {
+      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
+    }
+    return Result;
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // setValue and getValue should be able to operate on different underlying
+  // types: enum cl_float#N , builtin vector float#N, builtin type float.
+  // These versions are for N > 1.
+#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
+                          int) {
+    m_Data[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
+    return vec_data<DataT>::get(m_Data[Index]);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
+    m_Data.s[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements, typename Ty = int,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
+    return vec_data<DataT>::get(m_Data.s[Index]);
+  }
+#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr void setValue(int Index, const DataT &Value, int) {
+    m_Data[Index] = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 != Num>>
+  constexpr DataT getValue(int Index, int) const {
+    return vec_data<DataT>::get(m_Data[Index]);
+  }
+#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+
+  // N==1 versions, used by host and device. Shouldn't trailing type be int?
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 == Num>>
+  constexpr void setValue(int, const DataT &Value, float) {
+    m_Data = vec_data<DataT>::set(Value);
+  }
+
+  template <int Num = NumElements,
+            typename = typename std::enable_if_t<1 == Num>>
+  DataT getValue(int, float) const {
+    return vec_data<DataT>::get(m_Data);
+  }
+
+  // setValue and getValue.
+  // The "api" functions used by BINOP etc.  These versions just dispatch
+  // using additional int or float arg to disambiguate vec<1> vs. vec<N>
+  // Special proxies as specialization is not allowed in class scope.
+  constexpr void setValue(int Index, const DataT &Value) {
+    if (NumElements == 1)
+      setValue(Index, Value, 0);
+    else
+      setValue(Index, Value, 0.f);
+  }
+
+  DataT getValue(int Index) const {
+    return (NumElements == 1) ? getValue(Index, 0) : getValue(Index, 0.f);
+  }
+
+  // fields
+
+  // Alignment is the same as size, to a maximum size of 64.
+  // detail::vector_alignment will return that value.
+  alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
+
+  // friends
+  template <typename T1, typename T2, typename T3, template <typename> class T4,
+            int... T5>
+  friend class detail::SwizzleOp;
+  template <typename T1, int T2> friend class vec;
+};
+///////////////////////// class sycl::vec /////////////////////////
+
+#ifdef __cpp_deduction_guides
+// all compilers supporting deduction guides also support fold expressions
+template <class T, class... U,
+          class = std::enable_if_t<(std::is_same_v<T, U> && ...)>>
+vec(T, U...) -> vec<T, sizeof...(U) + 1>;
+#endif
+
+namespace detail {
+
+// Special type for working SwizzleOp with scalars, stores a scalar and gives
+// the scalar at any index. Provides interface is compatible with SwizzleOp
+// operations
+template <typename T> class GetScalarOp {
+public:
+  using DataT = T;
+  GetScalarOp(DataT Data) : m_Data(Data) {}
+  DataT getValue(size_t) const { return m_Data; }
+
+private:
+  DataT m_Data;
+};
+
+template <typename T> struct EqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs == Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct NotEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs != Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs >= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs <= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs > Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs < Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalAnd {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs && Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalOr {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs || Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct RShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs >> Rhs;
+  }
+};
+
+template <typename T> struct LShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs << Rhs;
+  }
+};
+
+///////////////////////// class SwizzleOp /////////////////////////
+// SwizzleOP represents expression templates that operate on vec.
+// Actual computation performed on conversion or assignment operators.
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp {
+  using DataT = typename VecT::element_type;
+  // Certain operators return a vector with a different element type. Also, the
+  // left and right operand types may differ. CommonDataT selects a result type
+  // based on these types to ensure that the result value can be represented.
+  //
+  // Example 1:
+  //   sycl::vec<unsigned char, 4> vec{...};
+  //   auto result = 300u + vec.x();
+  //
+  // CommonDataT is std::common_type_t<OperationLeftT, OperationRightT> since
+  // it's larger than unsigned char.
+  //
+  // Example 2:
+  //   sycl::vec<bool, 1> vec{...};
+  //   auto result = vec.template swizzle<sycl::elem::s0>() && vec;
+  //
+  // CommonDataT is DataT since operator&& returns a vector with element type
+  // int8_t, which is larger than bool.
+  //
+  // Example 3:
+  //   sycl::vec<std::byte, 4> vec{...}; auto swlo = vec.lo();
+  //   auto result = swlo == swlo;
+  //
+  // CommonDataT is DataT since operator== returns a vector with element type
+  // int8_t, which is the same size as std::byte. std::common_type_t<DataT, ...>
+  // can't be used here since there's no type that int8_t and std::byte can both
+  // be implicitly converted to.
+  using OpLeftDataT = typename OperationLeftT::DataT;
+  using OpRightDataT = typename OperationRightT::DataT;
+  using CommonDataT = std::conditional_t<
+      sizeof(DataT) >= sizeof(std::common_type_t<OpLeftDataT, OpRightDataT>),
+      DataT, std::common_type_t<OpLeftDataT, OpRightDataT>>;
+  static constexpr int getNumElements() { return sizeof...(Indexes); }
+
+  using rel_t = detail::rel_t<DataT>;
+  using vec_t = vec<DataT, sizeof...(Indexes)>;
+  using vec_rel_t = vec<rel_t, sizeof...(Indexes)>;
+
+  template <typename OperationRightT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewLHOp = SwizzleOp<VecT,
+                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                      OperationCurrentT, Indexes...>,
+                            OperationRightT_, OperationCurrentT_, Idx_...>;
+
+  template <typename OperationRightT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewRelOp = SwizzleOp<vec<rel_t, VecT::getNumElements()>,
+                             SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                       OperationCurrentT, Indexes...>,
+                             OperationRightT_, OperationCurrentT_, Idx_...>;
+
+  template <typename OperationLeftT_,
+            template <typename> class OperationCurrentT_, int... Idx_>
+  using NewRHOp = SwizzleOp<VecT, OperationLeftT_,
+                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                                      OperationCurrentT, Indexes...>,
+                            OperationCurrentT_, Idx_...>;
+
+  template <int IdxNum, typename T = void>
+  using EnableIfOneIndex = typename std::enable_if_t<
+      1 == IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+
+  template <int IdxNum, typename T = void>
+  using EnableIfMultipleIndexes = typename std::enable_if_t<
+      1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
+
+  template <typename T>
+  using EnableIfScalarType = typename std::enable_if_t<
+      std::is_convertible_v<DataT, T> &&
+      (std::is_fundamental_v<vec_data_t<T>> ||
+       detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+
+  template <typename T>
+  using EnableIfNoScalarType = typename std::enable_if_t<
+      !std::is_convertible_v<DataT, T> ||
+      !(std::is_fundamental_v<vec_data_t<T>> ||
+        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+
+  template <int... Indices>
+  using Swizzle =
+      SwizzleOp<VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
+
+  template <int... Indices>
+  using ConstSwizzle =
+      SwizzleOp<const VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
+
+public:
+  using element_type = DataT;
+  using value_type = DataT;
+
+#ifdef __SYCL_DEVICE_ONLY__
+  using vector_t = typename vec_t::vector_t;
+#endif // __SYCL_DEVICE_ONLY__
+
+  const DataT &operator[](int i) const {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    return (*m_Vector)[Idxs[i]];
+  }
+
+  template <typename _T = VecT>
+  std::enable_if_t<!std::is_const_v<_T>, DataT> &operator[](int i) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    return (*m_Vector)[Idxs[i]];
+  }
+
+  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
+  size_t get_count() const { return size(); }
+  static constexpr size_t size() noexcept { return getNumElements(); }
+
+  template <int Num = getNumElements()>
+  __SYCL2020_DEPRECATED(
+      "get_size() is deprecated, please use byte_size() instead")
+  size_t get_size() const {
+    return byte_size<Num>();
+  }
+
+  template <int Num = getNumElements()> size_t byte_size() const noexcept {
+    return sizeof(DataT) * (Num == 3 ? 4 : Num);
+  }
+
+  template <typename T, int IdxNum = getNumElements(),
+            typename = EnableIfOneIndex<IdxNum>,
+            typename = EnableIfScalarType<T>>
+  operator T() const {
+    return getValue(0);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>
+  operator*(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::plus, Indexes...>
+  operator+(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::plus, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  friend NewRHOp<GetScalarOp<T>, std::divides, Indexes...>
+  operator/(const T &Lhs, const SwizzleOp &Rhs) {
+    return NewRHOp<GetScalarOp<T>, std::divides, Indexes...>(
+        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
+  }
+
+  // TODO: Check that Rhs arg is suitable.
+#ifdef __SYCL_OPASSIGN
+#error "Undefine __SYCL_OPASSIGN macro."
+#endif
+#define __SYCL_OPASSIGN(OPASSIGN, OP)                                          \
+  SwizzleOp &operator OPASSIGN(const DataT & Rhs) {                            \
+    operatorHelper<OP>(vec_t(Rhs));                                            \
+    return *this;                                                              \
+  }                                                                            \
+  template <typename RhsOperation>                                             \
+  SwizzleOp &operator OPASSIGN(const RhsOperation & Rhs) {                     \
+    operatorHelper<OP>(Rhs);                                                   \
+    return *this;                                                              \
+  }
+
+  __SYCL_OPASSIGN(+=, std::plus)
+  __SYCL_OPASSIGN(-=, std::minus)
+  __SYCL_OPASSIGN(*=, std::multiplies)
+  __SYCL_OPASSIGN(/=, std::divides)
+  __SYCL_OPASSIGN(%=, std::modulus)
+  __SYCL_OPASSIGN(&=, std::bit_and)
+  __SYCL_OPASSIGN(|=, std::bit_or)
+  __SYCL_OPASSIGN(^=, std::bit_xor)
+  __SYCL_OPASSIGN(>>=, RShift)
+  __SYCL_OPASSIGN(<<=, LShift)
+#undef __SYCL_OPASSIGN
+
+#ifdef __SYCL_UOP
+#error "Undefine __SYCL_UOP macro"
+#endif
+#define __SYCL_UOP(UOP, OPASSIGN)                                              \
+  SwizzleOp &operator UOP() {                                                  \
+    *this OPASSIGN static_cast<DataT>(1);                                      \
+    return *this;                                                              \
+  }                                                                            \
+  vec_t operator UOP(int) {                                                    \
+    vec_t Ret = *this;                                                         \
+    *this OPASSIGN static_cast<DataT>(1);                                      \
+    return Ret;                                                                \
+  }
+
+  __SYCL_UOP(++, +=)
+  __SYCL_UOP(--, -=)
+#undef __SYCL_UOP
+
+  template <typename T = DataT>
+  friend typename std::enable_if_t<
+      std::is_same_v<T, DataT> && std::is_integral_v<vec_data_t<T>>, vec_t>
+  operator~(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return ~Tmp;
+  }
+
+  friend vec_rel_t operator!(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return !Tmp;
+  }
+
+  friend vec_t operator+(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return +Tmp;
+  }
+
+  friend vec_t operator-(const SwizzleOp &Rhs) {
+    vec_t Tmp = Rhs;
+    return -Tmp;
+  }
+
+// scalar BINOP vec<>
+// scalar BINOP SwizzleOp
+// vec<> BINOP SwizzleOp
+#ifdef __SYCL_BINOP
+#error "Undefine __SYCL_BINOP macro"
+#endif
+#define __SYCL_BINOP(BINOP)                                                    \
+  friend vec_t operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {        \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs BINOP Tmp;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {        \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp BINOP Rhs;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {        \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs BINOP Tmp;                                                      \
+  }                                                                            \
+  friend vec_t operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {        \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp BINOP Rhs;                                                      \
+  }
+
+  __SYCL_BINOP(+)
+  __SYCL_BINOP(-)
+  __SYCL_BINOP(*)
+  __SYCL_BINOP(/)
+  __SYCL_BINOP(%)
+  __SYCL_BINOP(&)
+  __SYCL_BINOP(|)
+  __SYCL_BINOP(^)
+  __SYCL_BINOP(>>)
+  __SYCL_BINOP(<<)
+#undef __SYCL_BINOP
+
+// scalar RELLOGOP vec<>
+// scalar RELLOGOP SwizzleOp
+// vec<> RELLOGOP SwizzleOp
+#ifdef __SYCL_RELLOGOP
+#error "Undefine __SYCL_RELLOGOP macro"
+#endif
+#define __SYCL_RELLOGOP(RELLOGOP)                                              \
+  friend vec_rel_t operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs RELLOGOP Tmp;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp RELLOGOP Rhs;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
+    vec_t Tmp = Rhs;                                                           \
+    return Lhs RELLOGOP Tmp;                                                   \
+  }                                                                            \
+  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
+    vec_t Tmp = Lhs;                                                           \
+    return Tmp RELLOGOP Rhs;                                                   \
+  }
+
+  __SYCL_RELLOGOP(==)
+  __SYCL_RELLOGOP(!=)
+  __SYCL_RELLOGOP(>)
+  __SYCL_RELLOGOP(<)
+  __SYCL_RELLOGOP(>=)
+  __SYCL_RELLOGOP(<=)
+  // TODO: limit to integral types.
+  __SYCL_RELLOGOP(&&)
+  __SYCL_RELLOGOP(||)
+#undef __SYCL_RELLOGOP
+
+  template <int IdxNum = getNumElements(),
+            typename = EnableIfMultipleIndexes<IdxNum>>
+  SwizzleOp &operator=(const vec<DataT, IdxNum> &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
+  SwizzleOp &operator=(const DataT &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    m_Vector->setValue(Idxs[0], Rhs);
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(),
+            EnableIfMultipleIndexes<IdxNum, bool> = true>
+  SwizzleOp &operator=(const DataT &Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    for (auto Idx : Idxs) {
+      m_Vector->setValue(Idx, Rhs);
+    }
+    return *this;
+  }
+
+  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
+  SwizzleOp &operator=(DataT &&Rhs) {
+    std::array<int, IdxNum> Idxs{Indexes...};
+    m_Vector->setValue(Idxs[0], Rhs);
+    return *this;
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>
+  operator*(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::multiplies, Indexes...>
+  operator*(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::multiplies, Indexes...>(m_Vector, *this,
+                                                              Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::plus, Indexes...> operator+(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::plus, Indexes...>(m_Vector, *this,
+                                                          GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::plus, Indexes...>
+  operator+(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::plus, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::minus, Indexes...>
+  operator-(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::minus, Indexes...>(m_Vector, *this,
+                                                           GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::minus, Indexes...>
+  operator-(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::minus, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::divides, Indexes...>
+  operator/(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::divides, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::divides, Indexes...>
+  operator/(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::divides, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>
+  operator%(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::modulus, Indexes...>
+  operator%(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::modulus, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>
+  operator&(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_and, Indexes...>
+  operator&(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_and, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>
+  operator|(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_or, Indexes...>
+  operator|(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_or, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>
+  operator^(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>(
+        m_Vector, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, std::bit_xor, Indexes...>
+  operator^(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, std::bit_xor, Indexes...>(m_Vector, *this,
+                                                           Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, RShift, Indexes...> operator>>(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, RShift, Indexes...>(m_Vector, *this,
+                                                       GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, RShift, Indexes...>
+  operator>>(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, RShift, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewLHOp<GetScalarOp<T>, LShift, Indexes...> operator<<(const T &Rhs) const {
+    return NewLHOp<GetScalarOp<T>, LShift, Indexes...>(m_Vector, *this,
+                                                       GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewLHOp<RhsOperation, LShift, Indexes...>
+  operator<<(const RhsOperation &Rhs) const {
+    return NewLHOp<RhsOperation, LShift, Indexes...>(m_Vector, *this, Rhs);
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  SwizzleOp &operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
+  SwizzleOp &operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) {
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
+    }
+    return *this;
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, EqualTo, Indexes...> operator==(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, EqualTo, Indexes...>(NULL, *this,
+                                                         GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, EqualTo, Indexes...>
+  operator==(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, EqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>
+  operator!=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, NotEqualTo, Indexes...>
+  operator!=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, NotEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>
+  operator>=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>
+  operator>=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>
+  operator<=(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LessEqualTo, Indexes...>
+  operator<=(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LessEqualTo, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>
+  operator>(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, GreaterThan, Indexes...>
+  operator>(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, GreaterThan, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LessThan, Indexes...> operator<(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LessThan, Indexes...>(NULL, *this,
+                                                          GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LessThan, Indexes...>
+  operator<(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LessThan, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>
+  operator&&(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>(
+        NULL, *this, GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LogicalAnd, Indexes...>
+  operator&&(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LogicalAnd, Indexes...>(NULL, *this, Rhs);
+  }
+
+  template <typename T, typename = EnableIfScalarType<T>>
+  NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>
+  operator||(const T &Rhs) const {
+    return NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>(NULL, *this,
+                                                           GetScalarOp<T>(Rhs));
+  }
+
+  template <typename RhsOperation,
+            typename = EnableIfNoScalarType<RhsOperation>>
+  NewRelOp<RhsOperation, LogicalOr, Indexes...>
+  operator||(const RhsOperation &Rhs) const {
+    return NewRelOp<RhsOperation, LogicalOr, Indexes...>(NULL, *this, Rhs);
+  }
+
+  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
+private:
+  // Indexer used in the swizzles.def.
+  // Currently it is defined as a template struct. Replacing it with a constexpr
+  // function would activate a bug in MSVC that is fixed only in v19.20.
+  // Until then MSVC does not recognize such constexpr functions as const and
+  // thus does not let using them in template parameters inside swizzle.def.
+  template <int Index> struct Indexer {
+    static constexpr int IDXs[sizeof...(Indexes)] = {Indexes...};
+    static constexpr int value = IDXs[Index >= getNumElements() ? 0 : Index];
+  };
+
+public:
+#ifdef __SYCL_ACCESS_RETURN
+#error "Undefine __SYCL_ACCESS_RETURN macro"
+#endif
+#define __SYCL_ACCESS_RETURN m_Vector
+#include "swizzles.def"
+#undef __SYCL_ACCESS_RETURN
+  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
+
+  // Leave store() interface to automatic conversion to vec<>.
+  // Load to vec_t and then assign to swizzle.
+  template <access::address_space Space, access::decorated DecorateAddress>
+  void load(size_t offset, multi_ptr<DataT, Space, DecorateAddress> ptr) {
+    vec_t Tmp;
+    Tmp.template load(offset, ptr);
+    *this = Tmp;
+  }
+
+  template <typename convertT, rounding_mode roundingMode>
+  vec<convertT, sizeof...(Indexes)> convert() const {
+    // First materialize the swizzle to vec_t and then apply convert() to it.
+    vec_t Tmp = *this;
+    return Tmp.template convert<convertT, roundingMode>();
+  }
+
+  template <typename asT> asT as() const {
+    // First materialize the swizzle to vec_t and then apply as() to it.
+    vec_t Tmp = *this;
+    static_assert((sizeof(Tmp) == sizeof(asT)),
+                  "The new SYCL vec type must have the same storage size in "
+                  "bytes as this SYCL swizzled vec");
+    static_assert(
+        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
+            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
+        "asT must be SYCL vec of a different element type and "
+        "number of elements specified by asT");
+    return Tmp.template as<asT>();
+  }
+
+private:
+  SwizzleOp(const SwizzleOp &Rhs)
+      : m_Vector(Rhs.m_Vector), m_LeftOperation(Rhs.m_LeftOperation),
+        m_RightOperation(Rhs.m_RightOperation) {}
+
+  SwizzleOp(VecT *Vector, OperationLeftT LeftOperation,
+            OperationRightT RightOperation)
+      : m_Vector(Vector), m_LeftOperation(LeftOperation),
+        m_RightOperation(RightOperation) {}
+
+  SwizzleOp(VecT *Vector) : m_Vector(Vector) {}
+
+  SwizzleOp(SwizzleOp &&Rhs)
+      : m_Vector(Rhs.m_Vector), m_LeftOperation(std::move(Rhs.m_LeftOperation)),
+        m_RightOperation(std::move(Rhs.m_RightOperation)) {}
+
+  // Either performing CurrentOperation on results of left and right operands
+  // or reading values from actual vector. Perform implicit type conversion when
+  // the number of elements == 1
+
+  template <int IdxNum = getNumElements()>
+  CommonDataT getValue(EnableIfOneIndex<IdxNum, size_t> Index) const {
+    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
+      std::array<int, getNumElements()> Idxs{Indexes...};
+      return m_Vector->getValue(Idxs[Index]);
+    }
+    auto Op = OperationCurrentT<vec_data_t<CommonDataT>>();
+    return vec_data<CommonDataT>::get(
+        Op(vec_data<CommonDataT>::get(m_LeftOperation.getValue(Index)),
+           vec_data<CommonDataT>::get(m_RightOperation.getValue(Index))));
+  }
+
+  template <int IdxNum = getNumElements()>
+  DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
+    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
+      std::array<int, getNumElements()> Idxs{Indexes...};
+      return m_Vector->getValue(Idxs[Index]);
+    }
+    auto Op = OperationCurrentT<vec_data_t<DataT>>();
+    return vec_data<DataT>::get(
+        Op(vec_data<DataT>::get(m_LeftOperation.getValue(Index)),
+           vec_data<DataT>::get(m_RightOperation.getValue(Index))));
+  }
+
+  template <template <typename> class Operation, typename RhsOperation>
+  void operatorHelper(const RhsOperation &Rhs) {
+    Operation<vec_data_t<DataT>> Op;
+    std::array<int, getNumElements()> Idxs{Indexes...};
+    for (size_t I = 0; I < Idxs.size(); ++I) {
+      DataT Res = vec_data<DataT>::get(
+          Op(vec_data<DataT>::get(m_Vector->getValue(Idxs[I])),
+             vec_data<DataT>::get(Rhs.getValue(I))));
+      m_Vector->setValue(Idxs[I], Res);
+    }
+  }
+
+  // fields
+  VecT *m_Vector;
+
+  OperationLeftT m_LeftOperation;
+  OperationRightT m_RightOperation;
+
+  // friends
+  template <typename T1, int T2> friend class sycl::vec;
+
+  template <typename T1, typename T2, typename T3, template <typename> class T4,
+            int... T5>
+  friend class SwizzleOp;
+};
+///////////////////////// class SwizzleOp /////////////////////////
+} // namespace detail
+} // namespace _V1
+} // namespace sycl

From 259240c1e6a9d5f2696aeba8f7e6ca9290b5c99b Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 24 Apr 2024 07:45:39 -0700
Subject: [PATCH 30/79] Refactor sycl::vec into a header of its own.

---
 sycl/include/sycl/types.hpp          | 2252 +-------------------------
 sycl/include/sycl/types_preview.hpp  | 2242 -------------------------
 sycl/include/sycl/vector.hpp         |  596 +++----
 sycl/include/sycl/vector_preview.hpp |  398 ++---
 4 files changed, 371 insertions(+), 5117 deletions(-)
 delete mode 100644 sycl/include/sycl/types_preview.hpp

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index aa4059d2af203..0a6ec207a622b 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -8,43 +8,15 @@
 
 #pragma once
 
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
-#include <sycl/types_preview.hpp>
-#else // __INTEL_PREVIEW_BREAKING_CHANGES
-
-// Check if Clang's ext_vector_type attribute is available. Host compiler
-// may not be Clang, and Clang may not be built with the extension.
-#ifdef __clang__
-#ifndef __has_extension
-#define __has_extension(x) 0
-#endif
-#ifdef __HAS_EXT_VECTOR_TYPE__
-#error "Undefine __HAS_EXT_VECTOR_TYPE__ macro"
-#endif
-#if __has_extension(attribute_ext_vector_type)
-#define __HAS_EXT_VECTOR_TYPE__
-#endif
-#endif // __clang__
-
-#if !defined(__HAS_EXT_VECTOR_TYPE__) && defined(__SYCL_DEVICE_ONLY__)
-#error "SYCL device compiler is built without ext_vector_type support"
-#endif
-
-#if defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_USE_EXT_VECTOR_TYPE__
-#endif
-
 #include <sycl/access/access.hpp>              // for decorated, address_space
 #include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
 #include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
 #include <sycl/detail/defines_elementary.hpp>  // for __SYCL2020_DEPRECATED
 #include <sycl/detail/generic_type_lists.hpp>  // for vector_basic_list
 #include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
-#include <sycl/detail/memcpy.hpp>              // for memcpy
+#include <sycl/detail/is_device_copyable.hpp>
 #include <sycl/detail/type_list.hpp>           // for is_contained
 #include <sycl/detail/type_traits.hpp>         // for is_floating_point
-#include <sycl/detail/vector_convert.hpp>      // for convertImpl
-#include <sycl/detail/vector_traits.hpp>       // for vector_alignment
 #include <sycl/exception.hpp>                  // for make_error_code, errc
 #include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
 #include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
@@ -55,2227 +27,12 @@
 #include <sycl/vector.hpp>                     // for sycl::vec and swizzles
 #endif
 
-#include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
-
-#include <array>       // for array
-#include <assert.h>    // for assert
-#include <cstddef>     // for size_t, NULL, byte
-#include <cstdint>     // for uint8_t, int16_t, int...
-#include <functional>  // for divides, multiplies
-#include <iterator>    // for pair
-#include <optional>    // for optional
-#include <ostream>     // for operator<<, basic_ost...
-#include <tuple>       // for tuple
-#include <type_traits> // for enable_if_t, is_same
-#include <utility>     // for index_sequence, make_...
-#include <variant>     // for tuple, variant
-
-// 4.10.1: Scalar data types
-// 4.10.2: SYCL vector types
+#include <sycl/ext/oneapi/bfloat16.hpp>        // bfloat16
 
 namespace sycl {
 inline namespace _V1 {
-
-struct elem {
-  static constexpr int x = 0;
-  static constexpr int y = 1;
-  static constexpr int z = 2;
-  static constexpr int w = 3;
-  static constexpr int r = 0;
-  static constexpr int g = 1;
-  static constexpr int b = 2;
-  static constexpr int a = 3;
-  static constexpr int s0 = 0;
-  static constexpr int s1 = 1;
-  static constexpr int s2 = 2;
-  static constexpr int s3 = 3;
-  static constexpr int s4 = 4;
-  static constexpr int s5 = 5;
-  static constexpr int s6 = 6;
-  static constexpr int s7 = 7;
-  static constexpr int s8 = 8;
-  static constexpr int s9 = 9;
-  static constexpr int sA = 10;
-  static constexpr int sB = 11;
-  static constexpr int sC = 12;
-  static constexpr int sD = 13;
-  static constexpr int sE = 14;
-  static constexpr int sF = 15;
-};
-
 namespace detail {
-// select_apply_cl_t selects from T8/T16/T32/T64 basing on
-// sizeof(_IN).  expected to handle scalar types in _IN.
-template <typename _IN, typename T8, typename T16, typename T32, typename T64>
-using select_apply_cl_t = std::conditional_t<
-    sizeof(_IN) == 1, T8,
-    std::conditional_t<sizeof(_IN) == 2, T16,
-                       std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
-
-template <typename T> struct vec_helper {
-  using RetType = T;
-  static constexpr RetType get(T value) { return value; }
-  static constexpr RetType set(T value) { return value; }
-};
-template <> struct vec_helper<bool> {
-  using RetType = select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                    std::int32_t, std::int64_t>;
-  static constexpr RetType get(bool value) { return value; }
-  static constexpr RetType set(bool value) { return value; }
-};
-
-template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
-  using RetType = sycl::ext::oneapi::bfloat16;
-  using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
-  static constexpr RetType get(BFloat16StorageT value) {
-#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
-    return sycl::bit_cast<RetType>(value);
-#else
-    // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
-    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
-    // but neither available yet.
-    union {
-      sycl::ext::oneapi::bfloat16 bf16;
-      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
-    } result = {};
-    result.storage = value;
-    return result.bf16;
-#endif
-  }
-
-  static constexpr RetType get(RetType value) { return value; }
-
-  static constexpr BFloat16StorageT set(RetType value) {
-#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
-    return sycl::bit_cast<BFloat16StorageT>(value);
-#else
-    union {
-      sycl::ext::oneapi::bfloat16 bf16;
-      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
-    } result = {};
-    result.bf16 = value;
-    return result.storage;
-#endif
-  }
-};
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-template <> struct vec_helper<std::byte> {
-  using RetType = std::uint8_t;
-  static constexpr RetType get(std::byte value) { return (RetType)value; }
-  static constexpr RetType set(std::byte value) { return (RetType)value; }
-  static constexpr std::byte get(std::uint8_t value) {
-    return (std::byte)value;
-  }
-  static constexpr std::byte set(std::uint8_t value) {
-    return (std::byte)value;
-  }
-};
-#endif
-
-template <typename VecT, typename OperationLeftT, typename OperationRightT,
-          template <typename> class OperationCurrentT, int... Indexes>
-class SwizzleOp;
-
-template <typename T, int N, typename V = void> struct VecStorage;
-
-// Element type for relational operator return value.
-template <typename DataT>
-using rel_t = typename std::conditional_t<
-    sizeof(DataT) == sizeof(opencl::cl_char), opencl::cl_char,
-    typename std::conditional_t<
-        sizeof(DataT) == sizeof(opencl::cl_short), opencl::cl_short,
-        typename std::conditional_t<
-            sizeof(DataT) == sizeof(opencl::cl_int), opencl::cl_int,
-            typename std::conditional_t<sizeof(DataT) ==
-                                            sizeof(opencl::cl_long),
-                                        opencl::cl_long, bool>>>>;
-
-// Special type indicating that SwizzleOp should just read value from vector -
-// not trying to perform any operations. Should not be called.
-template <typename T> class GetOp {
-public:
-  using DataT = T;
-  DataT getValue(size_t) const { return (DataT)0; }
-  DataT operator()(DataT, DataT) { return (DataT)0; }
-};
-
-// Special type for working SwizzleOp with scalars, stores a scalar and gives
-// the scalar at any index. Provides interface is compatible with SwizzleOp
-// operations
-template <typename T> class GetScalarOp {
-public:
-  using DataT = T;
-  GetScalarOp(DataT Data) : m_Data(Data) {}
-  DataT getValue(size_t) const { return m_Data; }
-
-private:
-  DataT m_Data;
-};
-
-template <typename T> struct EqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs == Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct NotEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs != Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct GreaterEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs >= Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LessEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs <= Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct GreaterThan {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs > Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LessThan {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs < Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LogicalAnd {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs && Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LogicalOr {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs || Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct RShift {
-  constexpr T operator()(const T &Lhs, const T &Rhs) const {
-    return Lhs >> Rhs;
-  }
-};
-
-template <typename T> struct LShift {
-  constexpr T operator()(const T &Lhs, const T &Rhs) const {
-    return Lhs << Rhs;
-  }
-};
-
-// Forward declarations
-template <typename TransformedArgType, int Dims, typename KernelType>
-class RoundedRangeKernel;
-template <typename TransformedArgType, int Dims, typename KernelType>
-class RoundedRangeKernelWithKH;
-
-} // namespace detail
-
-template <typename T> using vec_data = detail::vec_helper<T>;
-
-template <typename T>
-using vec_data_t = typename detail::vec_helper<T>::RetType;
-
-/// Provides a cross-patform vector class template that works efficiently on
-/// SYCL devices as well as in host C++ code.
-///
-/// \ingroup sycl_api
-template <typename Type, int NumElements> class vec {
-  using DataT = Type;
-
-  // This represent type of underlying value. There should be only one field
-  // in the class, so vec<float, 16> should be equal to float16 in memory.
-  using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
-
-  static constexpr bool IsHostHalf =
-      std::is_same_v<DataT, sycl::detail::half_impl::half> &&
-      std::is_same_v<sycl::detail::half_impl::StorageT,
-                     sycl::detail::host_half_impl::half>;
-
-  static constexpr bool IsBfloat16 =
-      std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
-
-  static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
-  static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
-  static constexpr bool IsSizeGreaterThanMaxAlign =
-      (Sz > detail::MaxVecAlignment);
-
-  // TODO: There is no support for vector half type on host yet.
-  // Also, when Sz is greater than alignment, we use std::array instead of
-  // vector extension. This is for MSVC compatibility, which has a max alignment
-  // of 64 for direct params. If we drop MSVC, we can have alignment the same as
-  // size and use vector extensions for all sizes.
-  static constexpr bool IsUsingArrayOnDevice =
-      (IsHostHalf || IsBfloat16 || IsSizeGreaterThanMaxAlign);
-
-#if defined(__SYCL_DEVICE_ONLY__)
-  static constexpr bool NativeVec = NumElements > 1 && !IsUsingArrayOnDevice;
-  static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
-#else
-  static constexpr bool NativeVec = false;
-  static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
-#endif
-
-  static constexpr int getNumElements() { return NumElements; }
-
-  // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
-  template <int Counter, int MaxValue, class...>
-  struct SizeChecker : std::conditional_t<Counter == MaxValue, std::true_type,
-                                          std::false_type> {};
-
-  template <int Counter, int MaxValue, typename DataT_, class... tail>
-  struct SizeChecker<Counter, MaxValue, DataT_, tail...>
-      : std::conditional_t<Counter + 1 <= MaxValue,
-                           SizeChecker<Counter + 1, MaxValue, tail...>,
-                           std::false_type> {};
-
-  // Utility trait for creating an std::array from an vector argument.
-  template <typename DataT_, typename T, std::size_t... Is>
-  static constexpr std::array<DataT_, sizeof...(Is)>
-  VecToArray(const vec<T, sizeof...(Is)> &V, std::index_sequence<Is...>) {
-    return {static_cast<DataT_>(V.getValue(Is))...};
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5, std::size_t... Is>
-  static constexpr std::array<DataT_, sizeof...(Is)>
-  VecToArray(const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &V,
-             std::index_sequence<Is...>) {
-    return {static_cast<DataT_>(V.getValue(Is))...};
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5, std::size_t... Is>
-  static constexpr std::array<DataT_, sizeof...(Is)>
-  VecToArray(const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &V,
-             std::index_sequence<Is...>) {
-    return {static_cast<DataT_>(V.getValue(Is))...};
-  }
-  template <typename DataT_, typename T, int N>
-  static constexpr std::array<DataT_, N>
-  FlattenVecArgHelper(const vec<T, N> &A) {
-    return VecToArray<DataT_>(A, std::make_index_sequence<N>());
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5>
-  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
-      const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &A) {
-    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5>
-  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
-      const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &A) {
-    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
-  }
-  template <typename DataT_, typename T>
-  static constexpr auto FlattenVecArgHelper(const T &A) {
-    return std::array<DataT_, 1>{vec_data<DataT_>::get(static_cast<DataT_>(A))};
-  }
-  template <typename DataT_, typename T> struct FlattenVecArg {
-    constexpr auto operator()(const T &A) const {
-      return FlattenVecArgHelper<DataT_>(A);
-    }
-  };
-
-  // Alias for shortening the vec arguments to array converter.
-  template <typename DataT_, typename... ArgTN>
-  using VecArgArrayCreator =
-      detail::ArrayCreator<DataT_, FlattenVecArg, ArgTN...>;
-
-#define __SYCL_ALLOW_VECTOR_SIZES(num_elements)                                \
-  template <int Counter, int MaxValue, typename DataT_, class... tail>         \
-  struct SizeChecker<Counter, MaxValue, vec<DataT_, num_elements>, tail...>    \
-      : std::conditional_t<                                                    \
-            Counter + (num_elements) <= MaxValue,                              \
-            SizeChecker<Counter + (num_elements), MaxValue, tail...>,          \
-            std::false_type> {};                                               \
-  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
-            typename T3, template <typename> class T4, int... T5,              \
-            class... tail>                                                     \
-  struct SizeChecker<                                                          \
-      Counter, MaxValue,                                                       \
-      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>,         \
-      tail...>                                                                 \
-      : std::conditional_t<                                                    \
-            Counter + sizeof...(T5) <= MaxValue,                               \
-            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
-            std::false_type> {};                                               \
-  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
-            typename T3, template <typename> class T4, int... T5,              \
-            class... tail>                                                     \
-  struct SizeChecker<                                                          \
-      Counter, MaxValue,                                                       \
-      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
-      tail...>                                                                 \
-      : std::conditional_t<                                                    \
-            Counter + sizeof...(T5) <= MaxValue,                               \
-            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
-            std::false_type> {};
-
-  __SYCL_ALLOW_VECTOR_SIZES(1)
-  __SYCL_ALLOW_VECTOR_SIZES(2)
-  __SYCL_ALLOW_VECTOR_SIZES(3)
-  __SYCL_ALLOW_VECTOR_SIZES(4)
-  __SYCL_ALLOW_VECTOR_SIZES(8)
-  __SYCL_ALLOW_VECTOR_SIZES(16)
-#undef __SYCL_ALLOW_VECTOR_SIZES
-
-  // TypeChecker is needed for vec(const argTN &... args) ctor to validate args.
-  template <typename T, typename DataT_>
-  struct TypeChecker : std::is_convertible<T, DataT_> {};
-#define __SYCL_ALLOW_VECTOR_TYPES(num_elements)                                \
-  template <typename DataT_>                                                   \
-  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {};   \
-  template <typename DataT_, typename T2, typename T3,                         \
-            template <typename> class T4, int... T5>                           \
-  struct TypeChecker<                                                          \
-      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
-      : std::true_type {};                                                     \
-  template <typename DataT_, typename T2, typename T3,                         \
-            template <typename> class T4, int... T5>                           \
-  struct TypeChecker<                                                          \
-      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
-      DataT_> : std::true_type {};
-
-  __SYCL_ALLOW_VECTOR_TYPES(1)
-  __SYCL_ALLOW_VECTOR_TYPES(2)
-  __SYCL_ALLOW_VECTOR_TYPES(3)
-  __SYCL_ALLOW_VECTOR_TYPES(4)
-  __SYCL_ALLOW_VECTOR_TYPES(8)
-  __SYCL_ALLOW_VECTOR_TYPES(16)
-#undef __SYCL_ALLOW_VECTOR_TYPES
-
-  template <int... Indexes>
-  using Swizzle =
-      detail::SwizzleOp<vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
-                        detail::GetOp, Indexes...>;
-
-  template <int... Indexes>
-  using ConstSwizzle =
-      detail::SwizzleOp<const vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
-                        detail::GetOp, Indexes...>;
-
-  // Shortcuts for args validation in vec(const argTN &... args) ctor.
-  template <typename... argTN>
-  using EnableIfSuitableTypes = typename std::enable_if_t<
-      std::conjunction_v<TypeChecker<argTN, DataT>...>>;
-
-  template <typename... argTN>
-  using EnableIfSuitableNumElements =
-      typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
-
-  template <size_t... Is>
-  constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
-                std::index_sequence<Is...>)
-      : m_Data{([&](vec_data_t<DataT> v) constexpr {
-          if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
-            return v.value;
-          else
-            return vec_data_t<DataT>(static_cast<DataT>(v));
-        })(Arr[Is])...} {}
-
-public:
-  using element_type = DataT;
-  using value_type = DataT;
-  using rel_t = detail::rel_t<DataT>;
-#ifdef __SYCL_DEVICE_ONLY__
-  using vector_t =
-      typename detail::VecStorage<DataT, NumElements>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-
-  vec() = default;
-
-  constexpr vec(const vec &Rhs) = default;
-  constexpr vec(vec &&Rhs) = default;
-
-  constexpr vec &operator=(const vec &Rhs) = default;
-
-  // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
-  template <typename Ty = DataT>
-  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
-                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
-                            vec &>
-  operator=(const vec<rel_t, NumElements> &Rhs) {
-    *this = Rhs.template as<vec>();
-    return *this;
-  }
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  template <typename T = void>
-  using EnableIfNotHostHalf = typename std::enable_if_t<!IsHostHalf, T>;
-
-  template <typename T = void>
-  using EnableIfHostHalf = typename std::enable_if_t<IsHostHalf, T>;
-
-  template <typename T = void>
-  using EnableIfUsingArrayOnDevice =
-      typename std::enable_if_t<IsUsingArrayOnDevice, T>;
-
-  template <typename T = void>
-  using EnableIfNotUsingArrayOnDevice =
-      typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  template <typename T = void>
-  using EnableIfUsingArray =
-      typename std::enable_if_t<IsUsingArrayOnDevice || IsUsingArrayOnHost, T>;
-
-  template <typename T = void>
-  using EnableIfNotUsingArray =
-      typename std::enable_if_t<!IsUsingArrayOnDevice && !IsUsingArrayOnHost,
-                                T>;
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-
-  template <typename Ty = DataT>
-  explicit constexpr vec(const EnableIfNotUsingArrayOnDevice<Ty> &arg)
-      : m_Data{DataType(vec_data<Ty>::get(arg))} {}
-
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) {
-    m_Data = (DataType)vec_data<Ty>::get(Rhs);
-    return *this;
-  }
-
-  template <typename Ty = DataT>
-  explicit constexpr vec(const EnableIfUsingArrayOnDevice<Ty> &arg)
-      : vec{detail::RepeatValue<NumElements>(
-                static_cast<vec_data_t<DataT>>(arg)),
-            std::make_index_sequence<NumElements>()} {}
-
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
-    for (int i = 0; i < NumElements; ++i) {
-      setValue(i, Rhs);
-    }
-    return *this;
-  }
-#else  // __SYCL_USE_EXT_VECTOR_TYPE__
-  explicit constexpr vec(const DataT &arg)
-      : vec{detail::RepeatValue<NumElements>(
-                static_cast<vec_data_t<DataT>>(arg)),
-            std::make_index_sequence<NumElements>()} {}
-
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const DataT &Rhs) {
-    for (int i = 0; i < NumElements; ++i) {
-      setValue(i, Rhs);
-    }
-    return *this;
-  }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  // Optimized naive constructors with NumElements of DataT values.
-  // We don't expect compilers to optimize vararg recursive functions well.
-
-  // Helper type to make specific constructors available only for specific
-  // number of elements.
-  template <int IdxNum, typename T = void>
-  using EnableIfMultipleElems = typename std::enable_if_t<
-      std::is_convertible_v<T, DataT> && NumElements == IdxNum, DataT>;
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<2, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<3, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<4, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const Ty Arg3)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<8, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const DataT Arg3, const DataT Arg4, const DataT Arg5,
-                const DataT Arg6, const DataT Arg7)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
-               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
-               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<16, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const DataT Arg3, const DataT Arg4, const DataT Arg5,
-                const DataT Arg6, const DataT Arg7, const DataT Arg8,
-                const DataT Arg9, const DataT ArgA, const DataT ArgB,
-                const DataT ArgC, const DataT ArgD, const DataT ArgE,
-                const DataT ArgF)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
-               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
-               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7),
-               vec_data<Ty>::get(Arg8), vec_data<Ty>::get(Arg9),
-               vec_data<Ty>::get(ArgA), vec_data<Ty>::get(ArgB),
-               vec_data<Ty>::get(ArgC), vec_data<Ty>::get(ArgD),
-               vec_data<Ty>::get(ArgE), vec_data<Ty>::get(ArgF)} {}
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  // Constructor from values of base type or vec of base type. Checks that
-  // base types are match and that the NumElements == sum of lengths of args.
-  template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
-            typename = EnableIfSuitableNumElements<argTN...>>
-  constexpr vec(const argTN &...args)
-      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
-            std::make_index_sequence<NumElements>()} {}
-
-#ifdef __SYCL_DEVICE_ONLY__
-  template <typename vector_t_ = vector_t,
-            typename =
-                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
-                                          !std::is_same_v<vector_t_, DataT>>>
-  constexpr vec(vector_t openclVector) {
-    if constexpr (!IsUsingArrayOnDevice) {
-      m_Data = openclVector;
-    } else {
-      m_Data = bit_cast<DataType>(openclVector);
-    }
-  }
-
-  operator vector_t() const {
-    if constexpr (!IsUsingArrayOnDevice) {
-      return m_Data;
-    } else {
-      auto ptr = bit_cast<const vector_t *>((&m_Data)->data());
-      return *ptr;
-    }
-  }
-#endif // __SYCL_DEVICE_ONLY__
-
-  // Available only when: NumElements == 1
-  template <int N = NumElements>
-  operator typename std::enable_if_t<N == 1, DataT>() const {
-    return vec_data<DataT>::get(m_Data);
-  }
-
-  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
-  static constexpr size_t get_count() { return size(); }
-  static constexpr size_t size() noexcept { return NumElements; }
-  __SYCL2020_DEPRECATED(
-      "get_size() is deprecated, please use byte_size() instead")
-  static constexpr size_t get_size() { return byte_size(); }
-  static constexpr size_t byte_size() noexcept { return sizeof(m_Data); }
-
-  // convertImpl can't be called with the same From and To types and therefore
-  // we need this version of convert which is mostly no-op.
-  template <typename convertT,
-            rounding_mode roundingMode = rounding_mode::automatic>
-  std::enable_if_t<
-      std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> ||
-          std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
-                         detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
-      vec<convertT, NumElements>>
-  convert() const {
-    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
-                      detail::is_floating_point<convertT>::value,
-                  "Unsupported convertT");
-    if constexpr (!std::is_same_v<DataT, convertT>) {
-      // Dummy conversion for cases like vec<signed char> -> vec<char>
-      vec<convertT, NumElements> Result;
-      for (size_t I = 0; I < NumElements; ++I)
-        Result.setValue(I, static_cast<convertT>(getValue(I)));
-
-      return Result;
-    } else {
-      // No conversion necessary
-      return *this;
-    }
-  }
-
-  template <typename convertT,
-            rounding_mode roundingMode = rounding_mode::automatic>
-  std::enable_if_t<
-      !std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> &&
-          !std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
-                          detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
-      vec<convertT, NumElements>>
-  convert() const {
-    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
-                      detail::is_floating_point<convertT>::value,
-                  "Unsupported convertT");
-    using T = vec_data_t<DataT>;
-    using R = vec_data_t<convertT>;
-    using OpenCLT = detail::ConvertToOpenCLType_t<T>;
-    using OpenCLR = detail::ConvertToOpenCLType_t<R>;
-    vec<convertT, NumElements> Result;
-
-#if defined(__SYCL_DEVICE_ONLY__)
-    using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
-    using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
-    // Whole vector conversion can only be done, if:
-    constexpr bool canUseNativeVectorConvert =
-#ifdef __NVPTX__
-        // - we are not on CUDA, see intel/llvm#11840
-        false &&
-#endif
-        // - both vectors are represented using native vector types;
-        NativeVec && vec<convertT, NumElements>::NativeVec &&
-        // - vec storage has an equivalent OpenCL native vector it is implicitly
-        //   convertible to. There are some corner cases where it is not the
-        //   case with char, long and long long types.
-        std::is_convertible_v<decltype(m_Data), OpenCLVecT> &&
-        std::is_convertible_v<decltype(Result.m_Data), OpenCLVecR> &&
-        // - it is not a signed to unsigned (or vice versa) conversion
-        //   see comments within 'convertImpl' for more details;
-        !detail::is_sint_to_from_uint<T, R>::value &&
-        // - destination type is not bool. bool is stored as integer under the
-        //   hood and therefore conversion to bool looks like conversion between
-        //   two integer types. Since bit pattern for true and false is not
-        //   defined, there is no guarantee that integer conversion yields
-        //   right results here;
-        !std::is_same_v<convertT, bool>;
-    if constexpr (canUseNativeVectorConvert) {
-      Result.m_Data = detail::convertImpl<T, R, roundingMode, NumElements,
-                                          OpenCLVecT, OpenCLVecR>(m_Data);
-    } else
-#endif // defined(__SYCL_DEVICE_ONLY__)
-    {
-      // Otherwise, we fallback to per-element conversion:
-      for (size_t I = 0; I < NumElements; ++I) {
-        Result.setValue(
-            I, vec_data<convertT>::get(
-                   detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
-                       vec_data<DataT>::get(getValue(I)))));
-      }
-    }
-
-    return Result;
-  }
-
-  template <typename asT> asT as() const {
-    static_assert((sizeof(*this) == sizeof(asT)),
-                  "The new SYCL vec type must have the same storage size in "
-                  "bytes as this SYCL vec");
-    static_assert(
-        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
-            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
-        "asT must be SYCL vec of a different element type and "
-        "number of elements specified by asT");
-    asT Result;
-    detail::memcpy(&Result.m_Data, &m_Data, sizeof(decltype(Result.m_Data)));
-    return Result;
-  }
-
-  template <int... SwizzleIndexes> Swizzle<SwizzleIndexes...> swizzle() {
-    return this;
-  }
-
-  template <int... SwizzleIndexes>
-  ConstSwizzle<SwizzleIndexes...> swizzle() const {
-    return this;
-  }
-
-  // ext_vector_type is used as an underlying type for sycl::vec on device.
-  // The problem is that for clang vector types the return of operator[] is a
-  // temporary and not a reference to the element in the vector. In practice
-  // reinterpret_cast<DataT *>(&m_Data)[i]; is working. According to
-  // http://llvm.org/docs/GetElementPtr.html#can-gep-index-into-vector-elements
-  // this is not disallowed now. But could probably be disallowed in the future.
-  // That is why tests are added to check that behavior of the compiler has
-  // not changed.
-  //
-  // Implement operator [] in the same way for host and device.
-  // TODO: change host side implementation when underlying type for host side
-  // will be changed to std::array.
-  // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
-  // aggressively optimized. Specializing with noinline to avoid as workaround.
-
-  template <typename T = DataT>
-  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                            const DataT &>
-  operator[](int i) const {
-    return reinterpret_cast<const DataT *>(&m_Data)[i];
-  }
-
-  template <typename T = DataT>
-  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                            DataT &>
-  operator[](int i) {
-    return reinterpret_cast<DataT *>(&m_Data)[i];
-  }
-
-#ifdef _MSC_VER
-#define __SYCL_NOINLINE_BF16 __declspec(noinline)
-#else
-#define __SYCL_NOINLINE_BF16 __attribute__((noinline))
-#endif
-
-  template <typename T = DataT>
-  __SYCL_NOINLINE_BF16
-      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                                const DataT &>
-      operator[](int i) const {
-    return reinterpret_cast<const DataT *>(&m_Data)[i];
-  }
-
-  template <typename T = DataT>
-  __SYCL_NOINLINE_BF16
-      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                                DataT &>
-      operator[](int i) {
-    return reinterpret_cast<DataT *>(&m_Data)[i];
-  }
-
-#undef __SYCL_NOINLINE_BF16
-
-  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
-private:
-  // Indexer used in the swizzles.def
-  // Currently it is defined as a template struct. Replacing it with a constexpr
-  // function would activate a bug in MSVC that is fixed only in v19.20.
-  // Until then MSVC does not recognize such constexpr functions as const and
-  // thus does not let using them in template parameters inside swizzle.def.
-  template <int Index> struct Indexer {
-    static constexpr int value = Index;
-  };
 
-public:
-#ifdef __SYCL_ACCESS_RETURN
-#error "Undefine __SYCL_ACCESS_RETURN macro"
-#endif
-#define __SYCL_ACCESS_RETURN this
-#include "swizzles.def"
-#undef __SYCL_ACCESS_RETURN
-  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
-
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void load(size_t Offset, multi_ptr<const DataT, Space, DecorateAddress> Ptr) {
-    for (int I = 0; I < NumElements; I++) {
-      setValue(I, *multi_ptr<const DataT, Space, DecorateAddress>(
-                      Ptr + Offset * NumElements + I));
-    }
-  }
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void load(size_t Offset, multi_ptr<DataT, Space, DecorateAddress> Ptr) {
-    multi_ptr<const DataT, Space, DecorateAddress> ConstPtr(Ptr);
-    load(Offset, ConstPtr);
-  }
-  template <int Dimensions, access::mode Mode,
-            access::placeholder IsPlaceholder, access::target Target,
-            typename PropertyListT>
-  void
-  load(size_t Offset,
-       accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
-           Acc) {
-    multi_ptr<const DataT, detail::TargetToAS<Target>::AS,
-              access::decorated::yes>
-        MultiPtr(Acc);
-    load(Offset, MultiPtr);
-  }
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void store(size_t Offset,
-             multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
-    for (int I = 0; I < NumElements; I++) {
-      *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
-                                                I) = getValue(I);
-    }
-  }
-  template <int Dimensions, access::mode Mode,
-            access::placeholder IsPlaceholder, access::target Target,
-            typename PropertyListT>
-  void
-  store(size_t Offset,
-        accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
-            Acc) {
-    multi_ptr<DataT, detail::TargetToAS<Target>::AS, access::decorated::yes>
-        MultiPtr(Acc);
-    store(Offset, MultiPtr);
-  }
-
-  void ConvertToDataT() {
-    for (size_t i = 0; i < NumElements; ++i) {
-      DataT tmp = getValue(i);
-      setValue(i, tmp);
-    }
-  }
-
-#ifdef __SYCL_BINOP
-#error "Undefine __SYCL_BINOP macro"
-#endif
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
-  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
-    vec Ret;                                                                   \
-    if constexpr (IsUsingArrayOnDevice) {                                      \
-      for (size_t I = 0; I < NumElements; ++I) {                               \
-        Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
-      }                                                                        \
-    } else {                                                                   \
-      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
-      if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
-        Ret.ConvertToDataT();                                                  \
-      }                                                                        \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
-    return Lhs BINOP vec(Rhs);                                                 \
-  }                                                                            \
-  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
-    return vec(Lhs) BINOP Rhs;                                                 \
-  }                                                                            \
-  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
-    Lhs = Lhs BINOP Rhs;                                                       \
-    return Lhs;                                                                \
-  }                                                                            \
-  template <int Num = NumElements>                                             \
-  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
-      vec & Lhs, const DataT & Rhs) {                                          \
-    Lhs = Lhs BINOP vec(Rhs);                                                  \
-    return Lhs;                                                                \
-  }
-
-#else // __SYCL_USE_EXT_VECTOR_TYPE__
-
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
-  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
-    vec Ret{};                                                                 \
-    if constexpr (NativeVec)                                                   \
-      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
-    else                                                                       \
-      for (size_t I = 0; I < NumElements; ++I)                                 \
-        Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(             \
-                            I)) BINOP vec_data<DataT>::get(Rhs.getValue(I)))); \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
-    return Lhs BINOP vec(Rhs);                                                 \
-  }                                                                            \
-  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
-    return vec(Lhs) BINOP Rhs;                                                 \
-  }                                                                            \
-  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
-    Lhs = Lhs BINOP Rhs;                                                       \
-    return Lhs;                                                                \
-  }                                                                            \
-  template <int Num = NumElements>                                             \
-  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
-      vec & Lhs, const DataT & Rhs) {                                          \
-    Lhs = Lhs BINOP vec(Rhs);                                                  \
-    return Lhs;                                                                \
-  }
-
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  __SYCL_BINOP(+, +=, true)
-  __SYCL_BINOP(-, -=, true)
-  __SYCL_BINOP(*, *=, false)
-  __SYCL_BINOP(/, /=, false)
-
-  // TODO: The following OPs are available only when: DataT != cl_float &&
-  // DataT != cl_double && DataT != cl_half
-  __SYCL_BINOP(%, %=, false)
-  __SYCL_BINOP(|, |=, false)
-  __SYCL_BINOP(&, &=, false)
-  __SYCL_BINOP(^, ^=, false)
-  __SYCL_BINOP(>>, >>=, false)
-  __SYCL_BINOP(<<, <<=, true)
-#undef __SYCL_BINOP
-#undef __SYCL_BINOP_HELP
-
-  // Note: vec<>/SwizzleOp logical value is 0/-1 logic, as opposed to 0/1 logic.
-  // As far as CTS validation is concerned, 0/-1 logic also applies when
-  // NumElements is equal to one, which is somewhat inconsistent with being
-  // transparent with scalar data.
-  // TODO: Determine if vec<, NumElements=1> is needed at all, remove this
-  // inconsistency if not by disallowing one-element vectors (as in OpenCL)
-
-#ifdef __SYCL_RELLOGOP
-#error "Undefine __SYCL_RELLOGOP macro"
-#endif
-// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
-// by SYCL device compiler only.
-#ifdef __SYCL_DEVICE_ONLY__
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const vec & Rhs) {          \
-    vec<rel_t, NumElements> Ret{};                                             \
-    /* This special case is needed since there are no standard operator||   */ \
-    /* or operator&& functions for std::array.                              */ \
-    if constexpr (IsUsingArrayOnDevice &&                                      \
-                  (std::string_view(#RELLOGOP) == "||" ||                      \
-                   std::string_view(#RELLOGOP) == "&&")) {                     \
-      for (size_t I = 0; I < NumElements; ++I) {                               \
-        /* We cannot use SetValue here as the operator is not a friend of*/    \
-        /* Ret on Windows. */                                                  \
-        Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                    \
-            Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
-      }                                                                        \
-    } else {                                                                   \
-      Ret = vec<rel_t, NumElements>(                                           \
-          (typename vec<rel_t, NumElements>::vector_t)(                        \
-              Lhs.m_Data RELLOGOP Rhs.m_Data));                                \
-      if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
-        Ret *= -1;                                                             \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const DataT & Rhs) {        \
-    return Lhs RELLOGOP vec(Rhs);                                              \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
-                                                   const vec & Rhs) {          \
-    return vec(Lhs) RELLOGOP Rhs;                                              \
-  }
-
-#else
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const vec & Rhs) {          \
-    vec<rel_t, NumElements> Ret{};                                             \
-    for (size_t I = 0; I < NumElements; ++I) {                                 \
-      /* We cannot use SetValue here as the operator is not a friend of*/      \
-      /* Ret on Windows. */                                                    \
-      Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                      \
-          Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));   \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const DataT & Rhs) {        \
-    return Lhs RELLOGOP vec(Rhs);                                              \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
-                                                   const vec & Rhs) {          \
-    return vec(Lhs) RELLOGOP Rhs;                                              \
-  }
-#endif
-
-  __SYCL_RELLOGOP(==)
-  __SYCL_RELLOGOP(!=)
-  __SYCL_RELLOGOP(>)
-  __SYCL_RELLOGOP(<)
-  __SYCL_RELLOGOP(>=)
-  __SYCL_RELLOGOP(<=)
-  // TODO: limit to integral types.
-  __SYCL_RELLOGOP(&&)
-  __SYCL_RELLOGOP(||)
-#undef __SYCL_RELLOGOP
-
-#ifdef __SYCL_UOP
-#error "Undefine __SYCL_UOP macro"
-#endif
-#define __SYCL_UOP(UOP, OPASSIGN)                                              \
-  friend vec &operator UOP(vec & Rhs) {                                        \
-    Rhs OPASSIGN vec_data<DataT>::get(1);                                      \
-    return Rhs;                                                                \
-  }                                                                            \
-  friend vec operator UOP(vec &Lhs, int) {                                     \
-    vec Ret(Lhs);                                                              \
-    Lhs OPASSIGN vec_data<DataT>::get(1);                                      \
-    return Ret;                                                                \
-  }
-
-  __SYCL_UOP(++, +=)
-  __SYCL_UOP(--, -=)
-#undef __SYCL_UOP
-
-  // operator~() available only when: dataT != float && dataT != double
-  // && dataT != half
-  friend vec operator~(const vec &Rhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I) {
-        Ret.setValue(I, ~Rhs.getValue(I));
-      }
-      return Ret;
-    } else {
-      vec Ret{(typename vec::DataType) ~Rhs.m_Data};
-      if constexpr (std::is_same_v<Type, bool>) {
-        Ret.ConvertToDataT();
-      }
-      return Ret;
-    }
-  }
-
-  // operator!
-  friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I) {
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-        // std::byte neither supports ! unary op or casting, so special handling
-        // is needed. And, worse, Windows has a conflict with 'byte'.
-        if constexpr (std::is_same_v<std::byte, DataT>) {
-          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
-        } else
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-        {
-          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
-        }
-      }
-      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
-    } else {
-      return vec{(typename vec<DataT, NumElements>::DataType) !Rhs.m_Data}
-          .template as<vec<detail::rel_t<DataT>, NumElements>>();
-    }
-  }
-
-  // operator +
-  friend vec operator+(const vec &Lhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I)
-        Ret.setValue(
-            I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
-      return Ret;
-    } else {
-      return vec{+Lhs.m_Data};
-    }
-  }
-
-  // operator -
-  friend vec operator-(const vec &Lhs) {
-    namespace oneapi = sycl::ext::oneapi;
-    vec Ret{};
-    if constexpr (IsBfloat16 && NumElements == 1) {
-      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data);
-      oneapi::bfloat16 w = -v;
-      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
-    } else if constexpr (IsBfloat16) {
-      for (size_t I = 0; I < NumElements; I++) {
-        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[I]);
-        oneapi::bfloat16 w = -v;
-        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
-      }
-    } else if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      for (size_t I = 0; I < NumElements; ++I)
-        Ret.setValue(
-            I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
-      return Ret;
-    } else {
-      Ret = vec{-Lhs.m_Data};
-      if constexpr (std::is_same_v<Type, bool>) {
-        Ret.ConvertToDataT();
-      }
-      return Ret;
-    }
-  }
-
-  // OP is: &&, ||
-  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
-  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
-
-  // OP is: ==, !=, <, >, <=, >=
-  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
-  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
-private:
-  // Generic method that execute "Operation" on underlying values.
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  template <template <typename> class Operation,
-            typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements>
-  operatorHelper(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataType> Op;
-    Result.m_Data = Op(m_Data, Rhs.m_Data);
-    return Result;
-  }
-
-  template <template <typename> class Operation,
-            typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements>
-  operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataT> Op;
-    for (size_t I = 0; I < NumElements; ++I) {
-      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
-    }
-    return Result;
-  }
-#else  // __SYCL_USE_EXT_VECTOR_TYPE__
-  template <template <typename> class Operation>
-  vec<DataT, NumElements>
-  operatorHelper(const vec<DataT, NumElements> &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataT> Op;
-    for (size_t I = 0; I < NumElements; ++I) {
-      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
-    }
-    return Result;
-  }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  // setValue and getValue should be able to operate on different underlying
-  // types: enum cl_float#N , builtin vector float#N, builtin type float.
-  // These versions are for N > 1.
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
-                          int) {
-    m_Data[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
-    return vec_data<DataT>::get(m_Data[Index]);
-  }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
-    m_Data.s[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
-    return vec_data<DataT>::get(m_Data.s[Index]);
-  }
-#else // __SYCL_USE_EXT_VECTOR_TYPE__
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(int Index, const DataT &Value, int) {
-    m_Data[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(int Index, int) const {
-    return vec_data<DataT>::get(m_Data[Index]);
-  }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  // N==1 versions, used by host and device. Shouldn't trailing type be int?
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 == Num>>
-  constexpr void setValue(int, const DataT &Value, float) {
-    m_Data = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 == Num>>
-  DataT getValue(int, float) const {
-    return vec_data<DataT>::get(m_Data);
-  }
-
-  // setValue and getValue.
-  // The "api" functions used by BINOP etc.  These versions just dispatch
-  // using additional int or float arg to disambiguate vec<1> vs. vec<N>
-  // Special proxies as specialization is not allowed in class scope.
-  constexpr void setValue(int Index, const DataT &Value) {
-    if (NumElements == 1)
-      setValue(Index, Value, 0);
-    else
-      setValue(Index, Value, 0.f);
-  }
-
-  DataT getValue(int Index) const {
-    return (NumElements == 1) ? getValue(Index, 0) : getValue(Index, 0.f);
-  }
-
-  // fields
-
-  // Alignment is the same as size, to a maximum size of 64.
-  // detail::vector_alignment will return that value.
-  alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
-
-  // friends
-  template <typename T1, typename T2, typename T3, template <typename> class T4,
-            int... T5>
-  friend class detail::SwizzleOp;
-  template <typename T1, int T2> friend class vec;
-};
-
-#ifdef __cpp_deduction_guides
-// all compilers supporting deduction guides also support fold expressions
-template <class T, class... U,
-          class = std::enable_if_t<(std::is_same_v<T, U> && ...)>>
-vec(T, U...) -> vec<T, sizeof...(U) + 1>;
-#endif
-
-namespace detail {
-
-// SwizzleOP represents expression templates that operate on vec.
-// Actual computation performed on conversion or assignment operators.
-template <typename VecT, typename OperationLeftT, typename OperationRightT,
-          template <typename> class OperationCurrentT, int... Indexes>
-class SwizzleOp {
-  using DataT = typename VecT::element_type;
-  // Certain operators return a vector with a different element type. Also, the
-  // left and right operand types may differ. CommonDataT selects a result type
-  // based on these types to ensure that the result value can be represented.
-  //
-  // Example 1:
-  //   sycl::vec<unsigned char, 4> vec{...};
-  //   auto result = 300u + vec.x();
-  //
-  // CommonDataT is std::common_type_t<OperationLeftT, OperationRightT> since
-  // it's larger than unsigned char.
-  //
-  // Example 2:
-  //   sycl::vec<bool, 1> vec{...};
-  //   auto result = vec.template swizzle<sycl::elem::s0>() && vec;
-  //
-  // CommonDataT is DataT since operator&& returns a vector with element type
-  // int8_t, which is larger than bool.
-  //
-  // Example 3:
-  //   sycl::vec<std::byte, 4> vec{...}; auto swlo = vec.lo();
-  //   auto result = swlo == swlo;
-  //
-  // CommonDataT is DataT since operator== returns a vector with element type
-  // int8_t, which is the same size as std::byte. std::common_type_t<DataT, ...>
-  // can't be used here since there's no type that int8_t and std::byte can both
-  // be implicitly converted to.
-  using OpLeftDataT = typename OperationLeftT::DataT;
-  using OpRightDataT = typename OperationRightT::DataT;
-  using CommonDataT = std::conditional_t<
-      sizeof(DataT) >= sizeof(std::common_type_t<OpLeftDataT, OpRightDataT>),
-      DataT, std::common_type_t<OpLeftDataT, OpRightDataT>>;
-  static constexpr int getNumElements() { return sizeof...(Indexes); }
-
-  using rel_t = detail::rel_t<DataT>;
-  using vec_t = vec<DataT, sizeof...(Indexes)>;
-  using vec_rel_t = vec<rel_t, sizeof...(Indexes)>;
-
-  template <typename OperationRightT_,
-            template <typename> class OperationCurrentT_, int... Idx_>
-  using NewLHOp = SwizzleOp<VecT,
-                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                                      OperationCurrentT, Indexes...>,
-                            OperationRightT_, OperationCurrentT_, Idx_...>;
-
-  template <typename OperationRightT_,
-            template <typename> class OperationCurrentT_, int... Idx_>
-  using NewRelOp = SwizzleOp<vec<rel_t, VecT::getNumElements()>,
-                             SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                                       OperationCurrentT, Indexes...>,
-                             OperationRightT_, OperationCurrentT_, Idx_...>;
-
-  template <typename OperationLeftT_,
-            template <typename> class OperationCurrentT_, int... Idx_>
-  using NewRHOp = SwizzleOp<VecT, OperationLeftT_,
-                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                                      OperationCurrentT, Indexes...>,
-                            OperationCurrentT_, Idx_...>;
-
-  template <int IdxNum, typename T = void>
-  using EnableIfOneIndex = typename std::enable_if_t<
-      1 == IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
-
-  template <int IdxNum, typename T = void>
-  using EnableIfMultipleIndexes = typename std::enable_if_t<
-      1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
-
-  template <typename T>
-  using EnableIfScalarType = typename std::enable_if_t<
-      std::is_convertible_v<DataT, T> &&
-      (std::is_fundamental_v<vec_data_t<T>> ||
-       detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
-
-  template <typename T>
-  using EnableIfNoScalarType = typename std::enable_if_t<
-      !std::is_convertible_v<DataT, T> ||
-      !(std::is_fundamental_v<vec_data_t<T>> ||
-        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
-
-  template <int... Indices>
-  using Swizzle =
-      SwizzleOp<VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
-
-  template <int... Indices>
-  using ConstSwizzle =
-      SwizzleOp<const VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
-
-public:
-  using element_type = DataT;
-  using value_type = DataT;
-
-#ifdef __SYCL_DEVICE_ONLY__
-  using vector_t = typename vec_t::vector_t;
-#endif // __SYCL_DEVICE_ONLY__
-
-  const DataT &operator[](int i) const {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    return (*m_Vector)[Idxs[i]];
-  }
-
-  template <typename _T = VecT>
-  std::enable_if_t<!std::is_const_v<_T>, DataT> &operator[](int i) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    return (*m_Vector)[Idxs[i]];
-  }
-
-  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
-  size_t get_count() const { return size(); }
-  static constexpr size_t size() noexcept { return getNumElements(); }
-
-  template <int Num = getNumElements()>
-  __SYCL2020_DEPRECATED(
-      "get_size() is deprecated, please use byte_size() instead")
-  size_t get_size() const {
-    return byte_size<Num>();
-  }
-
-  template <int Num = getNumElements()> size_t byte_size() const noexcept {
-    return sizeof(DataT) * (Num == 3 ? 4 : Num);
-  }
-
-  template <typename T, int IdxNum = getNumElements(),
-            typename = EnableIfOneIndex<IdxNum>,
-            typename = EnableIfScalarType<T>>
-  operator T() const {
-    return getValue(0);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  friend NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>
-  operator*(const T &Lhs, const SwizzleOp &Rhs) {
-    return NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
-        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  friend NewRHOp<GetScalarOp<T>, std::plus, Indexes...>
-  operator+(const T &Lhs, const SwizzleOp &Rhs) {
-    return NewRHOp<GetScalarOp<T>, std::plus, Indexes...>(
-        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  friend NewRHOp<GetScalarOp<T>, std::divides, Indexes...>
-  operator/(const T &Lhs, const SwizzleOp &Rhs) {
-    return NewRHOp<GetScalarOp<T>, std::divides, Indexes...>(
-        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
-  }
-
-  // TODO: Check that Rhs arg is suitable.
-#ifdef __SYCL_OPASSIGN
-#error "Undefine __SYCL_OPASSIGN macro."
-#endif
-#define __SYCL_OPASSIGN(OPASSIGN, OP)                                          \
-  SwizzleOp &operator OPASSIGN(const DataT & Rhs) {                            \
-    operatorHelper<OP>(vec_t(Rhs));                                            \
-    return *this;                                                              \
-  }                                                                            \
-  template <typename RhsOperation>                                             \
-  SwizzleOp &operator OPASSIGN(const RhsOperation & Rhs) {                     \
-    operatorHelper<OP>(Rhs);                                                   \
-    return *this;                                                              \
-  }
-
-  __SYCL_OPASSIGN(+=, std::plus)
-  __SYCL_OPASSIGN(-=, std::minus)
-  __SYCL_OPASSIGN(*=, std::multiplies)
-  __SYCL_OPASSIGN(/=, std::divides)
-  __SYCL_OPASSIGN(%=, std::modulus)
-  __SYCL_OPASSIGN(&=, std::bit_and)
-  __SYCL_OPASSIGN(|=, std::bit_or)
-  __SYCL_OPASSIGN(^=, std::bit_xor)
-  __SYCL_OPASSIGN(>>=, RShift)
-  __SYCL_OPASSIGN(<<=, LShift)
-#undef __SYCL_OPASSIGN
-
-#ifdef __SYCL_UOP
-#error "Undefine __SYCL_UOP macro"
-#endif
-#define __SYCL_UOP(UOP, OPASSIGN)                                              \
-  SwizzleOp &operator UOP() {                                                  \
-    *this OPASSIGN static_cast<DataT>(1);                                      \
-    return *this;                                                              \
-  }                                                                            \
-  vec_t operator UOP(int) {                                                    \
-    vec_t Ret = *this;                                                         \
-    *this OPASSIGN static_cast<DataT>(1);                                      \
-    return Ret;                                                                \
-  }
-
-  __SYCL_UOP(++, +=)
-  __SYCL_UOP(--, -=)
-#undef __SYCL_UOP
-
-  template <typename T = DataT>
-  friend typename std::enable_if_t<
-      std::is_same_v<T, DataT> && std::is_integral_v<vec_data_t<T>>, vec_t>
-  operator~(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return ~Tmp;
-  }
-
-  friend vec_rel_t operator!(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return !Tmp;
-  }
-
-  friend vec_t operator+(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return +Tmp;
-  }
-
-  friend vec_t operator-(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return -Tmp;
-  }
-
-// scalar BINOP vec<>
-// scalar BINOP SwizzleOp
-// vec<> BINOP SwizzleOp
-#ifdef __SYCL_BINOP
-#error "Undefine __SYCL_BINOP macro"
-#endif
-#define __SYCL_BINOP(BINOP)                                                    \
-  friend vec_t operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {        \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs BINOP Tmp;                                                      \
-  }                                                                            \
-  friend vec_t operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {        \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp BINOP Rhs;                                                      \
-  }                                                                            \
-  friend vec_t operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {        \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs BINOP Tmp;                                                      \
-  }                                                                            \
-  friend vec_t operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {        \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp BINOP Rhs;                                                      \
-  }
-
-  __SYCL_BINOP(+)
-  __SYCL_BINOP(-)
-  __SYCL_BINOP(*)
-  __SYCL_BINOP(/)
-  __SYCL_BINOP(%)
-  __SYCL_BINOP(&)
-  __SYCL_BINOP(|)
-  __SYCL_BINOP(^)
-  __SYCL_BINOP(>>)
-  __SYCL_BINOP(<<)
-#undef __SYCL_BINOP
-
-// scalar RELLOGOP vec<>
-// scalar RELLOGOP SwizzleOp
-// vec<> RELLOGOP SwizzleOp
-#ifdef __SYCL_RELLOGOP
-#error "Undefine __SYCL_RELLOGOP macro"
-#endif
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec_rel_t operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs RELLOGOP Tmp;                                                   \
-  }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp RELLOGOP Rhs;                                                   \
-  }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs RELLOGOP Tmp;                                                   \
-  }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp RELLOGOP Rhs;                                                   \
-  }
-
-  __SYCL_RELLOGOP(==)
-  __SYCL_RELLOGOP(!=)
-  __SYCL_RELLOGOP(>)
-  __SYCL_RELLOGOP(<)
-  __SYCL_RELLOGOP(>=)
-  __SYCL_RELLOGOP(<=)
-  // TODO: limit to integral types.
-  __SYCL_RELLOGOP(&&)
-  __SYCL_RELLOGOP(||)
-#undef __SYCL_RELLOGOP
-
-  template <int IdxNum = getNumElements(),
-            typename = EnableIfMultipleIndexes<IdxNum>>
-  SwizzleOp &operator=(const vec<DataT, IdxNum> &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
-    }
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
-  SwizzleOp &operator=(const DataT &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    m_Vector->setValue(Idxs[0], Rhs);
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(),
-            EnableIfMultipleIndexes<IdxNum, bool> = true>
-  SwizzleOp &operator=(const DataT &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    for (auto Idx : Idxs) {
-      m_Vector->setValue(Idx, Rhs);
-    }
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
-  SwizzleOp &operator=(DataT &&Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    m_Vector->setValue(Idxs[0], Rhs);
-    return *this;
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>
-  operator*(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::multiplies, Indexes...>
-  operator*(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::multiplies, Indexes...>(m_Vector, *this,
-                                                              Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::plus, Indexes...> operator+(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::plus, Indexes...>(m_Vector, *this,
-                                                          GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::plus, Indexes...>
-  operator+(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::plus, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::minus, Indexes...>
-  operator-(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::minus, Indexes...>(m_Vector, *this,
-                                                           GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::minus, Indexes...>
-  operator-(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::minus, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::divides, Indexes...>
-  operator/(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::divides, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::divides, Indexes...>
-  operator/(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::divides, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>
-  operator%(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::modulus, Indexes...>
-  operator%(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::modulus, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>
-  operator&(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::bit_and, Indexes...>
-  operator&(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::bit_and, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>
-  operator|(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::bit_or, Indexes...>
-  operator|(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::bit_or, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>
-  operator^(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::bit_xor, Indexes...>
-  operator^(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::bit_xor, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, RShift, Indexes...> operator>>(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, RShift, Indexes...>(m_Vector, *this,
-                                                       GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, RShift, Indexes...>
-  operator>>(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, RShift, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, LShift, Indexes...> operator<<(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, LShift, Indexes...>(m_Vector, *this,
-                                                       GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, LShift, Indexes...>
-  operator<<(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, LShift, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <
-      typename T1, typename T2, typename T3, template <typename> class T4,
-      int... T5,
-      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
-  SwizzleOp &operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
-    }
-    return *this;
-  }
-
-  template <
-      typename T1, typename T2, typename T3, template <typename> class T4,
-      int... T5,
-      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
-  SwizzleOp &operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
-    }
-    return *this;
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, EqualTo, Indexes...> operator==(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, EqualTo, Indexes...>(NULL, *this,
-                                                         GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, EqualTo, Indexes...>
-  operator==(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, EqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>
-  operator!=(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, NotEqualTo, Indexes...>
-  operator!=(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, NotEqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>
-  operator>=(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>
-  operator>=(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>
-  operator<=(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LessEqualTo, Indexes...>
-  operator<=(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LessEqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>
-  operator>(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, GreaterThan, Indexes...>
-  operator>(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, GreaterThan, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LessThan, Indexes...> operator<(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LessThan, Indexes...>(NULL, *this,
-                                                          GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LessThan, Indexes...>
-  operator<(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LessThan, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>
-  operator&&(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LogicalAnd, Indexes...>
-  operator&&(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LogicalAnd, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>
-  operator||(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>(NULL, *this,
-                                                           GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LogicalOr, Indexes...>
-  operator||(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LogicalOr, Indexes...>(NULL, *this, Rhs);
-  }
-
-  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
-private:
-  // Indexer used in the swizzles.def.
-  // Currently it is defined as a template struct. Replacing it with a constexpr
-  // function would activate a bug in MSVC that is fixed only in v19.20.
-  // Until then MSVC does not recognize such constexpr functions as const and
-  // thus does not let using them in template parameters inside swizzle.def.
-  template <int Index> struct Indexer {
-    static constexpr int IDXs[sizeof...(Indexes)] = {Indexes...};
-    static constexpr int value = IDXs[Index >= getNumElements() ? 0 : Index];
-  };
-
-public:
-#ifdef __SYCL_ACCESS_RETURN
-#error "Undefine __SYCL_ACCESS_RETURN macro"
-#endif
-#define __SYCL_ACCESS_RETURN m_Vector
-#include "swizzles.def"
-#undef __SYCL_ACCESS_RETURN
-  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
-
-  // Leave store() interface to automatic conversion to vec<>.
-  // Load to vec_t and then assign to swizzle.
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void load(size_t offset, multi_ptr<DataT, Space, DecorateAddress> ptr) {
-    vec_t Tmp;
-    Tmp.template load(offset, ptr);
-    *this = Tmp;
-  }
-
-  template <typename convertT, rounding_mode roundingMode>
-  vec<convertT, sizeof...(Indexes)> convert() const {
-    // First materialize the swizzle to vec_t and then apply convert() to it.
-    vec_t Tmp = *this;
-    return Tmp.template convert<convertT, roundingMode>();
-  }
-
-  template <typename asT> asT as() const {
-    // First materialize the swizzle to vec_t and then apply as() to it.
-    vec_t Tmp = *this;
-    static_assert((sizeof(Tmp) == sizeof(asT)),
-                  "The new SYCL vec type must have the same storage size in "
-                  "bytes as this SYCL swizzled vec");
-    static_assert(
-        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
-            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
-        "asT must be SYCL vec of a different element type and "
-        "number of elements specified by asT");
-    return Tmp.template as<asT>();
-  }
-
-private:
-  SwizzleOp(const SwizzleOp &Rhs)
-      : m_Vector(Rhs.m_Vector), m_LeftOperation(Rhs.m_LeftOperation),
-        m_RightOperation(Rhs.m_RightOperation) {}
-
-  SwizzleOp(VecT *Vector, OperationLeftT LeftOperation,
-            OperationRightT RightOperation)
-      : m_Vector(Vector), m_LeftOperation(LeftOperation),
-        m_RightOperation(RightOperation) {}
-
-  SwizzleOp(VecT *Vector) : m_Vector(Vector) {}
-
-  SwizzleOp(SwizzleOp &&Rhs)
-      : m_Vector(Rhs.m_Vector), m_LeftOperation(std::move(Rhs.m_LeftOperation)),
-        m_RightOperation(std::move(Rhs.m_RightOperation)) {}
-
-  // Either performing CurrentOperation on results of left and right operands
-  // or reading values from actual vector. Perform implicit type conversion when
-  // the number of elements == 1
-
-  template <int IdxNum = getNumElements()>
-  CommonDataT getValue(EnableIfOneIndex<IdxNum, size_t> Index) const {
-    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
-      std::array<int, getNumElements()> Idxs{Indexes...};
-      return m_Vector->getValue(Idxs[Index]);
-    }
-    auto Op = OperationCurrentT<vec_data_t<CommonDataT>>();
-    return vec_data<CommonDataT>::get(
-        Op(vec_data<CommonDataT>::get(m_LeftOperation.getValue(Index)),
-           vec_data<CommonDataT>::get(m_RightOperation.getValue(Index))));
-  }
-
-  template <int IdxNum = getNumElements()>
-  DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
-    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
-      std::array<int, getNumElements()> Idxs{Indexes...};
-      return m_Vector->getValue(Idxs[Index]);
-    }
-    auto Op = OperationCurrentT<vec_data_t<DataT>>();
-    return vec_data<DataT>::get(
-        Op(vec_data<DataT>::get(m_LeftOperation.getValue(Index)),
-           vec_data<DataT>::get(m_RightOperation.getValue(Index))));
-  }
-
-  template <template <typename> class Operation, typename RhsOperation>
-  void operatorHelper(const RhsOperation &Rhs) {
-    Operation<vec_data_t<DataT>> Op;
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      DataT Res = vec_data<DataT>::get(
-          Op(vec_data<DataT>::get(m_Vector->getValue(Idxs[I])),
-             vec_data<DataT>::get(Rhs.getValue(I))));
-      m_Vector->setValue(Idxs[I], Res);
-    }
-  }
-
-  // fields
-  VecT *m_Vector;
-
-  OperationLeftT m_LeftOperation;
-  OperationRightT m_RightOperation;
-
-  // friends
-  template <typename T1, int T2> friend class sycl::vec;
-
-  template <typename T1, typename T2, typename T3, template <typename> class T4,
-            int... T5>
-  friend class SwizzleOp;
-};
-} // namespace detail
-
-namespace detail {
-
-// Vectors of size 1 are handled separately and therefore 1 is not included in
-// the check below.
-constexpr bool isValidVectorSize(int N) {
-  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
-}
-template <typename T, int N, typename V> struct VecStorage {
-  static_assert(
-      isValidVectorSize(N) || N == 1,
-      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
-      "or 16 are supported");
-  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
-};
-
-#ifdef __SYCL_DEVICE_ONLY__
-// device always has ext vector support, but for huge vectors
-// we switch to std::array, so that we can use a smaller alignment (64)
-// this is to support MSVC, which has a max of 64 for direct params.
-template <typename T, int N> struct VecStorageImpl {
-  static constexpr size_t Num = (N == 3) ? 4 : N;
-  static constexpr size_t Sz = Num * sizeof(T);
-  using DataType =
-      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
-                                std::array<T, Num>>::type;
-  using VectorDataType = T __attribute__((ext_vector_type(N)));
-};
-#else // __SYCL_DEVICE_ONLY__
-template <typename T, int N> struct VecStorageImpl {
-  using DataType = std::array<T, (N == 3) ? 4 : N>;
-};
-#endif // __SYCL_DEVICE_ONLY__
-
-// Single element bool
-template <> struct VecStorage<bool, 1, void> {
-  using DataType = bool;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = bool;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple element bool
-template <int N>
-struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
-  using DataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-// Single element byte. Multiple elements will propagate through a later
-// specialization.
-template <> struct VecStorage<std::byte, 1, void> {
-  using DataType = std::int8_t;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = std::int8_t;
-#endif // __SYCL_DEVICE_ONLY__
-};
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-
-// Single element signed integers
-template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element unsigned integers
-template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element floating-point (except half/bfloat16)
-template <typename T>
-struct VecStorage<
-    T, 1,
-    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-// Multiple elements signed/unsigned integers and floating-point (except
-// half/bfloat16)
-template <typename T, int N>
-struct VecStorage<
-    T, N,
-    typename std::enable_if_t<isValidVectorSize(N) &&
-                              (is_sgeninteger_v<T> ||
-                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
-  using DataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element half
-template <> struct VecStorage<half, 1, void> {
-  using DataType = sycl::detail::half_impl::StorageT;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = sycl::detail::half_impl::StorageT;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple elements half
-#if defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
-    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
-  };
-#else // defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
-  };
-#endif // defined(__SYCL_DEVICE_ONLY__)
-
-__SYCL_DEFINE_HALF_VECSTORAGE(2)
-__SYCL_DEFINE_HALF_VECSTORAGE(3)
-__SYCL_DEFINE_HALF_VECSTORAGE(4)
-__SYCL_DEFINE_HALF_VECSTORAGE(8)
-__SYCL_DEFINE_HALF_VECSTORAGE(16)
-#undef __SYCL_DEFINE_HALF_VECSTORAGE
-
-// Single element bfloat16
-template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
-  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-  // using VectorDataType = sycl::ext::oneapi::bfloat16;
-  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-};
-// Multiple elements bfloat16
-#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
-    using VectorDataType =                                                     \
-        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
-  };
-__SYCL_DEFINE_BF16_VECSTORAGE(2)
-__SYCL_DEFINE_BF16_VECSTORAGE(3)
-__SYCL_DEFINE_BF16_VECSTORAGE(4)
-__SYCL_DEFINE_BF16_VECSTORAGE(8)
-__SYCL_DEFINE_BF16_VECSTORAGE(16)
-#undef __SYCL_DEFINE_BF16_VECSTORAGE
-} // namespace detail
-
-/// This macro must be defined to 1 when SYCL implementation allows user
-/// applications to explicitly declare certain class types as device copyable
-/// by adding specializations of is_device_copyable type trait class.
-#define SYCL_DEVICE_COPYABLE 1
-
-/// is_device_copyable is a user specializable class template to indicate
-/// that a type T is device copyable, which means that SYCL implementation
-/// may copy objects of the type T between host and device or between two
-/// devices.
-/// Specializing is_device_copyable such a way that
-/// is_device_copyable_v<T> == true on a T that does not satisfy all
-/// the requirements of a device copyable type is undefined behavior.
-template <typename T> struct is_device_copyable;
-
-namespace detail {
-template <typename T, typename = void>
-struct is_device_copyable_impl : std::is_trivially_copyable<T> {};
-
-template <typename T>
-struct is_device_copyable_impl<
-    T, std::enable_if_t<!std::is_same_v<T, std::remove_cv_t<T>>>>
-    // Cannot express this "recursion" (to take user's partial non-cv
-    // specializations into account) without this helper struct.
-    : is_device_copyable<std::remove_cv_t<T>> {};
-} // namespace detail
-
-template <typename T>
-struct is_device_copyable : detail::is_device_copyable_impl<T> {};
-
-// std::array<T, 0> is implicitly device copyable type.
-template <typename T>
-struct is_device_copyable<std::array<T, 0>> : std::true_type {};
-
-// std::array<T, N> is implicitly device copyable type if T is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<std::array<T, N>> : is_device_copyable<T> {};
-
-// std::optional<T> is implicitly device copyable type if T is device copyable.
-template <typename T>
-struct is_device_copyable<std::optional<T>> : is_device_copyable<T> {};
-
-// std::pair<T1, T2> is implicitly device copyable type if T1 and T2 are device
-// copyable.
-template <typename T1, typename T2>
-struct is_device_copyable<std::pair<T1, T2>>
-    : std::bool_constant<is_device_copyable<T1>::value &&
-                         is_device_copyable<T2>::value> {};
-
-// std::tuple<Ts...> is implicitly device copyable type if each type T of Ts...
-// is device copyable.
-template <typename... Ts>
-struct is_device_copyable<std::tuple<Ts...>>
-    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
-
-// std::variant<Ts...> is implicitly device copyable type if each type T of
-// Ts... is device copyable.
-template <typename... Ts>
-struct is_device_copyable<std::variant<Ts...>>
-    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
-
-// marray is device copyable if element type is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<sycl::marray<T, N>> : is_device_copyable<T> {};
-
-// array is device copyable if element type is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<T[N]> : is_device_copyable<T> {};
-
-template <typename T>
-inline constexpr bool is_device_copyable_v = is_device_copyable<T>::value;
-
-namespace detail {
 template <typename T, typename = void>
 struct IsDeprecatedDeviceCopyable : std::false_type {};
 
@@ -2349,8 +106,5 @@ struct CheckDeviceCopyable<
 
 #endif // __SYCL_DEVICE_ONLY__
 } // namespace detail
-
 } // namespace _V1
-} // namespace sycl
-
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
\ No newline at end of file
+} // namespace sycl
\ No newline at end of file
diff --git a/sycl/include/sycl/types_preview.hpp b/sycl/include/sycl/types_preview.hpp
deleted file mode 100644
index 28d3a6de193b6..0000000000000
--- a/sycl/include/sycl/types_preview.hpp
+++ /dev/null
@@ -1,2242 +0,0 @@
-//==---------------- types.hpp --- SYCL types ------------------------------==//
-//
-// 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
-
-// Check if Clang's ext_vector_type attribute is available. Host compiler
-// may not be Clang, and Clang may not be built with the extension.
-#ifdef __clang__
-#ifndef __has_extension
-#define __has_extension(x) 0
-#endif
-#ifdef __HAS_EXT_VECTOR_TYPE__
-#error "Undefine __HAS_EXT_VECTOR_TYPE__ macro"
-#endif
-#if __has_extension(attribute_ext_vector_type)
-#define __HAS_EXT_VECTOR_TYPE__
-#endif
-#endif // __clang__
-
-#if !defined(__HAS_EXT_VECTOR_TYPE__) && defined(__SYCL_DEVICE_ONLY__)
-#error "SYCL device compiler is built without ext_vector_type support"
-#endif
-
-#include <sycl/access/access.hpp>              // for decorated, address_space
-#include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
-#include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
-#include <sycl/detail/defines_elementary.hpp>  // for __SYCL2020_DEPRECATED
-#include <sycl/detail/generic_type_lists.hpp>  // for vector_basic_list
-#include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
-#include <sycl/detail/memcpy.hpp>              // for memcpy
-#include <sycl/detail/type_list.hpp>           // for is_contained
-#include <sycl/detail/type_traits.hpp>         // for is_floating_point
-#include <sycl/detail/vector_convert.hpp>      // for convertImpl
-#include <sycl/detail/vector_traits.hpp>       // for vector_alignment
-#include <sycl/exception.hpp>                  // for make_error_code, errc
-#include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
-#include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
-#include <sycl/multi_ptr.hpp>                  // for multi_ptr
-
-#include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
-
-#include <array>       // for array
-#include <assert.h>    // for assert
-#include <cstddef>     // for size_t, NULL, byte
-#include <cstdint>     // for uint8_t, int16_t, int...
-#include <functional>  // for divides, multiplies
-#include <iterator>    // for pair
-#include <optional>    // for optional
-#include <ostream>     // for operator<<, basic_ost...
-#include <tuple>       // for tuple
-#include <type_traits> // for enable_if_t, is_same
-#include <utility>     // for index_sequence, make_...
-#include <variant>     // for tuple, variant
-
-// 4.10.1: Scalar data types
-// 4.10.2: SYCL vector types
-
-namespace sycl {
-inline namespace _V1 {
-
-struct elem {
-  static constexpr int x = 0;
-  static constexpr int y = 1;
-  static constexpr int z = 2;
-  static constexpr int w = 3;
-  static constexpr int r = 0;
-  static constexpr int g = 1;
-  static constexpr int b = 2;
-  static constexpr int a = 3;
-  static constexpr int s0 = 0;
-  static constexpr int s1 = 1;
-  static constexpr int s2 = 2;
-  static constexpr int s3 = 3;
-  static constexpr int s4 = 4;
-  static constexpr int s5 = 5;
-  static constexpr int s6 = 6;
-  static constexpr int s7 = 7;
-  static constexpr int s8 = 8;
-  static constexpr int s9 = 9;
-  static constexpr int sA = 10;
-  static constexpr int sB = 11;
-  static constexpr int sC = 12;
-  static constexpr int sD = 13;
-  static constexpr int sE = 14;
-  static constexpr int sF = 15;
-};
-
-namespace detail {
-// select_apply_cl_t selects from T8/T16/T32/T64 basing on
-// sizeof(_IN).  expected to handle scalar types in _IN.
-template <typename _IN, typename T8, typename T16, typename T32, typename T64>
-using select_apply_cl_t = std::conditional_t<
-    sizeof(_IN) == 1, T8,
-    std::conditional_t<sizeof(_IN) == 2, T16,
-                       std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
-
-// Helper function to bit_cast one type to another.
-template <typename FromType, typename ToType>
-static constexpr ToType BitCast(const FromType &Value) {
-
-  static_assert(sizeof(FromType) == sizeof(ToType),
-                "BitCast: sizes of types are different");
-
-#ifdef __SYCL_BITCAST_IS_CONSTEXPR
-  return sycl::bit_cast<ToType>(Value);
-#else
-  // Awkward workaround. sycl::bit_cast isn't constexpr in older GCC
-  // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
-  // but neither available yet.
-  union {
-    const FromType from;
-    ToType to;
-  } result = {};
-  result.from = Value;
-  return result.to;
-#endif
-}
-
-/* Helper functions to get and set values in vec, depdending on the underlying
- * data type. */
-template <typename T> struct vec_helper {
-  using RetType = T;
-  static constexpr RetType get(T value) { return value; }
-  static constexpr RetType set(T value) { return value; }
-};
-template <> struct vec_helper<bool> {
-  using RetType = select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                    std::int32_t, std::int64_t>;
-  static constexpr RetType get(bool value) { return value; }
-  static constexpr RetType set(bool value) { return value; }
-};
-
-template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
-  using RetType = sycl::ext::oneapi::bfloat16;
-  using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
-
-  static constexpr RetType get(BFloat16StorageT value) {
-    return BitCast<BFloat16StorageT, RetType>(value);
-  }
-  static constexpr RetType get(RetType value) { return value; }
-
-  static constexpr BFloat16StorageT set(RetType value) {
-    return BitCast<RetType, BFloat16StorageT>(value);
-  }
-};
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-template <> struct vec_helper<std::byte> {
-  using RetType = std::uint8_t;
-  static constexpr RetType get(std::byte value) { return (RetType)value; }
-  static constexpr RetType set(std::byte value) { return (RetType)value; }
-  static constexpr std::byte get(std::uint8_t value) {
-    return (std::byte)value;
-  }
-  static constexpr std::byte set(std::uint8_t value) {
-    return (std::byte)value;
-  }
-};
-#endif
-
-template <typename VecT, typename OperationLeftT, typename OperationRightT,
-          template <typename> class OperationCurrentT, int... Indexes>
-class SwizzleOp;
-
-template <typename T, int N, typename V = void> struct VecStorage;
-
-// Element type for relational operator return value.
-template <typename DataT>
-using rel_t = typename std::conditional_t<
-    sizeof(DataT) == sizeof(opencl::cl_char), opencl::cl_char,
-    typename std::conditional_t<
-        sizeof(DataT) == sizeof(opencl::cl_short), opencl::cl_short,
-        typename std::conditional_t<
-            sizeof(DataT) == sizeof(opencl::cl_int), opencl::cl_int,
-            typename std::conditional_t<sizeof(DataT) ==
-                                            sizeof(opencl::cl_long),
-                                        opencl::cl_long, bool>>>>;
-
-// Special type indicating that SwizzleOp should just read value from vector -
-// not trying to perform any operations. Should not be called.
-template <typename T> class GetOp {
-public:
-  using DataT = T;
-  DataT getValue(size_t) const { return (DataT)0; }
-  DataT operator()(DataT, DataT) { return (DataT)0; }
-};
-
-// Special type for working SwizzleOp with scalars, stores a scalar and gives
-// the scalar at any index. Provides interface is compatible with SwizzleOp
-// operations
-template <typename T> class GetScalarOp {
-public:
-  using DataT = T;
-  GetScalarOp(DataT Data) : m_Data(Data) {}
-  DataT getValue(size_t) const { return m_Data; }
-
-private:
-  DataT m_Data;
-};
-
-template <typename T> struct EqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs == Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct NotEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs != Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct GreaterEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs >= Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LessEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs <= Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct GreaterThan {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs > Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LessThan {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs < Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LogicalAnd {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs && Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct LogicalOr {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs || Rhs) ? -1 : 0;
-  }
-};
-
-template <typename T> struct RShift {
-  constexpr T operator()(const T &Lhs, const T &Rhs) const {
-    return Lhs >> Rhs;
-  }
-};
-
-template <typename T> struct LShift {
-  constexpr T operator()(const T &Lhs, const T &Rhs) const {
-    return Lhs << Rhs;
-  }
-};
-
-// Forward declarations
-template <typename TransformedArgType, int Dims, typename KernelType>
-class RoundedRangeKernel;
-template <typename TransformedArgType, int Dims, typename KernelType>
-class RoundedRangeKernelWithKH;
-
-} // namespace detail
-
-template <typename T> using vec_data = detail::vec_helper<T>;
-
-template <typename T>
-using vec_data_t = typename detail::vec_helper<T>::RetType;
-
-/// Provides a cross-patform vector class template that works efficiently on
-/// SYCL devices as well as in host C++ code.
-///
-/// \ingroup sycl_api
-template <typename Type, int NumElements> class vec {
-  using DataT = Type;
-
-  // This represent type of underlying value. There should be only one field
-  // in the class, so vec<float, 16> should be equal to float16 in memory.
-  using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
-
-  static constexpr bool IsBfloat16 =
-      std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
-
-  static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
-  static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
-  static constexpr bool IsSizeGreaterThanMaxAlign =
-      (Sz > detail::MaxVecAlignment);
-
-#ifdef __SYCL_DEVICE_ONLY__
-  static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
-#else
-  static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
-#endif
-
-  static constexpr int getNumElements() { return NumElements; }
-
-  // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
-  template <int Counter, int MaxValue, class...>
-  struct SizeChecker : std::conditional_t<Counter == MaxValue, std::true_type,
-                                          std::false_type> {};
-
-  template <int Counter, int MaxValue, typename DataT_, class... tail>
-  struct SizeChecker<Counter, MaxValue, DataT_, tail...>
-      : std::conditional_t<Counter + 1 <= MaxValue,
-                           SizeChecker<Counter + 1, MaxValue, tail...>,
-                           std::false_type> {};
-
-  // Utility trait for creating an std::array from an vector argument.
-  template <typename DataT_, typename T, std::size_t... Is>
-  static constexpr std::array<DataT_, sizeof...(Is)>
-  VecToArray(const vec<T, sizeof...(Is)> &V, std::index_sequence<Is...>) {
-    return {static_cast<DataT_>(V.getValue(Is))...};
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5, std::size_t... Is>
-  static constexpr std::array<DataT_, sizeof...(Is)>
-  VecToArray(const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &V,
-             std::index_sequence<Is...>) {
-    return {static_cast<DataT_>(V.getValue(Is))...};
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5, std::size_t... Is>
-  static constexpr std::array<DataT_, sizeof...(Is)>
-  VecToArray(const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &V,
-             std::index_sequence<Is...>) {
-    return {static_cast<DataT_>(V.getValue(Is))...};
-  }
-  template <typename DataT_, typename T, int N>
-  static constexpr std::array<DataT_, N>
-  FlattenVecArgHelper(const vec<T, N> &A) {
-    return VecToArray<DataT_>(A, std::make_index_sequence<N>());
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5>
-  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
-      const detail::SwizzleOp<vec<T, N>, T2, T3, T4, T5...> &A) {
-    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
-  }
-  template <typename DataT_, typename T, int N, typename T2, typename T3,
-            template <typename> class T4, int... T5>
-  static constexpr std::array<DataT_, sizeof...(T5)> FlattenVecArgHelper(
-      const detail::SwizzleOp<const vec<T, N>, T2, T3, T4, T5...> &A) {
-    return VecToArray<DataT_>(A, std::make_index_sequence<sizeof...(T5)>());
-  }
-  template <typename DataT_, typename T>
-  static constexpr auto FlattenVecArgHelper(const T &A) {
-    return std::array<DataT_, 1>{vec_data<DataT_>::get(static_cast<DataT_>(A))};
-  }
-  template <typename DataT_, typename T> struct FlattenVecArg {
-    constexpr auto operator()(const T &A) const {
-      return FlattenVecArgHelper<DataT_>(A);
-    }
-  };
-
-  // Alias for shortening the vec arguments to array converter.
-  template <typename DataT_, typename... ArgTN>
-  using VecArgArrayCreator =
-      detail::ArrayCreator<DataT_, FlattenVecArg, ArgTN...>;
-
-#define __SYCL_ALLOW_VECTOR_SIZES(num_elements)                                \
-  template <int Counter, int MaxValue, typename DataT_, class... tail>         \
-  struct SizeChecker<Counter, MaxValue, vec<DataT_, num_elements>, tail...>    \
-      : std::conditional_t<                                                    \
-            Counter + (num_elements) <= MaxValue,                              \
-            SizeChecker<Counter + (num_elements), MaxValue, tail...>,          \
-            std::false_type> {};                                               \
-  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
-            typename T3, template <typename> class T4, int... T5,              \
-            class... tail>                                                     \
-  struct SizeChecker<                                                          \
-      Counter, MaxValue,                                                       \
-      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>,         \
-      tail...>                                                                 \
-      : std::conditional_t<                                                    \
-            Counter + sizeof...(T5) <= MaxValue,                               \
-            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
-            std::false_type> {};                                               \
-  template <int Counter, int MaxValue, typename DataT_, typename T2,           \
-            typename T3, template <typename> class T4, int... T5,              \
-            class... tail>                                                     \
-  struct SizeChecker<                                                          \
-      Counter, MaxValue,                                                       \
-      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
-      tail...>                                                                 \
-      : std::conditional_t<                                                    \
-            Counter + sizeof...(T5) <= MaxValue,                               \
-            SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
-            std::false_type> {};
-
-  __SYCL_ALLOW_VECTOR_SIZES(1)
-  __SYCL_ALLOW_VECTOR_SIZES(2)
-  __SYCL_ALLOW_VECTOR_SIZES(3)
-  __SYCL_ALLOW_VECTOR_SIZES(4)
-  __SYCL_ALLOW_VECTOR_SIZES(8)
-  __SYCL_ALLOW_VECTOR_SIZES(16)
-#undef __SYCL_ALLOW_VECTOR_SIZES
-
-  // TypeChecker is needed for vec(const argTN &... args) ctor to validate args.
-  template <typename T, typename DataT_>
-  struct TypeChecker : std::is_convertible<T, DataT_> {};
-#define __SYCL_ALLOW_VECTOR_TYPES(num_elements)                                \
-  template <typename DataT_>                                                   \
-  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {};   \
-  template <typename DataT_, typename T2, typename T3,                         \
-            template <typename> class T4, int... T5>                           \
-  struct TypeChecker<                                                          \
-      detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
-      : std::true_type {};                                                     \
-  template <typename DataT_, typename T2, typename T3,                         \
-            template <typename> class T4, int... T5>                           \
-  struct TypeChecker<                                                          \
-      detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
-      DataT_> : std::true_type {};
-
-  __SYCL_ALLOW_VECTOR_TYPES(1)
-  __SYCL_ALLOW_VECTOR_TYPES(2)
-  __SYCL_ALLOW_VECTOR_TYPES(3)
-  __SYCL_ALLOW_VECTOR_TYPES(4)
-  __SYCL_ALLOW_VECTOR_TYPES(8)
-  __SYCL_ALLOW_VECTOR_TYPES(16)
-#undef __SYCL_ALLOW_VECTOR_TYPES
-
-  template <int... Indexes>
-  using Swizzle =
-      detail::SwizzleOp<vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
-                        detail::GetOp, Indexes...>;
-
-  template <int... Indexes>
-  using ConstSwizzle =
-      detail::SwizzleOp<const vec, detail::GetOp<DataT>, detail::GetOp<DataT>,
-                        detail::GetOp, Indexes...>;
-
-  // Shortcuts for args validation in vec(const argTN &... args) ctor.
-  template <typename... argTN>
-  using EnableIfSuitableTypes = typename std::enable_if_t<
-      std::conjunction_v<TypeChecker<argTN, DataT>...>>;
-
-  template <typename... argTN>
-  using EnableIfSuitableNumElements =
-      typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
-
-  template <size_t... Is>
-  constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
-                std::index_sequence<Is...>)
-      : m_Data{([&](vec_data_t<DataT> v) constexpr {
-          if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
-            return v.value;
-          else
-            return vec_data_t<DataT>(static_cast<DataT>(v));
-        })(Arr[Is])...} {}
-
-public:
-  using element_type = DataT;
-  using value_type = DataT;
-  using rel_t = detail::rel_t<DataT>;
-#ifdef __SYCL_DEVICE_ONLY__
-  // Type used for passing sycl::vec to SPIRV builtins.
-  using vector_t =
-      typename detail::VecStorage<DataT, NumElements>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-
-  vec() = default;
-
-  constexpr vec(const vec &Rhs) = default;
-  constexpr vec(vec &&Rhs) = default;
-
-  constexpr vec &operator=(const vec &Rhs) = default;
-
-  // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
-  template <typename Ty = DataT>
-  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
-                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
-                            vec &>
-  operator=(const vec<rel_t, NumElements> &Rhs) {
-    *this = Rhs.template as<vec>();
-    return *this;
-  }
-
-#ifdef __SYCL_DEVICE_ONLY__
-  explicit constexpr vec(const DataT &arg)
-      : vec{detail::RepeatValue<NumElements>(
-                static_cast<vec_data_t<DataT>>(arg)),
-            std::make_index_sequence<NumElements>()} {}
-
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-
-  operator=(const Ty &Rhs) {
-    for (int i = 0; i < NumElements; ++i) {
-      setValue(i, Rhs);
-    }
-    return *this;
-  }
-#else  // __SYCL_DEVICE_ONLY__
-  explicit constexpr vec(const DataT &arg)
-      : vec{detail::RepeatValue<NumElements>(
-                static_cast<vec_data_t<DataT>>(arg)),
-            std::make_index_sequence<NumElements>()} {}
-
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const DataT &Rhs) {
-    for (int i = 0; i < NumElements; ++i) {
-      setValue(i, Rhs);
-    }
-    return *this;
-  }
-#endif // __SYCL_DEVICE_ONLY__
-
-  // Constructor from values of base type or vec of base type. Checks that
-  // base types are match and that the NumElements == sum of lengths of args.
-  template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
-            typename = EnableIfSuitableNumElements<argTN...>>
-  constexpr vec(const argTN &...args)
-      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
-            std::make_index_sequence<NumElements>()} {}
-
-#ifdef __SYCL_DEVICE_ONLY__
-  template <typename vector_t_ = vector_t,
-            typename =
-                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
-                                          !std::is_same_v<vector_t_, DataT>>>
-  constexpr vec(vector_t_ openclVector) {
-    m_Data = detail::BitCast<vector_t, DataType>(openclVector);
-  }
-
-  /* @SYCL2020
-   * Available only when: compiled for the device.
-   * Converts this SYCL vec instance to the underlying backend-native vector
-   * type defined by vector_t.
-   */
-  operator vector_t() const {
-    if constexpr (NumElements == 1) {
-      return m_Data;
-    } else {
-      return sycl::bit_cast<vector_t>(m_Data);
-    }
-  }
-#endif // __SYCL_DEVICE_ONLY__
-
-  // Available only when: NumElements == 1
-  template <int N = NumElements>
-  operator typename std::enable_if_t<N == 1, DataT>() const {
-    return vec_data<DataT>::get(m_Data);
-  }
-
-  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
-  static constexpr size_t get_count() { return size(); }
-  static constexpr size_t size() noexcept { return NumElements; }
-  __SYCL2020_DEPRECATED(
-      "get_size() is deprecated, please use byte_size() instead")
-  static constexpr size_t get_size() { return byte_size(); }
-  static constexpr size_t byte_size() noexcept { return sizeof(m_Data); }
-
-  // convertImpl can't be called with the same From and To types and therefore
-  // we need this version of convert which is mostly no-op.
-  template <typename convertT,
-            rounding_mode roundingMode = rounding_mode::automatic>
-  std::enable_if_t<
-      std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> ||
-          std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
-                         detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
-      vec<convertT, NumElements>>
-  convert() const {
-    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
-                      detail::is_floating_point<convertT>::value,
-                  "Unsupported convertT");
-    if constexpr (!std::is_same_v<DataT, convertT>) {
-      // Dummy conversion for cases like vec<signed char> -> vec<char>
-      vec<convertT, NumElements> Result;
-      for (size_t I = 0; I < NumElements; ++I)
-        Result.setValue(I, static_cast<convertT>(getValue(I)));
-
-      return Result;
-    } else {
-      // No conversion necessary
-      return *this;
-    }
-  }
-
-  template <typename convertT,
-            rounding_mode roundingMode = rounding_mode::automatic>
-  std::enable_if_t<
-      !std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> &&
-          !std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
-                          detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
-      vec<convertT, NumElements>>
-  convert() const {
-    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
-                      detail::is_floating_point<convertT>::value,
-                  "Unsupported convertT");
-    using T = vec_data_t<DataT>;
-    using R = vec_data_t<convertT>;
-    using OpenCLT = detail::ConvertToOpenCLType_t<T>;
-    using OpenCLR = detail::ConvertToOpenCLType_t<R>;
-    vec<convertT, NumElements> Result;
-
-#ifdef __SYCL_DEVICE_ONLY__
-    using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
-    using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
-
-    auto NativeVector = sycl::bit_cast<vector_t>(m_Data);
-    using ConvertTVecType = typename vec<convertT, NumElements>::vector_t;
-
-    // Whole vector conversion can only be done, if:
-    constexpr bool canUseNativeVectorConvert =
-#ifdef __NVPTX__
-        // - we are not on CUDA, see intel/llvm#11840
-        false &&
-#endif
-        NumElements > 1 &&
-        // - vec storage has an equivalent OpenCL native vector it is implicitly
-        //   convertible to. There are some corner cases where it is not the
-        //   case with char, long and long long types.
-        std::is_convertible_v<vector_t, OpenCLVecT> &&
-        std::is_convertible_v<ConvertTVecType, OpenCLVecR> &&
-        // - it is not a signed to unsigned (or vice versa) conversion
-        //   see comments within 'convertImpl' for more details;
-        !detail::is_sint_to_from_uint<T, R>::value &&
-        // - destination type is not bool. bool is stored as integer under the
-        //   hood and therefore conversion to bool looks like conversion between
-        //   two integer types. Since bit pattern for true and false is not
-        //   defined, there is no guarantee that integer conversion yields
-        //   right results here;
-        !std::is_same_v<convertT, bool>;
-    if constexpr (canUseNativeVectorConvert) {
-      Result.m_Data = sycl::bit_cast<decltype(Result.m_Data)>(
-          detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
-                              OpenCLVecR>(NativeVector));
-    } else
-#endif // __SYCL_DEVICE_ONLY__
-    {
-      // Otherwise, we fallback to per-element conversion:
-      for (size_t I = 0; I < NumElements; ++I) {
-        Result.setValue(
-            I, vec_data<convertT>::get(
-                   detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
-                       vec_data<DataT>::get(getValue(I)))));
-      }
-    }
-
-    return Result;
-  }
-
-  template <typename asT> asT as() const {
-    static_assert((sizeof(*this) == sizeof(asT)),
-                  "The new SYCL vec type must have the same storage size in "
-                  "bytes as this SYCL vec");
-    static_assert(
-        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
-            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
-        "asT must be SYCL vec of a different element type and "
-        "number of elements specified by asT");
-    asT Result;
-    detail::memcpy(&Result.m_Data, &m_Data, sizeof(decltype(Result.m_Data)));
-    return Result;
-  }
-
-  template <int... SwizzleIndexes> Swizzle<SwizzleIndexes...> swizzle() {
-    return this;
-  }
-
-  template <int... SwizzleIndexes>
-  ConstSwizzle<SwizzleIndexes...> swizzle() const {
-    return this;
-  }
-
-  // ext_vector_type is used as an underlying type for sycl::vec on device.
-  // The problem is that for clang vector types the return of operator[] is a
-  // temporary and not a reference to the element in the vector. In practice
-  // reinterpret_cast<DataT *>(&m_Data)[i]; is working. According to
-  // http://llvm.org/docs/GetElementPtr.html#can-gep-index-into-vector-elements
-  // this is not disallowed now. But could probably be disallowed in the future.
-  // That is why tests are added to check that behavior of the compiler has
-  // not changed.
-  //
-  // Implement operator [] in the same way for host and device.
-  // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
-  // aggressively optimized. Specializing with noinline to avoid as workaround.
-
-  template <typename T = DataT>
-  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                            const DataT &>
-  operator[](int i) const {
-    return reinterpret_cast<const DataT *>(&m_Data)[i];
-  }
-
-  template <typename T = DataT>
-  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                            DataT &>
-  operator[](int i) {
-    return reinterpret_cast<DataT *>(&m_Data)[i];
-  }
-
-#ifdef _MSC_VER
-#define __SYCL_NOINLINE_BF16 __declspec(noinline)
-#else
-#define __SYCL_NOINLINE_BF16 __attribute__((noinline))
-#endif
-
-  template <typename T = DataT>
-  __SYCL_NOINLINE_BF16
-      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                                const DataT &>
-      operator[](int i) const {
-    return reinterpret_cast<const DataT *>(&m_Data)[i];
-  }
-
-  template <typename T = DataT>
-  __SYCL_NOINLINE_BF16
-      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                                DataT &>
-      operator[](int i) {
-    return reinterpret_cast<DataT *>(&m_Data)[i];
-  }
-
-#undef __SYCL_NOINLINE_BF16
-
-  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
-private:
-  // Indexer used in the swizzles.def
-  // Currently it is defined as a template struct. Replacing it with a constexpr
-  // function would activate a bug in MSVC that is fixed only in v19.20.
-  // Until then MSVC does not recognize such constexpr functions as const and
-  // thus does not let using them in template parameters inside swizzle.def.
-  template <int Index> struct Indexer {
-    static constexpr int value = Index;
-  };
-
-public:
-#ifdef __SYCL_ACCESS_RETURN
-#error "Undefine __SYCL_ACCESS_RETURN macro"
-#endif
-#define __SYCL_ACCESS_RETURN this
-#include "swizzles.def"
-#undef __SYCL_ACCESS_RETURN
-  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
-
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void load(size_t Offset, multi_ptr<const DataT, Space, DecorateAddress> Ptr) {
-    for (int I = 0; I < NumElements; I++) {
-      setValue(I, *multi_ptr<const DataT, Space, DecorateAddress>(
-                      Ptr + Offset * NumElements + I));
-    }
-  }
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void load(size_t Offset, multi_ptr<DataT, Space, DecorateAddress> Ptr) {
-    multi_ptr<const DataT, Space, DecorateAddress> ConstPtr(Ptr);
-    load(Offset, ConstPtr);
-  }
-  template <int Dimensions, access::mode Mode,
-            access::placeholder IsPlaceholder, access::target Target,
-            typename PropertyListT>
-  void
-  load(size_t Offset,
-       accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
-           Acc) {
-    multi_ptr<const DataT, detail::TargetToAS<Target>::AS,
-              access::decorated::yes>
-        MultiPtr(Acc);
-    load(Offset, MultiPtr);
-  }
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void store(size_t Offset,
-             multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
-    for (int I = 0; I < NumElements; I++) {
-      *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
-                                                I) = getValue(I);
-    }
-  }
-  template <int Dimensions, access::mode Mode,
-            access::placeholder IsPlaceholder, access::target Target,
-            typename PropertyListT>
-  void
-  store(size_t Offset,
-        accessor<DataT, Dimensions, Mode, Target, IsPlaceholder, PropertyListT>
-            Acc) {
-    multi_ptr<DataT, detail::TargetToAS<Target>::AS, access::decorated::yes>
-        MultiPtr(Acc);
-    store(Offset, MultiPtr);
-  }
-
-  void ConvertToDataT() {
-    for (size_t i = 0; i < NumElements; ++i) {
-      DataT tmp = getValue(i);
-      setValue(i, tmp);
-    }
-  }
-
-#ifdef __SYCL_BINOP
-#error "Undefine __SYCL_BINOP macro"
-#endif
-
-#ifdef __SYCL_DEVICE_ONLY__
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
-  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
-    vec Ret;                                                                   \
-    if constexpr (IsBfloat16 ||                                                \
-                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
-      for (size_t I = 0; I < NumElements; ++I) {                               \
-        Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
-      }                                                                        \
-    } else {                                                                   \
-      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
-      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
-      Ret = vec<DataT, NumElements>(                                           \
-          (typename vec<DataT, NumElements>::vector_t)(                        \
-              ExtVecLhs BINOP ExtVecRhs));                                     \
-      if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
-        Ret.ConvertToDataT();                                                  \
-      }                                                                        \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
-    return Lhs BINOP vec(Rhs);                                                 \
-  }                                                                            \
-  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
-    return vec(Lhs) BINOP Rhs;                                                 \
-  }                                                                            \
-  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
-    Lhs = Lhs BINOP Rhs;                                                       \
-    return Lhs;                                                                \
-  }                                                                            \
-  template <int Num = NumElements>                                             \
-  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
-      vec & Lhs, const DataT & Rhs) {                                          \
-    Lhs = Lhs BINOP vec(Rhs);                                                  \
-    return Lhs;                                                                \
-  }
-#else // __SYCL_DEVICE_ONLY__
-
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
-  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
-    vec Ret{};                                                                 \
-    for (size_t I = 0; I < NumElements; ++I)                                   \
-      Ret.setValue(I,                                                          \
-                   (DataT)(vec_data<DataT>::get(Lhs.getValue(I))               \
-                               BINOP vec_data<DataT>::get(Rhs.getValue(I))));  \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
-    return Lhs BINOP vec(Rhs);                                                 \
-  }                                                                            \
-  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
-    return vec(Lhs) BINOP Rhs;                                                 \
-  }                                                                            \
-  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
-    Lhs = Lhs BINOP Rhs;                                                       \
-    return Lhs;                                                                \
-  }                                                                            \
-  template <int Num = NumElements>                                             \
-  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
-      vec & Lhs, const DataT & Rhs) {                                          \
-    Lhs = Lhs BINOP vec(Rhs);                                                  \
-    return Lhs;                                                                \
-  }
-#endif // __SYCL_DEVICE_ONLY__
-
-  __SYCL_BINOP(+, +=, true)
-  __SYCL_BINOP(-, -=, true)
-  __SYCL_BINOP(*, *=, false)
-  __SYCL_BINOP(/, /=, false)
-
-  // TODO: The following OPs are available only when: DataT != cl_float &&
-  // DataT != cl_double && DataT != cl_half
-  __SYCL_BINOP(%, %=, false)
-  __SYCL_BINOP(|, |=, false)
-  __SYCL_BINOP(&, &=, false)
-  __SYCL_BINOP(^, ^=, false)
-  __SYCL_BINOP(>>, >>=, false)
-  __SYCL_BINOP(<<, <<=, true)
-#undef __SYCL_BINOP
-#undef __SYCL_BINOP_HELP
-
-  // Note: vec<>/SwizzleOp logical value is 0/-1 logic, as opposed to 0/1 logic.
-  // As far as CTS validation is concerned, 0/-1 logic also applies when
-  // NumElements is equal to one, which is somewhat inconsistent with being
-  // transparent with scalar data.
-  // TODO: Determine if vec<, NumElements=1> is needed at all, remove this
-  // inconsistency if not by disallowing one-element vectors (as in OpenCL)
-
-#ifdef __SYCL_RELLOGOP
-#error "Undefine __SYCL_RELLOGOP macro"
-#endif
-// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
-// by SYCL device compiler only.
-#ifdef __SYCL_DEVICE_ONLY__
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const vec & Rhs) {          \
-    vec<rel_t, NumElements> Ret{};                                             \
-    /* ext_vector_type does not support bfloat16 or half, so for these   */    \
-    /* we do element-by-element operation on the underlying std::array.  */    \
-    if constexpr (IsBfloat16 ||                                                \
-                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
-      for (size_t I = 0; I < NumElements; ++I) {                               \
-        /* We cannot use SetValue here as the operator is not a friend of*/    \
-        /* Ret on Windows. */                                                  \
-        Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                    \
-            Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
-      }                                                                        \
-    } else {                                                                   \
-      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
-      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
-      Ret = vec<rel_t, NumElements>(                                           \
-          (typename vec<rel_t, NumElements>::vector_t)(                        \
-              ExtVecLhs RELLOGOP ExtVecRhs));                                  \
-      if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
-        Ret *= -1;                                                             \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const DataT & Rhs) {        \
-    return Lhs RELLOGOP vec(Rhs);                                              \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
-                                                   const vec & Rhs) {          \
-    return vec(Lhs) RELLOGOP Rhs;                                              \
-  }
-
-#else
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const vec & Rhs) {          \
-    vec<rel_t, NumElements> Ret{};                                             \
-    for (size_t I = 0; I < NumElements; ++I) {                                 \
-      /* We cannot use SetValue here as the operator is not a friend of*/      \
-      /* Ret on Windows. */                                                    \
-      Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                      \
-          Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));   \
-    }                                                                          \
-    return Ret;                                                                \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const DataT & Rhs) {        \
-    return Lhs RELLOGOP vec(Rhs);                                              \
-  }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
-                                                   const vec & Rhs) {          \
-    return vec(Lhs) RELLOGOP Rhs;                                              \
-  }
-#endif
-
-  __SYCL_RELLOGOP(==)
-  __SYCL_RELLOGOP(!=)
-  __SYCL_RELLOGOP(>)
-  __SYCL_RELLOGOP(<)
-  __SYCL_RELLOGOP(>=)
-  __SYCL_RELLOGOP(<=)
-  // TODO: limit to integral types.
-  __SYCL_RELLOGOP(&&)
-  __SYCL_RELLOGOP(||)
-#undef __SYCL_RELLOGOP
-
-#ifdef __SYCL_UOP
-#error "Undefine __SYCL_UOP macro"
-#endif
-#define __SYCL_UOP(UOP, OPASSIGN)                                              \
-  friend vec &operator UOP(vec & Rhs) {                                        \
-    Rhs OPASSIGN vec_data<DataT>::get(1);                                      \
-    return Rhs;                                                                \
-  }                                                                            \
-  friend vec operator UOP(vec &Lhs, int) {                                     \
-    vec Ret(Lhs);                                                              \
-    Lhs OPASSIGN vec_data<DataT>::get(1);                                      \
-    return Ret;                                                                \
-  }
-
-  __SYCL_UOP(++, +=)
-  __SYCL_UOP(--, -=)
-#undef __SYCL_UOP
-
-  // operator~() available only when: dataT != float && dataT != double
-  // && dataT != half
-  friend vec operator~(const vec &Rhs) {
-#ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
-    vec Ret{~extVec};
-    if constexpr (std::is_same_v<Type, bool>) {
-      Ret.ConvertToDataT();
-    }
-    return Ret;
-#else
-    vec Ret{};
-    for (size_t I = 0; I < NumElements; ++I) {
-      Ret.setValue(I, ~Rhs.getValue(I));
-    }
-    return Ret;
-#endif
-  }
-
-  // operator!
-  friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
-    vec Ret{};
-#ifdef __SYCL_DEVICE_ONLY__
-    if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
-                  !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-                  !std::is_same_v<DataT, std::byte>)
-#else
-                  1)
-#endif
-    {
-      auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
-      return vec<detail::rel_t<DataT>, NumElements>{!extVec};
-    } else
-#endif
-    {
-      for (size_t I = 0; I < NumElements; ++I) {
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-        // std::byte neither supports ! unary op or casting, so special handling
-        // is needed. And, worse, Windows has a conflict with 'byte'.
-        if constexpr (std::is_same_v<std::byte, DataT>) {
-          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
-        } else
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-        {
-          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
-        }
-      }
-      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
-    }
-  }
-
-  // operator +
-  friend vec operator+(const vec &Lhs) {
-#ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
-    return vec{+extVec};
-#else
-    vec Ret{};
-    for (size_t I = 0; I < NumElements; ++I)
-      Ret.setValue(
-          I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
-    return Ret;
-#endif
-  }
-
-  // operator -
-  friend vec operator-(const vec &Lhs) {
-    namespace oneapi = sycl::ext::oneapi;
-    vec Ret{};
-    if constexpr (IsBfloat16 && NumElements == 1) {
-      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data);
-      oneapi::bfloat16 w = -v;
-      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
-    } else if constexpr (IsBfloat16) {
-      for (size_t I = 0; I < NumElements; I++) {
-        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[I]);
-        oneapi::bfloat16 w = -v;
-        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
-      }
-    } else {
-#ifndef __SYCL_DEVICE_ONLY__
-      for (size_t I = 0; I < NumElements; ++I)
-        Ret.setValue(
-            I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
-#else
-      auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
-      Ret = vec{-extVec};
-      if constexpr (std::is_same_v<Type, bool>) {
-        Ret.ConvertToDataT();
-      }
-#endif
-    }
-    return Ret;
-  }
-
-  // OP is: &&, ||
-  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
-  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
-
-  // OP is: ==, !=, <, >, <=, >=
-  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
-  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
-private:
-  // Generic method that execute "Operation" on underlying values.
-
-#ifdef __SYCL_DEVICE_ONLY__
-  template <template <typename> class Operation,
-            typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements> operatorHelper(const Ty &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataT> Op;
-    // Typecast to ext_vector_type, carryout the operation, and type cast back.
-    // Compiler optimizations will remove redundant casts.
-    auto OpResult = Op(sycl::bit_cast<vector_t>(m_Data),
-                       sycl::bit_cast<vector_t>(Rhs.m_Data));
-    Result.m_Data = sycl::bit_cast<DataType>(OpResult);
-    return Result;
-  }
-#else  // __SYCL_DEVICE_ONLY__
-  template <template <typename> class Operation>
-  vec<DataT, NumElements>
-  operatorHelper(const vec<DataT, NumElements> &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataT> Op;
-    for (size_t I = 0; I < NumElements; ++I) {
-      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
-    }
-    return Result;
-  }
-#endif // __SYCL_DEVICE_ONLY__
-
-  // setValue and getValue should be able to operate on different underlying
-  // types: enum cl_float#N , builtin vector float#N, builtin type float.
-  // These versions are for N > 1.
-#ifdef __SYCL_DEVICE_ONLY__
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(Ty Index, const DataT &Value, int) {
-    m_Data[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(Ty Index, int) const {
-    return vec_data<DataT>::get(m_Data[Index]);
-  }
-#else  // __SYCL_DEVICE_ONLY__
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(int Index, const DataT &Value, int) {
-    m_Data[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(int Index, int) const {
-    return vec_data<DataT>::get(m_Data[Index]);
-  }
-#endif // __SYCL_DEVICE_ONLY__
-
-  // N==1 versions, used by host and device. Shouldn't trailing type be int?
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 == Num>>
-  constexpr void setValue(int, const DataT &Value, float) {
-    m_Data = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 == Num>>
-  DataT getValue(int, float) const {
-    return vec_data<DataT>::get(m_Data);
-  }
-
-  // setValue and getValue.
-  // The "api" functions used by BINOP etc.  These versions just dispatch
-  // using additional int or float arg to disambiguate vec<1> vs. vec<N>
-  // Special proxies as specialization is not allowed in class scope.
-  constexpr void setValue(int Index, const DataT &Value) {
-    if (NumElements == 1)
-      setValue(Index, Value, 0);
-    else
-      setValue(Index, Value, 0.f);
-  }
-
-  DataT getValue(int Index) const {
-    return (NumElements == 1) ? getValue(Index, 0) : getValue(Index, 0.f);
-  }
-
-  // fields
-
-  // Alignment is the same as size, to a maximum size of 64.
-  // detail::vector_alignment will return that value.
-  alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
-
-  // friends
-  template <typename T1, typename T2, typename T3, template <typename> class T4,
-            int... T5>
-  friend class detail::SwizzleOp;
-  template <typename T1, int T2> friend class vec;
-};
-
-#ifdef __cpp_deduction_guides
-// all compilers supporting deduction guides also support fold expressions
-template <class T, class... U,
-          class = std::enable_if_t<(std::is_same_v<T, U> && ...)>>
-vec(T, U...) -> vec<T, sizeof...(U) + 1>;
-#endif
-
-namespace detail {
-
-// SwizzleOP represents expression templates that operate on vec.
-// Actual computation performed on conversion or assignment operators.
-template <typename VecT, typename OperationLeftT, typename OperationRightT,
-          template <typename> class OperationCurrentT, int... Indexes>
-class SwizzleOp {
-  using DataT = typename VecT::element_type;
-  // Certain operators return a vector with a different element type. Also, the
-  // left and right operand types may differ. CommonDataT selects a result type
-  // based on these types to ensure that the result value can be represented.
-  //
-  // Example 1:
-  //   sycl::vec<unsigned char, 4> vec{...};
-  //   auto result = 300u + vec.x();
-  //
-  // CommonDataT is std::common_type_t<OperationLeftT, OperationRightT> since
-  // it's larger than unsigned char.
-  //
-  // Example 2:
-  //   sycl::vec<bool, 1> vec{...};
-  //   auto result = vec.template swizzle<sycl::elem::s0>() && vec;
-  //
-  // CommonDataT is DataT since operator&& returns a vector with element type
-  // int8_t, which is larger than bool.
-  //
-  // Example 3:
-  //   sycl::vec<std::byte, 4> vec{...}; auto swlo = vec.lo();
-  //   auto result = swlo == swlo;
-  //
-  // CommonDataT is DataT since operator== returns a vector with element type
-  // int8_t, which is the same size as std::byte. std::common_type_t<DataT, ...>
-  // can't be used here since there's no type that int8_t and std::byte can both
-  // be implicitly converted to.
-  using OpLeftDataT = typename OperationLeftT::DataT;
-  using OpRightDataT = typename OperationRightT::DataT;
-  using CommonDataT = std::conditional_t<
-      sizeof(DataT) >= sizeof(std::common_type_t<OpLeftDataT, OpRightDataT>),
-      DataT, std::common_type_t<OpLeftDataT, OpRightDataT>>;
-  static constexpr int getNumElements() { return sizeof...(Indexes); }
-
-  using rel_t = detail::rel_t<DataT>;
-  using vec_t = vec<DataT, sizeof...(Indexes)>;
-  using vec_rel_t = vec<rel_t, sizeof...(Indexes)>;
-
-  template <typename OperationRightT_,
-            template <typename> class OperationCurrentT_, int... Idx_>
-  using NewLHOp = SwizzleOp<VecT,
-                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                                      OperationCurrentT, Indexes...>,
-                            OperationRightT_, OperationCurrentT_, Idx_...>;
-
-  template <typename OperationRightT_,
-            template <typename> class OperationCurrentT_, int... Idx_>
-  using NewRelOp = SwizzleOp<vec<rel_t, VecT::getNumElements()>,
-                             SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                                       OperationCurrentT, Indexes...>,
-                             OperationRightT_, OperationCurrentT_, Idx_...>;
-
-  template <typename OperationLeftT_,
-            template <typename> class OperationCurrentT_, int... Idx_>
-  using NewRHOp = SwizzleOp<VecT, OperationLeftT_,
-                            SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                                      OperationCurrentT, Indexes...>,
-                            OperationCurrentT_, Idx_...>;
-
-  template <int IdxNum, typename T = void>
-  using EnableIfOneIndex = typename std::enable_if_t<
-      1 == IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
-
-  template <int IdxNum, typename T = void>
-  using EnableIfMultipleIndexes = typename std::enable_if_t<
-      1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
-
-  template <typename T>
-  using EnableIfScalarType = typename std::enable_if_t<
-      std::is_convertible_v<DataT, T> &&
-      (std::is_fundamental_v<vec_data_t<T>> ||
-       detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
-
-  template <typename T>
-  using EnableIfNoScalarType = typename std::enable_if_t<
-      !std::is_convertible_v<DataT, T> ||
-      !(std::is_fundamental_v<vec_data_t<T>> ||
-        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
-
-  template <int... Indices>
-  using Swizzle =
-      SwizzleOp<VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
-
-  template <int... Indices>
-  using ConstSwizzle =
-      SwizzleOp<const VecT, GetOp<DataT>, GetOp<DataT>, GetOp, Indices...>;
-
-public:
-  using element_type = DataT;
-  using value_type = DataT;
-
-#ifdef __SYCL_DEVICE_ONLY__
-  using vector_t = typename vec_t::vector_t;
-#endif // __SYCL_DEVICE_ONLY__
-
-  const DataT &operator[](int i) const {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    return (*m_Vector)[Idxs[i]];
-  }
-
-  template <typename _T = VecT>
-  std::enable_if_t<!std::is_const_v<_T>, DataT> &operator[](int i) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    return (*m_Vector)[Idxs[i]];
-  }
-
-  __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
-  size_t get_count() const { return size(); }
-  static constexpr size_t size() noexcept { return getNumElements(); }
-
-  template <int Num = getNumElements()>
-  __SYCL2020_DEPRECATED(
-      "get_size() is deprecated, please use byte_size() instead")
-  size_t get_size() const {
-    return byte_size<Num>();
-  }
-
-  template <int Num = getNumElements()> size_t byte_size() const noexcept {
-    return sizeof(DataT) * (Num == 3 ? 4 : Num);
-  }
-
-  template <typename T, int IdxNum = getNumElements(),
-            typename = EnableIfOneIndex<IdxNum>,
-            typename = EnableIfScalarType<T>>
-  operator T() const {
-    return getValue(0);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  friend NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>
-  operator*(const T &Lhs, const SwizzleOp &Rhs) {
-    return NewRHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
-        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  friend NewRHOp<GetScalarOp<T>, std::plus, Indexes...>
-  operator+(const T &Lhs, const SwizzleOp &Rhs) {
-    return NewRHOp<GetScalarOp<T>, std::plus, Indexes...>(
-        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  friend NewRHOp<GetScalarOp<T>, std::divides, Indexes...>
-  operator/(const T &Lhs, const SwizzleOp &Rhs) {
-    return NewRHOp<GetScalarOp<T>, std::divides, Indexes...>(
-        Rhs.m_Vector, GetScalarOp<T>(Lhs), Rhs);
-  }
-
-  // TODO: Check that Rhs arg is suitable.
-#ifdef __SYCL_OPASSIGN
-#error "Undefine __SYCL_OPASSIGN macro."
-#endif
-#define __SYCL_OPASSIGN(OPASSIGN, OP)                                          \
-  SwizzleOp &operator OPASSIGN(const DataT & Rhs) {                            \
-    operatorHelper<OP>(vec_t(Rhs));                                            \
-    return *this;                                                              \
-  }                                                                            \
-  template <typename RhsOperation>                                             \
-  SwizzleOp &operator OPASSIGN(const RhsOperation & Rhs) {                     \
-    operatorHelper<OP>(Rhs);                                                   \
-    return *this;                                                              \
-  }
-
-  __SYCL_OPASSIGN(+=, std::plus)
-  __SYCL_OPASSIGN(-=, std::minus)
-  __SYCL_OPASSIGN(*=, std::multiplies)
-  __SYCL_OPASSIGN(/=, std::divides)
-  __SYCL_OPASSIGN(%=, std::modulus)
-  __SYCL_OPASSIGN(&=, std::bit_and)
-  __SYCL_OPASSIGN(|=, std::bit_or)
-  __SYCL_OPASSIGN(^=, std::bit_xor)
-  __SYCL_OPASSIGN(>>=, RShift)
-  __SYCL_OPASSIGN(<<=, LShift)
-#undef __SYCL_OPASSIGN
-
-#ifdef __SYCL_UOP
-#error "Undefine __SYCL_UOP macro"
-#endif
-#define __SYCL_UOP(UOP, OPASSIGN)                                              \
-  SwizzleOp &operator UOP() {                                                  \
-    *this OPASSIGN static_cast<DataT>(1);                                      \
-    return *this;                                                              \
-  }                                                                            \
-  vec_t operator UOP(int) {                                                    \
-    vec_t Ret = *this;                                                         \
-    *this OPASSIGN static_cast<DataT>(1);                                      \
-    return Ret;                                                                \
-  }
-
-  __SYCL_UOP(++, +=)
-  __SYCL_UOP(--, -=)
-#undef __SYCL_UOP
-
-  template <typename T = DataT>
-  friend typename std::enable_if_t<
-      std::is_same_v<T, DataT> && std::is_integral_v<vec_data_t<T>>, vec_t>
-  operator~(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return ~Tmp;
-  }
-
-  friend vec_rel_t operator!(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return !Tmp;
-  }
-
-  friend vec_t operator+(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return +Tmp;
-  }
-
-  friend vec_t operator-(const SwizzleOp &Rhs) {
-    vec_t Tmp = Rhs;
-    return -Tmp;
-  }
-
-// scalar BINOP vec<>
-// scalar BINOP SwizzleOp
-// vec<> BINOP SwizzleOp
-#ifdef __SYCL_BINOP
-#error "Undefine __SYCL_BINOP macro"
-#endif
-#define __SYCL_BINOP(BINOP)                                                    \
-  friend vec_t operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {        \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs BINOP Tmp;                                                      \
-  }                                                                            \
-  friend vec_t operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {        \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp BINOP Rhs;                                                      \
-  }                                                                            \
-  friend vec_t operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {        \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs BINOP Tmp;                                                      \
-  }                                                                            \
-  friend vec_t operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {        \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp BINOP Rhs;                                                      \
-  }
-
-  __SYCL_BINOP(+)
-  __SYCL_BINOP(-)
-  __SYCL_BINOP(*)
-  __SYCL_BINOP(/)
-  __SYCL_BINOP(%)
-  __SYCL_BINOP(&)
-  __SYCL_BINOP(|)
-  __SYCL_BINOP(^)
-  __SYCL_BINOP(>>)
-  __SYCL_BINOP(<<)
-#undef __SYCL_BINOP
-
-// scalar RELLOGOP vec<>
-// scalar RELLOGOP SwizzleOp
-// vec<> RELLOGOP SwizzleOp
-#ifdef __SYCL_RELLOGOP
-#error "Undefine __SYCL_RELLOGOP macro"
-#endif
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec_rel_t operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs RELLOGOP Tmp;                                                   \
-  }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp RELLOGOP Rhs;                                                   \
-  }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
-    vec_t Tmp = Rhs;                                                           \
-    return Lhs RELLOGOP Tmp;                                                   \
-  }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
-    vec_t Tmp = Lhs;                                                           \
-    return Tmp RELLOGOP Rhs;                                                   \
-  }
-
-  __SYCL_RELLOGOP(==)
-  __SYCL_RELLOGOP(!=)
-  __SYCL_RELLOGOP(>)
-  __SYCL_RELLOGOP(<)
-  __SYCL_RELLOGOP(>=)
-  __SYCL_RELLOGOP(<=)
-  // TODO: limit to integral types.
-  __SYCL_RELLOGOP(&&)
-  __SYCL_RELLOGOP(||)
-#undef __SYCL_RELLOGOP
-
-  template <int IdxNum = getNumElements(),
-            typename = EnableIfMultipleIndexes<IdxNum>>
-  SwizzleOp &operator=(const vec<DataT, IdxNum> &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
-    }
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
-  SwizzleOp &operator=(const DataT &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    m_Vector->setValue(Idxs[0], Rhs);
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(),
-            EnableIfMultipleIndexes<IdxNum, bool> = true>
-  SwizzleOp &operator=(const DataT &Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    for (auto Idx : Idxs) {
-      m_Vector->setValue(Idx, Rhs);
-    }
-    return *this;
-  }
-
-  template <int IdxNum = getNumElements(), typename = EnableIfOneIndex<IdxNum>>
-  SwizzleOp &operator=(DataT &&Rhs) {
-    std::array<int, IdxNum> Idxs{Indexes...};
-    m_Vector->setValue(Idxs[0], Rhs);
-    return *this;
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>
-  operator*(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::multiplies, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::multiplies, Indexes...>
-  operator*(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::multiplies, Indexes...>(m_Vector, *this,
-                                                              Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::plus, Indexes...> operator+(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::plus, Indexes...>(m_Vector, *this,
-                                                          GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::plus, Indexes...>
-  operator+(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::plus, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::minus, Indexes...>
-  operator-(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::minus, Indexes...>(m_Vector, *this,
-                                                           GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::minus, Indexes...>
-  operator-(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::minus, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::divides, Indexes...>
-  operator/(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::divides, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::divides, Indexes...>
-  operator/(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::divides, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>
-  operator%(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::modulus, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::modulus, Indexes...>
-  operator%(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::modulus, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>
-  operator&(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::bit_and, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::bit_and, Indexes...>
-  operator&(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::bit_and, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>
-  operator|(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::bit_or, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::bit_or, Indexes...>
-  operator|(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::bit_or, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>
-  operator^(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, std::bit_xor, Indexes...>(
-        m_Vector, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, std::bit_xor, Indexes...>
-  operator^(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, std::bit_xor, Indexes...>(m_Vector, *this,
-                                                           Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, RShift, Indexes...> operator>>(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, RShift, Indexes...>(m_Vector, *this,
-                                                       GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, RShift, Indexes...>
-  operator>>(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, RShift, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewLHOp<GetScalarOp<T>, LShift, Indexes...> operator<<(const T &Rhs) const {
-    return NewLHOp<GetScalarOp<T>, LShift, Indexes...>(m_Vector, *this,
-                                                       GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewLHOp<RhsOperation, LShift, Indexes...>
-  operator<<(const RhsOperation &Rhs) const {
-    return NewLHOp<RhsOperation, LShift, Indexes...>(m_Vector, *this, Rhs);
-  }
-
-  template <
-      typename T1, typename T2, typename T3, template <typename> class T4,
-      int... T5,
-      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
-  SwizzleOp &operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
-    }
-    return *this;
-  }
-
-  template <
-      typename T1, typename T2, typename T3, template <typename> class T4,
-      int... T5,
-      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
-  SwizzleOp &operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) {
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      m_Vector->setValue(Idxs[I], Rhs.getValue(I));
-    }
-    return *this;
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, EqualTo, Indexes...> operator==(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, EqualTo, Indexes...>(NULL, *this,
-                                                         GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, EqualTo, Indexes...>
-  operator==(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, EqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>
-  operator!=(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, NotEqualTo, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, NotEqualTo, Indexes...>
-  operator!=(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, NotEqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>
-  operator>=(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, GreaterEqualTo, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>
-  operator>=(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, GreaterEqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>
-  operator<=(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LessEqualTo, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LessEqualTo, Indexes...>
-  operator<=(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LessEqualTo, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>
-  operator>(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, GreaterThan, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, GreaterThan, Indexes...>
-  operator>(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, GreaterThan, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LessThan, Indexes...> operator<(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LessThan, Indexes...>(NULL, *this,
-                                                          GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LessThan, Indexes...>
-  operator<(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LessThan, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>
-  operator&&(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LogicalAnd, Indexes...>(
-        NULL, *this, GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LogicalAnd, Indexes...>
-  operator&&(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LogicalAnd, Indexes...>(NULL, *this, Rhs);
-  }
-
-  template <typename T, typename = EnableIfScalarType<T>>
-  NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>
-  operator||(const T &Rhs) const {
-    return NewRelOp<GetScalarOp<T>, LogicalOr, Indexes...>(NULL, *this,
-                                                           GetScalarOp<T>(Rhs));
-  }
-
-  template <typename RhsOperation,
-            typename = EnableIfNoScalarType<RhsOperation>>
-  NewRelOp<RhsOperation, LogicalOr, Indexes...>
-  operator||(const RhsOperation &Rhs) const {
-    return NewRelOp<RhsOperation, LogicalOr, Indexes...>(NULL, *this, Rhs);
-  }
-
-  // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
-private:
-  // Indexer used in the swizzles.def.
-  // Currently it is defined as a template struct. Replacing it with a constexpr
-  // function would activate a bug in MSVC that is fixed only in v19.20.
-  // Until then MSVC does not recognize such constexpr functions as const and
-  // thus does not let using them in template parameters inside swizzle.def.
-  template <int Index> struct Indexer {
-    static constexpr int IDXs[sizeof...(Indexes)] = {Indexes...};
-    static constexpr int value = IDXs[Index >= getNumElements() ? 0 : Index];
-  };
-
-public:
-#ifdef __SYCL_ACCESS_RETURN
-#error "Undefine __SYCL_ACCESS_RETURN macro"
-#endif
-#define __SYCL_ACCESS_RETURN m_Vector
-#include "swizzles.def"
-#undef __SYCL_ACCESS_RETURN
-  // End of hi/lo, even/odd, xyzw, and rgba swizzles.
-
-  // Leave store() interface to automatic conversion to vec<>.
-  // Load to vec_t and then assign to swizzle.
-  template <access::address_space Space, access::decorated DecorateAddress>
-  void load(size_t offset, multi_ptr<DataT, Space, DecorateAddress> ptr) {
-    vec_t Tmp;
-    Tmp.template load(offset, ptr);
-    *this = Tmp;
-  }
-
-  template <typename convertT, rounding_mode roundingMode>
-  vec<convertT, sizeof...(Indexes)> convert() const {
-    // First materialize the swizzle to vec_t and then apply convert() to it.
-    vec_t Tmp = *this;
-    return Tmp.template convert<convertT, roundingMode>();
-  }
-
-  template <typename asT> asT as() const {
-    // First materialize the swizzle to vec_t and then apply as() to it.
-    vec_t Tmp = *this;
-    static_assert((sizeof(Tmp) == sizeof(asT)),
-                  "The new SYCL vec type must have the same storage size in "
-                  "bytes as this SYCL swizzled vec");
-    static_assert(
-        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
-            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
-        "asT must be SYCL vec of a different element type and "
-        "number of elements specified by asT");
-    return Tmp.template as<asT>();
-  }
-
-private:
-  SwizzleOp(const SwizzleOp &Rhs)
-      : m_Vector(Rhs.m_Vector), m_LeftOperation(Rhs.m_LeftOperation),
-        m_RightOperation(Rhs.m_RightOperation) {}
-
-  SwizzleOp(VecT *Vector, OperationLeftT LeftOperation,
-            OperationRightT RightOperation)
-      : m_Vector(Vector), m_LeftOperation(LeftOperation),
-        m_RightOperation(RightOperation) {}
-
-  SwizzleOp(VecT *Vector) : m_Vector(Vector) {}
-
-  SwizzleOp(SwizzleOp &&Rhs)
-      : m_Vector(Rhs.m_Vector), m_LeftOperation(std::move(Rhs.m_LeftOperation)),
-        m_RightOperation(std::move(Rhs.m_RightOperation)) {}
-
-  // Either performing CurrentOperation on results of left and right operands
-  // or reading values from actual vector. Perform implicit type conversion when
-  // the number of elements == 1
-
-  template <int IdxNum = getNumElements()>
-  CommonDataT getValue(EnableIfOneIndex<IdxNum, size_t> Index) const {
-    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
-      std::array<int, getNumElements()> Idxs{Indexes...};
-      return m_Vector->getValue(Idxs[Index]);
-    }
-    auto Op = OperationCurrentT<vec_data_t<CommonDataT>>();
-    return vec_data<CommonDataT>::get(
-        Op(vec_data<CommonDataT>::get(m_LeftOperation.getValue(Index)),
-           vec_data<CommonDataT>::get(m_RightOperation.getValue(Index))));
-  }
-
-  template <int IdxNum = getNumElements()>
-  DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
-    if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
-      std::array<int, getNumElements()> Idxs{Indexes...};
-      return m_Vector->getValue(Idxs[Index]);
-    }
-    auto Op = OperationCurrentT<vec_data_t<DataT>>();
-    return vec_data<DataT>::get(
-        Op(vec_data<DataT>::get(m_LeftOperation.getValue(Index)),
-           vec_data<DataT>::get(m_RightOperation.getValue(Index))));
-  }
-
-  template <template <typename> class Operation, typename RhsOperation>
-  void operatorHelper(const RhsOperation &Rhs) {
-    Operation<vec_data_t<DataT>> Op;
-    std::array<int, getNumElements()> Idxs{Indexes...};
-    for (size_t I = 0; I < Idxs.size(); ++I) {
-      DataT Res = vec_data<DataT>::get(
-          Op(vec_data<DataT>::get(m_Vector->getValue(Idxs[I])),
-             vec_data<DataT>::get(Rhs.getValue(I))));
-      m_Vector->setValue(Idxs[I], Res);
-    }
-  }
-
-  // fields
-  VecT *m_Vector;
-
-  OperationLeftT m_LeftOperation;
-  OperationRightT m_RightOperation;
-
-  // friends
-  template <typename T1, int T2> friend class sycl::vec;
-
-  template <typename T1, typename T2, typename T3, template <typename> class T4,
-            int... T5>
-  friend class SwizzleOp;
-};
-} // namespace detail
-
-namespace detail {
-
-// Vectors of size 1 are handled separately and therefore 1 is not included in
-// the check below.
-constexpr bool isValidVectorSize(int N) {
-  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
-}
-template <typename T, int N, typename V> struct VecStorage {
-  static_assert(
-      isValidVectorSize(N) || N == 1,
-      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
-      "or 16 are supported");
-  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
-};
-
-#ifdef __SYCL_DEVICE_ONLY__
-// device always has ext vector support, but for huge vectors
-// we switch to std::array, so that we can use a smaller alignment (64)
-// this is to support MSVC, which has a max of 64 for direct params.
-template <typename T, int N> struct VecStorageImpl {
-  static constexpr size_t Num = (N == 3) ? 4 : N;
-  static constexpr size_t Sz = Num * sizeof(T);
-
-  using DataType = std::array<T, (N == 3) ? 4 : N>;
-  using VectorDataType = T __attribute__((ext_vector_type(N)));
-};
-#else  // __SYCL_DEVICE_ONLY__
-template <typename T, int N> struct VecStorageImpl {
-  using DataType = std::array<T, (N == 3) ? 4 : N>;
-};
-#endif // __SYCL_DEVICE_ONLY__
-
-// Single element bool
-template <> struct VecStorage<bool, 1, void> {
-  using DataType = bool;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = bool;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple element bool
-template <int N>
-struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
-  using DataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-// Single element byte. Multiple elements will propagate through a later
-// specialization.
-template <> struct VecStorage<std::byte, 1, void> {
-  using DataType = std::int8_t;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = std::int8_t;
-#endif // __SYCL_DEVICE_ONLY__
-};
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-
-// Single element signed integers
-template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element unsigned integers
-template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element floating-point (except half/bfloat16)
-template <typename T>
-struct VecStorage<
-    T, 1,
-    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-// Multiple elements signed/unsigned integers and floating-point (except
-// half/bfloat16)
-template <typename T, int N>
-struct VecStorage<
-    T, N,
-    typename std::enable_if_t<isValidVectorSize(N) &&
-                              (is_sgeninteger_v<T> ||
-                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
-  using DataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element half
-template <> struct VecStorage<half, 1, void> {
-  using DataType = sycl::detail::half_impl::StorageT;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = sycl::detail::half_impl::StorageT;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple elements half
-#ifdef __SYCL_DEVICE_ONLY__
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##DeviceStorageT;        \
-    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
-  };
-#else // __SYCL_DEVICE_ONLY__
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
-  };
-#endif // __SYCL_DEVICE_ONLY__
-
-__SYCL_DEFINE_HALF_VECSTORAGE(2)
-__SYCL_DEFINE_HALF_VECSTORAGE(3)
-__SYCL_DEFINE_HALF_VECSTORAGE(4)
-__SYCL_DEFINE_HALF_VECSTORAGE(8)
-__SYCL_DEFINE_HALF_VECSTORAGE(16)
-#undef __SYCL_DEFINE_HALF_VECSTORAGE
-
-// Single element bfloat16
-template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
-  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-  // using VectorDataType = sycl::ext::oneapi::bfloat16;
-  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-};
-// Multiple elements bfloat16
-#ifndef __SYCL_DEVICE_ONLY__
-#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
-  };
-#else
-#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType =                                                           \
-        sycl::ext::oneapi::detail::bf16::Vec##Num##DeviceStorageT;             \
-    using VectorDataType =                                                     \
-        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
-  };
-#endif
-__SYCL_DEFINE_BF16_VECSTORAGE(2)
-__SYCL_DEFINE_BF16_VECSTORAGE(3)
-__SYCL_DEFINE_BF16_VECSTORAGE(4)
-__SYCL_DEFINE_BF16_VECSTORAGE(8)
-__SYCL_DEFINE_BF16_VECSTORAGE(16)
-#undef __SYCL_DEFINE_BF16_VECSTORAGE
-} // namespace detail
-
-/// This macro must be defined to 1 when SYCL implementation allows user
-/// applications to explicitly declare certain class types as device copyable
-/// by adding specializations of is_device_copyable type trait class.
-#define SYCL_DEVICE_COPYABLE 1
-
-/// is_device_copyable is a user specializable class template to indicate
-/// that a type T is device copyable, which means that SYCL implementation
-/// may copy objects of the type T between host and device or between two
-/// devices.
-/// Specializing is_device_copyable such a way that
-/// is_device_copyable_v<T> == true on a T that does not satisfy all
-/// the requirements of a device copyable type is undefined behavior.
-template <typename T> struct is_device_copyable;
-
-namespace detail {
-template <typename T, typename = void>
-struct is_device_copyable_impl : std::is_trivially_copyable<T> {};
-
-template <typename T>
-struct is_device_copyable_impl<
-    T, std::enable_if_t<!std::is_same_v<T, std::remove_cv_t<T>>>>
-    // Cannot express this "recursion" (to take user's partial non-cv
-    // specializations into account) without this helper struct.
-    : is_device_copyable<std::remove_cv_t<T>> {};
-} // namespace detail
-
-template <typename T>
-struct is_device_copyable : detail::is_device_copyable_impl<T> {};
-
-// std::array<T, 0> is implicitly device copyable type.
-template <typename T>
-struct is_device_copyable<std::array<T, 0>> : std::true_type {};
-
-// std::array<T, N> is implicitly device copyable type if T is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<std::array<T, N>> : is_device_copyable<T> {};
-
-// std::optional<T> is implicitly device copyable type if T is device copyable.
-template <typename T>
-struct is_device_copyable<std::optional<T>> : is_device_copyable<T> {};
-
-// std::pair<T1, T2> is implicitly device copyable type if T1 and T2 are device
-// copyable.
-template <typename T1, typename T2>
-struct is_device_copyable<std::pair<T1, T2>>
-    : std::bool_constant<is_device_copyable<T1>::value &&
-                         is_device_copyable<T2>::value> {};
-
-// std::tuple<Ts...> is implicitly device copyable type if each type T of Ts...
-// is device copyable.
-template <typename... Ts>
-struct is_device_copyable<std::tuple<Ts...>>
-    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
-
-// std::variant<Ts...> is implicitly device copyable type if each type T of
-// Ts... is device copyable.
-template <typename... Ts>
-struct is_device_copyable<std::variant<Ts...>>
-    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
-
-// marray is device copyable if element type is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<sycl::marray<T, N>> : is_device_copyable<T> {};
-
-// array is device copyable if element type is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<T[N]> : is_device_copyable<T> {};
-
-template <typename T>
-inline constexpr bool is_device_copyable_v = is_device_copyable<T>::value;
-
-namespace detail {
-template <typename T, typename = void>
-struct IsDeprecatedDeviceCopyable : std::false_type {};
-
-// TODO: using C++ attribute [[deprecated]] or the macro __SYCL2020_DEPRECATED
-// does not produce expected warning message for the type 'T'.
-template <typename T>
-struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
-    IsDeprecatedDeviceCopyable<
-        T, std::enable_if_t<std::is_trivially_copy_constructible_v<T> &&
-                            std::is_trivially_destructible_v<T> &&
-                            !is_device_copyable_v<T>>> : std::true_type {};
-
-template <typename T, int N>
-struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
-    IsDeprecatedDeviceCopyable<T[N]> : IsDeprecatedDeviceCopyable<T> {};
-
-#ifdef __SYCL_DEVICE_ONLY__
-// Checks that the fields of the type T with indices 0 to (NumFieldsToCheck -
-// 1) are device copyable.
-template <typename T, unsigned NumFieldsToCheck>
-struct CheckFieldsAreDeviceCopyable
-    : CheckFieldsAreDeviceCopyable<T, NumFieldsToCheck - 1> {
-  using FieldT = decltype(__builtin_field_type(T, NumFieldsToCheck - 1));
-  static_assert(is_device_copyable_v<FieldT> ||
-                    detail::IsDeprecatedDeviceCopyable<FieldT>::value,
-                "The specified type is not device copyable");
-};
-
-template <typename T> struct CheckFieldsAreDeviceCopyable<T, 0> {};
-
-// Checks that the base classes of the type T with indices 0 to
-// (NumFieldsToCheck - 1) are device copyable.
-template <typename T, unsigned NumBasesToCheck>
-struct CheckBasesAreDeviceCopyable
-    : CheckBasesAreDeviceCopyable<T, NumBasesToCheck - 1> {
-  using BaseT = decltype(__builtin_base_type(T, NumBasesToCheck - 1));
-  static_assert(is_device_copyable_v<BaseT> ||
-                    detail::IsDeprecatedDeviceCopyable<BaseT>::value,
-                "The specified type is not device copyable");
-};
-
-template <typename T> struct CheckBasesAreDeviceCopyable<T, 0> {};
-
-// All the captures of a lambda or functor of type FuncT passed to a kernel
-// must be is_device_copyable, which extends to bases and fields of FuncT.
-// Fields are captures of lambda/functors and bases are possible base classes
-// of functors also allowed by SYCL.
-// The SYCL-2020 implementation must check each of the fields & bases of the
-// type FuncT, only one level deep, which is enough to see if they are all
-// device copyable by using the result of is_device_copyable returned for them.
-// At this moment though the check also allowes using types for which
-// (is_trivially_copy_constructible && is_trivially_destructible) returns true
-// and (is_device_copyable) returns false. That is the deprecated behavior and
-// is currently/temporarily supported only to not break older SYCL programs.
-template <typename FuncT>
-struct CheckDeviceCopyable
-    : CheckFieldsAreDeviceCopyable<FuncT, __builtin_num_fields(FuncT)>,
-      CheckBasesAreDeviceCopyable<FuncT, __builtin_num_bases(FuncT)> {};
-
-// Below are two specializations for CheckDeviceCopyable when a kernel lambda
-// is wrapped after range rounding optimization.
-template <typename TransformedArgType, int Dims, typename KernelType>
-struct CheckDeviceCopyable<
-    RoundedRangeKernel<TransformedArgType, Dims, KernelType>>
-    : CheckDeviceCopyable<KernelType> {};
-
-template <typename TransformedArgType, int Dims, typename KernelType>
-struct CheckDeviceCopyable<
-    RoundedRangeKernelWithKH<TransformedArgType, Dims, KernelType>>
-    : CheckDeviceCopyable<KernelType> {};
-
-#endif // __SYCL_DEVICE_ONLY__
-} // namespace detail
-
-} // namespace _V1
-} // namespace sycl
diff --git a/sycl/include/sycl/vector.hpp b/sycl/include/sycl/vector.hpp
index 056012fd08cf1..9958ac55ae125 100644
--- a/sycl/include/sycl/vector.hpp
+++ b/sycl/include/sycl/vector.hpp
@@ -1,4 +1,4 @@
-//==---------------- types.hpp --- SYCL types ------------------------------==//
+//==---------------- vector.hpp --- Implements sycl::vec -------------------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -41,10 +41,7 @@
 #include <sycl/detail/type_traits.hpp>         // for is_floating_point
 #include <sycl/detail/vector_convert.hpp>      // for convertImpl
 #include <sycl/detail/vector_traits.hpp>       // for vector_alignment
-#include <sycl/exception.hpp>                  // for make_error_code, errc
 #include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
-#include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
-#include <sycl/multi_ptr.hpp>                  // for multi_ptr
 
 #include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
 
@@ -54,15 +51,9 @@
 #include <cstdint>     // for uint8_t, int16_t, int...
 #include <functional>  // for divides, multiplies
 #include <iterator>    // for pair
-#include <optional>    // for optional
 #include <ostream>     // for operator<<, basic_ost...
-#include <tuple>       // for tuple
 #include <type_traits> // for enable_if_t, is_same
 #include <utility>     // for index_sequence, make_...
-#include <variant>     // for tuple, variant
-
-// 4.10.1: Scalar data types
-// 4.10.2: SYCL vector types
 
 namespace sycl {
 inline namespace _V1 {
@@ -191,85 +182,170 @@ template <typename T> class GetOp {
   DataT operator()(DataT, DataT) { return (DataT)0; }
 };
 
-// Special type for working SwizzleOp with scalars, stores a scalar and gives
-// the scalar at any index. Provides interface is compatible with SwizzleOp
-// operations
-template <typename T> class GetScalarOp {
-public:
-  using DataT = T;
-  GetScalarOp(DataT Data) : m_Data(Data) {}
-  DataT getValue(size_t) const { return m_Data; }
+// Forward declarations
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernel;
+template <typename TransformedArgType, int Dims, typename KernelType>
+class RoundedRangeKernelWithKH;
 
-private:
-  DataT m_Data;
+// Vectors of size 1 are handled separately and therefore 1 is not included in
+// the check below.
+constexpr bool isValidVectorSize(int N) {
+  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
+}
+template <typename T, int N, typename V> struct VecStorage {
+  static_assert(
+      isValidVectorSize(N) || N == 1,
+      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
+      "or 16 are supported");
+  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
 };
 
-template <typename T> struct EqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs == Rhs) ? -1 : 0;
-  }
+#ifdef __SYCL_DEVICE_ONLY__
+// device always has ext vector support, but for huge vectors
+// we switch to std::array, so that we can use a smaller alignment (64)
+// this is to support MSVC, which has a max of 64 for direct params.
+template <typename T, int N> struct VecStorageImpl {
+  static constexpr size_t Num = (N == 3) ? 4 : N;
+  static constexpr size_t Sz = Num * sizeof(T);
+  using DataType =
+      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
+                                std::array<T, Num>>::type;
+  using VectorDataType = T __attribute__((ext_vector_type(N)));
 };
-
-template <typename T> struct NotEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs != Rhs) ? -1 : 0;
-  }
+#else // __SYCL_DEVICE_ONLY__
+template <typename T, int N> struct VecStorageImpl {
+  using DataType = std::array<T, (N == 3) ? 4 : N>;
 };
+#endif // __SYCL_DEVICE_ONLY__
 
-template <typename T> struct GreaterEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs >= Rhs) ? -1 : 0;
-  }
+// Single element bool
+template <> struct VecStorage<bool, 1, void> {
+  using DataType = bool;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = bool;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-template <typename T> struct LessEqualTo {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs <= Rhs) ? -1 : 0;
-  }
+// Multiple element bool
+template <int N>
+struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
+  using DataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
+                                                std::int32_t, std::int64_t>,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-template <typename T> struct GreaterThan {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs > Rhs) ? -1 : 0;
-  }
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+// Single element byte. Multiple elements will propagate through a later
+// specialization.
+template <> struct VecStorage<std::byte, 1, void> {
+  using DataType = std::int8_t;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = std::int8_t;
+#endif // __SYCL_DEVICE_ONLY__
 };
+#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
 
-template <typename T> struct LessThan {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs < Rhs) ? -1 : 0;
-  }
+// Single element signed integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-template <typename T> struct LogicalAnd {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs && Rhs) ? -1 : 0;
-  }
+// Single element unsigned integers
+template <typename T>
+struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-template <typename T> struct LogicalOr {
-  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
-    return (Lhs || Rhs) ? -1 : 0;
-  }
+// Single element floating-point (except half/bfloat16)
+template <typename T>
+struct VecStorage<
+    T, 1,
+    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
+  using DataType = T;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = DataType;
+#endif // __SYCL_DEVICE_ONLY__
 };
-
-template <typename T> struct RShift {
-  constexpr T operator()(const T &Lhs, const T &Rhs) const {
-    return Lhs >> Rhs;
-  }
+// Multiple elements signed/unsigned integers and floating-point (except
+// half/bfloat16)
+template <typename T, int N>
+struct VecStorage<
+    T, N,
+    typename std::enable_if_t<isValidVectorSize(N) &&
+                              (is_sgeninteger_v<T> ||
+                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
+  using DataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType =
+      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
+                              N>::VectorDataType;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-template <typename T> struct LShift {
-  constexpr T operator()(const T &Lhs, const T &Rhs) const {
-    return Lhs << Rhs;
-  }
+// Single element half
+template <> struct VecStorage<half, 1, void> {
+  using DataType = sycl::detail::half_impl::StorageT;
+#ifdef __SYCL_DEVICE_ONLY__
+  using VectorDataType = sycl::detail::half_impl::StorageT;
+#endif // __SYCL_DEVICE_ONLY__
 };
 
-// Forward declarations
-template <typename TransformedArgType, int Dims, typename KernelType>
-class RoundedRangeKernel;
-template <typename TransformedArgType, int Dims, typename KernelType>
-class RoundedRangeKernelWithKH;
+// Multiple elements half
+#if defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
+  };
+#else // defined(__SYCL_DEVICE_ONLY__)
+#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<half, Num, void> {                             \
+    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+  };
+#endif // defined(__SYCL_DEVICE_ONLY__)
 
+__SYCL_DEFINE_HALF_VECSTORAGE(2)
+__SYCL_DEFINE_HALF_VECSTORAGE(3)
+__SYCL_DEFINE_HALF_VECSTORAGE(4)
+__SYCL_DEFINE_HALF_VECSTORAGE(8)
+__SYCL_DEFINE_HALF_VECSTORAGE(16)
+#undef __SYCL_DEFINE_HALF_VECSTORAGE
+
+// Single element bfloat16
+template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
+  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  // using VectorDataType = sycl::ext::oneapi::bfloat16;
+  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+};
+// Multiple elements bfloat16
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
+    using VectorDataType =                                                     \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
+  };
+__SYCL_DEFINE_BF16_VECSTORAGE(2)
+__SYCL_DEFINE_BF16_VECSTORAGE(3)
+__SYCL_DEFINE_BF16_VECSTORAGE(4)
+__SYCL_DEFINE_BF16_VECSTORAGE(8)
+__SYCL_DEFINE_BF16_VECSTORAGE(16)
+#undef __SYCL_DEFINE_BF16_VECSTORAGE
 } // namespace detail
 
 template <typename T> using vec_data = detail::vec_helper<T>;
@@ -277,6 +353,7 @@ template <typename T> using vec_data = detail::vec_helper<T>;
 template <typename T>
 using vec_data_t = typename detail::vec_helper<T>::RetType;
 
+///////////////////////// class sycl::vec /////////////////////////
 /// Provides a cross-patform vector class template that works efficiently on
 /// SYCL devices as well as in host C++ code.
 ///
@@ -1298,6 +1375,7 @@ template <typename Type, int NumElements> class vec {
   friend class detail::SwizzleOp;
   template <typename T1, int T2> friend class vec;
 };
+///////////////////////// class sycl::vec /////////////////////////
 
 #ifdef __cpp_deduction_guides
 // all compilers supporting deduction guides also support fold expressions
@@ -1308,6 +1386,80 @@ vec(T, U...) -> vec<T, sizeof...(U) + 1>;
 
 namespace detail {
 
+// Special type for working SwizzleOp with scalars, stores a scalar and gives
+// the scalar at any index. Provides interface is compatible with SwizzleOp
+// operations
+template <typename T> class GetScalarOp {
+public:
+  using DataT = T;
+  GetScalarOp(DataT Data) : m_Data(Data) {}
+  DataT getValue(size_t) const { return m_Data; }
+
+private:
+  DataT m_Data;
+};
+
+template <typename T> struct EqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs == Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct NotEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs != Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs >= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessEqualTo {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs <= Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct GreaterThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs > Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LessThan {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs < Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalAnd {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs && Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct LogicalOr {
+  constexpr rel_t<T> operator()(const T &Lhs, const T &Rhs) const {
+    return (Lhs || Rhs) ? -1 : 0;
+  }
+};
+
+template <typename T> struct RShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs >> Rhs;
+  }
+};
+
+template <typename T> struct LShift {
+  constexpr T operator()(const T &Lhs, const T &Rhs) const {
+    return Lhs << Rhs;
+  }
+};
+
+///////////////////////// class SwizzleOp /////////////////////////
 // SwizzleOP represents expression templates that operate on vec.
 // Actual computation performed on conversion or assignment operators.
 template <typename VecT, typename OperationLeftT, typename OperationRightT,
@@ -2031,315 +2183,7 @@ class SwizzleOp {
             int... T5>
   friend class SwizzleOp;
 };
+///////////////////////// class SwizzleOp /////////////////////////
 } // namespace detail
-
-namespace detail {
-
-// Vectors of size 1 are handled separately and therefore 1 is not included in
-// the check below.
-constexpr bool isValidVectorSize(int N) {
-  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
-}
-template <typename T, int N, typename V> struct VecStorage {
-  static_assert(
-      isValidVectorSize(N) || N == 1,
-      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
-      "or 16 are supported");
-  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
-};
-
-#ifdef __SYCL_DEVICE_ONLY__
-// device always has ext vector support, but for huge vectors
-// we switch to std::array, so that we can use a smaller alignment (64)
-// this is to support MSVC, which has a max of 64 for direct params.
-template <typename T, int N> struct VecStorageImpl {
-  static constexpr size_t Num = (N == 3) ? 4 : N;
-  static constexpr size_t Sz = Num * sizeof(T);
-  using DataType =
-      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
-                                std::array<T, Num>>::type;
-  using VectorDataType = T __attribute__((ext_vector_type(N)));
-};
-#else // __SYCL_DEVICE_ONLY__
-template <typename T, int N> struct VecStorageImpl {
-  using DataType = std::array<T, (N == 3) ? 4 : N>;
-};
-#endif // __SYCL_DEVICE_ONLY__
-
-// Single element bool
-template <> struct VecStorage<bool, 1, void> {
-  using DataType = bool;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = bool;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple element bool
-template <int N>
-struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
-  using DataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-// Single element byte. Multiple elements will propagate through a later
-// specialization.
-template <> struct VecStorage<std::byte, 1, void> {
-  using DataType = std::int8_t;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = std::int8_t;
-#endif // __SYCL_DEVICE_ONLY__
-};
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-
-// Single element signed integers
-template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element unsigned integers
-template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element floating-point (except half/bfloat16)
-template <typename T>
-struct VecStorage<
-    T, 1,
-    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-// Multiple elements signed/unsigned integers and floating-point (except
-// half/bfloat16)
-template <typename T, int N>
-struct VecStorage<
-    T, N,
-    typename std::enable_if_t<isValidVectorSize(N) &&
-                              (is_sgeninteger_v<T> ||
-                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
-  using DataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element half
-template <> struct VecStorage<half, 1, void> {
-  using DataType = sycl::detail::half_impl::StorageT;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = sycl::detail::half_impl::StorageT;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple elements half
-#if defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
-    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
-  };
-#else // defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
-  };
-#endif // defined(__SYCL_DEVICE_ONLY__)
-
-__SYCL_DEFINE_HALF_VECSTORAGE(2)
-__SYCL_DEFINE_HALF_VECSTORAGE(3)
-__SYCL_DEFINE_HALF_VECSTORAGE(4)
-__SYCL_DEFINE_HALF_VECSTORAGE(8)
-__SYCL_DEFINE_HALF_VECSTORAGE(16)
-#undef __SYCL_DEFINE_HALF_VECSTORAGE
-
-// Single element bfloat16
-template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
-  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-  // using VectorDataType = sycl::ext::oneapi::bfloat16;
-  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-};
-// Multiple elements bfloat16
-#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
-    using VectorDataType =                                                     \
-        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
-  };
-__SYCL_DEFINE_BF16_VECSTORAGE(2)
-__SYCL_DEFINE_BF16_VECSTORAGE(3)
-__SYCL_DEFINE_BF16_VECSTORAGE(4)
-__SYCL_DEFINE_BF16_VECSTORAGE(8)
-__SYCL_DEFINE_BF16_VECSTORAGE(16)
-#undef __SYCL_DEFINE_BF16_VECSTORAGE
-} // namespace detail
-
-/// This macro must be defined to 1 when SYCL implementation allows user
-/// applications to explicitly declare certain class types as device copyable
-/// by adding specializations of is_device_copyable type trait class.
-#define SYCL_DEVICE_COPYABLE 1
-
-/// is_device_copyable is a user specializable class template to indicate
-/// that a type T is device copyable, which means that SYCL implementation
-/// may copy objects of the type T between host and device or between two
-/// devices.
-/// Specializing is_device_copyable such a way that
-/// is_device_copyable_v<T> == true on a T that does not satisfy all
-/// the requirements of a device copyable type is undefined behavior.
-template <typename T> struct is_device_copyable;
-
-namespace detail {
-template <typename T, typename = void>
-struct is_device_copyable_impl : std::is_trivially_copyable<T> {};
-
-template <typename T>
-struct is_device_copyable_impl<
-    T, std::enable_if_t<!std::is_same_v<T, std::remove_cv_t<T>>>>
-    // Cannot express this "recursion" (to take user's partial non-cv
-    // specializations into account) without this helper struct.
-    : is_device_copyable<std::remove_cv_t<T>> {};
-} // namespace detail
-
-template <typename T>
-struct is_device_copyable : detail::is_device_copyable_impl<T> {};
-
-// std::array<T, 0> is implicitly device copyable type.
-template <typename T>
-struct is_device_copyable<std::array<T, 0>> : std::true_type {};
-
-// std::array<T, N> is implicitly device copyable type if T is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<std::array<T, N>> : is_device_copyable<T> {};
-
-// std::optional<T> is implicitly device copyable type if T is device copyable.
-template <typename T>
-struct is_device_copyable<std::optional<T>> : is_device_copyable<T> {};
-
-// std::pair<T1, T2> is implicitly device copyable type if T1 and T2 are device
-// copyable.
-template <typename T1, typename T2>
-struct is_device_copyable<std::pair<T1, T2>>
-    : std::bool_constant<is_device_copyable<T1>::value &&
-                         is_device_copyable<T2>::value> {};
-
-// std::tuple<Ts...> is implicitly device copyable type if each type T of Ts...
-// is device copyable.
-template <typename... Ts>
-struct is_device_copyable<std::tuple<Ts...>>
-    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
-
-// std::variant<Ts...> is implicitly device copyable type if each type T of
-// Ts... is device copyable.
-template <typename... Ts>
-struct is_device_copyable<std::variant<Ts...>>
-    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
-
-// marray is device copyable if element type is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<sycl::marray<T, N>> : is_device_copyable<T> {};
-
-// array is device copyable if element type is device copyable.
-template <typename T, std::size_t N>
-struct is_device_copyable<T[N]> : is_device_copyable<T> {};
-
-template <typename T>
-inline constexpr bool is_device_copyable_v = is_device_copyable<T>::value;
-
-namespace detail {
-template <typename T, typename = void>
-struct IsDeprecatedDeviceCopyable : std::false_type {};
-
-// TODO: using C++ attribute [[deprecated]] or the macro __SYCL2020_DEPRECATED
-// does not produce expected warning message for the type 'T'.
-template <typename T>
-struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
-    IsDeprecatedDeviceCopyable<
-        T, std::enable_if_t<std::is_trivially_copy_constructible_v<T> &&
-                            std::is_trivially_destructible_v<T> &&
-                            !is_device_copyable_v<T>>> : std::true_type {};
-
-template <typename T, int N>
-struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
-    IsDeprecatedDeviceCopyable<T[N]> : IsDeprecatedDeviceCopyable<T> {};
-
-#ifdef __SYCL_DEVICE_ONLY__
-// Checks that the fields of the type T with indices 0 to (NumFieldsToCheck -
-// 1) are device copyable.
-template <typename T, unsigned NumFieldsToCheck>
-struct CheckFieldsAreDeviceCopyable
-    : CheckFieldsAreDeviceCopyable<T, NumFieldsToCheck - 1> {
-  using FieldT = decltype(__builtin_field_type(T, NumFieldsToCheck - 1));
-  static_assert(is_device_copyable_v<FieldT> ||
-                    detail::IsDeprecatedDeviceCopyable<FieldT>::value,
-                "The specified type is not device copyable");
-};
-
-template <typename T> struct CheckFieldsAreDeviceCopyable<T, 0> {};
-
-// Checks that the base classes of the type T with indices 0 to
-// (NumFieldsToCheck - 1) are device copyable.
-template <typename T, unsigned NumBasesToCheck>
-struct CheckBasesAreDeviceCopyable
-    : CheckBasesAreDeviceCopyable<T, NumBasesToCheck - 1> {
-  using BaseT = decltype(__builtin_base_type(T, NumBasesToCheck - 1));
-  static_assert(is_device_copyable_v<BaseT> ||
-                    detail::IsDeprecatedDeviceCopyable<BaseT>::value,
-                "The specified type is not device copyable");
-};
-
-template <typename T> struct CheckBasesAreDeviceCopyable<T, 0> {};
-
-// All the captures of a lambda or functor of type FuncT passed to a kernel
-// must be is_device_copyable, which extends to bases and fields of FuncT.
-// Fields are captures of lambda/functors and bases are possible base classes
-// of functors also allowed by SYCL.
-// The SYCL-2020 implementation must check each of the fields & bases of the
-// type FuncT, only one level deep, which is enough to see if they are all
-// device copyable by using the result of is_device_copyable returned for them.
-// At this moment though the check also allowes using types for which
-// (is_trivially_copy_constructible && is_trivially_destructible) returns true
-// and (is_device_copyable) returns false. That is the deprecated behavior and
-// is currently/temporarily supported only to not break older SYCL programs.
-template <typename FuncT>
-struct CheckDeviceCopyable
-    : CheckFieldsAreDeviceCopyable<FuncT, __builtin_num_fields(FuncT)>,
-      CheckBasesAreDeviceCopyable<FuncT, __builtin_num_bases(FuncT)> {};
-
-// Below are two specializations for CheckDeviceCopyable when a kernel lambda
-// is wrapped after range rounding optimization.
-template <typename TransformedArgType, int Dims, typename KernelType>
-struct CheckDeviceCopyable<
-    RoundedRangeKernel<TransformedArgType, Dims, KernelType>>
-    : CheckDeviceCopyable<KernelType> {};
-
-template <typename TransformedArgType, int Dims, typename KernelType>
-struct CheckDeviceCopyable<
-    RoundedRangeKernelWithKH<TransformedArgType, Dims, KernelType>>
-    : CheckDeviceCopyable<KernelType> {};
-
-#endif // __SYCL_DEVICE_ONLY__
-} // namespace detail
-
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index f1bf7fcfcc24d..7b23daf692b37 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -26,10 +26,6 @@
 #error "SYCL device compiler is built without ext_vector_type support"
 #endif
 
-#if defined(__SYCL_DEVICE_ONLY__)
-#define __SYCL_USE_EXT_VECTOR_TYPE__
-#endif
-
 #include <sycl/access/access.hpp>              // for decorated, address_space
 #include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
 #include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
@@ -94,6 +90,30 @@ using select_apply_cl_t = std::conditional_t<
     std::conditional_t<sizeof(_IN) == 2, T16,
                        std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
 
+// Helper function to bit_cast one type to another.
+template <typename FromType, typename ToType>
+static constexpr ToType BitCast(const FromType &Value) {
+
+  static_assert(sizeof(FromType) == sizeof(ToType),
+                "BitCast: sizes of types are different");
+
+#ifdef __SYCL_BITCAST_IS_CONSTEXPR
+  return sycl::bit_cast<ToType>(Value);
+#else
+  // Awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+  // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+  // but neither available yet.
+  union {
+    const FromType from;
+    ToType to;
+  } result = {};
+  result.from = Value;
+  return result.to;
+#endif
+}
+
+/* Helper functions to get and set values in vec, depdending on the underlying
++ * data type. */
 template <typename T> struct vec_helper {
   using RetType = T;
   static constexpr RetType get(T value) { return value; }
@@ -110,34 +130,13 @@ template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
   using RetType = sycl::ext::oneapi::bfloat16;
   using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
   static constexpr RetType get(BFloat16StorageT value) {
-#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
-    return sycl::bit_cast<RetType>(value);
-#else
-    // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
-    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
-    // but neither available yet.
-    union {
-      sycl::ext::oneapi::bfloat16 bf16;
-      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
-    } result = {};
-    result.storage = value;
-    return result.bf16;
-#endif
+    return BitCast<BFloat16StorageT, RetType>(value);
   }
 
   static constexpr RetType get(RetType value) { return value; }
 
   static constexpr BFloat16StorageT set(RetType value) {
-#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
-    return sycl::bit_cast<BFloat16StorageT>(value);
-#else
-    union {
-      sycl::ext::oneapi::bfloat16 bf16;
-      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
-    } result = {};
-    result.bf16 = value;
-    return result.storage;
-#endif
+    return BitCast<RetType, BFloat16StorageT>(value);
   }
 };
 
@@ -208,9 +207,8 @@ template <typename T, int N, typename V> struct VecStorage {
 template <typename T, int N> struct VecStorageImpl {
   static constexpr size_t Num = (N == 3) ? 4 : N;
   static constexpr size_t Sz = Num * sizeof(T);
-  using DataType =
-      typename std::conditional<Sz <= 64, T __attribute__((ext_vector_type(N))),
-                                std::array<T, Num>>::type;
+
+  using DataType = std::array<T, (N == 3) ? 4 : N>;
   using VectorDataType = T __attribute__((ext_vector_type(N)));
 };
 #else  // __SYCL_DEVICE_ONLY__
@@ -307,18 +305,18 @@ template <> struct VecStorage<half, 1, void> {
 };
 
 // Multiple elements half
-#if defined(__SYCL_DEVICE_ONLY__)
+#if __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+    using DataType = sycl::detail::half_impl::Vec##Num##DeviceStorageT;        \
     using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
   };
-#else // defined(__SYCL_DEVICE_ONLY__)
+#else // __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
     using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
   };
-#endif // defined(__SYCL_DEVICE_ONLY__)
+#endif // __SYCL_DEVICE_ONLY__
 
 __SYCL_DEFINE_HALF_VECSTORAGE(2)
 __SYCL_DEFINE_HALF_VECSTORAGE(3)
@@ -334,12 +332,20 @@ template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
   using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
 };
 // Multiple elements bfloat16
+#ifndef __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
     using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
+  };
+#else
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType =                                                           \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##DeviceStorageT;             \
     using VectorDataType =                                                     \
         sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
   };
+#endif
 __SYCL_DEFINE_BF16_VECSTORAGE(2)
 __SYCL_DEFINE_BF16_VECSTORAGE(3)
 __SYCL_DEFINE_BF16_VECSTORAGE(4)
@@ -365,11 +371,6 @@ template <typename Type, int NumElements> class vec {
   // in the class, so vec<float, 16> should be equal to float16 in memory.
   using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
 
-  static constexpr bool IsHostHalf =
-      std::is_same_v<DataT, sycl::detail::half_impl::half> &&
-      std::is_same_v<sycl::detail::half_impl::StorageT,
-                     sycl::detail::host_half_impl::half>;
-
   static constexpr bool IsBfloat16 =
       std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
 
@@ -378,19 +379,9 @@ template <typename Type, int NumElements> class vec {
   static constexpr bool IsSizeGreaterThanMaxAlign =
       (Sz > detail::MaxVecAlignment);
 
-  // TODO: There is no support for vector half type on host yet.
-  // Also, when Sz is greater than alignment, we use std::array instead of
-  // vector extension. This is for MSVC compatibility, which has a max alignment
-  // of 64 for direct params. If we drop MSVC, we can have alignment the same as
-  // size and use vector extensions for all sizes.
-  static constexpr bool IsUsingArrayOnDevice =
-      (IsHostHalf || IsBfloat16 || IsSizeGreaterThanMaxAlign);
-
-#if defined(__SYCL_DEVICE_ONLY__)
-  static constexpr bool NativeVec = NumElements > 1 && !IsUsingArrayOnDevice;
+#ifdef __SYCL_DEVICE_ONLY__
   static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
 #else
-  static constexpr bool NativeVec = false;
   static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
 #endif
 
@@ -556,6 +547,7 @@ template <typename Type, int NumElements> class vec {
   using value_type = DataT;
   using rel_t = detail::rel_t<DataT>;
 #ifdef __SYCL_DEVICE_ONLY__
+  // Type used for passing sycl::vec to SPIRV builtins.
   using vector_t =
       typename detail::VecStorage<DataT, NumElements>::VectorDataType;
 #endif // __SYCL_DEVICE_ONLY__
@@ -577,49 +569,8 @@ template <typename Type, int NumElements> class vec {
     return *this;
   }
 
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  template <typename T = void>
-  using EnableIfNotHostHalf = typename std::enable_if_t<!IsHostHalf, T>;
-
-  template <typename T = void>
-  using EnableIfHostHalf = typename std::enable_if_t<IsHostHalf, T>;
-
-  template <typename T = void>
-  using EnableIfUsingArrayOnDevice =
-      typename std::enable_if_t<IsUsingArrayOnDevice, T>;
-
-  template <typename T = void>
-  using EnableIfNotUsingArrayOnDevice =
-      typename std::enable_if_t<!IsUsingArrayOnDevice, T>;
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-  template <typename T = void>
-  using EnableIfUsingArray =
-      typename std::enable_if_t<IsUsingArrayOnDevice || IsUsingArrayOnHost, T>;
-
-  template <typename T = void>
-  using EnableIfNotUsingArray =
-      typename std::enable_if_t<!IsUsingArrayOnDevice && !IsUsingArrayOnHost,
-                                T>;
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-
-  template <typename Ty = DataT>
-  explicit constexpr vec(const EnableIfNotUsingArrayOnDevice<Ty> &arg)
-      : m_Data{DataType(vec_data<Ty>::get(arg))} {}
-
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) {
-    m_Data = (DataType)vec_data<Ty>::get(Rhs);
-    return *this;
-  }
-
-  template <typename Ty = DataT>
-  explicit constexpr vec(const EnableIfUsingArrayOnDevice<Ty> &arg)
+#ifdef __SYCL_DEVICE_ONLY__
+  explicit constexpr vec(const DataT &arg)
       : vec{detail::RepeatValue<NumElements>(
                 static_cast<vec_data_t<DataT>>(arg)),
             std::make_index_sequence<NumElements>()} {}
@@ -629,13 +580,13 @@ template <typename Type, int NumElements> class vec {
       std::is_fundamental_v<vec_data_t<Ty>> ||
           detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
-  operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
+  operator=(const Ty & Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
     }
     return *this;
   }
-#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+#else  // __SYCL_DEVICE_ONLY__
   explicit constexpr vec(const DataT &arg)
       : vec{detail::RepeatValue<NumElements>(
                 static_cast<vec_data_t<DataT>>(arg)),
@@ -652,58 +603,7 @@ template <typename Type, int NumElements> class vec {
     }
     return *this;
   }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
-
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  // Optimized naive constructors with NumElements of DataT values.
-  // We don't expect compilers to optimize vararg recursive functions well.
-
-  // Helper type to make specific constructors available only for specific
-  // number of elements.
-  template <int IdxNum, typename T = void>
-  using EnableIfMultipleElems = typename std::enable_if_t<
-      std::is_convertible_v<T, DataT> && NumElements == IdxNum, DataT>;
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<2, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<3, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<4, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const Ty Arg3)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<8, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const DataT Arg3, const DataT Arg4, const DataT Arg5,
-                const DataT Arg6, const DataT Arg7)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
-               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
-               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7)} {}
-  template <typename Ty = DataT>
-  constexpr vec(const EnableIfMultipleElems<16, Ty> Arg0,
-                const EnableIfNotUsingArrayOnDevice<Ty> Arg1, const DataT Arg2,
-                const DataT Arg3, const DataT Arg4, const DataT Arg5,
-                const DataT Arg6, const DataT Arg7, const DataT Arg8,
-                const DataT Arg9, const DataT ArgA, const DataT ArgB,
-                const DataT ArgC, const DataT ArgD, const DataT ArgE,
-                const DataT ArgF)
-      : m_Data{vec_data<Ty>::get(Arg0), vec_data<Ty>::get(Arg1),
-               vec_data<Ty>::get(Arg2), vec_data<Ty>::get(Arg3),
-               vec_data<Ty>::get(Arg4), vec_data<Ty>::get(Arg5),
-               vec_data<Ty>::get(Arg6), vec_data<Ty>::get(Arg7),
-               vec_data<Ty>::get(Arg8), vec_data<Ty>::get(Arg9),
-               vec_data<Ty>::get(ArgA), vec_data<Ty>::get(ArgB),
-               vec_data<Ty>::get(ArgC), vec_data<Ty>::get(ArgD),
-               vec_data<Ty>::get(ArgE), vec_data<Ty>::get(ArgF)} {}
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+#endif // __SYCL_DEVICE_ONLY__
 
   // Constructor from values of base type or vec of base type. Checks that
   // base types are match and that the NumElements == sum of lengths of args.
@@ -718,20 +618,20 @@ template <typename Type, int NumElements> class vec {
             typename =
                 typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
                                           !std::is_same_v<vector_t_, DataT>>>
-  constexpr vec(vector_t openclVector) {
-    if constexpr (!IsUsingArrayOnDevice) {
-      m_Data = openclVector;
-    } else {
-      m_Data = bit_cast<DataType>(openclVector);
-    }
+  constexpr vec(vector_t_ openclVector) {
+    m_Data = detail::BitCast<vector_t, DataType>(openclVector);
   }
 
+  /* @SYCL2020
+   * Available only when: compiled for the device.
+   * Converts this SYCL vec instance to the underlying backend-native vector
+   * type defined by vector_t.
+   */
   operator vector_t() const {
-    if constexpr (!IsUsingArrayOnDevice) {
+    if constexpr (NumElements == 1) {
       return m_Data;
     } else {
-      auto ptr = bit_cast<const vector_t *>((&m_Data)->data());
-      return *ptr;
+      return sycl::bit_cast<vector_t>(m_Data);
     }
   }
 #endif // __SYCL_DEVICE_ONLY__
@@ -793,22 +693,25 @@ template <typename Type, int NumElements> class vec {
     using OpenCLR = detail::ConvertToOpenCLType_t<R>;
     vec<convertT, NumElements> Result;
 
-#if defined(__SYCL_DEVICE_ONLY__)
+#ifdef __SYCL_DEVICE_ONLY__
     using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
     using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
+
+    auto NativeVector = sycl::bit_cast<vector_t>(m_Data);
+    using ConvertTVecType = typename vec<convertT, NumElements>::vector_t;
+
     // Whole vector conversion can only be done, if:
     constexpr bool canUseNativeVectorConvert =
 #ifdef __NVPTX__
         // - we are not on CUDA, see intel/llvm#11840
         false &&
 #endif
-        // - both vectors are represented using native vector types;
-        NativeVec && vec<convertT, NumElements>::NativeVec &&
+        NumElements > 1 &&
         // - vec storage has an equivalent OpenCL native vector it is implicitly
         //   convertible to. There are some corner cases where it is not the
         //   case with char, long and long long types.
-        std::is_convertible_v<decltype(m_Data), OpenCLVecT> &&
-        std::is_convertible_v<decltype(Result.m_Data), OpenCLVecR> &&
+        std::is_convertible_v<vector_t, OpenCLVecT> &&
+        std::is_convertible_v<ConvertTVecType, OpenCLVecR> &&
         // - it is not a signed to unsigned (or vice versa) conversion
         //   see comments within 'convertImpl' for more details;
         !detail::is_sint_to_from_uint<T, R>::value &&
@@ -819,10 +722,11 @@ template <typename Type, int NumElements> class vec {
         //   right results here;
         !std::is_same_v<convertT, bool>;
     if constexpr (canUseNativeVectorConvert) {
-      Result.m_Data = detail::convertImpl<T, R, roundingMode, NumElements,
-                                          OpenCLVecT, OpenCLVecR>(m_Data);
+      Result.m_Data = sycl::bit_cast<decltype(Result.m_Data)>(
+          detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
+                              OpenCLVecR>(NativeVector));
     } else
-#endif // defined(__SYCL_DEVICE_ONLY__)
+#endif // __SYCL_DEVICE_ONLY__
     {
       // Otherwise, we fallback to per-element conversion:
       for (size_t I = 0; I < NumElements; ++I) {
@@ -869,8 +773,6 @@ template <typename Type, int NumElements> class vec {
   // not changed.
   //
   // Implement operator [] in the same way for host and device.
-  // TODO: change host side implementation when underlying type for host side
-  // will be changed to std::array.
   // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
   // aggressively optimized. Specializing with noinline to avoid as workaround.
 
@@ -987,16 +889,21 @@ template <typename Type, int NumElements> class vec {
 #error "Undefine __SYCL_BINOP macro"
 #endif
 
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+#ifdef __SYCL_DEVICE_ONLY__
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret;                                                                   \
-    if constexpr (IsUsingArrayOnDevice) {                                      \
+    if constexpr (IsBfloat16 ||                                                \
+                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
       for (size_t I = 0; I < NumElements; ++I) {                               \
         Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
       }                                                                        \
     } else {                                                                   \
-      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
+      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
+      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
+      Ret = vec<DataT, NumElements>(                                           \
+          (typename vec<DataT, NumElements>::vector_t)(                        \
+              ExtVecLhs BINOP ExtVecRhs));                                     \
       if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
         Ret.ConvertToDataT();                                                  \
       }                                                                        \
@@ -1020,17 +927,15 @@ template <typename Type, int NumElements> class vec {
     return Lhs;                                                                \
   }
 
-#else // __SYCL_USE_EXT_VECTOR_TYPE__
+#else // __SYCL_DEVICE_ONLY__
 
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret{};                                                                 \
-    if constexpr (NativeVec)                                                   \
-      Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data;                                \
-    else                                                                       \
-      for (size_t I = 0; I < NumElements; ++I)                                 \
-        Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue(             \
-                            I)) BINOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+    for (size_t I = 0; I < NumElements; ++I)                                   \
+      Ret.setValue(I,                                                          \
+                   (DataT)(vec_data<DataT>::get(Lhs.getValue(I))               \
+                               BINOP vec_data<DataT>::get(Rhs.getValue(I))));  \
     return Ret;                                                                \
   }                                                                            \
   friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
@@ -1049,8 +954,7 @@ template <typename Type, int NumElements> class vec {
     Lhs = Lhs BINOP vec(Rhs);                                                  \
     return Lhs;                                                                \
   }
-
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+#endif // __SYCL_DEVICE_ONLY__
 
   __SYCL_BINOP(+, +=, true)
   __SYCL_BINOP(-, -=, true)
@@ -1085,11 +989,10 @@ template <typename Type, int NumElements> class vec {
   friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
                                                    const vec & Rhs) {          \
     vec<rel_t, NumElements> Ret{};                                             \
-    /* This special case is needed since there are no standard operator||   */ \
-    /* or operator&& functions for std::array.                              */ \
-    if constexpr (IsUsingArrayOnDevice &&                                      \
-                  (std::string_view(#RELLOGOP) == "||" ||                      \
-                   std::string_view(#RELLOGOP) == "&&")) {                     \
+    /* ext_vector_type does not support bfloat16 or half, so for these   */    \
+    /* we do element-by-element operation on the underlying std::array.  */    \
+    if constexpr (IsBfloat16 ||                                                \
+                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
       for (size_t I = 0; I < NumElements; ++I) {                               \
         /* We cannot use SetValue here as the operator is not a friend of*/    \
         /* Ret on Windows. */                                                  \
@@ -1097,9 +1000,11 @@ template <typename Type, int NumElements> class vec {
             Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
       }                                                                        \
     } else {                                                                   \
+      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
+      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
-              Lhs.m_Data RELLOGOP Rhs.m_Data));                                \
+              ExtVecLhs RELLOGOP ExtVecRhs));                                  \
       if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
         Ret *= -1;                                                             \
     }                                                                          \
@@ -1169,25 +1074,39 @@ template <typename Type, int NumElements> class vec {
   // operator~() available only when: dataT != float && dataT != double
   // && dataT != half
   friend vec operator~(const vec &Rhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I) {
-        Ret.setValue(I, ~Rhs.getValue(I));
-      }
-      return Ret;
-    } else {
-      vec Ret{(typename vec::DataType) ~Rhs.m_Data};
-      if constexpr (std::is_same_v<Type, bool>) {
-        Ret.ConvertToDataT();
-      }
-      return Ret;
+#ifdef __SYCL_DEVICE_ONLY__
+    auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
+    vec Ret{~extVec};
+    if constexpr (std::is_same_v<Type, bool>) {
+      Ret.ConvertToDataT();
+    }
+    return Ret;
+#else
+    vec Ret{};
+    for (size_t I = 0; I < NumElements; ++I) {
+      Ret.setValue(I, ~Rhs.getValue(I));
     }
+    return Ret;
+#endif
   }
 
   // operator!
   friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
+    vec Ret{};
+#ifdef __SYCL_DEVICE_ONLY__
+    if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
+                  !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+                  !std::is_same_v<DataT, std::byte>)
+#else
+                  1)
+#endif // defined(_HAS_STD_BYTE)
+    {
+      auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
+      return vec<detail::rel_t<DataT>, NumElements>{!extVec};
+    } else
+#endif // __SYCL_DEVICE_ONLY__
+    {
       for (size_t I = 0; I < NumElements; ++I) {
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
         // std::byte neither supports ! unary op or casting, so special handling
@@ -1201,23 +1120,21 @@ template <typename Type, int NumElements> class vec {
         }
       }
       return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
-    } else {
-      return vec{(typename vec<DataT, NumElements>::DataType) !Rhs.m_Data}
-          .template as<vec<detail::rel_t<DataT>, NumElements>>();
     }
   }
 
   // operator +
   friend vec operator+(const vec &Lhs) {
-    if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
-      vec Ret{};
-      for (size_t I = 0; I < NumElements; ++I)
-        Ret.setValue(
-            I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
-      return Ret;
-    } else {
-      return vec{+Lhs.m_Data};
-    }
+#ifdef __SYCL_DEVICE_ONLY__
+    auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
+    return vec{+extVec};
+#else
+    vec Ret{};
+    for (size_t I = 0; I < NumElements; ++I)
+      Ret.setValue(
+          I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
+    return Ret;
+#endif
   }
 
   // operator -
@@ -1234,18 +1151,20 @@ template <typename Type, int NumElements> class vec {
         oneapi::bfloat16 w = -v;
         Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
       }
-    } else if constexpr (IsUsingArrayOnDevice || IsUsingArrayOnHost) {
+    } else {
+#ifndef __SYCL_DEVICE_ONLY__
       for (size_t I = 0; I < NumElements; ++I)
         Ret.setValue(
             I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
-      return Ret;
-    } else {
-      Ret = vec{-Lhs.m_Data};
+#else
+      auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
+      Ret = vec{-extVec};
       if constexpr (std::is_same_v<Type, bool>) {
         Ret.ConvertToDataT();
       }
-      return Ret;
+#endif
     }
+    return Ret;
   }
 
   // OP is: &&, ||
@@ -1258,29 +1177,20 @@ template <typename Type, int NumElements> class vec {
 private:
   // Generic method that execute "Operation" on underlying values.
 
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
-  template <template <typename> class Operation,
-            typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements>
-  operatorHelper(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataType> Op;
-    Result.m_Data = Op(m_Data, Rhs.m_Data);
-    return Result;
-  }
-
+#ifdef __SYCL_DEVICE_ONLY__
   template <template <typename> class Operation,
             typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements>
-  operatorHelper(const EnableIfUsingArrayOnDevice<Ty> &Rhs) const {
+  vec<DataT, NumElements> operatorHelper(const Ty &Rhs) const {
     vec<DataT, NumElements> Result;
     Operation<DataT> Op;
-    for (size_t I = 0; I < NumElements; ++I) {
-      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
-    }
+    // Typecast to ext_vector_type, carryout the operation, and type cast back.
+    // Compiler optimizations will remove redundant casts.
+    auto OpResult = Op(sycl::bit_cast<vector_t>(m_Data),
+                       sycl::bit_cast<vector_t>(Rhs.m_Data));
+    Result.m_Data = sycl::bit_cast<DataType>(OpResult);
     return Result;
   }
-#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+#else  // __SYCL_DEVICE_ONLY__
   template <template <typename> class Operation>
   vec<DataT, NumElements>
   operatorHelper(const vec<DataT, NumElements> &Rhs) const {
@@ -1291,37 +1201,25 @@ template <typename Type, int NumElements> class vec {
     }
     return Result;
   }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+#endif // __SYCL_DEVICE_ONLY__
 
   // setValue and getValue should be able to operate on different underlying
   // types: enum cl_float#N , builtin vector float#N, builtin type float.
   // These versions are for N > 1.
-#ifdef __SYCL_USE_EXT_VECTOR_TYPE__
+#ifdef __SYCL_DEVICE_ONLY__
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
+  constexpr void setValue(Ty Index, const DataT &Value,
                           int) {
     m_Data[Index] = vec_data<DataT>::set(Value);
   }
 
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
+  constexpr DataT getValue(Ty Index, int) const {
     return vec_data<DataT>::get(m_Data[Index]);
   }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
-    m_Data.s[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
-    return vec_data<DataT>::get(m_Data.s[Index]);
-  }
-#else  // __SYCL_USE_EXT_VECTOR_TYPE__
+#else  // __SYCL_DEVICE_ONLY__
   template <int Num = NumElements,
             typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(int Index, const DataT &Value, int) {
@@ -1333,7 +1231,7 @@ template <typename Type, int NumElements> class vec {
   constexpr DataT getValue(int Index, int) const {
     return vec_data<DataT>::get(m_Data[Index]);
   }
-#endif // __SYCL_USE_EXT_VECTOR_TYPE__
+#endif // __SYCL_DEVICE_ONLY__
 
   // N==1 versions, used by host and device. Shouldn't trailing type be int?
   template <int Num = NumElements,

From 34fdbc62a988a26d6b6f00a597dc4c5b31747db4 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 24 Apr 2024 15:06:24 -0700
Subject: [PATCH 31/79] Fix no line at EOF

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

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 0fac92c7636b4..9aac1005cce86 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -107,4 +107,5 @@ struct CheckDeviceCopyable<
 #endif // __SYCL_DEVICE_ONLY__
 } // namespace detail
 } // namespace _V1
-} // namespace sycl
\ No newline at end of file
+} // namespace sycl
+

From 8c285a8713d686643eb53ee66894776cca49c2ca Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 25 Apr 2024 13:21:48 -0700
Subject: [PATCH 32/79] Add device code tests for vector operations.

---
 .../vector/vector_math_ops.cpp                | 157 ++++++++++++++++++
 .../vector/vector_storage.cpp                 | 123 ++++++++++++++
 2 files changed, 280 insertions(+)
 create mode 100644 sycl/test/check_device_code/vector/vector_math_ops.cpp
 create mode 100644 sycl/test/check_device_code/vector/vector_storage.cpp

diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
new file mode 100644
index 0000000000000..bac3a3077f06d
--- /dev/null
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -0,0 +1,157 @@
+// RUN: %clangxx -fsycl-device-only -S -O3 -Xclang -emit-llvm -o - %s | FileCheck %s
+
+// This test checks the device code for various math operations on sycl::vec.
+#include <sycl/sycl.hpp>
+
+using namespace sycl;
+
+template <typename T>
+using rel_t = std::conditional_t<
+    sizeof(T) == 1, int8_t,
+    std::conditional_t<
+        sizeof(T) == 2, int16_t,
+        std::conditional_t<sizeof(T) == 4, int32_t,
+                           std::conditional_t<sizeof(T) == 8, int64_t, void>>>>;
+
+// For testing binary operations
+#define CHECKBINOP(Q, T, N, IS_RELOP, OP, SUFFIX)                              \
+  {                                                                            \
+    using VecT = sycl::vec<T, N>;                                              \
+    using ResT = sycl::vec<std::conditional_t<IS_RELOP, rel_t<T>, T>, N>;      \
+    VecT In##SUFFIX##VecA{static_cast<T>(5)};                                  \
+    VecT In##SUFFIX##VecB{static_cast<T>(6)};                                  \
+    {                                                                          \
+      VecT OutVecsDevice[1];                                                   \
+      sycl::buffer<VecT, 1> OutVecsBuff{OutVecsDevice, 1};                     \
+      Q.submit([&](sycl::handler &CGH) {                                       \
+        sycl::accessor OutVecsAcc{OutVecsBuff, CGH, sycl::read_write};         \
+        CGH.single_task([=]() {                                                \
+          auto OutVec1 = In##SUFFIX##VecA OP In##SUFFIX##VecB;                 \
+          static_assert(std::is_same_v<decltype(OutVec1), ResT>);              \
+          OutVecsAcc[0] = OutVec1;                                             \
+        });                                                                    \
+      });                                                                      \
+    }                                                                          \
+  }
+
+// For testing unary operators
+#define CHECKUOP(Q, T, N, IS_RELOP, OP, SUFFIX, REF)                           \
+  {                                                                            \
+    using VecT = sycl::vec<T, N>;                                              \
+    using ResT = sycl::vec<std::conditional_t<IS_RELOP, rel_t<T>, T>, N>;      \
+    VecT In##SUFFIX##VecA{static_cast<T>(REF)};                                \
+    {                                                                          \
+      VecT OutVecsDevice[1];                                                   \
+      sycl::buffer<VecT, 1> OutVecsBuff{OutVecsDevice, 1};                     \
+      Q.submit([&](sycl::handler &CGH) {                                       \
+        sycl::accessor OutVecsAcc{OutVecsBuff, CGH, sycl::read_write};         \
+        CGH.single_task([=]() {                                                \
+          auto OutVec1 = OP In##SUFFIX##VecA;                                  \
+          static_assert(std::is_same_v<decltype(OutVec1), ResT>);              \
+          OutVecsAcc[0] = OutVec1;                                             \
+        });                                                                    \
+      });                                                                      \
+    }                                                                          \
+  }
+
+int main() {
+
+  queue Q;
+
+  // Check device code for binary arithmetic operations.
+  // int, char, and float are handled in the same manner.
+  {
+    // CHECK: %add{{.*}} = add <2 x i32> %{{.*}}
+    CHECKBINOP(Q, int, 2, false, +, INT)
+
+    // CHECK: %add{{.*}} = add <2 x i8> %{{.*}}
+    CHECKBINOP(Q, std::byte, 2, false, +, BYTE)
+
+    // CHECK: %add{{.*}} = add <2 x i8> %{{.*}}
+    // CHECK: for.body{{.*}}
+    // CHECK: {{.*}} = icmp ne i8 %{{.*}}, 0
+    CHECKBINOP(Q, bool, 2, false, +, BOOL)
+
+    // CHECK: %add{{.*}} = fadd <2 x half> %{{.*}}
+    CHECKBINOP(Q, sycl::half, 2, false, +, HALF)
+
+    // CHECK: for.body{{.*}}
+    // CHECK: {{.*}}ConvertBF16ToFINTEL{{.*}}
+    // CHECK: {{.*}}ConvertBF16ToFINTEL{{.*}}
+    // CHECK: %add{{.*}} = fadd float %{{.*}}, %{{.*}}
+    // CHECK: {{.*}}ConvertFToBF16INTEL{{.*}}
+    CHECKBINOP(Q, ext::oneapi::bfloat16, 2, false, +, BF)
+  }
+
+  // Check device code for binary logical operations.
+  {
+    // CHECK: icmp sgt <2 x i32> %{{.*}}
+    // CHECK: sext <2 x i1> %{{.*}} to <2 x i32>
+    CHECKBINOP(Q, int, 2, true, >, INT)
+
+    // TODO: std::byte and bool implementation for logical ops
+    // can be optimized. For some reason, we have an
+    // extra vector "%ref.tmp.i = alloca {{.*}}:vec.3"
+    // that serves no purpose.
+    // CHECK: {{.*}} icmp sgt <2 x i8> %{{.*}}
+    // CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
+    CHECKBINOP(Q, std::byte, 2, true, >, BYTE)
+
+    // CHECK: {{.*}} icmp sgt <2 x i8> %{{.*}}
+    // CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
+    CHECKBINOP(Q, bool, 2, true, >, BOOL)
+
+    // CHECK: {{.*}} fcmp ogt <2 x half> {{.*}}
+    // CHECK: {{.*}} sext <2 x i1> {{.*}} to <2 x i16>
+    CHECKBINOP(Q, sycl::half, 2, true, >, HALF)
+
+    // FIXME: Why do we treat BF16 as i16 when doing logical ops
+    // but convert to float for arithmetic ops?
+    // CHECK: {{.*}} load <2 x i16>, ptr %_arg_InBFVecA {{.*}}
+    // CHECK: {{.*}} icmp ugt <2 x i16> {{.*}}
+    // CHECK: {{.*}} sext <2 x i1> {{.*}} to <2 x i16>
+    CHECKBINOP(Q, ext::oneapi::bfloat16, 2, true, >, BF)
+  }
+
+  // Check device code for unary operators
+  {
+    // CHECK: {{.*}} icmp eq <2 x i32> %{{.*}}, zeroinitializer
+    // CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i32>
+    CHECKUOP(Q, int, 2, true, !, INTUOP, 1)
+
+    // CHECK: {{.*}} sub <2 x i32> zeroinitializer, %{{.*}}
+    CHECKUOP(Q, int, 2, false, -, INTUOP, 1)
+
+    // CHECK: %{{.*}} = icmp eq <2 x i8> %{{.*}}, zeroinitializer
+    // CHECK: %{{.*}} = sext <2 x i1> %{{.*}} to <2 x i8>
+    CHECKUOP(Q, std::byte, 2, true, !, BYTEUOP, 1)
+
+    // FIXME: Why is this getting optimized out?
+    //CHECKUOP(Q, std::byte, 2, false, +, BYTEUOP, -1)
+
+    // CHECK: {{.*}} icmp eq <2 x i8> {{.*}}, zeroinitializer
+    // CHECK: %{{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
+    CHECKUOP(Q, bool, 2, true, !, BOOLUOP, 1)
+
+    // CHECK: {{.*}} sub <2 x i8> zeroinitializer, %{{.*}}
+    CHECKUOP(Q, bool, 2, false, -, BOOLUOP, 1)
+
+    // CHECK: {{.*}} fcmp oeq <2 x half> %{{.*}}, zeroinitializer
+    // CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i16>
+    CHECKUOP(Q, sycl::half, 2, true, !, HALFUOP, 1)
+
+    // CHECK: {{.*}} fneg <2 x half> %{{.*}}
+    CHECKUOP(Q, sycl::half, 2, false, -, HALFUOP, 1)
+
+    // CHECK: for.cond{{.*}}
+    // CHECK: {{.*}} fcmp oeq float %{{.*}}, 0.000000e+00
+    // CHECK: {{.*}} uitofp i1 %{{.*}} to float
+    CHECKUOP(Q, ext::oneapi::bfloat16, 2, true, !, BFUOP, 1)
+
+    // CHECK: for.cond{{.*}}
+    // CHECK: {{.*}} fneg float %{{.*}}
+    CHECKUOP(Q, ext::oneapi::bfloat16, 2, false, -, BFUOP, 1)
+  }
+
+  return 0;
+};
diff --git a/sycl/test/check_device_code/vector/vector_storage.cpp b/sycl/test/check_device_code/vector/vector_storage.cpp
new file mode 100644
index 0000000000000..e630f66649c81
--- /dev/null
+++ b/sycl/test/check_device_code/vector/vector_storage.cpp
@@ -0,0 +1,123 @@
+// RUN: %clangxx -fsycl-device-only -S -O0 -Xclang -emit-llvm -o - %s | FileCheck %s
+
+// This test checks the storage type of sycl::vec on device for
+// all data types.
+#include <sycl/sycl.hpp>
+
+using namespace sycl;
+
+// Create sycl::vec for each type and verify the storage
+// type on device side.
+#define CHECK(Q, T, N)                                                         \
+  {                                                                            \
+    Q.submit([&](handler &CGH) {                                               \
+      CGH.single_task([=]() {                                                  \
+        vec<T, 2> InVec##N##2 {static_cast<T>(5)};                             \
+        vec<T, 3> InVec##N##3 {static_cast<T>(5)};                             \
+        vec<T, 4> InVec##N##4 {static_cast<T>(5)};                             \
+        vec<T, 8> InVec##N##8 {static_cast<T>(5)};                             \
+        vec<T, 16> InVec##N##16 {static_cast<T>(5)};                           \
+      });                                                                      \
+    });                                                                        \
+  }
+
+int main() {
+
+  queue q;
+
+  // CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
+  // CHECK: {{.*}}std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: {{.*}}std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: {{.*}}std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: {{.*}}std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  // CHECK: {{.*}}std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+  CHECK(q, ext::oneapi::bfloat16, BF)
+
+  // CHECK: {{.*}}InVecINT2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i32> {{.*}}
+  // CHECK: {{.*}}InVecINT3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i32> {{.*}}
+  // CHECK: {{.*}}InVecINT4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i32> {{.*}}
+  // CHECK: {{.*}}InVecINT8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i32> {{.*}}
+  // CHECK: {{.*}}InVecINT16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i32> {{.*}}
+  CHECK(q, int, INT)
+
+  // CHECK: {{.*}}InVecFLOAT2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x float> {{.*}}
+  // CHECK: {{.*}}InVecFLOAT3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x float> {{.*}}
+  // CHECK: {{.*}}InVecFLOAT4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x float> {{.*}}
+  // CHECK: {{.*}}InVecFLOAT8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x float> {{.*}}
+  // CHECK: {{.*}}InVecFLOAT16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x float> {{.*}}
+  CHECK(q, float, FLOAT)
+
+  // CHECK: {{.*}}InVecCHAR2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
+  // CHECK: {{.*}}InVecCHAR3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
+  // CHECK: {{.*}}InVecCHAR4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
+  // CHECK: {{.*}}InVecCHAR8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
+  // CHECK: {{.*}}InVecCHAR16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
+  CHECK(q, char, CHAR)
+
+  // CHECK: {{.*}}InVecBOOL2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
+  // CHECK: {{.*}}InVecBOOL3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
+  // CHECK: {{.*}}InVecBOOL4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
+  // CHECK: {{.*}}InVecBOOL8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
+  // CHECK: {{.*}}InVecBOOL16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
+  CHECK(q, bool, BOOL)
+
+  // CHECK: {{.*}}InVecHALF2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x half> {{.*}}
+  // CHECK: {{.*}}InVecHALF3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x half> {{.*}}
+  // CHECK: {{.*}}InVecHALF4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x half> {{.*}}
+  // CHECK: {{.*}}InVecHALF8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x half> {{.*}}
+  // CHECK: {{.*}}InVecHALF16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x half> {{.*}}
+  CHECK(q, half, HALF)
+
+  // CHECK: {{.*}}InVecBYTE2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
+  // CHECK: {{.*}}InVecBYTE3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
+  // CHECK: {{.*}}InVecBYTE4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
+  // CHECK: {{.*}}InVecBYTE8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
+  // CHECK: {{.*}}InVecBYTE16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
+  CHECK(q, std::byte, BYTE)
+
+  // Check alignment of the allocated sycl::vec
+
+  // CHECK: %InVecBF2 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+  // CHECK: %InVecBF3 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+  // CHECK: %InVecBF4 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+  // CHECK: %InVecBF8 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+  // CHECK: %InVecBF16 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
+
+  // CHECK: %InVecINT2 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+  // CHECK: %InVecINT3 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+  // CHECK: %InVecINT4 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+  // CHECK: %InVecINT8 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
+  // CHECK: %InVecINT16 = alloca %"class.sycl::_V1::vec{{.*}}", align 64
+
+  // CHECK: %InVecFLOAT2 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+  // CHECK: %InVecFLOAT3 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+  // CHECK: %InVecFLOAT4 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+  // CHECK: %InVecFLOAT8 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
+  // CHECK: %InVecFLOAT16 = alloca %"class.sycl::_V1::vec{{.*}}", align 64
+
+  // CHECK: %InVecCHAR2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
+  // CHECK: %InVecCHAR3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+  // CHECK: %InVecCHAR4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+  // CHECK: %InVecCHAR8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+  // CHECK: %InVecCHAR16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+
+  // CHECK: %InVecBOOL2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
+  // CHECK: %InVecBOOL3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+  // CHECK: %InVecBOOL4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+  // CHECK: %InVecBOOL8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+  // CHECK: %InVecBOOL16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+
+  // CHECK: %InVecHALF2 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+  // CHECK: %InVecHALF3 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+  // CHECK: %InVecHALF4 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+  // CHECK: %InVecHALF8 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+  // CHECK: %InVecHALF16 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
+
+  // CHECK: %InVecBYTE2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
+  // CHECK: %InVecBYTE3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+  // CHECK: %InVecBYTE4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+  // CHECK: %InVecBYTE8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+  // CHECK: %InVecBYTE16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+
+  return 0;
+};

From 49fa63d6deda15af540b32fb56ea1c15c73f0307 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 25 Apr 2024 20:26:50 -0700
Subject: [PATCH 33/79] Remove redundant code

---
 .../vector/vector_math_ops.cpp                | 204 ++++++-----------
 .../vector/vector_storage.cpp                 | 213 +++++++++---------
 2 files changed, 176 insertions(+), 241 deletions(-)

diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index bac3a3077f06d..07fa0a1761676 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -1,157 +1,103 @@
-// RUN: %clangxx -fsycl-device-only -S -O3 -Xclang -emit-llvm -o - %s | FileCheck %s
+// RUN: %clangxx -I %sycl_include -S -emit-llvm -fno-sycl-instrument-device-code -fsycl-device-only %s -o - | FileCheck %s
 
 // This test checks the device code for various math operations on sycl::vec.
 #include <sycl/sycl.hpp>
 
 using namespace sycl;
 
-template <typename T>
-using rel_t = std::conditional_t<
-    sizeof(T) == 1, int8_t,
-    std::conditional_t<
-        sizeof(T) == 2, int16_t,
-        std::conditional_t<sizeof(T) == 4, int32_t,
-                           std::conditional_t<sizeof(T) == 8, int64_t, void>>>>;
-
-// For testing binary operations
-#define CHECKBINOP(Q, T, N, IS_RELOP, OP, SUFFIX)                              \
-  {                                                                            \
-    using VecT = sycl::vec<T, N>;                                              \
-    using ResT = sycl::vec<std::conditional_t<IS_RELOP, rel_t<T>, T>, N>;      \
-    VecT In##SUFFIX##VecA{static_cast<T>(5)};                                  \
-    VecT In##SUFFIX##VecB{static_cast<T>(6)};                                  \
-    {                                                                          \
-      VecT OutVecsDevice[1];                                                   \
-      sycl::buffer<VecT, 1> OutVecsBuff{OutVecsDevice, 1};                     \
-      Q.submit([&](sycl::handler &CGH) {                                       \
-        sycl::accessor OutVecsAcc{OutVecsBuff, CGH, sycl::read_write};         \
-        CGH.single_task([=]() {                                                \
-          auto OutVec1 = In##SUFFIX##VecA OP In##SUFFIX##VecB;                 \
-          static_assert(std::is_same_v<decltype(OutVec1), ResT>);              \
-          OutVecsAcc[0] = OutVec1;                                             \
-        });                                                                    \
-      });                                                                      \
-    }                                                                          \
+// For testing binary operations.
+#define CHECKBINOP(T, SUFFIX, OP)                                              \
+  SYCL_EXTERNAL auto CheckDevCodeBINOP##SUFFIX(T Ref1 = (T)5, T Ref2 = (T)6) { \
+    vec<T, 2> InVec##SUFFIX##2A {Ref1, Ref2};                                  \
+    vec<T, 2> InVec##SUFFIX##2B {Ref2, Ref1};                                  \
+    return InVec##SUFFIX##2A OP InVec##SUFFIX##2B;                             \
   }
 
-// For testing unary operators
-#define CHECKUOP(Q, T, N, IS_RELOP, OP, SUFFIX, REF)                           \
-  {                                                                            \
-    using VecT = sycl::vec<T, N>;                                              \
-    using ResT = sycl::vec<std::conditional_t<IS_RELOP, rel_t<T>, T>, N>;      \
-    VecT In##SUFFIX##VecA{static_cast<T>(REF)};                                \
-    {                                                                          \
-      VecT OutVecsDevice[1];                                                   \
-      sycl::buffer<VecT, 1> OutVecsBuff{OutVecsDevice, 1};                     \
-      Q.submit([&](sycl::handler &CGH) {                                       \
-        sycl::accessor OutVecsAcc{OutVecsBuff, CGH, sycl::read_write};         \
-        CGH.single_task([=]() {                                                \
-          auto OutVec1 = OP In##SUFFIX##VecA;                                  \
-          static_assert(std::is_same_v<decltype(OutVec1), ResT>);              \
-          OutVecsAcc[0] = OutVec1;                                             \
-        });                                                                    \
-      });                                                                      \
-    }                                                                          \
+// For testing unary operators.
+#define CHECKUOP(T, SUFFIX, OP, REF)                                           \
+  SYCL_EXTERNAL auto CheckDevCodeUOP##SUFFIX(int Ref1 = REF) {                 \
+    vec<T, 2> InVec##SUFFIX##2 {static_cast<T>(Ref1),                          \
+                                static_cast<T>(Ref1 + 1)};                     \
+    return OP InVec##SUFFIX##2;                                                \
   }
 
-int main() {
+/********************** Binary Ops **********************/
 
-  queue Q;
+// CHECK: {{.*}} add <2 x i32> %{{.*}}
+CHECKBINOP(int, INTA, +)
 
-  // Check device code for binary arithmetic operations.
-  // int, char, and float are handled in the same manner.
-  {
-    // CHECK: %add{{.*}} = add <2 x i32> %{{.*}}
-    CHECKBINOP(Q, int, 2, false, +, INT)
+// CHECK: {{.*}} add <2 x i8> %{{.*}}
+CHECKBINOP(std::byte, BYTEA, +)
 
-    // CHECK: %add{{.*}} = add <2 x i8> %{{.*}}
-    CHECKBINOP(Q, std::byte, 2, false, +, BYTE)
+// CHECK: {{.*}} add nuw nsw <2 x i8> {{.*}}
+// CHECK: for.body{{.*}}
+// CHECK: {{.*}} = icmp ne i8 %{{.*}}, 0
+CHECKBINOP(bool, BOOLA, +)
 
-    // CHECK: %add{{.*}} = add <2 x i8> %{{.*}}
-    // CHECK: for.body{{.*}}
-    // CHECK: {{.*}} = icmp ne i8 %{{.*}}, 0
-    CHECKBINOP(Q, bool, 2, false, +, BOOL)
+// CHECK: {{.*}} fadd <2 x half> %{{.*}}
+CHECKBINOP(sycl::half, HALFA, +)
 
-    // CHECK: %add{{.*}} = fadd <2 x half> %{{.*}}
-    CHECKBINOP(Q, sycl::half, 2, false, +, HALF)
+// CHECK: for.body{{.*}}
+// CHECK: {{.*}}ConvertBF16ToFINTEL{{.*}}
+// CHECK: {{.*}}ConvertBF16ToFINTEL{{.*}}
+// CHECK: %add{{.*}} = fadd float %{{.*}}, %{{.*}}
+// CHECK: {{.*}}ConvertFToBF16INTEL{{.*}}
+CHECKBINOP(ext::oneapi::bfloat16, BFA, +)
 
-    // CHECK: for.body{{.*}}
-    // CHECK: {{.*}}ConvertBF16ToFINTEL{{.*}}
-    // CHECK: {{.*}}ConvertBF16ToFINTEL{{.*}}
-    // CHECK: %add{{.*}} = fadd float %{{.*}}, %{{.*}}
-    // CHECK: {{.*}}ConvertFToBF16INTEL{{.*}}
-    CHECKBINOP(Q, ext::oneapi::bfloat16, 2, false, +, BF)
-  }
+// CHECK: icmp sgt <2 x i32> %{{.*}}
+// CHECK: sext <2 x i1> %{{.*}} to <2 x i32>
+CHECKBINOP(int, INTL, >)
 
-  // Check device code for binary logical operations.
-  {
-    // CHECK: icmp sgt <2 x i32> %{{.*}}
-    // CHECK: sext <2 x i1> %{{.*}} to <2 x i32>
-    CHECKBINOP(Q, int, 2, true, >, INT)
-
-    // TODO: std::byte and bool implementation for logical ops
-    // can be optimized. For some reason, we have an
-    // extra vector "%ref.tmp.i = alloca {{.*}}:vec.3"
-    // that serves no purpose.
-    // CHECK: {{.*}} icmp sgt <2 x i8> %{{.*}}
-    // CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
-    CHECKBINOP(Q, std::byte, 2, true, >, BYTE)
-
-    // CHECK: {{.*}} icmp sgt <2 x i8> %{{.*}}
-    // CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
-    CHECKBINOP(Q, bool, 2, true, >, BOOL)
-
-    // CHECK: {{.*}} fcmp ogt <2 x half> {{.*}}
-    // CHECK: {{.*}} sext <2 x i1> {{.*}} to <2 x i16>
-    CHECKBINOP(Q, sycl::half, 2, true, >, HALF)
-
-    // FIXME: Why do we treat BF16 as i16 when doing logical ops
-    // but convert to float for arithmetic ops?
-    // CHECK: {{.*}} load <2 x i16>, ptr %_arg_InBFVecA {{.*}}
-    // CHECK: {{.*}} icmp ugt <2 x i16> {{.*}}
-    // CHECK: {{.*}} sext <2 x i1> {{.*}} to <2 x i16>
-    CHECKBINOP(Q, ext::oneapi::bfloat16, 2, true, >, BF)
-  }
+// CHECK: {{.*}} icmp sgt <2 x i8> %{{.*}}
+// CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
+CHECKBINOP(std::byte, BYTEL, >)
 
-  // Check device code for unary operators
-  {
-    // CHECK: {{.*}} icmp eq <2 x i32> %{{.*}}, zeroinitializer
-    // CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i32>
-    CHECKUOP(Q, int, 2, true, !, INTUOP, 1)
+// CHECK: {{.*}} icmp ugt <2 x i8> %{{.*}}
+// CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
+CHECKBINOP(bool, BOOLL, >)
 
-    // CHECK: {{.*}} sub <2 x i32> zeroinitializer, %{{.*}}
-    CHECKUOP(Q, int, 2, false, -, INTUOP, 1)
+// CHECK: {{.*}} fcmp ogt <2 x half> {{.*}}
+// CHECK: {{.*}} sext <2 x i1> {{.*}} to <2 x i16>
+CHECKBINOP(sycl::half, HALFL, >)
 
-    // CHECK: %{{.*}} = icmp eq <2 x i8> %{{.*}}, zeroinitializer
-    // CHECK: %{{.*}} = sext <2 x i1> %{{.*}} to <2 x i8>
-    CHECKUOP(Q, std::byte, 2, true, !, BYTEUOP, 1)
+// FIXME: Why do we treat BF16 as i16 when doing logical ops
+// but convert to float for arithmetic ops?
+// CHECK: {{.*}} icmp ugt <2 x i16> {{.*}}
+// CHECK: {{.*}} sext <2 x i1> {{.*}} to <2 x i16>
+CHECKBINOP(ext::oneapi::bfloat16, BFL, >)
 
-    // FIXME: Why is this getting optimized out?
-    //CHECKUOP(Q, std::byte, 2, false, +, BYTEUOP, -1)
+/********************** Unary Ops **********************/
 
-    // CHECK: {{.*}} icmp eq <2 x i8> {{.*}}, zeroinitializer
-    // CHECK: %{{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
-    CHECKUOP(Q, bool, 2, true, !, BOOLUOP, 1)
+// CHECK: {{.*}} icmp eq <2 x i32> %{{.*}}, zeroinitializer
+// CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i32>
+CHECKUOP(int, INTNEG, !, 1)
 
-    // CHECK: {{.*}} sub <2 x i8> zeroinitializer, %{{.*}}
-    CHECKUOP(Q, bool, 2, false, -, BOOLUOP, 1)
+// CHECK: {{.*}} sub <2 x i32> zeroinitializer, %{{.*}}
+CHECKUOP(int, INTSUB, -, 1)
 
-    // CHECK: {{.*}} fcmp oeq <2 x half> %{{.*}}, zeroinitializer
-    // CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i16>
-    CHECKUOP(Q, sycl::half, 2, true, !, HALFUOP, 1)
+// CHECK: %{{.*}} = icmp eq <2 x i8> %{{.*}}, zeroinitializer
+// CHECK: %{{.*}} = sext <2 x i1> %{{.*}} to <2 x i8>
+CHECKUOP(std::byte, BYTENEG, !, 1)
 
-    // CHECK: {{.*}} fneg <2 x half> %{{.*}}
-    CHECKUOP(Q, sycl::half, 2, false, -, HALFUOP, 1)
+// CHECK: {{.*}} sub <2 x i8> zeroinitializer, %{{.*}}
+CHECKUOP(std::byte, BYTESUB, -, -1)
 
-    // CHECK: for.cond{{.*}}
-    // CHECK: {{.*}} fcmp oeq float %{{.*}}, 0.000000e+00
-    // CHECK: {{.*}} uitofp i1 %{{.*}} to float
-    CHECKUOP(Q, ext::oneapi::bfloat16, 2, true, !, BFUOP, 1)
+// CHECK: {{.*}} icmp eq <2 x i8> {{.*}}, zeroinitializer
+// CHECK: %{{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
+CHECKUOP(bool, BOOLNEG, !, 1)
 
-    // CHECK: for.cond{{.*}}
-    // CHECK: {{.*}} fneg float %{{.*}}
-    CHECKUOP(Q, ext::oneapi::bfloat16, 2, false, -, BFUOP, 1)
-  }
+// CHECK: {{.*}} fcmp oeq <2 x half> %{{.*}}, zeroinitializer
+// CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i16>
+CHECKUOP(sycl::half, HALFNEG, !, 1)
+
+// CHECK: {{.*}} fneg <2 x half> %{{.*}}
+CHECKUOP(sycl::half, HALFSUB, -, 1)
+
+// CHECK: for.cond{{.*}}
+// CHECK: {{.*}} fcmp oeq float %{{.*}}, 0.000000e+00
+// CHECK: {{.*}} uitofp i1 %{{.*}} to float
+CHECKUOP(ext::oneapi::bfloat16, BFNEG, !, 1)
 
-  return 0;
-};
+// CHECK: for{{.*}}
+// CHECK: {{.*}} fneg float %{{.*}}
+CHECKUOP(ext::oneapi::bfloat16, BFSUB, -, 1)
diff --git a/sycl/test/check_device_code/vector/vector_storage.cpp b/sycl/test/check_device_code/vector/vector_storage.cpp
index e630f66649c81..3f78fb36e11fb 100644
--- a/sycl/test/check_device_code/vector/vector_storage.cpp
+++ b/sycl/test/check_device_code/vector/vector_storage.cpp
@@ -1,4 +1,4 @@
-// RUN: %clangxx -fsycl-device-only -S -O0 -Xclang -emit-llvm -o - %s | FileCheck %s
+// RUN: %clangxx -I %sycl_include -S -emit-llvm -fsycl-device-only %s -o - -Xclang -disable-llvm-passes -Xclang -no-enable-noundef-analysis | FileCheck %s
 
 // This test checks the storage type of sycl::vec on device for
 // all data types.
@@ -8,116 +8,105 @@ using namespace sycl;
 
 // Create sycl::vec for each type and verify the storage
 // type on device side.
-#define CHECK(Q, T, N)                                                         \
-  {                                                                            \
-    Q.submit([&](handler &CGH) {                                               \
-      CGH.single_task([=]() {                                                  \
-        vec<T, 2> InVec##N##2 {static_cast<T>(5)};                             \
-        vec<T, 3> InVec##N##3 {static_cast<T>(5)};                             \
-        vec<T, 4> InVec##N##4 {static_cast<T>(5)};                             \
-        vec<T, 8> InVec##N##8 {static_cast<T>(5)};                             \
-        vec<T, 16> InVec##N##16 {static_cast<T>(5)};                           \
-      });                                                                      \
-    });                                                                        \
+#define CHECK(T, SUFFIX)                                                       \
+  SYCL_EXTERNAL void CheckDevCode##SUFFIX() {                                  \
+    vec<T, 2> InVec##SUFFIX##2 {static_cast<T>(5)};                            \
+    vec<T, 3> InVec##SUFFIX##3 {static_cast<T>(5)};                            \
+    vec<T, 4> InVec##SUFFIX##4 {static_cast<T>(5)};                            \
+    vec<T, 8> InVec##SUFFIX##8 {static_cast<T>(5)};                            \
+    vec<T, 16> InVec##SUFFIX##16 {static_cast<T>(5)};                          \
   }
 
-int main() {
-
-  queue q;
-
-  // CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
-  // CHECK: {{.*}}std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: {{.*}}std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: {{.*}}std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: {{.*}}std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: {{.*}}std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  CHECK(q, ext::oneapi::bfloat16, BF)
-
-  // CHECK: {{.*}}InVecINT2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i32> {{.*}}
-  // CHECK: {{.*}}InVecINT3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i32> {{.*}}
-  // CHECK: {{.*}}InVecINT4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i32> {{.*}}
-  // CHECK: {{.*}}InVecINT8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i32> {{.*}}
-  // CHECK: {{.*}}InVecINT16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i32> {{.*}}
-  CHECK(q, int, INT)
-
-  // CHECK: {{.*}}InVecFLOAT2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x float> {{.*}}
-  // CHECK: {{.*}}InVecFLOAT3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x float> {{.*}}
-  // CHECK: {{.*}}InVecFLOAT4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x float> {{.*}}
-  // CHECK: {{.*}}InVecFLOAT8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x float> {{.*}}
-  // CHECK: {{.*}}InVecFLOAT16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x float> {{.*}}
-  CHECK(q, float, FLOAT)
-
-  // CHECK: {{.*}}InVecCHAR2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
-  // CHECK: {{.*}}InVecCHAR3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
-  // CHECK: {{.*}}InVecCHAR4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
-  // CHECK: {{.*}}InVecCHAR8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
-  // CHECK: {{.*}}InVecCHAR16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
-  CHECK(q, char, CHAR)
-
-  // CHECK: {{.*}}InVecBOOL2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
-  // CHECK: {{.*}}InVecBOOL3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
-  // CHECK: {{.*}}InVecBOOL4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
-  // CHECK: {{.*}}InVecBOOL8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
-  // CHECK: {{.*}}InVecBOOL16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
-  CHECK(q, bool, BOOL)
-
-  // CHECK: {{.*}}InVecHALF2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x half> {{.*}}
-  // CHECK: {{.*}}InVecHALF3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x half> {{.*}}
-  // CHECK: {{.*}}InVecHALF4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x half> {{.*}}
-  // CHECK: {{.*}}InVecHALF8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x half> {{.*}}
-  // CHECK: {{.*}}InVecHALF16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x half> {{.*}}
-  CHECK(q, half, HALF)
-
-  // CHECK: {{.*}}InVecBYTE2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
-  // CHECK: {{.*}}InVecBYTE3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
-  // CHECK: {{.*}}InVecBYTE4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
-  // CHECK: {{.*}}InVecBYTE8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
-  // CHECK: {{.*}}InVecBYTE16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
-  CHECK(q, std::byte, BYTE)
-
-  // Check alignment of the allocated sycl::vec
-
-  // CHECK: %InVecBF2 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-  // CHECK: %InVecBF3 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-  // CHECK: %InVecBF4 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-  // CHECK: %InVecBF8 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-  // CHECK: %InVecBF16 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
-
-  // CHECK: %InVecINT2 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-  // CHECK: %InVecINT3 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-  // CHECK: %InVecINT4 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-  // CHECK: %InVecINT8 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
-  // CHECK: %InVecINT16 = alloca %"class.sycl::_V1::vec{{.*}}", align 64
-
-  // CHECK: %InVecFLOAT2 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-  // CHECK: %InVecFLOAT3 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-  // CHECK: %InVecFLOAT4 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-  // CHECK: %InVecFLOAT8 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
-  // CHECK: %InVecFLOAT16 = alloca %"class.sycl::_V1::vec{{.*}}", align 64
-
-  // CHECK: %InVecCHAR2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
-  // CHECK: %InVecCHAR3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-  // CHECK: %InVecCHAR4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-  // CHECK: %InVecCHAR8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-  // CHECK: %InVecCHAR16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-
-  // CHECK: %InVecBOOL2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
-  // CHECK: %InVecBOOL3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-  // CHECK: %InVecBOOL4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-  // CHECK: %InVecBOOL8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-  // CHECK: %InVecBOOL16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-
-  // CHECK: %InVecHALF2 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-  // CHECK: %InVecHALF3 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-  // CHECK: %InVecHALF4 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-  // CHECK: %InVecHALF8 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-  // CHECK: %InVecHALF16 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
-
-  // CHECK: %InVecBYTE2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
-  // CHECK: %InVecBYTE3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-  // CHECK: %InVecBYTE4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-  // CHECK: %InVecBYTE8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-  // CHECK: %InVecBYTE16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-
-  return 0;
-};
+// CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
+// CHECK: {{.*}}std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+// CHECK: {{.*}}std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+// CHECK: {{.*}}std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+// CHECK: {{.*}}std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+// CHECK: {{.*}}std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
+CHECK(ext::oneapi::bfloat16, BF)
+
+// CHECK: {{.*}}InVecINT2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i32> {{.*}}
+// CHECK: {{.*}}InVecINT3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i32> {{.*}}
+// CHECK: {{.*}}InVecINT4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i32> {{.*}}
+// CHECK: {{.*}}InVecINT8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i32> {{.*}}
+// CHECK: {{.*}}InVecINT16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i32> {{.*}}
+CHECK(int, INT)
+
+// CHECK: {{.*}}InVecFLOAT2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x float> {{.*}}
+// CHECK: {{.*}}InVecFLOAT3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x float> {{.*}}
+// CHECK: {{.*}}InVecFLOAT4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x float> {{.*}}
+// CHECK: {{.*}}InVecFLOAT8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x float> {{.*}}
+// CHECK: {{.*}}InVecFLOAT16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x float> {{.*}}
+CHECK(float, FLOAT)
+
+// CHECK: {{.*}}InVecCHAR2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
+// CHECK: {{.*}}InVecCHAR3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
+// CHECK: {{.*}}InVecCHAR4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
+// CHECK: {{.*}}InVecCHAR8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
+// CHECK: {{.*}}InVecCHAR16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
+CHECK(char, CHAR)
+
+// CHECK: {{.*}}InVecBOOL2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
+// CHECK: {{.*}}InVecBOOL3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
+// CHECK: {{.*}}InVecBOOL4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
+// CHECK: {{.*}}InVecBOOL8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
+// CHECK: {{.*}}InVecBOOL16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
+CHECK(bool, BOOL)
+
+// CHECK: {{.*}}InVecHALF2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x half> {{.*}}
+// CHECK: {{.*}}InVecHALF3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x half> {{.*}}
+// CHECK: {{.*}}InVecHALF4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x half> {{.*}}
+// CHECK: {{.*}}InVecHALF8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x half> {{.*}}
+// CHECK: {{.*}}InVecHALF16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x half> {{.*}}
+CHECK(half, HALF)
+
+// CHECK: {{.*}}InVecBYTE2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
+// CHECK: {{.*}}InVecBYTE3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
+// CHECK: {{.*}}InVecBYTE4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
+// CHECK: {{.*}}InVecBYTE8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
+// CHECK: {{.*}}InVecBYTE16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
+CHECK(std::byte, BYTE)
+
+// Check alignment of the allocated sycl::vec
+
+// CHECK: %InVecBF2 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+// CHECK: %InVecBF3 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+// CHECK: %InVecBF4 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+// CHECK: %InVecBF8 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+// CHECK: %InVecBF16 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
+
+// CHECK: %InVecINT2 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+// CHECK: %InVecINT3 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+// CHECK: %InVecINT4 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+// CHECK: %InVecINT8 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
+// CHECK: %InVecINT16 = alloca %"class.sycl::_V1::vec{{.*}}", align 64
+
+// CHECK: %InVecFLOAT2 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+// CHECK: %InVecFLOAT3 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+// CHECK: %InVecFLOAT4 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+// CHECK: %InVecFLOAT8 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
+// CHECK: %InVecFLOAT16 = alloca %"class.sycl::_V1::vec{{.*}}", align 64
+
+// CHECK: %InVecCHAR2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
+// CHECK: %InVecCHAR3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+// CHECK: %InVecCHAR4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+// CHECK: %InVecCHAR8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+// CHECK: %InVecCHAR16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+
+// CHECK: %InVecBOOL2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
+// CHECK: %InVecBOOL3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+// CHECK: %InVecBOOL4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+// CHECK: %InVecBOOL8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+// CHECK: %InVecBOOL16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+
+// CHECK: %InVecHALF2 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+// CHECK: %InVecHALF3 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+// CHECK: %InVecHALF4 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+// CHECK: %InVecHALF8 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
+// CHECK: %InVecHALF16 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
+
+// CHECK: %InVecBYTE2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
+// CHECK: %InVecBYTE3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+// CHECK: %InVecBYTE4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
+// CHECK: %InVecBYTE8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
+// CHECK: %InVecBYTE16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
\ No newline at end of file

From 4516e75ccf0bab2cd38bd869cb42a2fdae4490f3 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 26 Apr 2024 09:21:46 -0700
Subject: [PATCH 34/79] Add line at EOF

---
 sycl/test/check_device_code/vector/vector_storage.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/test/check_device_code/vector/vector_storage.cpp b/sycl/test/check_device_code/vector/vector_storage.cpp
index 3f78fb36e11fb..061e24083324c 100644
--- a/sycl/test/check_device_code/vector/vector_storage.cpp
+++ b/sycl/test/check_device_code/vector/vector_storage.cpp
@@ -109,4 +109,4 @@ CHECK(std::byte, BYTE)
 // CHECK: %InVecBYTE3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
 // CHECK: %InVecBYTE4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
 // CHECK: %InVecBYTE8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-// CHECK: %InVecBYTE16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
\ No newline at end of file
+// CHECK: %InVecBYTE16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16

From e8adc8a48d49b376dd8846806c5aec4fea5b122c Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 26 Apr 2024 12:46:11 -0700
Subject: [PATCH 35/79] Simplify code

---
 .../vector/vector_math_ops.cpp                | 422 ++++++++++++++++--
 1 file changed, 377 insertions(+), 45 deletions(-)

diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 07fa0a1761676..7e541143c1c77 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -7,97 +7,429 @@ using namespace sycl;
 
 // For testing binary operations.
 #define CHECKBINOP(T, SUFFIX, OP)                                              \
-  SYCL_EXTERNAL auto CheckDevCodeBINOP##SUFFIX(T Ref1 = (T)5, T Ref2 = (T)6) { \
-    vec<T, 2> InVec##SUFFIX##2A {Ref1, Ref2};                                  \
-    vec<T, 2> InVec##SUFFIX##2B {Ref2, Ref1};                                  \
+  SYCL_EXTERNAL auto CheckDevCodeBINOP##SUFFIX(vec<T, 2> InVec##SUFFIX##2A,    \
+                                               vec<T, 2> InVec##SUFFIX##2B) {  \
     return InVec##SUFFIX##2A OP InVec##SUFFIX##2B;                             \
   }
 
 // For testing unary operators.
 #define CHECKUOP(T, SUFFIX, OP, REF)                                           \
-  SYCL_EXTERNAL auto CheckDevCodeUOP##SUFFIX(int Ref1 = REF) {                 \
-    vec<T, 2> InVec##SUFFIX##2 {static_cast<T>(Ref1),                          \
-                                static_cast<T>(Ref1 + 1)};                     \
+  SYCL_EXTERNAL auto CheckDevCodeUOP##SUFFIX(vec<T, 2> InVec##SUFFIX##2) {     \
     return OP InVec##SUFFIX##2;                                                \
   }
 
 /********************** Binary Ops **********************/
 
-// CHECK: {{.*}} add <2 x i32> %{{.*}}
+// CHECK-LABEL: define dso_local spir_func void @_Z21CheckDevCodeBINOPINTAN4sycl3_V13vecIiLi2EEES2_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTA2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTA2B:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] !srcloc [[META5:![0-9]+]] !sycl_fixed_targets [[META6:![0-9]+]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META7:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTA2A]], align 8, !tbaa [[TBAA10:![0-9]+]], !noalias [[META7]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[INVECINTA2B]], align 8, !tbaa [[TBAA10]], !noalias [[META7]]
+// CHECK-NEXT:    [[ADD_I:%.*]] = add <2 x i32> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    store <2 x i32> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META7]]
+// CHECK-NEXT:    ret void
+//
 CHECKBINOP(int, INTA, +)
 
-// CHECK: {{.*}} add <2 x i8> %{{.*}}
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPBYTEAN4sycl3_V13vecISt4byteLi2EEES3_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTEA2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTEA2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META13:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META14:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTEA2A]], align 2, !tbaa [[TBAA10]], !noalias [[META14]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBYTEA2B]], align 2, !tbaa [[TBAA10]], !noalias [[META14]]
+// CHECK-NEXT:    [[ADD_I:%.*]] = add <2 x i8> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    store <2 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META14]]
+// CHECK-NEXT:    ret void
+//
 CHECKBINOP(std::byte, BYTEA, +)
 
-// CHECK: {{.*}} add nuw nsw <2 x i8> {{.*}}
-// CHECK: for.body{{.*}}
-// CHECK: {{.*}} = icmp ne i8 %{{.*}}, 0
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPBOOLAN4sycl3_V13vecIbLi2EEES2_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.1") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 2 [[INVECBOOLA2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 2 [[INVECBOOLA2B:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] !srcloc [[META17:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META18:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBOOLA2A]], align 2, !tbaa [[TBAA10]], !noalias [[META18]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBOOLA2B]], align 2, !tbaa [[TBAA10]], !noalias [[META18]]
+// CHECK-NEXT:    [[ADD_I:%.*]] = add <2 x i8> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    br label [[FOR_COND_I_I:%.*]]
+// CHECK:       for.cond.i.i:
+// CHECK-NEXT:    [[VECINS_I_I6_I_I:%.*]] = phi <2 x i8> [ [[ADD_I]], [[ENTRY:%.*]] ], [ [[VECINS_I_I_I_I:%.*]], [[FOR_BODY_I_I:%.*]] ]
+// CHECK-NEXT:    [[I_0_I_I:%.*]] = phi i64 [ 0, [[ENTRY]] ], [ [[INC_I_I:%.*]], [[FOR_BODY_I_I]] ]
+// CHECK-NEXT:    [[CMP_I_I:%.*]] = icmp ult i64 [[I_0_I_I]], 2
+// CHECK-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECIBLI2EEES4__EXIT:%.*]]
+// CHECK:       for.body.i.i:
+// CHECK-NEXT:    [[CONV_I_I:%.*]] = trunc nuw nsw i64 [[I_0_I_I]] to i32
+// CHECK-NEXT:    [[VECEXT_I_I_I_I:%.*]] = extractelement <2 x i8> [[VECINS_I_I6_I_I]], i32 [[CONV_I_I]]
+// CHECK-NEXT:    [[TOBOOL_I_I_I_I:%.*]] = icmp ne i8 [[VECEXT_I_I_I_I]], 0
+// CHECK-NEXT:    [[FROMBOOL_I_I:%.*]] = zext i1 [[TOBOOL_I_I_I_I]] to i8
+// CHECK-NEXT:    [[VECINS_I_I_I_I]] = insertelement <2 x i8> [[VECINS_I_I6_I_I]], i8 [[FROMBOOL_I_I]], i32 [[CONV_I_I]]
+// CHECK-NEXT:    [[INC_I_I]] = add nuw nsw i64 [[I_0_I_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP21:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1plERKNS0_3vecIbLi2EEES4_.exit:
+// CHECK-NEXT:    store <2 x i8> [[VECINS_I_I6_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !alias.scope [[META18]]
+// CHECK-NEXT:    ret void
+//
 CHECKBINOP(bool, BOOLA, +)
 
-// CHECK: {{.*}} fadd <2 x half> %{{.*}}
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPHALFAN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEES5_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFA2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFA2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META23:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META24:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFA2A]], align 4, !tbaa [[TBAA10]], !noalias [[META24]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x half>, ptr [[INVECHALFA2B]], align 4, !tbaa [[TBAA10]], !noalias [[META24]]
+// CHECK-NEXT:    [[ADD_I:%.*]] = fadd <2 x half> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    store <2 x half> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META24]]
+// CHECK-NEXT:    ret void
+//
 CHECKBINOP(sycl::half, HALFA, +)
 
-// CHECK: for.body{{.*}}
-// CHECK: {{.*}}ConvertBF16ToFINTEL{{.*}}
-// CHECK: {{.*}}ConvertBF16ToFINTEL{{.*}}
-// CHECK: %add{{.*}} = fadd float %{{.*}}, %{{.*}}
-// CHECK: {{.*}}ConvertFToBF16INTEL{{.*}}
+// CHECK-LABEL: define dso_local spir_func void @_Z20CheckDevCodeBINOPBFAN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi2EEES5_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.3") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFA2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFA2B:%.*]]) local_unnamed_addr #[[ATTR3:[0-9]+]] !srcloc [[META27:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[REF_TMP1_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-NEXT:    [[REF_TMP3_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META28:![0-9]+]])
+// CHECK-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
+// CHECK-NEXT:    [[REF_TMP3_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP3_I]] to ptr addrspace(4)
+// CHECK-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
+// CHECK-NEXT:    [[AGG_RESULT_PROMOTED_I:%.*]] = load <2 x i16>, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META28]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i16>, ptr [[INVECBFA2A]], align 4, !tbaa [[TBAA10]], !noalias [[META31:![0-9]+]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i16>, ptr [[INVECBFA2B]], align 4, !tbaa [[TBAA10]], !noalias [[META36:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK:       for.cond.i:
+// CHECK-NEXT:    [[VECINS_I_I10_I:%.*]] = phi <2 x i16> [ [[AGG_RESULT_PROMOTED_I]], [[ENTRY:%.*]] ], [ [[VECINS_I_I_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY]] ], [ [[INC_I:%.*]], [[FOR_BODY_I]] ]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI2EEES7__EXIT:%.*]]
+// CHECK:       for.body.i:
+// CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8:[0-9]+]], !noalias [[META28]]
+// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META41:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META42:![0-9]+]])
+// CHECK-NEXT:    [[VECEXT_I_I_I:%.*]] = extractelement <2 x i16> [[TMP0]], i32 [[CONV_I]]
+// CHECK-NEXT:    store i16 [[VECEXT_I_I_I]], ptr [[REF_TMP1_I]], align 2, !alias.scope [[META43:![0-9]+]], !noalias [[META28]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP3_I]]) #[[ATTR8]], !noalias [[META28]]
+// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META48:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META49:![0-9]+]])
+// CHECK-NEXT:    [[VECEXT_I_I9_I:%.*]] = extractelement <2 x i16> [[TMP1]], i32 [[CONV_I]]
+// CHECK-NEXT:    store i16 [[VECEXT_I_I9_I]], ptr [[REF_TMP3_I]], align 2, !alias.scope [[META50:![0-9]+]], !noalias [[META28]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META55:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP1_ASCAST_I]]) #[[ATTR9:[0-9]+]], !noalias [[META55]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP3_ASCAST_I]]) #[[ATTR9]], !noalias [[META55]]
+// CHECK-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
+// CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA58:![0-9]+]], !noalias [[META55]]
+// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META55]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META55]]
+// CHECK-NEXT:    [[VECINS_I_I_I]] = insertelement <2 x i16> [[VECINS_I_I10_I]], i16 [[CALL_I_I3_I_I]], i32 [[CONV_I]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP3_I]]) #[[ATTR8]], !noalias [[META28]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8]], !noalias [[META28]]
+// CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP60:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1plERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi2EEES7_.exit:
+// CHECK-NEXT:    store <2 x i16> [[VECINS_I_I10_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META28]]
+// CHECK-NEXT:    ret void
+//
 CHECKBINOP(ext::oneapi::bfloat16, BFA, +)
 
-// CHECK: icmp sgt <2 x i32> %{{.*}}
-// CHECK: sext <2 x i1> %{{.*}} to <2 x i32>
+// CHECK-LABEL: define dso_local spir_func void @_Z21CheckDevCodeBINOPINTLN4sycl3_V13vecIiLi2EEES2_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTL2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META61:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META62:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTL2A]], align 8, !tbaa [[TBAA10]], !noalias [[META62]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[INVECINTL2B]], align 8, !tbaa [[TBAA10]], !noalias [[META62]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i32> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i32>
+// CHECK-NEXT:    store <2 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META62]]
+// CHECK-NEXT:    ret void
+//
 CHECKBINOP(int, INTL, >)
 
-// CHECK: {{.*}} icmp sgt <2 x i8> %{{.*}}
-// CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPBYTELN4sycl3_V13vecISt4byteLi2EEES3_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTEL2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTEL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META65:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META66:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTEL2A]], align 2, !tbaa [[TBAA10]], !noalias [[META66]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBYTEL2B]], align 2, !tbaa [[TBAA10]], !noalias [[META66]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META66]]
+// CHECK-NEXT:    ret void
+//
 CHECKBINOP(std::byte, BYTEL, >)
 
-// CHECK: {{.*}} icmp ugt <2 x i8> %{{.*}}
-// CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPBOOLLN4sycl3_V13vecIbLi2EEES2_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 2 [[INVECBOOLL2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 2 [[INVECBOOLL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META69:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META70:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBOOLL2A]], align 2, !tbaa [[TBAA10]], !noalias [[META70]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBOOLL2B]], align 2, !tbaa [[TBAA10]], !noalias [[META70]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META70]]
+// CHECK-NEXT:    ret void
+//
 CHECKBINOP(bool, BOOLL, >)
 
-// CHECK: {{.*}} fcmp ogt <2 x half> {{.*}}
-// CHECK: {{.*}} sext <2 x i1> {{.*}} to <2 x i16>
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPHALFLN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEES5_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.5") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFL2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META73:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META74:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFL2A]], align 4, !tbaa [[TBAA10]], !noalias [[META74]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x half>, ptr [[INVECHALFL2B]], align 4, !tbaa [[TBAA10]], !noalias [[META74]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = fcmp ogt <2 x half> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
+// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META74]]
+// CHECK-NEXT:    ret void
+//
 CHECKBINOP(sycl::half, HALFL, >)
 
-// FIXME: Why do we treat BF16 as i16 when doing logical ops
-// but convert to float for arithmetic ops?
-// CHECK: {{.*}} icmp ugt <2 x i16> {{.*}}
-// CHECK: {{.*}} sext <2 x i1> {{.*}} to <2 x i16>
+// CHECK-LABEL: define dso_local spir_func void @_Z20CheckDevCodeBINOPBFLN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi2EEES5_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.5") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFL2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META77:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META78:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i16>, ptr [[INVECBFL2A]], align 4, !tbaa [[TBAA10]], !noalias [[META78]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i16>, ptr [[INVECBFL2B]], align 4, !tbaa [[TBAA10]], !noalias [[META78]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp ugt <2 x i16> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
+// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META78]]
+// CHECK-NEXT:    ret void
+//
 CHECKBINOP(ext::oneapi::bfloat16, BFL, >)
 
 /********************** Unary Ops **********************/
 
-// CHECK: {{.*}} icmp eq <2 x i32> %{{.*}}, zeroinitializer
-// CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i32>
+// CHECK-LABEL: define dso_local spir_func void @_Z21CheckDevCodeUOPINTNEGN4sycl3_V13vecIiLi2EEE(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTNEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META81:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec", align 8
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META82:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 8, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META82]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTNEG2]], align 8, !tbaa [[TBAA10]], !noalias [[META82]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <2 x i32> [[TMP0]], zeroinitializer
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i32>
+// CHECK-NEXT:    store <2 x i32> [[SEXT_I]], ptr [[REF_TMP_I]], align 8, !tbaa [[TBAA10]], !noalias [[META82]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META85:![0-9]+]])
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
+// CHECK:       for.cond.i.i.i:
+// CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
+// CHECK-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 8
+// CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIILI2EEE_EXIT:%.*]]
+// CHECK:       for.body.i.i.i:
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[REF_TMP_I]], i64 [[I_0_I_I_I]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META88:![0-9]+]]
+// CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
+// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META88]]
+// CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP89:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1ntERKNS0_3vecIiLi2EEE.exit:
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 8, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META82]]
+// CHECK-NEXT:    ret void
+//
 CHECKUOP(int, INTNEG, !, 1)
 
-// CHECK: {{.*}} sub <2 x i32> zeroinitializer, %{{.*}}
+// CHECK-LABEL: define dso_local spir_func void @_Z21CheckDevCodeUOPINTSUBN4sycl3_V13vecIiLi2EEE(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTSUB2:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META90:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META91:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTSUB2]], align 8, !tbaa [[TBAA10]], !noalias [[META91]]
+// CHECK-NEXT:    [[SUB_I:%.*]] = sub <2 x i32> zeroinitializer, [[TMP0]]
+// CHECK-NEXT:    store <2 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META91]]
+// CHECK-NEXT:    ret void
+//
 CHECKUOP(int, INTSUB, -, 1)
 
-// CHECK: %{{.*}} = icmp eq <2 x i8> %{{.*}}, zeroinitializer
-// CHECK: %{{.*}} = sext <2 x i1> %{{.*}} to <2 x i8>
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeUOPBYTENEGN4sycl3_V13vecISt4byteLi2EEE(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTENEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META94:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec.0", align 2
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META95:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META95]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTENEG2]], align 2, !tbaa [[TBAA10]], !noalias [[META95]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <2 x i8> [[TMP0]], zeroinitializer
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr [[REF_TMP_I]], align 2, !tbaa [[TBAA10]], !noalias [[META95]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META98:![0-9]+]])
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
+// CHECK:       for.cond.i.i.i:
+// CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
+// CHECK-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 2
+// CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIST4BYTELI2EEE_EXIT:%.*]]
+// CHECK:       for.body.i.i.i:
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[REF_TMP_I]], i64 [[I_0_I_I_I]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META101:![0-9]+]]
+// CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
+// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META101]]
+// CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP89]]
+// CHECK:       _ZN4sycl3_V1ntERKNS0_3vecISt4byteLi2EEE.exit:
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META95]]
+// CHECK-NEXT:    ret void
+//
 CHECKUOP(std::byte, BYTENEG, !, 1)
 
-// CHECK: {{.*}} sub <2 x i8> zeroinitializer, %{{.*}}
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeUOPBYTESUBN4sycl3_V13vecISt4byteLi2EEE(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTESUB2:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META102:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META103:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTESUB2]], align 2, !tbaa [[TBAA10]], !noalias [[META103]]
+// CHECK-NEXT:    [[SUB_I:%.*]] = sub <2 x i8> zeroinitializer, [[TMP0]]
+// CHECK-NEXT:    store <2 x i8> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META103]]
+// CHECK-NEXT:    ret void
+//
 CHECKUOP(std::byte, BYTESUB, -, -1)
 
-// CHECK: {{.*}} icmp eq <2 x i8> {{.*}}, zeroinitializer
-// CHECK: %{{.*}} sext <2 x i1> %{{.*}} to <2 x i8>
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeUOPBOOLNEGN4sycl3_V13vecIbLi2EEE(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 2 [[INVECBOOLNEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META106:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec.1", align 2
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META107:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META107]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBOOLNEG2]], align 2, !tbaa [[TBAA10]], !noalias [[META107]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <2 x i8> [[TMP0]], zeroinitializer
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr [[REF_TMP_I]], align 2, !tbaa [[TBAA10]], !noalias [[META107]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META110:![0-9]+]])
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
+// CHECK:       for.cond.i.i.i:
+// CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
+// CHECK-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 2
+// CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIBLI2EEE_EXIT:%.*]]
+// CHECK:       for.body.i.i.i:
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[REF_TMP_I]], i64 [[I_0_I_I_I]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META113:![0-9]+]]
+// CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
+// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META113]]
+// CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP89]]
+// CHECK:       _ZN4sycl3_V1ntERKNS0_3vecIbLi2EEE.exit:
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META107]]
+// CHECK-NEXT:    ret void
+//
 CHECKUOP(bool, BOOLNEG, !, 1)
 
-// CHECK: {{.*}} fcmp oeq <2 x half> %{{.*}}, zeroinitializer
-// CHECK: {{.*}} sext <2 x i1> %{{.*}} to <2 x i16>
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeUOPHALFNEGN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.5") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFNEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META114:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec.2", align 4
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META115:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META115]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFNEG2]], align 4, !tbaa [[TBAA10]], !noalias [[META115]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = fcmp oeq <2 x half> [[TMP0]], zeroinitializer
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
+// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA10]], !noalias [[META115]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META118:![0-9]+]])
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
+// CHECK:       for.cond.i.i.i:
+// CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
+// CHECK-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 4
+// CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECINS0_6DETAIL9HALF_IMPL4HALFELI2EEE_EXIT:%.*]]
+// CHECK:       for.body.i.i.i:
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[REF_TMP_I]], i64 [[I_0_I_I_I]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META121:![0-9]+]]
+// CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
+// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META121]]
+// CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP89]]
+// CHECK:       _ZN4sycl3_V1ntERKNS0_3vecINS0_6detail9half_impl4halfELi2EEE.exit:
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META115]]
+// CHECK-NEXT:    ret void
+//
 CHECKUOP(sycl::half, HALFNEG, !, 1)
 
-// CHECK: {{.*}} fneg <2 x half> %{{.*}}
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeUOPHALFSUBN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFSUB2:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META122:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META123:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFSUB2]], align 4, !tbaa [[TBAA10]], !noalias [[META123]]
+// CHECK-NEXT:    [[FNEG_I:%.*]] = fneg <2 x half> [[TMP0]]
+// CHECK-NEXT:    store <2 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META123]]
+// CHECK-NEXT:    ret void
+//
 CHECKUOP(sycl::half, HALFSUB, -, 1)
 
-// CHECK: for.cond{{.*}}
-// CHECK: {{.*}} fcmp oeq float %{{.*}}, 0.000000e+00
-// CHECK: {{.*}} uitofp i1 %{{.*}} to float
+// CHECK-LABEL: define dso_local spir_func void @_Z20CheckDevCodeUOPBFNEGN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi2EEE(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.5") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFNEG2:%.*]]) local_unnamed_addr #[[ATTR3]] !srcloc [[META126:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.3", align 4
+// CHECK-NEXT:    [[REF_TMP1_I:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[REF_TMP2_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META127:![0-9]+]])
+// CHECK-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
+// CHECK-NEXT:    [[REF_TMP2_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP2_I]] to ptr addrspace(4)
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[RET_I]]) #[[ATTR8]], !noalias [[META127]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i16>, ptr [[INVECBFNEG2]], align 4, !tbaa [[TBAA10]], !noalias [[META130:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK:       for.cond.i:
+// CHECK-NEXT:    [[TMP1:%.*]] = phi <2 x i16> [ zeroinitializer, [[ENTRY:%.*]] ], [ [[VECINS_I_I_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY]] ], [ [[INC_I:%.*]], [[FOR_BODY_I]] ]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_COND_CLEANUP_I:%.*]]
+// CHECK:       for.cond.cleanup.i:
+// CHECK-NEXT:    store <2 x i16> [[TMP1]], ptr [[RET_I]], align 1, !noalias [[META127]]
+// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META135:![0-9]+]])
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
+// CHECK:       for.cond.i.i.i:
+// CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_COND_CLEANUP_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
+// CHECK-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 4
+// CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI2EEE_EXIT:%.*]]
+// CHECK:       for.body.i.i.i:
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
+// CHECK-NEXT:    [[TMP2:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META138:![0-9]+]]
+// CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
+// CHECK-NEXT:    store i8 [[TMP2]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META138]]
+// CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP89]]
+// CHECK:       for.body.i:
+// CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8]], !noalias [[META127]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP2_I]]) #[[ATTR8]], !noalias [[META127]]
+// CHECK-NEXT:    [[VECEXT_I_I_I:%.*]] = extractelement <2 x i16> [[TMP0]], i32 [[CONV_I]]
+// CHECK-NEXT:    store i16 [[VECEXT_I_I_I]], ptr [[REF_TMP2_I]], align 2, !tbaa [[TBAA139:![0-9]+]], !alias.scope [[META141:![0-9]+]], !noalias [[META127]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP2_ASCAST_I]]) #[[ATTR9]], !noalias [[META127]]
+// CHECK-NEXT:    [[CMP_I_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
+// CHECK-NEXT:    [[CONV4_I:%.*]] = uitofp i1 [[CMP_I_I]] to float
+// CHECK-NEXT:    store float [[CONV4_I]], ptr [[REF_TMP1_I]], align 4, !tbaa [[TBAA58]], !noalias [[META127]]
+// CHECK-NEXT:    [[CALL_I_I10_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP1_ASCAST_I]]) #[[ATTR9]], !noalias [[META127]]
+// CHECK-NEXT:    [[VECINS_I_I_I]] = insertelement <2 x i16> [[TMP1]], i16 [[CALL_I_I10_I]], i32 [[CONV_I]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP2_I]]) #[[ATTR8]], !noalias [[META127]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8]], !noalias [[META127]]
+// CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP144:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1ntERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi2EEE.exit:
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[RET_I]]) #[[ATTR8]], !noalias [[META127]]
+// CHECK-NEXT:    ret void
+//
 CHECKUOP(ext::oneapi::bfloat16, BFNEG, !, 1)
 
-// CHECK: for{{.*}}
-// CHECK: {{.*}} fneg float %{{.*}}
+// CHECK-LABEL: define dso_local spir_func void @_Z20CheckDevCodeUOPBFSUBN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi2EEE(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.3") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFSUB2:%.*]]) local_unnamed_addr #[[ATTR5:[0-9]+]] !srcloc [[META145:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[V_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META146:![0-9]+]])
+// CHECK-NEXT:    [[V_ASCAST_I:%.*]] = addrspacecast ptr [[V_I]] to ptr addrspace(4)
+// CHECK-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META146]]
+// CHECK-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
+// CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK:       for.cond.i:
+// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_COND_I]] ]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
+// CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_I]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[V_I]]) #[[ATTR8]], !noalias [[META146]]
+// CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds <2 x i16>, ptr [[INVECBFSUB2]], i64 0, i64 [[I_0_I]]
+// CHECK-NEXT:    [[VECEXT_I:%.*]] = load i16, ptr [[TMP0]], align 2, !noalias [[META146]]
+// CHECK-NEXT:    store i16 [[VECEXT_I]], ptr [[V_I]], align 2, !tbaa [[TBAA149:![0-9]+]], !alias.scope [[META151:![0-9]+]], !noalias [[META146]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META154:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I:%.*]] = call spir_func float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[V_ASCAST_I]]) #[[ATTR9]], !noalias [[META154]]
+// CHECK-NEXT:    [[FNEG_I_I:%.*]] = fneg float [[CALL_I_I]]
+// CHECK-NEXT:    store float [[FNEG_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA58]], !noalias [[META154]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META154]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META154]]
+// CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds <2 x i16>, ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
+// CHECK-NEXT:    store i16 [[CALL_I_I_I_I]], ptr addrspace(4) [[TMP1]], align 2, !alias.scope [[META146]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[V_I]]) #[[ATTR8]], !noalias [[META146]]
+// CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP157:![0-9]+]]
+//
 CHECKUOP(ext::oneapi::bfloat16, BFSUB, -, 1)

From eb8b8b748cfeeb3ecdac3e3b9de985e3c38174d7 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Sun, 28 Apr 2024 10:53:18 -0700
Subject: [PATCH 36/79] Merge the test cases. Add detailed checks

---
 .../vector/vector_math_ops.cpp                | 355 ++++++++++--------
 .../vector/vector_storage.cpp                 | 112 ------
 2 files changed, 198 insertions(+), 269 deletions(-)
 delete mode 100644 sycl/test/check_device_code/vector/vector_storage.cpp

diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 7e541143c1c77..99fa1b9876045 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -1,6 +1,8 @@
 // RUN: %clangxx -I %sycl_include -S -emit-llvm -fno-sycl-instrument-device-code -fsycl-device-only %s -o - | FileCheck %s
 
-// This test checks the device code for various math operations on sycl::vec.
+// This test checks
+// (1) the storage type of sycl::vec on device for all data types, and
+// (2) the device code for various math operations on sycl::vec.
 #include <sycl/sycl.hpp>
 
 using namespace sycl;
@@ -18,10 +20,20 @@ using namespace sycl;
     return OP InVec##SUFFIX##2;                                                \
   }
 
-/********************** Binary Ops **********************/
+/*************** sycl::vec Storage Types ****************/
+
+// CHECK: [[VECINT2:.*]] = type { <2 x i32> }
+// CHECK: [[VECFLOAT2:.*]] = type { <2 x float> }
+// CHECK: [[VECCHAR2:.*]] = type { <2 x i8> }
+// CHECK: [[VECBYTE2:.*]] = type { <2 x i8> }
+// CHECK: [[VECBOOL2:.*]] = type { <2 x i8> }
+// CHECK: [[VECHALF2:.*]] = type { <2 x half> }
+// CHECK: [[VECBF2:.*]] = type { <2 x i16> }
+
+/*************** Binary Arithmetic Ops ******************/
 
 // CHECK-LABEL: define dso_local spir_func void @_Z21CheckDevCodeBINOPINTAN4sycl3_V13vecIiLi2EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTA2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTA2B:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] !srcloc [[META5:![0-9]+]] !sycl_fixed_targets [[META6:![0-9]+]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECINT2]]) align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECINT2]]) align 8 [[INVECINTA2A:%.*]], ptr nocapture noundef readonly byval([[VECINT2]]) align 8 [[INVECINTA2B:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] !srcloc [[META5:![0-9]+]] !sycl_fixed_targets [[META6:![0-9]+]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META7:![0-9]+]])
 // CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTA2A]], align 8, !tbaa [[TBAA10:![0-9]+]], !noalias [[META7]]
@@ -32,24 +44,48 @@ using namespace sycl;
 //
 CHECKBINOP(int, INTA, +)
 
-// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPBYTEAN4sycl3_V13vecISt4byteLi2EEES3_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTEA2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTEA2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META13:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-LABEL: define dso_local spir_func void @_Z23CheckDevCodeBINOPFLOATAN4sycl3_V13vecIfLi2EEES2_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECFLOAT2]]) align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECFLOAT2]]) align 8 [[INVECFLOATA2A:%.*]], ptr nocapture noundef readonly byval([[VECFLOAT2]]) align 8 [[INVECFLOATA2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META13:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META14:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTEA2A]], align 2, !tbaa [[TBAA10]], !noalias [[META14]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBYTEA2B]], align 2, !tbaa [[TBAA10]], !noalias [[META14]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x float>, ptr [[INVECFLOATA2A]], align 8, !tbaa [[TBAA10]], !noalias [[META14]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x float>, ptr [[INVECFLOATA2B]], align 8, !tbaa [[TBAA10]], !noalias [[META14]]
+// CHECK-NEXT:    [[ADD_I:%.*]] = fadd <2 x float> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    store <2 x float> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META14]]
+// CHECK-NEXT:    ret void
+//
+CHECKBINOP(float, FLOATA, +)
+
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPCHARAN4sycl3_V13vecIcLi2EEES2_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECCHAR2]]) align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECCHAR2]]) align 2 [[INVECCHARA2A:%.*]], ptr nocapture noundef readonly byval([[VECCHAR2]]) align 2 [[INVECCHARA2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META17:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META18:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECCHARA2A]], align 2, !tbaa [[TBAA10]], !noalias [[META18]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECCHARA2B]], align 2, !tbaa [[TBAA10]], !noalias [[META18]]
+// CHECK-NEXT:    [[ADD_I:%.*]] = add <2 x i8> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    store <2 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META18]]
+// CHECK-NEXT:    ret void
+//
+CHECKBINOP(char, CHARA, +)
+
+// CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPBYTEAN4sycl3_V13vecISt4byteLi2EEES3_(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECBYTE2]]) align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBYTE2]]) align 2 [[INVECBYTEA2A:%.*]], ptr nocapture noundef readonly byval([[VECBYTE2]]) align 2 [[INVECBYTEA2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META21:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META22:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTEA2A]], align 2, !tbaa [[TBAA10]], !noalias [[META22]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBYTEA2B]], align 2, !tbaa [[TBAA10]], !noalias [[META22]]
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <2 x i8> [[TMP0]], [[TMP1]]
-// CHECK-NEXT:    store <2 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META14]]
+// CHECK-NEXT:    store <2 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META22]]
 // CHECK-NEXT:    ret void
 //
 CHECKBINOP(std::byte, BYTEA, +)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPBOOLAN4sycl3_V13vecIbLi2EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.1") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 2 [[INVECBOOLA2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 2 [[INVECBOOLA2B:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] !srcloc [[META17:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECBOOL2]]) align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBOOL2]]) align 2 [[INVECBOOLA2A:%.*]], ptr nocapture noundef readonly byval([[VECBOOL2]]) align 2 [[INVECBOOLA2B:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] !srcloc [[META25:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META18:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBOOLA2A]], align 2, !tbaa [[TBAA10]], !noalias [[META18]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBOOLA2B]], align 2, !tbaa [[TBAA10]], !noalias [[META18]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META26:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBOOLA2A]], align 2, !tbaa [[TBAA10]], !noalias [[META26]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBOOLA2B]], align 2, !tbaa [[TBAA10]], !noalias [[META26]]
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <2 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    br label [[FOR_COND_I_I:%.*]]
 // CHECK:       for.cond.i.i:
@@ -64,38 +100,38 @@ CHECKBINOP(std::byte, BYTEA, +)
 // CHECK-NEXT:    [[FROMBOOL_I_I:%.*]] = zext i1 [[TOBOOL_I_I_I_I]] to i8
 // CHECK-NEXT:    [[VECINS_I_I_I_I]] = insertelement <2 x i8> [[VECINS_I_I6_I_I]], i8 [[FROMBOOL_I_I]], i32 [[CONV_I_I]]
 // CHECK-NEXT:    [[INC_I_I]] = add nuw nsw i64 [[I_0_I_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP21:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP29:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1plERKNS0_3vecIbLi2EEES4_.exit:
-// CHECK-NEXT:    store <2 x i8> [[VECINS_I_I6_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !alias.scope [[META18]]
+// CHECK-NEXT:    store <2 x i8> [[VECINS_I_I6_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !alias.scope [[META26]]
 // CHECK-NEXT:    ret void
 //
 CHECKBINOP(bool, BOOLA, +)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPHALFAN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFA2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFA2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META23:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECHALF2]]) align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECHALF2]]) align 4 [[INVECHALFA2A:%.*]], ptr nocapture noundef readonly byval([[VECHALF2]]) align 4 [[INVECHALFA2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META31:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META24:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFA2A]], align 4, !tbaa [[TBAA10]], !noalias [[META24]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x half>, ptr [[INVECHALFA2B]], align 4, !tbaa [[TBAA10]], !noalias [[META24]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META32:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFA2A]], align 4, !tbaa [[TBAA10]], !noalias [[META32]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x half>, ptr [[INVECHALFA2B]], align 4, !tbaa [[TBAA10]], !noalias [[META32]]
 // CHECK-NEXT:    [[ADD_I:%.*]] = fadd <2 x half> [[TMP0]], [[TMP1]]
-// CHECK-NEXT:    store <2 x half> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META24]]
+// CHECK-NEXT:    store <2 x half> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META32]]
 // CHECK-NEXT:    ret void
 //
 CHECKBINOP(sycl::half, HALFA, +)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z20CheckDevCodeBINOPBFAN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi2EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.3") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFA2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFA2B:%.*]]) local_unnamed_addr #[[ATTR3:[0-9]+]] !srcloc [[META27:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret([[VECBF2]]) align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBF2]]) align 4 [[INVECBFA2A:%.*]], ptr nocapture noundef readonly byval([[VECBF2]]) align 4 [[INVECBFA2B:%.*]]) local_unnamed_addr #[[ATTR3:[0-9]+]] !srcloc [[META35:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
 // CHECK-NEXT:    [[REF_TMP1_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
 // CHECK-NEXT:    [[REF_TMP3_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META28:![0-9]+]])
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META36:![0-9]+]])
 // CHECK-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
 // CHECK-NEXT:    [[REF_TMP3_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP3_I]] to ptr addrspace(4)
 // CHECK-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
-// CHECK-NEXT:    [[AGG_RESULT_PROMOTED_I:%.*]] = load <2 x i16>, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META28]]
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i16>, ptr [[INVECBFA2A]], align 4, !tbaa [[TBAA10]], !noalias [[META31:![0-9]+]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i16>, ptr [[INVECBFA2B]], align 4, !tbaa [[TBAA10]], !noalias [[META36:![0-9]+]]
+// CHECK-NEXT:    [[AGG_RESULT_PROMOTED_I:%.*]] = load <2 x i16>, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META36]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i16>, ptr [[INVECBFA2A]], align 4, !tbaa [[TBAA10]], !noalias [[META39:![0-9]+]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i16>, ptr [[INVECBFA2B]], align 4, !tbaa [[TBAA10]], !noalias [[META44:![0-9]+]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[VECINS_I_I10_I:%.*]] = phi <2 x i16> [ [[AGG_RESULT_PROMOTED_I]], [[ENTRY:%.*]] ], [ [[VECINS_I_I_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -104,95 +140,100 @@ CHECKBINOP(sycl::half, HALFA, +)
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI2EEES7__EXIT:%.*]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8:[0-9]+]], !noalias [[META28]]
-// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META41:![0-9]+]])
-// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META42:![0-9]+]])
-// CHECK-NEXT:    [[VECEXT_I_I_I:%.*]] = extractelement <2 x i16> [[TMP0]], i32 [[CONV_I]]
-// CHECK-NEXT:    store i16 [[VECEXT_I_I_I]], ptr [[REF_TMP1_I]], align 2, !alias.scope [[META43:![0-9]+]], !noalias [[META28]]
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP3_I]]) #[[ATTR8]], !noalias [[META28]]
-// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META48:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8:[0-9]+]], !noalias [[META36]]
 // CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META49:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META50:![0-9]+]])
+// CHECK-NEXT:    [[VECEXT_I_I_I:%.*]] = extractelement <2 x i16> [[TMP0]], i32 [[CONV_I]]
+// CHECK-NEXT:    store i16 [[VECEXT_I_I_I]], ptr [[REF_TMP1_I]], align 2, !alias.scope [[META51:![0-9]+]], !noalias [[META36]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP3_I]]) #[[ATTR8]], !noalias [[META36]]
+// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META56:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META57:![0-9]+]])
 // CHECK-NEXT:    [[VECEXT_I_I9_I:%.*]] = extractelement <2 x i16> [[TMP1]], i32 [[CONV_I]]
-// CHECK-NEXT:    store i16 [[VECEXT_I_I9_I]], ptr [[REF_TMP3_I]], align 2, !alias.scope [[META50:![0-9]+]], !noalias [[META28]]
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META55:![0-9]+]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP1_ASCAST_I]]) #[[ATTR9:[0-9]+]], !noalias [[META55]]
-// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP3_ASCAST_I]]) #[[ATTR9]], !noalias [[META55]]
+// CHECK-NEXT:    store i16 [[VECEXT_I_I9_I]], ptr [[REF_TMP3_I]], align 2, !alias.scope [[META58:![0-9]+]], !noalias [[META36]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META63:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP1_ASCAST_I]]) #[[ATTR9:[0-9]+]], !noalias [[META63]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP3_ASCAST_I]]) #[[ATTR9]], !noalias [[META63]]
 // CHECK-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
-// CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA58:![0-9]+]], !noalias [[META55]]
-// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META55]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META55]]
+// CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA66:![0-9]+]], !noalias [[META63]]
+// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META63]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META63]]
 // CHECK-NEXT:    [[VECINS_I_I_I]] = insertelement <2 x i16> [[VECINS_I_I10_I]], i16 [[CALL_I_I3_I_I]], i32 [[CONV_I]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP3_I]]) #[[ATTR8]], !noalias [[META28]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8]], !noalias [[META28]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP3_I]]) #[[ATTR8]], !noalias [[META36]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8]], !noalias [[META36]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP60:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP68:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1plERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi2EEES7_.exit:
-// CHECK-NEXT:    store <2 x i16> [[VECINS_I_I10_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META28]]
+// CHECK-NEXT:    store <2 x i16> [[VECINS_I_I10_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META36]]
 // CHECK-NEXT:    ret void
 //
 CHECKBINOP(ext::oneapi::bfloat16, BFA, +)
 
+/***************** Binary Logical Ops *******************/
+
 // CHECK-LABEL: define dso_local spir_func void @_Z21CheckDevCodeBINOPINTLN4sycl3_V13vecIiLi2EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTL2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META61:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECINT2]]) align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECINT2]]) align 8 [[INVECINTL2A:%.*]], ptr nocapture noundef readonly byval([[VECINT2]]) align 8 [[INVECINTL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META69:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META62:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTL2A]], align 8, !tbaa [[TBAA10]], !noalias [[META62]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[INVECINTL2B]], align 8, !tbaa [[TBAA10]], !noalias [[META62]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META70:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTL2A]], align 8, !tbaa [[TBAA10]], !noalias [[META70]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[INVECINTL2B]], align 8, !tbaa [[TBAA10]], !noalias [[META70]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i32> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i32>
-// CHECK-NEXT:    store <2 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META62]]
+// CHECK-NEXT:    store <2 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META70]]
 // CHECK-NEXT:    ret void
 //
 CHECKBINOP(int, INTL, >)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPBYTELN4sycl3_V13vecISt4byteLi2EEES3_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTEL2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTEL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META65:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.6") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBYTE2]]) align 2 [[INVECBYTEL2A:%.*]], ptr nocapture noundef readonly byval([[VECBYTE2]]) align 2 [[INVECBYTEL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META73:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META66:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTEL2A]], align 2, !tbaa [[TBAA10]], !noalias [[META66]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBYTEL2B]], align 2, !tbaa [[TBAA10]], !noalias [[META66]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META74:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTEL2A]], align 2, !tbaa [[TBAA10]], !noalias [[META74]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBYTEL2B]], align 2, !tbaa [[TBAA10]], !noalias [[META74]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
-// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META66]]
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META74]]
 // CHECK-NEXT:    ret void
 //
 CHECKBINOP(std::byte, BYTEL, >)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPBOOLLN4sycl3_V13vecIbLi2EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 2 [[INVECBOOLL2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 2 [[INVECBOOLL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META69:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.6") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBOOL2]]) align 2 [[INVECBOOLL2A:%.*]], ptr nocapture noundef readonly byval([[VECBOOL2]]) align 2 [[INVECBOOLL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META77:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META70:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBOOLL2A]], align 2, !tbaa [[TBAA10]], !noalias [[META70]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBOOLL2B]], align 2, !tbaa [[TBAA10]], !noalias [[META70]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META78:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBOOLL2A]], align 2, !tbaa [[TBAA10]], !noalias [[META78]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[INVECBOOLL2B]], align 2, !tbaa [[TBAA10]], !noalias [[META78]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
-// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META70]]
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META78]]
 // CHECK-NEXT:    ret void
 //
 CHECKBINOP(bool, BOOLL, >)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeBINOPHALFLN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.5") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFL2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META73:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.7") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECHALF2]]) align 4 [[INVECHALFL2A:%.*]], ptr nocapture noundef readonly byval([[VECHALF2]]) align 4 [[INVECHALFL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META81:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META74:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFL2A]], align 4, !tbaa [[TBAA10]], !noalias [[META74]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x half>, ptr [[INVECHALFL2B]], align 4, !tbaa [[TBAA10]], !noalias [[META74]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META82:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFL2A]], align 4, !tbaa [[TBAA10]], !noalias [[META82]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x half>, ptr [[INVECHALFL2B]], align 4, !tbaa [[TBAA10]], !noalias [[META82]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp ogt <2 x half> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
-// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META74]]
+// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META82]]
 // CHECK-NEXT:    ret void
 //
 CHECKBINOP(sycl::half, HALFL, >)
 
+// FIXME: Why do we interpret BF16 as INT16 to perform logical operations?
+// For arithmetic ops, we convert BF16 to float and then perform the operation.
+
 // CHECK-LABEL: define dso_local spir_func void @_Z20CheckDevCodeBINOPBFLN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi2EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.5") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFL2A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META77:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.7") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBF2]]) align 4 [[INVECBFL2A:%.*]], ptr nocapture noundef readonly byval([[VECBF2]]) align 4 [[INVECBFL2B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META85:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META78:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i16>, ptr [[INVECBFL2A]], align 4, !tbaa [[TBAA10]], !noalias [[META78]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i16>, ptr [[INVECBFL2B]], align 4, !tbaa [[TBAA10]], !noalias [[META78]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META86:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i16>, ptr [[INVECBFL2A]], align 4, !tbaa [[TBAA10]], !noalias [[META86]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i16>, ptr [[INVECBFL2B]], align 4, !tbaa [[TBAA10]], !noalias [[META86]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ugt <2 x i16> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
-// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META78]]
+// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META86]]
 // CHECK-NEXT:    ret void
 //
 CHECKBINOP(ext::oneapi::bfloat16, BFL, >)
@@ -200,16 +241,16 @@ CHECKBINOP(ext::oneapi::bfloat16, BFL, >)
 /********************** Unary Ops **********************/
 
 // CHECK-LABEL: define dso_local spir_func void @_Z21CheckDevCodeUOPINTNEGN4sycl3_V13vecIiLi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTNEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META81:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECINT2]]) align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECINT2]]) align 8 [[INVECINTNEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META89:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec", align 8
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META82:![0-9]+]])
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 8, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META82]]
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTNEG2]], align 8, !tbaa [[TBAA10]], !noalias [[META82]]
+// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca [[VECINT2]], align 8
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META90:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 8, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META90]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTNEG2]], align 8, !tbaa [[TBAA10]], !noalias [[META90]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <2 x i32> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i32>
-// CHECK-NEXT:    store <2 x i32> [[SEXT_I]], ptr [[REF_TMP_I]], align 8, !tbaa [[TBAA10]], !noalias [[META82]]
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META85:![0-9]+]])
+// CHECK-NEXT:    store <2 x i32> [[SEXT_I]], ptr [[REF_TMP_I]], align 8, !tbaa [[TBAA10]], !noalias [[META90]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META93:![0-9]+]])
 // CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
 // CHECK:       for.cond.i.i.i:
 // CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
@@ -217,39 +258,39 @@ CHECKBINOP(ext::oneapi::bfloat16, BFL, >)
 // CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIILI2EEE_EXIT:%.*]]
 // CHECK:       for.body.i.i.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[REF_TMP_I]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META88:![0-9]+]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META96:![0-9]+]]
 // CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META88]]
+// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META96]]
 // CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP89:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP97:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1ntERKNS0_3vecIiLi2EEE.exit:
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 8, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META82]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 8, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META90]]
 // CHECK-NEXT:    ret void
 //
 CHECKUOP(int, INTNEG, !, 1)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z21CheckDevCodeUOPINTSUBN4sycl3_V13vecIiLi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[INVECINTSUB2:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META90:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECINT2]]) align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECINT2]]) align 8 [[INVECINTSUB2:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META98:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META91:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTSUB2]], align 8, !tbaa [[TBAA10]], !noalias [[META91]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META99:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[INVECINTSUB2]], align 8, !tbaa [[TBAA10]], !noalias [[META99]]
 // CHECK-NEXT:    [[SUB_I:%.*]] = sub <2 x i32> zeroinitializer, [[TMP0]]
-// CHECK-NEXT:    store <2 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META91]]
+// CHECK-NEXT:    store <2 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META99]]
 // CHECK-NEXT:    ret void
 //
 CHECKUOP(int, INTSUB, -, 1)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeUOPBYTENEGN4sycl3_V13vecISt4byteLi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTENEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META94:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.6") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBYTE2]]) align 2 [[INVECBYTENEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META102:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec.0", align 2
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META95:![0-9]+]])
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META95]]
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTENEG2]], align 2, !tbaa [[TBAA10]], !noalias [[META95]]
+// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca [[VECBYTE2]], align 2
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META103:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META103]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTENEG2]], align 2, !tbaa [[TBAA10]], !noalias [[META103]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <2 x i8> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
-// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr [[REF_TMP_I]], align 2, !tbaa [[TBAA10]], !noalias [[META95]]
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META98:![0-9]+]])
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr [[REF_TMP_I]], align 2, !tbaa [[TBAA10]], !noalias [[META103]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META106:![0-9]+]])
 // CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
 // CHECK:       for.cond.i.i.i:
 // CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
@@ -257,39 +298,39 @@ CHECKUOP(int, INTSUB, -, 1)
 // CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIST4BYTELI2EEE_EXIT:%.*]]
 // CHECK:       for.body.i.i.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[REF_TMP_I]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META101:![0-9]+]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META109:![0-9]+]]
 // CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META101]]
+// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META109]]
 // CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP89]]
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP97]]
 // CHECK:       _ZN4sycl3_V1ntERKNS0_3vecISt4byteLi2EEE.exit:
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META95]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META103]]
 // CHECK-NEXT:    ret void
 //
 CHECKUOP(std::byte, BYTENEG, !, 1)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeUOPBYTESUBN4sycl3_V13vecISt4byteLi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 2 [[INVECBYTESUB2:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META102:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECBYTE2]]) align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBYTE2]]) align 2 [[INVECBYTESUB2:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META110:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META103:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTESUB2]], align 2, !tbaa [[TBAA10]], !noalias [[META103]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META111:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBYTESUB2]], align 2, !tbaa [[TBAA10]], !noalias [[META111]]
 // CHECK-NEXT:    [[SUB_I:%.*]] = sub <2 x i8> zeroinitializer, [[TMP0]]
-// CHECK-NEXT:    store <2 x i8> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META103]]
+// CHECK-NEXT:    store <2 x i8> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META111]]
 // CHECK-NEXT:    ret void
 //
 CHECKUOP(std::byte, BYTESUB, -, -1)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeUOPBOOLNEGN4sycl3_V13vecIbLi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 2 [[INVECBOOLNEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META106:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.6") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBOOL2]]) align 2 [[INVECBOOLNEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META114:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec.1", align 2
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META107:![0-9]+]])
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META107]]
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBOOLNEG2]], align 2, !tbaa [[TBAA10]], !noalias [[META107]]
+// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca [[VECBOOL2]], align 2
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META115:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META115]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[INVECBOOLNEG2]], align 2, !tbaa [[TBAA10]], !noalias [[META115]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <2 x i8> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
-// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr [[REF_TMP_I]], align 2, !tbaa [[TBAA10]], !noalias [[META107]]
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META110:![0-9]+]])
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr [[REF_TMP_I]], align 2, !tbaa [[TBAA10]], !noalias [[META115]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META118:![0-9]+]])
 // CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
 // CHECK:       for.cond.i.i.i:
 // CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
@@ -297,28 +338,28 @@ CHECKUOP(std::byte, BYTESUB, -, -1)
 // CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIBLI2EEE_EXIT:%.*]]
 // CHECK:       for.body.i.i.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[REF_TMP_I]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META113:![0-9]+]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META121:![0-9]+]]
 // CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META113]]
+// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META121]]
 // CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP89]]
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP97]]
 // CHECK:       _ZN4sycl3_V1ntERKNS0_3vecIbLi2EEE.exit:
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META107]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META115]]
 // CHECK-NEXT:    ret void
 //
 CHECKUOP(bool, BOOLNEG, !, 1)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeUOPHALFNEGN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.5") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFNEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META114:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.7") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECHALF2]]) align 4 [[INVECHALFNEG2:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META122:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec.2", align 4
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META115:![0-9]+]])
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META115]]
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFNEG2]], align 4, !tbaa [[TBAA10]], !noalias [[META115]]
+// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca [[VECHALF2]], align 4
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META123:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META123]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFNEG2]], align 4, !tbaa [[TBAA10]], !noalias [[META123]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp oeq <2 x half> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
-// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA10]], !noalias [[META115]]
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META118:![0-9]+]])
+// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA10]], !noalias [[META123]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META126:![0-9]+]])
 // CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
 // CHECK:       for.cond.i.i.i:
 // CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
@@ -326,39 +367,39 @@ CHECKUOP(bool, BOOLNEG, !, 1)
 // CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECINS0_6DETAIL9HALF_IMPL4HALFELI2EEE_EXIT:%.*]]
 // CHECK:       for.body.i.i.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[REF_TMP_I]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META121:![0-9]+]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META129:![0-9]+]]
 // CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META121]]
+// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META129]]
 // CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP89]]
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP97]]
 // CHECK:       _ZN4sycl3_V1ntERKNS0_3vecINS0_6detail9half_impl4halfELi2EEE.exit:
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META115]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]]) #[[ATTR8]], !noalias [[META123]]
 // CHECK-NEXT:    ret void
 //
 CHECKUOP(sycl::half, HALFNEG, !, 1)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z22CheckDevCodeUOPHALFSUBN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 4 [[INVECHALFSUB2:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META122:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECHALF2]]) align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECHALF2]]) align 4 [[INVECHALFSUB2:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META130:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META123:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFSUB2]], align 4, !tbaa [[TBAA10]], !noalias [[META123]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META131:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[INVECHALFSUB2]], align 4, !tbaa [[TBAA10]], !noalias [[META131]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg <2 x half> [[TMP0]]
-// CHECK-NEXT:    store <2 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META123]]
+// CHECK-NEXT:    store <2 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META131]]
 // CHECK-NEXT:    ret void
 //
 CHECKUOP(sycl::half, HALFSUB, -, 1)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z20CheckDevCodeUOPBFNEGN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.5") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFNEG2:%.*]]) local_unnamed_addr #[[ATTR3]] !srcloc [[META126:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.7") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBF2]]) align 4 [[INVECBFNEG2:%.*]]) local_unnamed_addr #[[ATTR3]] !srcloc [[META134:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.3", align 4
+// CHECK-NEXT:    [[RET_I:%.*]] = alloca [[VECBF2]], align 4
 // CHECK-NEXT:    [[REF_TMP1_I:%.*]] = alloca float, align 4
 // CHECK-NEXT:    [[REF_TMP2_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META127:![0-9]+]])
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META135:![0-9]+]])
 // CHECK-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
 // CHECK-NEXT:    [[REF_TMP2_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP2_I]] to ptr addrspace(4)
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[RET_I]]) #[[ATTR8]], !noalias [[META127]]
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i16>, ptr [[INVECBFNEG2]], align 4, !tbaa [[TBAA10]], !noalias [[META130:![0-9]+]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[RET_I]]) #[[ATTR8]], !noalias [[META135]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i16>, ptr [[INVECBFNEG2]], align 4, !tbaa [[TBAA10]], !noalias [[META138:![0-9]+]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[TMP1:%.*]] = phi <2 x i16> [ zeroinitializer, [[ENTRY:%.*]] ], [ [[VECINS_I_I_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -366,8 +407,8 @@ CHECKUOP(sycl::half, HALFSUB, -, 1)
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_COND_CLEANUP_I:%.*]]
 // CHECK:       for.cond.cleanup.i:
-// CHECK-NEXT:    store <2 x i16> [[TMP1]], ptr [[RET_I]], align 1, !noalias [[META127]]
-// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META135:![0-9]+]])
+// CHECK-NEXT:    store <2 x i16> [[TMP1]], ptr [[RET_I]], align 1, !noalias [[META135]]
+// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META143:![0-9]+]])
 // CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
 // CHECK:       for.cond.i.i.i:
 // CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_COND_CLEANUP_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
@@ -375,61 +416,61 @@ CHECKUOP(sycl::half, HALFSUB, -, 1)
 // CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI2EEE_EXIT:%.*]]
 // CHECK:       for.body.i.i.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    [[TMP2:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META138:![0-9]+]]
+// CHECK-NEXT:    [[TMP2:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, !tbaa [[TBAA10]], !noalias [[META146:![0-9]+]]
 // CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    store i8 [[TMP2]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META138]]
+// CHECK-NEXT:    store i8 [[TMP2]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META146]]
 // CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP89]]
+// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP97]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8]], !noalias [[META127]]
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP2_I]]) #[[ATTR8]], !noalias [[META127]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8]], !noalias [[META135]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP2_I]]) #[[ATTR8]], !noalias [[META135]]
 // CHECK-NEXT:    [[VECEXT_I_I_I:%.*]] = extractelement <2 x i16> [[TMP0]], i32 [[CONV_I]]
-// CHECK-NEXT:    store i16 [[VECEXT_I_I_I]], ptr [[REF_TMP2_I]], align 2, !tbaa [[TBAA139:![0-9]+]], !alias.scope [[META141:![0-9]+]], !noalias [[META127]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP2_ASCAST_I]]) #[[ATTR9]], !noalias [[META127]]
+// CHECK-NEXT:    store i16 [[VECEXT_I_I_I]], ptr [[REF_TMP2_I]], align 2, !tbaa [[TBAA147:![0-9]+]], !alias.scope [[META149:![0-9]+]], !noalias [[META135]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP2_ASCAST_I]]) #[[ATTR9]], !noalias [[META135]]
 // CHECK-NEXT:    [[CMP_I_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
 // CHECK-NEXT:    [[CONV4_I:%.*]] = uitofp i1 [[CMP_I_I]] to float
-// CHECK-NEXT:    store float [[CONV4_I]], ptr [[REF_TMP1_I]], align 4, !tbaa [[TBAA58]], !noalias [[META127]]
-// CHECK-NEXT:    [[CALL_I_I10_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP1_ASCAST_I]]) #[[ATTR9]], !noalias [[META127]]
+// CHECK-NEXT:    store float [[CONV4_I]], ptr [[REF_TMP1_I]], align 4, !tbaa [[TBAA66]], !noalias [[META135]]
+// CHECK-NEXT:    [[CALL_I_I10_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP1_ASCAST_I]]) #[[ATTR9]], !noalias [[META135]]
 // CHECK-NEXT:    [[VECINS_I_I_I]] = insertelement <2 x i16> [[TMP1]], i16 [[CALL_I_I10_I]], i32 [[CONV_I]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP2_I]]) #[[ATTR8]], !noalias [[META127]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8]], !noalias [[META127]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP2_I]]) #[[ATTR8]], !noalias [[META135]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP1_I]]) #[[ATTR8]], !noalias [[META135]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP144:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP152:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1ntERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi2EEE.exit:
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[RET_I]]) #[[ATTR8]], !noalias [[META127]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[RET_I]]) #[[ATTR8]], !noalias [[META135]]
 // CHECK-NEXT:    ret void
 //
 CHECKUOP(ext::oneapi::bfloat16, BFNEG, !, 1)
 
 // CHECK-LABEL: define dso_local spir_func void @_Z20CheckDevCodeUOPBFSUBN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.3") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[INVECBFSUB2:%.*]]) local_unnamed_addr #[[ATTR5:[0-9]+]] !srcloc [[META145:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret([[VECBF2]]) align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval([[VECBF2]]) align 4 [[INVECBFSUB2:%.*]]) local_unnamed_addr #[[ATTR5:[0-9]+]] !srcloc [[META153:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
 // CHECK-NEXT:    [[V_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META146:![0-9]+]])
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META154:![0-9]+]])
 // CHECK-NEXT:    [[V_ASCAST_I:%.*]] = addrspacecast ptr [[V_I]] to ptr addrspace(4)
-// CHECK-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META146]]
+// CHECK-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META154]]
 // CHECK-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_COND_I]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
 // CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_I]])
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[V_I]]) #[[ATTR8]], !noalias [[META146]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[V_I]]) #[[ATTR8]], !noalias [[META154]]
 // CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds <2 x i16>, ptr [[INVECBFSUB2]], i64 0, i64 [[I_0_I]]
-// CHECK-NEXT:    [[VECEXT_I:%.*]] = load i16, ptr [[TMP0]], align 2, !noalias [[META146]]
-// CHECK-NEXT:    store i16 [[VECEXT_I]], ptr [[V_I]], align 2, !tbaa [[TBAA149:![0-9]+]], !alias.scope [[META151:![0-9]+]], !noalias [[META146]]
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META154:![0-9]+]]
-// CHECK-NEXT:    [[CALL_I_I:%.*]] = call spir_func float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[V_ASCAST_I]]) #[[ATTR9]], !noalias [[META154]]
+// CHECK-NEXT:    [[VECEXT_I:%.*]] = load i16, ptr [[TMP0]], align 2, !noalias [[META154]]
+// CHECK-NEXT:    store i16 [[VECEXT_I]], ptr [[V_I]], align 2, !tbaa [[TBAA157:![0-9]+]], !alias.scope [[META159:![0-9]+]], !noalias [[META154]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META162:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I:%.*]] = call spir_func float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[V_ASCAST_I]]) #[[ATTR9]], !noalias [[META162]]
 // CHECK-NEXT:    [[FNEG_I_I:%.*]] = fneg float [[CALL_I_I]]
-// CHECK-NEXT:    store float [[FNEG_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA58]], !noalias [[META154]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META154]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META154]]
+// CHECK-NEXT:    store float [[FNEG_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA66]], !noalias [[META162]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META162]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]) #[[ATTR8]], !noalias [[META162]]
 // CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds <2 x i16>, ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CALL_I_I_I_I]], ptr addrspace(4) [[TMP1]], align 2, !alias.scope [[META146]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[V_I]]) #[[ATTR8]], !noalias [[META146]]
+// CHECK-NEXT:    store i16 [[CALL_I_I_I_I]], ptr addrspace(4) [[TMP1]], align 2, !alias.scope [[META154]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[V_I]]) #[[ATTR8]], !noalias [[META154]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP157:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP165:![0-9]+]]
 //
 CHECKUOP(ext::oneapi::bfloat16, BFSUB, -, 1)
diff --git a/sycl/test/check_device_code/vector/vector_storage.cpp b/sycl/test/check_device_code/vector/vector_storage.cpp
deleted file mode 100644
index 061e24083324c..0000000000000
--- a/sycl/test/check_device_code/vector/vector_storage.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-// RUN: %clangxx -I %sycl_include -S -emit-llvm -fsycl-device-only %s -o - -Xclang -disable-llvm-passes -Xclang -no-enable-noundef-analysis | FileCheck %s
-
-// This test checks the storage type of sycl::vec on device for
-// all data types.
-#include <sycl/sycl.hpp>
-
-using namespace sycl;
-
-// Create sycl::vec for each type and verify the storage
-// type on device side.
-#define CHECK(T, SUFFIX)                                                       \
-  SYCL_EXTERNAL void CheckDevCode##SUFFIX() {                                  \
-    vec<T, 2> InVec##SUFFIX##2 {static_cast<T>(5)};                            \
-    vec<T, 3> InVec##SUFFIX##3 {static_cast<T>(5)};                            \
-    vec<T, 4> InVec##SUFFIX##4 {static_cast<T>(5)};                            \
-    vec<T, 8> InVec##SUFFIX##8 {static_cast<T>(5)};                            \
-    vec<T, 16> InVec##SUFFIX##16 {static_cast<T>(5)};                          \
-  }
-
-// CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
-// CHECK: {{.*}}std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-// CHECK: {{.*}}std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-// CHECK: {{.*}}std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-// CHECK: {{.*}}std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-// CHECK: {{.*}}std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-CHECK(ext::oneapi::bfloat16, BF)
-
-// CHECK: {{.*}}InVecINT2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i32> {{.*}}
-// CHECK: {{.*}}InVecINT3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i32> {{.*}}
-// CHECK: {{.*}}InVecINT4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i32> {{.*}}
-// CHECK: {{.*}}InVecINT8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i32> {{.*}}
-// CHECK: {{.*}}InVecINT16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i32> {{.*}}
-CHECK(int, INT)
-
-// CHECK: {{.*}}InVecFLOAT2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x float> {{.*}}
-// CHECK: {{.*}}InVecFLOAT3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x float> {{.*}}
-// CHECK: {{.*}}InVecFLOAT4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x float> {{.*}}
-// CHECK: {{.*}}InVecFLOAT8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x float> {{.*}}
-// CHECK: {{.*}}InVecFLOAT16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x float> {{.*}}
-CHECK(float, FLOAT)
-
-// CHECK: {{.*}}InVecCHAR2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
-// CHECK: {{.*}}InVecCHAR3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
-// CHECK: {{.*}}InVecCHAR4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
-// CHECK: {{.*}}InVecCHAR8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
-// CHECK: {{.*}}InVecCHAR16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
-CHECK(char, CHAR)
-
-// CHECK: {{.*}}InVecBOOL2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
-// CHECK: {{.*}}InVecBOOL3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
-// CHECK: {{.*}}InVecBOOL4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
-// CHECK: {{.*}}InVecBOOL8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
-// CHECK: {{.*}}InVecBOOL16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
-CHECK(bool, BOOL)
-
-// CHECK: {{.*}}InVecHALF2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x half> {{.*}}
-// CHECK: {{.*}}InVecHALF3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x half> {{.*}}
-// CHECK: {{.*}}InVecHALF4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x half> {{.*}}
-// CHECK: {{.*}}InVecHALF8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x half> {{.*}}
-// CHECK: {{.*}}InVecHALF16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x half> {{.*}}
-CHECK(half, HALF)
-
-// CHECK: {{.*}}InVecBYTE2 = {{.*}}sycl::_V1::vec{{.*}}" { <2 x i8> {{.*}}
-// CHECK: {{.*}}InVecBYTE3 = {{.*}}sycl::_V1::vec{{.*}}" { <3 x i8> {{.*}}
-// CHECK: {{.*}}InVecBYTE4 = {{.*}}sycl::_V1::vec{{.*}}" { <4 x i8> {{.*}}
-// CHECK: {{.*}}InVecBYTE8 = {{.*}}sycl::_V1::vec{{.*}}" { <8 x i8> {{.*}}
-// CHECK: {{.*}}InVecBYTE16 = {{.*}}sycl::_V1::vec{{.*}}" { <16 x i8> {{.*}}
-CHECK(std::byte, BYTE)
-
-// Check alignment of the allocated sycl::vec
-
-// CHECK: %InVecBF2 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-// CHECK: %InVecBF3 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-// CHECK: %InVecBF4 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-// CHECK: %InVecBF8 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-// CHECK: %InVecBF16 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
-
-// CHECK: %InVecINT2 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-// CHECK: %InVecINT3 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-// CHECK: %InVecINT4 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-// CHECK: %InVecINT8 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
-// CHECK: %InVecINT16 = alloca %"class.sycl::_V1::vec{{.*}}", align 64
-
-// CHECK: %InVecFLOAT2 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-// CHECK: %InVecFLOAT3 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-// CHECK: %InVecFLOAT4 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-// CHECK: %InVecFLOAT8 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
-// CHECK: %InVecFLOAT16 = alloca %"class.sycl::_V1::vec{{.*}}", align 64
-
-// CHECK: %InVecCHAR2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
-// CHECK: %InVecCHAR3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-// CHECK: %InVecCHAR4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-// CHECK: %InVecCHAR8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-// CHECK: %InVecCHAR16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-
-// CHECK: %InVecBOOL2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
-// CHECK: %InVecBOOL3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-// CHECK: %InVecBOOL4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-// CHECK: %InVecBOOL8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-// CHECK: %InVecBOOL16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-
-// CHECK: %InVecHALF2 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-// CHECK: %InVecHALF3 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-// CHECK: %InVecHALF4 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-// CHECK: %InVecHALF8 = alloca %"class.sycl::_V1::vec{{.*}}", align 16
-// CHECK: %InVecHALF16 = alloca %"class.sycl::_V1::vec{{.*}}", align 32
-
-// CHECK: %InVecBYTE2 = alloca %"class.sycl::_V1::vec{{.*}}", align 2
-// CHECK: %InVecBYTE3 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-// CHECK: %InVecBYTE4 = alloca %"class.sycl::_V1::vec{{.*}}", align 4
-// CHECK: %InVecBYTE8 = alloca %"class.sycl::_V1::vec{{.*}}", align 8
-// CHECK: %InVecBYTE16 = alloca %"class.sycl::_V1::vec{{.*}}", align 16

From ec0717d5b12b77527245bbba07cbdbd302602d0b Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Mon, 29 Apr 2024 06:36:47 -0700
Subject: [PATCH 37/79] Don't use ext_vector for bool with ! operator

---
 sycl/include/sycl/vector_preview.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 46964b6ee30ad..1f1dcdf271fc3 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -1097,6 +1097,7 @@ template <typename Type, int NumElements> class vec {
 #ifdef __SYCL_DEVICE_ONLY__
     if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
                   !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
+                  !std::is_same_v<DataT, bool> &&
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
                   !std::is_same_v<DataT, std::byte>)
 #else

From 3b652fb13b3bfb532faf5a3a63f27c2a001299bb Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 30 Apr 2024 09:08:40 -0700
Subject: [PATCH 38/79] Remove redundant changes

---
 sycl/include/sycl/types.hpp                   |  1 -
 .../math-builtins/vector.cpp                  | 79 -------------------
 2 files changed, 80 deletions(-)
 delete mode 100644 sycl/test/check_device_code/math-builtins/vector.cpp

diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index d7ce59fb9c83d..0ac53ecdd5731 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -108,4 +108,3 @@ struct CheckDeviceCopyable<
 } // namespace detail
 } // namespace _V1
 } // namespace sycl
-
diff --git a/sycl/test/check_device_code/math-builtins/vector.cpp b/sycl/test/check_device_code/math-builtins/vector.cpp
deleted file mode 100644
index f7bfd511f0c1a..0000000000000
--- a/sycl/test/check_device_code/math-builtins/vector.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-// RUN: %if preview-breaking-changes-supported %{ %clangxx -fpreview-breaking-changes -fsycl-device-only -S -O0 -Xclang -emit-llvm -o - %s | FileCheck %s %}
-
-// This test checks that sycl::vec uses std::array as storage type on device for
-// all data types.
-#include <sycl/sycl.hpp>
-
-using namespace sycl;
-
-// Create sycl::vec for each type and verify the storage
-// type on device side.
-#define CHECK(Q, T, N)                                                         \
-  {                                                                            \
-    Q.submit([&](handler &CGH) {                                               \
-      CGH.single_task([=]() {                                                  \
-        vec<T, 2> InVec##N##2 {static_cast<T>(5)};                             \
-        vec<T, 3> InVec##N##3 {static_cast<T>(5)};                             \
-        vec<T, 4> InVec##N##4 {static_cast<T>(5)};                             \
-        vec<T, 8> InVec##N##8 {static_cast<T>(5)};                             \
-        vec<T, 16> InVec##N##16 {static_cast<T>(5)};                           \
-      });                                                                      \
-    });                                                                        \
-  }
-
-int main() {
-
-  queue q;
-
-  // CHECK: %"class.sycl::_V1::ext::oneapi::bfloat16" = type { i16 }
-  // CHECK: {{.*}}std::array{{.*}}" = type { [2 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: {{.*}}std::array{{.*}}" = type { [3 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: {{.*}}std::array{{.*}}" = type { [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: {{.*}}std::array{{.*}}" = type { [8 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  // CHECK: {{.*}}std::array{{.*}}" = type { [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"] }
-  CHECK(q, ext::oneapi::bfloat16, BF)
-
-  // CHECK: {{.*}}InVecINT2 = {{.*}}std::array{{.*}}" { [2 x i32] {{.*}}
-  // CHECK: {{.*}}InVecINT3 = {{.*}}std::array.{{.*}}" { [4 x i32] {{.*}}
-  // CHECK: {{.*}}InVecINT4 = {{.*}}std::array.{{.*}}" { [4 x i32] {{.*}}
-  // CHECK: {{.*}}InVecINT8 = {{.*}}std::array.{{.*}}" { [8 x i32] {{.*}}
-  // CHECK: {{.*}}InVecINT16 = {{.*}}std::array.{{.*}}" { [16 x i32] {{.*}}
-  CHECK(q, int, INT)
-
-  // CHECK: {{.*}}InVecFLOAT2 = {{.*}}std::array.{{.*}}" { [2 x float] {{.*}}
-  // CHECK: {{.*}}InVecFLOAT3 = {{.*}}std::array.{{.*}}" { [4 x float] {{.*}}
-  // CHECK: {{.*}}InVecFLOAT4 = {{.*}}std::array.{{.*}}" { [4 x float] {{.*}}
-  // CHECK: {{.*}}InVecFLOAT8 = {{.*}}std::array.{{.*}}" { [8 x float] {{.*}}
-  // CHECK: {{.*}}InVecFLOAT16 = {{.*}}std::array.{{.*}}" { [16 x float] {{.*}}
-  CHECK(q, float, FLOAT)
-
-  // CHECK: {{.*}}InVecCHAR2 = {{.*}}std::array.{{.*}}" { [2 x i8] {{.*}}
-  // CHECK: {{.*}}InVecCHAR3 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecCHAR4 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecCHAR8 = {{.*}}std::array.{{.*}}" { [8 x i8] {{.*}}
-  // CHECK: {{.*}}InVecCHAR16 = {{.*}}std::array.{{.*}}" { [16 x i8] {{.*}}
-  CHECK(q, char, CHAR)
-
-  // CHECK: {{.*}}InVecBOOL2 = {{.*}}std::array.{{.*}}" { [2 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBOOL3 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBOOL4 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBOOL8 = {{.*}}std::array.{{.*}}" { [8 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBOOL16 = {{.*}}std::array.{{.*}}" { [16 x i8] {{.*}}
-  CHECK(q, bool, BOOL)
-
-  // CHECK: {{.*}}InVecHALF2 = {{.*}}std::array.{{.*}}" { [2 x %"class.sycl::_V1::detail::half_impl::half"] {{.*}}
-  // CHECK: {{.*}}InVecHALF3 = {{.*}}std::array.{{.*}}" { [4 x %"class.sycl::_V1::detail::half_impl::half"] {{.*}}
-  // CHECK: {{.*}}InVecHALF4 = {{.*}}std::array.{{.*}}" { [4 x %"class.sycl::_V1::detail::half_impl::half"] {{.*}}
-  // CHECK: {{.*}}InVecHALF8 = {{.*}}std::array.{{.*}}" { [8 x %"class.sycl::_V1::detail::half_impl::half"] {{.*}}
-  // CHECK: {{.*}}InVecHALF16 = {{.*}}std::array.{{.*}}" { [16 x %"class.sycl::_V1::detail::half_impl::half"] {{.*}}
-  CHECK(q, half, HALF)
-
-  // CHECK: {{.*}}InVecBYTE2 = {{.*}}std::array.{{.*}}" { [2 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBYTE3 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBYTE4 = {{.*}}std::array.{{.*}}" { [4 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBYTE8 = {{.*}}std::array.{{.*}}" { [8 x i8] {{.*}}
-  // CHECK: {{.*}}InVecBYTE16 = {{.*}}std::array.{{.*}}" { [16 x i8] {{.*}}
-  CHECK(q, std::byte, BYTE)
-
-  return 0;
-};

From 55329df88a027b596f154060c7f6fe28dcf1e69e Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 1 May 2024 13:49:38 -0700
Subject: [PATCH 39/79] Update vec device code test

---
 sycl/include/sycl/vector_preview.hpp           | 7 +++----
 sycl/test/self-contained-headers/lit.local.cfg | 3 +++
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 1f1dcdf271fc3..a9f44ea6ccaf3 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -89,7 +89,7 @@ using select_apply_cl_t = std::conditional_t<
     sizeof(_IN) == 1, T8,
     std::conditional_t<sizeof(_IN) == 2, T16,
                        std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
-    
+
 // Helper function to bit_cast one type to another.
 template <typename FromType, typename ToType>
 static constexpr ToType BitCast(const FromType &Value) {
@@ -581,7 +581,7 @@ template <typename Type, int NumElements> class vec {
       std::is_fundamental_v<vec_data_t<Ty>> ||
           detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
-  operator=(const Ty & Rhs) {
+  operator=(const Ty &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
     }
@@ -1211,8 +1211,7 @@ template <typename Type, int NumElements> class vec {
 #ifdef __SYCL_DEVICE_ONLY__
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(Ty Index, const DataT &Value,
-                          int) {
+  constexpr void setValue(Ty Index, const DataT &Value, int) {
     m_Data[Index] = vec_data<DataT>::set(Value);
   }
 
diff --git a/sycl/test/self-contained-headers/lit.local.cfg b/sycl/test/self-contained-headers/lit.local.cfg
index d61551742dd85..b08ac4823e536 100644
--- a/sycl/test/self-contained-headers/lit.local.cfg
+++ b/sycl/test/self-contained-headers/lit.local.cfg
@@ -13,4 +13,7 @@ config.sycl_headers_xfail = [
     os.path.join(
         "sycl", "ext", "intel", "esimd", "detail", "types_elementary.hpp"
     ),
+    os.path.join(
+        "sycl", "vector_preview.hpp"
+    ),
 ]

From fc95f45a4f67dded16639b69f8373e389d7c1471 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 1 May 2024 14:02:33 -0700
Subject: [PATCH 40/79] Update test

---
 .../vector/vector_math_ops.cpp                | 448 ++++++++++++++++++
 1 file changed, 448 insertions(+)

diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 979c0f21864d6..b66a3dc06f978 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -4,6 +4,7 @@
 // ./sycl/test/check_device_code/vector/vector_math_ops.cpp
 
 // RUN: %clangxx -I %sycl_include -S -emit-llvm -fno-sycl-instrument-device-code -Xclang -disable-lifetime-markers -fsycl-device-only %s -o - | FileCheck %s
+// RUN: %if preview-breaking-changes-supported %{ %clangxx -I %sycl_include -S -emit-llvm -fpreview-breaking-changes -fno-sycl-instrument-device-code -Xclang -disable-lifetime-markers -fsycl-device-only %s -o - | FileCheck %s -check-prefix=CHECK-ARR-STORAGE %}
 
 // This test checks
 // (1) the storage type of sycl::vec on device for all data types, and
@@ -23,6 +24,15 @@ using namespace sycl;
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <2 x i32> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    store <2 x i32> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIiLi2EEES2_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[A]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[B]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <2 x i32> [[TMP0]], [[TMP1]]
+// CHECK-ARR-STORAGE-NEXT:    store <2 x i32> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<int, 2> a, vec<int, 2> b) { return a + b; }
 
@@ -36,6 +46,16 @@ SYCL_EXTERNAL auto TestAdd(vec<int, 2> a, vec<int, 2> b) { return a + b; }
 // CHECK-NEXT:    [[EXTRACTVEC5_I:%.*]] = shufflevector <4 x float> [[TMP0]], <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
 // CHECK-NEXT:    store <4 x float> [[EXTRACTVEC5_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIfLi3EEES2_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x float>, ptr [[A]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I7_I:%.*]] = load <4 x float>, ptr [[B]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = fadd <4 x float> [[LOADVEC4_I_I]], [[LOADVEC4_I7_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I9_I:%.*]] = shufflevector <4 x float> [[TMP0]], <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-ARR-STORAGE-NEXT:    store <4 x float> [[EXTRACTVEC_I9_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<float, 3> a, vec<float, 3> b) { return a + b; }
 
@@ -48,6 +68,15 @@ SYCL_EXTERNAL auto TestAdd(vec<float, 3> a, vec<float, 3> b) { return a + b; }
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <16 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    store <16 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIcLi16EEES2_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <16 x i8>, ptr [[B]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <16 x i8> [[TMP0]], [[TMP1]]
+// CHECK-ARR-STORAGE-NEXT:    store <16 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<char, 16> a, vec<char, 16> b) { return a + b; }
 
@@ -60,6 +89,15 @@ SYCL_EXTERNAL auto TestAdd(vec<char, 16> a, vec<char, 16> b) { return a + b; }
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <8 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    store <8 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecISt4byteLi8EEES3_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x i8>, ptr [[A]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <8 x i8>, ptr [[B]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <8 x i8> [[TMP0]], [[TMP1]]
+// CHECK-ARR-STORAGE-NEXT:    store <8 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<std::byte, 8> a, vec<std::byte, 8> b) {
   return a + b;
@@ -89,6 +127,29 @@ SYCL_EXTERNAL auto TestAdd(vec<std::byte, 8> a, vec<std::byte, 8> b) {
 // CHECK:       _ZN4sycl3_V1plERKNS0_3vecIbLi4EEES4_.exit:
 // CHECK-NEXT:    store <4 x i8> [[VECINS_I_I6_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIbLi4EEES2_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.6") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <4 x i8>, ptr [[B]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <4 x i8> [[TMP0]], [[TMP1]]
+// CHECK-ARR-STORAGE-NEXT:    store <4 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I:%.*]], [[FOR_BODY_I_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = icmp ult i64 [[I_0_I_I]], 4
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECIBLI4EEES4__EXIT:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP2:%.*]] = load i8, ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I_I_I_I:%.*]] = icmp ne i8 [[TMP2]], 0
+// CHECK-ARR-STORAGE-NEXT:    [[FROMBOOL_I_I:%.*]] = zext i1 [[TOBOOL_I_I_I_I]] to i8
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[FROMBOOL_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I_I]] = add nuw nsw i64 [[I_0_I_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP29:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1plERKNS0_3vecIbLi4EEES4_.exit:
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
 
@@ -102,6 +163,27 @@ SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
 // CHECK-NEXT:    [[EXTRACTVEC5_I:%.*]] = shufflevector <4 x half> [[TMP0]], <4 x half> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
 // CHECK-NEXT:    store <4 x half> [[EXTRACTVEC5_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_6detail9half_impl4halfELi3EEES5_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECINS0_6DETAIL9HALF_IMPL4HALFELI3EEES7__EXIT:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[A]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I9_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[B]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load half, ptr [[ARRAYIDX_I_I_I_I9_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ADD_I_I_I:%.*]] = fadd half [[TMP1]], [[TMP0]]
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I13_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::detail::half_impl::half"], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store half [[ADD_I_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I13_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP48:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1plERKNS0_3vecINS0_6detail9half_impl4halfELi3EEES7_.exit:
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 
@@ -153,6 +235,49 @@ SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP3_I]])
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEES5_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP3_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP3_I]])
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP3_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP3_I]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI3EEES7__EXIT:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i:
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[A]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP0]], ptr [[REF_TMP1_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I10_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[B]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I_I10_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP1]], ptr [[REF_TMP3_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP1_ASCAST_I]]) #[[ATTR8:[0-9]+]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP3_ASCAST_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I12_I:%.*]] = getelementptr inbounds [4 x i16], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I12_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP88:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1plERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi3EEES7_.exit:
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP3_I]])
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
                            vec<ext::oneapi::bfloat16, 3> b) {
@@ -171,6 +296,16 @@ SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <16 x i1> [[CMP_I]] to <16 x i32>
 // CHECK-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIiLi16EEES2_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp sgt <16 x i32> [[TMP0]], [[TMP1]]
+// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <16 x i1> [[CMP_I]] to <16 x i32>
+// CHECK-ARR-STORAGE-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
   return a > b;
@@ -188,6 +323,18 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
 // CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
 // CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecISt4byteLi3EEES3_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I7_I:%.*]] = load <4 x i8>, ptr [[B]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = icmp sgt <4 x i8> [[LOADVEC4_I_I]], [[LOADVEC4_I7_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = shufflevector <4 x i1> [[TMP0]], <4 x i1> poison, <3 x i32> <i32 0, i32 1, i32 2>
+// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i8>
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I9_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-ARR-STORAGE-NEXT:    store <4 x i8> [[EXTRACTVEC_I9_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
   return a > b;
@@ -203,6 +350,16 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
 // CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIbLi2EEES2_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.16") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 2 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
+// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
+// CHECK-ARR-STORAGE-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
   return a > b;
@@ -218,6 +375,29 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <8 x i1> [[CMP_I]] to <8 x i16>
 // CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEES5_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.19") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 16 dereferenceable(16) [[AGG_RESULT]], i8 0, i64 16, i1 false), {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 8
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTERKNS0_3VECINS0_6DETAIL9HALF_IMPL4HALFELI8EEES7__EXIT:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [8 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[A]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I14_I:%.*]] = getelementptr inbounds [8 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[B]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load half, ptr [[ARRAYIDX_I_I_I_I14_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt half [[TMP0]], [[TMP1]]
+// CHECK-ARR-STORAGE-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP115:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1gtERKNS0_3vecINS0_6detail9half_impl4halfELi8EEES7_.exit:
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
   return a > b;
@@ -237,6 +417,41 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <4 x i1> [[CMP_I]] to <4 x i16>
 // CHECK-NEXT:    store <4 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEES5_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.23") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.25") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.25") align 8 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP_I]])
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP_I]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI4EEES7__EXIT:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[A]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP0]], ptr [[REF_TMP_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I14_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[B]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I_I14_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP1]], ptr [[REF_TMP1_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP_ASCAST_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP1_ASCAST_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP136:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1gtERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi4EEES7_.exit:
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP_I]])
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
                                    vec<ext::oneapi::bfloat16, 4> b) {
@@ -273,6 +488,17 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
 // CHECK:       _ZN4sycl3_V1ntERKNS0_3vecIiLi3EEE.exit:
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 16, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIiLi3EEE(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.26") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.26") align 16 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I]], zeroinitializer
+// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i32>
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I3_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-ARR-STORAGE-NEXT:    store <4 x i32> [[EXTRACTVEC_I3_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
 
@@ -284,6 +510,14 @@ SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
 // CHECK-NEXT:    [[SUB_I:%.*]] = sub <4 x i32> zeroinitializer, [[TMP0]]
 // CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecIiLi4EEE(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.28") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.28") align 16 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[SUB_I:%.*]] = sub <4 x i32> zeroinitializer, [[TMP0]]
+// CHECK-ARR-STORAGE-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
 
@@ -313,6 +547,44 @@ SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
 // CHECK:       _ZN4sycl3_V1ntERKNS0_3vecISt4byteLi16EEE.exit:
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 16, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecISt4byteLi16EEE(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.31") align 16 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.31", align 16
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 16, ptr nonnull [[RET_I]])
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.memset.p0.i64(ptr align 16 [[RET_I]], i8 0, i64 16, i1 false), {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 16
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [16 x i8], ptr [[A]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_NOT_I:%.*]] = icmp eq i8 [[TMP0]], 0
+// CHECK-ARR-STORAGE-NEXT:    [[CONV3_I:%.*]] = zext i1 [[TOBOOL_NOT_I]] to i8
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I8_I:%.*]] = getelementptr inbounds [16 x i8], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[CONV3_I]], ptr [[ARRAYIDX_I_I_I_I8_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP149:![0-9]+]]
+// CHECK-ARR-STORAGE:       for.end.i:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i.i.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 16
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIST4BYTELI16EEE_EXIT:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i.i.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP154:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntERKNS0_3vecISt4byteLi16EEE.exit:
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 16, ptr nonnull [[RET_I]])
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<std::byte, 16> a) { return !a; }
 
@@ -326,6 +598,16 @@ SYCL_EXTERNAL auto TestNegation(vec<std::byte, 16> a) { return !a; }
 // CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i8> [[SUB_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
 // CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecISt4byteLi3EEE(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.15") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x i8> [[LOADVEC4_I_I]], <4 x i8> poison, <3 x i32> <i32 0, i32 1, i32 2>
+// CHECK-ARR-STORAGE-NEXT:    [[SUB_I:%.*]] = sub <3 x i8> zeroinitializer, [[EXTRACTVEC_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I2_I:%.*]] = shufflevector <3 x i8> [[SUB_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-ARR-STORAGE-NEXT:    store <4 x i8> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<std::byte, 3> a) { return -a; }
 
@@ -355,6 +637,44 @@ SYCL_EXTERNAL auto TestMinus(vec<std::byte, 3> a) { return -a; }
 // CHECK:       _ZN4sycl3_V1ntERKNS0_3vecIbLi4EEE.exit:
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.6", align 4
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[RET_I]])
+// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr [[RET_I]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr [[A]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I_I_NOT_I:%.*]] = icmp eq i8 [[TMP0]], 0
+// CHECK-ARR-STORAGE-NEXT:    [[FROMBOOL_I:%.*]] = zext i1 [[TOBOOL_I_I_NOT_I]] to i8
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I7_I:%.*]] = getelementptr inbounds [4 x i8], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[FROMBOOL_I]], ptr [[ARRAYIDX_I_I_I_I7_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP163:![0-9]+]]
+// CHECK-ARR-STORAGE:       for.end.i:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i.i.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 4
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIBLI4EEE_EXIT:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i.i.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP154]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntERKNS0_3vecIbLi4EEE.exit:
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[RET_I]])
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 
@@ -384,6 +704,44 @@ SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 // CHECK:       _ZN4sycl3_V1ntERKNS0_3vecINS0_6detail9half_impl4halfELi2EEE.exit:
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.35", align 4
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[RET_I]])
+// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr [[RET_I]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [2 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[A]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq half [[TMP0]], 0xH0000
+// CHECK-ARR-STORAGE-NEXT:    [[CONV_I9_I:%.*]] = uitofp i1 [[TOBOOL_I]] to half
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I11_I:%.*]] = getelementptr inbounds [2 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store half [[CONV_I9_I]], ptr [[ARRAYIDX_I_I_I_I11_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP177:![0-9]+]]
+// CHECK-ARR-STORAGE:       for.end.i:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i.i.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 4
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECINS0_6DETAIL9HALF_IMPL4HALFELI2EEE_EXIT:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i.i.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP154]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntERKNS0_3vecINS0_6detail9half_impl4halfELi2EEE.exit:
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[RET_I]])
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 
@@ -395,6 +753,14 @@ SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg <8 x half> [[TMP0]]
 // CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEE(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.21") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[FNEG_I:%.*]] = fneg <8 x half> [[TMP0]]
+// CHECK-ARR-STORAGE-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 
@@ -451,6 +817,56 @@ SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP1_I]])
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP2_I]])
 // CHECK-NEXT:    ret void
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.10", align 8
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_I:%.*]] = alloca float, align 4
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP2_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 8, ptr nonnull [[RET_I]])
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP1_I]])
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP2_I]])
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP2_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP2_I]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr [[RET_I]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[A]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP0]], ptr [[REF_TMP2_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP2_ASCAST_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
+// CHECK-ARR-STORAGE-NEXT:    [[CONV4_I:%.*]] = uitofp i1 [[CMP_I_I]] to float
+// CHECK-ARR-STORAGE-NEXT:    store float [[CONV4_I]], ptr [[REF_TMP1_I]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I9_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP1_ASCAST_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I11_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I9_I]], ptr [[ARRAYIDX_I_I_I_I11_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP198:![0-9]+]]
+// CHECK-ARR-STORAGE:       for.end.i:
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i.i.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 8
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI3EEE_EXIT:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i.i.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP154]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi3EEE.exit:
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 8, ptr nonnull [[RET_I]])
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP1_I]])
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP2_I]])
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 
@@ -482,5 +898,37 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-NEXT:    store i16 [[CALL_I_I_I_I]], ptr addrspace(4) [[TMP1]], align 2, {{.*}}
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP165:![0-9]+]]
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-NEXT:  entry:
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
+// CHECK-ARR-STORAGE-NEXT:    [[V_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[V_I]])
+// CHECK-ARR-STORAGE-NEXT:    [[V_ASCAST_I:%.*]] = addrspacecast ptr [[V_I]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK-ARR-STORAGE:       for.cond.i:
+// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 16
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI16EEE_EXIT:%.*]]
+// CHECK-ARR-STORAGE:       for.body.i:
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds [16 x i16], ptr [[A]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP0]], ptr [[V_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I:%.*]] = call spir_func float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[V_ASCAST_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[FNEG_I_I:%.*]] = fneg float [[CALL_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    store float [[FNEG_I_I]], ptr [[REF_TMP_I_I]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I7_I:%.*]] = getelementptr inbounds [16 x i16], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I7_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP215:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ngERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi16EEE.exit:
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[V_I]])
+// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<ext::oneapi::bfloat16, 16> a) { return -a; }

From f71b2328f7baadf15dc376816baee03162cdb7ed Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 1 May 2024 17:54:46 -0700
Subject: [PATCH 41/79] Remove storage type alias

---
 sycl/include/sycl/ext/oneapi/bfloat16.hpp      | 11 ++---------
 sycl/include/sycl/half_type.hpp                | 11 ++++-------
 sycl/include/sycl/vector_preview.hpp           | 17 +++++++++--------
 sycl/test/self-contained-headers/lit.local.cfg |  3 ---
 4 files changed, 15 insertions(+), 27 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/bfloat16.hpp b/sycl/include/sycl/ext/oneapi/bfloat16.hpp
index cfa6cf8814462..6792262ec21a0 100644
--- a/sycl/include/sycl/ext/oneapi/bfloat16.hpp
+++ b/sycl/include/sycl/ext/oneapi/bfloat16.hpp
@@ -32,21 +32,13 @@ bfloat16 bitsToBfloat16(const Bfloat16StorageT Value);
 
 // sycl::vec support
 namespace bf16 {
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 #ifdef __SYCL_DEVICE_ONLY__
 using Vec2StorageT = Bfloat16StorageT __attribute__((ext_vector_type(2)));
 using Vec3StorageT = Bfloat16StorageT __attribute__((ext_vector_type(3)));
 using Vec4StorageT = Bfloat16StorageT __attribute__((ext_vector_type(4)));
 using Vec8StorageT = Bfloat16StorageT __attribute__((ext_vector_type(8)));
 using Vec16StorageT = Bfloat16StorageT __attribute__((ext_vector_type(16)));
-
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
-using Vec2DeviceStorageT = std::array<Bfloat16StorageT, 2>;
-using Vec3DeviceStorageT = std::array<Bfloat16StorageT, 4>;
-using Vec4DeviceStorageT = std::array<Bfloat16StorageT, 4>;
-using Vec8DeviceStorageT = std::array<Bfloat16StorageT, 8>;
-using Vec16DeviceStorageT = std::array<Bfloat16StorageT, 16>;
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
-
 #else
 using Vec2StorageT = std::array<Bfloat16StorageT, 2>;
 using Vec3StorageT = std::array<Bfloat16StorageT, 3>;
@@ -54,6 +46,7 @@ using Vec4StorageT = std::array<Bfloat16StorageT, 4>;
 using Vec8StorageT = std::array<Bfloat16StorageT, 8>;
 using Vec16StorageT = std::array<Bfloat16StorageT, 16>;
 #endif
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 } // namespace bf16
 } // namespace detail
 
diff --git a/sycl/include/sycl/half_type.hpp b/sycl/include/sycl/half_type.hpp
index 7e7e236124797..799ff9fb186e9 100644
--- a/sycl/include/sycl/half_type.hpp
+++ b/sycl/include/sycl/half_type.hpp
@@ -249,18 +249,12 @@ using StorageT = _Float16;
 using BIsRepresentationT = _Float16;
 using VecElemT = _Float16;
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 using Vec2StorageT = VecElemT __attribute__((ext_vector_type(2)));
 using Vec3StorageT = VecElemT __attribute__((ext_vector_type(3)));
 using Vec4StorageT = VecElemT __attribute__((ext_vector_type(4)));
 using Vec8StorageT = VecElemT __attribute__((ext_vector_type(8)));
 using Vec16StorageT = VecElemT __attribute__((ext_vector_type(16)));
-
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
-using Vec2DeviceStorageT = std::array<sycl::half, 2>;
-using Vec3DeviceStorageT = std::array<sycl::half, 4>;
-using Vec4DeviceStorageT = std::array<sycl::half, 4>;
-using Vec8DeviceStorageT = std::array<sycl::half, 8>;
-using Vec16DeviceStorageT = std::array<sycl::half, 16>;
 #endif // __INTEL_PREVIEW_BREAKING_CHANGES
 
 #else // SYCL_DEVICE_ONLY
@@ -270,6 +264,7 @@ using StorageT = detail::host_half_impl::half;
 using BIsRepresentationT = half;
 using VecElemT = half;
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 // On the host side we cannot use OpenCL cl_half# types as an underlying type
 // for vec because they are actually defined as an integer type under the
 // hood. As a result half values will be converted to the integer and passed
@@ -279,6 +274,8 @@ using Vec3StorageT = std::array<VecElemT, 3>;
 using Vec4StorageT = std::array<VecElemT, 4>;
 using Vec8StorageT = std::array<VecElemT, 8>;
 using Vec16StorageT = std::array<VecElemT, 16>;
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
+
 #endif // SYCL_DEVICE_ONLY
 
 #ifndef __SYCL_DEVICE_ONLY__
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index a9f44ea6ccaf3..d25bf570c8d5b 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -305,16 +305,17 @@ template <> struct VecStorage<half, 1, void> {
 };
 
 // Multiple elements half
-#if __SYCL_DEVICE_ONLY__
+#ifdef __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##DeviceStorageT;        \
-    using VectorDataType = sycl::detail::half_impl::Vec##Num##StorageT;        \
+    using DataType = std::array<sycl::half, Num>;                              \
+    using VectorDataType = sycl::detail::half_impl::VecElemT                   \
+                                        __attribute__((ext_vector_type(Num))); \
   };
 #else // __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = sycl::detail::half_impl::Vec##Num##StorageT;              \
+    using DataType = std::array<sycl::half, Num>;                              \
   };
 #endif // __SYCL_DEVICE_ONLY__
 
@@ -335,15 +336,15 @@ template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
 #ifndef __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
+    using DataType = std::array<sycl::ext::oneapi::detail::Bfloat16StorageT, Num>;             \
   };
 #else
 #define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType =                                                           \
-        sycl::ext::oneapi::detail::bf16::Vec##Num##DeviceStorageT;             \
+    using DataType = std::array<sycl::ext::oneapi::detail::Bfloat16StorageT, Num>;             \
     using VectorDataType =                                                     \
-        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
+        sycl::ext::oneapi::detail::Bfloat16StorageT                      \
+        __attribute__((ext_vector_type(Num)));                                 \
   };
 #endif
 __SYCL_DEFINE_BF16_VECSTORAGE(2)
diff --git a/sycl/test/self-contained-headers/lit.local.cfg b/sycl/test/self-contained-headers/lit.local.cfg
index b08ac4823e536..d61551742dd85 100644
--- a/sycl/test/self-contained-headers/lit.local.cfg
+++ b/sycl/test/self-contained-headers/lit.local.cfg
@@ -13,7 +13,4 @@ config.sycl_headers_xfail = [
     os.path.join(
         "sycl", "ext", "intel", "esimd", "detail", "types_elementary.hpp"
     ),
-    os.path.join(
-        "sycl", "vector_preview.hpp"
-    ),
 ]

From c7eba6466f73ee5d40fcecb8babf9c647a2e132f Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 1 May 2024 17:57:51 -0700
Subject: [PATCH 42/79] clang format

---
 sycl/include/sycl/vector_preview.hpp | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index d25bf570c8d5b..35ea33e325826 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -310,7 +310,7 @@ template <> struct VecStorage<half, 1, void> {
   template <> struct VecStorage<half, Num, void> {                             \
     using DataType = std::array<sycl::half, Num>;                              \
     using VectorDataType = sycl::detail::half_impl::VecElemT                   \
-                                        __attribute__((ext_vector_type(Num))); \
+        __attribute__((ext_vector_type(Num)));                                 \
   };
 #else // __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
@@ -336,14 +336,15 @@ template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
 #ifndef __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType = std::array<sycl::ext::oneapi::detail::Bfloat16StorageT, Num>;             \
+    using DataType =                                                           \
+        std::array<sycl::ext::oneapi::detail::Bfloat16StorageT, Num>;          \
   };
 #else
 #define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType = std::array<sycl::ext::oneapi::detail::Bfloat16StorageT, Num>;             \
-    using VectorDataType =                                                     \
-        sycl::ext::oneapi::detail::Bfloat16StorageT                      \
+    using DataType =                                                           \
+        std::array<sycl::ext::oneapi::detail::Bfloat16StorageT, Num>;          \
+    using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT         \
         __attribute__((ext_vector_type(Num)));                                 \
   };
 #endif
@@ -494,17 +495,17 @@ template <typename Type, int NumElements> class vec {
   struct TypeChecker : std::is_convertible<T, DataT_> {};
 #define __SYCL_ALLOW_VECTOR_TYPES(num_elements)                                \
   template <typename DataT_>                                                   \
-  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {};   \
+  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type{};    \
   template <typename DataT_, typename T2, typename T3,                         \
             template <typename> class T4, int... T5>                           \
   struct TypeChecker<                                                          \
       detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
-      : std::true_type {};                                                     \
+      : std::true_type{};                                                      \
   template <typename DataT_, typename T2, typename T3,                         \
             template <typename> class T4, int... T5>                           \
   struct TypeChecker<                                                          \
       detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
-      DataT_> : std::true_type {};
+      DataT_> : std::true_type{};
 
   __SYCL_ALLOW_VECTOR_TYPES(1)
   __SYCL_ALLOW_VECTOR_TYPES(2)

From 61dd7d459818e9ff7f1306d5dbf65aaad4ed1adf Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 1 May 2024 19:19:40 -0700
Subject: [PATCH 43/79] clang-format

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

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 35ea33e325826..254011f72ed21 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -308,7 +308,7 @@ template <> struct VecStorage<half, 1, void> {
 #ifdef __SYCL_DEVICE_ONLY__
 #define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = std::array<sycl::half, Num>;                              \
+    using DataType = std::array<sycl::half, (Num == 3)?4:Num>;                 \
     using VectorDataType = sycl::detail::half_impl::VecElemT                   \
         __attribute__((ext_vector_type(Num)));                                 \
   };
@@ -343,7 +343,7 @@ template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
 #define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
   template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
     using DataType =                                                           \
-        std::array<sycl::ext::oneapi::detail::Bfloat16StorageT, Num>;          \
+        std::array<sycl::ext::oneapi::detail::Bfloat16StorageT, (Num==3)?4:Num>;    \
     using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT         \
         __attribute__((ext_vector_type(Num)));                                 \
   };
@@ -495,17 +495,17 @@ template <typename Type, int NumElements> class vec {
   struct TypeChecker : std::is_convertible<T, DataT_> {};
 #define __SYCL_ALLOW_VECTOR_TYPES(num_elements)                                \
   template <typename DataT_>                                                   \
-  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type{};    \
+  struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {};   \
   template <typename DataT_, typename T2, typename T3,                         \
             template <typename> class T4, int... T5>                           \
   struct TypeChecker<                                                          \
       detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
-      : std::true_type{};                                                      \
+      : std::true_type {};                                                     \
   template <typename DataT_, typename T2, typename T3,                         \
             template <typename> class T4, int... T5>                           \
   struct TypeChecker<                                                          \
       detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
-      DataT_> : std::true_type{};
+      DataT_> : std::true_type {};
 
   __SYCL_ALLOW_VECTOR_TYPES(1)
   __SYCL_ALLOW_VECTOR_TYPES(2)

From 5dd79c0d289b80dae8109b8e8c4248e191c6c232 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 2 May 2024 10:12:19 -0700
Subject: [PATCH 44/79] Optimize operations on half

---
 sycl/include/sycl/vector_preview.hpp          |  6 +--
 .../vector/vector_math_ops.cpp                | 44 +++++--------------
 2 files changed, 12 insertions(+), 38 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 254011f72ed21..f854d4322192a 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -896,8 +896,7 @@ template <typename Type, int NumElements> class vec {
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
   friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
     vec Ret;                                                                   \
-    if constexpr (IsBfloat16 ||                                                \
-                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
+    if constexpr (IsBfloat16) {                                                \
       for (size_t I = 0; I < NumElements; ++I) {                               \
         Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
       }                                                                        \
@@ -994,8 +993,7 @@ template <typename Type, int NumElements> class vec {
     vec<rel_t, NumElements> Ret{};                                             \
     /* ext_vector_type does not support bfloat16 or half, so for these   */    \
     /* we do element-by-element operation on the underlying std::array.  */    \
-    if constexpr (IsBfloat16 ||                                                \
-                  std::is_same_v<DataT, sycl::detail::half_impl::half>) {      \
+    if constexpr (IsBfloat16) {                                                \
       for (size_t I = 0; I < NumElements; ++I) {                               \
         /* We cannot use SetValue here as the operator is not a friend of*/    \
         /* Ret on Windows. */                                                  \
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 9dc48edc8a1dd..b9bec834300a5 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -169,22 +169,11 @@ SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
 // CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) {{.*}} {
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECINS0_6DETAIL9HALF_IMPL4HALFELI3EEES7__EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[A]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I9_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[B]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load half, ptr [[ARRAYIDX_I_I_I_I9_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ADD_I_I_I:%.*]] = fadd half [[TMP1]], [[TMP0]]
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I13_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::detail::half_impl::half"], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store half [[ADD_I_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I13_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP48:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1plERKNS0_3vecINS0_6detail9half_impl4halfELi3EEES7_.exit:
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x half>, ptr [[A]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I7_I:%.*]] = load <4 x half>, ptr [[B]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = fadd <4 x half> [[LOADVEC4_I_I]], [[LOADVEC4_I7_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I9_I:%.*]] = shufflevector <4 x half> [[TMP0]], <4 x half> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-ARR-STORAGE-NEXT:    store <4 x half> [[EXTRACTVEC_I9_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
@@ -381,24 +370,11 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
 // CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.19") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[B:%.*]]) {{.*}} {
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 16 dereferenceable(16) [[AGG_RESULT]], i8 0, i64 16, i1 false), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 8
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTERKNS0_3VECINS0_6DETAIL9HALF_IMPL4HALFELI8EEES7__EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [8 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[A]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I14_I:%.*]] = getelementptr inbounds [8 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[B]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load half, ptr [[ARRAYIDX_I_I_I_I14_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt half [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP115:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1gtERKNS0_3vecINS0_6detail9half_impl4halfELi8EEES7_.exit:
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = fcmp ogt <8 x half> [[TMP0]], [[TMP1]]
+// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <8 x i1> [[CMP_I]] to <8 x i16>
+// CHECK-ARR-STORAGE-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {

From d4da05d4a15c66469992ba0a29f287b67035ceb6 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 2 May 2024 20:42:00 -0700
Subject: [PATCH 45/79] Removed VecStorage type aliases

---
 sycl/include/sycl/vector_preview.hpp | 224 ++++++---------------------
 1 file changed, 46 insertions(+), 178 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index f854d4322192a..a7d7a96d735e2 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -158,8 +158,6 @@ template <typename VecT, typename OperationLeftT, typename OperationRightT,
           template <typename> class OperationCurrentT, int... Indexes>
 class SwizzleOp;
 
-template <typename T, int N, typename V = void> struct VecStorage;
-
 // Element type for relational operator return value.
 template <typename DataT>
 using rel_t = typename std::conditional_t<
@@ -186,180 +184,44 @@ template <typename TransformedArgType, int Dims, typename KernelType>
 class RoundedRangeKernel;
 template <typename TransformedArgType, int Dims, typename KernelType>
 class RoundedRangeKernelWithKH;
+} // namespace detail
 
-// Vectors of size 1 are handled separately and therefore 1 is not included in
-// the check below.
-constexpr bool isValidVectorSize(int N) {
-  return N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
-}
-template <typename T, int N, typename V> struct VecStorage {
-  static_assert(
-      isValidVectorSize(N) || N == 1,
-      "Incorrect number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
-      "or 16 are supported");
-  static_assert(!std::is_same_v<V, void>, "Incorrect data type for sycl::vec");
-};
-
-#ifdef __SYCL_DEVICE_ONLY__
-// device always has ext vector support, but for huge vectors
-// we switch to std::array, so that we can use a smaller alignment (64)
-// this is to support MSVC, which has a max of 64 for direct params.
-template <typename T, int N> struct VecStorageImpl {
-  static constexpr size_t Num = (N == 3) ? 4 : N;
-  static constexpr size_t Sz = Num * sizeof(T);
-
-  using DataType = std::array<T, (N == 3) ? 4 : N>;
-  using VectorDataType = T __attribute__((ext_vector_type(N)));
-};
-#else  // __SYCL_DEVICE_ONLY__
-template <typename T, int N> struct VecStorageImpl {
-  using DataType = std::array<T, (N == 3) ? 4 : N>;
-};
-#endif // __SYCL_DEVICE_ONLY__
-
-// Single element bool
-template <> struct VecStorage<bool, 1, void> {
-  using DataType = bool;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = bool;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Multiple element bool
-template <int N>
-struct VecStorage<bool, N, typename std::enable_if_t<isValidVectorSize(N)>> {
-  using DataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                                std::int32_t, std::int64_t>,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-// Single element byte. Multiple elements will propagate through a later
-// specialization.
-template <> struct VecStorage<std::byte, 1, void> {
-  using DataType = std::int8_t;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = std::int8_t;
-#endif // __SYCL_DEVICE_ONLY__
-};
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+template <typename T> using vec_data = detail::vec_helper<T>;
 
-// Single element signed integers
 template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sigeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
+using vec_data_t = typename detail::vec_helper<T>::RetType;
 
-// Single element unsigned integers
+// data_type_single_t = T for all types except half, bfloat16, std::byte.
 template <typename T>
-struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
+using data_type_single_t = typename std::conditional_t<
+    // half
+    std::is_same_v<T, half>, sycl::detail::half_impl::StorageT, std::conditional_t<
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+    // std::byte
+    std::is_same_v<T, std::byte>, std::int8_t, typename std::conditional_t<
+#else
+    false, T, typename std::conditional_t<
+#endif
+    // bfloat16
+    std::is_same_v<T, sycl::ext::oneapi::bfloat16>, sycl::ext::oneapi::detail::Bfloat16StorageT,
+    T>>>;
 
-// Single element floating-point (except half/bfloat16)
-template <typename T>
-struct VecStorage<
-    T, 1,
-    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
-  using DataType = T;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = DataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-// Multiple elements signed/unsigned integers and floating-point (except
-// half/bfloat16)
 template <typename T, int N>
-struct VecStorage<
-    T, N,
-    typename std::enable_if_t<isValidVectorSize(N) &&
-                              (is_sgeninteger_v<T> ||
-                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
-  using DataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType =
-      typename VecStorageImpl<typename VecStorage<T, 1>::DataType,
-                              N>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
-};
-
-// Single element half
-template <> struct VecStorage<half, 1, void> {
-  using DataType = sycl::detail::half_impl::StorageT;
-#ifdef __SYCL_DEVICE_ONLY__
-  using VectorDataType = sycl::detail::half_impl::StorageT;
-#endif // __SYCL_DEVICE_ONLY__
-};
+using data_type_multiple_t = typename std::conditional_t<
+    // bool
+    std::is_same_v<T, bool>, std::array<int8_t, N>,
+    std::array<data_type_single_t<T>, N>
+    >;
 
-// Multiple elements half
 #ifdef __SYCL_DEVICE_ONLY__
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = std::array<sycl::half, (Num == 3)?4:Num>;                 \
-    using VectorDataType = sycl::detail::half_impl::VecElemT                   \
-        __attribute__((ext_vector_type(Num)));                                 \
-  };
-#else // __SYCL_DEVICE_ONLY__
-#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<half, Num, void> {                             \
-    using DataType = std::array<sycl::half, Num>;                              \
-  };
-#endif // __SYCL_DEVICE_ONLY__
+template <typename T>
+using vector_t_single = data_type_single_t<T>;
 
-__SYCL_DEFINE_HALF_VECSTORAGE(2)
-__SYCL_DEFINE_HALF_VECSTORAGE(3)
-__SYCL_DEFINE_HALF_VECSTORAGE(4)
-__SYCL_DEFINE_HALF_VECSTORAGE(8)
-__SYCL_DEFINE_HALF_VECSTORAGE(16)
-#undef __SYCL_DEFINE_HALF_VECSTORAGE
-
-// Single element bfloat16
-template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
-  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-  // using VectorDataType = sycl::ext::oneapi::bfloat16;
-  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-};
-// Multiple elements bfloat16
-#ifndef __SYCL_DEVICE_ONLY__
-#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType =                                                           \
-        std::array<sycl::ext::oneapi::detail::Bfloat16StorageT, Num>;          \
-  };
-#else
-#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
-  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
-    using DataType =                                                           \
-        std::array<sycl::ext::oneapi::detail::Bfloat16StorageT, (Num==3)?4:Num>;    \
-    using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT         \
-        __attribute__((ext_vector_type(Num)));                                 \
-  };
+template <typename T, int N>
+using vector_t_multiple = typename std::conditional_t<
+    std::is_same_v<T, bool>, int8_t __attribute__((ext_vector_type(N))),
+    vector_t_single<T> __attribute__((ext_vector_type(N)))>;
 #endif
-__SYCL_DEFINE_BF16_VECSTORAGE(2)
-__SYCL_DEFINE_BF16_VECSTORAGE(3)
-__SYCL_DEFINE_BF16_VECSTORAGE(4)
-__SYCL_DEFINE_BF16_VECSTORAGE(8)
-__SYCL_DEFINE_BF16_VECSTORAGE(16)
-#undef __SYCL_DEFINE_BF16_VECSTORAGE
-} // namespace detail
-
-template <typename T> using vec_data = detail::vec_helper<T>;
-
-template <typename T>
-using vec_data_t = typename detail::vec_helper<T>::RetType;
 
 ///////////////////////// class sycl::vec /////////////////////////
 /// Provides a cross-patform vector class template that works efficiently on
@@ -367,26 +229,37 @@ using vec_data_t = typename detail::vec_helper<T>::RetType;
 ///
 /// \ingroup sycl_api
 template <typename Type, int NumElements> class vec {
+
+  static_assert( NumElements == 1 || NumElements == 2 || NumElements == 3 ||
+                     NumElements == 4 || NumElements == 8 || NumElements == 16,
+                 "Invalid number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
+                 "or 16 are supported");
+  static_assert (sizeof(bool) == sizeof(int8_t), "bool size is not 1 byte");
+
   using DataT = Type;
+  static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
 
   // This represent type of underlying value. There should be only one field
   // in the class, so vec<float, 16> should be equal to float16 in memory.
-  using DataType = typename detail::VecStorage<DataT, NumElements>::DataType;
+  using DataType = typename std::conditional_t<
+      AdjustedNum == 1, data_type_single_t<DataT>,
+      data_type_multiple_t<DataT, AdjustedNum>>;
+
+public:
+#ifdef __SYCL_DEVICE_ONLY__
+  // Type used for passing sycl::vec to SPIRV builtins.
+  using vector_t = typename std::conditional_t<
+      AdjustedNum == 1, vector_t_single<DataT>, vector_t_multiple<DataT, AdjustedNum>>;
+#endif // __SYCL_DEVICE_ONLY__
 
+private:
   static constexpr bool IsBfloat16 =
       std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
 
-  static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
   static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
   static constexpr bool IsSizeGreaterThanMaxAlign =
       (Sz > detail::MaxVecAlignment);
 
-#ifdef __SYCL_DEVICE_ONLY__
-  static constexpr bool IsUsingArrayOnHost = false; // not compiling for host.
-#else
-  static constexpr bool IsUsingArrayOnHost = true; // host always std::array.
-#endif
-
   static constexpr int getNumElements() { return NumElements; }
 
   // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
@@ -548,11 +421,6 @@ template <typename Type, int NumElements> class vec {
   using element_type = DataT;
   using value_type = DataT;
   using rel_t = detail::rel_t<DataT>;
-#ifdef __SYCL_DEVICE_ONLY__
-  // Type used for passing sycl::vec to SPIRV builtins.
-  using vector_t =
-      typename detail::VecStorage<DataT, NumElements>::VectorDataType;
-#endif // __SYCL_DEVICE_ONLY__
 
   vec() = default;
 

From 8aa33e4a0aa4c9fb8e9fb97f8514854b33d834a9 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 2 May 2024 21:12:27 -0700
Subject: [PATCH 46/79] Remove some vec_helper stuff

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

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index a7d7a96d735e2..435468a7bbc23 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -115,16 +115,11 @@ static constexpr ToType BitCast(const FromType &Value) {
 /* Helper functions to get and set values in vec, depdending on the underlying
 + * data type. */
 template <typename T> struct vec_helper {
-  using RetType = T;
+  using RetType = typename std::conditional<
+      std::is_same_v<T, bool>, std::int8_t, T>::type;
   static constexpr RetType get(T value) { return value; }
   static constexpr RetType set(T value) { return value; }
 };
-template <> struct vec_helper<bool> {
-  using RetType = select_apply_cl_t<bool, std::int8_t, std::int16_t,
-                                    std::int32_t, std::int64_t>;
-  static constexpr RetType get(bool value) { return value; }
-  static constexpr RetType set(bool value) { return value; }
-};
 
 template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
   using RetType = sycl::ext::oneapi::bfloat16;
@@ -189,7 +184,14 @@ class RoundedRangeKernelWithKH;
 template <typename T> using vec_data = detail::vec_helper<T>;
 
 template <typename T>
-using vec_data_t = typename detail::vec_helper<T>::RetType;
+using vec_data_t = typename std::conditional_t<
+std::is_same_v<T, bool>, std::int8_t, typename std::conditional_t<
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+std::is_same_v<T, std::byte>, std::uint8_t, typename std::conditional_t<
+#else
+false, T, typename std::conditional_t<
+#endif
+true, T, T>>>;
 
 // data_type_single_t = T for all types except half, bfloat16, std::byte.
 template <typename T>

From 0b223b8b31eeede660abbd14da4ebc51e590ddab Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 2 May 2024 22:26:14 -0700
Subject: [PATCH 47/79] Replace HalfStorage with half as storage type for
 sycl::half vec

---
 sycl/include/sycl/vector_preview.hpp | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 435468a7bbc23..ad254bfec66f8 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -140,10 +140,10 @@ template <> struct vec_helper<std::byte> {
   using RetType = std::uint8_t;
   static constexpr RetType get(std::byte value) { return (RetType)value; }
   static constexpr RetType set(std::byte value) { return (RetType)value; }
-  static constexpr std::byte get(std::uint8_t value) {
+  static constexpr std::byte get(RetType value) {
     return (std::byte)value;
   }
-  static constexpr std::byte set(std::uint8_t value) {
+  static constexpr std::byte set(RetType value) {
     return (std::byte)value;
   }
 };
@@ -187,7 +187,7 @@ template <typename T>
 using vec_data_t = typename std::conditional_t<
 std::is_same_v<T, bool>, std::int8_t, typename std::conditional_t<
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-std::is_same_v<T, std::byte>, std::uint8_t, typename std::conditional_t<
+std::is_same_v<T, std::byte>, std::int8_t, typename std::conditional_t<
 #else
 false, T, typename std::conditional_t<
 #endif
@@ -196,17 +196,15 @@ true, T, T>>>;
 // data_type_single_t = T for all types except half, bfloat16, std::byte.
 template <typename T>
 using data_type_single_t = typename std::conditional_t<
-    // half
-    std::is_same_v<T, half>, sycl::detail::half_impl::StorageT, std::conditional_t<
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
     // std::byte
-    std::is_same_v<T, std::byte>, std::int8_t, typename std::conditional_t<
+    std::is_same_v<T, std::byte>, std::uint8_t, typename std::conditional_t<
 #else
     false, T, typename std::conditional_t<
 #endif
     // bfloat16
     std::is_same_v<T, sycl::ext::oneapi::bfloat16>, sycl::ext::oneapi::detail::Bfloat16StorageT,
-    T>>>;
+    T>>;
 
 template <typename T, int N>
 using data_type_multiple_t = typename std::conditional_t<
@@ -217,7 +215,10 @@ using data_type_multiple_t = typename std::conditional_t<
 
 #ifdef __SYCL_DEVICE_ONLY__
 template <typename T>
-using vector_t_single = data_type_single_t<T>;
+using vector_t_single = typename std::conditional_t<
+    std::is_same_v<T, sycl::half>, sycl::detail::half_impl::StorageT, typename std::conditional_t<
+    std::is_same_v<T, sycl::ext::oneapi::bfloat16>, sycl::ext::oneapi::detail::Bfloat16StorageT,
+    data_type_single_t<T>>>;
 
 template <typename T, int N>
 using vector_t_multiple = typename std::conditional_t<

From 6b09e147e413042d2c126f1dfa9a3395421ed261 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 2 May 2024 22:41:02 -0700
Subject: [PATCH 48/79] Fix

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

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index ad254bfec66f8..5a01b61fd312b 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -252,7 +252,7 @@ template <typename Type, int NumElements> class vec {
 #ifdef __SYCL_DEVICE_ONLY__
   // Type used for passing sycl::vec to SPIRV builtins.
   using vector_t = typename std::conditional_t<
-      AdjustedNum == 1, vector_t_single<DataT>, vector_t_multiple<DataT, AdjustedNum>>;
+      AdjustedNum == 1, vector_t_single<DataT>, vector_t_multiple<DataT, NumElements>>;
 #endif // __SYCL_DEVICE_ONLY__
 
 private:

From 4eb19da14ea59179b0ab9c0123cf0610b78add85 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 3 May 2024 09:34:59 -0700
Subject: [PATCH 49/79] Fix comments. DCE

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

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 5a01b61fd312b..2101652a1b3eb 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -193,7 +193,7 @@ false, T, typename std::conditional_t<
 #endif
 true, T, T>>>;
 
-// data_type_single_t = T for all types except half, bfloat16, std::byte.
+// data_type_single_t = T for all types except bfloat16, std::byte.
 template <typename T>
 using data_type_single_t = typename std::conditional_t<
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
@@ -259,10 +259,6 @@ template <typename Type, int NumElements> class vec {
   static constexpr bool IsBfloat16 =
       std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
 
-  static constexpr size_t Sz = sizeof(DataT) * AdjustedNum;
-  static constexpr bool IsSizeGreaterThanMaxAlign =
-      (Sz > detail::MaxVecAlignment);
-
   static constexpr int getNumElements() { return NumElements; }
 
   // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
@@ -862,7 +858,7 @@ template <typename Type, int NumElements> class vec {
   friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
                                                    const vec & Rhs) {          \
     vec<rel_t, NumElements> Ret{};                                             \
-    /* ext_vector_type does not support bfloat16 or half, so for these   */    \
+    /* ext_vector_type does not support bfloat16, so for these   */            \
     /* we do element-by-element operation on the underlying std::array.  */    \
     if constexpr (IsBfloat16) {                                                \
       for (size_t I = 0; I < NumElements; ++I) {                               \

From 2451cc2a04219e8524270fcceda960b667abdb03 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 3 May 2024 17:07:21 -0700
Subject: [PATCH 50/79] Make std::byte as storage type for vec<byte,_>

---
 sycl/include/sycl/vector_preview.hpp | 162 +++++++--------------------
 1 file changed, 43 insertions(+), 119 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 2101652a1b3eb..fd4a58d163a98 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -130,8 +130,11 @@ template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
 
   static constexpr RetType get(RetType value) { return value; }
 
-  static constexpr BFloat16StorageT set(RetType value) {
-    return BitCast<RetType, BFloat16StorageT>(value);
+  static constexpr RetType set(RetType value) {
+    return value;
+  }
+  static constexpr RetType set(BFloat16StorageT value) {
+    return BitCast<BFloat16StorageT, RetType>(value);
   }
 };
 
@@ -139,9 +142,9 @@ template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
 template <> struct vec_helper<std::byte> {
   using RetType = std::uint8_t;
   static constexpr RetType get(std::byte value) { return (RetType)value; }
-  static constexpr RetType set(std::byte value) { return (RetType)value; }
-  static constexpr std::byte get(RetType value) {
-    return (std::byte)value;
+  static constexpr std::byte set(std::byte value) { return value; }
+  static constexpr RetType get(RetType value) {
+    return value;
   }
   static constexpr std::byte set(RetType value) {
     return (std::byte)value;
@@ -184,27 +187,14 @@ class RoundedRangeKernelWithKH;
 template <typename T> using vec_data = detail::vec_helper<T>;
 
 template <typename T>
-using vec_data_t = typename std::conditional_t<
-std::is_same_v<T, bool>, std::int8_t, typename std::conditional_t<
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-std::is_same_v<T, std::byte>, std::int8_t, typename std::conditional_t<
-#else
-false, T, typename std::conditional_t<
-#endif
-true, T, T>>>;
+using vec_data_t = typename detail::vec_helper<T>::RetType;
 
 // data_type_single_t = T for all types except bfloat16, std::byte.
 template <typename T>
 using data_type_single_t = typename std::conditional_t<
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-    // std::byte
-    std::is_same_v<T, std::byte>, std::uint8_t, typename std::conditional_t<
-#else
-    false, T, typename std::conditional_t<
-#endif
     // bfloat16
     std::is_same_v<T, sycl::ext::oneapi::bfloat16>, sycl::ext::oneapi::detail::Bfloat16StorageT,
-    T>>;
+    T>;
 
 template <typename T, int N>
 using data_type_multiple_t = typename std::conditional_t<
@@ -217,8 +207,13 @@ using data_type_multiple_t = typename std::conditional_t<
 template <typename T>
 using vector_t_single = typename std::conditional_t<
     std::is_same_v<T, sycl::half>, sycl::detail::half_impl::StorageT, typename std::conditional_t<
-    std::is_same_v<T, sycl::ext::oneapi::bfloat16>, sycl::ext::oneapi::detail::Bfloat16StorageT,
-    data_type_single_t<T>>>;
+    std::is_same_v<T, sycl::ext::oneapi::bfloat16>, sycl::ext::oneapi::detail::Bfloat16StorageT, typename std::conditional_t<
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+    std::is_same_v<T, std::byte>, std::uint8_t, typename std::conditional_t<
+#else
+    false, T, typename std::conditional_t<
+#endif
+    true, data_type_single_t<T>, T>>>>;
 
 template <typename T, int N>
 using vector_t_multiple = typename std::conditional_t<
@@ -412,6 +407,8 @@ template <typename Type, int NumElements> class vec {
       : m_Data{([&](vec_data_t<DataT> v) constexpr {
           if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
             return v.value;
+          else if constexpr (std::is_same_v<std::byte, DataT>)
+            return (std::byte)v;
           else
             return vec_data_t<DataT>(static_cast<DataT>(v));
         })(Arr[Is])...} {}
@@ -509,7 +506,7 @@ template <typename Type, int NumElements> class vec {
   // Available only when: NumElements == 1
   template <int N = NumElements>
   operator typename std::enable_if_t<N == 1, DataT>() const {
-    return vec_data<DataT>::get(m_Data);
+    return vec_data<DataT>::set(m_Data);
   }
 
   __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
@@ -600,10 +597,11 @@ template <typename Type, int NumElements> class vec {
     {
       // Otherwise, we fallback to per-element conversion:
       for (size_t I = 0; I < NumElements; ++I) {
-        Result.setValue(
-            I, vec_data<convertT>::get(
+        auto val = vec_data<convertT>::set(
                    detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
-                       vec_data<DataT>::get(getValue(I)))));
+                       getValue(I)));
+
+        Result.setValue(I, val);
       }
     }
 
@@ -733,7 +731,7 @@ template <typename Type, int NumElements> class vec {
              multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
     for (int I = 0; I < NumElements; I++) {
       *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
-                                                I) = getValue(I);
+                                                I) = vec_data<DataT>::set(getValue(I));
     }
   }
   template <int Dimensions, access::mode Mode,
@@ -803,7 +801,7 @@ template <typename Type, int NumElements> class vec {
     vec Ret{};                                                                 \
     for (size_t I = 0; I < NumElements; ++I)                                   \
       Ret.setValue(I,                                                          \
-                   (DataT)(vec_data<DataT>::get(Lhs.getValue(I))               \
+                   vec_data<DataT>::set(vec_data<DataT>::get(Lhs.getValue(I))               \
                                BINOP vec_data<DataT>::get(Rhs.getValue(I))));  \
     return Ret;                                                                \
   }                                                                            \
@@ -910,6 +908,9 @@ template <typename Type, int NumElements> class vec {
   }
 #endif
 
+  // OP is: ==, !=, <, >, <=, >=, &&, ||
+  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
+  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
   __SYCL_RELLOGOP(==)
   __SYCL_RELLOGOP(!=)
   __SYCL_RELLOGOP(>)
@@ -926,12 +927,12 @@ template <typename Type, int NumElements> class vec {
 #endif
 #define __SYCL_UOP(UOP, OPASSIGN)                                              \
   friend vec &operator UOP(vec & Rhs) {                                        \
-    Rhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    Rhs OPASSIGN vec_data<DataT>::set(1);                                      \
     return Rhs;                                                                \
   }                                                                            \
   friend vec operator UOP(vec &Lhs, int) {                                     \
     vec Ret(Lhs);                                                              \
-    Lhs OPASSIGN vec_data<DataT>::get(1);                                      \
+    Lhs OPASSIGN vec_data<DataT>::set(1);                                      \
     return Ret;                                                                \
   }
 
@@ -952,7 +953,7 @@ template <typename Type, int NumElements> class vec {
 #else
     vec Ret{};
     for (size_t I = 0; I < NumElements; ++I) {
-      Ret.setValue(I, ~Rhs.getValue(I));
+      Ret.setValue(I, vec_data<DataT>::set(~Rhs.getValue(I)));
     }
     return Ret;
 #endif
@@ -1036,101 +1037,24 @@ template <typename Type, int NumElements> class vec {
     return Ret;
   }
 
-  // OP is: &&, ||
-  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
-  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
-
-  // OP is: ==, !=, <, >, <=, >=
-  // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
-  // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
 private:
-  // Generic method that execute "Operation" on underlying values.
-
-#ifdef __SYCL_DEVICE_ONLY__
-  template <template <typename> class Operation,
-            typename Ty = vec<DataT, NumElements>>
-  vec<DataT, NumElements> operatorHelper(const Ty &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataT> Op;
-    // Typecast to ext_vector_type, carryout the operation, and type cast back.
-    // Compiler optimizations will remove redundant casts.
-    auto OpResult = Op(sycl::bit_cast<vector_t>(m_Data),
-                       sycl::bit_cast<vector_t>(Rhs.m_Data));
-    Result.m_Data = sycl::bit_cast<DataType>(OpResult);
-    return Result;
-  }
-#else  // __SYCL_DEVICE_ONLY__
-  template <template <typename> class Operation>
-  vec<DataT, NumElements>
-  operatorHelper(const vec<DataT, NumElements> &Rhs) const {
-    vec<DataT, NumElements> Result;
-    Operation<DataT> Op;
-    for (size_t I = 0; I < NumElements; ++I) {
-      Result.setValue(I, Op(Rhs.getValue(I), getValue(I)));
-    }
-    return Result;
-  }
-#endif // __SYCL_DEVICE_ONLY__
-
   // setValue and getValue should be able to operate on different underlying
   // types: enum cl_float#N , builtin vector float#N, builtin type float.
-  // These versions are for N > 1.
-#ifdef __SYCL_DEVICE_ONLY__
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(Ty Index, const DataT &Value, int) {
-    m_Data[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements, typename Ty = int,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(Ty Index, int) const {
-    return vec_data<DataT>::get(m_Data[Index]);
-  }
-#else  // __SYCL_DEVICE_ONLY__
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr void setValue(int Index, const DataT &Value, int) {
-    m_Data[Index] = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 != Num>>
-  constexpr DataT getValue(int Index, int) const {
-    return vec_data<DataT>::get(m_Data[Index]);
-  }
-#endif // __SYCL_DEVICE_ONLY__
-
-  // N==1 versions, used by host and device. Shouldn't trailing type be int?
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 == Num>>
-  constexpr void setValue(int, const DataT &Value, float) {
-    m_Data = vec_data<DataT>::set(Value);
-  }
-
-  template <int Num = NumElements,
-            typename = typename std::enable_if_t<1 == Num>>
-  DataT getValue(int, float) const {
-    return vec_data<DataT>::get(m_Data);
+  constexpr auto getValue(int Index) const {
+    if constexpr (NumElements == 1)
+      return vec_data<DataT>::get(m_Data);
+    else
+      return vec_data<DataT>::get(m_Data[Index]);
   }
 
-  // setValue and getValue.
-  // The "api" functions used by BINOP etc.  These versions just dispatch
-  // using additional int or float arg to disambiguate vec<1> vs. vec<N>
-  // Special proxies as specialization is not allowed in class scope.
   constexpr void setValue(int Index, const DataT &Value) {
-    if (NumElements == 1)
-      setValue(Index, Value, 0);
+    if constexpr (NumElements == 1)
+      m_Data = vec_data<DataT>::set(Value);
     else
-      setValue(Index, Value, 0.f);
-  }
-
-  DataT getValue(int Index) const {
-    return (NumElements == 1) ? getValue(Index, 0) : getValue(Index, 0.f);
+      m_Data[Index] = vec_data<DataT>::set(Value);
   }
 
   // fields
-
   // Alignment is the same as size, to a maximum size of 64.
   // detail::vector_alignment will return that value.
   alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
@@ -1916,10 +1840,10 @@ class SwizzleOp {
   DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
     if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
       std::array<int, getNumElements()> Idxs{Indexes...};
-      return m_Vector->getValue(Idxs[Index]);
+      return vec_data<DataT>::set(m_Vector->getValue(Idxs[Index]));
     }
     auto Op = OperationCurrentT<vec_data_t<DataT>>();
-    return vec_data<DataT>::get(
+    return vec_data<DataT>::set(
         Op(vec_data<DataT>::get(m_LeftOperation.getValue(Index)),
            vec_data<DataT>::get(m_RightOperation.getValue(Index))));
   }
@@ -1929,7 +1853,7 @@ class SwizzleOp {
     Operation<vec_data_t<DataT>> Op;
     std::array<int, getNumElements()> Idxs{Indexes...};
     for (size_t I = 0; I < Idxs.size(); ++I) {
-      DataT Res = vec_data<DataT>::get(
+      DataT Res = vec_data<DataT>::set(
           Op(vec_data<DataT>::get(m_Vector->getValue(Idxs[I])),
              vec_data<DataT>::get(Rhs.getValue(I))));
       m_Vector->setValue(Idxs[I], Res);

From 04d9121966a8a7b0f3615bd550508663f7f2aa02 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 7 May 2024 12:05:47 -0700
Subject: [PATCH 51/79] More DCE. Refactor std::byte sycl::vec

---
 sycl/include/sycl/detail/vector_convert.hpp |   7 +
 sycl/include/sycl/vector_preview.hpp        | 294 ++++++++++----------
 sycl/test-e2e/Basic/vector/byte.cpp         |   3 -
 sycl/test-e2e/Basic/vector/byte_preview.cpp | 190 +++++++++++++
 4 files changed, 349 insertions(+), 145 deletions(-)
 create mode 100644 sycl/test-e2e/Basic/vector/byte_preview.cpp

diff --git a/sycl/include/sycl/detail/vector_convert.hpp b/sycl/include/sycl/detail/vector_convert.hpp
index c018fce5bcfa3..0c7232a1a1041 100644
--- a/sycl/include/sycl/detail/vector_convert.hpp
+++ b/sycl/include/sycl/detail/vector_convert.hpp
@@ -558,6 +558,13 @@ NativeToT convertImpl(NativeFromT Value) {
   }
 }
 
+template <typename FromT, typename ToT, sycl::rounding_mode RoundingMode,
+          int VecSize, typename NativeFromT, typename NativeToT>
+auto ConvertImpl(std::byte val){
+  return convertImpl<FromT, ToT, RoundingMode, VecSize, NativeFromT, NativeToT>(
+    (std::int8_t)val);
+}
+
 } // namespace detail
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index fd4a58d163a98..5fae53e0cef11 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -42,7 +42,7 @@
 #include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
 
 #include <array>       // for array
-#include <assert.h>    // for assert
+#include <cassert>     // for assert
 #include <cstddef>     // for size_t, NULL, byte
 #include <cstdint>     // for uint8_t, int16_t, int...
 #include <functional>  // for divides, multiplies
@@ -82,14 +82,6 @@ struct elem {
 };
 
 namespace detail {
-// select_apply_cl_t selects from T8/T16/T32/T64 basing on
-// sizeof(_IN).  expected to handle scalar types in _IN.
-template <typename _IN, typename T8, typename T16, typename T32, typename T64>
-using select_apply_cl_t = std::conditional_t<
-    sizeof(_IN) == 1, T8,
-    std::conditional_t<sizeof(_IN) == 2, T16,
-                       std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
-
 // Helper function to bit_cast one type to another.
 template <typename FromType, typename ToType>
 static constexpr ToType BitCast(const FromType &Value) {
@@ -115,40 +107,36 @@ static constexpr ToType BitCast(const FromType &Value) {
 /* Helper functions to get and set values in vec, depdending on the underlying
 + * data type. */
 template <typename T> struct vec_helper {
-  using RetType = typename std::conditional<
-      std::is_same_v<T, bool>, std::int8_t, T>::type;
-  static constexpr RetType get(T value) { return value; }
-  static constexpr RetType set(T value) { return value; }
+  using NativeType =
+      typename std::conditional<std::is_same_v<T, bool>, std::int8_t, T>::type;
+  static constexpr NativeType get(T value) { return value; }
+  static constexpr NativeType set(T value) { return value; }
 };
 
 template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
-  using RetType = sycl::ext::oneapi::bfloat16;
-  using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
-  static constexpr RetType get(BFloat16StorageT value) {
-    return BitCast<BFloat16StorageT, RetType>(value);
-  }
+  using BF16Type = sycl::ext::oneapi::bfloat16;
+  using NativeType = sycl::ext::oneapi::detail::Bfloat16StorageT;
 
-  static constexpr RetType get(RetType value) { return value; }
-
-  static constexpr RetType set(RetType value) {
-    return value;
+  static constexpr NativeType get(NativeType value) { return value; }
+  static constexpr NativeType get(BF16Type value) {
+    return BitCast<BF16Type, NativeType>(value);
   }
-  static constexpr RetType set(BFloat16StorageT value) {
-    return BitCast<BFloat16StorageT, RetType>(value);
+
+  static constexpr BF16Type set(BF16Type value) { return value; }
+  static constexpr BF16Type set(NativeType value) {
+    return BitCast<NativeType, BF16Type>(value);
   }
 };
 
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
 template <> struct vec_helper<std::byte> {
-  using RetType = std::uint8_t;
-  static constexpr RetType get(std::byte value) { return (RetType)value; }
+  using NativeType = std::uint8_t;
+
+  static constexpr NativeType get(std::byte value) { return (NativeType)value; }
+  static constexpr NativeType get(NativeType value) { return value; }
+
   static constexpr std::byte set(std::byte value) { return value; }
-  static constexpr RetType get(RetType value) {
-    return value;
-  }
-  static constexpr std::byte set(RetType value) {
-    return (std::byte)value;
-  }
+  static constexpr std::byte set(NativeType value) { return (std::byte)value; }
 };
 #endif
 
@@ -187,33 +175,36 @@ class RoundedRangeKernelWithKH;
 template <typename T> using vec_data = detail::vec_helper<T>;
 
 template <typename T>
-using vec_data_t = typename detail::vec_helper<T>::RetType;
+using vec_data_t = typename detail::vec_helper<T>::NativeType;
 
-// data_type_single_t = T for all types except bfloat16, std::byte.
+// data_type_single_t = T for all types except bfloat16.
 template <typename T>
 using data_type_single_t = typename std::conditional_t<
     // bfloat16
-    std::is_same_v<T, sycl::ext::oneapi::bfloat16>, sycl::ext::oneapi::detail::Bfloat16StorageT,
-    T>;
+    std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+    sycl::ext::oneapi::bfloat16, T>;
 
 template <typename T, int N>
 using data_type_multiple_t = typename std::conditional_t<
     // bool
     std::is_same_v<T, bool>, std::array<int8_t, N>,
-    std::array<data_type_single_t<T>, N>
-    >;
+    std::array<data_type_single_t<T>, N>>;
 
 #ifdef __SYCL_DEVICE_ONLY__
 template <typename T>
 using vector_t_single = typename std::conditional_t<
-    std::is_same_v<T, sycl::half>, sycl::detail::half_impl::StorageT, typename std::conditional_t<
-    std::is_same_v<T, sycl::ext::oneapi::bfloat16>, sycl::ext::oneapi::detail::Bfloat16StorageT, typename std::conditional_t<
+    std::is_same_v<T, sycl::half>, sycl::detail::half_impl::StorageT,
+    typename std::conditional_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                                sycl::ext::oneapi::detail::Bfloat16StorageT,
+                                typename std::conditional_t<
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-    std::is_same_v<T, std::byte>, std::uint8_t, typename std::conditional_t<
+                                    std::is_same_v<T, std::byte>, std::uint8_t,
+                                    typename std::conditional_t<
 #else
-    false, T, typename std::conditional_t<
+                                     false, T,
+                                     typename std::conditional_t<
 #endif
-    true, data_type_single_t<T>, T>>>>;
+                                        true, data_type_single_t<T>, T>>>>;
 
 template <typename T, int N>
 using vector_t_multiple = typename std::conditional_t<
@@ -222,32 +213,31 @@ using vector_t_multiple = typename std::conditional_t<
 #endif
 
 ///////////////////////// class sycl::vec /////////////////////////
-/// Provides a cross-patform vector class template that works efficiently on
-/// SYCL devices as well as in host C++ code.
-///
-/// \ingroup sycl_api
+// Provides a cross-patform vector class template that works efficiently on
+// SYCL devices as well as in host C++ code.
 template <typename Type, int NumElements> class vec {
 
-  static_assert( NumElements == 1 || NumElements == 2 || NumElements == 3 ||
-                     NumElements == 4 || NumElements == 8 || NumElements == 16,
-                 "Invalid number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
-                 "or 16 are supported");
-  static_assert (sizeof(bool) == sizeof(int8_t), "bool size is not 1 byte");
+  static_assert(NumElements == 1 || NumElements == 2 || NumElements == 3 ||
+                    NumElements == 4 || NumElements == 8 || NumElements == 16,
+                "Invalid number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
+                "or 16 are supported");
+  static_assert(sizeof(bool) == sizeof(int8_t), "bool size is not 1 byte");
 
   using DataT = Type;
   static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
 
   // This represent type of underlying value. There should be only one field
   // in the class, so vec<float, 16> should be equal to float16 in memory.
-  using DataType = typename std::conditional_t<
-      AdjustedNum == 1, data_type_single_t<DataT>,
-      data_type_multiple_t<DataT, AdjustedNum>>;
+  using DataType =
+      typename std::conditional_t<AdjustedNum == 1, data_type_single_t<DataT>,
+                                  data_type_multiple_t<DataT, AdjustedNum>>;
 
 public:
 #ifdef __SYCL_DEVICE_ONLY__
   // Type used for passing sycl::vec to SPIRV builtins.
-  using vector_t = typename std::conditional_t<
-      AdjustedNum == 1, vector_t_single<DataT>, vector_t_multiple<DataT, NumElements>>;
+  using vector_t =
+      typename std::conditional_t<AdjustedNum == 1, vector_t_single<DataT>,
+                                  vector_t_multiple<DataT, NumElements>>;
 #endif // __SYCL_DEVICE_ONLY__
 
 private:
@@ -405,12 +395,7 @@ template <typename Type, int NumElements> class vec {
   constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
                 std::index_sequence<Is...>)
       : m_Data{([&](vec_data_t<DataT> v) constexpr {
-          if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
-            return v.value;
-          else if constexpr (std::is_same_v<std::byte, DataT>)
-            return (std::byte)v;
-          else
-            return vec_data_t<DataT>(static_cast<DataT>(v));
+          return vec_data<DataT>::set(v);
         })(Arr[Is])...} {}
 
 public:
@@ -418,67 +403,47 @@ template <typename Type, int NumElements> class vec {
   using value_type = DataT;
   using rel_t = detail::rel_t<DataT>;
 
+  /****************** Constructors **************/
   vec() = default;
-
   constexpr vec(const vec &Rhs) = default;
   constexpr vec(vec &&Rhs) = default;
 
-  constexpr vec &operator=(const vec &Rhs) = default;
-
-  // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
-  template <typename Ty = DataT>
-  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
-                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
-                            vec &>
-  operator=(const vec<rel_t, NumElements> &Rhs) {
-    *this = Rhs.template as<vec>();
-    return *this;
-  }
-
-#ifdef __SYCL_DEVICE_ONLY__
   explicit constexpr vec(const DataT &arg)
+      : vec{detail::RepeatValue<NumElements>(vec_data<DataT>::get(arg)),
+            std::make_index_sequence<NumElements>()} {}
 
-      : vec{detail::RepeatValue<NumElements>(
-                static_cast<vec_data_t<DataT>>(arg)),
+  // Constructor from values of base type or vec of base type. Checks that
+  // base types are match and that the NumElements == sum of lengths of args.
+  template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
+            typename = EnableIfSuitableNumElements<argTN...>>
+  constexpr vec(const argTN &...args)
+      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
             std::make_index_sequence<NumElements>()} {}
 
+  /****************** Assignment Operators **************/
+  constexpr vec &operator=(const vec &Rhs) = default;
+
   template <typename Ty = DataT>
   typename std::enable_if_t<
       std::is_fundamental_v<vec_data_t<Ty>> ||
           detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
-  operator=(const Ty &Rhs) {
+  operator=(const DataT &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
     }
     return *this;
   }
-#else  // __SYCL_DEVICE_ONLY__
-  explicit constexpr vec(const DataT &arg)
-      : vec{detail::RepeatValue<NumElements>(
-                static_cast<vec_data_t<DataT>>(arg)),
-            std::make_index_sequence<NumElements>()} {}
 
+  // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
   template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const DataT &Rhs) {
-    for (int i = 0; i < NumElements; ++i) {
-      setValue(i, Rhs);
-    }
+  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
+                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
+                            vec &>
+  operator=(const vec<rel_t, NumElements> &Rhs) {
+    *this = Rhs.template as<vec>();
     return *this;
   }
-#endif // __SYCL_DEVICE_ONLY__
-
-  // Constructor from values of base type or vec of base type. Checks that
-  // base types are match and that the NumElements == sum of lengths of args.
-  template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
-            typename = EnableIfSuitableNumElements<argTN...>>
-  constexpr vec(const argTN &...args)
-      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
-            std::make_index_sequence<NumElements>()} {}
 
 #ifdef __SYCL_DEVICE_ONLY__
   template <typename vector_t_ = vector_t,
@@ -598,8 +563,8 @@ template <typename Type, int NumElements> class vec {
       // Otherwise, we fallback to per-element conversion:
       for (size_t I = 0; I < NumElements; ++I) {
         auto val = vec_data<convertT>::set(
-                   detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
-                       getValue(I)));
+            detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
+                getValue(I)));
 
         Result.setValue(I, val);
       }
@@ -730,8 +695,8 @@ template <typename Type, int NumElements> class vec {
   void store(size_t Offset,
              multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
     for (int I = 0; I < NumElements; I++) {
-      *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
-                                                I) = vec_data<DataT>::set(getValue(I));
+      *multi_ptr<DataT, Space, DecorateAddress>(
+          Ptr + Offset * NumElements + I) = vec_data<DataT>::set(getValue(I));
     }
   }
   template <int Dimensions, access::mode Mode,
@@ -758,12 +723,14 @@ template <typename Type, int NumElements> class vec {
 #endif
 
 #ifdef __SYCL_DEVICE_ONLY__
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
-  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT, COND)                           \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
+      const vec & Lhs, const vec & Rhs) {                                      \
     vec Ret;                                                                   \
     if constexpr (IsBfloat16) {                                                \
       for (size_t I = 0; I < NumElements; ++I) {                               \
-        Ret.setValue(I, (Lhs.getValue(I) BINOP Rhs.getValue(I)));              \
+        Ret.setValue(I, vec_data<DataT>::set(Lhs[I] BINOP Rhs[I]));            \
       }                                                                        \
     } else {                                                                   \
       vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
@@ -777,67 +744,110 @@ template <typename Type, int NumElements> class vec {
     }                                                                          \
     return Ret;                                                                \
   }                                                                            \
-  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
+      const vec & Lhs, const DataT & Rhs) {                                    \
     return Lhs BINOP vec(Rhs);                                                 \
   }                                                                            \
-  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
+      const DataT & Lhs, const vec & Rhs) {                                    \
     return vec(Lhs) BINOP Rhs;                                                 \
   }                                                                            \
-  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec> &operator OPASSIGN(            \
+      vec & Lhs, const vec & Rhs) {                                            \
     Lhs = Lhs BINOP Rhs;                                                       \
     return Lhs;                                                                \
   }                                                                            \
-  template <int Num = NumElements>                                             \
-  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
-      vec & Lhs, const DataT & Rhs) {                                          \
+  template <int Num = NumElements, typename T = DataT>                         \
+  friend typename std::enable_if_t<(Num != 1) && (COND), vec &>                \
+  operator OPASSIGN(vec & Lhs, const DataT & Rhs) {                            \
     Lhs = Lhs BINOP vec(Rhs);                                                  \
     return Lhs;                                                                \
   }
-
 #else // __SYCL_DEVICE_ONLY__
 
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)                                 \
-  friend vec operator BINOP(const vec &Lhs, const vec &Rhs) {                  \
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT, COND)                           \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
+      const vec & Lhs, const vec & Rhs) {                                      \
     vec Ret{};                                                                 \
-    for (size_t I = 0; I < NumElements; ++I)                                   \
-      Ret.setValue(I,                                                          \
-                   vec_data<DataT>::set(vec_data<DataT>::get(Lhs.getValue(I))               \
-                               BINOP vec_data<DataT>::get(Rhs.getValue(I))));  \
+    for (size_t I = 0; I < NumElements; ++I) {                                 \
+      Ret.setValue(I, vec_data<DataT>::set(vec_data<DataT>::set(Lhs[I]) BINOP  \
+                                           vec_data<DataT>::set(Rhs[I])));     \
+    }                                                                          \
     return Ret;                                                                \
   }                                                                            \
-  friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) {                \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
+      const vec & Lhs, const DataT & Rhs) {                                    \
     return Lhs BINOP vec(Rhs);                                                 \
   }                                                                            \
-  friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) {                \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
+      const DataT & Lhs, const vec & Rhs) {                                    \
     return vec(Lhs) BINOP Rhs;                                                 \
   }                                                                            \
-  friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) {                  \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec> &operator OPASSIGN(            \
+      vec & Lhs, const vec & Rhs) {                                            \
     Lhs = Lhs BINOP Rhs;                                                       \
     return Lhs;                                                                \
   }                                                                            \
-  template <int Num = NumElements>                                             \
-  friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(         \
-      vec & Lhs, const DataT & Rhs) {                                          \
+  template <int Num = NumElements, typename T = DataT>                         \
+  friend typename std::enable_if_t<(Num != 1) && (COND), vec &>                \
+  operator OPASSIGN(vec & Lhs, const DataT & Rhs) {                            \
     Lhs = Lhs BINOP vec(Rhs);                                                  \
     return Lhs;                                                                \
   }
 #endif // __SYCL_DEVICE_ONLY__
 
-  __SYCL_BINOP(+, +=, true)
-  __SYCL_BINOP(-, -=, true)
-  __SYCL_BINOP(*, *=, false)
-  __SYCL_BINOP(/, /=, false)
-
-  // TODO: The following OPs are available only when: DataT != cl_float &&
-  // DataT != cl_double && DataT != cl_half
-  __SYCL_BINOP(%, %=, false)
-  __SYCL_BINOP(|, |=, false)
-  __SYCL_BINOP(&, &=, false)
-  __SYCL_BINOP(^, ^=, false)
-  __SYCL_BINOP(>>, >>=, false)
-  __SYCL_BINOP(<<, <<=, true)
+  // std::byte is not an arithmetic type.
+  __SYCL_BINOP(+, +=, true, (!std::is_same_v<T, std::byte>))
+  __SYCL_BINOP(-, -=, true, (!std::is_same_v<T, std::byte>))
+  __SYCL_BINOP(*, *=, false, (!std::is_same_v<T, std::byte>))
+  __SYCL_BINOP(/, /=, false, (!std::is_same_v<T, std::byte>))
+
+  // The following OPs are available only when: DataT != cl_float &&
+  // DataT != cl_double && DataT != cl_half && DataT != BF16.
+  __SYCL_BINOP(%, %=, false, (!detail::is_vgenfloat_v<T> && !std::is_same_v<T, std::byte>))
+  // Bitwise operations are allowed for std::byte.
+  __SYCL_BINOP(|, |=, false, (!detail::is_vgenfloat_v<T>))
+  __SYCL_BINOP(&, &=, false, (!detail::is_vgenfloat_v<T>))
+  __SYCL_BINOP(^, ^=, false, (!detail::is_vgenfloat_v<T>))
+  __SYCL_BINOP(>>, >>=, false, (!detail::is_vgenfloat_v<T> && !std::is_same_v<T, std::byte>))
+  __SYCL_BINOP(<<, <<=, true, (!detail::is_vgenfloat_v<T> && !std::is_same_v<T, std::byte>))
 #undef __SYCL_BINOP
-#undef __SYCL_BINOP_HELP
+
+  // Special <<, >> operators for std::byte.
+  // std::byte is not an arithmetic type and it only supports the following
+  // overloads of >> and << operators.
+  //
+  // 1 template <class IntegerType>
+  //   constexpr std::byte operator<<( std::byte b, IntegerType shift ) noexcept;
+  // 2 template <class IntegerType>
+  //   constexpr std::byte operator>>( std::byte b, IntegerType shift ) noexcept;
+#define __SYCL_SHIFT_BYTE(OP, OPASSIGN)                                         \
+  template <typename T = DataT>                                                 \
+  friend typename std::enable_if_t<std::is_same_v<T, std::byte>, vec>           \
+  operator OP(const vec & Lhs, int shift) {                                     \
+    vec Ret;                                                                    \
+    for (size_t I = 0; I < NumElements; ++I) {                                  \
+      Ret.setValue(I, Lhs[I] OP shift);                                         \
+    }                                                                           \
+    return Ret;                                                                 \
+  }                                                                             \
+  template <typename T = DataT>                                                 \
+  friend typename std::enable_if_t<std::is_same_v<T, std::byte>, vec&>          \
+  operator OPASSIGN(vec & Lhs, int shift) {                                     \
+    Lhs = Lhs OP shift;                                                         \
+    return Lhs;                                                                 \
+  }
+
+  __SYCL_SHIFT_BYTE(<<, <<=)
+  __SYCL_SHIFT_BYTE(>>, >>=)
+#undef __SYCL_SHIFT_BYTE
 
   // Note: vec<>/SwizzleOp logical value is 0/-1 logic, as opposed to 0/1 logic.
   // As far as CTS validation is concerned, 0/-1 logic also applies when
diff --git a/sycl/test-e2e/Basic/vector/byte.cpp b/sycl/test-e2e/Basic/vector/byte.cpp
index a2d70d1a0ba31..7581e52839035 100644
--- a/sycl/test-e2e/Basic/vector/byte.cpp
+++ b/sycl/test-e2e/Basic/vector/byte.cpp
@@ -1,9 +1,6 @@
 // RUN: %{build} -std=c++17 -o %t.out
 // RUN: %{run} %t.out
 
-// RUN: %if preview-breaking-changes-supported %{ %{build} -fpreview-breaking-changes -std=c++17 -o %t2.out %}
-// RUN: %if preview-breaking-changes-supported %{ %{run} %t2.out %}
-
 //==---------- vector_byte.cpp - SYCL vec<> for std::byte test -------------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
diff --git a/sycl/test-e2e/Basic/vector/byte_preview.cpp b/sycl/test-e2e/Basic/vector/byte_preview.cpp
new file mode 100644
index 0000000000000..49db97a294a51
--- /dev/null
+++ b/sycl/test-e2e/Basic/vector/byte_preview.cpp
@@ -0,0 +1,190 @@
+// RUN: %if preview-breaking-changes-supported %{ %{build} -fpreview-breaking-changes -std=c++17 -o %t2.out %}
+// RUN: %if preview-breaking-changes-supported %{ %{run} %t2.out %}
+
+//==---------- vector_byte.cpp - SYCL vec<> for std::byte test -------------==//
+//
+// 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 <cstddef> // std::byte
+#include <tuple>   // std::ignore
+
+int main() {
+  std::byte bt{7};
+  // constructors
+  sycl::vec<std::byte, 1> vb1(bt);
+  sycl::vec<std::byte, 2> vb2{bt, bt};
+  sycl::vec<std::byte, 3> vb3{bt, bt, bt};
+  sycl::vec<std::byte, 4> vb4{bt, bt, bt, bt};
+  sycl::vec<std::byte, 8> vb8{bt, bt, bt, bt, bt, bt, bt, bt};
+  sycl::vec<std::byte, 16> vb16{bt, bt, bt, std::byte{2}, bt, bt, bt, bt,
+                                bt, bt, bt, bt,           bt, bt, bt, bt};
+
+  {
+    // operator[]
+    assert(vb16[3] == std::byte{2});
+    // explicit conversion
+    std::ignore = std::byte(vb1.x());
+    std::byte b = vb1;
+
+    // operator=
+    auto vb4op = vb4;
+    vb1 = std::byte{3};
+  }
+
+  // convert() and as()
+  {
+    sycl::vec<int, 2> vi2(1, 1);
+    auto cnv = vi2.convert<std::byte>();
+    auto cnv2 = vb1.convert<int>();
+
+    auto asint = vb2.template as<sycl::vec<int16_t, 1>>();
+    auto asbyte = vi2.template as<sycl::vec<std::byte, 8>>();
+  }
+
+  // load() and store()
+  std::vector<std::byte> std_vec(8, bt);
+  {
+    sycl::buffer<std::byte, 1> Buf(std_vec.data(), sycl::range<1>(8));
+
+    sycl::queue Queue;
+    Queue
+        .submit([&](sycl::handler &cgh) {
+          auto Acc = Buf.get_access<sycl::access::mode::read_write>(cgh);
+          cgh.single_task<class st>([=]() {
+            // load
+            sycl::multi_ptr<std::byte,
+                            sycl::access::address_space::global_space,
+                            sycl::access::decorated::yes>
+                mp(Acc);
+            sycl::vec<std::byte, 8> sycl_vec;
+            sycl_vec.load(0, mp);
+            sycl_vec[0] = std::byte{2};
+            Acc[1] = std::byte{10};
+
+            // store
+            sycl_vec.store(0, mp);
+          });
+        })
+        .wait();
+  }
+  assert(std_vec[0] == std::byte{2});
+  assert(std_vec[1] == std::byte{7});
+
+  // swizzle
+  {
+    auto swizzled_vec = vb8.lo();
+
+    auto sw = vb8.template swizzle<sycl::elem::s0, sycl::elem::s1>()
+                  .template as<sycl::vec<int16_t, 1>>();
+    auto swbyte = sw.template as<sycl::vec<std::byte, 2>>();
+    auto swbyte2 = swizzled_vec.template as<sycl::vec<int, 1>>();
+
+    // hi/lo, even/odd
+    sycl::vec<std::byte, 4> vbsw(std::byte{0}, std::byte{1}, std::byte{2},
+                                 std::byte{3});
+    sycl::vec<std::byte, 2> vbswhi = vbsw.hi();
+    assert(vbswhi[0] == std::byte{2});
+    vbswhi = vbsw.lo();
+    vbswhi = vbsw.odd();
+    vbswhi = vbsw.even();
+  }
+
+  // operatorOP for vec and for swizzle
+  {
+    sycl::vec<std::byte, 3> vop1{std::byte{4}, std::byte{9}, std::byte{25}};
+    sycl::vec<std::byte, 3> vop2{std::byte{2}, std::byte{3}, std::byte{5}};
+    sycl::vec<std::byte, 4> vop3{std::byte{5}, std::byte{6}, std::byte{2},
+                                 std::byte{3}};
+
+    // logical binary op for 2 vec
+    auto vop = vop1 & vop2;
+    vop = vop1 | vop2;
+    vop = vop1 ^ vop2;
+
+    // logical binary op for 2 swizzle
+    auto swlo = vop3.lo();
+    auto swhi = vop3.hi();
+    auto swand = swlo & swhi;
+    auto swor = swlo | swhi;
+    auto swxor = swlo ^ swhi;
+
+    // logical binary op for 1 vec
+    vop = vop1 & std::byte{3};
+    vop = vop1 | std::byte{3};
+    vop = vop1 ^ std::byte{3};
+    vop = std::byte{3} & vop1;
+    vop = std::byte{3} | vop1;
+    vop = std::byte{3} ^ vop1;
+
+    // logical binary op for 1 swizzle
+    auto swand2 = swlo & std::byte{3};
+    auto swor2 = swlo | std::byte{3};
+    auto swxor2 = swlo ^ std::byte{3};
+
+    auto swand3 = std::byte{3} & swlo;
+    auto swor3 = std::byte{3} | swlo;
+    auto swxor3 = std::byte{3} ^ swlo;
+
+    // bit binary op for 2 vec
+    vop = vop1 && vop2;
+    vop = vop1 || vop2;
+
+    vop = vop1 << 3;
+    vop = vop1 >> 3;
+
+    // bit binary op for 2 swizzle
+    // TODO: Fix >> and << for swizzle of std::byte. Currently, Swizzles assume that both operands
+    // of the >> abd << operator have the same data type. That is not the case with std::byte.
+    // swlo >> 3;
+    // swlo << 3;
+
+    // condition op for 2 vec
+    auto vres = vop1 == vop2;
+    vres = vop1 != vop2;
+    vres = vop1 > vop2;
+    vres = vop1 < vop2;
+    vres = vop1 >= vop2;
+    vres = vop1 <= vop2;
+
+    vres = vop1 == std::byte{3};
+    vres = vop1 != std::byte{3};
+    vres = vop1 > std::byte{3};
+    vres = vop1 < std::byte{3};
+    vres = vop1 >= std::byte{3};
+    vres = vop1 <= std::byte{3};
+
+    vres = std::byte{3} == vop1;
+    vres = std::byte{3} != vop1;
+    vres = std::byte{3} > vop1;
+    vres = std::byte{3} < vop1;
+    vres = std::byte{3} >= vop1;
+    vres = std::byte{3} <= vop1;
+
+    // condition op for 2 swizzle
+    auto swres = swhi == swlo;
+    auto swres1 = swhi != swlo;
+    auto swres2 = swhi > swlo;
+    auto swres3 = swhi < swlo;
+    auto swres4 = swhi >= swlo;
+    auto swres5 = swhi <= swlo;
+    auto swres6 = swhi == std::byte{3};
+    auto swres7 = swhi != std::byte{3};
+    auto swres8 = swhi > std::byte{3};
+    auto swres9 = swhi < std::byte{3};
+    auto swres10 = swhi >= std::byte{3};
+    auto swres11 = swhi <= std::byte{3};
+
+    sycl::vec<std::byte, 3> voptest{std::byte{4}, std::byte{9}, std::byte{25}};
+    auto bitv1 = ~vop3;
+    auto bitv2 = !vop3;
+    auto bitw = ~swhi;
+  }
+
+  return 0;
+}

From 26987f4fba2114bebbc8119159e71162e61b311e Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 7 May 2024 15:29:16 -0700
Subject: [PATCH 52/79] Fix sycl::vec BFloat16

---
 sycl/include/sycl/vector_preview.hpp | 80 ++++++++++++----------------
 1 file changed, 35 insertions(+), 45 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 5fae53e0cef11..c1e0cd7e0af74 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -82,30 +82,8 @@ struct elem {
 };
 
 namespace detail {
-// Helper function to bit_cast one type to another.
-template <typename FromType, typename ToType>
-static constexpr ToType BitCast(const FromType &Value) {
-
-  static_assert(sizeof(FromType) == sizeof(ToType),
-                "BitCast: sizes of types are different");
-
-#ifdef __SYCL_BITCAST_IS_CONSTEXPR
-  return sycl::bit_cast<ToType>(Value);
-#else
-  // Awkward workaround. sycl::bit_cast isn't constexpr in older GCC
-  // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
-  // but neither available yet.
-  union {
-    const FromType from;
-    ToType to;
-  } result = {};
-  result.from = Value;
-  return result.to;
-#endif
-}
-
 /* Helper functions to get and set values in vec, depdending on the underlying
-+ * data type. */
+ * data type. */
 template <typename T> struct vec_helper {
   using NativeType =
       typename std::conditional<std::is_same_v<T, bool>, std::int8_t, T>::type;
@@ -117,14 +95,14 @@ template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
   using BF16Type = sycl::ext::oneapi::bfloat16;
   using NativeType = sycl::ext::oneapi::detail::Bfloat16StorageT;
 
-  static constexpr NativeType get(NativeType value) { return value; }
-  static constexpr NativeType get(BF16Type value) {
-    return BitCast<BF16Type, NativeType>(value);
+  static NativeType get(NativeType value) { return value; }
+  static NativeType get(BF16Type value) {
+    return sycl::bit_cast<NativeType>(value);
   }
 
-  static constexpr BF16Type set(BF16Type value) { return value; }
-  static constexpr BF16Type set(NativeType value) {
-    return BitCast<NativeType, BF16Type>(value);
+  static BF16Type set(BF16Type value) { return value; }
+  static BF16Type set(NativeType value) {
+    return sycl::bit_cast<BF16Type>(value);
   }
 };
 
@@ -132,11 +110,11 @@ template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
 template <> struct vec_helper<std::byte> {
   using NativeType = std::uint8_t;
 
-  static constexpr NativeType get(std::byte value) { return (NativeType)value; }
-  static constexpr NativeType get(NativeType value) { return value; }
+  static NativeType get(std::byte value) { return (NativeType)value; }
+  static NativeType get(NativeType value) { return value; }
 
-  static constexpr std::byte set(std::byte value) { return value; }
-  static constexpr std::byte set(NativeType value) { return (std::byte)value; }
+  static std::byte set(std::byte value) { return value; }
+  static std::byte set(NativeType value) { return (std::byte)value; }
 };
 #endif
 
@@ -177,12 +155,10 @@ template <typename T> using vec_data = detail::vec_helper<T>;
 template <typename T>
 using vec_data_t = typename detail::vec_helper<T>::NativeType;
 
-// data_type_single_t = T for all types except bfloat16.
+// data_type_single_t and data_type_multiple_t are data types
+// used to store sycl::vec on host and device.
 template <typename T>
-using data_type_single_t = typename std::conditional_t<
-    // bfloat16
-    std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-    sycl::ext::oneapi::bfloat16, T>;
+using data_type_single_t = T;
 
 template <typename T, int N>
 using data_type_multiple_t = typename std::conditional_t<
@@ -190,6 +166,8 @@ using data_type_multiple_t = typename std::conditional_t<
     std::is_same_v<T, bool>, std::array<int8_t, N>,
     std::array<data_type_single_t<T>, N>>;
 
+// sycl::vec is converted to vector_t_single and vector_t_multiple
+// data types on device for use in SPIRV builtins.
 #ifdef __SYCL_DEVICE_ONLY__
 template <typename T>
 using vector_t_single = typename std::conditional_t<
@@ -296,7 +274,7 @@ template <typename Type, int NumElements> class vec {
   }
   template <typename DataT_, typename T>
   static constexpr auto FlattenVecArgHelper(const T &A) {
-    return std::array<DataT_, 1>{vec_data<DataT_>::get(static_cast<DataT_>(A))};
+    return std::array<DataT_, 1>{A};
   }
   template <typename DataT_, typename T> struct FlattenVecArg {
     constexpr auto operator()(const T &A) const {
@@ -392,10 +370,10 @@ template <typename Type, int NumElements> class vec {
       typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
 
   template <size_t... Is>
-  constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
+  constexpr vec(const std::array<DataT, NumElements> &Arr,
                 std::index_sequence<Is...>)
-      : m_Data{([&](vec_data_t<DataT> v) constexpr {
-          return vec_data<DataT>::set(v);
+      : m_Data{([&](DataT v) constexpr {
+          return v;
         })(Arr[Is])...} {}
 
 public:
@@ -409,7 +387,7 @@ template <typename Type, int NumElements> class vec {
   constexpr vec(vec &&Rhs) = default;
 
   explicit constexpr vec(const DataT &arg)
-      : vec{detail::RepeatValue<NumElements>(vec_data<DataT>::get(arg)),
+      : vec{detail::RepeatValue<NumElements>(arg),
             std::make_index_sequence<NumElements>()} {}
 
   // Constructor from values of base type or vec of base type. Checks that
@@ -417,7 +395,7 @@ template <typename Type, int NumElements> class vec {
   template <typename... argTN, typename = EnableIfSuitableTypes<argTN...>,
             typename = EnableIfSuitableNumElements<argTN...>>
   constexpr vec(const argTN &...args)
-      : vec{VecArgArrayCreator<vec_data_t<DataT>, argTN...>::Create(args...),
+      : vec{VecArgArrayCreator<DataT, argTN...>::Create(args...),
             std::make_index_sequence<NumElements>()} {}
 
   /****************** Assignment Operators **************/
@@ -451,7 +429,19 @@ template <typename Type, int NumElements> class vec {
                 typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
                                           !std::is_same_v<vector_t_, DataT>>>
   constexpr vec(vector_t_ openclVector) {
-    m_Data = detail::BitCast<vector_t, DataType>(openclVector);
+#ifdef __SYCL_BITCAST_IS_CONSTEXPR
+    m_Data = sycl::bit_cast<DataType>(openclVector);
+#else
+  // Awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+  // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+  // but neither available yet.
+  union {
+    vector_t from;
+    DataType to;
+  } result = {};
+  result.from = openclVector;
+  m_Data = result.to;
+#endif
   }
 
   /* @SYCL2020

From 1c85fc849ccac5050f2a3b04dd2130f3c24b1229 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 7 May 2024 20:34:03 -0700
Subject: [PATCH 53/79] For Num=1, store as array<_, 1>

---
 sycl/include/sycl/vector_preview.hpp | 45 +++++++++++-----------------
 1 file changed, 18 insertions(+), 27 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index c1e0cd7e0af74..1f3b8e83437ed 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -157,14 +157,11 @@ using vec_data_t = typename detail::vec_helper<T>::NativeType;
 
 // data_type_single_t and data_type_multiple_t are data types
 // used to store sycl::vec on host and device.
-template <typename T>
-using data_type_single_t = T;
-
 template <typename T, int N>
 using data_type_multiple_t = typename std::conditional_t<
     // bool
     std::is_same_v<T, bool>, std::array<int8_t, N>,
-    std::array<data_type_single_t<T>, N>>;
+    std::array<T, N>>;
 
 // sycl::vec is converted to vector_t_single and vector_t_multiple
 // data types on device for use in SPIRV builtins.
@@ -182,7 +179,7 @@ using vector_t_single = typename std::conditional_t<
                                      false, T,
                                      typename std::conditional_t<
 #endif
-                                        true, data_type_single_t<T>, T>>>>;
+                                        true, T, T>>>>;
 
 template <typename T, int N>
 using vector_t_multiple = typename std::conditional_t<
@@ -206,16 +203,12 @@ template <typename Type, int NumElements> class vec {
 
   // This represent type of underlying value. There should be only one field
   // in the class, so vec<float, 16> should be equal to float16 in memory.
-  using DataType =
-      typename std::conditional_t<AdjustedNum == 1, data_type_single_t<DataT>,
-                                  data_type_multiple_t<DataT, AdjustedNum>>;
+  using DataType = data_type_multiple_t<DataT, AdjustedNum>;
 
 public:
 #ifdef __SYCL_DEVICE_ONLY__
   // Type used for passing sycl::vec to SPIRV builtins.
-  using vector_t =
-      typename std::conditional_t<AdjustedNum == 1, vector_t_single<DataT>,
-                                  vector_t_multiple<DataT, NumElements>>;
+  using vector_t = vector_t_multiple<DataT, NumElements>;
 #endif // __SYCL_DEVICE_ONLY__
 
 private:
@@ -274,7 +267,9 @@ template <typename Type, int NumElements> class vec {
   }
   template <typename DataT_, typename T>
   static constexpr auto FlattenVecArgHelper(const T &A) {
-    return std::array<DataT_, 1>{A};
+    // static_cast required to avoid narrowing conversion warning
+    // when T = unsigned long int and DataT_ = int.
+    return std::array<DataT_, 1>{static_cast<DataT_>(A)};
   }
   template <typename DataT_, typename T> struct FlattenVecArg {
     constexpr auto operator()(const T &A) const {
@@ -450,18 +445,14 @@ template <typename Type, int NumElements> class vec {
    * type defined by vector_t.
    */
   operator vector_t() const {
-    if constexpr (NumElements == 1) {
-      return m_Data;
-    } else {
       return sycl::bit_cast<vector_t>(m_Data);
-    }
   }
 #endif // __SYCL_DEVICE_ONLY__
 
   // Available only when: NumElements == 1
   template <int N = NumElements>
   operator typename std::enable_if_t<N == 1, DataT>() const {
-    return vec_data<DataT>::set(m_Data);
+    return vec_data<DataT>::set(m_Data[0]);
   }
 
   __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
@@ -1012,9 +1003,9 @@ template <typename Type, int NumElements> class vec {
     namespace oneapi = sycl::ext::oneapi;
     vec Ret{};
     if constexpr (IsBfloat16 && NumElements == 1) {
-      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data);
+      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[0]);
       oneapi::bfloat16 w = -v;
-      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
+      Ret.m_Data[0] = oneapi::detail::bfloat16ToBits(w);
     } else if constexpr (IsBfloat16) {
       for (size_t I = 0; I < NumElements; I++) {
         oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[I]);
@@ -1041,17 +1032,17 @@ template <typename Type, int NumElements> class vec {
   // setValue and getValue should be able to operate on different underlying
   // types: enum cl_float#N , builtin vector float#N, builtin type float.
   constexpr auto getValue(int Index) const {
-    if constexpr (NumElements == 1)
-      return vec_data<DataT>::get(m_Data);
-    else
-      return vec_data<DataT>::get(m_Data[Index]);
+#ifndef __SYCL_DEVICE_ONLY__
+    assert(Index < NumElements && "Index out of range");
+#endif
+    return vec_data<DataT>::get(m_Data[Index]);
   }
 
   constexpr void setValue(int Index, const DataT &Value) {
-    if constexpr (NumElements == 1)
-      m_Data = vec_data<DataT>::set(Value);
-    else
-      m_Data[Index] = vec_data<DataT>::set(Value);
+#ifndef __SYCL_DEVICE_ONLY__
+    assert(Index < NumElements && "Index out of range");
+#endif
+    m_Data[Index] = vec_data<DataT>::set(Value);
   }
 
   // fields

From 3812b8c57889197a7fd357eb0907a39a588462d2 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 8 May 2024 11:33:58 -0700
Subject: [PATCH 54/79] Limit math operations to their designated types, as per
 the SPEC.

---
 sycl/include/sycl/vector_preview.hpp        | 164 +++++++++++---------
 sycl/test-e2e/Basic/vector/byte_preview.cpp |   9 +-
 2 files changed, 91 insertions(+), 82 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 1f3b8e83437ed..6b87a6c39c525 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -155,7 +155,7 @@ template <typename T> using vec_data = detail::vec_helper<T>;
 template <typename T>
 using vec_data_t = typename detail::vec_helper<T>::NativeType;
 
-// data_type_single_t and data_type_multiple_t are data types
+// data_type_multiple_t data type is
 // used to store sycl::vec on host and device.
 template <typename T, int N>
 using data_type_multiple_t = typename std::conditional_t<
@@ -699,6 +699,16 @@ template <typename Type, int NumElements> class vec {
     }
   }
 
+ /******************* sycl::vec math operations ***********************/
+
+template <typename T>
+using IsByte = typename
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+  std::is_same<T, std::byte>;
+#else
+  std::false_type;
+#endif
+
 #ifdef __SYCL_BINOP
 #error "Undefine __SYCL_BINOP macro"
 #endif
@@ -785,20 +795,21 @@ template <typename Type, int NumElements> class vec {
 #endif // __SYCL_DEVICE_ONLY__
 
   // std::byte is not an arithmetic type.
-  __SYCL_BINOP(+, +=, true, (!std::is_same_v<T, std::byte>))
-  __SYCL_BINOP(-, -=, true, (!std::is_same_v<T, std::byte>))
-  __SYCL_BINOP(*, *=, false, (!std::is_same_v<T, std::byte>))
-  __SYCL_BINOP(/, /=, false, (!std::is_same_v<T, std::byte>))
+  __SYCL_BINOP(+, +=, true, (!IsByte<T>::value))
+  __SYCL_BINOP(-, -=, true, (!IsByte<T>::value))
+  __SYCL_BINOP(*, *=, false, (!IsByte<T>::value))
+  __SYCL_BINOP(/, /=, false, (!IsByte<T>::value))
 
   // The following OPs are available only when: DataT != cl_float &&
   // DataT != cl_double && DataT != cl_half && DataT != BF16.
-  __SYCL_BINOP(%, %=, false, (!detail::is_vgenfloat_v<T> && !std::is_same_v<T, std::byte>))
+  __SYCL_BINOP(%, %=, false, (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
   // Bitwise operations are allowed for std::byte.
   __SYCL_BINOP(|, |=, false, (!detail::is_vgenfloat_v<T>))
   __SYCL_BINOP(&, &=, false, (!detail::is_vgenfloat_v<T>))
   __SYCL_BINOP(^, ^=, false, (!detail::is_vgenfloat_v<T>))
-  __SYCL_BINOP(>>, >>=, false, (!detail::is_vgenfloat_v<T> && !std::is_same_v<T, std::byte>))
-  __SYCL_BINOP(<<, <<=, true, (!detail::is_vgenfloat_v<T> && !std::is_same_v<T, std::byte>))
+  __SYCL_BINOP(>>, >>=, false, (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
+  __SYCL_BINOP(<<, <<=, true, (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
+
 #undef __SYCL_BINOP
 
   // Special <<, >> operators for std::byte.
@@ -811,7 +822,7 @@ template <typename Type, int NumElements> class vec {
   //   constexpr std::byte operator>>( std::byte b, IntegerType shift ) noexcept;
 #define __SYCL_SHIFT_BYTE(OP, OPASSIGN)                                         \
   template <typename T = DataT>                                                 \
-  friend typename std::enable_if_t<std::is_same_v<T, std::byte>, vec>           \
+  friend typename std::enable_if_t<(IsByte<T>::value), vec>                     \
   operator OP(const vec & Lhs, int shift) {                                     \
     vec Ret;                                                                    \
     for (size_t I = 0; I < NumElements; ++I) {                                  \
@@ -820,7 +831,7 @@ template <typename Type, int NumElements> class vec {
     return Ret;                                                                 \
   }                                                                             \
   template <typename T = DataT>                                                 \
-  friend typename std::enable_if_t<std::is_same_v<T, std::byte>, vec&>          \
+  friend typename std::enable_if_t<(IsByte<T>::value), vec&>                    \
   operator OPASSIGN(vec & Lhs, int shift) {                                     \
     Lhs = Lhs OP shift;                                                         \
     return Lhs;                                                                 \
@@ -843,9 +854,11 @@ template <typename Type, int NumElements> class vec {
 // Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
 // by SYCL device compiler only.
 #ifdef __SYCL_DEVICE_ONLY__
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const vec & Rhs) {          \
+#define __SYCL_RELLOGOP(RELLOGOP, COND)                                        \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
+  operator RELLOGOP(const vec & Lhs, const vec & Rhs) {                        \
+                                                                               \
     vec<rel_t, NumElements> Ret{};                                             \
     /* ext_vector_type does not support bfloat16, so for these   */            \
     /* we do element-by-element operation on the underlying std::array.  */    \
@@ -853,8 +866,7 @@ template <typename Type, int NumElements> class vec {
       for (size_t I = 0; I < NumElements; ++I) {                               \
         /* We cannot use SetValue here as the operator is not a friend of*/    \
         /* Ret on Windows. */                                                  \
-        Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                    \
-            Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
+        Ret[I] = static_cast<rel_t>(-(Lhs[I] RELLOGOP Rhs[I]));                \
       }                                                                        \
     } else {                                                                   \
       vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
@@ -867,34 +879,39 @@ template <typename Type, int NumElements> class vec {
     }                                                                          \
     return Ret;                                                                \
   }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const DataT & Rhs) {        \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
+  operator RELLOGOP(const vec & Lhs, const DataT & Rhs) {                      \
     return Lhs RELLOGOP vec(Rhs);                                              \
   }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
-                                                   const vec & Rhs) {          \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
+  operator RELLOGOP(const DataT & Lhs, const vec & Rhs) {                      \
     return vec(Lhs) RELLOGOP Rhs;                                              \
   }
 
 #else
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const vec & Rhs) {          \
+#define __SYCL_RELLOGOP(RELLOGOP, COND)                                        \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
+  operator RELLOGOP(const vec & Lhs, const vec & Rhs) {                        \
+                                                                               \
     vec<rel_t, NumElements> Ret{};                                             \
     for (size_t I = 0; I < NumElements; ++I) {                                 \
       /* We cannot use SetValue here as the operator is not a friend of*/      \
       /* Ret on Windows. */                                                    \
-      Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get(                      \
-          Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I))));   \
+      Ret[I] = static_cast<rel_t>(-(Lhs[I] RELLOGOP Rhs[I]));                  \
     }                                                                          \
     return Ret;                                                                \
   }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs,            \
-                                                   const DataT & Rhs) {        \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
+  operator RELLOGOP(const vec & Lhs, const DataT & Rhs) {                      \
     return Lhs RELLOGOP vec(Rhs);                                              \
   }                                                                            \
-  friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs,          \
-                                                   const vec & Rhs) {          \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
+  operator RELLOGOP(const DataT & Lhs, const vec & Rhs) {                      \
     return vec(Lhs) RELLOGOP Rhs;                                              \
   }
 #endif
@@ -902,38 +919,47 @@ template <typename Type, int NumElements> class vec {
   // OP is: ==, !=, <, >, <=, >=, &&, ||
   // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
   // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
-  __SYCL_RELLOGOP(==)
-  __SYCL_RELLOGOP(!=)
-  __SYCL_RELLOGOP(>)
-  __SYCL_RELLOGOP(<)
-  __SYCL_RELLOGOP(>=)
-  __SYCL_RELLOGOP(<=)
-  // TODO: limit to integral types.
-  __SYCL_RELLOGOP(&&)
-  __SYCL_RELLOGOP(||)
+  __SYCL_RELLOGOP(==, (true))
+  __SYCL_RELLOGOP(!=, (true))
+  __SYCL_RELLOGOP(>, (true))
+  __SYCL_RELLOGOP(<, (true))
+  __SYCL_RELLOGOP(>=, (true))
+  __SYCL_RELLOGOP(<=, (true))
+
+  // Only available to integral types.
+  __SYCL_RELLOGOP(&&, (!detail::is_vgenfloat_v<T>) && (!IsByte<T>::value))
+  __SYCL_RELLOGOP(||, (!detail::is_vgenfloat_v<T>) && (!IsByte<T>::value))
 #undef __SYCL_RELLOGOP
 
+
+// ++ and -- operators are only allowed for DataT!=std::byte and DataT!=bool
 #ifdef __SYCL_UOP
 #error "Undefine __SYCL_UOP macro"
 #endif
-#define __SYCL_UOP(UOP, OPASSIGN)                                              \
-  friend vec &operator UOP(vec & Rhs) {                                        \
+#define __SYCL_UOP(UOP, OPASSIGN, COND)                                        \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec &>                              \
+  operator UOP(vec & Rhs) {                                                    \
     Rhs OPASSIGN vec_data<DataT>::set(1);                                      \
     return Rhs;                                                                \
   }                                                                            \
-  friend vec operator UOP(vec &Lhs, int) {                                     \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec>                                \
+  operator UOP(vec &Lhs, int) {                                                \
     vec Ret(Lhs);                                                              \
     Lhs OPASSIGN vec_data<DataT>::set(1);                                      \
     return Ret;                                                                \
   }
 
-  __SYCL_UOP(++, +=)
-  __SYCL_UOP(--, -=)
+  __SYCL_UOP(++, +=, ((!std::is_same_v<T, std::byte>) && !std::is_same_v<T, bool>))
+  __SYCL_UOP(--, -=, ((!std::is_same_v<T, std::byte>) && !std::is_same_v<T, bool>))
 #undef __SYCL_UOP
 
   // operator~() available only when: dataT != float && dataT != double
   // && dataT != half
-  friend vec operator~(const vec &Rhs) {
+  template <typename T = DataT>
+  friend typename std::enable_if_t<!detail::is_vgenfloat_v<T>, vec>
+  operator~(const vec &Rhs) {
 #ifdef __SYCL_DEVICE_ONLY__
     auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
     vec Ret{~extVec};
@@ -950,18 +976,15 @@ template <typename Type, int NumElements> class vec {
 #endif
   }
 
-  // operator!
-  friend vec<detail::rel_t<DataT>, NumElements> operator!(const vec &Rhs) {
+  // operator!. Not available for std::byte.
+  template <typename T = DataT>
+  friend typename std::enable_if_t<(!IsByte<T>::value), vec<detail::rel_t<DataT>, NumElements>>
+  operator!(const vec &Rhs) {
     vec Ret{};
 #ifdef __SYCL_DEVICE_ONLY__
     if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
                   !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
-                  !std::is_same_v<DataT, bool> &&
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-                  !std::is_same_v<DataT, std::byte>)
-#else
-                  1)
-#endif // defined(_HAS_STD_BYTE)
+                  !std::is_same_v<DataT, bool>)
     {
       auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
       return vec<detail::rel_t<DataT>, NumElements>{!extVec};
@@ -969,23 +992,16 @@ template <typename Type, int NumElements> class vec {
 #endif // __SYCL_DEVICE_ONLY__
     {
       for (size_t I = 0; I < NumElements; ++I) {
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-        // std::byte neither supports ! unary op or casting, so special handling
-        // is needed. And, worse, Windows has a conflict with 'byte'.
-        if constexpr (std::is_same_v<std::byte, DataT>) {
-          Ret.setValue(I, std::byte{!vec_data<DataT>::get(Rhs.getValue(I))});
-        } else
-#endif // (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-        {
-          Ret.setValue(I, !vec_data<DataT>::get(Rhs.getValue(I)));
-        }
+        Ret.setValue(I, !vec_data<DataT>::get(Rhs[I]));
       }
       return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
     }
   }
 
-  // operator +
-  friend vec operator+(const vec &Lhs) {
+  // operator +. Not available for std::byte as it is not an arithmetic type.
+  template <typename T = DataT>
+  friend typename std::enable_if_t<(!IsByte<T>::value), vec>
+  operator+(const vec &Lhs) {
 #ifdef __SYCL_DEVICE_ONLY__
     auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
     return vec{+extVec};
@@ -998,25 +1014,19 @@ template <typename Type, int NumElements> class vec {
 #endif
   }
 
-  // operator -
-  friend vec operator-(const vec &Lhs) {
+  // operator -. Not available for std::byte as it is not an arithmetic type.
+  template <typename T = DataT>
+  friend typename std::enable_if_t<(!IsByte<T>::value), vec>
+  operator-(const vec &Lhs) {
     namespace oneapi = sycl::ext::oneapi;
     vec Ret{};
-    if constexpr (IsBfloat16 && NumElements == 1) {
-      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[0]);
-      oneapi::bfloat16 w = -v;
-      Ret.m_Data[0] = oneapi::detail::bfloat16ToBits(w);
-    } else if constexpr (IsBfloat16) {
-      for (size_t I = 0; I < NumElements; I++) {
-        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(Lhs.m_Data[I]);
-        oneapi::bfloat16 w = -v;
-        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
-      }
+    if constexpr (IsBfloat16) {
+    for (size_t I = 0; I < NumElements; I++)
+      Ret.m_Data[I] = -Lhs.m_Data[I];
     } else {
 #ifndef __SYCL_DEVICE_ONLY__
       for (size_t I = 0; I < NumElements; ++I)
-        Ret.setValue(
-            I, vec_data<DataT>::get(-vec_data<DataT>::get(Lhs.getValue(I))));
+        Ret[I] = -Lhs[I];
 #else
       auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
       Ret = vec{-extVec};
diff --git a/sycl/test-e2e/Basic/vector/byte_preview.cpp b/sycl/test-e2e/Basic/vector/byte_preview.cpp
index 49db97a294a51..c1f8605b12f2b 100644
--- a/sycl/test-e2e/Basic/vector/byte_preview.cpp
+++ b/sycl/test-e2e/Basic/vector/byte_preview.cpp
@@ -14,6 +14,10 @@
 #include <cstddef> // std::byte
 #include <tuple>   // std::ignore
 
+// std::byte is not an arithmetic type or a character type, so std::byte and
+// vec<std::byte> support a limited set of operations. Namely, bitwise
+// operations, comparison operations, and shift operations.
+
 int main() {
   std::byte bt{7};
   // constructors
@@ -131,10 +135,6 @@ int main() {
     auto swor3 = std::byte{3} | swlo;
     auto swxor3 = std::byte{3} ^ swlo;
 
-    // bit binary op for 2 vec
-    vop = vop1 && vop2;
-    vop = vop1 || vop2;
-
     vop = vop1 << 3;
     vop = vop1 >> 3;
 
@@ -182,7 +182,6 @@ int main() {
 
     sycl::vec<std::byte, 3> voptest{std::byte{4}, std::byte{9}, std::byte{25}};
     auto bitv1 = ~vop3;
-    auto bitv2 = !vop3;
     auto bitw = ~swhi;
   }
 

From 62dd74d521174a80a117381be3aae068b9856b89 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 8 May 2024 11:59:30 -0700
Subject: [PATCH 55/79] Add guard before using std::byte

---
 sycl/include/sycl/detail/vector_convert.hpp | 2 ++
 sycl/test-e2e/Basic/vector/byte_preview.cpp | 1 +
 2 files changed, 3 insertions(+)

diff --git a/sycl/include/sycl/detail/vector_convert.hpp b/sycl/include/sycl/detail/vector_convert.hpp
index 0c7232a1a1041..5a9f05c3c8479 100644
--- a/sycl/include/sycl/detail/vector_convert.hpp
+++ b/sycl/include/sycl/detail/vector_convert.hpp
@@ -558,12 +558,14 @@ NativeToT convertImpl(NativeFromT Value) {
   }
 }
 
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
 template <typename FromT, typename ToT, sycl::rounding_mode RoundingMode,
           int VecSize, typename NativeFromT, typename NativeToT>
 auto ConvertImpl(std::byte val){
   return convertImpl<FromT, ToT, RoundingMode, VecSize, NativeFromT, NativeToT>(
     (std::int8_t)val);
 }
+#endif
 
 } // namespace detail
 } // namespace _V1
diff --git a/sycl/test-e2e/Basic/vector/byte_preview.cpp b/sycl/test-e2e/Basic/vector/byte_preview.cpp
index c1f8605b12f2b..6caf45cc3e98d 100644
--- a/sycl/test-e2e/Basic/vector/byte_preview.cpp
+++ b/sycl/test-e2e/Basic/vector/byte_preview.cpp
@@ -141,6 +141,7 @@ int main() {
     // bit binary op for 2 swizzle
     // TODO: Fix >> and << for swizzle of std::byte. Currently, Swizzles assume that both operands
     // of the >> abd << operator have the same data type. That is not the case with std::byte.
+  
     // swlo >> 3;
     // swlo << 3;
 

From 54e9c2594b75ab2a5a5b31166a71aa4d455920d6 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 8 May 2024 12:01:31 -0700
Subject: [PATCH 56/79] clang format

---
 sycl/include/sycl/detail/vector_convert.hpp |   4 +-
 sycl/include/sycl/vector_preview.hpp        | 116 ++++++++++----------
 sycl/test-e2e/Basic/vector/byte_preview.cpp |   7 +-
 3 files changed, 64 insertions(+), 63 deletions(-)

diff --git a/sycl/include/sycl/detail/vector_convert.hpp b/sycl/include/sycl/detail/vector_convert.hpp
index 5a9f05c3c8479..6552daa560e9a 100644
--- a/sycl/include/sycl/detail/vector_convert.hpp
+++ b/sycl/include/sycl/detail/vector_convert.hpp
@@ -561,9 +561,9 @@ NativeToT convertImpl(NativeFromT Value) {
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
 template <typename FromT, typename ToT, sycl::rounding_mode RoundingMode,
           int VecSize, typename NativeFromT, typename NativeToT>
-auto ConvertImpl(std::byte val){
+auto ConvertImpl(std::byte val) {
   return convertImpl<FromT, ToT, RoundingMode, VecSize, NativeFromT, NativeToT>(
-    (std::int8_t)val);
+      (std::int8_t)val);
 }
 #endif
 
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 6b87a6c39c525..84352e4775914 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -160,8 +160,7 @@ using vec_data_t = typename detail::vec_helper<T>::NativeType;
 template <typename T, int N>
 using data_type_multiple_t = typename std::conditional_t<
     // bool
-    std::is_same_v<T, bool>, std::array<int8_t, N>,
-    std::array<T, N>>;
+    std::is_same_v<T, bool>, std::array<int8_t, N>, std::array<T, N>>;
 
 // sycl::vec is converted to vector_t_single and vector_t_multiple
 // data types on device for use in SPIRV builtins.
@@ -176,8 +175,8 @@ using vector_t_single = typename std::conditional_t<
                                     std::is_same_v<T, std::byte>, std::uint8_t,
                                     typename std::conditional_t<
 #else
-                                     false, T,
-                                     typename std::conditional_t<
+                                    false, T,
+                                    typename std::conditional_t<
 #endif
                                         true, T, T>>>>;
 
@@ -367,9 +366,7 @@ template <typename Type, int NumElements> class vec {
   template <size_t... Is>
   constexpr vec(const std::array<DataT, NumElements> &Arr,
                 std::index_sequence<Is...>)
-      : m_Data{([&](DataT v) constexpr {
-          return v;
-        })(Arr[Is])...} {}
+      : m_Data{([&](DataT v) constexpr { return v; })(Arr[Is])...} {}
 
 public:
   using element_type = DataT;
@@ -427,15 +424,15 @@ template <typename Type, int NumElements> class vec {
 #ifdef __SYCL_BITCAST_IS_CONSTEXPR
     m_Data = sycl::bit_cast<DataType>(openclVector);
 #else
-  // Awkward workaround. sycl::bit_cast isn't constexpr in older GCC
-  // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
-  // but neither available yet.
-  union {
-    vector_t from;
-    DataType to;
-  } result = {};
-  result.from = openclVector;
-  m_Data = result.to;
+    // Awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+    // but neither available yet.
+    union {
+      vector_t from;
+      DataType to;
+    } result = {};
+    result.from = openclVector;
+    m_Data = result.to;
 #endif
   }
 
@@ -444,9 +441,7 @@ template <typename Type, int NumElements> class vec {
    * Converts this SYCL vec instance to the underlying backend-native vector
    * type defined by vector_t.
    */
-  operator vector_t() const {
-      return sycl::bit_cast<vector_t>(m_Data);
-  }
+  operator vector_t() const { return sycl::bit_cast<vector_t>(m_Data); }
 #endif // __SYCL_DEVICE_ONLY__
 
   // Available only when: NumElements == 1
@@ -699,14 +694,14 @@ template <typename Type, int NumElements> class vec {
     }
   }
 
- /******************* sycl::vec math operations ***********************/
+  /******************* sycl::vec math operations ***********************/
 
-template <typename T>
-using IsByte = typename
+  template <typename T>
+  using IsByte = typename
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-  std::is_same<T, std::byte>;
+      std::is_same<T, std::byte>;
 #else
-  std::false_type;
+      std::false_type;
 #endif
 
 #ifdef __SYCL_BINOP
@@ -765,8 +760,8 @@ using IsByte = typename
       const vec & Lhs, const vec & Rhs) {                                      \
     vec Ret{};                                                                 \
     for (size_t I = 0; I < NumElements; ++I) {                                 \
-      Ret.setValue(I, vec_data<DataT>::set(vec_data<DataT>::set(Lhs[I]) BINOP  \
-                                           vec_data<DataT>::set(Rhs[I])));     \
+      Ret.setValue(I, vec_data<DataT>::set(vec_data<DataT>::set(               \
+                          Lhs[I]) BINOP vec_data<DataT>::set(Rhs[I])));        \
     }                                                                          \
     return Ret;                                                                \
   }                                                                            \
@@ -802,13 +797,16 @@ using IsByte = typename
 
   // The following OPs are available only when: DataT != cl_float &&
   // DataT != cl_double && DataT != cl_half && DataT != BF16.
-  __SYCL_BINOP(%, %=, false, (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
+  __SYCL_BINOP(%, %=, false,
+               (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
   // Bitwise operations are allowed for std::byte.
   __SYCL_BINOP(|, |=, false, (!detail::is_vgenfloat_v<T>))
   __SYCL_BINOP(&, &=, false, (!detail::is_vgenfloat_v<T>))
   __SYCL_BINOP(^, ^=, false, (!detail::is_vgenfloat_v<T>))
-  __SYCL_BINOP(>>, >>=, false, (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
-  __SYCL_BINOP(<<, <<=, true, (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
+  __SYCL_BINOP(>>, >>=, false,
+               (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
+  __SYCL_BINOP(<<, <<=, true,
+               (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
 
 #undef __SYCL_BINOP
 
@@ -817,24 +815,27 @@ using IsByte = typename
   // overloads of >> and << operators.
   //
   // 1 template <class IntegerType>
-  //   constexpr std::byte operator<<( std::byte b, IntegerType shift ) noexcept;
+  //   constexpr std::byte operator<<( std::byte b, IntegerType shift )
+  //   noexcept;
   // 2 template <class IntegerType>
-  //   constexpr std::byte operator>>( std::byte b, IntegerType shift ) noexcept;
-#define __SYCL_SHIFT_BYTE(OP, OPASSIGN)                                         \
-  template <typename T = DataT>                                                 \
-  friend typename std::enable_if_t<(IsByte<T>::value), vec>                     \
-  operator OP(const vec & Lhs, int shift) {                                     \
-    vec Ret;                                                                    \
-    for (size_t I = 0; I < NumElements; ++I) {                                  \
-      Ret.setValue(I, Lhs[I] OP shift);                                         \
-    }                                                                           \
-    return Ret;                                                                 \
-  }                                                                             \
-  template <typename T = DataT>                                                 \
-  friend typename std::enable_if_t<(IsByte<T>::value), vec&>                    \
-  operator OPASSIGN(vec & Lhs, int shift) {                                     \
-    Lhs = Lhs OP shift;                                                         \
-    return Lhs;                                                                 \
+  //   constexpr std::byte operator>>( std::byte b, IntegerType shift )
+  //   noexcept;
+#define __SYCL_SHIFT_BYTE(OP, OPASSIGN)                                        \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(IsByte<T>::value), vec> operator OP(       \
+      const vec & Lhs, int shift) {                                            \
+    vec Ret;                                                                   \
+    for (size_t I = 0; I < NumElements; ++I) {                                 \
+      Ret.setValue(I, Lhs[I] OP shift);                                        \
+    }                                                                          \
+    return Ret;                                                                \
+  }                                                                            \
+  template <typename T = DataT>                                                \
+  friend                                                                       \
+      typename std::enable_if_t<(IsByte<T>::value), vec &> operator OPASSIGN(  \
+          vec & Lhs, int shift) {                                              \
+    Lhs = Lhs OP shift;                                                        \
+    return Lhs;                                                                \
   }
 
   __SYCL_SHIFT_BYTE(<<, <<=)
@@ -931,28 +932,27 @@ using IsByte = typename
   __SYCL_RELLOGOP(||, (!detail::is_vgenfloat_v<T>) && (!IsByte<T>::value))
 #undef __SYCL_RELLOGOP
 
-
 // ++ and -- operators are only allowed for DataT!=std::byte and DataT!=bool
 #ifdef __SYCL_UOP
 #error "Undefine __SYCL_UOP macro"
 #endif
 #define __SYCL_UOP(UOP, OPASSIGN, COND)                                        \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec &>                              \
-  operator UOP(vec & Rhs) {                                                    \
+  friend typename std::enable_if_t<(COND), vec &> operator UOP(vec & Rhs) {    \
     Rhs OPASSIGN vec_data<DataT>::set(1);                                      \
     return Rhs;                                                                \
   }                                                                            \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec>                                \
-  operator UOP(vec &Lhs, int) {                                                \
+  friend typename std::enable_if_t<(COND), vec> operator UOP(vec & Lhs, int) { \
     vec Ret(Lhs);                                                              \
     Lhs OPASSIGN vec_data<DataT>::set(1);                                      \
     return Ret;                                                                \
   }
 
-  __SYCL_UOP(++, +=, ((!std::is_same_v<T, std::byte>) && !std::is_same_v<T, bool>))
-  __SYCL_UOP(--, -=, ((!std::is_same_v<T, std::byte>) && !std::is_same_v<T, bool>))
+  __SYCL_UOP(++, +=,
+             ((!std::is_same_v<T, std::byte>) && !std::is_same_v<T, bool>))
+  __SYCL_UOP(--, -=,
+             ((!std::is_same_v<T, std::byte>) && !std::is_same_v<T, bool>))
 #undef __SYCL_UOP
 
   // operator~() available only when: dataT != float && dataT != double
@@ -978,14 +978,14 @@ using IsByte = typename
 
   // operator!. Not available for std::byte.
   template <typename T = DataT>
-  friend typename std::enable_if_t<(!IsByte<T>::value), vec<detail::rel_t<DataT>, NumElements>>
+  friend typename std::enable_if_t<(!IsByte<T>::value),
+                                   vec<detail::rel_t<DataT>, NumElements>>
   operator!(const vec &Rhs) {
     vec Ret{};
 #ifdef __SYCL_DEVICE_ONLY__
     if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
                   !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
-                  !std::is_same_v<DataT, bool>)
-    {
+                  !std::is_same_v<DataT, bool>) {
       auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
       return vec<detail::rel_t<DataT>, NumElements>{!extVec};
     } else
@@ -1021,8 +1021,8 @@ using IsByte = typename
     namespace oneapi = sycl::ext::oneapi;
     vec Ret{};
     if constexpr (IsBfloat16) {
-    for (size_t I = 0; I < NumElements; I++)
-      Ret.m_Data[I] = -Lhs.m_Data[I];
+      for (size_t I = 0; I < NumElements; I++)
+        Ret.m_Data[I] = -Lhs.m_Data[I];
     } else {
 #ifndef __SYCL_DEVICE_ONLY__
       for (size_t I = 0; I < NumElements; ++I)
diff --git a/sycl/test-e2e/Basic/vector/byte_preview.cpp b/sycl/test-e2e/Basic/vector/byte_preview.cpp
index 6caf45cc3e98d..7e9bb191a87db 100644
--- a/sycl/test-e2e/Basic/vector/byte_preview.cpp
+++ b/sycl/test-e2e/Basic/vector/byte_preview.cpp
@@ -139,9 +139,10 @@ int main() {
     vop = vop1 >> 3;
 
     // bit binary op for 2 swizzle
-    // TODO: Fix >> and << for swizzle of std::byte. Currently, Swizzles assume that both operands
-    // of the >> abd << operator have the same data type. That is not the case with std::byte.
-  
+    // TODO: Fix >> and << for swizzle of std::byte. Currently, Swizzles assume
+    // that both operands of the >> abd << operator have the same data type.
+    // That is not the case with std::byte.
+
     // swlo >> 3;
     // swlo << 3;
 

From 4ec3cc1fdf54e2a6a19d0c2a10c65148cebac27e Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 8 May 2024 21:32:12 -0700
Subject: [PATCH 57/79] Update dev code. Replace union UB with
 __builtin_bit_cast

---
 sycl/include/sycl/vector_preview.hpp          |  14 +-
 .../vector/vector_math_ops.cpp                | 354 +++++++-----------
 2 files changed, 126 insertions(+), 242 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 84352e4775914..4941400ee829d 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -421,19 +421,7 @@ template <typename Type, int NumElements> class vec {
                 typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
                                           !std::is_same_v<vector_t_, DataT>>>
   constexpr vec(vector_t_ openclVector) {
-#ifdef __SYCL_BITCAST_IS_CONSTEXPR
-    m_Data = sycl::bit_cast<DataType>(openclVector);
-#else
-    // Awkward workaround. sycl::bit_cast isn't constexpr in older GCC
-    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
-    // but neither available yet.
-    union {
-      vector_t from;
-      DataType to;
-    } result = {};
-    result.from = openclVector;
-    m_Data = result.to;
-#endif
+    m_Data = __builtin_bit_cast(DataType, openclVector);
   }
 
   /* @SYCL2020
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index b9bec834300a5..164a1a24ea8db 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -3,10 +3,8 @@
 // ./llvm/utils/update_cc_test_checks.py --clang=./build/bin/clang
 // ./sycl/test/check_device_code/vector/vector_math_ops.cpp
 
-// RUN: %clangxx -I %sycl_include -S -emit-llvm -fno-sycl-instrument-device-code -Xclang -disable-lifetime-markers -fsycl-device-only %s -o - | FileCheck %s
-// RUN: %if preview-breaking-changes-supported %{ %clangxx -I %sycl_include -S -emit-llvm -fpreview-breaking-changes -fno-sycl-instrument-device-code -Xclang -disable-lifetime-markers -fsycl-device-only %s -o - | FileCheck %s -check-prefix=CHECK-ARR-STORAGE %}
-
-// REQUIRES: asserts
+// RUN: %clangxx -I %sycl_include -S -emit-llvm -fno-discard-value-names -fno-sycl-instrument-device-code -Xclang -disable-lifetime-markers -fsycl-device-only %s -o - | FileCheck %s
+// RUN: %if preview-breaking-changes-supported %{ %clangxx -I %sycl_include -S -emit-llvm -fno-discard-value-names -fpreview-breaking-changes -fno-sycl-instrument-device-code -Xclang -disable-lifetime-markers -fsycl-device-only %s -o - | FileCheck %s -check-prefix=CHECK-ARR-STORAGE %}
 
 // This test checks
 // (1) the storage type of sycl::vec on device for all data types, and
@@ -27,7 +25,7 @@ using namespace sycl;
 // CHECK-NEXT:    store <2 x i32> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIiLi2EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[A]], align 4, {{.*}}
@@ -49,7 +47,7 @@ SYCL_EXTERNAL auto TestAdd(vec<int, 2> a, vec<int, 2> b) { return a + b; }
 // CHECK-NEXT:    store <4 x float> [[EXTRACTVEC5_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIfLi3EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x float>, ptr [[A]], align 4, {{.*}}
@@ -71,7 +69,7 @@ SYCL_EXTERNAL auto TestAdd(vec<float, 3> a, vec<float, 3> b) { return a + b; }
 // CHECK-NEXT:    store <16 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIcLi16EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, {{.*}}
@@ -82,27 +80,28 @@ SYCL_EXTERNAL auto TestAdd(vec<float, 3> a, vec<float, 3> b) { return a + b; }
 //
 SYCL_EXTERNAL auto TestAdd(vec<char, 16> a, vec<char, 16> b) { return a + b; }
 
-// CHECK-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecISt4byteLi8EEES3_(
+// std::byte does not support '+'. Therefore, using bitwise XOR as a substitute.
+// CHECK-LABEL: define dso_local spir_func void @_Z7TestXorN4sycl3_V13vecISt4byteLi8EEES3_(
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 8 [[B:%.*]]) {{.*}}{
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-NEXT:    [[TMP0:%.*]] = load <8 x i8>, ptr [[A]], align 8, {{.*}}
 // CHECK-NEXT:    [[TMP1:%.*]] = load <8 x i8>, ptr [[B]], align 8, {{.*}}
-// CHECK-NEXT:    [[ADD_I:%.*]] = add <8 x i8> [[TMP0]], [[TMP1]]
-// CHECK-NEXT:    store <8 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
+// CHECK-NEXT:    [[XOR_I:%.*]] = xor <8 x i8> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    store <8 x i8> [[XOR_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecISt4byteLi8EEES3_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestXorN4sycl3_V13vecISt4byteLi8EEES3_(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x i8>, ptr [[A]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <8 x i8>, ptr [[B]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <8 x i8> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    store <8 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[XOR_I:%.*]] = xor <8 x i8> [[TMP0]], [[TMP1]]
+// CHECK-ARR-STORAGE-NEXT:    store <8 x i8> [[XOR_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
-SYCL_EXTERNAL auto TestAdd(vec<std::byte, 8> a, vec<std::byte, 8> b) {
-  return a + b;
+SYCL_EXTERNAL auto TestXor(vec<std::byte, 8> a, vec<std::byte, 8> b) {
+  return a ^ b;
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIbLi4EEES2_(
@@ -130,7 +129,7 @@ SYCL_EXTERNAL auto TestAdd(vec<std::byte, 8> a, vec<std::byte, 8> b) {
 // CHECK-NEXT:    store <4 x i8> [[VECINS_I_I6_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIbLi4EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.6") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.6") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 1, {{.*}}
@@ -141,16 +140,16 @@ SYCL_EXTERNAL auto TestAdd(vec<std::byte, 8> a, vec<std::byte, 8> b) {
 // CHECK-ARR-STORAGE:       for.cond.i.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I:%.*]], [[FOR_BODY_I_I:%.*]] ]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = icmp ult i64 [[I_0_I_I]], 4
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECIBLI4EEES4__EXIT:%.*]]
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIBLI4EEEE4TYPEERKS5_S9__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP2:%.*]] = load i8, ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I_I_I_I:%.*]] = icmp ne i8 [[TMP2]], 0
-// CHECK-ARR-STORAGE-NEXT:    [[FROMBOOL_I_I:%.*]] = zext i1 [[TOBOOL_I_I_I_I]] to i8
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[FROMBOOL_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP2:%.*]] = load i8, ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I_I_I:%.*]] = icmp ne i8 [[TMP2]], 0
+// CHECK-ARR-STORAGE-NEXT:    [[FROMBOOL_I_I_I_I:%.*]] = zext i1 [[TOBOOL_I_I_I]] to i8
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[FROMBOOL_I_I_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I_I]] = add nuw nsw i64 [[I_0_I_I]], 1
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP29:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1plERKNS0_3vecIbLi4EEES4_.exit:
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIbLi4EEEE4typeERKS5_S9_.exit:
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
@@ -166,7 +165,7 @@ SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
 // CHECK-NEXT:    store <4 x half> [[EXTRACTVEC5_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_6detail9half_impl4halfELi3EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x half>, ptr [[A]], align 2, {{.*}}
@@ -227,47 +226,34 @@ SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP3_I]])
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP3_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP3_I]])
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP3_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP3_I]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI3EEES7__EXIT:%.*]]
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI3EEEE4TYPEERKS8_SC__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[A]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP0]], ptr [[REF_TMP1_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I10_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[B]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I_I10_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP1]], ptr [[REF_TMP3_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8:[0-9]+]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL3_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP1_ASCAST_I]]) #[[ATTR8:[0-9]+]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP3_ASCAST_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9:[0-9]+]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL3_I]]) #[[ATTR9]], {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I12_I:%.*]] = getelementptr inbounds [4 x i16], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I12_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP88:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1plERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi3EEES7_.exit:
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP3_I]])
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP47:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_.exit:
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
@@ -288,7 +274,7 @@ SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
 // CHECK-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIiLi16EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 4, {{.*}}
@@ -315,12 +301,12 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
 // CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecISt4byteLi3EEES3_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I7_I:%.*]] = load <4 x i8>, ptr [[B]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = icmp sgt <4 x i8> [[LOADVEC4_I_I]], [[LOADVEC4_I7_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = icmp ugt <4 x i8> [[LOADVEC4_I_I]], [[LOADVEC4_I7_I]]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = shufflevector <4 x i1> [[TMP0]], <4 x i1> poison, <3 x i32> <i32 0, i32 1, i32 2>
 // CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i8>
 // CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I9_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
@@ -342,7 +328,7 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
 // CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIbLi2EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.16") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 2 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 1, {{.*}}
@@ -367,7 +353,7 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
 // CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.19") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, {{.*}}
@@ -384,7 +370,6 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 // FIXME: We incorrectly interpret BF16 as INT16 to peform logical operation.
 // For example, vec<BF16, 2>{-0.5, 3.333} < vec<BF16, 2>{6.0, 6.666} results
 // into {-1, -1} on host but {0, -1} on device.
-
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEES5_(
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.13") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.14") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.14") align 8 [[B:%.*]]) {{.*}}{
 // CHECK-NEXT:  entry:
@@ -396,39 +381,30 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 // CHECK-NEXT:    store <4 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.23") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.25") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.25") align 8 [[B:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.24") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP_I]])
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP_I]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI4EEES7__EXIT:%.*]]
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTINS0_3EXT6ONEAPI8BFLOAT16EEENS0_3VECISLI4EEERKNS5_IS4_LI4EEES9__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[A]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP0]], ptr [[REF_TMP_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I14_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[B]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I_I14_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP1]], ptr [[REF_TMP1_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP_ASCAST_I]]) #[[ATTR8]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP1_ASCAST_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR9]], {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
 // CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP136:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1gtERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi4EEES7_.exit:
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP_I]])
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP69:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_.exit:
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
@@ -467,7 +443,7 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 16, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIiLi3EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.26") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.26") align 16 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.27") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.27") align 16 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 4, {{.*}}
@@ -489,7 +465,7 @@ SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
 // CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecIiLi4EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.28") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.28") align 16 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 4, {{.*}}
@@ -499,98 +475,28 @@ SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
 //
 SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
 
-// CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecISt4byteLi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 16 [[A:%.*]]) {{.*}}{
+// Negation is not valid for std::byte. Therefore, using bitwise negation.
+// CHECK-LABEL: define dso_local spir_func void @_Z19TestBitwiseNegationN4sycl3_V13vecISt4byteLi16EEE(
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.17") align 16 [[A:%.*]]) {{.*}}{
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec.18", align 16
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 16, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, {{.*}}
-// CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <16 x i8> [[TMP0]], zeroinitializer
-// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <16 x i1> [[CMP_I]] to <16 x i8>
-// CHECK-NEXT:    store <16 x i8> [[SEXT_I]], ptr [[REF_TMP_I]], align 16, {{.*}}
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
-// CHECK:       for.cond.i.i.i:
-// CHECK-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
-// CHECK-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 16
-// CHECK-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIST4BYTELI16EEE_EXIT:%.*]]
-// CHECK:       for.body.i.i.i:
-// CHECK-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[REF_TMP_I]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
-// CHECK-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
-// CHECK-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
-// CHECK-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP97]]
-// CHECK:       _ZN4sycl3_V1ntERKNS0_3vecISt4byteLi16EEE.exit:
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 16, ptr nonnull [[REF_TMP_I]])
+// CHECK-NEXT:    [[NOT_I:%.*]] = xor <16 x i8> [[TMP0]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
+// CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecISt4byteLi16EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.31") align 16 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z19TestBitwiseNegationN4sycl3_V13vecISt4byteLi16EEE(
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.30") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.30") align 16 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.31", align 16
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 16, ptr nonnull [[RET_I]])
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.memset.p0.i64(ptr align 16 [[RET_I]], i8 0, i64 16, i1 false), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 16
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [16 x i8], ptr [[A]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_NOT_I:%.*]] = icmp eq i8 [[TMP0]], 0
-// CHECK-ARR-STORAGE-NEXT:    [[CONV3_I:%.*]] = zext i1 [[TOBOOL_NOT_I]] to i8
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I8_I:%.*]] = getelementptr inbounds [16 x i8], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[CONV3_I]], ptr [[ARRAYIDX_I_I_I_I8_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP149:![0-9]+]]
-// CHECK-ARR-STORAGE:       for.end.i:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 16
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIST4BYTELI16EEE_EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP154:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntERKNS0_3vecISt4byteLi16EEE.exit:
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 16, ptr nonnull [[RET_I]])
-// CHECK-ARR-STORAGE-NEXT:    ret void
-//
-SYCL_EXTERNAL auto TestNegation(vec<std::byte, 16> a) { return !a; }
-
-// CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecISt4byteLi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 4 [[A:%.*]]) {{.*}}{
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-NEXT:    [[LOADVEC4_I:%.*]] = load <4 x i8>, ptr [[A]], align 4, {{.*}}
-// CHECK-NEXT:    [[EXTRACTVEC_I:%.*]] = shufflevector <4 x i8> [[LOADVEC4_I]], <4 x i8> poison, <3 x i32> <i32 0, i32 1, i32 2>
-// CHECK-NEXT:    [[SUB_I:%.*]] = sub <3 x i8> zeroinitializer, [[EXTRACTVEC_I]]
-// CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i8> [[SUB_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
-// CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecISt4byteLi3EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.15") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]]) {{.*}} {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x i8> [[LOADVEC4_I_I]], <4 x i8> poison, <3 x i32> <i32 0, i32 1, i32 2>
-// CHECK-ARR-STORAGE-NEXT:    [[SUB_I:%.*]] = sub <3 x i8> zeroinitializer, [[EXTRACTVEC_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I2_I:%.*]] = shufflevector <3 x i8> [[SUB_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-ARR-STORAGE-NEXT:    store <4 x i8> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[NOT_I:%.*]] = xor <16 x i8> [[TMP0]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
+// CHECK-ARR-STORAGE-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
-SYCL_EXTERNAL auto TestMinus(vec<std::byte, 3> a) { return -a; }
+SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.19") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[A:%.*]]) {{.*}}{
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.18") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[A:%.*]]) {{.*}}{
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec.3", align 4
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
@@ -616,7 +522,7 @@ SYCL_EXTERNAL auto TestMinus(vec<std::byte, 3> a) { return -a; }
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.6", align 4
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
@@ -628,38 +534,37 @@ SYCL_EXTERNAL auto TestMinus(vec<std::byte, 3> a) { return -a; }
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr [[A]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I_I_NOT_I:%.*]] = icmp eq i8 [[TMP0]], 0
-// CHECK-ARR-STORAGE-NEXT:    [[FROMBOOL_I:%.*]] = zext i1 [[TOBOOL_I_I_NOT_I]] to i8
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I7_I:%.*]] = getelementptr inbounds [4 x i8], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[FROMBOOL_I]], ptr [[ARRAYIDX_I_I_I_I7_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[FROMBOOL_I:%.*]] = xor i8 [[TMP0]], 1
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[FROMBOOL_I]], ptr [[ARRAYIDX_I_I_I_I]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP163:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP89:![0-9]+]]
 // CHECK-ARR-STORAGE:       for.end.i:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i.i.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 4
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECIBLI4EEE_EXIT:%.*]]
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIALI4EEEE4TYPEERKNS4_IBLI4EEE_EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i.i.i:
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP154]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntERKNS0_3vecIbLi4EEE.exit:
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP94:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIaLi4EEEE4typeERKNS4_IbLi4EEE.exit:
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[RET_I]])
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 4 [[A:%.*]]) {{.*}}{
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.19") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.20") align 4 [[A:%.*]]) {{.*}}{
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec.21", align 4
+// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca %"class.sycl::_V1::vec.20", align 4
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 4, {{.*}}
@@ -683,7 +588,7 @@ SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.35", align 4
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
@@ -695,29 +600,29 @@ SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [2 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[A]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::detail::half_impl::half", ptr [[A]], i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq half [[TMP0]], 0xH0000
-// CHECK-ARR-STORAGE-NEXT:    [[CONV_I9_I:%.*]] = uitofp i1 [[TOBOOL_I]] to half
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I11_I:%.*]] = getelementptr inbounds [2 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store half [[CONV_I9_I]], ptr [[ARRAYIDX_I_I_I_I11_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CONV_I10_I:%.*]] = uitofp i1 [[TOBOOL_I]] to half
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [2 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store half [[CONV_I10_I]], ptr [[ARRAYIDX_I_I_I_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP177:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP101:![0-9]+]]
 // CHECK-ARR-STORAGE:       for.end.i:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i.i.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 4
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECINS0_6DETAIL9HALF_IMPL4HALFELI2EEE_EXIT:%.*]]
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTINS0_6DETAIL9HALF_IMPL4HALFEEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI2EEEE4TYPEERKNS7_IS4_LI2EEE_EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i.i.i:
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP154]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntERKNS0_3vecINS0_6detail9half_impl4halfELi2EEE.exit:
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP94]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi2EEEE4typeERKNS7_IS4_Li2EEE.exit:
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[RET_I]])
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
@@ -732,7 +637,7 @@ SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 // CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.21") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, {{.*}}
@@ -743,7 +648,7 @@ SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.5") align 8 [[A:%.*]]) {{.*}}{
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.21") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.5") align 8 [[A:%.*]]) {{.*}}{
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.5", align 8
 // CHECK-NEXT:    [[REF_TMP1_I:%.*]] = alloca float, align 4
@@ -774,7 +679,7 @@ SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 // CHECK-NEXT:    [[CALL_I_I9_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP1_ASCAST_I]]) #[[ATTR9]], {{.*}}
 // CHECK-NEXT:    [[VECINS_I_I_I]] = insertelement <3 x i16> [[TMP0]], i16 [[CALL_I_I9_I]], i32 [[CONV_I]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP148:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP140:![0-9]+]]
 // CHECK:       for.end.i:
 // CHECK-NEXT:    store <3 x i16> [[TMP0]], ptr [[RET_I]], align 1, {{.*}}
 // CHECK-NEXT:    call void @llvm.experimental.noalias.{{.*}}
@@ -796,17 +701,15 @@ SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP2_I]])
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.10", align 8
 // CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_I:%.*]] = alloca float, align 4
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP2_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 8, ptr nonnull [[RET_I]])
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP1_I]])
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP2_I]])
 // CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP2_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP2_I]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr [[RET_I]], align 8, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
@@ -814,42 +717,40 @@ SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[A]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I_I_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP0]], ptr [[REF_TMP2_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP2_ASCAST_I]]) #[[ATTR8]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
-// CHECK-ARR-STORAGE-NEXT:    [[CONV4_I:%.*]] = uitofp i1 [[CMP_I_I]] to float
+// CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr addrspace(4) [[CALL_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_NOT_I:%.*]] = icmp eq i16 [[TMP0]], 0
+// CHECK-ARR-STORAGE-NEXT:    [[CONV4_I:%.*]] = uitofp i1 [[TOBOOL_NOT_I]] to float
 // CHECK-ARR-STORAGE-NEXT:    store float [[CONV4_I]], ptr [[REF_TMP1_I]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I9_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP1_ASCAST_I]]) #[[ATTR8]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I11_I:%.*]] = getelementptr inbounds [4 x i16], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I9_I]], ptr [[ARRAYIDX_I_I_I_I11_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP1_ASCAST_I]]) #[[ATTR9]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I_I]], ptr [[ARRAYIDX_I_I_I_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP198:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP114:![0-9]+]]
 // CHECK-ARR-STORAGE:       for.end.i:
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i.i.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 8
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI3EEE_EXIT:%.*]]
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i.i.i:
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP154]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi3EEE.exit:
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP94]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 8, ptr nonnull [[RET_I]])
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP1_I]])
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP2_I]])
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.23") align 32 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.23") align 32 [[A:%.*]]) {{.*}}{
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 32 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 32 [[A:%.*]]) {{.*}}{
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
 // CHECK-NEXT:    [[V_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
@@ -875,38 +776,33 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds <16 x i16>, ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
 // CHECK-NEXT:    store i16 [[CALL_I_I_I_I]], ptr addrspace(4) [[TMP1]], align 2, {{.*}}
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP165:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP157:![0-9]+]]
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) {{.*}} {
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
-// CHECK-ARR-STORAGE-NEXT:    [[V_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I:%.*]] = alloca float, align 4
+// CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[V_I]])
-// CHECK-ARR-STORAGE-NEXT:    [[V_ASCAST_I:%.*]] = addrspacecast ptr [[V_I]] to ptr addrspace(4)
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]])
+// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP_I]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 16
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI16EEE_EXIT:%.*]]
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI16EEEE4TYPEERKS8__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds [16 x i16], ptr [[A]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr [[ARRAYIDX_I_I_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[TMP0]], ptr [[V_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I:%.*]] = call spir_func float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[V_ASCAST_I]]) #[[ATTR8]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[FNEG_I_I:%.*]] = fneg float [[CALL_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    store float [[FNEG_I_I]], ptr [[REF_TMP_I_I]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR8]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I7_I:%.*]] = getelementptr inbounds [16 x i16], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I7_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[A_ASCAST]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I_I]]) #[[ATTR9]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[FNEG_I:%.*]] = fneg float [[CALL_I_I_I]]
+// CHECK-ARR-STORAGE-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I8_I:%.*]] = getelementptr inbounds [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I9_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR9]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I9_I]], ptr addrspace(4) [[ARRAYIDX_I_I8_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP215:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ngERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi16EEE.exit:
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[V_I]])
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP125:![0-9]+]]
+// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<ext::oneapi::bfloat16, 16> a) { return -a; }

From 76a2ca3995e10ceee2d6a214fdb1815bf722748c Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 9 May 2024 00:17:05 -0700
Subject: [PATCH 58/79] Remove unnessary use of vec_data casts.

---
 sycl/include/sycl/vector_preview.hpp | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 4941400ee829d..d7cd5494a3db6 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -435,7 +435,8 @@ template <typename Type, int NumElements> class vec {
   // Available only when: NumElements == 1
   template <int N = NumElements>
   operator typename std::enable_if_t<N == 1, DataT>() const {
-    return vec_data<DataT>::set(m_Data[0]);
+    // Cast required to convert int8_t to bool.
+    return (DataT)m_Data[0];
   }
 
   __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
@@ -704,7 +705,7 @@ template <typename Type, int NumElements> class vec {
     vec Ret;                                                                   \
     if constexpr (IsBfloat16) {                                                \
       for (size_t I = 0; I < NumElements; ++I) {                               \
-        Ret.setValue(I, vec_data<DataT>::set(Lhs[I] BINOP Rhs[I]));            \
+        Ret[I] = Lhs[I] BINOP Rhs[I];                                          \
       }                                                                        \
     } else {                                                                   \
       vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
@@ -748,8 +749,7 @@ template <typename Type, int NumElements> class vec {
       const vec & Lhs, const vec & Rhs) {                                      \
     vec Ret{};                                                                 \
     for (size_t I = 0; I < NumElements; ++I) {                                 \
-      Ret.setValue(I, vec_data<DataT>::set(vec_data<DataT>::set(               \
-                          Lhs[I]) BINOP vec_data<DataT>::set(Rhs[I])));        \
+      Ret[I] = Lhs[I] BINOP Rhs[I];                                            \
     }                                                                          \
     return Ret;                                                                \
   }                                                                            \
@@ -927,13 +927,13 @@ template <typename Type, int NumElements> class vec {
 #define __SYCL_UOP(UOP, OPASSIGN, COND)                                        \
   template <typename T = DataT>                                                \
   friend typename std::enable_if_t<(COND), vec &> operator UOP(vec & Rhs) {    \
-    Rhs OPASSIGN vec_data<DataT>::set(1);                                      \
+    Rhs OPASSIGN DataT{1};                                                     \
     return Rhs;                                                                \
   }                                                                            \
   template <typename T = DataT>                                                \
   friend typename std::enable_if_t<(COND), vec> operator UOP(vec & Lhs, int) { \
     vec Ret(Lhs);                                                              \
-    Lhs OPASSIGN vec_data<DataT>::set(1);                                      \
+    Lhs OPASSIGN DataT{1};                                                     \
     return Ret;                                                                \
   }
 
@@ -996,8 +996,7 @@ template <typename Type, int NumElements> class vec {
 #else
     vec Ret{};
     for (size_t I = 0; I < NumElements; ++I)
-      Ret.setValue(
-          I, vec_data<DataT>::get(+vec_data<DataT>::get(Lhs.getValue(I))));
+      Ret[I] = +Lhs[I];
     return Ret;
 #endif
   }
@@ -1010,7 +1009,7 @@ template <typename Type, int NumElements> class vec {
     vec Ret{};
     if constexpr (IsBfloat16) {
       for (size_t I = 0; I < NumElements; I++)
-        Ret.m_Data[I] = -Lhs.m_Data[I];
+        Ret[I] = -Lhs[I];
     } else {
 #ifndef __SYCL_DEVICE_ONLY__
       for (size_t I = 0; I < NumElements; ++I)

From 3073a13879c6c5e0d43511cef5ddf20562b2766b Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 9 May 2024 04:43:46 -0700
Subject: [PATCH 59/79] Address reviews

---
 sycl/include/sycl/vector_preview.hpp          | 142 +++++++----------
 .../vector/vector_math_ops.cpp                | 143 ++++++------------
 2 files changed, 95 insertions(+), 190 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index d7cd5494a3db6..7ef2925339b53 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -82,42 +82,6 @@ struct elem {
 };
 
 namespace detail {
-/* Helper functions to get and set values in vec, depdending on the underlying
- * data type. */
-template <typename T> struct vec_helper {
-  using NativeType =
-      typename std::conditional<std::is_same_v<T, bool>, std::int8_t, T>::type;
-  static constexpr NativeType get(T value) { return value; }
-  static constexpr NativeType set(T value) { return value; }
-};
-
-template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
-  using BF16Type = sycl::ext::oneapi::bfloat16;
-  using NativeType = sycl::ext::oneapi::detail::Bfloat16StorageT;
-
-  static NativeType get(NativeType value) { return value; }
-  static NativeType get(BF16Type value) {
-    return sycl::bit_cast<NativeType>(value);
-  }
-
-  static BF16Type set(BF16Type value) { return value; }
-  static BF16Type set(NativeType value) {
-    return sycl::bit_cast<BF16Type>(value);
-  }
-};
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-template <> struct vec_helper<std::byte> {
-  using NativeType = std::uint8_t;
-
-  static NativeType get(std::byte value) { return (NativeType)value; }
-  static NativeType get(NativeType value) { return value; }
-
-  static std::byte set(std::byte value) { return value; }
-  static std::byte set(NativeType value) { return (std::byte)value; }
-};
-#endif
-
 template <typename VecT, typename OperationLeftT, typename OperationRightT,
           template <typename> class OperationCurrentT, int... Indexes>
 class SwizzleOp;
@@ -150,41 +114,35 @@ template <typename TransformedArgType, int Dims, typename KernelType>
 class RoundedRangeKernelWithKH;
 } // namespace detail
 
-template <typename T> using vec_data = detail::vec_helper<T>;
-
-template <typename T>
-using vec_data_t = typename detail::vec_helper<T>::NativeType;
-
-// data_type_multiple_t data type is
-// used to store sycl::vec on host and device.
-template <typename T, int N>
-using data_type_multiple_t = typename std::conditional_t<
-    // bool
-    std::is_same_v<T, bool>, std::array<int8_t, N>, std::array<T, N>>;
-
-// sycl::vec is converted to vector_t_single and vector_t_multiple
-// data types on device for use in SPIRV builtins.
-#ifdef __SYCL_DEVICE_ONLY__
+// OpenCL data type to convert to.
 template <typename T>
-using vector_t_single = typename std::conditional_t<
-    std::is_same_v<T, sycl::half>, sycl::detail::half_impl::StorageT,
-    typename std::conditional_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                                sycl::ext::oneapi::detail::Bfloat16StorageT,
-                                typename std::conditional_t<
+using vec_data_t = typename std::conditional_t<
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-                                    std::is_same_v<T, std::byte>, std::uint8_t,
-                                    typename std::conditional_t<
+      std::is_same_v<T, std::byte>, std::uint8_t,
 #else
-                                    false, T,
-                                    typename std::conditional_t<
-#endif
-                                        true, T, T>>>>;
-
-template <typename T, int N>
-using vector_t_multiple = typename std::conditional_t<
-    std::is_same_v<T, bool>, int8_t __attribute__((ext_vector_type(N))),
-    vector_t_single<T> __attribute__((ext_vector_type(N)))>;
+      false, T,
 #endif
+      typename std::conditional_t<std::is_same_v<T, bool>, std::int8_t,
+      typename std::conditional_t<std::is_same_v<T, sycl::half>, sycl::detail::half_impl::StorageT,
+      typename std::conditional_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+      sycl::ext::oneapi::detail::Bfloat16StorageT, T>>>>;
+
+// Helper functions to convert to and from OpenCL type.
+template <typename T> auto VecConvertToOpenCLType(T value) {
+  if constexpr (std::is_same_v<T, sycl::ext::oneapi::bfloat16>)
+    return sycl::bit_cast<vec_data_t<T>>(value);
+  else
+    return (vec_data_t<T>)value;
+}
+
+template <typename T, typename U> auto VecConvertFromOpenCLType(U value) {
+  if constexpr (std::is_same_v<T, sycl::ext::oneapi::bfloat16>)
+    return sycl::bit_cast<T>(value);
+  else if constexpr (std::is_same_v<T, bool>)
+    return (int8_t)value;
+  else
+    return (T)value;
+}
 
 ///////////////////////// class sycl::vec /////////////////////////
 // Provides a cross-patform vector class template that works efficiently on
@@ -202,12 +160,15 @@ template <typename Type, int NumElements> class vec {
 
   // This represent type of underlying value. There should be only one field
   // in the class, so vec<float, 16> should be equal to float16 in memory.
+  template <typename T, int N>
+  using data_type_multiple_t = typename std::conditional_t<
+    std::is_same_v<T, bool>, std::array<int8_t, N>, std::array<T, N>>;
   using DataType = data_type_multiple_t<DataT, AdjustedNum>;
 
 public:
 #ifdef __SYCL_DEVICE_ONLY__
   // Type used for passing sycl::vec to SPIRV builtins.
-  using vector_t = vector_t_multiple<DataT, NumElements>;
+  using vector_t = vec_data_t<DataT> __attribute__((ext_vector_type(NumElements)));
 #endif // __SYCL_DEVICE_ONLY__
 
 private:
@@ -484,8 +445,8 @@ template <typename Type, int NumElements> class vec {
     static_assert(std::is_integral_v<vec_data_t<convertT>> ||
                       detail::is_floating_point<convertT>::value,
                   "Unsupported convertT");
-    using T = vec_data_t<DataT>;
-    using R = vec_data_t<convertT>;
+    using T = typename std::conditional_t<std::is_same_v<DataT, sycl::half>, DataT, vec_data_t<DataT>>;
+    using R = typename std::conditional_t<std::is_same_v<convertT, sycl::half>, convertT, vec_data_t<convertT>>;
     using OpenCLT = detail::ConvertToOpenCLType_t<T>;
     using OpenCLR = detail::ConvertToOpenCLType_t<R>;
     vec<convertT, NumElements> Result;
@@ -518,6 +479,7 @@ template <typename Type, int NumElements> class vec {
         //   defined, there is no guarantee that integer conversion yields
         //   right results here;
         !std::is_same_v<convertT, bool>;
+
     if constexpr (canUseNativeVectorConvert) {
       Result.m_Data = sycl::bit_cast<decltype(Result.m_Data)>(
           detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
@@ -527,7 +489,7 @@ template <typename Type, int NumElements> class vec {
     {
       // Otherwise, we fallback to per-element conversion:
       for (size_t I = 0; I < NumElements; ++I) {
-        auto val = vec_data<convertT>::set(
+        auto val = VecConvertFromOpenCLType<convertT>(
             detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
                 getValue(I)));
 
@@ -661,7 +623,7 @@ template <typename Type, int NumElements> class vec {
              multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
     for (int I = 0; I < NumElements; I++) {
       *multi_ptr<DataT, Space, DecorateAddress>(
-          Ptr + Offset * NumElements + I) = vec_data<DataT>::set(getValue(I));
+          Ptr + Offset * NumElements + I) = VecConvertFromOpenCLType<DataT>(getValue(I));
     }
   }
   template <int Dimensions, access::mode Mode,
@@ -958,7 +920,7 @@ template <typename Type, int NumElements> class vec {
 #else
     vec Ret{};
     for (size_t I = 0; I < NumElements; ++I) {
-      Ret.setValue(I, vec_data<DataT>::set(~Rhs.getValue(I)));
+      Ret.setValue(I, VecConvertFromOpenCLType<DataT>(~Rhs.getValue(I)));
     }
     return Ret;
 #endif
@@ -969,7 +931,6 @@ template <typename Type, int NumElements> class vec {
   friend typename std::enable_if_t<(!IsByte<T>::value),
                                    vec<detail::rel_t<DataT>, NumElements>>
   operator!(const vec &Rhs) {
-    vec Ret{};
 #ifdef __SYCL_DEVICE_ONLY__
     if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
                   !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
@@ -979,10 +940,12 @@ template <typename Type, int NumElements> class vec {
     } else
 #endif // __SYCL_DEVICE_ONLY__
     {
+      vec<detail::rel_t<DataT>, NumElements> Ret{};
       for (size_t I = 0; I < NumElements; ++I) {
-        Ret.setValue(I, !vec_data<DataT>::get(Rhs[I]));
+        // static_cast will work here as the output of ! operator is either 0 or -1.
+        Ret[I] = static_cast<detail::rel_t<DataT>>(-1*(!VecConvertToOpenCLType<DataT>(Rhs[I])));
       }
-      return Ret.template as<vec<detail::rel_t<DataT>, NumElements>>();
+      return Ret;
     }
   }
 
@@ -1032,20 +995,19 @@ template <typename Type, int NumElements> class vec {
 #ifndef __SYCL_DEVICE_ONLY__
     assert(Index < NumElements && "Index out of range");
 #endif
-    return vec_data<DataT>::get(m_Data[Index]);
+    return VecConvertToOpenCLType<DataT>(m_Data[Index]);
   }
 
   constexpr void setValue(int Index, const DataT &Value) {
 #ifndef __SYCL_DEVICE_ONLY__
     assert(Index < NumElements && "Index out of range");
 #endif
-    m_Data[Index] = vec_data<DataT>::set(Value);
+    m_Data[Index] = VecConvertFromOpenCLType<DataT>(Value);
   }
 
   // fields
   // Alignment is the same as size, to a maximum size of 64.
-  // detail::vector_alignment will return that value.
-  alignas(detail::vector_alignment<DataT, NumElements>::value) DataType m_Data;
+  alignas(std::min((long unsigned)64, sizeof(DataType))) DataType m_Data;
 
   // friends
   template <typename T1, typename T2, typename T3, template <typename> class T4,
@@ -1819,21 +1781,21 @@ class SwizzleOp {
       return m_Vector->getValue(Idxs[Index]);
     }
     auto Op = OperationCurrentT<vec_data_t<CommonDataT>>();
-    return vec_data<CommonDataT>::get(
-        Op(vec_data<CommonDataT>::get(m_LeftOperation.getValue(Index)),
-           vec_data<CommonDataT>::get(m_RightOperation.getValue(Index))));
+    return VecConvertToOpenCLType<CommonDataT>(
+        Op(VecConvertToOpenCLType<CommonDataT>(m_LeftOperation.getValue(Index)),
+           VecConvertToOpenCLType<CommonDataT>(m_RightOperation.getValue(Index))));
   }
 
   template <int IdxNum = getNumElements()>
   DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
     if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
       std::array<int, getNumElements()> Idxs{Indexes...};
-      return vec_data<DataT>::set(m_Vector->getValue(Idxs[Index]));
+      return VecConvertFromOpenCLType<DataT>(m_Vector->getValue(Idxs[Index]));
     }
     auto Op = OperationCurrentT<vec_data_t<DataT>>();
-    return vec_data<DataT>::set(
-        Op(vec_data<DataT>::get(m_LeftOperation.getValue(Index)),
-           vec_data<DataT>::get(m_RightOperation.getValue(Index))));
+    return VecConvertFromOpenCLType<DataT>(
+        Op(VecConvertToOpenCLType<DataT>(m_LeftOperation.getValue(Index)),
+           VecConvertToOpenCLType<DataT>(m_RightOperation.getValue(Index))));
   }
 
   template <template <typename> class Operation, typename RhsOperation>
@@ -1841,9 +1803,9 @@ class SwizzleOp {
     Operation<vec_data_t<DataT>> Op;
     std::array<int, getNumElements()> Idxs{Indexes...};
     for (size_t I = 0; I < Idxs.size(); ++I) {
-      DataT Res = vec_data<DataT>::set(
-          Op(vec_data<DataT>::get(m_Vector->getValue(Idxs[I])),
-             vec_data<DataT>::get(Rhs.getValue(I))));
+      DataT Res = VecConvertFromOpenCLType<DataT>(
+          Op(VecConvertToOpenCLType<DataT>(m_Vector->getValue(Idxs[I])),
+             VecConvertToOpenCLType<DataT>(Rhs.getValue(I))));
       m_Vector->setValue(Idxs[I], Res);
     }
   }
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 164a1a24ea8db..db6edd0583a2f 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -226,12 +226,11 @@ SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP3_I]])
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
 // CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
@@ -240,19 +239,19 @@ SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI3EEEE4TYPEERKS8_SC__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8:[0-9]+]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL3_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9:[0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9]]
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9:[0-9]+]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL3_I]]) #[[ATTR9]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR10:[0-9]+]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR10]], {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR10]], {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL4_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR9]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[CALL4_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP47:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP48:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_.exit:
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
@@ -394,16 +393,16 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTINS0_3EXT6ONEAPI8BFLOAT16EEENS0_3VECISLI4EEERKNS5_IS4_LI4EEES9__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR9]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR10]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR10]], {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
 // CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP69:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP71:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_.exit:
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
@@ -450,8 +449,8 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
 // CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I]], zeroinitializer
 // CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i32>
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I3_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-ARR-STORAGE-NEXT:    store <4 x i32> [[EXTRACTVEC_I3_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I2_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-ARR-STORAGE-NEXT:    store <4 x i32> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
@@ -524,39 +523,22 @@ SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
 // CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.6", align 4
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[RET_I]])
-// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr [[RET_I]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIALI4EEEE4TYPEERKNS4_IBLI4EEE_EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[I_0_I]]
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[FROMBOOL_I:%.*]] = xor i8 [[TMP0]], 1
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[FROMBOOL_I]], ptr [[ARRAYIDX_I_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = add nsw i8 [[TMP0]], -1
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I11_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[SEXT_I]], ptr addrspace(4) [[ARRAYIDX_I11_I]], align 1, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP89:![0-9]+]]
-// CHECK-ARR-STORAGE:       for.end.i:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 4
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIALI4EEEE4TYPEERKNS4_IBLI4EEE_EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP94:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP91:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIaLi4EEEE4typeERKNS4_IbLi4EEE.exit:
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[RET_I]])
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
@@ -590,40 +572,23 @@ SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
 // CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.35", align 4
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[RET_I]])
-// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr [[RET_I]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_6DETAIL9HALF_IMPL4HALFEEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI2EEEE4TYPEERKNS7_IS4_LI2EEE_EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::detail::half_impl::half", ptr [[A]], i64 [[I_0_I]]
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq half [[TMP0]], 0xH0000
-// CHECK-ARR-STORAGE-NEXT:    [[CONV_I10_I:%.*]] = uitofp i1 [[TOBOOL_I]] to half
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [2 x %"class.sycl::_V1::detail::half_impl::half"], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store half [[CONV_I10_I]], ptr [[ARRAYIDX_I_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I11_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I11_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP101:![0-9]+]]
-// CHECK-ARR-STORAGE:       for.end.i:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 4
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTINS0_6DETAIL9HALF_IMPL4HALFEEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI2EEEE4TYPEERKNS7_IS4_LI2EEE_EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP94]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP98:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi2EEEE4typeERKNS7_IS4_Li2EEE.exit:
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[RET_I]])
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
@@ -703,48 +668,25 @@ SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
 // CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    [[RET_I:%.*]] = alloca %"class.sycl::_V1::vec.10", align 8
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_I:%.*]] = alloca float, align 4
 // CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 8, ptr nonnull [[RET_I]])
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP1_I]])
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr [[RET_I]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[FOR_END_I:%.*]]
+// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9]], {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr addrspace(4) [[CALL_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_NOT_I:%.*]] = icmp eq i16 [[TMP0]], 0
-// CHECK-ARR-STORAGE-NEXT:    [[CONV4_I:%.*]] = uitofp i1 [[TOBOOL_NOT_I]] to float
-// CHECK-ARR-STORAGE-NEXT:    store float [[CONV4_I]], ptr [[REF_TMP1_I]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP1_ASCAST_I]]) #[[ATTR9]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr [[RET_I]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I_I]], ptr [[ARRAYIDX_I_I_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_NOT_I]] to i16
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP114:![0-9]+]]
-// CHECK-ARR-STORAGE:       for.end.i:
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I_I:%.*]] = phi i64 [ 0, [[FOR_END_I]] ], [ [[INC_I_I_I:%.*]], [[FOR_BODY_I_I_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I_I:%.*]] = icmp ult i64 [[I_0_I_I_I]], 8
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I_I]], label [[FOR_BODY_I_I_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds i8, ptr [[RET_I]], i64 [[I_0_I_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX1_I_I_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[TMP1]], ptr addrspace(4) [[ARRAYIDX1_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I_I_I]] = add nuw nsw i64 [[I_0_I_I_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I_I]], !llvm.loop [[LOOP94]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP107:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 8, ptr nonnull [[RET_I]])
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP1_I]])
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
@@ -778,7 +720,7 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP157:![0-9]+]]
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) {{.*}}{
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I:%.*]] = alloca float, align 4
 // CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
@@ -792,15 +734,16 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 16
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI16EEEE4TYPEERKS8__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I:%.*]] = getelementptr inbounds [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[A_ASCAST]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I_I]]) #[[ATTR9]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR10]]
 // CHECK-ARR-STORAGE-NEXT:    [[FNEG_I:%.*]] = fneg float [[CALL_I_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I8_I:%.*]] = getelementptr inbounds [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I9_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR9]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I9_I]], ptr addrspace(4) [[ARRAYIDX_I_I8_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL3_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR9]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I8_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR10]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I8_I]], ptr addrspace(4) [[CALL3_I]], align 2, {{.*}}
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP125:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP114:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-ARR-STORAGE-NEXT:    ret void

From 1ec252d4c9ae74ed09cab233bb4fd63a5c62d539 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 9 May 2024 08:14:11 -0700
Subject: [PATCH 60/79] Fix test failure for half swizzles.

---
 sycl/include/sycl/vector_preview.hpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 7ef2925339b53..ac0d5ccaeeb84 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -103,8 +103,18 @@ using rel_t = typename std::conditional_t<
 template <typename T> class GetOp {
 public:
   using DataT = T;
-  DataT getValue(size_t) const { return (DataT)0; }
-  DataT operator()(DataT, DataT) { return (DataT)0; }
+  DataT getValue(size_t) const {
+    if constexpr (std::is_same_v<DataT, sycl::detail::host_half_impl::half>)
+      return DataT{0.0f};
+    else
+      return (DataT)0;
+  }
+  DataT operator()(DataT, DataT) {
+    if constexpr (std::is_same_v<DataT, sycl::detail::host_half_impl::half>)
+      return DataT{0.0f};
+    else
+      return (DataT)0;
+  }
 };
 
 // Forward declarations

From f1b749610eca0e9f8c8505c25756f99477a54248 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 9 May 2024 09:22:15 -0700
Subject: [PATCH 61/79] Fix build on Windows

---
 sycl/include/sycl/vector_preview.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index ac0d5ccaeeb84..1c8d9ee40d205 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -41,6 +41,7 @@
 
 #include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
 
+#include <algorithm>   // for std::min
 #include <array>       // for array
 #include <cassert>     // for assert
 #include <cstddef>     // for size_t, NULL, byte

From 2e85695767c4a7640daeca2d0f84d033eb362a11 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Mon, 13 May 2024 09:41:18 -0700
Subject: [PATCH 62/79] Address reviews

---
 .../sycl/detail/generic_type_traits.hpp       |  22 ++++
 sycl/include/sycl/vector_preview.hpp          | 108 ++++++++++--------
 2 files changed, 83 insertions(+), 47 deletions(-)

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 287fb6de06b79..1426f0553bb6e 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -450,6 +450,28 @@ template <typename T> static constexpr T max_v() {
 template <typename T> static constexpr T min_v() {
   return (std::numeric_limits<T>::min)();
 }
+
+// Check if a given type is derived from std::array or Clang's ext_vector_type.
+template<typename T>
+struct is_std_array : std::false_type {};
+
+template<typename T, std::size_t N>
+struct is_std_array<std::array<T, N>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_std_array_v = is_std_array<T>::value;
+
+#ifdef __SYCL_DEVICE_ONLY__
+template<typename T>
+struct is_ext_vector_type : std::false_type {};
+
+template<typename T, unsigned N>
+struct is_ext_vector_type<T __attribute__((ext_vector_type(N)))> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_ext_vector_type_v = is_ext_vector_type<T>::value;
+#endif // __SYCL_DEVICE_ONLY__
+
 } // namespace detail
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 1c8d9ee40d205..518a5bef189a4 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -127,7 +127,7 @@ class RoundedRangeKernelWithKH;
 
 // OpenCL data type to convert to.
 template <typename T>
-using vec_data_t = typename std::conditional_t<
+using element_type_for_vector_t = typename std::conditional_t<
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
       std::is_same_v<T, std::byte>, std::uint8_t,
 #else
@@ -139,20 +139,36 @@ using vec_data_t = typename std::conditional_t<
       sycl::ext::oneapi::detail::Bfloat16StorageT, T>>>>;
 
 // Helper functions to convert to and from OpenCL type.
-template <typename T> auto VecConvertToOpenCLType(T value) {
-  if constexpr (std::is_same_v<T, sycl::ext::oneapi::bfloat16>)
-    return sycl::bit_cast<vec_data_t<T>>(value);
+template <typename T, typename U> constexpr auto VecConvertFromOpenCLType(U value) {
+
+#ifdef __SYCL_DEVICE_ONLY__
+  // Convert from std::array to ext_vector_type.
+  // Check if T is std::array and U is ext_vector_type. If so, you sycl::bit_cast<T>.
+  if constexpr (detail::is_std_array_v<T> && detail::is_ext_vector_type_v<U>)
+    return sycl::bit_cast<T>(value);
   else
-    return (vec_data_t<T>)value;
+#endif
+    if constexpr (std::is_same_v<T, sycl::ext::oneapi::bfloat16>)
+      return sycl::bit_cast<T>(value);
+    else if constexpr (std::is_same_v<T, bool>)
+      return static_cast<int8_t>(value);
+    else
+      return static_cast<T>(value);
 }
 
-template <typename T, typename U> auto VecConvertFromOpenCLType(U value) {
+template <typename T, typename U = void> constexpr auto VecConvertToOpenCLType(T value) {
+
+#ifdef __SYCL_DEVICE_ONLY__
+  // Convert from std::array to ext_vector_type.
+  // Check if T is std::array and U is ext_vector_type. If so, you sycl::bit_cast<U>.
+  if constexpr (detail::is_std_array_v<T> && detail::is_ext_vector_type_v<U>)
+    return sycl::bit_cast<U>(value);
+  else
+#endif
   if constexpr (std::is_same_v<T, sycl::ext::oneapi::bfloat16>)
-    return sycl::bit_cast<T>(value);
-  else if constexpr (std::is_same_v<T, bool>)
-    return (int8_t)value;
+    return sycl::bit_cast<element_type_for_vector_t<T>>(value);
   else
-    return (T)value;
+    return static_cast<element_type_for_vector_t<T>>(value);
 }
 
 ///////////////////////// class sycl::vec /////////////////////////
@@ -171,15 +187,13 @@ template <typename Type, int NumElements> class vec {
 
   // This represent type of underlying value. There should be only one field
   // in the class, so vec<float, 16> should be equal to float16 in memory.
-  template <typename T, int N>
-  using data_type_multiple_t = typename std::conditional_t<
-    std::is_same_v<T, bool>, std::array<int8_t, N>, std::array<T, N>>;
-  using DataType = data_type_multiple_t<DataT, AdjustedNum>;
+  using DataType = typename std::conditional_t<
+    std::is_same_v<DataT, bool>, std::array<int8_t, AdjustedNum>, std::array<DataT, AdjustedNum>>;
 
 public:
 #ifdef __SYCL_DEVICE_ONLY__
   // Type used for passing sycl::vec to SPIRV builtins.
-  using vector_t = vec_data_t<DataT> __attribute__((ext_vector_type(NumElements)));
+  using vector_t = element_type_for_vector_t<DataT> __attribute__((ext_vector_type(NumElements)));
 #endif // __SYCL_DEVICE_ONLY__
 
 private:
@@ -367,7 +381,7 @@ template <typename Type, int NumElements> class vec {
 
   template <typename Ty = DataT>
   typename std::enable_if_t<
-      std::is_fundamental_v<vec_data_t<Ty>> ||
+      std::is_fundamental_v<element_type_for_vector_t<Ty>> ||
           detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
   operator=(const DataT &Rhs) {
@@ -380,7 +394,7 @@ template <typename Type, int NumElements> class vec {
   // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
   template <typename Ty = DataT>
   typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
-                                std::is_convertible_v<vec_data_t<Ty>, rel_t>,
+                                std::is_convertible_v<element_type_for_vector_t<Ty>, rel_t>,
                             vec &>
   operator=(const vec<rel_t, NumElements> &Rhs) {
     *this = Rhs.template as<vec>();
@@ -393,7 +407,7 @@ template <typename Type, int NumElements> class vec {
                 typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
                                           !std::is_same_v<vector_t_, DataT>>>
   constexpr vec(vector_t_ openclVector) {
-    m_Data = __builtin_bit_cast(DataType, openclVector);
+    m_Data = VecConvertFromOpenCLType<DataType>(openclVector);
   }
 
   /* @SYCL2020
@@ -401,14 +415,14 @@ template <typename Type, int NumElements> class vec {
    * Converts this SYCL vec instance to the underlying backend-native vector
    * type defined by vector_t.
    */
-  operator vector_t() const { return sycl::bit_cast<vector_t>(m_Data); }
+  operator vector_t() const { return VecConvertToOpenCLType<DataType, vector_t>(m_Data); }
 #endif // __SYCL_DEVICE_ONLY__
 
   // Available only when: NumElements == 1
   template <int N = NumElements>
   operator typename std::enable_if_t<N == 1, DataT>() const {
     // Cast required to convert int8_t to bool.
-    return (DataT)m_Data[0];
+    return static_cast<DataT>(m_Data[0]);
   }
 
   __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
@@ -424,12 +438,12 @@ template <typename Type, int NumElements> class vec {
   template <typename convertT,
             rounding_mode roundingMode = rounding_mode::automatic>
   std::enable_if_t<
-      std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> ||
-          std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
-                         detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      std::is_same_v<element_type_for_vector_t<DataT>, element_type_for_vector_t<convertT>> ||
+          std::is_same_v<detail::ConvertToOpenCLType_t<element_type_for_vector_t<DataT>>,
+                         detail::ConvertToOpenCLType_t<element_type_for_vector_t<convertT>>>,
       vec<convertT, NumElements>>
   convert() const {
-    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+    static_assert(std::is_integral_v<element_type_for_vector_t<convertT>> ||
                       detail::is_floating_point<convertT>::value,
                   "Unsupported convertT");
     if constexpr (!std::is_same_v<DataT, convertT>) {
@@ -448,16 +462,16 @@ template <typename Type, int NumElements> class vec {
   template <typename convertT,
             rounding_mode roundingMode = rounding_mode::automatic>
   std::enable_if_t<
-      !std::is_same_v<vec_data_t<DataT>, vec_data_t<convertT>> &&
-          !std::is_same_v<detail::ConvertToOpenCLType_t<vec_data_t<DataT>>,
-                          detail::ConvertToOpenCLType_t<vec_data_t<convertT>>>,
+      !std::is_same_v<element_type_for_vector_t<DataT>, element_type_for_vector_t<convertT>> &&
+          !std::is_same_v<detail::ConvertToOpenCLType_t<element_type_for_vector_t<DataT>>,
+                          detail::ConvertToOpenCLType_t<element_type_for_vector_t<convertT>>>,
       vec<convertT, NumElements>>
   convert() const {
-    static_assert(std::is_integral_v<vec_data_t<convertT>> ||
+    static_assert(std::is_integral_v<element_type_for_vector_t<convertT>> ||
                       detail::is_floating_point<convertT>::value,
                   "Unsupported convertT");
-    using T = typename std::conditional_t<std::is_same_v<DataT, sycl::half>, DataT, vec_data_t<DataT>>;
-    using R = typename std::conditional_t<std::is_same_v<convertT, sycl::half>, convertT, vec_data_t<convertT>>;
+    using T = typename std::conditional_t<std::is_same_v<DataT, sycl::half>, DataT, element_type_for_vector_t<DataT>>;
+    using R = typename std::conditional_t<std::is_same_v<convertT, sycl::half>, convertT, element_type_for_vector_t<convertT>>;
     using OpenCLT = detail::ConvertToOpenCLType_t<T>;
     using OpenCLR = detail::ConvertToOpenCLType_t<R>;
     vec<convertT, NumElements> Result;
@@ -466,7 +480,7 @@ template <typename Type, int NumElements> class vec {
     using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
     using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
 
-    auto NativeVector = sycl::bit_cast<vector_t>(m_Data);
+    auto NativeVector = VecConvertToOpenCLType<DataType, vector_t>(m_Data);
     using ConvertTVecType = typename vec<convertT, NumElements>::vector_t;
 
     // Whole vector conversion can only be done, if:
@@ -492,7 +506,7 @@ template <typename Type, int NumElements> class vec {
         !std::is_same_v<convertT, bool>;
 
     if constexpr (canUseNativeVectorConvert) {
-      Result.m_Data = sycl::bit_cast<decltype(Result.m_Data)>(
+      Result.m_Data = VecConvertFromOpenCLType<decltype(Result.m_Data)>(
           detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
                               OpenCLVecR>(NativeVector));
     } else
@@ -681,8 +695,8 @@ template <typename Type, int NumElements> class vec {
         Ret[I] = Lhs[I] BINOP Rhs[I];                                          \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
-      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
+      vector_t ExtVecLhs = VecConvertToOpenCLType<DataType, vector_t>(Lhs.m_Data);               \
+      vector_t ExtVecRhs = VecConvertToOpenCLType<DataType, vector_t>(Rhs.m_Data);               \
       Ret = vec<DataT, NumElements>(                                           \
           (typename vec<DataT, NumElements>::vector_t)(                        \
               ExtVecLhs BINOP ExtVecRhs));                                     \
@@ -831,8 +845,8 @@ template <typename Type, int NumElements> class vec {
         Ret[I] = static_cast<rel_t>(-(Lhs[I] RELLOGOP Rhs[I]));                \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs.m_Data);               \
-      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs.m_Data);               \
+      vector_t ExtVecLhs = VecConvertToOpenCLType<DataType, vector_t>(Lhs.m_Data);               \
+      vector_t ExtVecRhs = VecConvertToOpenCLType<DataType, vector_t>(Rhs.m_Data);               \
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
               ExtVecLhs RELLOGOP ExtVecRhs));                                  \
@@ -922,7 +936,7 @@ template <typename Type, int NumElements> class vec {
   friend typename std::enable_if_t<!detail::is_vgenfloat_v<T>, vec>
   operator~(const vec &Rhs) {
 #ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
+    auto extVec = VecConvertToOpenCLType<DataType, vector_t>(Rhs.m_Data);
     vec Ret{~extVec};
     if constexpr (std::is_same_v<Type, bool>) {
       Ret.ConvertToDataT();
@@ -946,7 +960,7 @@ template <typename Type, int NumElements> class vec {
     if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
                   !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
                   !std::is_same_v<DataT, bool>) {
-      auto extVec = sycl::bit_cast<vector_t>(Rhs.m_Data);
+      auto extVec = VecConvertToOpenCLType<DataType, vector_t>(Rhs.m_Data);
       return vec<detail::rel_t<DataT>, NumElements>{!extVec};
     } else
 #endif // __SYCL_DEVICE_ONLY__
@@ -965,7 +979,7 @@ template <typename Type, int NumElements> class vec {
   friend typename std::enable_if_t<(!IsByte<T>::value), vec>
   operator+(const vec &Lhs) {
 #ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
+    auto extVec = VecConvertToOpenCLType<DataType, vector_t>(Lhs.m_Data);
     return vec{+extVec};
 #else
     vec Ret{};
@@ -989,7 +1003,7 @@ template <typename Type, int NumElements> class vec {
       for (size_t I = 0; I < NumElements; ++I)
         Ret[I] = -Lhs[I];
 #else
-      auto extVec = sycl::bit_cast<vector_t>(Lhs.m_Data);
+      auto extVec = VecConvertToOpenCLType<DataType, vector_t>(Lhs.m_Data);
       Ret = vec{-extVec};
       if constexpr (std::is_same_v<Type, bool>) {
         Ret.ConvertToDataT();
@@ -1018,7 +1032,7 @@ template <typename Type, int NumElements> class vec {
 
   // fields
   // Alignment is the same as size, to a maximum size of 64.
-  alignas(std::min((long unsigned)64, sizeof(DataType))) DataType m_Data;
+  alignas(std::min((size_t)64, sizeof(DataType))) DataType m_Data;
 
   // friends
   template <typename T1, typename T2, typename T3, template <typename> class T4,
@@ -1186,13 +1200,13 @@ class SwizzleOp {
   template <typename T>
   using EnableIfScalarType = typename std::enable_if_t<
       std::is_convertible_v<DataT, T> &&
-      (std::is_fundamental_v<vec_data_t<T>> ||
+      (std::is_fundamental_v<element_type_for_vector_t<T>> ||
        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
 
   template <typename T>
   using EnableIfNoScalarType = typename std::enable_if_t<
       !std::is_convertible_v<DataT, T> ||
-      !(std::is_fundamental_v<vec_data_t<T>> ||
+      !(std::is_fundamental_v<element_type_for_vector_t<T>> ||
         detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
 
   template <int... Indices>
@@ -1312,7 +1326,7 @@ class SwizzleOp {
 
   template <typename T = DataT>
   friend typename std::enable_if_t<
-      std::is_same_v<T, DataT> && std::is_integral_v<vec_data_t<T>>, vec_t>
+      std::is_same_v<T, DataT> && std::is_integral_v<element_type_for_vector_t<T>>, vec_t>
   operator~(const SwizzleOp &Rhs) {
     vec_t Tmp = Rhs;
     return ~Tmp;
@@ -1791,7 +1805,7 @@ class SwizzleOp {
       std::array<int, getNumElements()> Idxs{Indexes...};
       return m_Vector->getValue(Idxs[Index]);
     }
-    auto Op = OperationCurrentT<vec_data_t<CommonDataT>>();
+    auto Op = OperationCurrentT<element_type_for_vector_t<CommonDataT>>();
     return VecConvertToOpenCLType<CommonDataT>(
         Op(VecConvertToOpenCLType<CommonDataT>(m_LeftOperation.getValue(Index)),
            VecConvertToOpenCLType<CommonDataT>(m_RightOperation.getValue(Index))));
@@ -1803,7 +1817,7 @@ class SwizzleOp {
       std::array<int, getNumElements()> Idxs{Indexes...};
       return VecConvertFromOpenCLType<DataT>(m_Vector->getValue(Idxs[Index]));
     }
-    auto Op = OperationCurrentT<vec_data_t<DataT>>();
+    auto Op = OperationCurrentT<element_type_for_vector_t<DataT>>();
     return VecConvertFromOpenCLType<DataT>(
         Op(VecConvertToOpenCLType<DataT>(m_LeftOperation.getValue(Index)),
            VecConvertToOpenCLType<DataT>(m_RightOperation.getValue(Index))));
@@ -1811,7 +1825,7 @@ class SwizzleOp {
 
   template <template <typename> class Operation, typename RhsOperation>
   void operatorHelper(const RhsOperation &Rhs) {
-    Operation<vec_data_t<DataT>> Op;
+    Operation<element_type_for_vector_t<DataT>> Op;
     std::array<int, getNumElements()> Idxs{Indexes...};
     for (size_t I = 0; I < Idxs.size(); ++I) {
       DataT Res = VecConvertFromOpenCLType<DataT>(

From 66c30bcd726b3cb416426bf46a76f030903b438d Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 14 May 2024 12:42:52 -0700
Subject: [PATCH 63/79] Address reviews

---
 .../sycl/detail/generic_type_traits.hpp       |  21 --
 sycl/include/sycl/vector_preview.hpp          | 353 ++++++++----------
 2 files changed, 148 insertions(+), 226 deletions(-)

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 1426f0553bb6e..c9699e34cb654 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -451,27 +451,6 @@ template <typename T> static constexpr T min_v() {
   return (std::numeric_limits<T>::min)();
 }
 
-// Check if a given type is derived from std::array or Clang's ext_vector_type.
-template<typename T>
-struct is_std_array : std::false_type {};
-
-template<typename T, std::size_t N>
-struct is_std_array<std::array<T, N>> : std::true_type {};
-
-template <typename T>
-inline constexpr bool is_std_array_v = is_std_array<T>::value;
-
-#ifdef __SYCL_DEVICE_ONLY__
-template<typename T>
-struct is_ext_vector_type : std::false_type {};
-
-template<typename T, unsigned N>
-struct is_ext_vector_type<T __attribute__((ext_vector_type(N)))> : std::true_type {};
-
-template <typename T>
-inline constexpr bool is_ext_vector_type_v = is_ext_vector_type<T>::value;
-#endif // __SYCL_DEVICE_ONLY__
-
 } // namespace detail
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 518a5bef189a4..b082d88d43c8b 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -123,7 +123,15 @@ template <typename TransformedArgType, int Dims, typename KernelType>
 class RoundedRangeKernel;
 template <typename TransformedArgType, int Dims, typename KernelType>
 class RoundedRangeKernelWithKH;
-} // namespace detail
+
+template <typename T>
+using GetEquivalentFundamentalType = typename std::conditional_t<std::is_same_v<T, bool>, int8_t,
+                                      typename std::conditional_t<
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+                                          std::is_same_v<T, std::byte>, uint8_t, T>>;
+#else
+                                          false, T, T>>;
+#endif
 
 // OpenCL data type to convert to.
 template <typename T>
@@ -137,44 +145,12 @@ using element_type_for_vector_t = typename std::conditional_t<
       typename std::conditional_t<std::is_same_v<T, sycl::half>, sycl::detail::half_impl::StorageT,
       typename std::conditional_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
       sycl::ext::oneapi::detail::Bfloat16StorageT, T>>>>;
-
-// Helper functions to convert to and from OpenCL type.
-template <typename T, typename U> constexpr auto VecConvertFromOpenCLType(U value) {
-
-#ifdef __SYCL_DEVICE_ONLY__
-  // Convert from std::array to ext_vector_type.
-  // Check if T is std::array and U is ext_vector_type. If so, you sycl::bit_cast<T>.
-  if constexpr (detail::is_std_array_v<T> && detail::is_ext_vector_type_v<U>)
-    return sycl::bit_cast<T>(value);
-  else
-#endif
-    if constexpr (std::is_same_v<T, sycl::ext::oneapi::bfloat16>)
-      return sycl::bit_cast<T>(value);
-    else if constexpr (std::is_same_v<T, bool>)
-      return static_cast<int8_t>(value);
-    else
-      return static_cast<T>(value);
-}
-
-template <typename T, typename U = void> constexpr auto VecConvertToOpenCLType(T value) {
-
-#ifdef __SYCL_DEVICE_ONLY__
-  // Convert from std::array to ext_vector_type.
-  // Check if T is std::array and U is ext_vector_type. If so, you sycl::bit_cast<U>.
-  if constexpr (detail::is_std_array_v<T> && detail::is_ext_vector_type_v<U>)
-    return sycl::bit_cast<U>(value);
-  else
-#endif
-  if constexpr (std::is_same_v<T, sycl::ext::oneapi::bfloat16>)
-    return sycl::bit_cast<element_type_for_vector_t<T>>(value);
-  else
-    return static_cast<element_type_for_vector_t<T>>(value);
-}
+} // namespace detail
 
 ///////////////////////// class sycl::vec /////////////////////////
 // Provides a cross-patform vector class template that works efficiently on
 // SYCL devices as well as in host C++ code.
-template <typename Type, int NumElements> class vec {
+template <typename DataT, int NumElements> class vec {
 
   static_assert(NumElements == 1 || NumElements == 2 || NumElements == 3 ||
                     NumElements == 4 || NumElements == 8 || NumElements == 16,
@@ -182,7 +158,6 @@ template <typename Type, int NumElements> class vec {
                 "or 16 are supported");
   static_assert(sizeof(bool) == sizeof(int8_t), "bool size is not 1 byte");
 
-  using DataT = Type;
   static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
 
   // This represent type of underlying value. There should be only one field
@@ -193,7 +168,7 @@ template <typename Type, int NumElements> class vec {
 public:
 #ifdef __SYCL_DEVICE_ONLY__
   // Type used for passing sycl::vec to SPIRV builtins.
-  using vector_t = element_type_for_vector_t<DataT> __attribute__((ext_vector_type(NumElements)));
+  using vector_t = detail::element_type_for_vector_t<DataT> __attribute__((ext_vector_type(NumElements)));
 #endif // __SYCL_DEVICE_ONLY__
 
 private:
@@ -349,11 +324,6 @@ template <typename Type, int NumElements> class vec {
   using EnableIfSuitableNumElements =
       typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
 
-  template <size_t... Is>
-  constexpr vec(const std::array<DataT, NumElements> &Arr,
-                std::index_sequence<Is...>)
-      : m_Data{([&](DataT v) constexpr { return v; })(Arr[Is])...} {}
-
 public:
   using element_type = DataT;
   using value_type = DataT;
@@ -364,6 +334,11 @@ template <typename Type, int NumElements> class vec {
   constexpr vec(const vec &Rhs) = default;
   constexpr vec(vec &&Rhs) = default;
 
+  template <size_t... Is>
+  constexpr vec(const std::array<DataT, NumElements> &Arr,
+                std::index_sequence<Is...>)
+      : m_Data{([&](DataT v) constexpr { return v; })(Arr[Is])...} {}
+
   explicit constexpr vec(const DataT &arg)
       : vec{detail::RepeatValue<NumElements>(arg),
             std::make_index_sequence<NumElements>()} {}
@@ -379,12 +354,7 @@ template <typename Type, int NumElements> class vec {
   /****************** Assignment Operators **************/
   constexpr vec &operator=(const vec &Rhs) = default;
 
-  template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<element_type_for_vector_t<Ty>> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
-  operator=(const DataT &Rhs) {
+  vec& operator=(const DataT &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
       setValue(i, Rhs);
     }
@@ -394,7 +364,7 @@ template <typename Type, int NumElements> class vec {
   // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
   template <typename Ty = DataT>
   typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
-                                std::is_convertible_v<element_type_for_vector_t<Ty>, rel_t>,
+                                std::is_convertible_v<detail::GetEquivalentFundamentalType<Ty>, rel_t>,
                             vec &>
   operator=(const vec<rel_t, NumElements> &Rhs) {
     *this = Rhs.template as<vec>();
@@ -404,10 +374,9 @@ template <typename Type, int NumElements> class vec {
 #ifdef __SYCL_DEVICE_ONLY__
   template <typename vector_t_ = vector_t,
             typename =
-                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t> &&
-                                          !std::is_same_v<vector_t_, DataT>>>
+                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t>>>
   constexpr vec(vector_t_ openclVector) {
-    m_Data = VecConvertFromOpenCLType<DataType>(openclVector);
+    m_Data = sycl::bit_cast<DataType>(openclVector);
   }
 
   /* @SYCL2020
@@ -415,7 +384,7 @@ template <typename Type, int NumElements> class vec {
    * Converts this SYCL vec instance to the underlying backend-native vector
    * type defined by vector_t.
    */
-  operator vector_t() const { return VecConvertToOpenCLType<DataType, vector_t>(m_Data); }
+  operator vector_t() const { return sycl::bit_cast<vector_t>(m_Data); }
 #endif // __SYCL_DEVICE_ONLY__
 
   // Available only when: NumElements == 1
@@ -437,88 +406,72 @@ template <typename Type, int NumElements> class vec {
   // we need this version of convert which is mostly no-op.
   template <typename convertT,
             rounding_mode roundingMode = rounding_mode::automatic>
-  std::enable_if_t<
-      std::is_same_v<element_type_for_vector_t<DataT>, element_type_for_vector_t<convertT>> ||
-          std::is_same_v<detail::ConvertToOpenCLType_t<element_type_for_vector_t<DataT>>,
-                         detail::ConvertToOpenCLType_t<element_type_for_vector_t<convertT>>>,
-      vec<convertT, NumElements>>
-  convert() const {
-    static_assert(std::is_integral_v<element_type_for_vector_t<convertT>> ||
-                      detail::is_floating_point<convertT>::value,
-                  "Unsupported convertT");
-    if constexpr (!std::is_same_v<DataT, convertT>) {
-      // Dummy conversion for cases like vec<signed char> -> vec<char>
-      vec<convertT, NumElements> Result;
-      for (size_t I = 0; I < NumElements; ++I)
-        Result.setValue(I, static_cast<convertT>(getValue(I)));
+  vec<convertT, NumElements> convert() const {
 
-      return Result;
-    } else {
-      // No conversion necessary
-      return *this;
-    }
-  }
-
-  template <typename convertT,
-            rounding_mode roundingMode = rounding_mode::automatic>
-  std::enable_if_t<
-      !std::is_same_v<element_type_for_vector_t<DataT>, element_type_for_vector_t<convertT>> &&
-          !std::is_same_v<detail::ConvertToOpenCLType_t<element_type_for_vector_t<DataT>>,
-                          detail::ConvertToOpenCLType_t<element_type_for_vector_t<convertT>>>,
-      vec<convertT, NumElements>>
-  convert() const {
-    static_assert(std::is_integral_v<element_type_for_vector_t<convertT>> ||
-                      detail::is_floating_point<convertT>::value,
+    using T = detail::GetEquivalentFundamentalType<DataT>;
+    using R = detail::GetEquivalentFundamentalType<convertT>;
+    static_assert(std::is_integral_v<R> ||
+                  detail::is_floating_point<R>::value,
                   "Unsupported convertT");
-    using T = typename std::conditional_t<std::is_same_v<DataT, sycl::half>, DataT, element_type_for_vector_t<DataT>>;
-    using R = typename std::conditional_t<std::is_same_v<convertT, sycl::half>, convertT, element_type_for_vector_t<convertT>>;
+
     using OpenCLT = detail::ConvertToOpenCLType_t<T>;
     using OpenCLR = detail::ConvertToOpenCLType_t<R>;
     vec<convertT, NumElements> Result;
 
+    // For conversion between bool -> signed char and byte -> uint8_t.
+    if constexpr (!std::is_same_v<DataT, convertT> && (std::is_same_v<OpenCLT, OpenCLR> || std::is_same_v<T, R>)) {
+      for (size_t I = 0; I < NumElements; ++I)
+        Result.setValue(I, static_cast<convertT>(getValue(I)));
+      return Result;
+    } else if constexpr (std::is_same_v<DataT, convertT>) {
+      return *this;
+    } else {
+
 #ifdef __SYCL_DEVICE_ONLY__
-    using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
-    using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
+      using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
+      using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
 
-    auto NativeVector = VecConvertToOpenCLType<DataType, vector_t>(m_Data);
-    using ConvertTVecType = typename vec<convertT, NumElements>::vector_t;
+      auto NativeVector = static_cast<vector_t>(*this);
+      using ConvertTVecType = typename vec<convertT, NumElements>::vector_t;
 
-    // Whole vector conversion can only be done, if:
-    constexpr bool canUseNativeVectorConvert =
+      // Whole vector conversion can only be done, if:
+      constexpr bool canUseNativeVectorConvert =
 #ifdef __NVPTX__
-        // - we are not on CUDA, see intel/llvm#11840
-        false &&
+          // - we are not on CUDA, see intel/llvm#11840
+          false &&
 #endif
-        NumElements > 1 &&
-        // - vec storage has an equivalent OpenCL native vector it is implicitly
-        //   convertible to. There are some corner cases where it is not the
-        //   case with char, long and long long types.
-        std::is_convertible_v<vector_t, OpenCLVecT> &&
-        std::is_convertible_v<ConvertTVecType, OpenCLVecR> &&
-        // - it is not a signed to unsigned (or vice versa) conversion
-        //   see comments within 'convertImpl' for more details;
-        !detail::is_sint_to_from_uint<T, R>::value &&
-        // - destination type is not bool. bool is stored as integer under the
-        //   hood and therefore conversion to bool looks like conversion between
-        //   two integer types. Since bit pattern for true and false is not
-        //   defined, there is no guarantee that integer conversion yields
-        //   right results here;
-        !std::is_same_v<convertT, bool>;
-
-    if constexpr (canUseNativeVectorConvert) {
-      Result.m_Data = VecConvertFromOpenCLType<decltype(Result.m_Data)>(
-          detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
-                              OpenCLVecR>(NativeVector));
-    } else
+          NumElements > 1 &&
+          // - vec storage has an equivalent OpenCL native vector it is implicitly
+          //   convertible to. There are some corner cases where it is not the
+          //   case with char, long and long long types.
+          std::is_convertible_v<vector_t, OpenCLVecT> &&
+          std::is_convertible_v<ConvertTVecType, OpenCLVecR> &&
+          // - it is not a signed to unsigned (or vice versa) conversion
+          //   see comments within 'convertImpl' for more details;
+          !detail::is_sint_to_from_uint<T, R>::value &&
+          // - destination type is not bool. bool is stored as integer under the
+          //   hood and therefore conversion to bool looks like conversion between
+          //   two integer types. Since bit pattern for true and false is not
+          //   defined, there is no guarantee that integer conversion yields
+          //   right results here;
+          !std::is_same_v<convertT, bool>;
+
+      if constexpr (canUseNativeVectorConvert) {
+        Result.m_Data = sycl::bit_cast<decltype(Result.m_Data)>(
+            detail::convertImpl<T, R, roundingMode, NumElements, OpenCLVecT,
+                                OpenCLVecR>(NativeVector));
+      } else
 #endif // __SYCL_DEVICE_ONLY__
-    {
-      // Otherwise, we fallback to per-element conversion:
-      for (size_t I = 0; I < NumElements; ++I) {
-        auto val = VecConvertFromOpenCLType<convertT>(
-            detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
-                getValue(I)));
-
-        Result.setValue(I, val);
+      {
+        // Otherwise, we fallback to per-element conversion:
+        for (size_t I = 0; I < NumElements; ++I) {
+          auto val = detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
+                getValue(I));
+          if constexpr (IsByte<convertT>::value)
+            Result.setValue(I, static_cast<std::byte>(val));
+          else
+            Result.setValue(I, val);
+        }
       }
     }
 
@@ -647,8 +600,9 @@ template <typename Type, int NumElements> class vec {
   void store(size_t Offset,
              multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
     for (int I = 0; I < NumElements; I++) {
+      // Cast require for int8 -> std::byte conversion.
       *multi_ptr<DataT, Space, DecorateAddress>(
-          Ptr + Offset * NumElements + I) = VecConvertFromOpenCLType<DataT>(getValue(I));
+          Ptr + Offset * NumElements + I) = static_cast<DataT>(getValue(I));
     }
   }
   template <int Dimensions, access::mode Mode,
@@ -680,12 +634,12 @@ template <typename Type, int NumElements> class vec {
       std::false_type;
 #endif
 
-#ifdef __SYCL_BINOP
-#error "Undefine __SYCL_BINOP macro"
+#if defined(__SYCL_BINOP) || defined(BINOP_BASE)
+#error "Undefine __SYCL_BINOP and BINOP_BASE macro"
 #endif
 
 #ifdef __SYCL_DEVICE_ONLY__
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT, COND)                           \
+#define BINOP_BASE(BINOP, OPASSIGN, CONVERT, COND)                             \
   template <typename T = DataT>                                                \
   friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
       const vec & Lhs, const vec & Rhs) {                                      \
@@ -695,42 +649,20 @@ template <typename Type, int NumElements> class vec {
         Ret[I] = Lhs[I] BINOP Rhs[I];                                          \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = VecConvertToOpenCLType<DataType, vector_t>(Lhs.m_Data);               \
-      vector_t ExtVecRhs = VecConvertToOpenCLType<DataType, vector_t>(Rhs.m_Data);               \
+      vector_t ExtVecLhs = static_cast<vector_t>(Lhs);                         \
+      vector_t ExtVecRhs = static_cast<vector_t>(Rhs);                         \
       Ret = vec<DataT, NumElements>(                                           \
           (typename vec<DataT, NumElements>::vector_t)(                        \
               ExtVecLhs BINOP ExtVecRhs));                                     \
-      if constexpr (std::is_same_v<Type, bool> && CONVERT) {                   \
+      if constexpr (std::is_same_v<DataT, bool> && CONVERT) {                  \
         Ret.ConvertToDataT();                                                  \
       }                                                                        \
     }                                                                          \
     return Ret;                                                                \
-  }                                                                            \
-  template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
-      const vec & Lhs, const DataT & Rhs) {                                    \
-    return Lhs BINOP vec(Rhs);                                                 \
-  }                                                                            \
-  template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
-      const DataT & Lhs, const vec & Rhs) {                                    \
-    return vec(Lhs) BINOP Rhs;                                                 \
-  }                                                                            \
-  template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec> &operator OPASSIGN(            \
-      vec & Lhs, const vec & Rhs) {                                            \
-    Lhs = Lhs BINOP Rhs;                                                       \
-    return Lhs;                                                                \
-  }                                                                            \
-  template <int Num = NumElements, typename T = DataT>                         \
-  friend typename std::enable_if_t<(Num != 1) && (COND), vec &>                \
-  operator OPASSIGN(vec & Lhs, const DataT & Rhs) {                            \
-    Lhs = Lhs BINOP vec(Rhs);                                                  \
-    return Lhs;                                                                \
   }
 #else // __SYCL_DEVICE_ONLY__
 
-#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT, COND)                           \
+#define BINOP_BASE(BINOP, OPASSIGN, CONVERT, COND)                             \
   template <typename T = DataT>                                                \
   friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
       const vec & Lhs, const vec & Rhs) {                                      \
@@ -739,7 +671,13 @@ template <typename Type, int NumElements> class vec {
       Ret[I] = Lhs[I] BINOP Rhs[I];                                            \
     }                                                                          \
     return Ret;                                                                \
-  }                                                                            \
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
+
+#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT, COND)                           \
+  BINOP_BASE(BINOP, OPASSIGN, CONVERT, COND)                                   \
+                                                                               \
   template <typename T = DataT>                                                \
   friend typename std::enable_if_t<(COND), vec> operator BINOP(                \
       const vec & Lhs, const DataT & Rhs) {                                    \
@@ -762,7 +700,6 @@ template <typename Type, int NumElements> class vec {
     Lhs = Lhs BINOP vec(Rhs);                                                  \
     return Lhs;                                                                \
   }
-#endif // __SYCL_DEVICE_ONLY__
 
   // std::byte is not an arithmetic type.
   __SYCL_BINOP(+, +=, true, (!IsByte<T>::value))
@@ -783,6 +720,7 @@ template <typename Type, int NumElements> class vec {
   __SYCL_BINOP(<<, <<=, true,
                (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
 
+#undef BINOP_BASE
 #undef __SYCL_BINOP
 
   // Special <<, >> operators for std::byte.
@@ -824,13 +762,12 @@ template <typename Type, int NumElements> class vec {
   // TODO: Determine if vec<, NumElements=1> is needed at all, remove this
   // inconsistency if not by disallowing one-element vectors (as in OpenCL)
 
-#ifdef __SYCL_RELLOGOP
-#error "Undefine __SYCL_RELLOGOP macro"
+#if defined(__SYCL_RELLOGOP) || defined(RELLOGOP_BASE)
+#error "Undefine __SYCL_RELLOGOP and RELLOGOP_BASE macro."
 #endif
-// Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
-// by SYCL device compiler only.
+
 #ifdef __SYCL_DEVICE_ONLY__
-#define __SYCL_RELLOGOP(RELLOGOP, COND)                                        \
+#define RELLOGOP_BASE(RELLOGOP, COND)                                          \
   template <typename T = DataT>                                                \
   friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
   operator RELLOGOP(const vec & Lhs, const vec & Rhs) {                        \
@@ -845,8 +782,8 @@ template <typename Type, int NumElements> class vec {
         Ret[I] = static_cast<rel_t>(-(Lhs[I] RELLOGOP Rhs[I]));                \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = VecConvertToOpenCLType<DataType, vector_t>(Lhs.m_Data);               \
-      vector_t ExtVecRhs = VecConvertToOpenCLType<DataType, vector_t>(Rhs.m_Data);               \
+      vector_t ExtVecLhs = static_cast<vector_t>(Lhs);                         \
+      vector_t ExtVecRhs = static_cast<vector_t>(Rhs);                         \
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
               ExtVecLhs RELLOGOP ExtVecRhs));                                  \
@@ -854,32 +791,24 @@ template <typename Type, int NumElements> class vec {
         Ret *= -1;                                                             \
     }                                                                          \
     return Ret;                                                                \
-  }                                                                            \
-  template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
-  operator RELLOGOP(const vec & Lhs, const DataT & Rhs) {                      \
-    return Lhs RELLOGOP vec(Rhs);                                              \
-  }                                                                            \
-  template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
-  operator RELLOGOP(const DataT & Lhs, const vec & Rhs) {                      \
-    return vec(Lhs) RELLOGOP Rhs;                                              \
   }
-
-#else
-#define __SYCL_RELLOGOP(RELLOGOP, COND)                                        \
+#else // __SYCL_DEVICE_ONLY__
+#define RELLOGOP_BASE(RELLOGOP, COND)                                          \
   template <typename T = DataT>                                                \
   friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
   operator RELLOGOP(const vec & Lhs, const vec & Rhs) {                        \
                                                                                \
     vec<rel_t, NumElements> Ret{};                                             \
     for (size_t I = 0; I < NumElements; ++I) {                                 \
-      /* We cannot use SetValue here as the operator is not a friend of*/      \
-      /* Ret on Windows. */                                                    \
       Ret[I] = static_cast<rel_t>(-(Lhs[I] RELLOGOP Rhs[I]));                  \
     }                                                                          \
     return Ret;                                                                \
-  }                                                                            \
+  }
+#endif
+
+#define __SYCL_RELLOGOP(RELLOGOP, COND)                                        \
+  RELLOGOP_BASE(RELLOGOP, COND)                                                \
+                                                                               \
   template <typename T = DataT>                                                \
   friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
   operator RELLOGOP(const vec & Lhs, const DataT & Rhs) {                      \
@@ -890,7 +819,6 @@ template <typename Type, int NumElements> class vec {
   operator RELLOGOP(const DataT & Lhs, const vec & Rhs) {                      \
     return vec(Lhs) RELLOGOP Rhs;                                              \
   }
-#endif
 
   // OP is: ==, !=, <, >, <=, >=, &&, ||
   // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
@@ -936,16 +864,16 @@ template <typename Type, int NumElements> class vec {
   friend typename std::enable_if_t<!detail::is_vgenfloat_v<T>, vec>
   operator~(const vec &Rhs) {
 #ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = VecConvertToOpenCLType<DataType, vector_t>(Rhs.m_Data);
+    auto extVec = static_cast<vector_t>(Rhs);
     vec Ret{~extVec};
-    if constexpr (std::is_same_v<Type, bool>) {
+    if constexpr (std::is_same_v<DataT, bool>) {
       Ret.ConvertToDataT();
     }
     return Ret;
 #else
     vec Ret{};
     for (size_t I = 0; I < NumElements; ++I) {
-      Ret.setValue(I, VecConvertFromOpenCLType<DataT>(~Rhs.getValue(I)));
+      Ret.setValue(I, static_cast<DataT>(~Rhs.getValue(I)));
     }
     return Ret;
 #endif
@@ -960,7 +888,7 @@ template <typename Type, int NumElements> class vec {
     if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
                   !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
                   !std::is_same_v<DataT, bool>) {
-      auto extVec = VecConvertToOpenCLType<DataType, vector_t>(Rhs.m_Data);
+      auto extVec = static_cast<vector_t>(Rhs);
       return vec<detail::rel_t<DataT>, NumElements>{!extVec};
     } else
 #endif // __SYCL_DEVICE_ONLY__
@@ -968,7 +896,7 @@ template <typename Type, int NumElements> class vec {
       vec<detail::rel_t<DataT>, NumElements> Ret{};
       for (size_t I = 0; I < NumElements; ++I) {
         // static_cast will work here as the output of ! operator is either 0 or -1.
-        Ret[I] = static_cast<detail::rel_t<DataT>>(-1*(!VecConvertToOpenCLType<DataT>(Rhs[I])));
+        Ret[I] = static_cast<detail::rel_t<DataT>>(-1*(!Rhs[I]));
       }
       return Ret;
     }
@@ -979,7 +907,7 @@ template <typename Type, int NumElements> class vec {
   friend typename std::enable_if_t<(!IsByte<T>::value), vec>
   operator+(const vec &Lhs) {
 #ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = VecConvertToOpenCLType<DataType, vector_t>(Lhs.m_Data);
+    auto extVec = static_cast<vector_t>(Lhs);
     return vec{+extVec};
 #else
     vec Ret{};
@@ -1003,9 +931,9 @@ template <typename Type, int NumElements> class vec {
       for (size_t I = 0; I < NumElements; ++I)
         Ret[I] = -Lhs[I];
 #else
-      auto extVec = VecConvertToOpenCLType<DataType, vector_t>(Lhs.m_Data);
+      auto extVec = static_cast<vector_t>(Lhs);
       Ret = vec{-extVec};
-      if constexpr (std::is_same_v<Type, bool>) {
+      if constexpr (std::is_same_v<DataT, bool>) {
         Ret.ConvertToDataT();
       }
 #endif
@@ -1019,15 +947,34 @@ template <typename Type, int NumElements> class vec {
   constexpr auto getValue(int Index) const {
 #ifndef __SYCL_DEVICE_ONLY__
     assert(Index < NumElements && "Index out of range");
+
+    // Special tratment required for std::byte for vec::Convert
+    if constexpr (IsByte<DataT>::value)
+      return static_cast<int8_t>(m_Data[Index]);
+    else
+      return m_Data[Index];
+#else
+
+  if constexpr (std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>)
+    return sycl::bit_cast<detail::element_type_for_vector_t<DataT>>(m_Data[Index]);
+  else
+    return static_cast<detail::element_type_for_vector_t<DataT>>(m_Data[Index]);
 #endif
-    return VecConvertToOpenCLType<DataT>(m_Data[Index]);
   }
 
   constexpr void setValue(int Index, const DataT &Value) {
 #ifndef __SYCL_DEVICE_ONLY__
     assert(Index < NumElements && "Index out of range");
+    m_Data[Index] = Value;
+#else
+
+    if constexpr (std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>)
+      m_Data[Index] = sycl::bit_cast<DataT>(Value);
+    else if constexpr (std::is_same_v<DataT, bool>)
+      m_Data[Index] = static_cast<int8_t>(Value);
+    else
+      m_Data[Index] = Value;
 #endif
-    m_Data[Index] = VecConvertFromOpenCLType<DataT>(Value);
   }
 
   // fields
@@ -1200,13 +1147,13 @@ class SwizzleOp {
   template <typename T>
   using EnableIfScalarType = typename std::enable_if_t<
       std::is_convertible_v<DataT, T> &&
-      (std::is_fundamental_v<element_type_for_vector_t<T>> ||
+      (std::is_fundamental_v<T> ||
        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
 
   template <typename T>
   using EnableIfNoScalarType = typename std::enable_if_t<
       !std::is_convertible_v<DataT, T> ||
-      !(std::is_fundamental_v<element_type_for_vector_t<T>> ||
+      !(std::is_fundamental_v<T> ||
         detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
 
   template <int... Indices>
@@ -1326,7 +1273,7 @@ class SwizzleOp {
 
   template <typename T = DataT>
   friend typename std::enable_if_t<
-      std::is_same_v<T, DataT> && std::is_integral_v<element_type_for_vector_t<T>>, vec_t>
+      std::is_same_v<T, DataT> && std::is_integral_v<detail::GetEquivalentFundamentalType<T>>, vec_t>
   operator~(const SwizzleOp &Rhs) {
     vec_t Tmp = Rhs;
     return ~Tmp;
@@ -1805,32 +1752,28 @@ class SwizzleOp {
       std::array<int, getNumElements()> Idxs{Indexes...};
       return m_Vector->getValue(Idxs[Index]);
     }
-    auto Op = OperationCurrentT<element_type_for_vector_t<CommonDataT>>();
-    return VecConvertToOpenCLType<CommonDataT>(
-        Op(VecConvertToOpenCLType<CommonDataT>(m_LeftOperation.getValue(Index)),
-           VecConvertToOpenCLType<CommonDataT>(m_RightOperation.getValue(Index))));
+    auto Op = OperationCurrentT<CommonDataT>();
+    return Op(m_LeftOperation.getValue(Index), m_RightOperation.getValue(Index));
   }
 
   template <int IdxNum = getNumElements()>
   DataT getValue(EnableIfMultipleIndexes<IdxNum, size_t> Index) const {
     if (std::is_same_v<OperationCurrentT<DataT>, GetOp<DataT>>) {
       std::array<int, getNumElements()> Idxs{Indexes...};
-      return VecConvertFromOpenCLType<DataT>(m_Vector->getValue(Idxs[Index]));
+      // Cast required for int8_t -> std::byte
+      return static_cast<DataT>(m_Vector->getValue(Idxs[Index]));
     }
-    auto Op = OperationCurrentT<element_type_for_vector_t<DataT>>();
-    return VecConvertFromOpenCLType<DataT>(
-        Op(VecConvertToOpenCLType<DataT>(m_LeftOperation.getValue(Index)),
-           VecConvertToOpenCLType<DataT>(m_RightOperation.getValue(Index))));
+    auto Op = OperationCurrentT<DataT>();
+    return Op(m_LeftOperation.getValue(Index),
+           m_RightOperation.getValue(Index));
   }
 
   template <template <typename> class Operation, typename RhsOperation>
   void operatorHelper(const RhsOperation &Rhs) {
-    Operation<element_type_for_vector_t<DataT>> Op;
+    Operation<DataT> Op;
     std::array<int, getNumElements()> Idxs{Indexes...};
     for (size_t I = 0; I < Idxs.size(); ++I) {
-      DataT Res = VecConvertFromOpenCLType<DataT>(
-          Op(VecConvertToOpenCLType<DataT>(m_Vector->getValue(Idxs[I])),
-             VecConvertToOpenCLType<DataT>(Rhs.getValue(I))));
+      DataT Res = Op(m_Vector->getValue(Idxs[I]), Rhs.getValue(I));
       m_Vector->setValue(Idxs[I], Res);
     }
   }

From 5579f7b30db4543e760fa7a59675b171273c69c8 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Wed, 15 May 2024 23:31:40 -0700
Subject: [PATCH 64/79] Address reviews. Fix formatting and tests

---
 .../sycl/detail/generic_type_traits.hpp       |   1 -
 sycl/include/sycl/vector_preview.hpp          |  56 ++--
 .../vector/vector_math_ops.cpp                | 262 +++++++++---------
 3 files changed, 164 insertions(+), 155 deletions(-)

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index d8261b831c310..892b76e6062a0 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -457,7 +457,6 @@ template <typename T> static constexpr T max_v() {
 template <typename T> static constexpr T min_v() {
   return (std::numeric_limits<T>::min)();
 }
-
 } // namespace detail
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index b082d88d43c8b..ad581a9a01d11 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -124,15 +124,6 @@ class RoundedRangeKernel;
 template <typename TransformedArgType, int Dims, typename KernelType>
 class RoundedRangeKernelWithKH;
 
-template <typename T>
-using GetEquivalentFundamentalType = typename std::conditional_t<std::is_same_v<T, bool>, int8_t,
-                                      typename std::conditional_t<
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-                                          std::is_same_v<T, std::byte>, uint8_t, T>>;
-#else
-                                          false, T, T>>;
-#endif
-
 // OpenCL data type to convert to.
 template <typename T>
 using element_type_for_vector_t = typename std::conditional_t<
@@ -162,12 +153,14 @@ template <typename DataT, int NumElements> class vec {
 
   // This represent type of underlying value. There should be only one field
   // in the class, so vec<float, 16> should be equal to float16 in memory.
-  using DataType = typename std::conditional_t<
-    std::is_same_v<DataT, bool>, std::array<int8_t, AdjustedNum>, std::array<DataT, AdjustedNum>>;
+  using DataType =
+      std::array<std::conditional_t<std::is_same_v<DataT, bool>, int8_t, DataT>,
+                 AdjustedNum>;
 
 public:
 #ifdef __SYCL_DEVICE_ONLY__
-  // Type used for passing sycl::vec to SPIRV builtins.
+  // Type used for passing sycl::vec to SPIRV builtins. Frontend treats
+  // ext_vector_type(1) as a scalar.
   using vector_t = detail::element_type_for_vector_t<DataT> __attribute__((ext_vector_type(NumElements)));
 #endif // __SYCL_DEVICE_ONLY__
 
@@ -354,18 +347,23 @@ template <typename DataT, int NumElements> class vec {
   /****************** Assignment Operators **************/
   constexpr vec &operator=(const vec &Rhs) = default;
 
-  vec& operator=(const DataT &Rhs) {
-    for (int i = 0; i < NumElements; ++i) {
-      setValue(i, Rhs);
-    }
+  // Template required to prevent ambiguous overload with the copy assignment
+  // when NumElements == 1. The template prevents implicit conversion from
+  // vec<_, 1> to DataT.
+  template <typename Ty = DataT>
+  typename std::enable_if_t<
+      std::is_fundamental_v<Ty> ||
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
+      vec &>
+  operator=(const DataT &Rhs) {
+    *this = vec{Rhs};
     return *this;
   }
 
   // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
   template <typename Ty = DataT>
-  typename std::enable_if_t<!std::is_same_v<Ty, rel_t> &&
-                                std::is_convertible_v<detail::GetEquivalentFundamentalType<Ty>, rel_t>,
-                            vec &>
+  typename std::enable_if_t<
+      !std::is_same_v<Ty, rel_t> && std::is_convertible_v<Ty, rel_t>, vec &>
   operator=(const vec<rel_t, NumElements> &Rhs) {
     *this = Rhs.template as<vec>();
     return *this;
@@ -402,14 +400,26 @@ template <typename DataT, int NumElements> class vec {
   static constexpr size_t get_size() { return byte_size(); }
   static constexpr size_t byte_size() noexcept { return sizeof(m_Data); }
 
+  // We interpret bool as int8_t, std::byte as uint8_t for onversion to other
+  // types.
+  template <typename T>
+  using ConvertBoolAndByteT = typename std::conditional_t<
+      std::is_same_v<T, bool>, int8_t,
+      typename std::conditional_t<
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+          std::is_same_v<T, std::byte>, uint8_t, T>>;
+#else
+          false, T, T>>;
+#endif
+
   // convertImpl can't be called with the same From and To types and therefore
   // we need this version of convert which is mostly no-op.
   template <typename convertT,
             rounding_mode roundingMode = rounding_mode::automatic>
   vec<convertT, NumElements> convert() const {
 
-    using T = detail::GetEquivalentFundamentalType<DataT>;
-    using R = detail::GetEquivalentFundamentalType<convertT>;
+    using T = ConvertBoolAndByteT<DataT>;
+    using R = ConvertBoolAndByteT<convertT>;
     static_assert(std::is_integral_v<R> ||
                   detail::is_floating_point<R>::value,
                   "Unsupported convertT");
@@ -739,7 +749,7 @@ template <typename DataT, int NumElements> class vec {
       const vec & Lhs, int shift) {                                            \
     vec Ret;                                                                   \
     for (size_t I = 0; I < NumElements; ++I) {                                 \
-      Ret.setValue(I, Lhs[I] OP shift);                                        \
+      Ret[I] = Lhs[I] OP shift;                                                \
     }                                                                          \
     return Ret;                                                                \
   }                                                                            \
@@ -1273,7 +1283,7 @@ class SwizzleOp {
 
   template <typename T = DataT>
   friend typename std::enable_if_t<
-      std::is_same_v<T, DataT> && std::is_integral_v<detail::GetEquivalentFundamentalType<T>>, vec_t>
+      std::is_same_v<T, DataT> && !detail::is_vgenfloat_v<T>, vec_t>
   operator~(const SwizzleOp &Rhs) {
     vec_t Tmp = Rhs;
     return ~Tmp;
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 6a7c92a853283..46e4b072645ba 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -23,13 +23,13 @@ using namespace sycl;
 // CHECK-NEXT:    store <2 x i32> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META7]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIiLi2EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] !srcloc [[META5:![0-9]+]] !sycl_fixed_targets [[META6:![0-9]+]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[A]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[B]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META7:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10:![0-9]+]], !noalias [[META7]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[B]], align 4, !tbaa [[TBAA10]], !noalias [[META7]]
 // CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <2 x i32> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    store <2 x i32> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store <2 x i32> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META7]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<int, 2> a, vec<int, 2> b) { return a + b; }
@@ -45,14 +45,14 @@ SYCL_EXTERNAL auto TestAdd(vec<int, 2> a, vec<int, 2> b) { return a + b; }
 // CHECK-NEXT:    store <4 x float> [[EXTRACTVEC5_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META14]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIfLi3EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META13:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x float>, ptr [[A]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I7_I:%.*]] = load <4 x float>, ptr [[B]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = fadd <4 x float> [[LOADVEC4_I_I]], [[LOADVEC4_I7_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I9_I:%.*]] = shufflevector <4 x float> [[TMP0]], <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-ARR-STORAGE-NEXT:    store <4 x float> [[EXTRACTVEC_I9_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META14:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x float>, ptr [[A]], align 4, !noalias [[META14]]
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x float>, ptr [[B]], align 4, !noalias [[META14]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = fadd <4 x float> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x float> [[TMP0]], <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-ARR-STORAGE-NEXT:    store <4 x float> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META14]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<float, 3> a, vec<float, 3> b) { return a + b; }
@@ -67,13 +67,13 @@ SYCL_EXTERNAL auto TestAdd(vec<float, 3> a, vec<float, 3> b) { return a + b; }
 // CHECK-NEXT:    store <16 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META18]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIcLi16EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META17:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <16 x i8>, ptr [[B]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META18:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META18]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <16 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META18]]
 // CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <16 x i8> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    store <16 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store <16 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META18]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<char, 16> a, vec<char, 16> b) { return a + b; }
@@ -89,13 +89,13 @@ SYCL_EXTERNAL auto TestAdd(vec<char, 16> a, vec<char, 16> b) { return a + b; }
 // CHECK-NEXT:    store <8 x i8> [[XOR_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META22]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestXorN4sycl3_V13vecISt4byteLi8EEES3_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META21:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x i8>, ptr [[A]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <8 x i8>, ptr [[B]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META22:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META22]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <8 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META22]]
 // CHECK-ARR-STORAGE-NEXT:    [[XOR_I:%.*]] = xor <8 x i8> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    store <8 x i8> [[XOR_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store <8 x i8> [[XOR_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META22]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestXor(vec<std::byte, 8> a, vec<std::byte, 8> b) {
@@ -127,13 +127,13 @@ SYCL_EXTERNAL auto TestXor(vec<std::byte, 8> a, vec<std::byte, 8> b) {
 // CHECK-NEXT:    store <4 x i8> [[VECINS_I_I6_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META26]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIbLi4EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.6") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.6") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] !srcloc [[META25:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <4 x i8>, ptr [[B]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META26:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META26]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <4 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META26]]
 // CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <4 x i8> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    store <4 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store <4 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META26]]
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I:%.*]], [[FOR_BODY_I_I:%.*]] ]
@@ -141,10 +141,10 @@ SYCL_EXTERNAL auto TestXor(vec<std::byte, 8> a, vec<std::byte, 8> b) {
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIBLI4EEEE4TYPEERKS5_S9__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i.i:
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP2:%.*]] = load i8, ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I_I_I:%.*]] = icmp ne i8 [[TMP2]], 0
-// CHECK-ARR-STORAGE-NEXT:    [[FROMBOOL_I_I_I_I:%.*]] = zext i1 [[TOBOOL_I_I_I]] to i8
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[FROMBOOL_I_I_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP2:%.*]] = load i8, ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
+// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I_I:%.*]] = icmp ne i8 [[TMP2]], 0
+// CHECK-ARR-STORAGE-NEXT:    [[FROMBOOL_I_I:%.*]] = zext i1 [[TOBOOL_I_I]] to i8
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[FROMBOOL_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I_I]] = add nuw nsw i64 [[I_0_I_I]], 1
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP29:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIbLi4EEEE4typeERKS5_S9_.exit:
@@ -163,14 +163,14 @@ SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
 // CHECK-NEXT:    store <4 x half> [[EXTRACTVEC5_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META32]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_6detail9half_impl4halfELi3EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META31:![0-9]+]] !sycl_used_aspects [[META32:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x half>, ptr [[A]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I7_I:%.*]] = load <4 x half>, ptr [[B]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = fadd <4 x half> [[LOADVEC4_I_I]], [[LOADVEC4_I7_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I9_I:%.*]] = shufflevector <4 x half> [[TMP0]], <4 x half> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-ARR-STORAGE-NEXT:    store <4 x half> [[EXTRACTVEC_I9_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META33:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x half>, ptr [[A]], align 2, !noalias [[META33]]
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x half>, ptr [[B]], align 2, !noalias [[META33]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = fadd <4 x half> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x half> [[TMP0]], <4 x half> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-ARR-STORAGE-NEXT:    store <4 x half> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META33]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
@@ -224,7 +224,7 @@ SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP3_I]])
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] !srcloc [[META36:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
 // CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
@@ -237,17 +237,17 @@ SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI3EEEE4TYPEERKS8_SC__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9:[0-9]+]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9]]
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR10:[0-9]+]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR10]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8:[0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]]
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9:[0-9]+]], !noalias [[META40:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR9]], !noalias [[META40]]
 // CHECK-ARR-STORAGE-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR10]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL4_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR9]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[CALL4_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA43:![0-9]+]], !noalias [[META45:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META40]]
+// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL4_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR8]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[CALL4_I]], align 2, !tbaa [[TBAA46:![0-9]+]]
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP48:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_.exit:
@@ -271,14 +271,14 @@ SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
 // CHECK-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, !tbaa [[TBAA10]], !alias.scope [[META70]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIiLi16EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META51:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META52:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META52]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 4, !tbaa [[TBAA10]], !noalias [[META52]]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp sgt <16 x i32> [[TMP0]], [[TMP1]]
 // CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <16 x i1> [[CMP_I]] to <16 x i32>
-// CHECK-ARR-STORAGE-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, !tbaa [[TBAA10]], !alias.scope [[META52]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
@@ -298,16 +298,16 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
 // CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META74]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecISt4byteLi3EEES3_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META55:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I7_I:%.*]] = load <4 x i8>, ptr [[B]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = icmp ugt <4 x i8> [[LOADVEC4_I_I]], [[LOADVEC4_I7_I]]
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META56:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1, !noalias [[META56]]
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x i8>, ptr [[B]], align 1, !noalias [[META56]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = icmp ugt <4 x i8> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = shufflevector <4 x i1> [[TMP0]], <4 x i1> poison, <3 x i32> <i32 0, i32 1, i32 2>
 // CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i8>
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I9_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-ARR-STORAGE-NEXT:    store <4 x i8> [[EXTRACTVEC_I9_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-ARR-STORAGE-NEXT:    store <4 x i8> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META56]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
@@ -325,14 +325,14 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
 // CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META78]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIbLi2EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META59:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META60:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META60]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META60]]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
 // CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
-// CHECK-ARR-STORAGE-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META60]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
@@ -350,14 +350,14 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
 // CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META82]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META63:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META64:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META64]]
+// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META64]]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = fcmp ogt <8 x half> [[TMP0]], [[TMP1]]
 // CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <8 x i1> [[CMP_I]] to <8 x i16>
-// CHECK-ARR-STORAGE-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META64]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
@@ -378,12 +378,12 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 // CHECK-NEXT:    store <4 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META86]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.24") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[B:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.24") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META67:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
 // CHECK-ARR-STORAGE-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META68:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META68]]
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -391,14 +391,14 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTINS0_3EXT6ONEAPI8BFLOAT16EEENS0_3VECISLI4EEERKNS5_IS4_LI4EEES9__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR10]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR10]], {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META68]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META68]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], !noalias [[META68]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR9]], !noalias [[META68]]
 // CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-ARR-STORAGE-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META68]]
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP71:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_.exit:
@@ -423,15 +423,15 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
 // CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !alias.scope [[META90]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIiLi3EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.27") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.27") align 16 [[A:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.27") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.27") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META72:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I]], zeroinitializer
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META73:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 4, !noalias [[META73]]
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
+// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I_I]], zeroinitializer
 // CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i32>
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I2_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-ARR-STORAGE-NEXT:    store <4 x i32> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-ARR-STORAGE-NEXT:    store <4 x i32> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META73]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
@@ -445,12 +445,12 @@ SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
 // CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META94]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecIiLi4EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META76:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META77:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META77]]
 // CHECK-ARR-STORAGE-NEXT:    [[SUB_I:%.*]] = sub <4 x i32> zeroinitializer, [[TMP0]]
-// CHECK-ARR-STORAGE-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META77]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
@@ -465,12 +465,12 @@ SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
 // CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META98]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z19TestBitwiseNegationN4sycl3_V13vecISt4byteLi16EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.30") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.30") align 16 [[A:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.30") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.30") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META80:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META81:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META81]]
 // CHECK-ARR-STORAGE-NEXT:    [[NOT_I:%.*]] = xor <16 x i8> [[TMP0]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
-// CHECK-ARR-STORAGE-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META81]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
@@ -485,10 +485,10 @@ SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 // CHECK-NEXT:    store <4 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META105:![0-9]+]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META84:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META85:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META85]]
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -496,10 +496,10 @@ SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIALI4EEEE4TYPEERKNS4_IBLI4EEE_EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I]], align 1, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = add nsw i8 [[TMP0]], -1
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I11_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[SEXT_I]], ptr addrspace(4) [[ARRAYIDX_I11_I]], align 1, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I]], align 1, !tbaa [[TBAA88:![0-9]+]], !range [[RNG90:![0-9]+]], !noalias [[META85]], !noundef [[META6]]
+// CHECK-ARR-STORAGE-NEXT:    [[DOTNEG_I:%.*]] = add nsw i8 [[TMP0]], -1
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I9_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i8 [[DOTNEG_I]], ptr addrspace(4) [[ARRAYIDX_I9_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META85]]
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP91:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIaLi4EEEE4typeERKNS4_IbLi4EEE.exit:
@@ -517,10 +517,10 @@ SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 // CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META112:![0-9]+]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META92:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META93:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META93]]
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -528,13 +528,13 @@ SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_6DETAIL9HALF_IMPL4HALFEEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI2EEEE4TYPEERKNS7_IS4_LI2EEE_EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::detail::half_impl::half", ptr [[A]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA96:![0-9]+]], !noalias [[META93]]
 // CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq half [[TMP0]], 0xH0000
 // CHECK-ARR-STORAGE-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I11_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I11_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I10_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META93]]
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP98:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP99:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi2EEEE4typeERKNS7_IS4_Li2EEE.exit:
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
@@ -549,12 +549,12 @@ SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 // CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META116]]
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META100:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META101:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META101]]
 // CHECK-ARR-STORAGE-NEXT:    [[FNEG_I:%.*]] = fneg <8 x half> [[TMP0]]
-// CHECK-ARR-STORAGE-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META101]]
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
@@ -597,11 +597,11 @@ SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP2_I]])
 // CHECK-NEXT:    ret void
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META104:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
-// CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META105:![0-9]+]])
+// CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META105]]
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -609,14 +609,14 @@ SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9]], {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i16, ptr addrspace(4) [[CALL_I]], align 2, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_NOT_I:%.*]] = icmp eq i16 [[TMP0]], 0
-// CHECK-ARR-STORAGE-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_NOT_I]] to i16
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META105]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], !noalias [[META105]]
+// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
+// CHECK-ARR-STORAGE-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
 // CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META105]]
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP107:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP108:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
 // CHECK-ARR-STORAGE-NEXT:    ret void
 //
@@ -651,14 +651,14 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP157:![0-9]+]]
 // CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) {{.*}}{
+// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META109:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-ARR-STORAGE-NEXT:  entry:
 // CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I:%.*]] = alloca float, align 4
 // CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.{{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META110:![0-9]+]])
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP_I]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META110]]
 // CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK-ARR-STORAGE:       for.cond.i:
 // CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -666,15 +666,15 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI16EEEE4TYPEERKS8__EXIT:%.*]]
 // CHECK-ARR-STORAGE:       for.body.i:
 // CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR9]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR10]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]]
 // CHECK-ARR-STORAGE-NEXT:    [[FNEG_I:%.*]] = fneg float [[CALL_I_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, {{.*}}
-// CHECK-ARR-STORAGE-NEXT:    [[CALL3_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR9]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I8_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR10]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I8_I]], ptr addrspace(4) [[CALL3_I]], align 2, {{.*}}
+// CHECK-ARR-STORAGE-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA43]], !noalias [[META110]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL3_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR8]]
+// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I8_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR9]]
+// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I8_I]], ptr addrspace(4) [[CALL3_I]], align 2, !tbaa [[TBAA113:![0-9]+]]
 // CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP114:![0-9]+]]
+// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP115:![0-9]+]]
 // CHECK-ARR-STORAGE:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:
 // CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-ARR-STORAGE-NEXT:    ret void

From 3b6da036d0feb8ec58f056dc80a607d4b53b993c Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 16 May 2024 00:47:59 -0700
Subject: [PATCH 65/79] Fix cformatting

---
 sycl/include/sycl/vector_preview.hpp | 70 ++++++++++++++++------------
 1 file changed, 40 insertions(+), 30 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index ad581a9a01d11..43556cf1752b6 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -128,14 +128,17 @@ class RoundedRangeKernelWithKH;
 template <typename T>
 using element_type_for_vector_t = typename std::conditional_t<
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-      std::is_same_v<T, std::byte>, std::uint8_t,
+    std::is_same_v<T, std::byte>, std::uint8_t,
 #else
-      false, T,
+    false, T,
 #endif
-      typename std::conditional_t<std::is_same_v<T, bool>, std::int8_t,
-      typename std::conditional_t<std::is_same_v<T, sycl::half>, sycl::detail::half_impl::StorageT,
-      typename std::conditional_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-      sycl::ext::oneapi::detail::Bfloat16StorageT, T>>>>;
+    typename std::conditional_t<
+        std::is_same_v<T, bool>, std::int8_t,
+        typename std::conditional_t<
+            std::is_same_v<T, sycl::half>, sycl::detail::half_impl::StorageT,
+            typename std::conditional_t<
+                std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
+                sycl::ext::oneapi::detail::Bfloat16StorageT, T>>>>;
 } // namespace detail
 
 ///////////////////////// class sycl::vec /////////////////////////
@@ -161,7 +164,8 @@ template <typename DataT, int NumElements> class vec {
 #ifdef __SYCL_DEVICE_ONLY__
   // Type used for passing sycl::vec to SPIRV builtins. Frontend treats
   // ext_vector_type(1) as a scalar.
-  using vector_t = detail::element_type_for_vector_t<DataT> __attribute__((ext_vector_type(NumElements)));
+  using vector_t = detail::element_type_for_vector_t<DataT> __attribute__((
+      ext_vector_type(NumElements)));
 #endif // __SYCL_DEVICE_ONLY__
 
 private:
@@ -370,9 +374,9 @@ template <typename DataT, int NumElements> class vec {
   }
 
 #ifdef __SYCL_DEVICE_ONLY__
-  template <typename vector_t_ = vector_t,
-            typename =
-                typename std::enable_if_t<std::is_same_v<vector_t_, vector_t>>>
+  template <
+      typename vector_t_ = vector_t,
+      typename = typename std::enable_if_t<std::is_same_v<vector_t_, vector_t>>>
   constexpr vec(vector_t_ openclVector) {
     m_Data = sycl::bit_cast<DataType>(openclVector);
   }
@@ -420,8 +424,7 @@ template <typename DataT, int NumElements> class vec {
 
     using T = ConvertBoolAndByteT<DataT>;
     using R = ConvertBoolAndByteT<convertT>;
-    static_assert(std::is_integral_v<R> ||
-                  detail::is_floating_point<R>::value,
+    static_assert(std::is_integral_v<R> || detail::is_floating_point<R>::value,
                   "Unsupported convertT");
 
     using OpenCLT = detail::ConvertToOpenCLType_t<T>;
@@ -429,7 +432,8 @@ template <typename DataT, int NumElements> class vec {
     vec<convertT, NumElements> Result;
 
     // For conversion between bool -> signed char and byte -> uint8_t.
-    if constexpr (!std::is_same_v<DataT, convertT> && (std::is_same_v<OpenCLT, OpenCLR> || std::is_same_v<T, R>)) {
+    if constexpr (!std::is_same_v<DataT, convertT> &&
+                  (std::is_same_v<OpenCLT, OpenCLR> || std::is_same_v<T, R>)) {
       for (size_t I = 0; I < NumElements; ++I)
         Result.setValue(I, static_cast<convertT>(getValue(I)));
       return Result;
@@ -451,7 +455,8 @@ template <typename DataT, int NumElements> class vec {
           false &&
 #endif
           NumElements > 1 &&
-          // - vec storage has an equivalent OpenCL native vector it is implicitly
+          // - vec storage has an equivalent OpenCL native vector it is
+          // implicitly
           //   convertible to. There are some corner cases where it is not the
           //   case with char, long and long long types.
           std::is_convertible_v<vector_t, OpenCLVecT> &&
@@ -460,10 +465,10 @@ template <typename DataT, int NumElements> class vec {
           //   see comments within 'convertImpl' for more details;
           !detail::is_sint_to_from_uint<T, R>::value &&
           // - destination type is not bool. bool is stored as integer under the
-          //   hood and therefore conversion to bool looks like conversion between
-          //   two integer types. Since bit pattern for true and false is not
-          //   defined, there is no guarantee that integer conversion yields
-          //   right results here;
+          //   hood and therefore conversion to bool looks like conversion
+          //   between two integer types. Since bit pattern for true and false
+          //   is not defined, there is no guarantee that integer conversion
+          //   yields right results here;
           !std::is_same_v<convertT, bool>;
 
       if constexpr (canUseNativeVectorConvert) {
@@ -475,8 +480,9 @@ template <typename DataT, int NumElements> class vec {
       {
         // Otherwise, we fallback to per-element conversion:
         for (size_t I = 0; I < NumElements; ++I) {
-          auto val = detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
-                getValue(I));
+          auto val =
+              detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
+                  getValue(I));
           if constexpr (IsByte<convertT>::value)
             Result.setValue(I, static_cast<std::byte>(val));
           else
@@ -684,7 +690,6 @@ template <typename DataT, int NumElements> class vec {
   }
 #endif // __SYCL_DEVICE_ONLY__
 
-
 #define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT, COND)                           \
   BINOP_BASE(BINOP, OPASSIGN, CONVERT, COND)                                   \
                                                                                \
@@ -905,8 +910,9 @@ template <typename DataT, int NumElements> class vec {
     {
       vec<detail::rel_t<DataT>, NumElements> Ret{};
       for (size_t I = 0; I < NumElements; ++I) {
-        // static_cast will work here as the output of ! operator is either 0 or -1.
-        Ret[I] = static_cast<detail::rel_t<DataT>>(-1*(!Rhs[I]));
+        // static_cast will work here as the output of ! operator is either 0 or
+        // -1.
+        Ret[I] = static_cast<detail::rel_t<DataT>>(-1 * (!Rhs[I]));
       }
       return Ret;
     }
@@ -965,10 +971,12 @@ template <typename DataT, int NumElements> class vec {
       return m_Data[Index];
 #else
 
-  if constexpr (std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>)
-    return sycl::bit_cast<detail::element_type_for_vector_t<DataT>>(m_Data[Index]);
-  else
-    return static_cast<detail::element_type_for_vector_t<DataT>>(m_Data[Index]);
+    if constexpr (std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>)
+      return sycl::bit_cast<detail::element_type_for_vector_t<DataT>>(
+          m_Data[Index]);
+    else
+      return static_cast<detail::element_type_for_vector_t<DataT>>(
+          m_Data[Index]);
 #endif
   }
 
@@ -989,7 +997,8 @@ template <typename DataT, int NumElements> class vec {
 
   // fields
   // Alignment is the same as size, to a maximum size of 64.
-  alignas(std::min((size_t)64, sizeof(DataType))) DataType m_Data;
+  static constexpr int alignment = std::min((size_t)64, sizeof(DataType));
+  alignas(alignment) DataType m_Data;
 
   // friends
   template <typename T1, typename T2, typename T3, template <typename> class T4,
@@ -1763,7 +1772,8 @@ class SwizzleOp {
       return m_Vector->getValue(Idxs[Index]);
     }
     auto Op = OperationCurrentT<CommonDataT>();
-    return Op(m_LeftOperation.getValue(Index), m_RightOperation.getValue(Index));
+    return Op(m_LeftOperation.getValue(Index),
+              m_RightOperation.getValue(Index));
   }
 
   template <int IdxNum = getNumElements()>
@@ -1775,7 +1785,7 @@ class SwizzleOp {
     }
     auto Op = OperationCurrentT<DataT>();
     return Op(m_LeftOperation.getValue(Index),
-           m_RightOperation.getValue(Index));
+              m_RightOperation.getValue(Index));
   }
 
   template <template <typename> class Operation, typename RhsOperation>

From 48713c7525e32e6688f151de8d6d974616ee17e1 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 16 May 2024 12:32:57 -0700
Subject: [PATCH 66/79] Remove invert logic for NumElements=1 as we now use
 ext_vector_type for all sizes.

---
 sycl/include/sycl/vector_preview.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 43556cf1752b6..c26917da55747 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -633,12 +633,15 @@ template <typename DataT, int NumElements> class vec {
     store(Offset, MultiPtr);
   }
 
+#ifdef __SYCL_DEVICE_ONLY__
+  // Require only for std::bool.
   void ConvertToDataT() {
     for (size_t i = 0; i < NumElements; ++i) {
       DataT tmp = getValue(i);
       setValue(i, tmp);
     }
   }
+#endif
 
   /******************* sycl::vec math operations ***********************/
 
@@ -802,8 +805,6 @@ template <typename DataT, int NumElements> class vec {
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
               ExtVecLhs RELLOGOP ExtVecRhs));                                  \
-      if (NumElements == 1) /*Scalar 0/1 logic was applied, invert*/           \
-        Ret *= -1;                                                             \
     }                                                                          \
     return Ret;                                                                \
   }
@@ -888,7 +889,7 @@ template <typename DataT, int NumElements> class vec {
 #else
     vec Ret{};
     for (size_t I = 0; I < NumElements; ++I) {
-      Ret.setValue(I, static_cast<DataT>(~Rhs.getValue(I)));
+      Ret[I] = ~Rhs[I];
     }
     return Ret;
 #endif

From 9376a62da149dad60e720444e14db3d183f71cca Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 17 May 2024 08:01:56 -0700
Subject: [PATCH 67/79] Address reviews

---
 sycl/include/sycl/vector_preview.hpp          |   6 +-
 .../vector/vector_math_ops.cpp                | 656 +++++-------------
 2 files changed, 187 insertions(+), 475 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index c26917da55747..e476797701a64 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -162,8 +162,10 @@ template <typename DataT, int NumElements> class vec {
 
 public:
 #ifdef __SYCL_DEVICE_ONLY__
-  // Type used for passing sycl::vec to SPIRV builtins. Frontend treats
-  // ext_vector_type(1) as a scalar.
+  // Type used for passing sycl::vec to SPIRV builtins. Optimizer treats
+  // ext_vector_type(1) as a scalar type, except for logical operations.
+  // Logical operations on ext_vector_type(1) results in 0 or -1, while
+  // on scalar types it results in 0 or 1. 
   using vector_t = detail::element_type_for_vector_t<DataT> __attribute__((
       ext_vector_type(NumElements)));
 #endif // __SYCL_DEVICE_ONLY__
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 46e4b072645ba..7259a4b0687a5 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -1,8 +1,7 @@
 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 4
 // NOTE: ..., followed by some manual cleanup.
 
-// RUN: %clangxx -I %sycl_include -S -emit-llvm -fno-discard-value-names -fno-sycl-instrument-device-code -Xclang -disable-lifetime-markers -fsycl-device-only %s -o - | FileCheck %s
-// RUN: %if preview-breaking-changes-supported %{ %clangxx -I %sycl_include -S -emit-llvm -fno-discard-value-names -fpreview-breaking-changes -fno-sycl-instrument-device-code -Xclang -disable-lifetime-markers -fsycl-device-only %s -o - | FileCheck %s -check-prefix=CHECK-ARR-STORAGE %}
+// RUN: %clangxx -I %sycl_include -fpreview-breaking-changes -fno-discard-value-names -S -emit-llvm -fno-sycl-instrument-device-code -Xclang -disable-lifetime-markers -fsycl-device-only %s -o - | FileCheck %s
 
 // This test checks
 // (1) the storage type of sycl::vec on device for all data types, and
@@ -17,20 +16,11 @@ using namespace sycl;
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] !srcloc [[META5:![0-9]+]] !sycl_fixed_targets [[META6:![0-9]+]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META7:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[A]], align 8, !tbaa [[TBAA10:![0-9]+]], !noalias [[META7]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[B]], align 8, !tbaa [[TBAA10]], !noalias [[META7]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10:![0-9]+]], !noalias [[META7]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[B]], align 4, !tbaa [[TBAA10]], !noalias [[META7]]
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <2 x i32> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    store <2 x i32> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META7]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIiLi2EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] !srcloc [[META5:![0-9]+]] !sycl_fixed_targets [[META6:![0-9]+]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META7:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10:![0-9]+]], !noalias [[META7]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[B]], align 4, !tbaa [[TBAA10]], !noalias [[META7]]
-// CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <2 x i32> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    store <2 x i32> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META7]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<int, 2> a, vec<int, 2> b) { return a + b; }
 
@@ -38,220 +28,110 @@ SYCL_EXTERNAL auto TestAdd(vec<int, 2> a, vec<int, 2> b) { return a + b; }
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META13:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META14:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I:%.*]] = load <4 x float>, ptr [[A]], align 16, !noalias [[META14]]
-// CHECK-NEXT:    [[LOADVEC42_I:%.*]] = load <4 x float>, ptr [[B]], align 16, !noalias [[META14]]
-// CHECK-NEXT:    [[TMP0:%.*]] = fadd <4 x float> [[LOADVEC4_I]], [[LOADVEC42_I]]
-// CHECK-NEXT:    [[EXTRACTVEC5_I:%.*]] = shufflevector <4 x float> [[TMP0]], <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x float> [[EXTRACTVEC5_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META14]]
+// CHECK-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x float>, ptr [[A]], align 4, !noalias [[META14]]
+// CHECK-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x float>, ptr [[B]], align 4, !noalias [[META14]]
+// CHECK-NEXT:    [[TMP0:%.*]] = fadd <4 x float> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
+// CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x float> [[TMP0]], <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-NEXT:    store <4 x float> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META14]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIfLi3EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META13:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META14:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x float>, ptr [[A]], align 4, !noalias [[META14]]
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x float>, ptr [[B]], align 4, !noalias [[META14]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = fadd <4 x float> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x float> [[TMP0]], <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-ARR-STORAGE-NEXT:    store <4 x float> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META14]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<float, 3> a, vec<float, 3> b) { return a + b; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIcLi16EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.1") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.1") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META17:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META17:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META18:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META18]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i8>, ptr [[B]], align 16, !tbaa [[TBAA10]], !noalias [[META18]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META18]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META18]]
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <16 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    store <16 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META18]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIcLi16EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META17:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META18:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META18]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <16 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META18]]
-// CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <16 x i8> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    store <16 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META18]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<char, 16> a, vec<char, 16> b) { return a + b; }
 
 // std::byte does not support '+'. Therefore, using bitwise XOR as a substitute.
 // CHECK-LABEL: define dso_local spir_func void @_Z7TestXorN4sycl3_V13vecISt4byteLi8EEES3_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META21:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META21:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META22:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x i8>, ptr [[A]], align 8, !tbaa [[TBAA10]], !noalias [[META22]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x i8>, ptr [[B]], align 8, !tbaa [[TBAA10]], !noalias [[META22]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META22]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META22]]
 // CHECK-NEXT:    [[XOR_I:%.*]] = xor <8 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    store <8 x i8> [[XOR_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META22]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestXorN4sycl3_V13vecISt4byteLi8EEES3_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META21:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META22:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META22]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <8 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META22]]
-// CHECK-ARR-STORAGE-NEXT:    [[XOR_I:%.*]] = xor <8 x i8> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    store <8 x i8> [[XOR_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META22]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestXor(vec<std::byte, 8> a, vec<std::byte, 8> b) {
   return a ^ b;
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIbLi4EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.3") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] !srcloc [[META25:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.6") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] !srcloc [[META25:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META26:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META26]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i8>, ptr [[B]], align 4, !tbaa [[TBAA10]], !noalias [[META26]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META26]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META26]]
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <4 x i8> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    store <4 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META26]]
 // CHECK-NEXT:    br label [[FOR_COND_I_I:%.*]]
 // CHECK:       for.cond.i.i:
-// CHECK-NEXT:    [[VECINS_I_I6_I_I:%.*]] = phi <4 x i8> [ [[ADD_I]], [[ENTRY:%.*]] ], [ [[VECINS_I_I_I_I:%.*]], [[FOR_BODY_I_I:%.*]] ]
-// CHECK-NEXT:    [[I_0_I_I:%.*]] = phi i64 [ 0, [[ENTRY]] ], [ [[INC_I_I:%.*]], [[FOR_BODY_I_I]] ]
+// CHECK-NEXT:    [[I_0_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I:%.*]], [[FOR_BODY_I_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I_I:%.*]] = icmp ult i64 [[I_0_I_I]], 4
-// CHECK-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECIBLI4EEES4__EXIT:%.*]]
+// CHECK-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIBLI4EEEE4TYPEERKS5_S9__EXIT:%.*]]
 // CHECK:       for.body.i.i:
-// CHECK-NEXT:    [[CONV_I_I:%.*]] = trunc nuw nsw i64 [[I_0_I_I]] to i32
-// CHECK-NEXT:    [[VECEXT_I_I_I_I:%.*]] = extractelement <4 x i8> [[VECINS_I_I6_I_I]], i32 [[CONV_I_I]]
-// CHECK-NEXT:    [[TOBOOL_I_I_I_I:%.*]] = icmp ne i8 [[VECEXT_I_I_I_I]], 0
-// CHECK-NEXT:    [[FROMBOOL_I_I:%.*]] = zext i1 [[TOBOOL_I_I_I_I]] to i8
-// CHECK-NEXT:    [[VECINS_I_I_I_I]] = insertelement <4 x i8> [[VECINS_I_I6_I_I]], i8 [[FROMBOOL_I_I]], i32 [[CONV_I_I]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I_I]]
+// CHECK-NEXT:    [[TMP2:%.*]] = load i8, ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
+// CHECK-NEXT:    [[TOBOOL_I_I:%.*]] = icmp ne i8 [[TMP2]], 0
+// CHECK-NEXT:    [[FROMBOOL_I_I:%.*]] = zext i1 [[TOBOOL_I_I]] to i8
+// CHECK-NEXT:    store i8 [[FROMBOOL_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
 // CHECK-NEXT:    [[INC_I_I]] = add nuw nsw i64 [[I_0_I_I]], 1
 // CHECK-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP29:![0-9]+]]
-// CHECK:       _ZN4sycl3_V1plERKNS0_3vecIbLi4EEES4_.exit:
-// CHECK-NEXT:    store <4 x i8> [[VECINS_I_I6_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META26]]
+// CHECK:       _ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIbLi4EEEE4typeERKS5_S9_.exit:
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecIbLi4EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.6") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] !srcloc [[META25:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META26:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META26]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <4 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META26]]
-// CHECK-ARR-STORAGE-NEXT:    [[ADD_I:%.*]] = add <4 x i8> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    store <4 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META26]]
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I:%.*]], [[FOR_BODY_I_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = icmp ult i64 [[I_0_I_I]], 4
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIBLI4EEEE4TYPEERKS5_S9__EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP2:%.*]] = load i8, ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
-// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I_I:%.*]] = icmp ne i8 [[TMP2]], 0
-// CHECK-ARR-STORAGE-NEXT:    [[FROMBOOL_I_I:%.*]] = zext i1 [[TOBOOL_I_I]] to i8
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[FROMBOOL_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I_I]] = add nuw nsw i64 [[I_0_I_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP29:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIbLi4EEEE4typeERKS5_S9_.exit:
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_6detail9half_impl4halfELi3EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META31:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META31:![0-9]+]] !sycl_used_aspects [[META32:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META32:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I:%.*]] = load <4 x half>, ptr [[A]], align 8, !noalias [[META32]]
-// CHECK-NEXT:    [[LOADVEC42_I:%.*]] = load <4 x half>, ptr [[B]], align 8, !noalias [[META32]]
-// CHECK-NEXT:    [[TMP0:%.*]] = fadd <4 x half> [[LOADVEC4_I]], [[LOADVEC42_I]]
-// CHECK-NEXT:    [[EXTRACTVEC5_I:%.*]] = shufflevector <4 x half> [[TMP0]], <4 x half> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x half> [[EXTRACTVEC5_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META32]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META33:![0-9]+]])
+// CHECK-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x half>, ptr [[A]], align 2, !noalias [[META33]]
+// CHECK-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x half>, ptr [[B]], align 2, !noalias [[META33]]
+// CHECK-NEXT:    [[TMP0:%.*]] = fadd <4 x half> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
+// CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x half> [[TMP0]], <4 x half> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-NEXT:    store <4 x half> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META33]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_6detail9half_impl4halfELi3EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META31:![0-9]+]] !sycl_used_aspects [[META32:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META33:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x half>, ptr [[A]], align 2, !noalias [[META33]]
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x half>, ptr [[B]], align 2, !noalias [[META33]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = fadd <4 x half> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x half> [[TMP0]], <4 x half> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-ARR-STORAGE-NEXT:    store <4 x half> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META33]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.5") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.5") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.5") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] !srcloc [[META35:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] !srcloc [[META36:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
-// CHECK-NEXT:    [[REF_TMP1_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
-// CHECK-NEXT:    [[REF_TMP3_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META36:![0-9]+]])
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP3_I]])
-// CHECK-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
-// CHECK-NEXT:    [[REF_TMP3_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP3_I]] to ptr addrspace(4)
+// CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
+// CHECK-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
 // CHECK-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
-// CHECK-NEXT:    [[AGG_RESULT_PROMOTED_I:%.*]] = load <3 x i16>, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META36]]
-// CHECK-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x i16>, ptr [[A]], align 8, !noalias [[META39:![0-9]+]]
-// CHECK-NEXT:    [[EXTRACTVEC_I_I_I:%.*]] = shufflevector <4 x i16> [[LOADVEC4_I_I_I]], <4 x i16> poison, <3 x i32> <i32 0, i32 1, i32 2>
-// CHECK-NEXT:    [[LOADVEC4_I_I9_I:%.*]] = load <4 x i16>, ptr [[B]], align 8, !noalias [[META44:![0-9]+]]
-// CHECK-NEXT:    [[EXTRACTVEC_I_I10_I:%.*]] = shufflevector <4 x i16> [[LOADVEC4_I_I9_I]], <4 x i16> poison, <3 x i32> <i32 0, i32 1, i32 2>
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
-// CHECK-NEXT:    [[VECINS_I_I12_I:%.*]] = phi <3 x i16> [ [[AGG_RESULT_PROMOTED_I]], [[ENTRY:%.*]] ], [ [[VECINS_I_I_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY]] ], [ [[INC_I:%.*]], [[FOR_BODY_I]] ]
+// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
-// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI3EEES7__EXIT:%.*]]
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI3EEEE4TYPEERKS8_SC__EXIT:%.*]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META49:![0-9]+]])
-// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META50:![0-9]+]])
-// CHECK-NEXT:    [[VECEXT_I_I_I:%.*]] = extractelement <3 x i16> [[EXTRACTVEC_I_I_I]], i32 [[CONV_I]]
-// CHECK-NEXT:    store i16 [[VECEXT_I_I_I]], ptr [[REF_TMP1_I]], align 2, !alias.scope [[META51:![0-9]+]], !noalias [[META36]]
-// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META56:![0-9]+]])
-// CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata [[META57:![0-9]+]])
-// CHECK-NEXT:    [[VECEXT_I_I11_I:%.*]] = extractelement <3 x i16> [[EXTRACTVEC_I_I10_I]], i32 [[CONV_I]]
-// CHECK-NEXT:    store i16 [[VECEXT_I_I11_I]], ptr [[REF_TMP3_I]], align 2, !alias.scope [[META58:![0-9]+]], !noalias [[META36]]
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META36]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP1_ASCAST_I]]) #[[ATTR9:[0-9]+]], !noalias [[META63:![0-9]+]]
-// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP3_ASCAST_I]]) #[[ATTR9]], !noalias [[META63]]
+// CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8:[0-9]+]]
+// CHECK-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9:[0-9]+]], !noalias [[META40:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR9]], !noalias [[META40]]
 // CHECK-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
-// CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA66:![0-9]+]], !noalias [[META63]]
-// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META63]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META36]]
-// CHECK-NEXT:    [[VECINS_I_I_I]] = insertelement <3 x i16> [[VECINS_I_I12_I]], i16 [[CALL_I_I3_I_I]], i32 [[CONV_I]]
+// CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA43:![0-9]+]], !noalias [[META45:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META40]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37]]
+// CHECK-NEXT:    [[CALL4_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR8]]
+// CHECK-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[CALL4_I]], align 2, !tbaa [[TBAA46:![0-9]+]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP68:![0-9]+]]
-// CHECK:       _ZN4sycl3_V1plERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi3EEES7_.exit:
-// CHECK-NEXT:    store <3 x i16> [[VECINS_I_I12_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META36]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP1_I]])
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP3_I]])
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP48:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_.exit:
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] !srcloc [[META36:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
-// CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI3EEEE4TYPEERKS8_SC__EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8:[0-9]+]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]]
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37:![0-9]+]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9:[0-9]+]], !noalias [[META40:![0-9]+]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR9]], !noalias [[META40]]
-// CHECK-ARR-STORAGE-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA43:![0-9]+]], !noalias [[META45:![0-9]+]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META40]]
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL4_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR8]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[CALL4_I]], align 2, !tbaa [[TBAA46:![0-9]+]]
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP48:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_.exit:
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
                            vec<ext::oneapi::bfloat16, 3> b) {
@@ -261,104 +141,62 @@ SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
 /***************** Binary Logical Ops *******************/
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIiLi16EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.6") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 64 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META69:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META51:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META70:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 64, !tbaa [[TBAA10]], !noalias [[META70]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 64, !tbaa [[TBAA10]], !noalias [[META70]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META52:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META52]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 4, !tbaa [[TBAA10]], !noalias [[META52]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <16 x i32> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <16 x i1> [[CMP_I]] to <16 x i32>
-// CHECK-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, !tbaa [[TBAA10]], !alias.scope [[META70]]
+// CHECK-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, !tbaa [[TBAA10]], !alias.scope [[META52]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIiLi16EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META51:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META52:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META52]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 4, !tbaa [[TBAA10]], !noalias [[META52]]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp sgt <16 x i32> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <16 x i1> [[CMP_I]] to <16 x i32>
-// CHECK-ARR-STORAGE-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, !tbaa [[TBAA10]], !alias.scope [[META52]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
   return a > b;
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecISt4byteLi3EEES3_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.7") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META73:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META55:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META74:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I:%.*]] = load <4 x i8>, ptr [[A]], align 4, !noalias [[META74]]
-// CHECK-NEXT:    [[LOADVEC42_I:%.*]] = load <4 x i8>, ptr [[B]], align 4, !noalias [[META74]]
-// CHECK-NEXT:    [[TMP0:%.*]] = icmp sgt <4 x i8> [[LOADVEC4_I]], [[LOADVEC42_I]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META56:![0-9]+]])
+// CHECK-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1, !noalias [[META56]]
+// CHECK-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x i8>, ptr [[B]], align 1, !noalias [[META56]]
+// CHECK-NEXT:    [[TMP0:%.*]] = icmp ugt <4 x i8> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = shufflevector <4 x i1> [[TMP0]], <4 x i1> poison, <3 x i32> <i32 0, i32 1, i32 2>
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i8>
 // CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META74]]
+// CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META56]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecISt4byteLi3EEES3_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META55:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META56:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1, !noalias [[META56]]
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x i8>, ptr [[B]], align 1, !noalias [[META56]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = icmp ugt <4 x i8> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = shufflevector <4 x i1> [[TMP0]], <4 x i1> poison, <3 x i32> <i32 0, i32 1, i32 2>
-// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i8>
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-ARR-STORAGE-NEXT:    store <4 x i8> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META56]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
   return a > b;
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIbLi2EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.9") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.10") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.10") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META77:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META59:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META78:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META78]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META78]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META60:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META60]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META60]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
-// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META78]]
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META60]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIbLi2EEES2_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META59:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META60:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META60]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META60]]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
-// CHECK-ARR-STORAGE-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META60]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
   return a > b;
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.11") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META81:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META63:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META82:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META82]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 16, !tbaa [[TBAA10]], !noalias [[META82]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META64:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META64]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META64]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp ogt <8 x half> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <8 x i1> [[CMP_I]] to <8 x i16>
-// CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META82]]
+// CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META64]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META63:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META64:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META64]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META64]]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = fcmp ogt <8 x half> [[TMP0]], [[TMP1]]
-// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <8 x i1> [[CMP_I]] to <8 x i16>
-// CHECK-ARR-STORAGE-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META64]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
   return a > b;
@@ -368,41 +206,31 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 // For example, vec<BF16, 2>{-0.5, 3.333} < vec<BF16, 2>{6.0, 6.666} results
 // into {-1, -1} on host but {0, -1} on device.
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.13") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.14") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.14") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META85:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.24") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META67:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META86:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i16>, ptr [[A]], align 8, !tbaa [[TBAA10]], !noalias [[META86]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i16>, ptr [[B]], align 8, !tbaa [[TBAA10]], !noalias [[META86]]
-// CHECK-NEXT:    [[CMP_I:%.*]] = icmp ugt <4 x i16> [[TMP0]], [[TMP1]]
-// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <4 x i1> [[CMP_I]] to <4 x i16>
-// CHECK-NEXT:    store <4 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META86]]
+// CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
+// CHECK-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META68:![0-9]+]])
+// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META68]]
+// CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK:       for.cond.i:
+// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTINS0_3EXT6ONEAPI8BFLOAT16EEENS0_3VECISLI4EEERKNS5_IS4_LI4EEES9__EXIT:%.*]]
+// CHECK:       for.body.i:
+// CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
+// CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META68]]
+// CHECK-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META68]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], !noalias [[META68]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR9]], !noalias [[META68]]
+// CHECK-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
+// CHECK-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
+// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META68]]
+// CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP71:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_.exit:
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEES5_(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.24") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META67:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META68:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META68]]
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTINS0_3EXT6ONEAPI8BFLOAT16EEENS0_3VECISLI4EEERKNS5_IS4_LI4EEES9__EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META68]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META68]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], !noalias [[META68]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR9]], !noalias [[META68]]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META68]]
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP71:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_.exit:
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
                                    vec<ext::oneapi::bfloat16, 4> b) {
@@ -412,271 +240,153 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
 /********************** Unary Ops **********************/
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIiLi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.15") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META89:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.27") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.27") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META72:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META90:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I:%.*]] = load <4 x i32>, ptr [[A]], align 16, !noalias [[META90]]
-// CHECK-NEXT:    [[EXTRACTVEC_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
-// CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I]], zeroinitializer
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META73:![0-9]+]])
+// CHECK-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 4, !noalias [[META73]]
+// CHECK-NEXT:    [[EXTRACTVEC_I_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I_I]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i32>
 // CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !alias.scope [[META90]]
+// CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META73]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIiLi3EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.27") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.27") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META72:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META73:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 4, !noalias [[META73]]
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I_I]], zeroinitializer
-// CHECK-ARR-STORAGE-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i32>
-// CHECK-ARR-STORAGE-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-ARR-STORAGE-NEXT:    store <4 x i32> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META73]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecIiLi4EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.16") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.16") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META93:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META76:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META94:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META94]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META77:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META77]]
 // CHECK-NEXT:    [[SUB_I:%.*]] = sub <4 x i32> zeroinitializer, [[TMP0]]
-// CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META94]]
+// CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META77]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecIiLi4EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META76:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META77:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META77]]
-// CHECK-ARR-STORAGE-NEXT:    [[SUB_I:%.*]] = sub <4 x i32> zeroinitializer, [[TMP0]]
-// CHECK-ARR-STORAGE-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META77]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
 
 // Negation is not valid for std::byte. Therefore, using bitwise negation.
 // CHECK-LABEL: define dso_local spir_func void @_Z19TestBitwiseNegationN4sycl3_V13vecISt4byteLi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.17") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META97:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.30") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.30") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META80:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META98:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META98]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META81:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META81]]
 // CHECK-NEXT:    [[NOT_I:%.*]] = xor <16 x i8> [[TMP0]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
-// CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META98]]
+// CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META81]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z19TestBitwiseNegationN4sycl3_V13vecISt4byteLi16EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.30") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.30") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META80:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META81:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META81]]
-// CHECK-ARR-STORAGE-NEXT:    [[NOT_I:%.*]] = xor <16 x i8> [[TMP0]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
-// CHECK-ARR-STORAGE-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META81]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.18") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.3") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META101:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META84:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META102:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META102]]
-// CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <4 x i8> [[TMP0]], zeroinitializer
-// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <4 x i1> [[CMP_I]] to <4 x i8>
-// CHECK-NEXT:    store <4 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META105:![0-9]+]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META85:![0-9]+]])
+// CHECK-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META85]]
+// CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK:       for.cond.i:
+// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIALI4EEEE4TYPEERKNS4_IBLI4EEE_EXIT:%.*]]
+// CHECK:       for.body.i:
+// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[I_0_I]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I]], align 1, !tbaa [[TBAA88:![0-9]+]], !range [[RNG90:![0-9]+]], !noalias [[META85]], !noundef [[META6]]
+// CHECK-NEXT:    [[DOTNEG_I:%.*]] = add nsw i8 [[TMP0]], -1
+// CHECK-NEXT:    [[ARRAYIDX_I9_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-NEXT:    store i8 [[DOTNEG_I]], ptr addrspace(4) [[ARRAYIDX_I9_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META85]]
+// CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP91:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1ntIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIaLi4EEEE4typeERKNS4_IbLi4EEE.exit:
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META84:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META85:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META85]]
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIALI4EEEE4TYPEERKNS4_IBLI4EEE_EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I]], align 1, !tbaa [[TBAA88:![0-9]+]], !range [[RNG90:![0-9]+]], !noalias [[META85]], !noundef [[META6]]
-// CHECK-ARR-STORAGE-NEXT:    [[DOTNEG_I:%.*]] = add nsw i8 [[TMP0]], -1
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I9_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i8 [[DOTNEG_I]], ptr addrspace(4) [[ARRAYIDX_I9_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META85]]
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP91:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIaLi4EEEE4typeERKNS4_IbLi4EEE.exit:
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.19") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.20") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META108:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META92:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META109:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META109]]
-// CHECK-NEXT:    [[CMP_I:%.*]] = fcmp oeq <2 x half> [[TMP0]], zeroinitializer
-// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
-// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META112:![0-9]+]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META93:![0-9]+]])
+// CHECK-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META93]]
+// CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
+// CHECK:       for.cond.i:
+// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_6DETAIL9HALF_IMPL4HALFEEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI2EEEE4TYPEERKNS7_IS4_LI2EEE_EXIT:%.*]]
+// CHECK:       for.body.i:
+// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::detail::half_impl::half", ptr [[A]], i64 [[I_0_I]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA96:![0-9]+]], !noalias [[META93]]
+// CHECK-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq half [[TMP0]], 0xH0000
+// CHECK-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
+// CHECK-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I10_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META93]]
+// CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP99:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1ntINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi2EEEE4typeERKNS7_IS4_Li2EEE.exit:
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META92:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META93:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META93]]
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_6DETAIL9HALF_IMPL4HALFEEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI2EEEE4TYPEERKNS7_IS4_LI2EEE_EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::detail::half_impl::half", ptr [[A]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA96:![0-9]+]], !noalias [[META93]]
-// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq half [[TMP0]], 0xH0000
-// CHECK-ARR-STORAGE-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I10_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META93]]
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP99:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi2EEEE4typeERKNS7_IS4_Li2EEE.exit:
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META115:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META100:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META116:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META116]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META101:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META101]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg <8 x half> [[TMP0]]
-// CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META116]]
+// CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META101]]
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META100:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META101:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META101]]
-// CHECK-ARR-STORAGE-NEXT:    [[FNEG_I:%.*]] = fneg <8 x half> [[TMP0]]
-// CHECK-ARR-STORAGE-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META101]]
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.21") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.5") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META119:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META104:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[REF_TMP1_I:%.*]] = alloca float, align 4
-// CHECK-NEXT:    [[REF_TMP2_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META120:![0-9]+]])
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP1_I]])
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[REF_TMP2_I]])
-// CHECK-NEXT:    [[REF_TMP1_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP1_I]] to ptr addrspace(4)
-// CHECK-NEXT:    [[REF_TMP2_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP2_I]] to ptr addrspace(4)
-// CHECK-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x i16>, ptr [[A]], align 8, !noalias [[META123:![0-9]+]]
-// CHECK-NEXT:    [[EXTRACTVEC_I_I_I:%.*]] = shufflevector <4 x i16> [[LOADVEC4_I_I_I]], <4 x i16> poison, <3 x i32> <i32 0, i32 1, i32 2>
+// CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META105:![0-9]+]])
+// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META105]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
-// CHECK-NEXT:    [[RET_SROA_0_0_I:%.*]] = phi <3 x i16> [ zeroinitializer, [[ENTRY:%.*]] ], [ [[VECINS_I_I_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY]] ], [ [[INC_I:%.*]], [[FOR_BODY_I]] ]
+// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
-// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTERKNS0_3VECINS0_3EXT6ONEAPI8BFLOAT16ELI3EEE_EXIT:%.*]]
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-NEXT:    [[VECEXT_I_I_I:%.*]] = extractelement <3 x i16> [[EXTRACTVEC_I_I_I]], i32 [[CONV_I]]
-// CHECK-NEXT:    store i16 [[VECEXT_I_I_I]], ptr [[REF_TMP2_I]], align 2, !tbaa [[TBAA128:![0-9]+]], !alias.scope [[META130:![0-9]+]], !noalias [[META120]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[REF_TMP2_ASCAST_I]]) #[[ATTR9]], !noalias [[META120]]
-// CHECK-NEXT:    [[CMP_I_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
-// CHECK-NEXT:    [[CONV4_I:%.*]] = uitofp i1 [[CMP_I_I]] to float
-// CHECK-NEXT:    store float [[CONV4_I]], ptr [[REF_TMP1_I]], align 4, !tbaa [[TBAA66]], !noalias [[META120]]
-// CHECK-NEXT:    [[CALL_I_I9_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP1_ASCAST_I]]) #[[ATTR9]], !noalias [[META120]]
-// CHECK-NEXT:    [[VECINS_I_I_I]] = insertelement <3 x i16> [[RET_SROA_0_0_I]], i16 [[CALL_I_I9_I]], i32 [[CONV_I]]
+// CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META105]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], !noalias [[META105]]
+// CHECK-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
+// CHECK-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
+// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META105]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP133:![0-9]+]]
-// CHECK:       _ZN4sycl3_V1ntERKNS0_3vecINS0_3ext6oneapi8bfloat16ELi3EEE.exit:
-// CHECK-NEXT:    store <3 x i16> [[RET_SROA_0_0_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META134:![0-9]+]]
-// CHECK-NEXT:    [[AGG_RESULT_SROA_IDX_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 6
-// CHECK-NEXT:    store i16 0, ptr addrspace(4) [[AGG_RESULT_SROA_IDX_I]], align 2, !alias.scope [[META134]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP1_I]])
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 2, ptr nonnull [[REF_TMP2_I]])
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP108:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
 // CHECK-NEXT:    ret void
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META104:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META105:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META105]]
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META105]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], !noalias [[META105]]
-// CHECK-ARR-STORAGE-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
-// CHECK-ARR-STORAGE-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
-// CHECK-ARR-STORAGE-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META105]]
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP108:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
-// CHECK-ARR-STORAGE-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 32 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR5:[0-9]+]] !srcloc [[META137:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META109:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
-// CHECK-NEXT:    [[V_I:%.*]] = alloca %"class.sycl::_V1::ext::oneapi::bfloat16", align 2
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META138:![0-9]+]])
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 2, ptr nonnull [[V_I]])
-// CHECK-NEXT:    [[V_ASCAST_I:%.*]] = addrspacecast ptr [[V_I]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META138]]
-// CHECK-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
+// CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META110:![0-9]+]])
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]])
+// CHECK-NEXT:    [[REF_TMP_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP_I]] to ptr addrspace(4)
+// CHECK-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META110]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
-// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_COND_I]] ]
+// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 16
-// CHECK-NEXT:    call void @llvm.assume(i1 [[CMP_I]])
-// CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds <16 x i16>, ptr [[A]], i64 0, i64 [[I_0_I]]
-// CHECK-NEXT:    [[VECEXT_I:%.*]] = load i16, ptr [[TMP0]], align 2, !noalias [[META138]]
-// CHECK-NEXT:    store i16 [[VECEXT_I]], ptr [[V_I]], align 2, !tbaa [[TBAA141:![0-9]+]], !alias.scope [[META143:![0-9]+]], !noalias [[META138]]
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META138]]
-// CHECK-NEXT:    [[CALL_I_I:%.*]] = call spir_func float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[V_ASCAST_I]]) #[[ATTR9]], !noalias [[META146:![0-9]+]]
-// CHECK-NEXT:    [[FNEG_I_I:%.*]] = fneg float [[CALL_I_I]]
-// CHECK-NEXT:    store float [[FNEG_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA66]], !noalias [[META146]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META146]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META138]]
-// CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds <16 x i16>, ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CALL_I_I_I_I]], ptr addrspace(4) [[TMP1]], align 2, !alias.scope [[META138]]
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI16EEEE4TYPEERKS8__EXIT:%.*]]
+// CHECK:       for.body.i:
+// CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
+// CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]]
+// CHECK-NEXT:    [[FNEG_I:%.*]] = fneg float [[CALL_I_I_I]]
+// CHECK-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA43]], !noalias [[META110]]
+// CHECK-NEXT:    [[CALL3_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR8]]
+// CHECK-NEXT:    [[CALL_I_I8_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR9]]
+// CHECK-NEXT:    store i16 [[CALL_I_I8_I]], ptr addrspace(4) [[CALL3_I]], align 2, !tbaa [[TBAA113:![0-9]+]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP157:![0-9]+]]
-// CHECK-ARR-STORAGE-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
-// CHECK-ARR-STORAGE-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META109:![0-9]+]] !sycl_fixed_targets [[META6]] {
-// CHECK-ARR-STORAGE-NEXT:  entry:
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_I:%.*]] = alloca float, align 4
-// CHECK-ARR-STORAGE-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META110:![0-9]+]])
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]])
-// CHECK-ARR-STORAGE-NEXT:    [[REF_TMP_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP_I]] to ptr addrspace(4)
-// CHECK-ARR-STORAGE-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META110]]
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK-ARR-STORAGE:       for.cond.i:
-// CHECK-ARR-STORAGE-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-ARR-STORAGE-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 16
-// CHECK-ARR-STORAGE-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI16EEEE4TYPEERKS8__EXIT:%.*]]
-// CHECK-ARR-STORAGE:       for.body.i:
-// CHECK-ARR-STORAGE-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]]
-// CHECK-ARR-STORAGE-NEXT:    [[FNEG_I:%.*]] = fneg float [[CALL_I_I_I]]
-// CHECK-ARR-STORAGE-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA43]], !noalias [[META110]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL3_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR8]]
-// CHECK-ARR-STORAGE-NEXT:    [[CALL_I_I8_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR9]]
-// CHECK-ARR-STORAGE-NEXT:    store i16 [[CALL_I_I8_I]], ptr addrspace(4) [[CALL3_I]], align 2, !tbaa [[TBAA113:![0-9]+]]
-// CHECK-ARR-STORAGE-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-ARR-STORAGE-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP115:![0-9]+]]
-// CHECK-ARR-STORAGE:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:
-// CHECK-ARR-STORAGE-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
-// CHECK-ARR-STORAGE-NEXT:    ret void
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP115:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
+// CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<ext::oneapi::bfloat16, 16> a) { return -a; }

From a953f6a47d8e4f37dc7e4dc8c48dbef567c19935 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 17 May 2024 08:37:27 -0700
Subject: [PATCH 68/79] Fix tests

---
 sycl/include/sycl/vector_preview.hpp          |  7 +-
 .../vector/vector_math_ops.cpp                | 79 +++++++------------
 2 files changed, 31 insertions(+), 55 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index e476797701a64..48e16074ad036 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -903,11 +903,10 @@ template <typename DataT, int NumElements> class vec {
                                    vec<detail::rel_t<DataT>, NumElements>>
   operator!(const vec &Rhs) {
 #ifdef __SYCL_DEVICE_ONLY__
-    if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16> &&
-                  !std::is_same_v<DataT, sycl::detail::half_impl::half> &&
-                  !std::is_same_v<DataT, bool>) {
+    if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>) {
       auto extVec = static_cast<vector_t>(Rhs);
-      return vec<detail::rel_t<DataT>, NumElements>{!extVec};
+      vec<detail::rel_t<DataT>, NumElements> Ret{(typename vec<rel_t, NumElements>::vector_t)!extVec};
+      return Ret;
     } else
 #endif // __SYCL_DEVICE_ONLY__
     {
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 7259a4b0687a5..9d92d140863b2 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -277,69 +277,46 @@ SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
 SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META84:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META84:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META85:![0-9]+]])
-// CHECK-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META85]]
-// CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK:       for.cond.i:
-// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
-// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIALI4EEEE4TYPEERKNS4_IBLI4EEE_EXIT:%.*]]
-// CHECK:       for.body.i:
-// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8, ptr [[ARRAYIDX_I_I]], align 1, !tbaa [[TBAA88:![0-9]+]], !range [[RNG90:![0-9]+]], !noalias [[META85]], !noundef [[META6]]
-// CHECK-NEXT:    [[DOTNEG_I:%.*]] = add nsw i8 [[TMP0]], -1
-// CHECK-NEXT:    [[ARRAYIDX_I9_I:%.*]] = getelementptr inbounds i8, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i8 [[DOTNEG_I]], ptr addrspace(4) [[ARRAYIDX_I9_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META85]]
-// CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP91:![0-9]+]]
-// CHECK:       _ZN4sycl3_V1ntIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIaLi4EEEE4typeERKNS4_IbLi4EEE.exit:
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META85]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <4 x i8> [[TMP0]], zeroinitializer
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <4 x i1> [[CMP_I]] to <4 x i8>
+// CHECK-NEXT:    store <4 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META85]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] !srcloc [[META92:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META88:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META93:![0-9]+]])
-// CHECK-NEXT:    store i32 0, ptr addrspace(4) [[AGG_RESULT]], align 4, !alias.scope [[META93]]
-// CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
-// CHECK:       for.cond.i:
-// CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
-// CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 2
-// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_6DETAIL9HALF_IMPL4HALFEEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI2EEEE4TYPEERKNS7_IS4_LI2EEE_EXIT:%.*]]
-// CHECK:       for.body.i:
-// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::detail::half_impl::half", ptr [[A]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[TMP0:%.*]] = load half, ptr [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA96:![0-9]+]], !noalias [[META93]]
-// CHECK-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq half [[TMP0]], 0xH0000
-// CHECK-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
-// CHECK-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I10_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META93]]
-// CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP99:![0-9]+]]
-// CHECK:       _ZN4sycl3_V1ntINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi2EEEE4typeERKNS7_IS4_Li2EEE.exit:
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META89:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META89]]
+// CHECK-NEXT:    [[CMP_I:%.*]] = fcmp oeq <2 x half> [[TMP0]], zeroinitializer
+// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
+// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META89]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META100:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META92:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META101:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META101]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META93:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META93]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg <8 x half> [[TMP0]]
-// CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META101]]
+// CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META93]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META104:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META96:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META105:![0-9]+]])
-// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META105]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META97:![0-9]+]])
+// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META97]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -347,28 +324,28 @@ SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META105]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], !noalias [[META105]]
+// CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META97]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], !noalias [[META97]]
 // CHECK-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
 // CHECK-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
 // CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META105]]
+// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META97]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP108:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP100:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META109:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META101:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca float, align 4
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META110:![0-9]+]])
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META102:![0-9]+]])
 // CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    [[REF_TMP_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP_I]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META110]]
+// CHECK-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META102]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -379,12 +356,12 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]]
 // CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg float [[CALL_I_I_I]]
-// CHECK-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA43]], !noalias [[META110]]
+// CHECK-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA43]], !noalias [[META102]]
 // CHECK-NEXT:    [[CALL3_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR8]]
 // CHECK-NEXT:    [[CALL_I_I8_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR9]]
-// CHECK-NEXT:    store i16 [[CALL_I_I8_I]], ptr addrspace(4) [[CALL3_I]], align 2, !tbaa [[TBAA113:![0-9]+]]
+// CHECK-NEXT:    store i16 [[CALL_I_I8_I]], ptr addrspace(4) [[CALL3_I]], align 2, !tbaa [[TBAA105:![0-9]+]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP115:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP107:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void

From d41f74734987c2f50362a1eb1bf2718294eec2d7 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Mon, 20 May 2024 13:45:33 -0700
Subject: [PATCH 69/79] Replace static_cast<vector_t> with sycl::bit_cast

---
 sycl/include/sycl/vector_preview.hpp          |  18 +-
 .../vector/vector_math_ops.cpp                | 185 ++++++++++++++----
 2 files changed, 153 insertions(+), 50 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 48e16074ad036..7baa7919a6a64 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -447,7 +447,7 @@ template <typename DataT, int NumElements> class vec {
       using OpenCLVecT = OpenCLT __attribute__((ext_vector_type(NumElements)));
       using OpenCLVecR = OpenCLR __attribute__((ext_vector_type(NumElements)));
 
-      auto NativeVector = static_cast<vector_t>(*this);
+      auto NativeVector = sycl::bit_cast<vector_t>(*this);
       using ConvertTVecType = typename vec<convertT, NumElements>::vector_t;
 
       // Whole vector conversion can only be done, if:
@@ -670,8 +670,8 @@ template <typename DataT, int NumElements> class vec {
         Ret[I] = Lhs[I] BINOP Rhs[I];                                          \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = static_cast<vector_t>(Lhs);                         \
-      vector_t ExtVecRhs = static_cast<vector_t>(Rhs);                         \
+      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs);                         \
+      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs);                         \
       Ret = vec<DataT, NumElements>(                                           \
           (typename vec<DataT, NumElements>::vector_t)(                        \
               ExtVecLhs BINOP ExtVecRhs));                                     \
@@ -802,8 +802,8 @@ template <typename DataT, int NumElements> class vec {
         Ret[I] = static_cast<rel_t>(-(Lhs[I] RELLOGOP Rhs[I]));                \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = static_cast<vector_t>(Lhs);                         \
-      vector_t ExtVecRhs = static_cast<vector_t>(Rhs);                         \
+      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs);                         \
+      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs);                         \
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
               ExtVecLhs RELLOGOP ExtVecRhs));                                  \
@@ -882,7 +882,7 @@ template <typename DataT, int NumElements> class vec {
   friend typename std::enable_if_t<!detail::is_vgenfloat_v<T>, vec>
   operator~(const vec &Rhs) {
 #ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = static_cast<vector_t>(Rhs);
+    auto extVec = sycl::bit_cast<vector_t>(Rhs);
     vec Ret{~extVec};
     if constexpr (std::is_same_v<DataT, bool>) {
       Ret.ConvertToDataT();
@@ -904,7 +904,7 @@ template <typename DataT, int NumElements> class vec {
   operator!(const vec &Rhs) {
 #ifdef __SYCL_DEVICE_ONLY__
     if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>) {
-      auto extVec = static_cast<vector_t>(Rhs);
+      auto extVec = sycl::bit_cast<vector_t>(Rhs);
       vec<detail::rel_t<DataT>, NumElements> Ret{(typename vec<rel_t, NumElements>::vector_t)!extVec};
       return Ret;
     } else
@@ -925,7 +925,7 @@ template <typename DataT, int NumElements> class vec {
   friend typename std::enable_if_t<(!IsByte<T>::value), vec>
   operator+(const vec &Lhs) {
 #ifdef __SYCL_DEVICE_ONLY__
-    auto extVec = static_cast<vector_t>(Lhs);
+    auto extVec = sycl::bit_cast<vector_t>(Lhs);
     return vec{+extVec};
 #else
     vec Ret{};
@@ -949,7 +949,7 @@ template <typename DataT, int NumElements> class vec {
       for (size_t I = 0; I < NumElements; ++I)
         Ret[I] = -Lhs[I];
 #else
-      auto extVec = static_cast<vector_t>(Lhs);
+      auto extVec = sycl::bit_cast<vector_t>(Lhs);
       Ret = vec{-extVec};
       if constexpr (std::is_same_v<DataT, bool>) {
         Ret.ConvertToDataT();
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 9d92d140863b2..67f6f8eb85cad 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -16,8 +16,8 @@ using namespace sycl;
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] !srcloc [[META5:![0-9]+]] !sycl_fixed_targets [[META6:![0-9]+]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META7:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10:![0-9]+]], !noalias [[META7]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[B]], align 4, !tbaa [[TBAA10]], !noalias [[META7]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i32>, ptr [[A]], align 8, !tbaa [[TBAA10:![0-9]+]], !noalias [[META7]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i32>, ptr [[B]], align 8, !tbaa [[TBAA10]], !noalias [[META7]]
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <2 x i32> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    store <2 x i32> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META7]]
 // CHECK-NEXT:    ret void
@@ -28,11 +28,11 @@ SYCL_EXTERNAL auto TestAdd(vec<int, 2> a, vec<int, 2> b) { return a + b; }
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.0") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.0") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META13:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META14:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x float>, ptr [[A]], align 4, !noalias [[META14]]
-// CHECK-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x float>, ptr [[B]], align 4, !noalias [[META14]]
-// CHECK-NEXT:    [[TMP0:%.*]] = fadd <4 x float> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
-// CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x float> [[TMP0]], <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x float> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META14]]
+// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x float>, ptr [[A]], align 16, !noalias [[META14]]
+// CHECK-NEXT:    [[LOADVEC4_I6_I:%.*]] = load <4 x float>, ptr [[B]], align 16, !noalias [[META14]]
+// CHECK-NEXT:    [[TMP0:%.*]] = fadd <4 x float> [[LOADVEC4_I_I]], [[LOADVEC4_I6_I]]
+// CHECK-NEXT:    [[EXTRACTVEC_I8_I:%.*]] = shufflevector <4 x float> [[TMP0]], <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-NEXT:    store <4 x float> [[EXTRACTVEC_I8_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META14]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<float, 3> a, vec<float, 3> b) { return a + b; }
@@ -41,8 +41,8 @@ SYCL_EXTERNAL auto TestAdd(vec<float, 3> a, vec<float, 3> b) { return a + b; }
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.2") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.2") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META17:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META18:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META18]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META18]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META18]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i8>, ptr [[B]], align 16, !tbaa [[TBAA10]], !noalias [[META18]]
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <16 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    store <16 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META18]]
 // CHECK-NEXT:    ret void
@@ -54,8 +54,8 @@ SYCL_EXTERNAL auto TestAdd(vec<char, 16> a, vec<char, 16> b) { return a + b; }
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.4") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.4") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META21:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META22:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META22]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META22]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x i8>, ptr [[A]], align 8, !tbaa [[TBAA10]], !noalias [[META22]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x i8>, ptr [[B]], align 8, !tbaa [[TBAA10]], !noalias [[META22]]
 // CHECK-NEXT:    [[XOR_I:%.*]] = xor <8 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    store <8 x i8> [[XOR_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META22]]
 // CHECK-NEXT:    ret void
@@ -68,8 +68,8 @@ SYCL_EXTERNAL auto TestXor(vec<std::byte, 8> a, vec<std::byte, 8> b) {
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable sret(%"class.sycl::_V1::vec.6") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] !srcloc [[META25:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META26:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META26]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META26]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META26]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i8>, ptr [[B]], align 4, !tbaa [[TBAA10]], !noalias [[META26]]
 // CHECK-NEXT:    [[ADD_I:%.*]] = add <4 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    store <4 x i8> [[ADD_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META26]]
 // CHECK-NEXT:    br label [[FOR_COND_I_I:%.*]]
@@ -94,11 +94,11 @@ SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META31:![0-9]+]] !sycl_used_aspects [[META32:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META33:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x half>, ptr [[A]], align 2, !noalias [[META33]]
-// CHECK-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x half>, ptr [[B]], align 2, !noalias [[META33]]
-// CHECK-NEXT:    [[TMP0:%.*]] = fadd <4 x half> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
-// CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x half> [[TMP0]], <4 x half> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x half> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META33]]
+// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x half>, ptr [[A]], align 8, !noalias [[META33]]
+// CHECK-NEXT:    [[LOADVEC4_I6_I:%.*]] = load <4 x half>, ptr [[B]], align 8, !noalias [[META33]]
+// CHECK-NEXT:    [[TMP0:%.*]] = fadd <4 x half> [[LOADVEC4_I_I]], [[LOADVEC4_I6_I]]
+// CHECK-NEXT:    [[EXTRACTVEC_I8_I:%.*]] = shufflevector <4 x half> [[TMP0]], <4 x half> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-NEXT:    store <4 x half> [[EXTRACTVEC_I8_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META33]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
@@ -144,8 +144,8 @@ SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META51:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META52:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META52]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 4, !tbaa [[TBAA10]], !noalias [[META52]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 64, !tbaa [[TBAA10]], !noalias [[META52]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 64, !tbaa [[TBAA10]], !noalias [[META52]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <16 x i32> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <16 x i1> [[CMP_I]] to <16 x i32>
 // CHECK-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, !tbaa [[TBAA10]], !alias.scope [[META52]]
@@ -159,13 +159,13 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META55:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META56:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1, !noalias [[META56]]
-// CHECK-NEXT:    [[LOADVEC4_I_I6_I:%.*]] = load <4 x i8>, ptr [[B]], align 1, !noalias [[META56]]
-// CHECK-NEXT:    [[TMP0:%.*]] = icmp ugt <4 x i8> [[LOADVEC4_I_I_I]], [[LOADVEC4_I_I6_I]]
+// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 4, !noalias [[META56]]
+// CHECK-NEXT:    [[LOADVEC4_I6_I:%.*]] = load <4 x i8>, ptr [[B]], align 4, !noalias [[META56]]
+// CHECK-NEXT:    [[TMP0:%.*]] = icmp ugt <4 x i8> [[LOADVEC4_I_I]], [[LOADVEC4_I6_I]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = shufflevector <4 x i1> [[TMP0]], <4 x i1> poison, <3 x i32> <i32 0, i32 1, i32 2>
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i8>
-// CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META56]]
+// CHECK-NEXT:    [[EXTRACTVEC_I8_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I8_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META56]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
@@ -176,8 +176,8 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META59:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META60:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META60]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 1, !tbaa [[TBAA10]], !noalias [[META60]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META60]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META60]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
 // CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META60]]
@@ -188,11 +188,11 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META63:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META63:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META64:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META64]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META64]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META64]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 16, !tbaa [[TBAA10]], !noalias [[META64]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp ogt <8 x half> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <8 x i1> [[CMP_I]] to <8 x i16>
 // CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META64]]
@@ -243,12 +243,12 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.27") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.27") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META72:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META73:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 4, !noalias [[META73]]
-// CHECK-NEXT:    [[EXTRACTVEC_I_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
-// CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I_I]], zeroinitializer
+// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 16, !noalias [[META73]]
+// CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
+// CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i32>
-// CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META73]]
+// CHECK-NEXT:    [[EXTRACTVEC_I2_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
+// CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META73]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
@@ -257,7 +257,7 @@ SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META76:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META77:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META77]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META77]]
 // CHECK-NEXT:    [[SUB_I:%.*]] = sub <4 x i32> zeroinitializer, [[TMP0]]
 // CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META77]]
 // CHECK-NEXT:    ret void
@@ -269,7 +269,7 @@ SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.30") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.30") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META80:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META81:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META81]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META81]]
 // CHECK-NEXT:    [[NOT_I:%.*]] = xor <16 x i8> [[TMP0]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 // CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META81]]
 // CHECK-NEXT:    ret void
@@ -280,7 +280,7 @@ SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META84:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META85:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 1, !tbaa [[TBAA10]], !noalias [[META85]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META85]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <4 x i8> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <4 x i1> [[CMP_I]] to <4 x i8>
 // CHECK-NEXT:    store <4 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META85]]
@@ -289,10 +289,10 @@ SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META88:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META88:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META89:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META89]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META89]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp oeq <2 x half> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
 // CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META89]]
@@ -304,7 +304,7 @@ SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 // CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META92:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META93:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META93]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META93]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg <8 x half> [[TMP0]]
 // CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META93]]
 // CHECK-NEXT:    ret void
@@ -367,3 +367,106 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<ext::oneapi::bfloat16, 16> a) { return -a; }
+//.
+// CHECK: [[META5]] = !{i32 1704}
+// CHECK: [[META6]] = !{}
+// CHECK: [[META7]] = !{[[META8:![0-9]+]]}
+// CHECK: [[META8]] = distinct !{[[META8]], [[META9:![0-9]+]], !"_ZN4sycl3_V1plIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi2EEEE4typeERKS5_S9_: %agg.result"}
+// CHECK: [[META9]] = distinct !{[[META9]], !"_ZN4sycl3_V1plIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi2EEEE4typeERKS5_S9_"}
+// CHECK: [[TBAA10]] = !{[[META11:![0-9]+]], [[META11]], i64 0}
+// CHECK: [[META11]] = !{!"omnipotent char", [[META12:![0-9]+]], i64 0}
+// CHECK: [[META12]] = !{!"Simple C++ TBAA"}
+// CHECK: [[META13]] = !{i32 2998}
+// CHECK: [[META14]] = !{[[META15:![0-9]+]]}
+// CHECK: [[META15]] = distinct !{[[META15]], [[META16:![0-9]+]], !"_ZN4sycl3_V1plIfEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIfLi3EEEE4typeERKS5_S9_: %agg.result"}
+// CHECK: [[META16]] = distinct !{[[META16]], !"_ZN4sycl3_V1plIfEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIfLi3EEEE4typeERKS5_S9_"}
+// CHECK: [[META17]] = !{i32 4131}
+// CHECK: [[META18]] = !{[[META19:![0-9]+]]}
+// CHECK: [[META19]] = distinct !{[[META19]], [[META20:![0-9]+]], !"_ZN4sycl3_V1plIcEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIcLi16EEEE4typeERKS5_S9_: %agg.result"}
+// CHECK: [[META20]] = distinct !{[[META20]], !"_ZN4sycl3_V1plIcEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIcLi16EEEE4typeERKS5_S9_"}
+// CHECK: [[META21]] = !{i32 5342}
+// CHECK: [[META22]] = !{[[META23:![0-9]+]]}
+// CHECK: [[META23]] = distinct !{[[META23]], [[META24:![0-9]+]], !"_ZN4sycl3_V1eoISt4byteEENSt9enable_ifIXntsr6detailE14is_vgenfloat_vIT_EENS0_3vecIS2_Li8EEEE4typeERKS6_SA_: %agg.result"}
+// CHECK: [[META24]] = distinct !{[[META24]], !"_ZN4sycl3_V1eoISt4byteEENSt9enable_ifIXntsr6detailE14is_vgenfloat_vIT_EENS0_3vecIS2_Li8EEEE4typeERKS6_SA_"}
+// CHECK: [[META25]] = !{i32 7708}
+// CHECK: [[META26]] = !{[[META27:![0-9]+]]}
+// CHECK: [[META27]] = distinct !{[[META27]], [[META28:![0-9]+]], !"_ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIbLi4EEEE4typeERKS5_S9_: %agg.result"}
+// CHECK: [[META28]] = distinct !{[[META28]], !"_ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIbLi4EEEE4typeERKS5_S9_"}
+// CHECK: [[LOOP29]] = distinct !{[[LOOP29]], [[META30:![0-9]+]]}
+// CHECK: [[META30]] = !{!"llvm.loop.mustprogress"}
+// CHECK: [[META31]] = !{i32 9058}
+// CHECK: [[META32]] = !{i32 5}
+// CHECK: [[META33]] = !{[[META34:![0-9]+]]}
+// CHECK: [[META34]] = distinct !{[[META34]], [[META35:![0-9]+]], !"_ZN4sycl3_V1plINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_: %agg.result"}
+// CHECK: [[META35]] = distinct !{[[META35]], !"_ZN4sycl3_V1plINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_"}
+// CHECK: [[META36]] = !{i32 12920}
+// CHECK: [[META37]] = !{[[META38:![0-9]+]]}
+// CHECK: [[META38]] = distinct !{[[META38]], [[META39:![0-9]+]], !"_ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_: %agg.result"}
+// CHECK: [[META39]] = distinct !{[[META39]], !"_ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_"}
+// CHECK: [[META40]] = !{[[META41:![0-9]+]]}
+// CHECK: [[META41]] = distinct !{[[META41]], [[META42:![0-9]+]], !"_ZN4sycl3_V13ext6oneapiplERKNS2_8bfloat16ES5_: %agg.result"}
+// CHECK: [[META42]] = distinct !{[[META42]], !"_ZN4sycl3_V13ext6oneapiplERKNS2_8bfloat16ES5_"}
+// CHECK: [[TBAA43]] = !{[[META44:![0-9]+]], [[META44]], i64 0}
+// CHECK: [[META44]] = !{!"float", [[META11]], i64 0}
+// CHECK: [[META45]] = !{[[META41]], [[META38]]}
+// CHECK: [[TBAA46]] = !{[[META47:![0-9]+]], [[META47]], i64 0}
+// CHECK: [[META47]] = !{!"short", [[META11]], i64 0}
+// CHECK: [[LOOP48]] = distinct !{[[LOOP48]], [[META30]]}
+// CHECK: [[META51]] = !{i32 14270}
+// CHECK: [[META52]] = !{[[META53:![0-9]+]]}
+// CHECK: [[META53]] = distinct !{[[META53]], [[META54:![0-9]+]], !"_ZN4sycl3_V1gtIiEENS0_3vecIiLi16EEERKS3_S5_: %agg.result"}
+// CHECK: [[META54]] = distinct !{[[META54]], !"_ZN4sycl3_V1gtIiEENS0_3vecIiLi16EEERKS3_S5_"}
+// CHECK: [[META55]] = !{i32 15765}
+// CHECK: [[META56]] = !{[[META57:![0-9]+]]}
+// CHECK: [[META57]] = distinct !{[[META57]], [[META58:![0-9]+]], !"_ZN4sycl3_V1gtISt4byteEENS0_3vecIaLi3EEERKNS3_IS2_Li3EEES7_: %agg.result"}
+// CHECK: [[META58]] = distinct !{[[META58]], !"_ZN4sycl3_V1gtISt4byteEENS0_3vecIaLi3EEERKNS3_IS2_Li3EEES7_"}
+// CHECK: [[META59]] = !{i32 16996}
+// CHECK: [[META60]] = !{[[META61:![0-9]+]]}
+// CHECK: [[META61]] = distinct !{[[META61]], [[META62:![0-9]+]], !"_ZN4sycl3_V1gtIbEENS0_3vecIaLi2EEERKNS2_IbLi2EEES6_: %agg.result"}
+// CHECK: [[META62]] = distinct !{[[META62]], !"_ZN4sycl3_V1gtIbEENS0_3vecIaLi2EEERKNS2_IbLi2EEES6_"}
+// CHECK: [[META63]] = !{i32 18285}
+// CHECK: [[META64]] = !{[[META65:![0-9]+]]}
+// CHECK: [[META65]] = distinct !{[[META65]], [[META66:![0-9]+]], !"_ZN4sycl3_V1gtINS0_6detail9half_impl4halfEEENS0_3vecIsLi8EEERKNS5_IS4_Li8EEES9_: %agg.result"}
+// CHECK: [[META66]] = distinct !{[[META66]], !"_ZN4sycl3_V1gtINS0_6detail9half_impl4halfEEENS0_3vecIsLi8EEERKNS5_IS4_Li8EEES9_"}
+// CHECK: [[META67]] = !{i32 21671}
+// CHECK: [[META68]] = !{[[META69:![0-9]+]]}
+// CHECK: [[META69]] = distinct !{[[META69]], [[META70:![0-9]+]], !"_ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_: %agg.result"}
+// CHECK: [[META70]] = distinct !{[[META70]], !"_ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_"}
+// CHECK: [[LOOP71]] = distinct !{[[LOOP71]], [[META30]]}
+// CHECK: [[META72]] = !{i32 23129}
+// CHECK: [[META73]] = !{[[META74:![0-9]+]]}
+// CHECK: [[META74]] = distinct !{[[META74]], [[META75:![0-9]+]], !"_ZN4sycl3_V1ntIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi3EEEE4typeERKS5_: %agg.result"}
+// CHECK: [[META75]] = distinct !{[[META75]], !"_ZN4sycl3_V1ntIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi3EEEE4typeERKS5_"}
+// CHECK: [[META76]] = !{i32 24061}
+// CHECK: [[META77]] = !{[[META78:![0-9]+]]}
+// CHECK: [[META78]] = distinct !{[[META78]], [[META79:![0-9]+]], !"_ZN4sycl3_V1ngIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi4EEEE4typeERKS5_: %agg.result"}
+// CHECK: [[META79]] = distinct !{[[META79]], !"_ZN4sycl3_V1ngIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi4EEEE4typeERKS5_"}
+// CHECK: [[META80]] = !{i32 25180}
+// CHECK: [[META81]] = !{[[META82:![0-9]+]]}
+// CHECK: [[META82]] = distinct !{[[META82]], [[META83:![0-9]+]], !"_ZN4sycl3_V1coISt4byteEENSt9enable_ifIXntsr6detailE14is_vgenfloat_vIT_EENS0_3vecIS2_Li16EEEE4typeERKS6_: %agg.result"}
+// CHECK: [[META83]] = distinct !{[[META83]], !"_ZN4sycl3_V1coISt4byteEENSt9enable_ifIXntsr6detailE14is_vgenfloat_vIT_EENS0_3vecIS2_Li16EEEE4typeERKS6_"}
+// CHECK: [[META84]] = !{i32 26199}
+// CHECK: [[META85]] = !{[[META86:![0-9]+]]}
+// CHECK: [[META86]] = distinct !{[[META86]], [[META87:![0-9]+]], !"_ZN4sycl3_V1ntIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIaLi4EEEE4typeERKNS4_IbLi4EEE: %agg.result"}
+// CHECK: [[META87]] = distinct !{[[META87]], !"_ZN4sycl3_V1ntIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIaLi4EEEE4typeERKNS4_IbLi4EEE"}
+// CHECK: [[META88]] = !{i32 27269}
+// CHECK: [[META89]] = !{[[META90:![0-9]+]]}
+// CHECK: [[META90]] = distinct !{[[META90]], [[META91:![0-9]+]], !"_ZN4sycl3_V1ntINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi2EEEE4typeERKNS7_IS4_Li2EEE: %agg.result"}
+// CHECK: [[META91]] = distinct !{[[META91]], !"_ZN4sycl3_V1ntINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi2EEEE4typeERKNS7_IS4_Li2EEE"}
+// CHECK: [[META92]] = !{i32 28247}
+// CHECK: [[META93]] = !{[[META94:![0-9]+]]}
+// CHECK: [[META94]] = distinct !{[[META94]], [[META95:![0-9]+]], !"_ZN4sycl3_V1ngINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li8EEEE4typeERKS8_: %agg.result"}
+// CHECK: [[META95]] = distinct !{[[META95]], !"_ZN4sycl3_V1ngINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li8EEEE4typeERKS8_"}
+// CHECK: [[META96]] = !{i32 30784}
+// CHECK: [[META97]] = !{[[META98:![0-9]+]]}
+// CHECK: [[META98]] = distinct !{[[META98]], [[META99:![0-9]+]], !"_ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE: %agg.result"}
+// CHECK: [[META99]] = distinct !{[[META99]], !"_ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE"}
+// CHECK: [[LOOP100]] = distinct !{[[LOOP100]], [[META30]]}
+// CHECK: [[META101]] = !{i32 34082}
+// CHECK: [[META102]] = !{[[META103:![0-9]+]]}
+// CHECK: [[META103]] = distinct !{[[META103]], [[META104:![0-9]+]], !"_ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_: %agg.result"}
+// CHECK: [[META104]] = distinct !{[[META104]], !"_ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_"}
+// CHECK: [[TBAA105]] = !{[[META106:![0-9]+]], [[META47]], i64 0}
+// CHECK: [[META106]] = !{!"_ZTSN4sycl3_V13ext6oneapi8bfloat16E", [[META47]], i64 0}
+// CHECK: [[LOOP107]] = distinct !{[[LOOP107]], [[META30]]}
+//.

From 561a22569c633bb47bf9129940617805b283f2e1 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Mon, 20 May 2024 15:25:01 -0700
Subject: [PATCH 70/79] Add asserts. Address reviews.

---
 sycl/include/sycl/vector_preview.hpp          |  41 ++++---
 .../vector/vector_math_ops.cpp                | 103 ------------------
 2 files changed, 26 insertions(+), 118 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 7baa7919a6a64..10c05b7a25649 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -126,19 +126,17 @@ class RoundedRangeKernelWithKH;
 
 // OpenCL data type to convert to.
 template <typename T>
-using element_type_for_vector_t = typename std::conditional_t<
+// clang-format off
+using element_type_for_vector_t = typename map_type<
+    T,
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-    std::is_same_v<T, std::byte>, std::uint8_t,
-#else
-    false, T,
+    std::byte, /*->*/ std::uint8_t,
 #endif
-    typename std::conditional_t<
-        std::is_same_v<T, bool>, std::int8_t,
-        typename std::conditional_t<
-            std::is_same_v<T, sycl::half>, sycl::detail::half_impl::StorageT,
-            typename std::conditional_t<
-                std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                sycl::ext::oneapi::detail::Bfloat16StorageT, T>>>>;
+    bool, /*->*/ std::int8_t,
+    sycl::half, /*->*/ sycl::detail::half_impl::StorageT,
+    sycl::ext::oneapi::bfloat16, /*->*/ sycl::ext::oneapi::detail::Bfloat16StorageT,
+    T, /*->*/ T>::type;
+// clang-format on
 } // namespace detail
 
 ///////////////////////// class sycl::vec /////////////////////////
@@ -333,11 +331,14 @@ template <typename DataT, int NumElements> class vec {
   constexpr vec(const vec &Rhs) = default;
   constexpr vec(vec &&Rhs) = default;
 
+private:
+  // Implementation detail for the next public ctor.
   template <size_t... Is>
   constexpr vec(const std::array<DataT, NumElements> &Arr,
                 std::index_sequence<Is...>)
-      : m_Data{([&](DataT v) constexpr { return v; })(Arr[Is])...} {}
+      : m_Data{Arr[Is]...} {}
 
+public:
   explicit constexpr vec(const DataT &arg)
       : vec{detail::RepeatValue<NumElements>(arg),
             std::make_index_sequence<NumElements>()} {}
@@ -792,6 +793,13 @@ template <typename DataT, int NumElements> class vec {
   friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
   operator RELLOGOP(const vec & Lhs, const vec & Rhs) {                        \
                                                                                \
+    /* Asserts to verify that logical operations on ext_vector_type(1) */      \
+    /* results in 0 or -1. SYCL Spec (Table 143) requires logical operations */\
+    /* on sycl::vec to result in 0 or -1, similar to OpenCL vectors.*/         \
+    using SingleIntVecType = int __attribute__((ext_vector_type(1)));          \
+    assert(sycl::bit_cast<int>(static_cast<SingleIntVecType>(1) == static_cast<SingleIntVecType>(1)) == -1); \
+    assert(sycl::bit_cast<int>(static_cast<SingleIntVecType>(1) != static_cast<SingleIntVecType>(1)) == 0); \
+                                                                               \
     vec<rel_t, NumElements> Ret{};                                             \
     /* ext_vector_type does not support bfloat16, so for these   */            \
     /* we do element-by-element operation on the underlying std::array.  */    \
@@ -802,8 +810,8 @@ template <typename DataT, int NumElements> class vec {
         Ret[I] = static_cast<rel_t>(-(Lhs[I] RELLOGOP Rhs[I]));                \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs);                         \
-      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs);                         \
+      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs);                      \
+      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs);                      \
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
               ExtVecLhs RELLOGOP ExtVecRhs));                                  \
@@ -998,7 +1006,10 @@ template <typename DataT, int NumElements> class vec {
   }
 
   // fields
-  // Alignment is the same as size, to a maximum size of 64.
+  // Alignment is the same as size, to a maximum size of 64. SPEC requires
+  // "The elements of an instance of the SYCL vec class template are stored
+  // in memory sequentially and contiguously and are aligned to the size of
+  // the element type in bytes multiplied by the number of elements."
   static constexpr int alignment = std::min((size_t)64, sizeof(DataType));
   alignas(alignment) DataType m_Data;
 
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 67f6f8eb85cad..c52b8f6f283ac 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -367,106 +367,3 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<ext::oneapi::bfloat16, 16> a) { return -a; }
-//.
-// CHECK: [[META5]] = !{i32 1704}
-// CHECK: [[META6]] = !{}
-// CHECK: [[META7]] = !{[[META8:![0-9]+]]}
-// CHECK: [[META8]] = distinct !{[[META8]], [[META9:![0-9]+]], !"_ZN4sycl3_V1plIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi2EEEE4typeERKS5_S9_: %agg.result"}
-// CHECK: [[META9]] = distinct !{[[META9]], !"_ZN4sycl3_V1plIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi2EEEE4typeERKS5_S9_"}
-// CHECK: [[TBAA10]] = !{[[META11:![0-9]+]], [[META11]], i64 0}
-// CHECK: [[META11]] = !{!"omnipotent char", [[META12:![0-9]+]], i64 0}
-// CHECK: [[META12]] = !{!"Simple C++ TBAA"}
-// CHECK: [[META13]] = !{i32 2998}
-// CHECK: [[META14]] = !{[[META15:![0-9]+]]}
-// CHECK: [[META15]] = distinct !{[[META15]], [[META16:![0-9]+]], !"_ZN4sycl3_V1plIfEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIfLi3EEEE4typeERKS5_S9_: %agg.result"}
-// CHECK: [[META16]] = distinct !{[[META16]], !"_ZN4sycl3_V1plIfEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIfLi3EEEE4typeERKS5_S9_"}
-// CHECK: [[META17]] = !{i32 4131}
-// CHECK: [[META18]] = !{[[META19:![0-9]+]]}
-// CHECK: [[META19]] = distinct !{[[META19]], [[META20:![0-9]+]], !"_ZN4sycl3_V1plIcEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIcLi16EEEE4typeERKS5_S9_: %agg.result"}
-// CHECK: [[META20]] = distinct !{[[META20]], !"_ZN4sycl3_V1plIcEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIcLi16EEEE4typeERKS5_S9_"}
-// CHECK: [[META21]] = !{i32 5342}
-// CHECK: [[META22]] = !{[[META23:![0-9]+]]}
-// CHECK: [[META23]] = distinct !{[[META23]], [[META24:![0-9]+]], !"_ZN4sycl3_V1eoISt4byteEENSt9enable_ifIXntsr6detailE14is_vgenfloat_vIT_EENS0_3vecIS2_Li8EEEE4typeERKS6_SA_: %agg.result"}
-// CHECK: [[META24]] = distinct !{[[META24]], !"_ZN4sycl3_V1eoISt4byteEENSt9enable_ifIXntsr6detailE14is_vgenfloat_vIT_EENS0_3vecIS2_Li8EEEE4typeERKS6_SA_"}
-// CHECK: [[META25]] = !{i32 7708}
-// CHECK: [[META26]] = !{[[META27:![0-9]+]]}
-// CHECK: [[META27]] = distinct !{[[META27]], [[META28:![0-9]+]], !"_ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIbLi4EEEE4typeERKS5_S9_: %agg.result"}
-// CHECK: [[META28]] = distinct !{[[META28]], !"_ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIbLi4EEEE4typeERKS5_S9_"}
-// CHECK: [[LOOP29]] = distinct !{[[LOOP29]], [[META30:![0-9]+]]}
-// CHECK: [[META30]] = !{!"llvm.loop.mustprogress"}
-// CHECK: [[META31]] = !{i32 9058}
-// CHECK: [[META32]] = !{i32 5}
-// CHECK: [[META33]] = !{[[META34:![0-9]+]]}
-// CHECK: [[META34]] = distinct !{[[META34]], [[META35:![0-9]+]], !"_ZN4sycl3_V1plINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_: %agg.result"}
-// CHECK: [[META35]] = distinct !{[[META35]], !"_ZN4sycl3_V1plINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_"}
-// CHECK: [[META36]] = !{i32 12920}
-// CHECK: [[META37]] = !{[[META38:![0-9]+]]}
-// CHECK: [[META38]] = distinct !{[[META38]], [[META39:![0-9]+]], !"_ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_: %agg.result"}
-// CHECK: [[META39]] = distinct !{[[META39]], !"_ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_"}
-// CHECK: [[META40]] = !{[[META41:![0-9]+]]}
-// CHECK: [[META41]] = distinct !{[[META41]], [[META42:![0-9]+]], !"_ZN4sycl3_V13ext6oneapiplERKNS2_8bfloat16ES5_: %agg.result"}
-// CHECK: [[META42]] = distinct !{[[META42]], !"_ZN4sycl3_V13ext6oneapiplERKNS2_8bfloat16ES5_"}
-// CHECK: [[TBAA43]] = !{[[META44:![0-9]+]], [[META44]], i64 0}
-// CHECK: [[META44]] = !{!"float", [[META11]], i64 0}
-// CHECK: [[META45]] = !{[[META41]], [[META38]]}
-// CHECK: [[TBAA46]] = !{[[META47:![0-9]+]], [[META47]], i64 0}
-// CHECK: [[META47]] = !{!"short", [[META11]], i64 0}
-// CHECK: [[LOOP48]] = distinct !{[[LOOP48]], [[META30]]}
-// CHECK: [[META51]] = !{i32 14270}
-// CHECK: [[META52]] = !{[[META53:![0-9]+]]}
-// CHECK: [[META53]] = distinct !{[[META53]], [[META54:![0-9]+]], !"_ZN4sycl3_V1gtIiEENS0_3vecIiLi16EEERKS3_S5_: %agg.result"}
-// CHECK: [[META54]] = distinct !{[[META54]], !"_ZN4sycl3_V1gtIiEENS0_3vecIiLi16EEERKS3_S5_"}
-// CHECK: [[META55]] = !{i32 15765}
-// CHECK: [[META56]] = !{[[META57:![0-9]+]]}
-// CHECK: [[META57]] = distinct !{[[META57]], [[META58:![0-9]+]], !"_ZN4sycl3_V1gtISt4byteEENS0_3vecIaLi3EEERKNS3_IS2_Li3EEES7_: %agg.result"}
-// CHECK: [[META58]] = distinct !{[[META58]], !"_ZN4sycl3_V1gtISt4byteEENS0_3vecIaLi3EEERKNS3_IS2_Li3EEES7_"}
-// CHECK: [[META59]] = !{i32 16996}
-// CHECK: [[META60]] = !{[[META61:![0-9]+]]}
-// CHECK: [[META61]] = distinct !{[[META61]], [[META62:![0-9]+]], !"_ZN4sycl3_V1gtIbEENS0_3vecIaLi2EEERKNS2_IbLi2EEES6_: %agg.result"}
-// CHECK: [[META62]] = distinct !{[[META62]], !"_ZN4sycl3_V1gtIbEENS0_3vecIaLi2EEERKNS2_IbLi2EEES6_"}
-// CHECK: [[META63]] = !{i32 18285}
-// CHECK: [[META64]] = !{[[META65:![0-9]+]]}
-// CHECK: [[META65]] = distinct !{[[META65]], [[META66:![0-9]+]], !"_ZN4sycl3_V1gtINS0_6detail9half_impl4halfEEENS0_3vecIsLi8EEERKNS5_IS4_Li8EEES9_: %agg.result"}
-// CHECK: [[META66]] = distinct !{[[META66]], !"_ZN4sycl3_V1gtINS0_6detail9half_impl4halfEEENS0_3vecIsLi8EEERKNS5_IS4_Li8EEES9_"}
-// CHECK: [[META67]] = !{i32 21671}
-// CHECK: [[META68]] = !{[[META69:![0-9]+]]}
-// CHECK: [[META69]] = distinct !{[[META69]], [[META70:![0-9]+]], !"_ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_: %agg.result"}
-// CHECK: [[META70]] = distinct !{[[META70]], !"_ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_"}
-// CHECK: [[LOOP71]] = distinct !{[[LOOP71]], [[META30]]}
-// CHECK: [[META72]] = !{i32 23129}
-// CHECK: [[META73]] = !{[[META74:![0-9]+]]}
-// CHECK: [[META74]] = distinct !{[[META74]], [[META75:![0-9]+]], !"_ZN4sycl3_V1ntIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi3EEEE4typeERKS5_: %agg.result"}
-// CHECK: [[META75]] = distinct !{[[META75]], !"_ZN4sycl3_V1ntIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi3EEEE4typeERKS5_"}
-// CHECK: [[META76]] = !{i32 24061}
-// CHECK: [[META77]] = !{[[META78:![0-9]+]]}
-// CHECK: [[META78]] = distinct !{[[META78]], [[META79:![0-9]+]], !"_ZN4sycl3_V1ngIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi4EEEE4typeERKS5_: %agg.result"}
-// CHECK: [[META79]] = distinct !{[[META79]], !"_ZN4sycl3_V1ngIiEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIiLi4EEEE4typeERKS5_"}
-// CHECK: [[META80]] = !{i32 25180}
-// CHECK: [[META81]] = !{[[META82:![0-9]+]]}
-// CHECK: [[META82]] = distinct !{[[META82]], [[META83:![0-9]+]], !"_ZN4sycl3_V1coISt4byteEENSt9enable_ifIXntsr6detailE14is_vgenfloat_vIT_EENS0_3vecIS2_Li16EEEE4typeERKS6_: %agg.result"}
-// CHECK: [[META83]] = distinct !{[[META83]], !"_ZN4sycl3_V1coISt4byteEENSt9enable_ifIXntsr6detailE14is_vgenfloat_vIT_EENS0_3vecIS2_Li16EEEE4typeERKS6_"}
-// CHECK: [[META84]] = !{i32 26199}
-// CHECK: [[META85]] = !{[[META86:![0-9]+]]}
-// CHECK: [[META86]] = distinct !{[[META86]], [[META87:![0-9]+]], !"_ZN4sycl3_V1ntIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIaLi4EEEE4typeERKNS4_IbLi4EEE: %agg.result"}
-// CHECK: [[META87]] = distinct !{[[META87]], !"_ZN4sycl3_V1ntIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIaLi4EEEE4typeERKNS4_IbLi4EEE"}
-// CHECK: [[META88]] = !{i32 27269}
-// CHECK: [[META89]] = !{[[META90:![0-9]+]]}
-// CHECK: [[META90]] = distinct !{[[META90]], [[META91:![0-9]+]], !"_ZN4sycl3_V1ntINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi2EEEE4typeERKNS7_IS4_Li2EEE: %agg.result"}
-// CHECK: [[META91]] = distinct !{[[META91]], !"_ZN4sycl3_V1ntINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi2EEEE4typeERKNS7_IS4_Li2EEE"}
-// CHECK: [[META92]] = !{i32 28247}
-// CHECK: [[META93]] = !{[[META94:![0-9]+]]}
-// CHECK: [[META94]] = distinct !{[[META94]], [[META95:![0-9]+]], !"_ZN4sycl3_V1ngINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li8EEEE4typeERKS8_: %agg.result"}
-// CHECK: [[META95]] = distinct !{[[META95]], !"_ZN4sycl3_V1ngINS0_6detail9half_impl4halfEEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li8EEEE4typeERKS8_"}
-// CHECK: [[META96]] = !{i32 30784}
-// CHECK: [[META97]] = !{[[META98:![0-9]+]]}
-// CHECK: [[META98]] = distinct !{[[META98]], [[META99:![0-9]+]], !"_ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE: %agg.result"}
-// CHECK: [[META99]] = distinct !{[[META99]], !"_ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE"}
-// CHECK: [[LOOP100]] = distinct !{[[LOOP100]], [[META30]]}
-// CHECK: [[META101]] = !{i32 34082}
-// CHECK: [[META102]] = !{[[META103:![0-9]+]]}
-// CHECK: [[META103]] = distinct !{[[META103]], [[META104:![0-9]+]], !"_ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_: %agg.result"}
-// CHECK: [[META104]] = distinct !{[[META104]], !"_ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_"}
-// CHECK: [[TBAA105]] = !{[[META106:![0-9]+]], [[META47]], i64 0}
-// CHECK: [[META106]] = !{!"_ZTSN4sycl3_V13ext6oneapi8bfloat16E", [[META47]], i64 0}
-// CHECK: [[LOOP107]] = distinct !{[[LOOP107]], [[META30]]}
-//.

From 4a89d59c7e2636c1d0276b4879ae4ff5cf7ad173 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 23 May 2024 13:07:55 -0700
Subject: [PATCH 71/79] All tests passing, including CTS. Address reviews

---
 sycl/include/sycl/vector_preview.hpp          |  77 +++-----
 sycl/test-e2e/Basic/vector/byte_preview.cpp   |   9 +
 .../vector/vector_math_ops.cpp                | 174 +++++++++---------
 3 files changed, 116 insertions(+), 144 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 10c05b7a25649..ae52df65fbeca 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -154,18 +154,17 @@ template <typename DataT, int NumElements> class vec {
 
   // This represent type of underlying value. There should be only one field
   // in the class, so vec<float, 16> should be equal to float16 in memory.
-  using DataType =
-      std::array<std::conditional_t<std::is_same_v<DataT, bool>, int8_t, DataT>,
-                 AdjustedNum>;
+  using DataType = std::array<std::conditional_t<std::is_same_v<DataT, bool>, int8_t, DataT>, AdjustedNum>;
 
 public:
 #ifdef __SYCL_DEVICE_ONLY__
-  // Type used for passing sycl::vec to SPIRV builtins. Optimizer treats
-  // ext_vector_type(1) as a scalar type, except for logical operations.
-  // Logical operations on ext_vector_type(1) results in 0 or -1, while
-  // on scalar types it results in 0 or 1. 
-  using vector_t = detail::element_type_for_vector_t<DataT> __attribute__((
-      ext_vector_type(NumElements)));
+  // Type used for passing sycl::vec to SPIRV builtins.
+  // We can not use ext_vector_type(1) as it's not supported by SPIRV
+  // plugins (CTS fails).
+  using vector_t = typename std::conditional_t<
+      NumElements == 1, detail::element_type_for_vector_t<DataT>,
+        detail::element_type_for_vector_t<DataT> __attribute__((
+        ext_vector_type(NumElements)))>;
 #endif // __SYCL_DEVICE_ONLY__
 
 private:
@@ -189,7 +188,7 @@ template <typename DataT, int NumElements> class vec {
   template <typename DataT_, typename T, std::size_t... Is>
   static constexpr std::array<DataT_, sizeof...(Is)>
   VecToArray(const vec<T, sizeof...(Is)> &V, std::index_sequence<Is...>) {
-    return {static_cast<DataT_>(V.getValue(Is))...};
+    return {static_cast<DataT_>(V[Is])...};
   }
   template <typename DataT_, typename T, int N, typename T2, typename T3,
             template <typename> class T4, int... T5, std::size_t... Is>
@@ -322,6 +321,8 @@ template <typename DataT, int NumElements> class vec {
       typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
 
 public:
+  // Aliases required by SPEC to make sycl::vec consistent
+  // with that of marray and buffer.
   using element_type = DataT;
   using value_type = DataT;
   using rel_t = detail::rel_t<DataT>;
@@ -407,7 +408,7 @@ template <typename DataT, int NumElements> class vec {
   static constexpr size_t get_size() { return byte_size(); }
   static constexpr size_t byte_size() noexcept { return sizeof(m_Data); }
 
-  // We interpret bool as int8_t, std::byte as uint8_t for onversion to other
+  // We interpret bool as int8_t, std::byte as uint8_t for conversion to other
   // types.
   template <typename T>
   using ConvertBoolAndByteT = typename std::conditional_t<
@@ -533,44 +534,14 @@ template <typename DataT, int NumElements> class vec {
   // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
   // aggressively optimized. Specializing with noinline to avoid as workaround.
 
-  template <typename T = DataT>
-  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                            const DataT &>
-  operator[](int i) const {
-    return reinterpret_cast<const DataT *>(&m_Data)[i];
-  }
-
-  template <typename T = DataT>
-  typename std::enable_if_t<!std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                            DataT &>
-  operator[](int i) {
-    return reinterpret_cast<DataT *>(&m_Data)[i];
-  }
-
-#ifdef _MSC_VER
-#define __SYCL_NOINLINE_BF16 __declspec(noinline)
-#else
-#define __SYCL_NOINLINE_BF16 __attribute__((noinline))
-#endif
-
-  template <typename T = DataT>
-  __SYCL_NOINLINE_BF16
-      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                                const DataT &>
-      operator[](int i) const {
+  const DataT& operator[](int i) const {
     return reinterpret_cast<const DataT *>(&m_Data)[i];
   }
 
-  template <typename T = DataT>
-  __SYCL_NOINLINE_BF16
-      typename std::enable_if_t<std::is_same_v<T, sycl::ext::oneapi::bfloat16>,
-                                DataT &>
-      operator[](int i) {
+  DataT& operator[](int i) {
     return reinterpret_cast<DataT *>(&m_Data)[i];
   }
 
-#undef __SYCL_NOINLINE_BF16
-
   // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
 private:
   // Indexer used in the swizzles.def
@@ -621,7 +592,7 @@ template <typename DataT, int NumElements> class vec {
     for (int I = 0; I < NumElements; I++) {
       // Cast require for int8 -> std::byte conversion.
       *multi_ptr<DataT, Space, DecorateAddress>(
-          Ptr + Offset * NumElements + I) = static_cast<DataT>(getValue(I));
+          Ptr + Offset * NumElements + I) = static_cast<DataT>(m_Data[I]);
     }
   }
   template <int Dimensions, access::mode Mode,
@@ -792,14 +763,6 @@ template <typename DataT, int NumElements> class vec {
   template <typename T = DataT>                                                \
   friend typename std::enable_if_t<(COND), vec<rel_t, NumElements>>            \
   operator RELLOGOP(const vec & Lhs, const vec & Rhs) {                        \
-                                                                               \
-    /* Asserts to verify that logical operations on ext_vector_type(1) */      \
-    /* results in 0 or -1. SYCL Spec (Table 143) requires logical operations */\
-    /* on sycl::vec to result in 0 or -1, similar to OpenCL vectors.*/         \
-    using SingleIntVecType = int __attribute__((ext_vector_type(1)));          \
-    assert(sycl::bit_cast<int>(static_cast<SingleIntVecType>(1) == static_cast<SingleIntVecType>(1)) == -1); \
-    assert(sycl::bit_cast<int>(static_cast<SingleIntVecType>(1) != static_cast<SingleIntVecType>(1)) == 0); \
-                                                                               \
     vec<rel_t, NumElements> Ret{};                                             \
     /* ext_vector_type does not support bfloat16, so for these   */            \
     /* we do element-by-element operation on the underlying std::array.  */    \
@@ -815,6 +778,10 @@ template <typename DataT, int NumElements> class vec {
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
               ExtVecLhs RELLOGOP ExtVecRhs));                                  \
+      /* For NumElements == 1, we use scalar instead of ext_vector_type. */    \
+      if constexpr (NumElements == 1) {                                        \
+        Ret *= -1;                                                             \
+      }                                                                        \
     }                                                                          \
     return Ret;                                                                \
   }
@@ -862,6 +829,8 @@ template <typename DataT, int NumElements> class vec {
 #undef __SYCL_RELLOGOP
 
 // ++ and -- operators are only allowed for DataT!=std::byte and DataT!=bool
+// FIXME: Don't allow Unary operators on vec<bool> after
+// https://github.com/KhronosGroup/SYCL-CTS/issues/896 gets fixed.
 #ifdef __SYCL_UOP
 #error "Undefine __SYCL_UOP macro"
 #endif
@@ -879,9 +848,9 @@ template <typename DataT, int NumElements> class vec {
   }
 
   __SYCL_UOP(++, +=,
-             ((!std::is_same_v<T, std::byte>) && !std::is_same_v<T, bool>))
+             (!std::is_same_v<T, std::byte>))
   __SYCL_UOP(--, -=,
-             ((!std::is_same_v<T, std::byte>) && !std::is_same_v<T, bool>))
+             (!std::is_same_v<T, std::byte>))
 #undef __SYCL_UOP
 
   // operator~() available only when: dataT != float && dataT != double
diff --git a/sycl/test-e2e/Basic/vector/byte_preview.cpp b/sycl/test-e2e/Basic/vector/byte_preview.cpp
index 7e9bb191a87db..235b4726e195f 100644
--- a/sycl/test-e2e/Basic/vector/byte_preview.cpp
+++ b/sycl/test-e2e/Basic/vector/byte_preview.cpp
@@ -135,6 +135,15 @@ int main() {
     auto swor3 = std::byte{3} | swlo;
     auto swxor3 = std::byte{3} ^ swlo;
 
+    // std::byte is not an arithmetic type and it only supports the following
+    // overloads of >> and << operators.
+    //
+    // 1 template <class IntegerType>
+    //   constexpr std::byte operator<<( std::byte b, IntegerType shift )
+    //   noexcept;
+    // 2 template <class IntegerType>
+    //   constexpr std::byte operator>>( std::byte b, IntegerType shift )
+    //   noexcept;
     vop = vop1 << 3;
     vop = vop1 >> 3;
 
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index c52b8f6f283ac..6c835881fbb29 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -104,11 +104,12 @@ SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
 SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] !srcloc [[META36:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] !srcloc [[META36:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
 // CHECK-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META37:![0-9]+]])
 // CHECK-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
@@ -116,20 +117,19 @@ SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI3EEEE4TYPEERKS8_SC__EXIT:%.*]]
 // CHECK:       for.body.i:
-// CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8:[0-9]+]]
-// CHECK-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]]
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37:![0-9]+]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9:[0-9]+]], !noalias [[META40:![0-9]+]]
-// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR9]], !noalias [[META40]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
+// CHECK-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[B_ASCAST]], i64 [[I_0_I]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR7:[0-9]+]], !noalias [[META40:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I10_I]]) #[[ATTR7]], !noalias [[META40]]
 // CHECK-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
-// CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA43:![0-9]+]], !noalias [[META45:![0-9]+]]
-// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR9]], !noalias [[META40]]
+// CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA43:![0-9]+]], !noalias [[META40]]
+// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR7]], !noalias [[META40]]
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37]]
-// CHECK-NEXT:    [[CALL4_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR8]]
-// CHECK-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[CALL4_I]], align 2, !tbaa [[TBAA46:![0-9]+]]
+// CHECK-NEXT:    [[ARRAYIDX_I12_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[ARRAYIDX_I12_I]], align 2, !tbaa [[TBAA45:![0-9]+]], !alias.scope [[META37]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP48:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP47:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_.exit:
 // CHECK-NEXT:    ret void
 //
@@ -141,14 +141,14 @@ SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
 /***************** Binary Logical Ops *******************/
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIiLi16EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META51:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META48:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META52:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 64, !tbaa [[TBAA10]], !noalias [[META52]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 64, !tbaa [[TBAA10]], !noalias [[META52]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META49:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 64, !tbaa [[TBAA10]], !noalias [[META49]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 64, !tbaa [[TBAA10]], !noalias [[META49]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <16 x i32> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <16 x i1> [[CMP_I]] to <16 x i32>
-// CHECK-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, !tbaa [[TBAA10]], !alias.scope [[META52]]
+// CHECK-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, !tbaa [[TBAA10]], !alias.scope [[META49]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
@@ -156,16 +156,16 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecISt4byteLi3EEES3_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META55:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META52:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META56:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 4, !noalias [[META56]]
-// CHECK-NEXT:    [[LOADVEC4_I6_I:%.*]] = load <4 x i8>, ptr [[B]], align 4, !noalias [[META56]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META53:![0-9]+]])
+// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 4, !noalias [[META53]]
+// CHECK-NEXT:    [[LOADVEC4_I6_I:%.*]] = load <4 x i8>, ptr [[B]], align 4, !noalias [[META53]]
 // CHECK-NEXT:    [[TMP0:%.*]] = icmp ugt <4 x i8> [[LOADVEC4_I_I]], [[LOADVEC4_I6_I]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = shufflevector <4 x i1> [[TMP0]], <4 x i1> poison, <3 x i32> <i32 0, i32 1, i32 2>
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i8>
 // CHECK-NEXT:    [[EXTRACTVEC_I8_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I8_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META56]]
+// CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I8_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META53]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
@@ -173,14 +173,14 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIbLi2EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META59:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META56:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META60:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META60]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META60]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META57:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META57]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META57]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
-// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META60]]
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META57]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
@@ -188,47 +188,43 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META63:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META60:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META64:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META64]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 16, !tbaa [[TBAA10]], !noalias [[META64]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META61:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META61]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 16, !tbaa [[TBAA10]], !noalias [[META61]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp ogt <8 x half> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <8 x i1> [[CMP_I]] to <8 x i16>
-// CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META64]]
+// CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META61]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
   return a > b;
 }
 
-// FIXME: We incorrectly interpret BF16 as INT16 to peform logical operation.
-// For example, vec<BF16, 2>{-0.5, 3.333} < vec<BF16, 2>{6.0, 6.666} results
-// into {-1, -1} on host but {0, -1} on device.
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.24") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META67:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.24") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META64:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
 // CHECK-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META68:![0-9]+]])
-// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META68]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META65:![0-9]+]])
+// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META65]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTINS0_3EXT6ONEAPI8BFLOAT16EEENS0_3VECISLI4EEERKNS5_IS4_LI4EEES9__EXIT:%.*]]
 // CHECK:       for.body.i:
-// CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META68]]
-// CHECK-NEXT:    [[CALL2_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[B_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META68]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], !noalias [[META68]]
-// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL2_I]]) #[[ATTR9]], !noalias [[META68]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
+// CHECK-NEXT:    [[ARRAYIDX_I13_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[B_ASCAST]], i64 [[I_0_I]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR7]], !noalias [[META65]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I13_I]]) #[[ATTR7]], !noalias [[META65]]
 // CHECK-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
-// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META68]]
+// CHECK-NEXT:    [[ARRAYIDX_I15_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I15_I]], align 2, !tbaa [[TBAA45]], !alias.scope [[META65]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP71:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP68:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_.exit:
 // CHECK-NEXT:    ret void
 //
@@ -240,128 +236,126 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
 /********************** Unary Ops **********************/
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIiLi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.27") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.27") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META72:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.27") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.27") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META69:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META73:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 16, !noalias [[META73]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META70:![0-9]+]])
+// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 16, !noalias [[META70]]
 // CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i32>
 // CHECK-NEXT:    [[EXTRACTVEC_I2_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META73]]
+// CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META70]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecIiLi4EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META76:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META73:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META77:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META77]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META74:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META74]]
 // CHECK-NEXT:    [[SUB_I:%.*]] = sub <4 x i32> zeroinitializer, [[TMP0]]
-// CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META77]]
+// CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META74]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
 
 // Negation is not valid for std::byte. Therefore, using bitwise negation.
 // CHECK-LABEL: define dso_local spir_func void @_Z19TestBitwiseNegationN4sycl3_V13vecISt4byteLi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.30") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.30") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META80:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.30") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.30") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META77:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META81:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META81]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META78:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META78]]
 // CHECK-NEXT:    [[NOT_I:%.*]] = xor <16 x i8> [[TMP0]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
-// CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META81]]
+// CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META78]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META84:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META81:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META85:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META85]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META82:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META82]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <4 x i8> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <4 x i1> [[CMP_I]] to <4 x i8>
-// CHECK-NEXT:    store <4 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META85]]
+// CHECK-NEXT:    store <4 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META82]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META88:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META85:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META89:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META89]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META86:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META86]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp oeq <2 x half> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
-// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META89]]
+// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META86]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META92:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META89:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META93:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META93]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META90:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META90]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg <8 x half> [[TMP0]]
-// CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META93]]
+// CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META90]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META96:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META93:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META97:![0-9]+]])
-// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META97]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META94:![0-9]+]])
+// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META94]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
 // CHECK:       for.body.i:
-// CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 8 dereferenceable_or_null(8) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]], !noalias [[META97]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]], !noalias [[META97]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR7]], !noalias [[META94]]
 // CHECK-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
 // CHECK-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
-// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I_I]], align 2, !tbaa [[TBAA46]], !alias.scope [[META97]]
+// CHECK-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I10_I]], align 2, !tbaa [[TBAA45]], !alias.scope [[META94]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP100:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP97:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias writable sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META101:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META98:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca float, align 4
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META102:![0-9]+]])
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META99:![0-9]+]])
 // CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    [[REF_TMP_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP_I]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META102]]
+// CHECK-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META99]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 16
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI16EEEE4TYPEERKS8__EXIT:%.*]]
 // CHECK:       for.body.i:
-// CHECK-NEXT:    [[CONV_I:%.*]] = trunc nuw nsw i64 [[I_0_I]] to i32
-// CHECK-NEXT:    [[CALL_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZNK4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERKS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[A_ASCAST]], i32 noundef [[CONV_I]]) #[[ATTR8]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[CALL_I]]) #[[ATTR9]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR7]], !noalias [[META99]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg float [[CALL_I_I_I]]
-// CHECK-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA43]], !noalias [[META102]]
-// CHECK-NEXT:    [[CALL3_I:%.*]] = call spir_func noundef align 2 dereferenceable(2) ptr addrspace(4) @_ZN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEixIS4_EENSt9enable_ifIXsr3stdE9is_same_vIT_S4_EERS4_E4typeEi(ptr addrspace(4) noundef align 32 dereferenceable_or_null(32) [[AGG_RESULT]], i32 noundef [[CONV_I]]) #[[ATTR8]]
-// CHECK-NEXT:    [[CALL_I_I8_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR9]]
-// CHECK-NEXT:    store i16 [[CALL_I_I8_I]], ptr addrspace(4) [[CALL3_I]], align 2, !tbaa [[TBAA105:![0-9]+]]
+// CHECK-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA43]], !noalias [[META99]]
+// CHECK-NEXT:    [[ARRAYIDX_I9_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-NEXT:    [[CALL_I_I10_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR7]], !noalias [[META99]]
+// CHECK-NEXT:    store i16 [[CALL_I_I10_I]], ptr addrspace(4) [[ARRAYIDX_I9_I]], align 2, !tbaa [[TBAA102:![0-9]+]], !alias.scope [[META99]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP107:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP104:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void

From f4b965c33299d5a14e3c1785721783fd8e1fe524 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Thu, 23 May 2024 13:46:55 -0700
Subject: [PATCH 72/79] Merge byte_preview and byte

---
 sycl/test-e2e/Basic/vector/byte.cpp | 47 +++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/sycl/test-e2e/Basic/vector/byte.cpp b/sycl/test-e2e/Basic/vector/byte.cpp
index 7581e52839035..f427d861f56ae 100644
--- a/sycl/test-e2e/Basic/vector/byte.cpp
+++ b/sycl/test-e2e/Basic/vector/byte.cpp
@@ -1,6 +1,9 @@
 // RUN: %{build} -std=c++17 -o %t.out
 // RUN: %{run} %t.out
 
+// RUN: %if preview-breaking-changes-supported %{ %{build} -fpreview-breaking-changes -std=c++17 -o %t2.out %}
+// RUN: %if preview-breaking-changes-supported %{ %{run} %t2.out %}
+
 //==---------- vector_byte.cpp - SYCL vec<> for std::byte test -------------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
@@ -102,6 +105,7 @@ int main() {
     sycl::vec<std::byte, 4> vop3{std::byte{5}, std::byte{6}, std::byte{2},
                                  std::byte{3}};
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
     // binary op for 2 vec
     auto vop = vop1 + vop2;
     assert(vop[0] == std::byte{6});
@@ -210,6 +214,11 @@ int main() {
 
     // logical binary op for 2 vec
     vop = vop1 & vop2;
+  #else // __INTEL_PREVIEW_BREAKING_CHANGES
+    auto vop = vop1 & vop2;
+    auto swlo = vop3.lo();
+    auto swhi = vop3.hi();
+  #endif // __INTEL_PREVIEW_BREAKING_CHANGES
     vop = vop1 | vop2;
     vop = vop1 ^ vop2;
 
@@ -218,6 +227,7 @@ int main() {
     auto swor = swlo | swhi;
     auto swxor = swlo ^ swhi;
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
     // logical binary op for 1 vec
     vop = vop1 & std::byte{3};
     vop = vop1 | std::byte{3};
@@ -225,6 +235,20 @@ int main() {
     vop = std::byte{3} & vop1;
     vop = std::byte{3} | vop1;
     vop = std::byte{3} ^ vop1;
+#else
+    {
+      // Check order of operands for bitwise operators.
+      auto BitWiseAnd1 = vop1 & std::byte{3};
+      auto BitWiseOr1 = vop1 | std::byte{3};
+      auto BitWiseXor1 = vop1 ^ std::byte{3};
+      auto BitWiseAnd2 = std::byte{3} & vop1;
+      auto BitWiseOr2 = std::byte{3} | vop1;
+      auto BitWiseXor2 = std::byte{3} ^ vop1;
+      assert(BitWiseAnd1[0] == BitWiseAnd2[0]);
+      assert(BitWiseOr1[1] == BitWiseOr2[1]);
+      assert(BitWiseXor1[2] == BitWiseXor2[2]);
+    }
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 
     // logical binary op for 1 swizzle
     auto swand2 = swlo & std::byte{3};
@@ -235,6 +259,7 @@ int main() {
     auto swor3 = std::byte{3} | swlo;
     auto swxor3 = std::byte{3} ^ swlo;
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
     // bit binary op for 2 vec
     vop = vop1 && vop2;
     vop = vop1 || vop2;
@@ -253,6 +278,26 @@ int main() {
     swlo << std::byte{3};
     auto right = std::byte{3} >> swhi;
     auto left = std::byte{3} << swhi;
+#else
+    // std::byte is not an arithmetic type and it only supports the following
+    // overloads of >> and << operators.
+    //
+    // 1 template <class IntegerType>
+    //   constexpr std::byte operator<<( std::byte b, IntegerType shift )
+    //   noexcept;
+    // 2 template <class IntegerType>
+    //   constexpr std::byte operator>>( std::byte b, IntegerType shift )
+    //   noexcept;
+    vop = vop1 << 3;
+    vop = vop1 >> 3;
+
+    // TODO: Fix >> and << for swizzle of std::byte. Currently, Swizzles assume
+    // that both operands of the >> abd << operator have the same data type.
+    // That is not the case with std::byte.
+
+    // swlo >> 3;
+    // swlo << 3;
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 
     // condition op for 2 vec
     auto vres = vop1 == vop2;
@@ -292,7 +337,9 @@ int main() {
 
     sycl::vec<std::byte, 3> voptest{std::byte{4}, std::byte{9}, std::byte{25}};
     auto bitv1 = ~vop3;
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
     auto bitv2 = !vop3;
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
     auto bitw = ~swhi;
   }
 

From cf9d905dae3eeefcb0167059a0ebcfc599574f4d Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Fri, 24 May 2024 10:39:31 -0700
Subject: [PATCH 73/79] Fix vector/byte E2E test case. Restrict swizzles of
 std::byte to limited operators.

---
 .../sycl/detail/generic_type_traits.hpp       |  11 +
 sycl/include/sycl/vector_preview.hpp          | 156 +++---
 sycl/test-e2e/Basic/vector/byte.cpp           | 493 ++++++++++--------
 sycl/test-e2e/Basic/vector/byte_preview.cpp   | 200 -------
 .../vector/vector_math_ops.cpp                | 155 +++---
 5 files changed, 434 insertions(+), 581 deletions(-)
 delete mode 100644 sycl/test-e2e/Basic/vector/byte_preview.cpp

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 892b76e6062a0..d51bc816d6cd8 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -252,6 +252,17 @@ inline constexpr bool is_genfloatptr_marray_v =
     (IsDecorated == access::decorated::yes ||
      IsDecorated == access::decorated::no);
 
+template <typename T>
+using is_byte_t = typename
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+      std::is_same<T, std::byte>;
+#else
+      std::false_type;
+#endif
+
+template <typename T>
+inline constexpr bool is_byte_v = is_byte_t<T>::value;
+
 template <typename T>
 using make_floating_point_t = make_type_t<T, gtl::scalar_floating_list>;
 
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index ae52df65fbeca..7193dfe7e7f5c 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -413,12 +413,7 @@ template <typename DataT, int NumElements> class vec {
   template <typename T>
   using ConvertBoolAndByteT = typename std::conditional_t<
       std::is_same_v<T, bool>, int8_t,
-      typename std::conditional_t<
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-          std::is_same_v<T, std::byte>, uint8_t, T>>;
-#else
-          false, T, T>>;
-#endif
+      typename std::conditional_t<detail::is_byte_v<T>, uint8_t, T>>;
 
   // convertImpl can't be called with the same From and To types and therefore
   // we need this version of convert which is mostly no-op.
@@ -487,8 +482,8 @@ template <typename DataT, int NumElements> class vec {
           auto val =
               detail::convertImpl<T, R, roundingMode, 1, OpenCLT, OpenCLR>(
                   getValue(I));
-          if constexpr (IsByte<convertT>::value)
-            Result.setValue(I, static_cast<std::byte>(val));
+          if constexpr (detail::is_byte_t<convertT>::value)
+            Result.setValue(I, static_cast<convertT>(val));
           else
             Result.setValue(I, val);
         }
@@ -618,15 +613,6 @@ template <typename DataT, int NumElements> class vec {
 #endif
 
   /******************* sycl::vec math operations ***********************/
-
-  template <typename T>
-  using IsByte = typename
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-      std::is_same<T, std::byte>;
-#else
-      std::false_type;
-#endif
-
 #if defined(__SYCL_BINOP) || defined(BINOP_BASE)
 #error "Undefine __SYCL_BINOP and BINOP_BASE macro"
 #endif
@@ -694,23 +680,23 @@ template <typename DataT, int NumElements> class vec {
   }
 
   // std::byte is not an arithmetic type.
-  __SYCL_BINOP(+, +=, true, (!IsByte<T>::value))
-  __SYCL_BINOP(-, -=, true, (!IsByte<T>::value))
-  __SYCL_BINOP(*, *=, false, (!IsByte<T>::value))
-  __SYCL_BINOP(/, /=, false, (!IsByte<T>::value))
+  __SYCL_BINOP(+, +=, true, (!detail::is_byte_v<T>))
+  __SYCL_BINOP(-, -=, true, (!detail::is_byte_v<T>))
+  __SYCL_BINOP(*, *=, false, (!detail::is_byte_v<T>))
+  __SYCL_BINOP(/, /=, false, (!detail::is_byte_v<T>))
 
   // The following OPs are available only when: DataT != cl_float &&
   // DataT != cl_double && DataT != cl_half && DataT != BF16.
   __SYCL_BINOP(%, %=, false,
-               (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
+               (!detail::is_vgenfloat_v<T> && (!detail::is_byte_v<T>)))
   // Bitwise operations are allowed for std::byte.
   __SYCL_BINOP(|, |=, false, (!detail::is_vgenfloat_v<T>))
   __SYCL_BINOP(&, &=, false, (!detail::is_vgenfloat_v<T>))
   __SYCL_BINOP(^, ^=, false, (!detail::is_vgenfloat_v<T>))
   __SYCL_BINOP(>>, >>=, false,
-               (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
+               (!detail::is_vgenfloat_v<T> && (!detail::is_byte_v<T>)))
   __SYCL_BINOP(<<, <<=, true,
-               (!detail::is_vgenfloat_v<T> && (!IsByte<T>::value)))
+               (!detail::is_vgenfloat_v<T> && (!detail::is_byte_v<T>)))
 
 #undef BINOP_BASE
 #undef __SYCL_BINOP
@@ -727,7 +713,7 @@ template <typename DataT, int NumElements> class vec {
   //   noexcept;
 #define __SYCL_SHIFT_BYTE(OP, OPASSIGN)                                        \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(IsByte<T>::value), vec> operator OP(       \
+  friend typename std::enable_if_t<(detail::is_byte_v<T>), vec> operator OP(       \
       const vec & Lhs, int shift) {                                            \
     vec Ret;                                                                   \
     for (size_t I = 0; I < NumElements; ++I) {                                 \
@@ -737,7 +723,7 @@ template <typename DataT, int NumElements> class vec {
   }                                                                            \
   template <typename T = DataT>                                                \
   friend                                                                       \
-      typename std::enable_if_t<(IsByte<T>::value), vec &> operator OPASSIGN(  \
+      typename std::enable_if_t<(detail::is_byte_v<T>), vec &> operator OPASSIGN(  \
           vec & Lhs, int shift) {                                              \
     Lhs = Lhs OP shift;                                                        \
     return Lhs;                                                                \
@@ -816,16 +802,16 @@ template <typename DataT, int NumElements> class vec {
   // OP is: ==, !=, <, >, <=, >=, &&, ||
   // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
   // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
-  __SYCL_RELLOGOP(==, (true))
-  __SYCL_RELLOGOP(!=, (true))
-  __SYCL_RELLOGOP(>, (true))
-  __SYCL_RELLOGOP(<, (true))
-  __SYCL_RELLOGOP(>=, (true))
-  __SYCL_RELLOGOP(<=, (true))
+  __SYCL_RELLOGOP(==, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(!=, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(>, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(<, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(>=, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(<=, (!detail::is_byte_v<T>))
 
   // Only available to integral types.
-  __SYCL_RELLOGOP(&&, (!detail::is_vgenfloat_v<T>) && (!IsByte<T>::value))
-  __SYCL_RELLOGOP(||, (!detail::is_vgenfloat_v<T>) && (!IsByte<T>::value))
+  __SYCL_RELLOGOP(&&, (!detail::is_vgenfloat_v<T>) && (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(||, (!detail::is_vgenfloat_v<T>) && (!detail::is_byte_v<T>))
 #undef __SYCL_RELLOGOP
 
 // ++ and -- operators are only allowed for DataT!=std::byte and DataT!=bool
@@ -847,10 +833,8 @@ template <typename DataT, int NumElements> class vec {
     return Ret;                                                                \
   }
 
-  __SYCL_UOP(++, +=,
-             (!std::is_same_v<T, std::byte>))
-  __SYCL_UOP(--, -=,
-             (!std::is_same_v<T, std::byte>))
+  __SYCL_UOP(++, +=, (!detail::is_byte_v<T>))
+  __SYCL_UOP(--, -=, (!detail::is_byte_v<T>))
 #undef __SYCL_UOP
 
   // operator~() available only when: dataT != float && dataT != double
@@ -876,7 +860,7 @@ template <typename DataT, int NumElements> class vec {
 
   // operator!. Not available for std::byte.
   template <typename T = DataT>
-  friend typename std::enable_if_t<(!IsByte<T>::value),
+  friend typename std::enable_if_t<(!detail::is_byte_v<T>),
                                    vec<detail::rel_t<DataT>, NumElements>>
   operator!(const vec &Rhs) {
 #ifdef __SYCL_DEVICE_ONLY__
@@ -899,7 +883,7 @@ template <typename DataT, int NumElements> class vec {
 
   // operator +. Not available for std::byte as it is not an arithmetic type.
   template <typename T = DataT>
-  friend typename std::enable_if_t<(!IsByte<T>::value), vec>
+  friend typename std::enable_if_t<(!detail::is_byte_v<T>), vec>
   operator+(const vec &Lhs) {
 #ifdef __SYCL_DEVICE_ONLY__
     auto extVec = sycl::bit_cast<vector_t>(Lhs);
@@ -914,7 +898,7 @@ template <typename DataT, int NumElements> class vec {
 
   // operator -. Not available for std::byte as it is not an arithmetic type.
   template <typename T = DataT>
-  friend typename std::enable_if_t<(!IsByte<T>::value), vec>
+  friend typename std::enable_if_t<(!detail::is_byte_v<T>), vec>
   operator-(const vec &Lhs) {
     namespace oneapi = sycl::ext::oneapi;
     vec Ret{};
@@ -944,7 +928,7 @@ template <typename DataT, int NumElements> class vec {
     assert(Index < NumElements && "Index out of range");
 
     // Special tratment required for std::byte for vec::Convert
-    if constexpr (IsByte<DataT>::value)
+    if constexpr (detail::is_byte_t<DataT>::value)
       return static_cast<int8_t>(m_Data[Index]);
     else
       return m_Data[Index];
@@ -1301,34 +1285,57 @@ class SwizzleOp {
 #ifdef __SYCL_BINOP
 #error "Undefine __SYCL_BINOP macro"
 #endif
-#define __SYCL_BINOP(BINOP)                                                    \
-  friend vec_t operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {        \
+#define __SYCL_BINOP(BINOP, COND)                                              \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec_t>                              \
+  operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {                     \
     vec_t Tmp = Rhs;                                                           \
     return Lhs BINOP Tmp;                                                      \
   }                                                                            \
-  friend vec_t operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {        \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec_t>                              \
+  operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {                     \
     vec_t Tmp = Lhs;                                                           \
     return Tmp BINOP Rhs;                                                      \
   }                                                                            \
-  friend vec_t operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {        \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec_t>                              \
+  operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {                     \
     vec_t Tmp = Rhs;                                                           \
     return Lhs BINOP Tmp;                                                      \
   }                                                                            \
-  friend vec_t operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {        \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec_t>                              \
+  operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {                     \
     vec_t Tmp = Lhs;                                                           \
     return Tmp BINOP Rhs;                                                      \
   }
 
-  __SYCL_BINOP(+)
-  __SYCL_BINOP(-)
-  __SYCL_BINOP(*)
-  __SYCL_BINOP(/)
-  __SYCL_BINOP(%)
-  __SYCL_BINOP(&)
-  __SYCL_BINOP(|)
-  __SYCL_BINOP(^)
-  __SYCL_BINOP(>>)
-  __SYCL_BINOP(<<)
+  __SYCL_BINOP(+, (!detail::is_byte_v<T>))
+  __SYCL_BINOP(-, (!detail::is_byte_v<T>))
+  __SYCL_BINOP(*, (!detail::is_byte_v<T>))
+  __SYCL_BINOP(/, (!detail::is_byte_v<T>))
+  __SYCL_BINOP(%, (!detail::is_byte_v<T>))
+  __SYCL_BINOP(&, true)
+  __SYCL_BINOP(|, true)
+  __SYCL_BINOP(^, true)
+  // We have special <<, >> operators for std::byte.
+  __SYCL_BINOP(>>, (!detail::is_byte_v<T>))
+  __SYCL_BINOP(<<, (!detail::is_byte_v<T>))
+
+  template <typename T = DataT>
+  friend typename std::enable_if_t<detail::is_byte_v<T>, vec_t>
+  operator >>(const SwizzleOp &Lhs, const int shift) {
+    vec_t Tmp = Lhs;
+    return Tmp >> shift;
+  }
+
+  template <typename T = DataT>
+  friend typename std::enable_if_t<detail::is_byte_v<T>, vec_t>
+  operator <<(const SwizzleOp &Lhs, const int shift) {
+    vec_t Tmp = Lhs;
+    return Tmp << shift;
+  }
 #undef __SYCL_BINOP
 
 // scalar RELLOGOP vec<>
@@ -1337,33 +1344,40 @@ class SwizzleOp {
 #ifdef __SYCL_RELLOGOP
 #error "Undefine __SYCL_RELLOGOP macro"
 #endif
-#define __SYCL_RELLOGOP(RELLOGOP)                                              \
-  friend vec_rel_t operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
+#define __SYCL_RELLOGOP(RELLOGOP, COND)                                        \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec_rel_t>                          \
+  operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) {                  \
     vec_t Tmp = Rhs;                                                           \
     return Lhs RELLOGOP Tmp;                                                   \
   }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec_rel_t>                          \
+  operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) {                  \
     vec_t Tmp = Lhs;                                                           \
     return Tmp RELLOGOP Rhs;                                                   \
   }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec_rel_t>                          \
+  operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) {                  \
     vec_t Tmp = Rhs;                                                           \
     return Lhs RELLOGOP Tmp;                                                   \
   }                                                                            \
-  friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
+  template <typename T = DataT>                                                \
+  friend typename std::enable_if_t<(COND), vec_rel_t>                          \
+  operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) {                  \
     vec_t Tmp = Lhs;                                                           \
     return Tmp RELLOGOP Rhs;                                                   \
   }
 
-  __SYCL_RELLOGOP(==)
-  __SYCL_RELLOGOP(!=)
-  __SYCL_RELLOGOP(>)
-  __SYCL_RELLOGOP(<)
-  __SYCL_RELLOGOP(>=)
-  __SYCL_RELLOGOP(<=)
-  // TODO: limit to integral types.
-  __SYCL_RELLOGOP(&&)
-  __SYCL_RELLOGOP(||)
+  __SYCL_RELLOGOP(==, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(!=, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(>, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(<, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(>=, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(<=, (!detail::is_byte_v<T>))
+  __SYCL_RELLOGOP(&&, (!detail::is_byte_v<T> && !detail::is_vgenfloat_v<T>))
+  __SYCL_RELLOGOP(||, (!detail::is_byte_v<T> && !detail::is_vgenfloat_v<T>))
 #undef __SYCL_RELLOGOP
 
   template <int IdxNum = getNumElements(),
diff --git a/sycl/test-e2e/Basic/vector/byte.cpp b/sycl/test-e2e/Basic/vector/byte.cpp
index f427d861f56ae..72f58b841d011 100644
--- a/sycl/test-e2e/Basic/vector/byte.cpp
+++ b/sycl/test-e2e/Basic/vector/byte.cpp
@@ -18,7 +18,7 @@
 #include <tuple>   // std::ignore
 
 int main() {
-  std::byte bt{7};
+  std::byte bt{2};
   // constructors
   sycl::vec<std::byte, 1> vb1(bt);
   sycl::vec<std::byte, 2> vb2{bt, bt};
@@ -46,8 +46,21 @@ int main() {
     auto cnv = vi2.convert<std::byte>();
     auto cnv2 = vb1.convert<int>();
 
+    assert(cnv[0] == std::byte{1} && cnv[1] == std::byte{1});
+    assert(cnv2[0] == 3);
+
     auto asint = vb2.template as<sycl::vec<int16_t, 1>>();
     auto asbyte = vi2.template as<sycl::vec<std::byte, 8>>();
+
+    // 0000 0010 0000 0010 = 514
+    assert(asint[0] == 514);
+
+    // 0000 0000 0000 0001 0000 0000 0000 0001
+    assert(asbyte[0] == std::byte{1} && asbyte[1] == std::byte{0} &&
+            asbyte[2] == std::byte{0} && asbyte[3] == std::byte{0} &&
+            asbyte[4] == std::byte{1} && asbyte[5] == std::byte{0} &&
+            asbyte[6] == std::byte{0} && asbyte[7] == std::byte{0}
+    );
   }
 
   // load() and store()
@@ -77,7 +90,7 @@ int main() {
         .wait();
   }
   assert(std_vec[0] == std::byte{2});
-  assert(std_vec[1] == std::byte{7});
+  assert(std_vec[1] == std::byte{2});
 
   // swizzle
   {
@@ -91,256 +104,274 @@ int main() {
     // hi/lo, even/odd
     sycl::vec<std::byte, 4> vbsw(std::byte{0}, std::byte{1}, std::byte{2},
                                  std::byte{3});
+
     sycl::vec<std::byte, 2> vbswhi = vbsw.hi();
-    assert(vbswhi[0] == std::byte{2});
+    assert(vbswhi[0] == std::byte{2} && vbswhi[1] == std::byte{3});
+
     vbswhi = vbsw.lo();
+    assert(vbswhi[0] == std::byte{0} && vbswhi[1] == std::byte{1});
+
     vbswhi = vbsw.odd();
+    assert(vbswhi[0] == std::byte{1} && vbswhi[1] == std::byte{3});
+
     vbswhi = vbsw.even();
+    assert(vbswhi[0] == std::byte{0} && vbswhi[1] == std::byte{2});
   }
 
   // operatorOP for vec and for swizzle
   {
-    sycl::vec<std::byte, 3> vop1{std::byte{4}, std::byte{9}, std::byte{25}};
-    sycl::vec<std::byte, 3> vop2{std::byte{2}, std::byte{3}, std::byte{5}};
-    sycl::vec<std::byte, 4> vop3{std::byte{5}, std::byte{6}, std::byte{2},
+    sycl::vec<std::byte, 3> VecByte3A{std::byte{4}, std::byte{9}, std::byte{25}};
+    sycl::vec<std::byte, 3> VecByte3B{std::byte{2}, std::byte{3}, std::byte{5}};
+    sycl::vec<std::byte, 4> VecByte4A{std::byte{5}, std::byte{6}, std::byte{2},
                                  std::byte{3}};
 
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-    // binary op for 2 vec
-    auto vop = vop1 + vop2;
-    assert(vop[0] == std::byte{6});
-    vop = vop1 - vop2;
-    vop = vop1 * vop2;
-    vop = vop1 / vop2;
-    assert(vop[0] == std::byte{2});
-    vop = vop1 % vop2;
-
-    // binary op for 2 swizzle
-    auto swlo = vop3.lo();
-    auto swhi = vop3.hi();
-    auto swplus = swlo + swhi;
-    sycl::vec<std::byte, 2> vec_test = swplus;
-    assert(vec_test.x() == std::byte{7} && vec_test.y() == std::byte{9});
-    auto swominus = swlo - swhi;
-    auto swmul = swlo * swhi;
-    vec_test = swmul;
-    assert(vec_test.x() == std::byte{10} && vec_test.y() == std::byte{18});
-    auto swdiv = swlo / swhi;
-
-    // binary op for 1 vec
-    vop = vop1 + std::byte{3};
-    vop = vop1 - std::byte{3};
-    assert(vop[1] == std::byte{6});
-    vop = vop1 * std::byte{3};
-    vop = vop1 / std::byte{3};
-    vop = vop1 % std::byte{3};
-    assert(vop[0] == std::byte{1});
-
-    vop = std::byte{3} + vop1;
-    assert(vop[0] == std::byte{7});
-    vop = std::byte{3} - vop1;
-    vop = std::byte{3} * vop1;
-    assert(vop[2] == std::byte{75});
-    vop = std::byte{3} / vop1;
-
-    // binary op for 1 swizzle
-    auto swplus1 = swlo + std::byte{3};
-    auto swminus1 = swlo - std::byte{3};
-    vec_test = swminus1;
-    assert(vec_test.x() == std::byte{2} && vec_test.y() == std::byte{3});
-    auto swmul1 = swlo * std::byte{3};
-    auto swdiv1 = swlo / std::byte{3};
-    vec_test = swdiv1;
-    assert(vec_test.x() == std::byte{1} && vec_test.y() == std::byte{2});
-
-    auto swplus2 = std::byte{3} + swlo;
-    vec_test = swplus2;
-    assert(vec_test.x() == std::byte{8} && vec_test.y() == std::byte{9});
-    auto swminus2 = std::byte{3} - swlo;
-    auto swmul2 = std::byte{3} * swlo;
-    vec_test = swmul2;
-    assert(vec_test.x() == std::byte{15} && vec_test.y() == std::byte{18});
-    auto swdiv2 = std::byte{3} / swlo;
-
-    // operatorOP= for 2 vec
-    sycl::vec<std::byte, 3> vbuf{std::byte{4}, std::byte{5}, std::byte{6}};
-    vop = vbuf += vop1;
-    assert(vop[0] == std::byte{8});
-    vop = vbuf -= vop1;
-    vop = vbuf *= vop1;
-    vop = vbuf /= vop1;
-    vop = vbuf %= vop1;
-
-    // operatorOP= for 2 swizzle
-    swlo += swhi;
-    swlo -= swhi;
-    vec_test = swlo;
-    assert(vec_test.x() == std::byte{5} && vec_test.y() == std::byte{6});
-    swlo *= swhi;
-    swlo /= swhi;
-    swlo %= swhi;
-
-    // operatorOP= for 1 vec
-    vop = vop1 += std::byte{3};
-    assert(vop[0] == std::byte{7});
-    vop = vop1 -= std::byte{3};
-    vop = vop1 *= std::byte{3};
-    vop = vop1 /= std::byte{3};
-    vop = vop1 %= std::byte{3};
-
-    // operatorOP= for 1 swizzle
-
-    swlo += std::byte{3};
-    swlo -= std::byte{1};
-    vec_test = swlo;
-    assert(vec_test.x() == std::byte{3} && vec_test.y() == std::byte{2});
-    swlo *= std::byte{3};
-    swlo /= std::byte{3};
-    swlo %= std::byte{3};
-
-    // unary operator++ and -- for vec
-    vop1 = sycl::vec<std::byte, 3>(std::byte{4}, std::byte{9}, std::byte{25});
-    vop1++;
-    vop1--;
-    vop = ++vop1;
-    assert(vop[2] == std::byte{26});
-    --vop1;
-
-    // unary operator++ and -- for swizzle
-    swlo++;
-    swlo--;
-    vec_test = swlo;
-    assert(vec_test.x() == std::byte{0} && vec_test.y() == std::byte{2});
-
-    // logical binary op for 2 vec
-    vop = vop1 & vop2;
-  #else // __INTEL_PREVIEW_BREAKING_CHANGES
-    auto vop = vop1 & vop2;
-    auto swlo = vop3.lo();
-    auto swhi = vop3.hi();
-  #endif // __INTEL_PREVIEW_BREAKING_CHANGES
-    vop = vop1 | vop2;
-    vop = vop1 ^ vop2;
-
-    // logical binary op for 2 swizzle
-    auto swand = swlo & swhi;
-    auto swor = swlo | swhi;
-    auto swxor = swlo ^ swhi;
-
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-    // logical binary op for 1 vec
-    vop = vop1 & std::byte{3};
-    vop = vop1 | std::byte{3};
-    vop = vop1 ^ std::byte{3};
-    vop = std::byte{3} & vop1;
-    vop = std::byte{3} | vop1;
-    vop = std::byte{3} ^ vop1;
-#else
+    // Test bitwise operations on vec<std::byte> and swizzles.
+    // Adding asserts on vec<> operations, and not swizzle operations,
+    // should suffice as swizzles just delegates the operation to vec<>
+    // class.
     {
+      auto SwizByte2A = VecByte4A.lo();
+      auto SwizByte2B = VecByte4A.hi();
+
+      // logical binary op for 2 vec
+      auto VecByte3And = VecByte3A & VecByte3B;
+      auto VecByte3Or = VecByte3A | VecByte3B;
+      auto VecByte3Xor = VecByte3A ^ VecByte3B;
+      assert(VecByte3And[0] == (VecByte3A[0] & VecByte3B[0]));
+      assert(VecByte3Or[1] == (VecByte3A[1] | VecByte3B[1]));
+      assert(VecByte3Xor[2] == (VecByte3A[2] ^ VecByte3B[2]));
+
+      // logical binary op for 2 swizzle
+      auto swand = SwizByte2A & SwizByte2B;
+      auto swor = SwizByte2A | SwizByte2B;
+      auto swxor = SwizByte2A ^ SwizByte2B;
+
       // Check order of operands for bitwise operators.
-      auto BitWiseAnd1 = vop1 & std::byte{3};
-      auto BitWiseOr1 = vop1 | std::byte{3};
-      auto BitWiseXor1 = vop1 ^ std::byte{3};
-      auto BitWiseAnd2 = std::byte{3} & vop1;
-      auto BitWiseOr2 = std::byte{3} | vop1;
-      auto BitWiseXor2 = std::byte{3} ^ vop1;
+      auto BitWiseAnd1 = VecByte3A & std::byte{3};
+      auto BitWiseOr1 = VecByte3A | std::byte{3};
+      auto BitWiseXor1 = VecByte3A ^ std::byte{3};
+      auto BitWiseAnd2 = std::byte{3} & VecByte3A;
+      auto BitWiseOr2 = std::byte{3} | VecByte3A;
+      auto BitWiseXor2 = std::byte{3} ^ VecByte3A;
       assert(BitWiseAnd1[0] == BitWiseAnd2[0]);
       assert(BitWiseOr1[1] == BitWiseOr2[1]);
       assert(BitWiseXor1[2] == BitWiseXor2[2]);
-    }
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 
-    // logical binary op for 1 swizzle
-    auto swand2 = swlo & std::byte{3};
-    auto swor2 = swlo | std::byte{3};
-    auto swxor2 = swlo ^ std::byte{3};
+      // logical binary op for 1 swizzle
+      auto swand2 = SwizByte2A & std::byte{3};
+      auto swor2 = SwizByte2A | std::byte{3};
+      auto swxor2 = SwizByte2A ^ std::byte{3};
 
-    auto swand3 = std::byte{3} & swlo;
-    auto swor3 = std::byte{3} | swlo;
-    auto swxor3 = std::byte{3} ^ swlo;
+      auto swand3 = std::byte{3} & SwizByte2A;
+      auto swor3 = std::byte{3} | SwizByte2A;
+      auto swxor3 = std::byte{3} ^ SwizByte2A;
 
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-    // bit binary op for 2 vec
-    vop = vop1 && vop2;
-    vop = vop1 || vop2;
-    vop = vop1 >> vop2;
-    vop = vop1 << vop2;
-
-    vop = vop1 >> std::byte{3};
-    vop = vop1 << std::byte{3};
-    vop = std::byte{3} >> vop1;
-    vop = std::byte{3} << vop1;
-
-    // bit binary op for 2 swizzle
-    swlo >> swhi;
-    swlo << swhi;
-    swlo >> std::byte{3};
-    swlo << std::byte{3};
-    auto right = std::byte{3} >> swhi;
-    auto left = std::byte{3} << swhi;
-#else
-    // std::byte is not an arithmetic type and it only supports the following
-    // overloads of >> and << operators.
-    //
-    // 1 template <class IntegerType>
-    //   constexpr std::byte operator<<( std::byte b, IntegerType shift )
-    //   noexcept;
-    // 2 template <class IntegerType>
-    //   constexpr std::byte operator>>( std::byte b, IntegerType shift )
-    //   noexcept;
-    vop = vop1 << 3;
-    vop = vop1 >> 3;
-
-    // TODO: Fix >> and << for swizzle of std::byte. Currently, Swizzles assume
-    // that both operands of the >> abd << operator have the same data type.
-    // That is not the case with std::byte.
-
-    // swlo >> 3;
-    // swlo << 3;
-#endif // __INTEL_PREVIEW_BREAKING_CHANGES
+      // bit-wise negation test
+      auto VecByte4Neg = ~VecByte4A;
+      assert(VecByte4Neg[0] == ~VecByte4A[0]);
 
-    // condition op for 2 vec
-    auto vres = vop1 == vop2;
-    vres = vop1 != vop2;
-    vres = vop1 > vop2;
-    vres = vop1 < vop2;
-    vres = vop1 >= vop2;
-    vres = vop1 <= vop2;
-
-    vres = vop1 == std::byte{3};
-    vres = vop1 != std::byte{3};
-    vres = vop1 > std::byte{3};
-    vres = vop1 < std::byte{3};
-    vres = vop1 >= std::byte{3};
-    vres = vop1 <= std::byte{3};
-
-    vres = std::byte{3} == vop1;
-    vres = std::byte{3} != vop1;
-    vres = std::byte{3} > vop1;
-    vres = std::byte{3} < vop1;
-    vres = std::byte{3} >= vop1;
-    vres = std::byte{3} <= vop1;
-
-    // condition op for 2 swizzle
-    auto swres = swhi == swlo;
-    auto swres1 = swhi != swlo;
-    auto swres2 = swhi > swlo;
-    auto swres3 = swhi < swlo;
-    auto swres4 = swhi >= swlo;
-    auto swres5 = swhi <= swlo;
-    auto swres6 = swhi == std::byte{3};
-    auto swres7 = swhi != std::byte{3};
-    auto swres8 = swhi > std::byte{3};
-    auto swres9 = swhi < std::byte{3};
-    auto swres10 = swhi >= std::byte{3};
-    auto swres11 = swhi <= std::byte{3};
-
-    sycl::vec<std::byte, 3> voptest{std::byte{4}, std::byte{9}, std::byte{25}};
-    auto bitv1 = ~vop3;
+      auto bitw = ~SwizByte2B;
+    }
+
+// std::byte is not an arithmetic type or a character type, so std::byte and
+// vec<std::byte> should not support artithmetic operations. In the new
+// implementation of vec<> class, the following will be removed.
 #ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-    auto bitv2 = !vop3;
+    {
+      // binary op for 2 vec
+      auto vop = VecByte3A + VecByte3B;
+      assert(vop[0] == std::byte{6});
+      vop = VecByte3A - VecByte3B;
+      vop = VecByte3A * VecByte3B;
+      vop = VecByte3A / VecByte3B;
+      assert(vop[0] == std::byte{2});
+      vop = VecByte3A % VecByte3B;
+
+      // binary op for 2 swizzle
+      auto swlo = VecByte4A.lo();
+      auto swhi = VecByte4A.hi();
+      auto swplus = swlo + swhi;
+      sycl::vec<std::byte, 2> vec_test = swplus;
+      assert(vec_test.x() == std::byte{7} && vec_test.y() == std::byte{9});
+      auto swominus = swlo - swhi;
+      auto swmul = swlo * swhi;
+      vec_test = swmul;
+      assert(vec_test.x() == std::byte{10} && vec_test.y() == std::byte{18});
+      auto swdiv = swlo / swhi;
+
+      // binary op for 1 vec
+      vop = VecByte3A + std::byte{3};
+      vop = VecByte3A - std::byte{3};
+      assert(vop[1] == std::byte{6});
+      vop = VecByte3A * std::byte{3};
+      vop = VecByte3A / std::byte{3};
+      vop = VecByte3A % std::byte{3};
+      assert(vop[0] == std::byte{1});
+
+      vop = std::byte{3} + VecByte3A;
+      assert(vop[0] == std::byte{7});
+      vop = std::byte{3} - VecByte3A;
+      vop = std::byte{3} * VecByte3A;
+      assert(vop[2] == std::byte{75});
+      vop = std::byte{3} / VecByte3A;
+
+      // binary op for 1 swizzle
+      auto swplus1 = swlo + std::byte{3};
+      auto swminus1 = swlo - std::byte{3};
+      vec_test = swminus1;
+      assert(vec_test.x() == std::byte{2} && vec_test.y() == std::byte{3});
+      auto swmul1 = swlo * std::byte{3};
+      auto swdiv1 = swlo / std::byte{3};
+      vec_test = swdiv1;
+      assert(vec_test.x() == std::byte{1} && vec_test.y() == std::byte{2});
+
+      auto swplus2 = std::byte{3} + swlo;
+      vec_test = swplus2;
+      assert(vec_test.x() == std::byte{8} && vec_test.y() == std::byte{9});
+      auto swminus2 = std::byte{3} - swlo;
+      auto swmul2 = std::byte{3} * swlo;
+      vec_test = swmul2;
+      assert(vec_test.x() == std::byte{15} && vec_test.y() == std::byte{18});
+      auto swdiv2 = std::byte{3} / swlo;
+
+      // operatorOP= for 2 vec
+      sycl::vec<std::byte, 3> vbuf{std::byte{4}, std::byte{5}, std::byte{6}};
+      vop = vbuf += VecByte3A;
+      assert(vop[0] == std::byte{8});
+      vop = vbuf -= VecByte3A;
+      vop = vbuf *= VecByte3A;
+      vop = vbuf /= VecByte3A;
+      vop = vbuf %= VecByte3A;
+
+      // operatorOP= for 2 swizzle
+      swlo += swhi;
+      swlo -= swhi;
+      vec_test = swlo;
+      assert(vec_test.x() == std::byte{5} && vec_test.y() == std::byte{6});
+      swlo *= swhi;
+      swlo /= swhi;
+      swlo %= swhi;
+
+      // operatorOP= for 1 vec
+      vop = VecByte3A += std::byte{3};
+      assert(vop[0] == std::byte{7});
+      vop = VecByte3A -= std::byte{3};
+      vop = VecByte3A *= std::byte{3};
+      vop = VecByte3A /= std::byte{3};
+      vop = VecByte3A %= std::byte{3};
+
+      // operatorOP= for 1 swizzle
+      swlo += std::byte{3};
+      swlo -= std::byte{1};
+      vec_test = swlo;
+      assert(vec_test.x() == std::byte{3} && vec_test.y() == std::byte{2});
+      swlo *= std::byte{3};
+      swlo /= std::byte{3};
+      swlo %= std::byte{3};
+
+      // unary operator++ and -- for vec
+      VecByte3A = sycl::vec<std::byte, 3>(std::byte{4}, std::byte{9}, std::byte{25});
+      VecByte3A++;
+      VecByte3A--;
+      vop = ++VecByte3A;
+      assert(vop[2] == std::byte{26});
+      --VecByte3A;
+
+      // unary operator++ and -- for swizzle
+      swlo++;
+      swlo--;
+      vec_test = swlo;
+      assert(vec_test.x() == std::byte{0} && vec_test.y() == std::byte{2});
+    }
+
+    // Logical operations on vec<byte> and swizzles.
+    {
+      // condition op for 2 vec
+      auto vres = VecByte3A == VecByte3B;
+      vres = VecByte3A != VecByte3B;
+      vres = VecByte3A > VecByte3B;
+      vres = VecByte3A < VecByte3B;
+      vres = VecByte3A >= VecByte3B;
+      vres = VecByte3A <= VecByte3B;
+
+      vres = VecByte3A == std::byte{3};
+      vres = VecByte3A != std::byte{3};
+      vres = VecByte3A > std::byte{3};
+      vres = VecByte3A < std::byte{3};
+      vres = VecByte3A >= std::byte{3};
+      vres = VecByte3A <= std::byte{3};
+
+      vres = std::byte{3} == VecByte3A;
+      vres = std::byte{3} != VecByte3A;
+      vres = std::byte{3} > VecByte3A;
+      vres = std::byte{3} < VecByte3A;
+      vres = std::byte{3} >= VecByte3A;
+      vres = std::byte{3} <= VecByte3A;
+
+      auto swlo = VecByte4A.lo();
+      auto swhi = VecByte4A.hi();
+
+      // condition op for 2 swizzle
+      auto swres = swhi == swlo;
+      auto swres1 = swhi != swlo;
+      auto swres2 = swhi > swlo;
+      auto swres3 = swhi < swlo;
+      auto swres4 = swhi >= swlo;
+      auto swres5 = swhi <= swlo;
+      auto swres6 = swhi == std::byte{3};
+      auto swres7 = swhi != std::byte{3};
+      auto swres8 = swhi > std::byte{3};
+      auto swres9 = swhi < std::byte{3};
+      auto swres10 = swhi >= std::byte{3};
+      auto swres11 = swhi <= std::byte{3};
+
+      // bit binary operations
+      auto vop = VecByte3A && VecByte3B;
+      vop = VecByte3A || VecByte3B;
+
+      auto vop1 = VecByte3A >> VecByte3B;
+      vop1 = VecByte3A << VecByte3B;
+
+      vop1 = VecByte3A >> std::byte{3};
+      vop1 = VecByte3A << std::byte{3};
+      vop1 = std::byte{3} >> VecByte3A;
+      vop1 = std::byte{3} << VecByte3A;
+
+      swlo >> swhi;
+      swlo << swhi;
+      swlo >> std::byte{3};
+      swlo << std::byte{3};
+      auto right = std::byte{3} >> swhi;
+      auto left = std::byte{3} << swhi;
+
+      auto bitv2 = !VecByte4A;
+    }
+#else
+    {
+      // std::byte is not an arithmetic type and it only supports the following
+      // overloads of >> and << operators.
+      //
+      // 1 template <class IntegerType>
+      //   constexpr std::byte operator<<( std::byte b, IntegerType shift )
+      //   noexcept;
+      // 2 template <class IntegerType>
+      //   constexpr std::byte operator>>( std::byte b, IntegerType shift )
+      //   noexcept;
+      auto VecByte3Shift = VecByte3A << 3;
+      assert(VecByte3Shift[0] == VecByte3A[0] << 3 &&
+             VecByte3Shift[1] == VecByte3A[1] << 3 &&
+             VecByte3Shift[2] == VecByte3A[2] << 3);
+
+      VecByte3Shift = VecByte3A >> 1;
+      assert(VecByte3Shift[0] == VecByte3A[0] >> 1 &&
+             VecByte3Shift[1] == VecByte3A[1] >> 1 &&
+             VecByte3Shift[2] == VecByte3A[2] >> 1);
+
+      auto SwizByte3Shift = VecByte4A.lo();
+      SwizByte3Shift >> 3;
+      SwizByte3Shift << 3;
+    }
 #endif // __INTEL_PREVIEW_BREAKING_CHANGES
-    auto bitw = ~swhi;
   }
 
   return 0;
diff --git a/sycl/test-e2e/Basic/vector/byte_preview.cpp b/sycl/test-e2e/Basic/vector/byte_preview.cpp
deleted file mode 100644
index 235b4726e195f..0000000000000
--- a/sycl/test-e2e/Basic/vector/byte_preview.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-// RUN: %if preview-breaking-changes-supported %{ %{build} -fpreview-breaking-changes -std=c++17 -o %t2.out %}
-// RUN: %if preview-breaking-changes-supported %{ %{run} %t2.out %}
-
-//==---------- vector_byte.cpp - SYCL vec<> for std::byte test -------------==//
-//
-// 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 <cstddef> // std::byte
-#include <tuple>   // std::ignore
-
-// std::byte is not an arithmetic type or a character type, so std::byte and
-// vec<std::byte> support a limited set of operations. Namely, bitwise
-// operations, comparison operations, and shift operations.
-
-int main() {
-  std::byte bt{7};
-  // constructors
-  sycl::vec<std::byte, 1> vb1(bt);
-  sycl::vec<std::byte, 2> vb2{bt, bt};
-  sycl::vec<std::byte, 3> vb3{bt, bt, bt};
-  sycl::vec<std::byte, 4> vb4{bt, bt, bt, bt};
-  sycl::vec<std::byte, 8> vb8{bt, bt, bt, bt, bt, bt, bt, bt};
-  sycl::vec<std::byte, 16> vb16{bt, bt, bt, std::byte{2}, bt, bt, bt, bt,
-                                bt, bt, bt, bt,           bt, bt, bt, bt};
-
-  {
-    // operator[]
-    assert(vb16[3] == std::byte{2});
-    // explicit conversion
-    std::ignore = std::byte(vb1.x());
-    std::byte b = vb1;
-
-    // operator=
-    auto vb4op = vb4;
-    vb1 = std::byte{3};
-  }
-
-  // convert() and as()
-  {
-    sycl::vec<int, 2> vi2(1, 1);
-    auto cnv = vi2.convert<std::byte>();
-    auto cnv2 = vb1.convert<int>();
-
-    auto asint = vb2.template as<sycl::vec<int16_t, 1>>();
-    auto asbyte = vi2.template as<sycl::vec<std::byte, 8>>();
-  }
-
-  // load() and store()
-  std::vector<std::byte> std_vec(8, bt);
-  {
-    sycl::buffer<std::byte, 1> Buf(std_vec.data(), sycl::range<1>(8));
-
-    sycl::queue Queue;
-    Queue
-        .submit([&](sycl::handler &cgh) {
-          auto Acc = Buf.get_access<sycl::access::mode::read_write>(cgh);
-          cgh.single_task<class st>([=]() {
-            // load
-            sycl::multi_ptr<std::byte,
-                            sycl::access::address_space::global_space,
-                            sycl::access::decorated::yes>
-                mp(Acc);
-            sycl::vec<std::byte, 8> sycl_vec;
-            sycl_vec.load(0, mp);
-            sycl_vec[0] = std::byte{2};
-            Acc[1] = std::byte{10};
-
-            // store
-            sycl_vec.store(0, mp);
-          });
-        })
-        .wait();
-  }
-  assert(std_vec[0] == std::byte{2});
-  assert(std_vec[1] == std::byte{7});
-
-  // swizzle
-  {
-    auto swizzled_vec = vb8.lo();
-
-    auto sw = vb8.template swizzle<sycl::elem::s0, sycl::elem::s1>()
-                  .template as<sycl::vec<int16_t, 1>>();
-    auto swbyte = sw.template as<sycl::vec<std::byte, 2>>();
-    auto swbyte2 = swizzled_vec.template as<sycl::vec<int, 1>>();
-
-    // hi/lo, even/odd
-    sycl::vec<std::byte, 4> vbsw(std::byte{0}, std::byte{1}, std::byte{2},
-                                 std::byte{3});
-    sycl::vec<std::byte, 2> vbswhi = vbsw.hi();
-    assert(vbswhi[0] == std::byte{2});
-    vbswhi = vbsw.lo();
-    vbswhi = vbsw.odd();
-    vbswhi = vbsw.even();
-  }
-
-  // operatorOP for vec and for swizzle
-  {
-    sycl::vec<std::byte, 3> vop1{std::byte{4}, std::byte{9}, std::byte{25}};
-    sycl::vec<std::byte, 3> vop2{std::byte{2}, std::byte{3}, std::byte{5}};
-    sycl::vec<std::byte, 4> vop3{std::byte{5}, std::byte{6}, std::byte{2},
-                                 std::byte{3}};
-
-    // logical binary op for 2 vec
-    auto vop = vop1 & vop2;
-    vop = vop1 | vop2;
-    vop = vop1 ^ vop2;
-
-    // logical binary op for 2 swizzle
-    auto swlo = vop3.lo();
-    auto swhi = vop3.hi();
-    auto swand = swlo & swhi;
-    auto swor = swlo | swhi;
-    auto swxor = swlo ^ swhi;
-
-    // logical binary op for 1 vec
-    vop = vop1 & std::byte{3};
-    vop = vop1 | std::byte{3};
-    vop = vop1 ^ std::byte{3};
-    vop = std::byte{3} & vop1;
-    vop = std::byte{3} | vop1;
-    vop = std::byte{3} ^ vop1;
-
-    // logical binary op for 1 swizzle
-    auto swand2 = swlo & std::byte{3};
-    auto swor2 = swlo | std::byte{3};
-    auto swxor2 = swlo ^ std::byte{3};
-
-    auto swand3 = std::byte{3} & swlo;
-    auto swor3 = std::byte{3} | swlo;
-    auto swxor3 = std::byte{3} ^ swlo;
-
-    // std::byte is not an arithmetic type and it only supports the following
-    // overloads of >> and << operators.
-    //
-    // 1 template <class IntegerType>
-    //   constexpr std::byte operator<<( std::byte b, IntegerType shift )
-    //   noexcept;
-    // 2 template <class IntegerType>
-    //   constexpr std::byte operator>>( std::byte b, IntegerType shift )
-    //   noexcept;
-    vop = vop1 << 3;
-    vop = vop1 >> 3;
-
-    // bit binary op for 2 swizzle
-    // TODO: Fix >> and << for swizzle of std::byte. Currently, Swizzles assume
-    // that both operands of the >> abd << operator have the same data type.
-    // That is not the case with std::byte.
-
-    // swlo >> 3;
-    // swlo << 3;
-
-    // condition op for 2 vec
-    auto vres = vop1 == vop2;
-    vres = vop1 != vop2;
-    vres = vop1 > vop2;
-    vres = vop1 < vop2;
-    vres = vop1 >= vop2;
-    vres = vop1 <= vop2;
-
-    vres = vop1 == std::byte{3};
-    vres = vop1 != std::byte{3};
-    vres = vop1 > std::byte{3};
-    vres = vop1 < std::byte{3};
-    vres = vop1 >= std::byte{3};
-    vres = vop1 <= std::byte{3};
-
-    vres = std::byte{3} == vop1;
-    vres = std::byte{3} != vop1;
-    vres = std::byte{3} > vop1;
-    vres = std::byte{3} < vop1;
-    vres = std::byte{3} >= vop1;
-    vres = std::byte{3} <= vop1;
-
-    // condition op for 2 swizzle
-    auto swres = swhi == swlo;
-    auto swres1 = swhi != swlo;
-    auto swres2 = swhi > swlo;
-    auto swres3 = swhi < swlo;
-    auto swres4 = swhi >= swlo;
-    auto swres5 = swhi <= swlo;
-    auto swres6 = swhi == std::byte{3};
-    auto swres7 = swhi != std::byte{3};
-    auto swres8 = swhi > std::byte{3};
-    auto swres9 = swhi < std::byte{3};
-    auto swres10 = swhi >= std::byte{3};
-    auto swres11 = swhi <= std::byte{3};
-
-    sycl::vec<std::byte, 3> voptest{std::byte{4}, std::byte{9}, std::byte{25}};
-    auto bitv1 = ~vop3;
-    auto bitw = ~swhi;
-  }
-
-  return 0;
-}
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 6c835881fbb29..bc6d2ec93c888 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -76,7 +76,7 @@ SYCL_EXTERNAL auto TestXor(vec<std::byte, 8> a, vec<std::byte, 8> b) {
 // CHECK:       for.cond.i.i:
 // CHECK-NEXT:    [[I_0_I_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I_I:%.*]], [[FOR_BODY_I_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I_I:%.*]] = icmp ult i64 [[I_0_I_I]], 4
-// CHECK-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLIBEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIBLI4EEEE4TYPEERKS5_S9__EXIT:%.*]]
+// CHECK-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLIBEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECIBLI4EEEE4TYPEERKS5_S9__EXIT:%.*]]
 // CHECK:       for.body.i.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I_I]]
 // CHECK-NEXT:    [[TMP2:%.*]] = load i8, ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
@@ -85,7 +85,7 @@ SYCL_EXTERNAL auto TestXor(vec<std::byte, 8> a, vec<std::byte, 8> b) {
 // CHECK-NEXT:    store i8 [[FROMBOOL_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
 // CHECK-NEXT:    [[INC_I_I]] = add nuw nsw i64 [[I_0_I_I]], 1
 // CHECK-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP29:![0-9]+]]
-// CHECK:       _ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIbLi4EEEE4typeERKS5_S9_.exit:
+// CHECK:       _ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIbLi4EEEE4typeERKS5_S9_.exit:
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
@@ -115,22 +115,22 @@ SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
-// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI3EEEE4TYPEERKS8_SC__EXIT:%.*]]
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECIS4_LI3EEEE4TYPEERKS8_SC__EXIT:%.*]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
 // CHECK-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[B_ASCAST]], i64 [[I_0_I]]
 // CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR7:[0-9]+]], !noalias [[META40:![0-9]+]]
-// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I10_I]]) #[[ATTR7]], !noalias [[META40]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8:[0-9]+]], !noalias [[META40:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I10_I]]) #[[ATTR8]], !noalias [[META40]]
 // CHECK-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA43:![0-9]+]], !noalias [[META40]]
-// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR7]], !noalias [[META40]]
+// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR8]], !noalias [[META40]]
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37]]
 // CHECK-NEXT:    [[ARRAYIDX_I12_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
 // CHECK-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[ARRAYIDX_I12_I]], align 2, !tbaa [[TBAA45:![0-9]+]], !alias.scope [[META37]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP47:![0-9]+]]
-// CHECK:       _ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li3EEEE4typeERKS8_SC_.exit:
+// CHECK:       _ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIS4_Li3EEEE4typeERKS8_SC_.exit:
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
@@ -155,32 +155,29 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
   return a > b;
 }
 
-// CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecISt4byteLi3EEES3_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.14") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.15") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META52:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-LABEL: define dso_local spir_func noundef <3 x i8> @_Z15TestGreaterThanN4sycl3_V13vecISt4byteLi3EEES3_(
+// CHECK-SAME: ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.14") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.14") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR5:[0-9]+]] !srcloc [[META52:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META53:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 4, !noalias [[META53]]
-// CHECK-NEXT:    [[LOADVEC4_I6_I:%.*]] = load <4 x i8>, ptr [[B]], align 4, !noalias [[META53]]
-// CHECK-NEXT:    [[TMP0:%.*]] = icmp ugt <4 x i8> [[LOADVEC4_I_I]], [[LOADVEC4_I6_I]]
-// CHECK-NEXT:    [[CMP_I:%.*]] = shufflevector <4 x i1> [[TMP0]], <4 x i1> poison, <3 x i32> <i32 0, i32 1, i32 2>
-// CHECK-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i8>
-// CHECK-NEXT:    [[EXTRACTVEC_I8_I:%.*]] = shufflevector <3 x i8> [[SEXT_I]], <3 x i8> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x i8> [[EXTRACTVEC_I8_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META53]]
-// CHECK-NEXT:    ret void
+// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1
+// CHECK-NEXT:    [[LOADVEC4_I_I2:%.*]] = load <4 x i8>, ptr [[B]], align 1
+// CHECK-NEXT:    [[TMP0:%.*]] = icmp ugt <4 x i8> [[LOADVEC4_I_I]], [[LOADVEC4_I_I2]]
+// CHECK-NEXT:    [[CMP:%.*]] = shufflevector <4 x i1> [[TMP0]], <4 x i1> poison, <3 x i32> <i32 0, i32 1, i32 2>
+// CHECK-NEXT:    [[SEXT:%.*]] = sext <3 x i1> [[CMP]] to <3 x i8>
+// CHECK-NEXT:    ret <3 x i8> [[SEXT]]
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
   return a > b;
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIbLi2EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.17") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.19") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META56:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.16") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META53:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META57:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META57]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META57]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META54:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META54]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META54]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
-// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META57]]
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META54]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
@@ -188,14 +185,14 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META60:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.19") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META57:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META61:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META61]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 16, !tbaa [[TBAA10]], !noalias [[META61]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META58:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META58]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 16, !tbaa [[TBAA10]], !noalias [[META58]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp ogt <8 x half> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <8 x i1> [[CMP_I]] to <8 x i16>
-// CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META61]]
+// CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META58]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
@@ -203,29 +200,29 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.24") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META64:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.23") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.25") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.25") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META61:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
 // CHECK-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META65:![0-9]+]])
-// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META65]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META62:![0-9]+]])
+// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META62]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
-// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTINS0_3EXT6ONEAPI8BFLOAT16EEENS0_3VECISLI4EEERKNS5_IS4_LI4EEES9__EXIT:%.*]]
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECISLI4EEEE4TYPEERKNS7_IS4_LI4EEESD__EXIT:%.*]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
 // CHECK-NEXT:    [[ARRAYIDX_I13_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[B_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR7]], !noalias [[META65]]
-// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I13_I]]) #[[ATTR7]], !noalias [[META65]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META62]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I13_I]]) #[[ATTR8]], !noalias [[META62]]
 // CHECK-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
 // CHECK-NEXT:    [[ARRAYIDX_I15_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I15_I]], align 2, !tbaa [[TBAA45]], !alias.scope [[META65]]
+// CHECK-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I15_I]], align 2, !tbaa [[TBAA45]], !alias.scope [[META62]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP68:![0-9]+]]
-// CHECK:       _ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENS0_3vecIsLi4EEERKNS5_IS4_Li4EEES9_.exit:
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP65:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIsLi4EEEE4typeERKNS7_IS4_Li4EEESD_.exit:
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
@@ -236,127 +233,127 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
 /********************** Unary Ops **********************/
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIiLi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.27") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.27") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META69:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.26") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.26") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META66:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META70:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 16, !noalias [[META70]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META67:![0-9]+]])
+// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 16, !noalias [[META67]]
 // CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i32>
 // CHECK-NEXT:    [[EXTRACTVEC_I2_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META70]]
+// CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META67]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecIiLi4EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META73:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.28") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.28") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META70:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META74:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META74]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META71:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META71]]
 // CHECK-NEXT:    [[SUB_I:%.*]] = sub <4 x i32> zeroinitializer, [[TMP0]]
-// CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META74]]
+// CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META71]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
 
 // Negation is not valid for std::byte. Therefore, using bitwise negation.
 // CHECK-LABEL: define dso_local spir_func void @_Z19TestBitwiseNegationN4sycl3_V13vecISt4byteLi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.30") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.30") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META77:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META74:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META78:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META78]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META75:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META75]]
 // CHECK-NEXT:    [[NOT_I:%.*]] = xor <16 x i8> [[TMP0]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
-// CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META78]]
+// CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META75]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META81:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.31") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META78:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META82:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META82]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META79:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META79]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <4 x i8> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <4 x i1> [[CMP_I]] to <4 x i8>
-// CHECK-NEXT:    store <4 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META82]]
+// CHECK-NEXT:    store <4 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META79]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.33") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.35") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META85:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.34") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META82:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META86:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META86]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META83:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META83]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp oeq <2 x half> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
-// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META86]]
+// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META83]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META89:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.21") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META86:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META90:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META90]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META87:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META87]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg <8 x half> [[TMP0]]
-// CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META90]]
+// CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META87]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META93:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.36") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META90:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META94:![0-9]+]])
-// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META94]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META91:![0-9]+]])
+// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META91]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
-// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR7]], !noalias [[META94]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META91]]
 // CHECK-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
 // CHECK-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
 // CHECK-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I10_I]], align 2, !tbaa [[TBAA45]], !alias.scope [[META94]]
+// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I10_I]], align 2, !tbaa [[TBAA45]], !alias.scope [[META91]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP97:![0-9]+]]
-// CHECK:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP94:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.38") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.38") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META98:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.37") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META95:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca float, align 4
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META99:![0-9]+]])
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META96:![0-9]+]])
 // CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    [[REF_TMP_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP_I]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META99]]
+// CHECK-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META96]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 16
-// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6ISBYTEIT_EE5VALUEENS0_3VECIS4_LI16EEEE4TYPEERKS8__EXIT:%.*]]
+// CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECIS4_LI16EEEE4TYPEERKS8__EXIT:%.*]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR7]], !noalias [[META99]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META96]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg float [[CALL_I_I_I]]
-// CHECK-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA43]], !noalias [[META99]]
+// CHECK-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA43]], !noalias [[META96]]
 // CHECK-NEXT:    [[ARRAYIDX_I9_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I10_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR7]], !noalias [[META99]]
-// CHECK-NEXT:    store i16 [[CALL_I_I10_I]], ptr addrspace(4) [[ARRAYIDX_I9_I]], align 2, !tbaa [[TBAA102:![0-9]+]], !alias.scope [[META99]]
+// CHECK-NEXT:    [[CALL_I_I10_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR8]], !noalias [[META96]]
+// CHECK-NEXT:    store i16 [[CALL_I_I10_I]], ptr addrspace(4) [[ARRAYIDX_I9_I]], align 2, !tbaa [[TBAA99:![0-9]+]], !alias.scope [[META96]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP104:![0-9]+]]
-// CHECK:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6IsByteIT_EE5valueENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP101:![0-9]+]]
+// CHECK:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void
 //

From 1e61bd1eaacff633acebb686cb20fe7ed6ae5cb9 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Mon, 27 May 2024 23:02:52 -0700
Subject: [PATCH 74/79] Store bool as it is, not as int8_t. All test passing.

---
 sycl/include/sycl/vector_preview.hpp          |  12 +-
 sycl/test/abi/layout_vec.cpp                  |   2 +-
 .../vector/vector_math_ops.cpp                | 164 +++++++++---------
 3 files changed, 87 insertions(+), 91 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 7193dfe7e7f5c..4c8fa4a44ef7b 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -154,7 +154,7 @@ template <typename DataT, int NumElements> class vec {
 
   // This represent type of underlying value. There should be only one field
   // in the class, so vec<float, 16> should be equal to float16 in memory.
-  using DataType = std::array<std::conditional_t<std::is_same_v<DataT, bool>, int8_t, DataT>, AdjustedNum>;
+  using DataType = std::array<DataT, AdjustedNum>;
 
 public:
 #ifdef __SYCL_DEVICE_ONLY__
@@ -396,8 +396,7 @@ template <typename DataT, int NumElements> class vec {
   // Available only when: NumElements == 1
   template <int N = NumElements>
   operator typename std::enable_if_t<N == 1, DataT>() const {
-    // Cast required to convert int8_t to bool.
-    return static_cast<DataT>(m_Data[0]);
+    return m_Data[0];
   }
 
   __SYCL2020_DEPRECATED("get_count() is deprecated, please use size() instead")
@@ -604,10 +603,9 @@ template <typename DataT, int NumElements> class vec {
 
 #ifdef __SYCL_DEVICE_ONLY__
   // Require only for std::bool.
-  void ConvertToDataT() {
+  inline void ConvertToDataT() {
     for (size_t i = 0; i < NumElements; ++i) {
-      DataT tmp = getValue(i);
-      setValue(i, tmp);
+      m_Data[i] = bit_cast<int8_t>(m_Data[i]) != 0;
     }
   }
 #endif
@@ -951,8 +949,6 @@ template <typename DataT, int NumElements> class vec {
 
     if constexpr (std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>)
       m_Data[Index] = sycl::bit_cast<DataT>(Value);
-    else if constexpr (std::is_same_v<DataT, bool>)
-      m_Data[Index] = static_cast<int8_t>(Value);
     else
       m_Data[Index] = Value;
 #endif
diff --git a/sycl/test/abi/layout_vec.cpp b/sycl/test/abi/layout_vec.cpp
index e0928ce364a81..3357641ca607a 100644
--- a/sycl/test/abi/layout_vec.cpp
+++ b/sycl/test/abi/layout_vec.cpp
@@ -33,7 +33,7 @@ SYCL_EXTERNAL void foo(sycl::vec<bool, 16>) {}
 // CHECK-NEXT: |  nvsize=16, nvalign=16]
 
 // FSYCL-PREVIEW-BREAKING-CHANGES-CHECK: 0 | class sycl::vec<_Bool, 16>
-// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: 0 | struct std::array<signed char, 16> m_Data
+// FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: 0 | struct std::array<_Bool, 16> m_Data
 // FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: 0 | typename _AT_Type::_Type _M_elems
 // FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: | [sizeof=16, dsize=16, align=16,
 // FSYCL-PREVIEW-BREAKING-CHANGES-CHECK-NEXT: |  nvsize=16, nvalign=16]
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index bc6d2ec93c888..25bac18de1ca7 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -78,38 +78,38 @@ SYCL_EXTERNAL auto TestXor(vec<std::byte, 8> a, vec<std::byte, 8> b) {
 // CHECK-NEXT:    [[CMP_I_I:%.*]] = icmp ult i64 [[I_0_I_I]], 4
 // CHECK-NEXT:    br i1 [[CMP_I_I]], label [[FOR_BODY_I_I]], label [[_ZN4SYCL3_V1PLIBEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECIBLI4EEEE4TYPEERKS5_S9__EXIT:%.*]]
 // CHECK:       for.body.i.i:
-// CHECK-NEXT:    [[ARRAYIDX_I_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I_I]]
-// CHECK-NEXT:    [[TMP2:%.*]] = load i8, ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
-// CHECK-NEXT:    [[TOBOOL_I_I:%.*]] = icmp ne i8 [[TMP2]], 0
-// CHECK-NEXT:    [[FROMBOOL_I_I:%.*]] = zext i1 [[TOBOOL_I_I]] to i8
-// CHECK-NEXT:    store i8 [[FROMBOOL_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [4 x i8], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I_I]]
+// CHECK-NEXT:    [[TMP2:%.*]] = load i8, ptr addrspace(4) [[ARRAYIDX_I_I_I_I]], align 1, !tbaa [[TBAA10]], !alias.scope [[META26]]
+// CHECK-NEXT:    [[CMP3_I_I:%.*]] = icmp ne i8 [[TMP2]], 0
+// CHECK-NEXT:    [[FROMBOOL_I_I:%.*]] = zext i1 [[CMP3_I_I]] to i8
+// CHECK-NEXT:    store i8 [[FROMBOOL_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I_I]], align 1, !tbaa [[TBAA29:![0-9]+]], !alias.scope [[META26]]
 // CHECK-NEXT:    [[INC_I_I]] = add nuw nsw i64 [[I_0_I_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP29:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I_I]], !llvm.loop [[LOOP31:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1plIbEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIbLi4EEEE4typeERKS5_S9_.exit:
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<bool, 4> a, vec<bool, 4> b) { return a + b; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_6detail9half_impl4halfELi3EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META31:![0-9]+]] !sycl_used_aspects [[META32:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.8") align 8 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.8") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META33:![0-9]+]] !sycl_used_aspects [[META34:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META33:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x half>, ptr [[A]], align 8, !noalias [[META33]]
-// CHECK-NEXT:    [[LOADVEC4_I6_I:%.*]] = load <4 x half>, ptr [[B]], align 8, !noalias [[META33]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META35:![0-9]+]])
+// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x half>, ptr [[A]], align 8, !noalias [[META35]]
+// CHECK-NEXT:    [[LOADVEC4_I6_I:%.*]] = load <4 x half>, ptr [[B]], align 8, !noalias [[META35]]
 // CHECK-NEXT:    [[TMP0:%.*]] = fadd <4 x half> [[LOADVEC4_I_I]], [[LOADVEC4_I6_I]]
 // CHECK-NEXT:    [[EXTRACTVEC_I8_I:%.*]] = shufflevector <4 x half> [[TMP0]], <4 x half> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x half> [[EXTRACTVEC_I8_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META33]]
+// CHECK-NEXT:    store <4 x half> [[EXTRACTVEC_I8_I]], ptr addrspace(4) [[AGG_RESULT]], align 8, !tbaa [[TBAA10]], !alias.scope [[META35]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z7TestAddN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] !srcloc [[META36:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.10") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] !srcloc [[META38:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I_I:%.*]] = alloca float, align 4
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
 // CHECK-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META37:![0-9]+]])
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META39:![0-9]+]])
 // CHECK-NEXT:    [[REF_TMP_ASCAST_I_I:%.*]] = addrspacecast ptr [[REF_TMP_I_I]] to ptr addrspace(4)
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
@@ -119,17 +119,17 @@ SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
 // CHECK-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[B_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8:[0-9]+]], !noalias [[META40:![0-9]+]]
-// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I10_I]]) #[[ATTR8]], !noalias [[META40]]
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META39]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8:[0-9]+]], !noalias [[META42:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I10_I]]) #[[ATTR8]], !noalias [[META42]]
 // CHECK-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
-// CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA43:![0-9]+]], !noalias [[META40]]
-// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR8]], !noalias [[META40]]
-// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META37]]
+// CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA45:![0-9]+]], !noalias [[META42]]
+// CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR8]], !noalias [[META42]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META39]]
 // CHECK-NEXT:    [[ARRAYIDX_I12_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[ARRAYIDX_I12_I]], align 2, !tbaa [[TBAA45:![0-9]+]], !alias.scope [[META37]]
+// CHECK-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[ARRAYIDX_I12_I]], align 2, !tbaa [[TBAA47:![0-9]+]], !alias.scope [[META39]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP47:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP49:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIS4_Li3EEEE4typeERKS8_SC_.exit:
 // CHECK-NEXT:    ret void
 //
@@ -141,14 +141,14 @@ SYCL_EXTERNAL auto TestAdd(vec<ext::oneapi::bfloat16, 3> a,
 /***************** Binary Logical Ops *******************/
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIiLi16EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META48:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.12") align 64 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.12") align 64 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META50:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META49:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 64, !tbaa [[TBAA10]], !noalias [[META49]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 64, !tbaa [[TBAA10]], !noalias [[META49]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META51:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr [[A]], align 64, !tbaa [[TBAA10]], !noalias [[META51]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[B]], align 64, !tbaa [[TBAA10]], !noalias [[META51]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <16 x i32> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <16 x i1> [[CMP_I]] to <16 x i32>
-// CHECK-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, !tbaa [[TBAA10]], !alias.scope [[META49]]
+// CHECK-NEXT:    store <16 x i32> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 64, !tbaa [[TBAA10]], !alias.scope [[META51]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
@@ -156,7 +156,7 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<int, 16> a, vec<int, 16> b) {
 }
 
 // CHECK-LABEL: define dso_local spir_func noundef <3 x i8> @_Z15TestGreaterThanN4sycl3_V13vecISt4byteLi3EEES3_(
-// CHECK-SAME: ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.14") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.14") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR5:[0-9]+]] !srcloc [[META52:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.14") align 4 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.14") align 4 [[B:%.*]]) local_unnamed_addr #[[ATTR5:[0-9]+]] !srcloc [[META54:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i8>, ptr [[A]], align 1
 // CHECK-NEXT:    [[LOADVEC4_I_I2:%.*]] = load <4 x i8>, ptr [[B]], align 1
@@ -170,14 +170,14 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<std::byte, 3> a, vec<std::byte, 3> b) {
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecIbLi2EEES2_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.16") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META53:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.16") align 2 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 2 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.18") align 2 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META55:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META54:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META54]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META54]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META56:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x i8>, ptr [[A]], align 2, !tbaa [[TBAA10]], !noalias [[META56]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <2 x i8>, ptr [[B]], align 2, !tbaa [[TBAA10]], !noalias [[META56]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp sgt <2 x i8> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i8>
-// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META54]]
+// CHECK-NEXT:    store <2 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 2, !tbaa [[TBAA10]], !alias.scope [[META56]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
@@ -185,14 +185,14 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<bool, 2> a, vec<bool, 2> b) {
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.19") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META57:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.20") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[B:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META59:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META58:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META58]]
-// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 16, !tbaa [[TBAA10]], !noalias [[META58]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META60:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META60]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x half>, ptr [[B]], align 16, !tbaa [[TBAA10]], !noalias [[META60]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp ogt <8 x half> [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <8 x i1> [[CMP_I]] to <8 x i16>
-// CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META58]]
+// CHECK-NEXT:    store <8 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META60]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
@@ -200,12 +200,12 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z15TestGreaterThanN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi4EEES5_(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.23") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.25") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.25") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META61:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.24") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[A:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.26") align 8 [[B:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META63:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
 // CHECK-NEXT:    [[B_ASCAST:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META62:![0-9]+]])
-// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META62]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META64:![0-9]+]])
+// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META64]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -214,14 +214,14 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
 // CHECK-NEXT:    [[ARRAYIDX_I13_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[B_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META62]]
-// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I13_I]]) #[[ATTR8]], !noalias [[META62]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META64]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I13_I]]) #[[ATTR8]], !noalias [[META64]]
 // CHECK-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
 // CHECK-NEXT:    [[ARRAYIDX_I15_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I15_I]], align 2, !tbaa [[TBAA45]], !alias.scope [[META62]]
+// CHECK-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I15_I]], align 2, !tbaa [[TBAA47]], !alias.scope [[META64]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP65:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP67:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIsLi4EEEE4typeERKNS7_IS4_Li4EEESD_.exit:
 // CHECK-NEXT:    ret void
 //
@@ -233,83 +233,83 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<ext::oneapi::bfloat16, 4> a,
 /********************** Unary Ops **********************/
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIiLi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.26") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.26") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META66:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.27") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.27") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META68:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META67:![0-9]+]])
-// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 16, !noalias [[META67]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META69:![0-9]+]])
+// CHECK-NEXT:    [[LOADVEC4_I_I:%.*]] = load <4 x i32>, ptr [[A]], align 16, !noalias [[META69]]
 // CHECK-NEXT:    [[EXTRACTVEC_I_I:%.*]] = shufflevector <4 x i32> [[LOADVEC4_I_I]], <4 x i32> poison, <3 x i32> <i32 0, i32 1, i32 2>
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <3 x i32> [[EXTRACTVEC_I_I]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <3 x i1> [[CMP_I]] to <3 x i32>
 // CHECK-NEXT:    [[EXTRACTVEC_I2_I:%.*]] = shufflevector <3 x i32> [[SEXT_I]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
-// CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META67]]
+// CHECK-NEXT:    store <4 x i32> [[EXTRACTVEC_I2_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META69]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<int, 3> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecIiLi4EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.28") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.28") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META70:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META72:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META71:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META71]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META73:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i32>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META73]]
 // CHECK-NEXT:    [[SUB_I:%.*]] = sub <4 x i32> zeroinitializer, [[TMP0]]
-// CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META71]]
+// CHECK-NEXT:    store <4 x i32> [[SUB_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META73]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<int, 4> a) { return -a; }
 
 // Negation is not valid for std::byte. Therefore, using bitwise negation.
 // CHECK-LABEL: define dso_local spir_func void @_Z19TestBitwiseNegationN4sycl3_V13vecISt4byteLi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.29") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.29") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META74:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.30") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.30") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META76:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META75:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META75]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META77:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i8>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META77]]
 // CHECK-NEXT:    [[NOT_I:%.*]] = xor <16 x i8> [[TMP0]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
-// CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META75]]
+// CHECK-NEXT:    store <16 x i8> [[NOT_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META77]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestBitwiseNegation(vec<std::byte, 16> a) { return ~a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecIbLi4EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.31") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META78:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.6") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META80:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META79:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META79]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META81:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <4 x i8>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META81]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq <4 x i8> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <4 x i1> [[CMP_I]] to <4 x i8>
-// CHECK-NEXT:    store <4 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META79]]
+// CHECK-NEXT:    store <4 x i8> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META81]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<bool, 4> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_6detail9half_impl4halfELi2EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.32") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.34") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META82:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.34") align 4 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.36") align 4 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META84:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META83:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META83]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META85:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <2 x half>, ptr [[A]], align 4, !tbaa [[TBAA10]], !noalias [[META85]]
 // CHECK-NEXT:    [[CMP_I:%.*]] = fcmp oeq <2 x half> [[TMP0]], zeroinitializer
 // CHECK-NEXT:    [[SEXT_I:%.*]] = sext <2 x i1> [[CMP_I]] to <2 x i16>
-// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META83]]
+// CHECK-NEXT:    store <2 x i16> [[SEXT_I]], ptr addrspace(4) [[AGG_RESULT]], align 4, !tbaa [[TBAA10]], !alias.scope [[META85]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<half, 2> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_6detail9half_impl4halfELi8EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.21") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.21") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META86:![0-9]+]] !sycl_used_aspects [[META32]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.22") align 16 [[AGG_RESULT:%.*]], ptr nocapture noundef readonly byval(%"class.sycl::_V1::vec.22") align 16 [[A:%.*]]) local_unnamed_addr #[[ATTR0]] !srcloc [[META88:![0-9]+]] !sycl_used_aspects [[META34]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META87:![0-9]+]])
-// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META87]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META89:![0-9]+]])
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x half>, ptr [[A]], align 16, !tbaa [[TBAA10]], !noalias [[META89]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg <8 x half> [[TMP0]]
-// CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META87]]
+// CHECK-NEXT:    store <8 x half> [[FNEG_I]], ptr addrspace(4) [[AGG_RESULT]], align 16, !tbaa [[TBAA10]], !alias.scope [[META89]]
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z12TestNegationN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi3EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.36") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META90:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.38") align 8 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.10") align 8 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META92:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META91:![0-9]+]])
-// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META91]]
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META93:![0-9]+]])
+// CHECK-NEXT:    store i64 0, ptr addrspace(4) [[AGG_RESULT]], align 8, !alias.scope [[META93]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -317,27 +317,27 @@ SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META91]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META93]]
 // CHECK-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
 // CHECK-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
 // CHECK-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I10_I]], align 2, !tbaa [[TBAA45]], !alias.scope [[META91]]
+// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I10_I]], align 2, !tbaa [[TBAA47]], !alias.scope [[META93]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP94:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP96:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
 // CHECK-NEXT:    ret void
 //
 SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 
 // CHECK-LABEL: define dso_local spir_func void @_Z9TestMinusN4sycl3_V13vecINS0_3ext6oneapi8bfloat16ELi16EEE(
-// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.37") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.37") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META95:![0-9]+]] !sycl_fixed_targets [[META6]] {
+// CHECK-SAME: ptr addrspace(4) dead_on_unwind noalias nocapture writable writeonly sret(%"class.sycl::_V1::vec.39") align 32 [[AGG_RESULT:%.*]], ptr noundef byval(%"class.sycl::_V1::vec.39") align 32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] !srcloc [[META97:![0-9]+]] !sycl_fixed_targets [[META6]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REF_TMP_I:%.*]] = alloca float, align 4
 // CHECK-NEXT:    [[A_ASCAST:%.*]] = addrspacecast ptr [[A]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META96:![0-9]+]])
+// CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata [[META98:![0-9]+]])
 // CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    [[REF_TMP_ASCAST_I:%.*]] = addrspacecast ptr [[REF_TMP_I]] to ptr addrspace(4)
-// CHECK-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META96]]
+// CHECK-NEXT:    tail call void @llvm.memset.p4.i64(ptr addrspace(4) noundef align 32 dereferenceable(32) [[AGG_RESULT]], i8 0, i64 32, i1 false), !alias.scope [[META98]]
 // CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 // CHECK:       for.cond.i:
 // CHECK-NEXT:    [[I_0_I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC_I:%.*]], [[FOR_BODY_I:%.*]] ]
@@ -345,14 +345,14 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECIS4_LI16EEEE4TYPEERKS8__EXIT:%.*]]
 // CHECK:       for.body.i:
 // CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META96]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META98]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg float [[CALL_I_I_I]]
-// CHECK-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA43]], !noalias [[META96]]
+// CHECK-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA45]], !noalias [[META98]]
 // CHECK-NEXT:    [[ARRAYIDX_I9_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I10_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR8]], !noalias [[META96]]
-// CHECK-NEXT:    store i16 [[CALL_I_I10_I]], ptr addrspace(4) [[ARRAYIDX_I9_I]], align 2, !tbaa [[TBAA99:![0-9]+]], !alias.scope [[META96]]
+// CHECK-NEXT:    [[CALL_I_I10_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR8]], !noalias [[META98]]
+// CHECK-NEXT:    store i16 [[CALL_I_I10_I]], ptr addrspace(4) [[ARRAYIDX_I9_I]], align 2, !tbaa [[TBAA101:![0-9]+]], !alias.scope [[META98]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
-// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP101:![0-9]+]]
+// CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP103:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I]])
 // CHECK-NEXT:    ret void

From 79012b7caba12f76b66e37fae297ea1b0b751474 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Mon, 27 May 2024 23:25:21 -0700
Subject: [PATCH 75/79] Refactor setValue and getValue

---
 sycl/include/sycl/vector_preview.hpp | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 4c8fa4a44ef7b..7dcf8c9d555e1 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -922,36 +922,30 @@ template <typename DataT, int NumElements> class vec {
   // setValue and getValue should be able to operate on different underlying
   // types: enum cl_float#N , builtin vector float#N, builtin type float.
   constexpr auto getValue(int Index) const {
-#ifndef __SYCL_DEVICE_ONLY__
-    assert(Index < NumElements && "Index out of range");
 
-    // Special tratment required for std::byte for vec::Convert
-    if constexpr (detail::is_byte_t<DataT>::value)
-      return static_cast<int8_t>(m_Data[Index]);
-    else
-      return m_Data[Index];
+  using RetType = typename std::conditional_t<detail::is_byte_v<DataT>, int8_t,
+#ifdef __SYCL_DEVICE_ONLY__
+    detail::element_type_for_vector_t<DataT>
 #else
+    DataT
+#endif
+  >;
 
+#ifdef __SYCL_DEVICE_ONLY__
     if constexpr (std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>)
-      return sycl::bit_cast<detail::element_type_for_vector_t<DataT>>(
-          m_Data[Index]);
+      return sycl::bit_cast<RetType>(m_Data[Index]);
     else
-      return static_cast<detail::element_type_for_vector_t<DataT>>(
-          m_Data[Index]);
 #endif
+      return static_cast<RetType>(m_Data[Index]);
   }
 
   constexpr void setValue(int Index, const DataT &Value) {
-#ifndef __SYCL_DEVICE_ONLY__
-    assert(Index < NumElements && "Index out of range");
-    m_Data[Index] = Value;
-#else
-
+#ifdef __SYCL_DEVICE_ONLY__
     if constexpr (std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>)
       m_Data[Index] = sycl::bit_cast<DataT>(Value);
     else
-      m_Data[Index] = Value;
 #endif
+      m_Data[Index] = Value;
   }
 
   // fields

From 1b260d056e483a69cb0f38610d0728858003eda6 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 28 May 2024 12:21:55 -0700
Subject: [PATCH 76/79] Address reviews.

---
 sycl/include/sycl/vector_preview.hpp | 36 +++++++++++-----------------
 1 file changed, 14 insertions(+), 22 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 7dcf8c9d555e1..6ee76866ea8fc 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -409,10 +409,16 @@ template <typename DataT, int NumElements> class vec {
 
   // We interpret bool as int8_t, std::byte as uint8_t for conversion to other
   // types.
+  // clang-format off
   template <typename T>
-  using ConvertBoolAndByteT = typename std::conditional_t<
-      std::is_same_v<T, bool>, int8_t,
-      typename std::conditional_t<detail::is_byte_v<T>, uint8_t, T>>;
+  using ConvertBoolAndByteT = typename detail::map_type<
+      T,
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+      std::byte, /*->*/ std::uint8_t,
+#endif
+      bool, /*->*/ std::int8_t,
+      T, /*->*/ T>::type;
+  // clang-format on
 
   // convertImpl can't be called with the same From and To types and therefore
   // we need this version of convert which is mostly no-op.
@@ -454,9 +460,8 @@ template <typename DataT, int NumElements> class vec {
 #endif
           NumElements > 1 &&
           // - vec storage has an equivalent OpenCL native vector it is
-          // implicitly
-          //   convertible to. There are some corner cases where it is not the
-          //   case with char, long and long long types.
+          //   implicitly convertible to. There are some corner cases where it
+          //   is not the case with char, long and long long types.
           std::is_convertible_v<vector_t, OpenCLVecT> &&
           std::is_convertible_v<ConvertTVecType, OpenCLVecR> &&
           // - it is not a signed to unsigned (or vice versa) conversion
@@ -515,25 +520,13 @@ template <typename DataT, int NumElements> class vec {
     return this;
   }
 
-  // ext_vector_type is used as an underlying type for sycl::vec on device.
-  // The problem is that for clang vector types the return of operator[] is a
-  // temporary and not a reference to the element in the vector. In practice
-  // reinterpret_cast<DataT *>(&m_Data)[i]; is working. According to
-  // http://llvm.org/docs/GetElementPtr.html#can-gep-index-into-vector-elements
-  // this is not disallowed now. But could probably be disallowed in the future.
-  // That is why tests are added to check that behavior of the compiler has
-  // not changed.
-  //
   // Implement operator [] in the same way for host and device.
-  // NOTE: aliasing the incompatible types of bfloat16 may lead to problems if
-  // aggressively optimized. Specializing with noinline to avoid as workaround.
-
   const DataT& operator[](int i) const {
-    return reinterpret_cast<const DataT *>(&m_Data)[i];
+    return m_Data[i];
   }
 
   DataT& operator[](int i) {
-    return reinterpret_cast<DataT *>(&m_Data)[i];
+    return m_Data[i];
   }
 
   // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
@@ -584,9 +577,8 @@ template <typename DataT, int NumElements> class vec {
   void store(size_t Offset,
              multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
     for (int I = 0; I < NumElements; I++) {
-      // Cast require for int8 -> std::byte conversion.
       *multi_ptr<DataT, Space, DecorateAddress>(
-          Ptr + Offset * NumElements + I) = static_cast<DataT>(m_Data[I]);
+          Ptr + Offset * NumElements + I) = m_Data[I];
     }
   }
   template <int Dimensions, access::mode Mode,

From 935c13935a1eeacef3455e766bc175e7314a7943 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 28 May 2024 12:27:27 -0700
Subject: [PATCH 77/79] Fix formatting

---
 sycl/include/sycl/vector_preview.hpp | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 6ee76866ea8fc..b8a47708c7f9c 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -521,13 +521,9 @@ template <typename DataT, int NumElements> class vec {
   }
 
   // Implement operator [] in the same way for host and device.
-  const DataT& operator[](int i) const {
-    return m_Data[i];
-  }
+  const DataT &operator[](int i) const { return m_Data[i]; }
 
-  DataT& operator[](int i) {
-    return m_Data[i];
-  }
+  DataT &operator[](int i) { return m_Data[i]; }
 
   // Begin hi/lo, even/odd, xyzw, and rgba swizzles.
 private:
@@ -577,8 +573,8 @@ template <typename DataT, int NumElements> class vec {
   void store(size_t Offset,
              multi_ptr<DataT, Space, DecorateAddress> Ptr) const {
     for (int I = 0; I < NumElements; I++) {
-      *multi_ptr<DataT, Space, DecorateAddress>(
-          Ptr + Offset * NumElements + I) = m_Data[I];
+      *multi_ptr<DataT, Space, DecorateAddress>(Ptr + Offset * NumElements +
+                                                I) = m_Data[I];
     }
   }
   template <int Dimensions, access::mode Mode,

From 7f3badd5b2d19fae25e59100c42997874a5f6d32 Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 28 May 2024 12:37:02 -0700
Subject: [PATCH 78/79] clang-format; update check_device_code/vector

---
 .../sycl/detail/generic_type_traits.hpp       |  7 +--
 sycl/include/sycl/vector_preview.hpp          | 63 ++++++++++---------
 sycl/test-e2e/Basic/vector/byte.cpp           | 15 ++---
 .../vector/vector_math_ops.cpp                | 40 ++++++------
 4 files changed, 63 insertions(+), 62 deletions(-)

diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index d51bc816d6cd8..cf00f3d01f381 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -255,13 +255,12 @@ inline constexpr bool is_genfloatptr_marray_v =
 template <typename T>
 using is_byte_t = typename
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-      std::is_same<T, std::byte>;
+    std::is_same<T, std::byte>;
 #else
-      std::false_type;
+    std::false_type;
 #endif
 
-template <typename T>
-inline constexpr bool is_byte_v = is_byte_t<T>::value;
+template <typename T> inline constexpr bool is_byte_v = is_byte_t<T>::value;
 
 template <typename T>
 using make_floating_point_t = make_type_t<T, gtl::scalar_floating_list>;
diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index b8a47708c7f9c..9424383ce02ae 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -163,8 +163,8 @@ template <typename DataT, int NumElements> class vec {
   // plugins (CTS fails).
   using vector_t = typename std::conditional_t<
       NumElements == 1, detail::element_type_for_vector_t<DataT>,
-        detail::element_type_for_vector_t<DataT> __attribute__((
-        ext_vector_type(NumElements)))>;
+      detail::element_type_for_vector_t<DataT> __attribute__((
+          ext_vector_type(NumElements)))>;
 #endif // __SYCL_DEVICE_ONLY__
 
 private:
@@ -614,8 +614,8 @@ template <typename DataT, int NumElements> class vec {
         Ret[I] = Lhs[I] BINOP Rhs[I];                                          \
       }                                                                        \
     } else {                                                                   \
-      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs);                         \
-      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs);                         \
+      vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs);                      \
+      vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs);                      \
       Ret = vec<DataT, NumElements>(                                           \
           (typename vec<DataT, NumElements>::vector_t)(                        \
               ExtVecLhs BINOP ExtVecRhs));                                     \
@@ -699,7 +699,7 @@ template <typename DataT, int NumElements> class vec {
   //   noexcept;
 #define __SYCL_SHIFT_BYTE(OP, OPASSIGN)                                        \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(detail::is_byte_v<T>), vec> operator OP(       \
+  friend typename std::enable_if_t<(detail::is_byte_v<T>), vec> operator OP(   \
       const vec & Lhs, int shift) {                                            \
     vec Ret;                                                                   \
     for (size_t I = 0; I < NumElements; ++I) {                                 \
@@ -708,9 +708,8 @@ template <typename DataT, int NumElements> class vec {
     return Ret;                                                                \
   }                                                                            \
   template <typename T = DataT>                                                \
-  friend                                                                       \
-      typename std::enable_if_t<(detail::is_byte_v<T>), vec &> operator OPASSIGN(  \
-          vec & Lhs, int shift) {                                              \
+  friend typename std::enable_if_t<(detail::is_byte_v<T>), vec &>              \
+  operator OPASSIGN(vec & Lhs, int shift) {                                    \
     Lhs = Lhs OP shift;                                                        \
     return Lhs;                                                                \
   }
@@ -852,7 +851,8 @@ template <typename DataT, int NumElements> class vec {
 #ifdef __SYCL_DEVICE_ONLY__
     if constexpr (!std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>) {
       auto extVec = sycl::bit_cast<vector_t>(Rhs);
-      vec<detail::rel_t<DataT>, NumElements> Ret{(typename vec<rel_t, NumElements>::vector_t)!extVec};
+      vec<detail::rel_t<DataT>, NumElements> Ret{
+          (typename vec<rel_t, NumElements>::vector_t) !extVec};
       return Ret;
     } else
 #endif // __SYCL_DEVICE_ONLY__
@@ -911,13 +911,14 @@ template <typename DataT, int NumElements> class vec {
   // types: enum cl_float#N , builtin vector float#N, builtin type float.
   constexpr auto getValue(int Index) const {
 
-  using RetType = typename std::conditional_t<detail::is_byte_v<DataT>, int8_t,
+    using RetType =
+        typename std::conditional_t<detail::is_byte_v<DataT>, int8_t,
 #ifdef __SYCL_DEVICE_ONLY__
-    detail::element_type_for_vector_t<DataT>
+                                    detail::element_type_for_vector_t<DataT>
 #else
-    DataT
+                                    DataT
 #endif
-  >;
+                                    >;
 
 #ifdef __SYCL_DEVICE_ONLY__
     if constexpr (std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>)
@@ -1265,26 +1266,26 @@ class SwizzleOp {
 #endif
 #define __SYCL_BINOP(BINOP, COND)                                              \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec_t>                              \
-  operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) {                     \
+  friend typename std::enable_if_t<(COND), vec_t> operator BINOP(              \
+      const DataT & Lhs, const SwizzleOp & Rhs) {                              \
     vec_t Tmp = Rhs;                                                           \
     return Lhs BINOP Tmp;                                                      \
   }                                                                            \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec_t>                              \
-  operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) {                     \
+  friend typename std::enable_if_t<(COND), vec_t> operator BINOP(              \
+      const SwizzleOp & Lhs, const DataT & Rhs) {                              \
     vec_t Tmp = Lhs;                                                           \
     return Tmp BINOP Rhs;                                                      \
   }                                                                            \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec_t>                              \
-  operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) {                     \
+  friend typename std::enable_if_t<(COND), vec_t> operator BINOP(              \
+      const vec_t & Lhs, const SwizzleOp & Rhs) {                              \
     vec_t Tmp = Rhs;                                                           \
     return Lhs BINOP Tmp;                                                      \
   }                                                                            \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec_t>                              \
-  operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) {                     \
+  friend typename std::enable_if_t<(COND), vec_t> operator BINOP(              \
+      const SwizzleOp & Lhs, const vec_t & Rhs) {                              \
     vec_t Tmp = Lhs;                                                           \
     return Tmp BINOP Rhs;                                                      \
   }
@@ -1303,14 +1304,14 @@ class SwizzleOp {
 
   template <typename T = DataT>
   friend typename std::enable_if_t<detail::is_byte_v<T>, vec_t>
-  operator >>(const SwizzleOp &Lhs, const int shift) {
+  operator>>(const SwizzleOp &Lhs, const int shift) {
     vec_t Tmp = Lhs;
     return Tmp >> shift;
   }
 
   template <typename T = DataT>
   friend typename std::enable_if_t<detail::is_byte_v<T>, vec_t>
-  operator <<(const SwizzleOp &Lhs, const int shift) {
+  operator<<(const SwizzleOp &Lhs, const int shift) {
     vec_t Tmp = Lhs;
     return Tmp << shift;
   }
@@ -1324,26 +1325,26 @@ class SwizzleOp {
 #endif
 #define __SYCL_RELLOGOP(RELLOGOP, COND)                                        \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec_rel_t>                          \
-  operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) {                  \
+  friend typename std::enable_if_t<(COND), vec_rel_t> operator RELLOGOP(       \
+      const DataT & Lhs, const SwizzleOp & Rhs) {                              \
     vec_t Tmp = Rhs;                                                           \
     return Lhs RELLOGOP Tmp;                                                   \
   }                                                                            \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec_rel_t>                          \
-  operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) {                  \
+  friend typename std::enable_if_t<(COND), vec_rel_t> operator RELLOGOP(       \
+      const SwizzleOp & Lhs, const DataT & Rhs) {                              \
     vec_t Tmp = Lhs;                                                           \
     return Tmp RELLOGOP Rhs;                                                   \
   }                                                                            \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec_rel_t>                          \
-  operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) {                  \
+  friend typename std::enable_if_t<(COND), vec_rel_t> operator RELLOGOP(       \
+      const vec_t & Lhs, const SwizzleOp & Rhs) {                              \
     vec_t Tmp = Rhs;                                                           \
     return Lhs RELLOGOP Tmp;                                                   \
   }                                                                            \
   template <typename T = DataT>                                                \
-  friend typename std::enable_if_t<(COND), vec_rel_t>                          \
-  operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) {                  \
+  friend typename std::enable_if_t<(COND), vec_rel_t> operator RELLOGOP(       \
+      const SwizzleOp & Lhs, const vec_t & Rhs) {                              \
     vec_t Tmp = Lhs;                                                           \
     return Tmp RELLOGOP Rhs;                                                   \
   }
diff --git a/sycl/test-e2e/Basic/vector/byte.cpp b/sycl/test-e2e/Basic/vector/byte.cpp
index 72f58b841d011..052e1b14269fd 100644
--- a/sycl/test-e2e/Basic/vector/byte.cpp
+++ b/sycl/test-e2e/Basic/vector/byte.cpp
@@ -57,10 +57,9 @@ int main() {
 
     // 0000 0000 0000 0001 0000 0000 0000 0001
     assert(asbyte[0] == std::byte{1} && asbyte[1] == std::byte{0} &&
-            asbyte[2] == std::byte{0} && asbyte[3] == std::byte{0} &&
-            asbyte[4] == std::byte{1} && asbyte[5] == std::byte{0} &&
-            asbyte[6] == std::byte{0} && asbyte[7] == std::byte{0}
-    );
+           asbyte[2] == std::byte{0} && asbyte[3] == std::byte{0} &&
+           asbyte[4] == std::byte{1} && asbyte[5] == std::byte{0} &&
+           asbyte[6] == std::byte{0} && asbyte[7] == std::byte{0});
   }
 
   // load() and store()
@@ -120,10 +119,11 @@ int main() {
 
   // operatorOP for vec and for swizzle
   {
-    sycl::vec<std::byte, 3> VecByte3A{std::byte{4}, std::byte{9}, std::byte{25}};
+    sycl::vec<std::byte, 3> VecByte3A{std::byte{4}, std::byte{9},
+                                      std::byte{25}};
     sycl::vec<std::byte, 3> VecByte3B{std::byte{2}, std::byte{3}, std::byte{5}};
     sycl::vec<std::byte, 4> VecByte4A{std::byte{5}, std::byte{6}, std::byte{2},
-                                 std::byte{3}};
+                                      std::byte{3}};
 
     // Test bitwise operations on vec<std::byte> and swizzles.
     // Adding asserts on vec<> operations, and not swizzle operations,
@@ -270,7 +270,8 @@ int main() {
       swlo %= std::byte{3};
 
       // unary operator++ and -- for vec
-      VecByte3A = sycl::vec<std::byte, 3>(std::byte{4}, std::byte{9}, std::byte{25});
+      VecByte3A =
+          sycl::vec<std::byte, 3>(std::byte{4}, std::byte{9}, std::byte{25});
       VecByte3A++;
       VecByte3A--;
       vop = ++VecByte3A;
diff --git a/sycl/test/check_device_code/vector/vector_math_ops.cpp b/sycl/test/check_device_code/vector/vector_math_ops.cpp
index 25bac18de1ca7..187641fa508cf 100644
--- a/sycl/test/check_device_code/vector/vector_math_ops.cpp
+++ b/sycl/test/check_device_code/vector/vector_math_ops.cpp
@@ -117,17 +117,17 @@ SYCL_EXTERNAL auto TestAdd(vec<half, 3> a, vec<half, 3> b) { return a + b; }
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1PLINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECIS4_LI3EEEE4TYPEERKS8_SC__EXIT:%.*]]
 // CHECK:       for.body.i:
-// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[B_ASCAST]], i64 [[I_0_I]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[A_ASCAST]], i64 0, i64 [[I_0_I]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I10_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[B_ASCAST]], i64 0, i64 [[I_0_I]]
 // CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META39]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8:[0-9]+]], !noalias [[META42:![0-9]+]]
-// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I10_I]]) #[[ATTR8]], !noalias [[META42]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I_I_I]]) #[[ATTR8:[0-9]+]], !noalias [[META42:![0-9]+]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I_I10_I]]) #[[ATTR8]], !noalias [[META42]]
 // CHECK-NEXT:    [[ADD_I_I:%.*]] = fadd float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-NEXT:    store float [[ADD_I_I]], ptr [[REF_TMP_I_I]], align 4, !tbaa [[TBAA45:![0-9]+]], !noalias [[META42]]
 // CHECK-NEXT:    [[CALL_I_I3_I_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I_I]]) #[[ATTR8]], !noalias [[META42]]
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[REF_TMP_I_I]]), !noalias [[META39]]
-// CHECK-NEXT:    [[ARRAYIDX_I12_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[ARRAYIDX_I12_I]], align 2, !tbaa [[TBAA47:![0-9]+]], !alias.scope [[META39]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I12_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
+// CHECK-NEXT:    store i16 [[CALL_I_I3_I_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I12_I]], align 2, !tbaa [[TBAA47:![0-9]+]], !alias.scope [[META39]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP49:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1plINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIS4_Li3EEEE4typeERKS8_SC_.exit:
@@ -212,14 +212,14 @@ SYCL_EXTERNAL auto TestGreaterThan(vec<half, 8> a, vec<half, 8> b) {
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 4
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1GTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECISLI4EEEE4TYPEERKNS7_IS4_LI4EEESD__EXIT:%.*]]
 // CHECK:       for.body.i:
-// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[ARRAYIDX_I13_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[B_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META64]]
-// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I13_I]]) #[[ATTR8]], !noalias [[META64]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[A_ASCAST]], i64 0, i64 [[I_0_I]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I13_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[B_ASCAST]], i64 0, i64 [[I_0_I]]
+// CHECK-NEXT:    [[CALL_I_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I_I_I]]) #[[ATTR8]], !noalias [[META64]]
+// CHECK-NEXT:    [[CALL_I_I2_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I_I13_I]]) #[[ATTR8]], !noalias [[META64]]
 // CHECK-NEXT:    [[CMP_I_I:%.*]] = fcmp ogt float [[CALL_I_I_I_I]], [[CALL_I_I2_I_I]]
 // CHECK-NEXT:    [[CONV5_I:%.*]] = sext i1 [[CMP_I_I]] to i16
-// CHECK-NEXT:    [[ARRAYIDX_I15_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I15_I]], align 2, !tbaa [[TBAA47]], !alias.scope [[META64]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I15_I:%.*]] = getelementptr inbounds [4 x i16], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
+// CHECK-NEXT:    store i16 [[CONV5_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I15_I]], align 2, !tbaa [[TBAA47]], !alias.scope [[META64]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP67:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1gtINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIsLi4EEEE4typeERKNS7_IS4_Li4EEESD_.exit:
@@ -316,12 +316,12 @@ SYCL_EXTERNAL auto TestMinus(vec<half, 8> a) { return -a; }
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 3
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NTINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECISLI3EEEE4TYPEERKNS7_IS4_LI3EEE_EXIT:%.*]]
 // CHECK:       for.body.i:
-// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META93]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [4 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[A_ASCAST]], i64 0, i64 [[I_0_I]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I_I_I]]) #[[ATTR8]], !noalias [[META93]]
 // CHECK-NEXT:    [[TOBOOL_I:%.*]] = fcmp oeq float [[CALL_I_I_I]], 0.000000e+00
 // CHECK-NEXT:    [[CONV3_I:%.*]] = sext i1 [[TOBOOL_I]] to i16
-// CHECK-NEXT:    [[ARRAYIDX_I10_I:%.*]] = getelementptr inbounds i16, ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
-// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I10_I]], align 2, !tbaa [[TBAA47]], !alias.scope [[META93]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I10_I:%.*]] = getelementptr inbounds [4 x i16], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
+// CHECK-NEXT:    store i16 [[CONV3_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I10_I]], align 2, !tbaa [[TBAA47]], !alias.scope [[META93]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP96:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1ntINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIsLi3EEEE4typeERKNS7_IS4_Li3EEE.exit:
@@ -344,13 +344,13 @@ SYCL_EXTERNAL auto TestNegation(vec<ext::oneapi::bfloat16, 3> a) { return !a; }
 // CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i64 [[I_0_I]], 16
 // CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I]], label [[_ZN4SYCL3_V1NGINS0_3EXT6ONEAPI8BFLOAT16EEENST9ENABLE_IFIXNTSR6DETAILE9IS_BYTE_VIT_EENS0_3VECIS4_LI16EEEE4TYPEERKS8__EXIT:%.*]]
 // CHECK:       for.body.i:
-// CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[A_ASCAST]], i64 [[I_0_I]]
-// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I]]) #[[ATTR8]], !noalias [[META98]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I_I:%.*]] = getelementptr inbounds [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[A_ASCAST]], i64 0, i64 [[I_0_I]]
+// CHECK-NEXT:    [[CALL_I_I_I:%.*]] = call spir_func noundef float @__devicelib_ConvertBF16ToFINTEL(ptr addrspace(4) noundef align 2 dereferenceable(2) [[ARRAYIDX_I_I_I_I]]) #[[ATTR8]], !noalias [[META98]]
 // CHECK-NEXT:    [[FNEG_I:%.*]] = fneg float [[CALL_I_I_I]]
 // CHECK-NEXT:    store float [[FNEG_I]], ptr [[REF_TMP_I]], align 4, !tbaa [[TBAA45]], !noalias [[META98]]
-// CHECK-NEXT:    [[ARRAYIDX_I9_I:%.*]] = getelementptr inbounds %"class.sycl::_V1::ext::oneapi::bfloat16", ptr addrspace(4) [[AGG_RESULT]], i64 [[I_0_I]]
+// CHECK-NEXT:    [[ARRAYIDX_I_I_I9_I:%.*]] = getelementptr inbounds [16 x %"class.sycl::_V1::ext::oneapi::bfloat16"], ptr addrspace(4) [[AGG_RESULT]], i64 0, i64 [[I_0_I]]
 // CHECK-NEXT:    [[CALL_I_I10_I:%.*]] = call spir_func noundef zeroext i16 @__devicelib_ConvertFToBF16INTEL(ptr addrspace(4) noundef align 4 dereferenceable(4) [[REF_TMP_ASCAST_I]]) #[[ATTR8]], !noalias [[META98]]
-// CHECK-NEXT:    store i16 [[CALL_I_I10_I]], ptr addrspace(4) [[ARRAYIDX_I9_I]], align 2, !tbaa [[TBAA101:![0-9]+]], !alias.scope [[META98]]
+// CHECK-NEXT:    store i16 [[CALL_I_I10_I]], ptr addrspace(4) [[ARRAYIDX_I_I_I9_I]], align 2, !tbaa [[TBAA101:![0-9]+]], !alias.scope [[META98]]
 // CHECK-NEXT:    [[INC_I]] = add nuw nsw i64 [[I_0_I]], 1
 // CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP103:![0-9]+]]
 // CHECK:       _ZN4sycl3_V1ngINS0_3ext6oneapi8bfloat16EEENSt9enable_ifIXntsr6detailE9is_byte_vIT_EENS0_3vecIS4_Li16EEEE4typeERKS8_.exit:

From 273229ad1eb8b9bfe5bff7d899b3122bc0d1456b Mon Sep 17 00:00:00 2001
From: "Agarwal, Udit" <udit.agarwal@intel.com>
Date: Tue, 28 May 2024 16:02:37 -0700
Subject: [PATCH 79/79] Remove cast

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

diff --git a/sycl/include/sycl/vector_preview.hpp b/sycl/include/sycl/vector_preview.hpp
index 9424383ce02ae..1d38fc08b287d 100644
--- a/sycl/include/sycl/vector_preview.hpp
+++ b/sycl/include/sycl/vector_preview.hpp
@@ -616,9 +616,7 @@ template <typename DataT, int NumElements> class vec {
     } else {                                                                   \
       vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs);                      \
       vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs);                      \
-      Ret = vec<DataT, NumElements>(                                           \
-          (typename vec<DataT, NumElements>::vector_t)(                        \
-              ExtVecLhs BINOP ExtVecRhs));                                     \
+      Ret = vec<DataT, NumElements>(ExtVecLhs BINOP ExtVecRhs);                \
       if constexpr (std::is_same_v<DataT, bool> && CONVERT) {                  \
         Ret.ConvertToDataT();                                                  \
       }                                                                        \
@@ -746,6 +744,8 @@ template <typename DataT, int NumElements> class vec {
     } else {                                                                   \
       vector_t ExtVecLhs = sycl::bit_cast<vector_t>(Lhs);                      \
       vector_t ExtVecRhs = sycl::bit_cast<vector_t>(Rhs);                      \
+      /* Cast required to convert unsigned char ext_vec_type to */             \
+      /* char ext_vec_type. */                                                 \
       Ret = vec<rel_t, NumElements>(                                           \
           (typename vec<rel_t, NumElements>::vector_t)(                        \
               ExtVecLhs RELLOGOP ExtVecRhs));                                  \