[libcxx] Add missing <experimental/simd> __simd_reference pieces based on R9.

libcxx/include/experimental/simd

public:
 
   operator _Vp() const { return __to_value_type(__ptr_->__get(__index_)); }
 
   __simd_reference operator=(_Vp __val) && {
     __ptr_->__set(__index_, __from_value_type(__val));
     return *this;
   }
 
+  template <class _Up>
+  __simd_reference operator=(__simd_reference<_Vp, _Up, _Abi>&& __ref) && {
+    return std::move(*this) = _Vp(__ref);
+  }
+
   __simd_reference operator++() && {
     return std::move(*this) = __ptr_->__get(__index_) + 1;
   }
 
   _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) =
                __from_value_type(__ptr_->__get(__index_) | __val);
   }
 
   __simd_reference operator^=(_Vp __val) && {
     return std::move(*this) =
                __from_value_type(__ptr_->__get(__index_) ^ __val);
   }
+
+  friend void swap(__simd_reference&& a, __simd_reference&& b) noexcept {
+    _Vp __val = std::move(b);
+    std::move(b) = std::move(a);
+    std::move(a) = __val;
+  }
+
+  friend void swap(_Vp& a, __simd_reference&& b) noexcept {
+    swap(std::move(b), a);
+  }
+
+  friend void swap(__simd_reference&& a, _Vp& b) noexcept {
+    _Vp __val = b;
+    b = std::move(a);
+    std::move(a) = __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);
       auto ret = c[0]--;
       assert(ret == 42);
       assert(c[0] == 42 - 1);
       assert(c[1] == 42);
     }
 
     {
       auto c = a;
+      c[0] = b[0];
+      assert(c[0] == 4);
+      assert(c[1] == 42);
+    }
+    {
+      auto c = a;
       c[0] += b[0];
       assert(c[0] == 42 + 4);
       assert(c[1] == 42);
     }
     {
       auto c = a;
       c[0] -= b[0];
       assert(c[0] == 42 - 4);
assert((a[0] || b[0]) == true);
       assert(c[1] == 42);
     }
     {
       auto c = a;
       c[0] ^= b[0];
       assert(c[0] == (42 ^ 4));
       assert(c[1] == 42);
     }
-
+    {
+      auto aa = a, bb = b;
+      swap(aa[0], bb[0]);
+      assert(aa[0] == 4);
+      assert(bb[0] == 42);
+      assert(aa[1] == 42);
+      assert(bb[1] == 4);
+    }
+    {
+      auto c = a;
+      int d = 4;
+      swap(c[0], d);
+      assert(c[0] == 4);
+      assert(d == 42);
+      assert(c[1] == 42);
+    }
+    {
+      auto c = a;
+      int d = 4;
+      swap(d, c[0]);
+      assert(c[0] == 4);
+      assert(d == 42);
+      assert(c[1] == 42);
+    }
     {
       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);
       auto ret = c[0]--;
       assert(ret == false);
       assert(bool(c[0]) == true);
       assert(bool(c[1]) == false);
     }
 
     {
       auto c = a;
+      c[0] = b[0];
+      assert(bool(c[0]) == true);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
       c[0] += b[0];
       assert(bool(c[0]) == true);
       assert(bool(c[1]) == false);
     }
     {
       auto c = a;
       c[0] -= b[0];
       assert(bool(c[0]) == true);
assert(bool((a[0] || b[0])) == true);
       assert(bool(c[1]) == false);
     }
     {
       auto c = a;
       c[0] ^= b[0];
       assert(bool(c[0]) == true);
       assert(bool(c[1]) == false);
     }
+    {
+      auto aa = a, bb = b;
+      swap(aa[0], bb[0]);
+      assert(aa[0] == true);
+      assert(bb[0] == false);
+      assert(aa[1] == false);
+      assert(bb[1] == true);
+    }
+    {
+      auto c = a;
+      bool d = true;
+      swap(c[0], d);
+      assert(c[0] == true);
+      assert(d == false);
+      assert(c[1] == false);
+    }
+    {
+      auto c = a;
+      bool d = true;
+      swap(d, c[0]);
+      assert(c[0] == true);
+      assert(d == false);
+      assert(c[1] == false);
+    }
 
     {
       auto c = a;
       (void)(a[0] + (c[0] += a[0]));
     }
     {
       auto c = a;
       (void)(a[0] + (c[0] -= a[0]));