[libcxx] fix a sanitizer-reported bug in <experimental/simd>

[timshen]

Summary

In __simd_reference, the conversion between bool and mask integer is
in wrong place.

libcxx/include/experimental/simd

public:
   _Vp operator--(int) && {
     auto __val = __ptr_->__get(__index_);
     __ptr_->__set(__index_, __val - 1);
     return __to_value_type(__val);
   }
 
   __simd_reference operator+=(_Vp __val) && {
     return std::move(*this) =
-               __ptr_->__get(__index_) + __from_value_type(__val);
+               __from_value_type(__ptr_->__get(__index_) + __val);
   }
 
   __simd_reference operator-=(_Vp __val) && {
     return std::move(*this) =
-               __ptr_->__get(__index_) - __from_value_type(__val);
+               __from_value_type(__ptr_->__get(__index_) - __val);
   }
 
   __simd_reference operator*=(_Vp __val) && {
     return std::move(*this) =
-               __ptr_->__get(__index_) * __from_value_type(__val);
+               __from_value_type(__ptr_->__get(__index_) * __val);
   }
 
   __simd_reference operator/=(_Vp __val) && {
     return std::move(*this) =
-               __ptr_->__get(__index_) / __from_value_type(__val);
+               __from_value_type(__ptr_->__get(__index_) / __val);
   }
 
   __simd_reference operator%=(_Vp __val) && {
     return std::move(*this) =
-               __ptr_->__get(__index_) % __from_value_type(__val);
+               __from_value_type(__ptr_->__get(__index_) % __val);
   }
 
   __simd_reference operator>>=(_Vp __val) && {
     return std::move(*this) =
-               __ptr_->__get(__index_) >> __from_value_type(__val);
+               __from_value_type(__ptr_->__get(__index_) >> __val);
   }
 
   __simd_reference operator<<=(_Vp __val) && {
-    return std::move(*this) = __ptr_->__get(__index_)
-                              << __from_value_type(__val);
+    return std::move(*this) =
+               __from_value_type(__ptr_->__get(__index_) << __val);
   }
 
   __simd_reference operator&=(_Vp __val) && {
     return std::move(*this) =
-               __ptr_->__get(__index_) & __from_value_type(__val);
+               __from_value_type(__ptr_->__get(__index_) & __val);
   }
 
   __simd_reference operator|=(_Vp __val) && {
     return std::move(*this) =
-               __ptr_->__get(__index_) | __from_value_type(__val);
+               __from_value_type(__ptr_->__get(__index_) | __val);
   }
 
   __simd_reference operator^=(_Vp __val) && {
     return std::move(*this) =
-               __ptr_->__get(__index_) ^ __from_value_type(__val);
+               __from_value_type(__ptr_->__get(__index_) ^ __val);
   }
 };
 
 template <class _To, class _From>
 constexpr auto __is_non_narrowing_convertible_impl(_From a [[gnu::unused]])
     -> decltype(_To{a}, true) {
   return true;
 }

libcxx/test/std/experimental/simd/simd.access/default.pass.cpp

assert((a[0] || b[0]) == true);
       (void)(a[0] + (c[0] /= a[0]));
     }
     {
       auto c = a;
       (void)(a[0] + (c[0] %= a[0]));
     }
     {
       auto c = a;
-      (void)(a[0] + (c[0] >>= a[0]));
+      (void)(a[0] + (c[0] >>= b[0]));
     }
     {
       auto c = a;
-      (void)(a[0] + (c[0] <<= a[0]));
+      (void)(a[0] + (c[0] <<= b[0]));
     }
     {
       auto c = a;
       (void)(a[0] + (c[0] &= a[0]));
     }
     {
       auto c = a;
       (void)(a[0] + (c[0] |= a[0]));

libcxx/test/std/experimental/simd/simd.mask.access/default.pass.cpp

assert(bool((a[0] || b[0])) == true);
       (void)(a[0] + (c[0] /= b[0]));
     }
     {
       auto c = a;
       (void)(a[0] + (c[0] %= b[0]));
     }
     {
       auto c = a;
-      (void)(a[0] + (c[0] >>= a[0]));
+      (void)(a[0] + (c[0] >>= b[0]));
     }
     {
       auto c = a;
-      (void)(a[0] + (c[0] <<= a[0]));
+      (void)(a[0] + (c[0] <<= b[0]));
     }
     {
       auto c = a;
       (void)(a[0] + (c[0] &= a[0]));
     }
     {
       auto c = a;
       (void)(a[0] + (c[0] |= a[0]));