[libcxx] clean up and complete <experimental/simd>

[timshen]

Summary

The cleanup patch adds sevreal TODOs for the following unimplemented
features:
*) aligned load
*) simd<> version of <cmath> functions

This patch declares the completion of my implementation of
<experimental/simd>.

[timshen]

Implement memory_alignment.

[timshen]

Update on template variable #ifdefs in tests.

[timshen]

Rebase.

libcxx/include/experimental/simd

int find_last_set(const simd_mask<_Tp, _Abi>& __m) {
   for (int __i = __m.size() - 1; __i >= 0; __i--) {
     if (__m[__i]) {
       return __i;
     }
   }
   return __m.size();
 }
 
-bool all_of(bool __v) noexcept { return __v; }
-bool any_of(bool __v) noexcept { return __v; }
-bool none_of(bool __v) noexcept { return !__v; }
+bool all_of(bool __val) noexcept { return __val; }
+bool any_of(bool __val) noexcept { return __val; }
+bool none_of(bool __val) noexcept { return !__val; }
 bool some_of(bool) noexcept { return false; }
-int popcount(bool __v) noexcept { return __v; }
+int popcount(bool __val) noexcept { return __val; }
 int find_first_set(bool) noexcept { return 0; }
 int find_last_set(bool) noexcept { return 0; }
 
 // reductions [simd.reductions]
 template <class _SimdType, class _BinaryOp>
 typename _SimdType::value_type __reduce(const _SimdType& __v, _BinaryOp __op) {
   auto __acc = __v[0];
   for (size_t __i = 1; __i < __v.size(); __i++) {
for (size_t __i = 0; __i < size(); __i++) {
       (*this)[__i] = static_cast<_Tp>(__v[__i]);
     }
   }
 
   // implicit broadcast constructor
   template <class _Up,
             class = typename std::enable_if<__can_broadcast<_Up>()>::type>
   simd(_Up&& __rv) {
-    auto __v = static_cast<_Tp>(__rv);
+    auto __val = static_cast<_Tp>(__rv);
     for (size_t __i = 0; __i < size(); __i++) {
-      (*this)[__i] = __v;
+      (*this)[__i] = __val;
     }
   }
 
   // generator constructor
   template <class _Generator,
             int = typename std::enable_if<
                 __can_generate<_Generator>(std::make_index_sequence<size()>()),
                 int>::type()>
public:
 
   static constexpr size_t size() noexcept {
     return simd<__element_type, _Abi>::size();
   }
 
   simd_mask() = default;
 
   // broadcast constructor
-  explicit simd_mask(value_type __value) noexcept {
+  explicit simd_mask(value_type __val) noexcept {
     for (size_t __i = 0; __i < size(); __i++) {
-      (*this)[__i] = __value;
+      (*this)[__i] = __val;
     }
   }
 
   // implicit type conversion constructor
   template <
       class _Up,
       class = typename std::enable_if<
           !std::is_void<_Up>::value &&
           std::is_same<abi_type, simd_abi::fixed_size<size()>>::value>::type>
   simd_mask(const simd_mask<_Up, simd_abi::fixed_size<size()>>& __v) noexcept {
     for (size_t __i = 0; __i < size(); __i++) {
       (*this)[__i] = __v[__i];
     }
   }
 
   // load constructor
   template <class _Flags, class = typename std::enable_if<
                               is_simd_flag_type<_Flags>::value>::type>
   simd_mask(const value_type* __buffer, _Flags) {
+    // TODO: optimize for overaligned flags
     for (size_t __i = 0; __i < size(); __i++) {
       (*this)[__i] = __buffer[__i];
     }
   }
 
   // loads [simd.mask.copy]
   template <class _Flags>
   typename std::enable_if<is_simd_flag_type<_Flags>::value>::type
   copy_from(const value_type* __buffer, _Flags) {
     *this = simd_mask(__buffer, _Flags());
   }
 
   template <class _Flags>
   typename std::enable_if<is_simd_flag_type<_Flags>::value>::type
   copy_to(value_type* __buffer, _Flags) const {
+    // TODO: optimize for overaligned flags
     for (size_t __i = 0; __i < size(); __i++) {
       __buffer[__i] = (*this)[__i];
     }
   }
 
   // scalar access [simd.mask.subscr]
   reference operator[](size_t __i) {
     return __ref_traits::__ref(&__s_.__s_, __i);
friend simd_mask operator!=(const simd_mask& __a,
                               const simd_mask& __b) noexcept {
     return simd_mask(__a.__s_ != __b.__s_);
   }
 };
 
 template <class _Tp, class _Abi, class _Up, class _Flags>
 void __mask_copy_to(const simd<_Tp, _Abi>& __v, const simd_mask<_Tp, _Abi>& __m,
                     _Up* __buffer, _Flags) {
+  // TODO: optimize for overaligned flags
   for (size_t __i = 0; __i < __v.size(); __i++) {
     if (__m[__i]) {
       __buffer[__i] = static_cast<_Up>(__v[__i]);
     }
   }
 }
 
 template <class _Tp, class _Abi, class _Up, class _Flags>
 void __mask_copy_to(const simd_mask<_Tp, _Abi>& __v,
                     const simd_mask<_Tp, _Abi>& __m, _Up* __buffer, _Flags) {
+  // TODO: optimize based on bool's bit pattern.
   for (size_t __i = 0; __i < __v.size(); __i++) {
     if (__m[__i]) {
       __buffer[__i] = static_cast<_Up>(__v[__i]);
     }
   }
 }
 
 template <class _Tp, class _Up, class _Flags>
-void __mask_copy_to(_Tp __v, bool __m, _Up* __buffer, _Flags) {
+void __mask_copy_to(_Tp __val, bool __m, _Up* __buffer, _Flags) {
   if (__m) {
-    *__buffer = static_cast<_Up>(__v);
+    *__buffer = static_cast<_Up>(__val);
   }
 }
 
 template <class _Tp, class _Abi, class _Up, class _Flags>
 void __mask_copy_from(simd<_Tp, _Abi>& __v, const simd_mask<_Tp, _Abi>& __m,
                       const _Up* __buffer, _Flags) {
   // TODO: optimize for overaligned flags
   for (size_t __i = 0; __i < __v.size(); __i++) {
void __mask_copy_from(simd_mask<_Tp, _Abi>& __v,
   for (size_t __i = 0; __i < __v.size(); __i++) {
     if (__m[__i]) {
       __v[__i] = static_cast<bool>(__buffer[__i]);
     }
   }
 }
 
 template <class _Tp, class _Up, class _Flags>
-void __mask_copy_from(_Tp& __v, bool __m, const _Up* __buffer, _Flags) {
+void __mask_copy_from(_Tp& __val, bool __m, const _Up* __buffer, _Flags) {
   if (__m) {
-    __v = static_cast<_Tp>(*__buffer);
+    __val = static_cast<_Tp>(*__buffer);
   }
 }
 
 template <class _ValueType>
 struct __simd_value_type_traits {
   static_assert(std::is_arithmetic<_ValueType>::value, "");
   using type = _ValueType;
 };

 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 hmax(const const_where_expression<_MaskType, _SimdType>& __w) {
   return __hmax(__simd_mask_friend::__simd_select(
       _SimdType(std::numeric_limits<typename _SimdType::value_type>::min()),
       __w.__v_, __w.__m_));
 }
 
+// TODO: Implement <cmath> functions for simd.
+
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
 
 #endif /* _LIBCPP_EXPERIMENTAL_SIMD */