libstdc++: Make barrier::arrival_token a move-only class type

The standard only specifies that barrier::arrival_token is a move
constructible and move assignable type. We originally used a scoped enum
type, but that means we do not diagnose non-portable code that makes
copies of arrival tokens (or compares them for equality, or uses them as
keys in map!) This wraps the enum in a move-only class type, so that
users are forced to pass it correctly.

The move constructor and move assignment operator of the new class do
not zero out the moved-from token, as that would add additional
instructions. That means that passing a moved-from token will work with
our implementation, despite being a bug in the user code. We could
consider doing that zeroing out in debug mode.

libstdc++-v3/ChangeLog:

	* include/std/barrier (barrier::arrival_token): New move-only
	class that encapsulates the underlying token value.

diff --git a/libstdc++-v3/include/std/barrier b/libstdc++-v3/include/std/barrier
index e09212dfcb94e3a8055066ffacad6a5dde46a59d..6f2b9873500dd8577afc9fe79a09351690b14ae3 100644 (file)
--- a/libstdc++-v3/include/std/barrier
+++ b/libstdc++-v3/include/std/barrier
@@ -209,15 +209,27 @@ It looks different from literature pseudocode for two main reasons:
       __algorithm_t _M_b;
 
     public:
-      using arrival_token = typename __tree_barrier<_CompletionF>::arrival_token;
+      class arrival_token final
+      {
+      public:
+       arrival_token(arrival_token&&) = default;
+       arrival_token& operator=(arrival_token&&) = default;
+       ~arrival_token() = default;
+
+      private:
+       friend class barrier;
+       using __token = typename __algorithm_t::arrival_token;
+       explicit arrival_token(__token __tok) noexcept : _M_tok(__tok) { }
+       __token _M_tok;
+      };
 
       static constexpr ptrdiff_t
       max() noexcept
       { return __algorithm_t::max(); }
 
-      explicit barrier(ptrdiff_t __count,
-                      _CompletionF __completion = _CompletionF())
-         : _M_b(__count, std::move(__completion))
+      explicit
+      barrier(ptrdiff_t __count, _CompletionF __completion = _CompletionF())
+      : _M_b(__count, std::move(__completion))
       { }
 
       barrier(barrier const&) = delete;
@@ -225,11 +237,11 @@ It looks different from literature pseudocode for two main reasons:
 
       [[nodiscard]] arrival_token
       arrive(ptrdiff_t __update = 1)
-      { return _M_b.arrive(__update); }
+      { return arrival_token{_M_b.arrive(__update)}; }
 
       void
       wait(arrival_token&& __phase) const
-      { _M_b.wait(std::move(__phase)); }
+      { _M_b.wait(std::move(__phase._M_tok)); }
 
       void
       arrive_and_wait()