Index: libcxx/include/experimental/simd
===================================================================
--- libcxx/include/experimental/simd
+++ libcxx/include/experimental/simd
@@ -685,6 +685,11 @@
   friend struct simd_mask;
 
 public:
+  using __raw_type = std::array<_Tp, __num_element>;
+
+  __simd_storage() = default;
+  void __assign(__raw_type __raw) { __storage_ = __raw; }
+  __raw_type __raw() const { return __storage_; }
   _Tp __get(size_t __index) const noexcept { return __storage_[__index]; };
   void __set(size_t __index, _Tp __val) noexcept {
     __storage_[__index] = __val;
@@ -702,6 +707,11 @@
   friend struct simd_mask;
 
 public:
+  using __raw_type = _Tp;
+
+  __simd_storage() = default;
+  void __assign(__raw_type __raw) { __storage_ = __raw; }
+  __raw_type __raw() const { return __storage_; }
   _Tp __get(size_t __index) const noexcept { return (&__storage_)[__index]; };
   void __set(size_t __index, _Tp __val) noexcept {
     (&__storage_)[__index] = __val;
@@ -804,6 +814,11 @@
   friend struct simd_mask;
 
 public:
+  using __raw_type = _StorageType;
+
+  __simd_storage() = default;
+  void __assign(__raw_type __raw) { __storage_ = __raw; }
+  __raw_type __raw() const { return __storage_; }
   _Tp __get(size_t __index) const noexcept { return __storage_[__index]; };
   void __set(size_t __index, _Tp __val) noexcept {
     __storage_[__index] = __val;
@@ -1036,12 +1051,22 @@
 template <class _Tp>
 _LIBCPP_INLINE_VAR constexpr bool is_simd_flag_type_v =
     is_simd_flag_type<_Tp>::value;
-template <class _Tp, size_t _Np>
+
+template <class _Tp, size_t _Np, class... _Abis>
 struct abi_for_size {
   using type = simd_abi::fixed_size<_Np>;
 };
-template <class _Tp, size_t _Np>
-using abi_for_size_t = typename abi_for_size<_Tp, _Np>::type;
+
+template <class _Tp, size_t _Np, _StorageKind __kind, int... __old_size>
+struct abi_for_size<_Tp, _Np, __simd_abi<__kind, __old_size>...> {
+  using type = __simd_abi<__kind, _Np>;
+};
+
+template <class _Tp, size_t _Np, class... _Abis>
+using abi_for_size_t = typename abi_for_size<_Tp, _Np, _Abis...>::type;
+
+template <class _Tp, size_t _Np, class... _Abis>
+using rebind_abi_t = abi_for_size_t<_Tp, _Np, _Abis...>;
 
 template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
 struct simd_size;
@@ -1146,32 +1171,184 @@
 template <class _Tp, size_t _Np>
 simd_mask<_Tp> to_compatible(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
 
+template <class _TupleType, class _Tp, size_t... __indices>
+_TupleType __split_tuple_impl(_Tp** __buffers,
+                              std::index_sequence<__indices...>) {
+  return _TupleType(typename std::tuple_element<__indices, _TupleType>::type(
+      __buffers[__indices], element_aligned_tag())...);
+}
+
+#if !defined(_LIBCPP_HAS_NO_VECTOR_EXTENSION) && defined(_LIBCPP_COMPILER_CLANG)
+template <size_t... __indices, class _Tp, int __num_element>
+simd<_Tp, __simd_abi<_StorageKind::_VecExt, sizeof...(__indices)>>
+__simd_shuffle(
+    const simd<_Tp, __simd_abi<_StorageKind::_VecExt, __num_element>>& __v,
+    const simd<_Tp, __simd_abi<_StorageKind::_VecExt, __num_element>>& __u,
+    std::index_sequence<__indices...> = {}) {
+  simd<_Tp, __simd_abi<_StorageKind::_VecExt, sizeof...(__indices)>> __ret;
+  __ret.__s_.__assign(__builtin_shufflevector(__v.__s_.__raw(),
+                                              __u.__s_.__raw(), __indices...));
+  return __ret;
+}
+#endif
+
+template <size_t... __indices, class _Tp, class _Abi1, class _Abi2>
+simd<_Tp, rebind_abi_t<_Tp, sizeof...(__indices), _Abi1, _Abi2>>
+__simd_shuffle(const simd<_Tp, _Abi1>& __v, const simd<_Tp, _Abi2>& __u,
+               std::index_sequence<__indices...> = {}) {
+  simd<_Tp, rebind_abi_t<_Tp, sizeof...(__indices), _Abi1, _Abi2>> __ret;
+  size_t __i = 0;
+  for (size_t __index : {__indices...}) {
+    __ret[__i++] =
+        __index < __v.size() ? __v[__index] : __u[__index - __v.size()];
+  }
+  return __ret;
+}
+
+template <size_t __first_size, class _Tp, class _Abi, size_t... __indices>
+tuple<
+    simd<_Tp, rebind_abi_t<_Tp, __first_size, _Abi>>,
+    simd<_Tp, rebind_abi_t<_Tp, simd<_Tp, _Abi>::size() - __first_size, _Abi>>>
+__split_to_two(const simd<_Tp, _Abi>& __v, std::index_sequence<__indices...>) {
+  static_assert(__first_size + sizeof...(__indices) == simd<_Tp, _Abi>::size(),
+                "");
+  return std::make_tuple(
+      __simd_shuffle(__v, __v, std::make_index_sequence<__first_size>()),
+      __simd_shuffle<(__first_size + __indices)...>(__v, __v));
+}
+
+template <size_t __size, class _Tp, class _Abi>
+std::tuple<simd<_Tp, _Abi>>
+__split_impl(const simd<_Tp, _Abi>& __v,
+             std::integral_constant<size_t, __size>) {
+  return std::make_tuple(__v);
+}
+
+template <size_t __first, size_t... __rest, class _Tp, class _Abi>
+tuple<simd<_Tp, rebind_abi_t<_Tp, __first, _Abi>>,
+      simd<_Tp, rebind_abi_t<_Tp, __rest, _Abi>>...>
+__split_impl(const simd<_Tp, _Abi>& __v,
+             std::integral_constant<size_t, __first>,
+             std::integral_constant<size_t, __rest>...) {
+  auto __res = __split_to_two<__first>(
+      __v, std::make_index_sequence<simd<_Tp, _Abi>::size() - __first>());
+  return std::tuple_cat(
+      std::make_tuple(std::get<0>(__res)),
+      __split_impl(std::get<1>(__res),
+                   std::integral_constant<size_t, __rest>()...));
+}
+
 template <size_t... __sizes, class _Tp, class _Abi>
-tuple<simd<_Tp, abi_for_size_t<_Tp, __sizes>>...> split(const simd<_Tp, _Abi>&);
+typename std::enable_if<
+    __variadic_sum<size_t>(__sizes...) == simd<_Tp, _Abi>::size(),
+    tuple<simd<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>>::type
+split(const simd<_Tp, _Abi>& __v) {
+  return __split_impl(__v, std::integral_constant<size_t, __sizes>()...);
+}
 
 template <size_t... __sizes, class _Tp, class _Abi>
-tuple<simd_mask<_Tp, abi_for_size_t<_Tp, __sizes>>...>
+tuple<simd_mask<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>
 split(const simd_mask<_Tp, _Abi>&);
 
+template <class _Tp, class _Abi, class _Abi2, size_t __array_size,
+          size_t... __indices>
+void __split_by_impl(const simd<_Tp, _Abi>& __v,
+                     std::array<simd<_Tp, _Abi2>, __array_size>* __arr,
+                     std::index_sequence<__indices...>) {
+  auto __tp = split<(__indices, simd<_Tp, _Abi2>::size())...>(__v);
+  int __not_used[]{((*__arr)[__indices] = std::get<__indices>(__tp), 0)...};
+  (void)__not_used;
+}
+
+template <size_t __array_size, class _Tp, class _Abi>
+typename std::enable_if<
+    simd_size<_Tp, _Abi>::value % __array_size == 0,
+    array<simd<_Tp, rebind_abi_t<
+                        _Tp, simd_size<_Tp, _Abi>::value / __array_size, _Abi>>,
+          __array_size>>::type
+split_by(const simd<_Tp, _Abi>& __v) {
+  array<simd<_Tp, rebind_abi_t<_Tp, simd_size<_Tp, _Abi>::value / __array_size,
+                               _Abi>>,
+        __array_size>
+      __ret;
+  __split_by_impl(__v, &__ret, std::make_index_sequence<__array_size>());
+  return __ret;
+}
+
 template <class _SimdType, class _Abi>
-array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
-                     _SimdType::size()>
-split(const simd<typename _SimdType::value_type, _Abi>&);
+typename std::enable_if<
+    is_simd<_SimdType>::value &&
+        simd_size<typename _SimdType::value_type, _Abi>::value %
+                _SimdType::size() ==
+            0,
+    array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
+                         _SimdType::size()>>::type
+split(const simd<typename _SimdType::value_type, _Abi>& __v) {
+  return split_by<simd_size<typename _SimdType::value_type, _Abi>::value /
+                  _SimdType::size()>(__v);
+}
+
+template <size_t __array_size, class _Tp, class _Abi>
+array<
+    simd_mask<_Tp, rebind_abi_t<_Tp, simd_size<_Tp, _Abi>::value / __array_size,
+                                _Abi>>,
+    __array_size>
+split_by(const simd_mask<_Tp, _Abi>& x);
 
 template <class _SimdType, class _Abi>
 array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
                      _SimdType::size()>
 split(const simd_mask<typename _SimdType::value_type, _Abi>&);
 
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> __concat_variadic(const simd<_Tp, _Abi>& __v) {
+  return __v;
+}
+
+template <class _Tp, class _Abi, class... _Abis>
+simd<_Tp, rebind_abi_t<_Tp,
+                       __variadic_sum<size_t>(simd_size<_Tp, _Abi>::value,
+                                              simd_size<_Tp, _Abis>::value...),
+                       _Abi, _Abis...>>
+__concat_variadic(const simd<_Tp, _Abi>& __first,
+                  const simd<_Tp, _Abis>&... __rest) {
+  return __simd_shuffle(
+      __first, __concat_variadic(__rest...),
+      std::make_index_sequence<__variadic_sum<size_t>(
+          simd_size<_Tp, _Abi>::value, simd_size<_Tp, _Abis>::value...)>());
+}
+
 template <class _Tp, class... _Abis>
-simd<_Tp, abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>>
-concat(const simd<_Tp, _Abis>&...);
+simd<_Tp,
+     rebind_abi_t<_Tp, __variadic_sum<size_t>(simd_size<_Tp, _Abis>::value...),
+                  _Abis...>>
+concat(const simd<_Tp, _Abis>&... __vs) {
+  return __concat_variadic(__vs...);
+}
+
+template <class _Tp, class _Abi, size_t _Np, size_t... __indices>
+simd<_Tp, rebind_abi_t<_Tp, _Np * simd<_Tp, _Abi>::size(), _Abi>>
+__concat_array(const std::array<simd<_Tp, _Abi>, _Np>& __arr,
+               std::index_sequence<__indices...>) {
+  return concat(__arr[__indices]...);
+}
+
+template <class _Tp, class _Abi, size_t _Np>
+simd<_Tp, rebind_abi_t<_Tp, _Np * simd<_Tp, _Abi>::size(), _Abi>>
+concat(const std::array<simd<_Tp, _Abi>, _Np>& __arr) {
+  return __concat_array(__arr, std::make_index_sequence<_Np>());
+}
 
 template <class _Tp, class... _Abis>
-simd_mask<_Tp,
-          abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>>
+simd_mask<_Tp, rebind_abi_t<
+                   _Tp, __variadic_sum<size_t>(simd_size<_Tp, _Abis>::value...),
+                   _Abis...>>
 concat(const simd_mask<_Tp, _Abis>&...);
 
+template <class _Tp, class _Abi, size_t _Np>
+simd_mask<_Tp, rebind_abi_t<_Tp, _Np, _Abi>>
+concat(const std::array<simd_mask<_Tp, _Abi>, _Np>&);
+
 // reductions [simd.mask.reductions]
 template <class _Tp, class _Abi>
 bool all_of(const simd_mask<_Tp, _Abi>&) noexcept;
@@ -1367,15 +1544,15 @@
             std::is_unsigned<_Tp>::value);
   }
 
-  template <class _Generator, size_t... __indicies>
+  template <class _Generator, size_t... __indices>
   static constexpr decltype(
       std::forward_as_tuple(std::declval<_Generator>()(
-          std::integral_constant<size_t, __indicies>())...),
+          std::integral_constant<size_t, __indices>())...),
       bool())
-  __can_generate(std::index_sequence<__indicies...>) {
+  __can_generate(std::index_sequence<__indices...>) {
     return !__variadic_sum<bool>(
         !__can_broadcast<decltype(std::declval<_Generator>()(
-            std::integral_constant<size_t, __indicies>()))>()...);
+            std::integral_constant<size_t, __indices>()))>()...);
   }
 
   template <class _Generator>
@@ -1383,11 +1560,11 @@
     return false;
   }
 
-  template <class _Generator, size_t... __indicies>
-  void __generator_init(_Generator&& __g, std::index_sequence<__indicies...>) {
-    int __not_used[]{((*this)[__indicies] =
-                          __g(std::integral_constant<size_t, __indicies>()),
-                      0)...};
+  template <class _Generator, size_t... __indices>
+  void __generator_init(_Generator&& __g, std::index_sequence<__indices...>) {
+    int __not_used[]{
+        ((*this)[__indices] = __g(std::integral_constant<size_t, __indices>()),
+         0)...};
     (void)__not_used;
   }
 
@@ -1505,6 +1682,15 @@
   friend mask_type operator<=(const simd&, const simd&);
   friend mask_type operator>(const simd&, const simd&);
   friend mask_type operator<(const simd&, const simd&);
+
+#if !defined(_LIBCPP_HAS_NO_VECTOR_EXTENSION) && defined(_LIBCPP_COMPILER_CLANG)
+  template <size_t... __indices, class _Up, int __num_element>
+  friend simd<_Up, __simd_abi<_StorageKind::_VecExt, sizeof...(__indices)>>
+  __simd_shuffle(
+      const simd<_Up, __simd_abi<_StorageKind::_VecExt, __num_element>>& __v,
+      const simd<_Up, __simd_abi<_StorageKind::_VecExt, __num_element>>& __u,
+      std::index_sequence<__indices...>);
+#endif
 };
 
 // [simd.mask.class]
Index: libcxx/test/std/experimental/simd/simd.horizontal/concat.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/experimental/simd/simd.horizontal/concat.pass.cpp
@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// template <class T, class... Abis>
+// simd<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>>
+// concat(const simd<T, Abis>&...);
+//
+// template <class T, class Abi, size_t N>
+// simd<T, rebind_abi_t<T, N * simd_size_v<T, Abi>, Abi>>
+// concat(const std::array<simd<T, Abi>, N>& __v);
+//
+// template <class T, class... Abis>
+// simd_mask<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>>
+// concat(const simd_mask<T, Abis>&...);
+//
+// template <class T, class Abi, size_t N>
+// simd_mask<T, rebind_abi_t<T, N * simd_size_v<T, Abi>, Abi>>
+// concat(const std::array<simd_mask<T, Abi>, N>&);
+
+#include <cassert>
+#include <cstdint>
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+void test_concat() {
+  auto v = ex::concat(ex::fixed_size_simd<int, 1>([](int i) { return i; }),
+                      ex::fixed_size_simd<int, 2>([](int i) { return i + 1; }),
+                      ex::fixed_size_simd<int, 3>([](int i) { return i + 3; }));
+  static_assert(v.size() == 6, "");
+  assert(v[0] == 0);
+  assert(v[1] == 1);
+  assert(v[2] == 2);
+  assert(v[3] == 3);
+  assert(v[4] == 4);
+  assert(v[5] == 5);
+}
+
+void test_concat_array() {
+  std::array<ex::fixed_size_simd<int, 2>, 2> arr;
+  arr[0] = ex::fixed_size_simd<int, 2>([](int) { return 0; });
+  arr[1] = ex::fixed_size_simd<int, 2>([](int) { return 1; });
+
+  auto v = ex::concat(arr);
+  static_assert(v.size() == 4, "");
+  assert(v[0] == 0);
+  assert(v[1] == 0);
+  assert(v[2] == 1);
+  assert(v[3] == 1);
+}
+
+void test_concat_native() {
+  std::array<ex::native_simd<int>, 2> arr;
+  arr[0] = ex::native_simd<int>([](int) { return 0; });
+  arr[1] = ex::native_simd<int>([](int) { return 1; });
+
+  auto v = ex::concat(arr);
+  auto n = ex::native_simd<int>::size();
+  assert(v.size() == n * 2);
+  for (size_t i = 0; i < n; i++) {
+    assert(v[i] == 0);
+  }
+  for (size_t i = n; i < 2 * n; i++) {
+    assert(v[i] == 1);
+  }
+}
+
+void compile_split_propagate_abi() {
+  static_assert(
+      std::is_same<typename decltype(
+                       ex::concat(ex::simd<int>(), ex::simd<int>()))::abi_type,
+                   ex::rebind_abi_t<int, ex::simd<int>::size() * 2,
+                                    ex::simd_abi::compatible<int>>>::value,
+      "");
+
+  static_assert(
+      std::is_same<typename decltype(
+                       ex::concat(ex::native_simd<int>(),
+                                  ex::native_simd<int>()))::abi_type,
+                   ex::rebind_abi_t<int, ex::native_simd<int>::size() * 2,
+                                    ex::simd_abi::native<int>>>::value,
+      "");
+}
+
+int main() {
+  test_concat();
+  test_concat_array();
+  test_concat_native();
+}
Index: libcxx/test/std/experimental/simd/simd.horizontal/split.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/experimental/simd/simd.horizontal/split.pass.cpp
@@ -0,0 +1,128 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// template <size_t... Sizes, class T, class Abi>
+// tuple<simd<T, abi_for_size_t<Sizes>>...> split(const simd<T, Abi>&);
+//
+// template <size_t... Sizes, class T, class Abi>
+// tuple<simd_mask<T, abi_for_size_t<Sizes>>...> split(const simd_mask<T,
+// Abi>&);
+//
+// template <class V, class Abi>
+// array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(
+//     const simd<typename V::value_type, Abi>&);
+//
+// template <class V, class Abi>
+// array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(
+//     const simd_mask<typename V::value_type, Abi>&);
+//
+// template <size_t n, class T, class A>
+// array<simd<T, rebind_abi_t<T, simd_size_v<T, A> / n, A>>, n> split_by(
+//     const simd<T, A>& x);
+//
+// template <size_t n, class T, class A>
+// array<simd_mask<T, rebind_abi_t<T, simd_size_v<T, A> / n, A>>, n> split_by(
+//     const simd_mask<T, A>& x);
+
+#include <cassert>
+#include <cstdint>
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+void test_split() {
+  auto t =
+      ex::split<1, 2, 3>(ex::fixed_size_simd<int, 6>([](int i) { return i; }));
+  static_assert(std::tuple_size<decltype(t)>::value == 3, "");
+
+  assert(std::get<0>(t).size() == 1);
+  assert(std::get<0>(t)[0] == 0);
+
+  assert(std::get<1>(t).size() == 2);
+  assert(std::get<1>(t)[0] == 1);
+  assert(std::get<1>(t)[1] == 2);
+
+  assert(std::get<2>(t).size() == 3);
+  assert(std::get<2>(t)[0] == 3);
+  assert(std::get<2>(t)[1] == 4);
+  assert(std::get<2>(t)[2] == 5);
+}
+
+void test_split_array() {
+  {
+    auto arr =
+        ex::split_by<2>(ex::fixed_size_simd<int, 6>([](int i) { return i; }));
+    static_assert(arr.size() == 2, "");
+
+    assert(arr[0].size() == 3);
+    assert(arr[0][0] == 0);
+    assert(arr[0][1] == 1);
+    assert(arr[0][2] == 2);
+
+    assert(arr[1].size() == 3);
+    assert(arr[1][0] == 3);
+    assert(arr[1][1] == 4);
+    assert(arr[1][2] == 5);
+  }
+  {
+    auto arr = ex::split<ex::fixed_size_simd<int, 3>>(
+        ex::fixed_size_simd<int, 6>([](int i) { return i; }));
+    static_assert(arr.size() == 2, "");
+
+    assert(arr[0].size() == 3);
+    assert(arr[0][0] == 0);
+    assert(arr[0][1] == 1);
+    assert(arr[0][2] == 2);
+
+    assert(arr[1].size() == 3);
+    assert(arr[1][0] == 3);
+    assert(arr[1][1] == 4);
+    assert(arr[1][2] == 5);
+  }
+}
+
+void compile_split_propagate_abi() {
+  using compatible_simd_half =
+      ex::simd<int, ex::rebind_abi_t<int, ex::simd<int>::size() / 2,
+                                     ex::simd_abi::compatible<int>>>;
+  using native_simd_half =
+      ex::simd<int, ex::rebind_abi_t<int, ex::native_simd<int>::size() / 2,
+                                     ex::simd_abi::native<int>>>;
+
+  static_assert(
+      std::is_same<
+          decltype(ex::split<ex::simd<int>::size() / 2,
+                             ex::simd<int>::size() / 2>(ex::simd<int>())),
+          std::tuple<compatible_simd_half, compatible_simd_half>>::value,
+      "");
+
+  static_assert(
+      std::is_same<decltype(ex::split<ex::native_simd<int>::size() / 2,
+                                      ex::native_simd<int>::size() / 2>(
+                       ex::native_simd<int>())),
+                   std::tuple<native_simd_half, native_simd_half>>::value,
+      "");
+
+  static_assert(std::is_same<decltype(ex::split_by<2>(ex::simd<int>())),
+                             std::array<compatible_simd_half, 2>>::value,
+                "");
+
+  static_assert(std::is_same<decltype(ex::split_by<2>(ex::native_simd<int>())),
+                             std::array<native_simd_half, 2>>::value,
+                "");
+}
+
+int main() {
+  test_split();
+  test_split_array();
+}