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.

1 files changed, 18 insertions, 6 deletions

diff --git a/libstdc++-v3/include/std/barrier b/libstdc++-v3/include/std/barrier
index e09212d..6f2b987 100644
--- 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()