diff --git a/libcxx/include/experimental/simd b/libcxx/include/experimental/simd
--- a/libcxx/include/experimental/simd
+++ b/libcxx/include/experimental/simd
@@ -230,6 +230,7 @@
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__functional/operations.h>
 #include <array>
+#include <bit>
 #include <experimental/__config>
 #include <experimental/__simd/scalar.h>
 #include <experimental/__simd/utility.h>
@@ -296,9 +297,30 @@
   friend void swap(__simd_reference&& __a, value_type& __b) noexcept;
 };
 
-struct element_aligned_tag {};
-struct vector_aligned_tag {};
-template<size_t> struct overaligned_tag {};
+struct element_aligned_tag {
+  template<class _Tp, class _Up = typename _Tp::value_type>
+  static constexpr size_t __alignment = bit_ceil(alignof(_Up));
+  template<class _Tp, class _Up>
+  static constexpr _Up* __apply(_Up* __ptr) {
+    return static_cast<_Up*>(__builtin_assume_aligned(__ptr, __alignment<_Tp, _Up>));
+  }
+};
+struct vector_aligned_tag {
+  template<class _Tp, class _Up = typename _Tp::value_type>
+  static constexpr size_t __alignment = bit_ceil(sizeof(_Up) * _Tp::size());
+  template<class _Tp, class _Up>
+  static constexpr _Up* __apply(_Up* __ptr) {
+    return static_cast<_Up*>(__builtin_assume_aligned(__ptr, __alignment<_Tp, _Up>));
+  }
+};
+template<size_t _Np> struct overaligned_tag {
+  template<class _Tp, class _Up = typename _Tp::value_type>
+  static constexpr size_t __alignment = bit_ceil(_Np);
+  template<class _Tp, class _Up>
+  static constexpr _Up* __apply(_Up* __ptr) {
+    return static_cast<_Up*>(__builtin_assume_aligned(__ptr, __alignment<_Tp, _Up>));
+  }
+};
 inline constexpr element_aligned_tag element_aligned{};
 inline constexpr vector_aligned_tag vector_aligned{};
 template<size_t _Np> inline constexpr overaligned_tag<_Np> overaligned{};
@@ -320,13 +342,18 @@
 template<class _Tp> struct is_abi_tag : __is_abi_tag_impl<_Tp> {};
 template<class _Tp> inline constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value;
 
-template<class _Tp> struct is_simd;
+template<class _Tp> struct is_simd : false_type {};
+template<class _Tp, class _Abi> struct is_simd<simd<_Tp, _Abi>> : true_type {};
 template<class _Tp> inline constexpr bool is_simd_v = is_simd<_Tp>::value;
 
-template<class _Tp> struct is_simd_mask;
+template<class _Tp> struct is_simd_mask : false_type {};
+template<class _Tp, class _Abi> struct is_simd_mask<simd_mask<_Tp, _Abi>> : true_type {};
 template<class _Tp> inline constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value;
 
-template<class _Tp> struct is_simd_flag_type;
+template<class _Tp> struct is_simd_flag_type : false_type {};
+template<> struct is_simd_flag_type<element_aligned_tag> : true_type {};
+template<> struct is_simd_flag_type<vector_aligned_tag> : true_type {};
+template<size_t _Np> struct is_simd_flag_type<overaligned_tag<_Np>> : true_type {};
 template<class _Tp> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<_Tp>::value;
 
 template<class _Tp, class _Abi, class = void> struct __simd_size_impl {};
@@ -337,7 +364,11 @@
 template<class _Tp, class _Abi = simd_abi::compatible<_Tp>>
   inline constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value;
 
-template<class _Tp, class _Up = typename _Tp::value_type> struct memory_alignment;
+template<class _Tp, class _Up, class = void> struct __memory_alignment_impl {};
+template<class _Tp, class _Up> struct __memory_alignment_impl<_Tp, _Up,
+  enable_if_t<(is_simd_v<_Tp> && __is_vectorizable<_Up>()) || (is_simd_mask_v<_Tp> && is_same_v<_Up, bool>)>>
+    : integral_constant<size_t, vector_aligned_tag::__alignment<_Tp, _Up>> {};
+template<class _Tp, class _Up = typename _Tp::value_type> struct memory_alignment : __memory_alignment_impl<_Tp, _Up> {};
 template<class _Tp, class _Up = typename _Tp::value_type>
   inline constexpr size_t memory_alignment_v = memory_alignment<_Tp, _Up>::value;
 
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.traits]
+// template <class T> struct ex::is_simd;
+// template <class T> inline constexpr bool ex::is_simd_v =
+// ex::is_simd<T>::value;
+
+#include "../test_utils.h"
+#include <cstdint>
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+struct CheckIsSimdTrue {
+  template <class _Tp>
+  void operator()() {
+    static_assert(_Tp::value);
+  }
+};
+
+struct CheckIsSimdFalse {
+  template <class _Tp>
+  void operator()() {
+    static_assert(!_Tp::value);
+  }
+};
+
+struct CheckIsSimdVTrue {
+  template <bool _Tp>
+  void operator()() {
+    static_assert(_Tp);
+  }
+};
+
+struct CheckIsSimdVFalse {
+  template <bool _Tp>
+  void operator()() {
+    static_assert(!_Tp);
+  }
+};
+
+template <class F, std::size_t _Np, class _Tp>
+void test_simd_abi() {}
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi() {
+  if constexpr (std::is_same<F, CheckIsSimdTrue>::value) {
+    F{}.template operator()<ex::is_simd<ex::simd<_Tp, SimdAbi>>>();
+  } else if constexpr (std::is_same<F, CheckIsSimdFalse>::value) {
+    F{}.template operator()<ex::is_simd<_Tp>>();
+    F{}.template operator()<ex::is_simd<ex::simd_mask<_Tp, SimdAbi>>>();
+  } else if constexpr (std::is_same<F, CheckIsSimdVTrue>::value) {
+    F{}.template operator()<ex::is_simd_v<ex::simd<_Tp, SimdAbi>>>();
+  } else {
+    F{}.template operator()<ex::is_simd_v<_Tp>>();
+    F{}.template operator()<ex::is_simd_v<ex::simd_mask<_Tp, SimdAbi>>>();
+  }
+
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<CheckIsSimdTrue>();
+  test_all_simd_abi<CheckIsSimdFalse>();
+  test_all_simd_abi<CheckIsSimdVTrue>();
+  test_all_simd_abi<CheckIsSimdVFalse>();
+  return 0;
+}
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.traits]
+// template <class T> struct is_simd_flag_type;
+// template <class T> inline constexpr bool ex::is_simd_flag_type_v = ex::is_simd_flag_type<T>::value;
+
+#include "../test_utils.h"
+#include <cstdint>
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+struct CheckIsSimdFlagTypeTrue {
+  template <class _Tp>
+  void operator()() {
+    static_assert(_Tp::value);
+  }
+};
+
+struct CheckIsSimdFlagTypeFalse {
+  template <class _Tp>
+  void operator()() {
+    static_assert(!_Tp::value);
+  }
+};
+
+struct CheckIsSimdFlagTypeVTrue {
+  template <bool _Tp>
+  void operator()() {
+    static_assert(_Tp);
+  }
+};
+
+struct CheckIsSimdFlagTypeVFalse {
+  template <bool _Tp>
+  void operator()() {
+    static_assert(!_Tp);
+  }
+};
+
+template <class F, std::size_t _Np, class _Tp>
+void test_simd_abi() {}
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi() {
+  if constexpr (std::is_same<F, CheckIsSimdFlagTypeTrue>::value) {
+    F{}.template operator()<ex::is_simd_flag_type<ex::element_aligned_tag>>();
+    F{}.template operator()<ex::is_simd_flag_type<ex::vector_aligned_tag>>();
+    F{}.template operator()<ex::is_simd_flag_type<ex::overaligned_tag<_Np>>>();
+  } else if constexpr (std::is_same<F, CheckIsSimdFlagTypeFalse>::value) {
+    F{}.template operator()<ex::is_simd_flag_type<_Tp>>();
+    F{}.template operator()<ex::is_simd_flag_type<ex::simd<_Tp, SimdAbi>>>();
+    F{}.template operator()<ex::is_simd_flag_type<ex::simd_mask<_Tp, SimdAbi>>>();
+  } else if constexpr (std::is_same<F, CheckIsSimdFlagTypeVTrue>::value) {
+    F{}.template operator()<ex::is_simd_flag_type_v<ex::element_aligned_tag>>();
+    F{}.template operator()<ex::is_simd_flag_type_v<ex::vector_aligned_tag>>();
+    F{}.template operator()<ex::is_simd_flag_type_v<ex::overaligned_tag<_Np>>>();
+  } else {
+    F{}.template operator()<ex::is_simd_flag_type_v<_Tp>>();
+    F{}.template operator()<ex::is_simd_flag_type_v<ex::simd<_Tp, SimdAbi>>>();
+    F{}.template operator()<ex::is_simd_flag_type_v<ex::simd_mask<_Tp, SimdAbi>>>();
+  }
+
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<CheckIsSimdFlagTypeTrue>();
+  test_all_simd_abi<CheckIsSimdFlagTypeFalse>();
+  test_all_simd_abi<CheckIsSimdFlagTypeVTrue>();
+  test_all_simd_abi<CheckIsSimdFlagTypeVFalse>();
+  return 0;
+}
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.traits]
+// template <class T> struct ex::is_simd_mask;
+// template <class T> inline constexpr bool ex::is_simd_mask_v = ex::is_simd_mask<T>::value;
+
+#include "../test_utils.h"
+#include <cstdint>
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+struct CheckIsSimdMaskTrue {
+  template <class _Tp>
+  void operator()() {
+    static_assert(_Tp::value);
+  }
+};
+
+struct CheckIsSimdMaskFalse {
+  template <class _Tp>
+  void operator()() {
+    static_assert(!_Tp::value);
+  }
+};
+
+struct CheckIsSimdMaskVTrue {
+  template <bool _Tp>
+  void operator()() {
+    static_assert(_Tp);
+  }
+};
+
+struct CheckIsSimdMaskVFalse {
+  template <bool _Tp>
+  void operator()() {
+    static_assert(!_Tp);
+  }
+};
+
+template <class F, std::size_t _Np, class _Tp>
+void test_simd_abi() {}
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi() {
+  if constexpr (std::is_same<F, CheckIsSimdMaskTrue>::value) {
+    F{}.template operator()<ex::is_simd_mask<ex::simd_mask<_Tp, SimdAbi>>>();
+  } else if constexpr (std::is_same<F, CheckIsSimdMaskFalse>::value) {
+    F{}.template operator()<ex::is_simd_mask<_Tp>>();
+    F{}.template operator()<ex::is_simd_mask<ex::simd<_Tp, SimdAbi>>>();
+  } else if constexpr (std::is_same<F, CheckIsSimdMaskVTrue>::value) {
+    F{}.template operator()<ex::is_simd_mask_v<ex::simd_mask<_Tp, SimdAbi>>>();
+  } else {
+    F{}.template operator()<ex::is_simd_mask_v<_Tp>>();
+    F{}.template operator()<ex::is_simd_mask_v<ex::simd<_Tp, SimdAbi>>>();
+  }
+
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<CheckIsSimdMaskTrue>();
+  test_all_simd_abi<CheckIsSimdMaskFalse>();
+  test_all_simd_abi<CheckIsSimdMaskVTrue>();
+  test_all_simd_abi<CheckIsSimdMaskVFalse>();
+  return 0;
+}
diff --git a/libcxx/test/std/experimental/simd/simd.traits/memory_alignment.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/memory_alignment.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/experimental/simd/simd.traits/memory_alignment.pass.cpp
@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.traits]
+// template <class T, class U = typename T::value_type> struct memory_alignment;
+// template <class T, class U = typename T::value_type>
+//   inline constexpr size_t memory_alignment_v = memory_alignment<T, U>::value;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+struct CheckMemoryAlignmentNative {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd<_Tp, SimdAbi>>{}.value == _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES);
+    static_assert(ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>> == _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES);
+  }
+};
+struct CheckMemoryAlignmentCompatible {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd<_Tp, SimdAbi>>{}.value == 16);
+    static_assert(ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>> == 16);
+  }
+};
+struct CheckMemoryAlignmentScalar {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd<_Tp, SimdAbi>>{}.value == sizeof(_Tp));
+    static_assert(ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>> == sizeof(_Tp));
+  }
+};
+
+struct CheckMemoryAlignmentFixedSize {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd<_Tp, SimdAbi>>{}.value == std::bit_ceil(sizeof(_Tp) * _Np));
+    static_assert(ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>> == std::bit_ceil(sizeof(_Tp) * _Np));
+  }
+};
+
+struct CheckMemoryAlignmentDeduce {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd<_Tp, SimdAbi>>{}.value == std::bit_ceil(sizeof(_Tp) * _Np));
+    static_assert(ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>> == std::bit_ceil(sizeof(_Tp) * _Np));
+  }
+};
+struct CheckMemoryAlignmentMask {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd_mask<_Tp, SimdAbi>>{}.value ==
+                  std::bit_ceil(sizeof(bool) * ex::simd_size_v<_Tp, SimdAbi>));
+    static_assert(ex::memory_alignment_v<ex::simd_mask<_Tp, SimdAbi>> ==
+                  std::bit_ceil(sizeof(bool) * ex::simd_size_v<_Tp, SimdAbi>));
+  }
+};
+template <class F, std::size_t _Np, class _Tp>
+void test_simd_abi() {}
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi() {
+  if constexpr (std::is_same_v<F, CheckMemoryAlignmentNative>) {
+    F{}.template operator()<_Tp, ex::simd_abi::native<_Tp>, _Np>();
+  } else if constexpr (std::is_same_v<F, CheckMemoryAlignmentCompatible>) {
+    F{}.template operator()<_Tp, ex::simd_abi::compatible<_Tp>, _Np>();
+  } else if constexpr (std::is_same_v<F, CheckMemoryAlignmentScalar>) {
+    F{}.template operator()<_Tp, ex::simd_abi::scalar, _Np>();
+  } else if constexpr (std::is_same_v<F, CheckMemoryAlignmentFixedSize>) {
+    F{}.template operator()<_Tp, ex::simd_abi::fixed_size<_Np>, _Np>();
+  } else if constexpr (std::is_same_v<F, CheckMemoryAlignmentDeduce>) {
+    F{}.template operator()<_Tp, ex::simd_abi::deduce_t<_Tp, _Np>, _Np>();
+  } else {
+    F{}.template operator()<_Tp, SimdAbi, _Np>();
+  }
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<CheckMemoryAlignmentNative>();
+  test_all_simd_abi<CheckMemoryAlignmentCompatible>();
+  test_all_simd_abi<CheckMemoryAlignmentScalar>();
+  test_all_simd_abi<CheckMemoryAlignmentFixedSize>();
+  test_all_simd_abi<CheckMemoryAlignmentDeduce>();
+  test_all_simd_abi<CheckMemoryAlignmentMask>();
+  return 0;
+}