head	1.1;
branch	1.1.1;
access;
symbols
	netbsd-11-0-RC5:1.1.1.11
	netbsd-11-0-RC4:1.1.1.11
	netbsd-11-0-RC3:1.1.1.11
	netbsd-11-0-RC2:1.1.1.11
	netbsd-11-0-RC1:1.1.1.11
	gcc-14-3-0:1.1.1.12
	perseant-exfatfs-base-20250801:1.1.1.11
	netbsd-11:1.1.1.11.0.2
	netbsd-11-base:1.1.1.11
	gcc-12-5-0:1.1.1.11
	netbsd-10-1-RELEASE:1.1.1.8
	perseant-exfatfs-base-20240630:1.1.1.10
	gcc-12-4-0:1.1.1.10
	perseant-exfatfs:1.1.1.9.0.2
	perseant-exfatfs-base:1.1.1.9
	netbsd-9-4-RELEASE:1.1.1.1.6.1
	netbsd-10-0-RELEASE:1.1.1.8
	netbsd-10-0-RC6:1.1.1.8
	netbsd-10-0-RC5:1.1.1.8
	netbsd-10-0-RC4:1.1.1.8
	netbsd-10-0-RC3:1.1.1.8
	netbsd-10-0-RC2:1.1.1.8
	netbsd-10-0-RC1:1.1.1.8
	gcc-12-3-0:1.1.1.9
	gcc-10-5-0:1.1.1.8
	netbsd-10:1.1.1.8.0.2
	netbsd-10-base:1.1.1.8
	netbsd-9-3-RELEASE:1.1.1.1.6.1
	gcc-10-4-0:1.1.1.8
	cjep_sun2x-base1:1.1.1.7
	cjep_sun2x:1.1.1.7.0.4
	cjep_sun2x-base:1.1.1.7
	cjep_staticlib_x-base1:1.1.1.7
	netbsd-9-2-RELEASE:1.1.1.1.6.1
	cjep_staticlib_x:1.1.1.7.0.2
	cjep_staticlib_x-base:1.1.1.7
	gcc-10-3-0:1.1.1.7
	netbsd-9-1-RELEASE:1.1.1.1.6.1
	gcc-9-3-0:1.1.1.6
	gcc-7-5-0:1.1.1.4
	phil-wifi-20200421:1.1.1.3
	phil-wifi-20200411:1.1.1.3
	is-mlppp:1.1.1.2.0.2
	is-mlppp-base:1.1.1.2
	phil-wifi-20200406:1.1.1.3
	gcc-8-4-0:1.1.1.5
	netbsd-9-0-RELEASE:1.1.1.1
	netbsd-9-0-RC2:1.1.1.1
	netbsd-9-0-RC1:1.1.1.1
	phil-wifi-20191119:1.1.1.2
	gcc-8-3-0:1.1.1.2
	netbsd-9:1.1.1.1.0.6
	netbsd-9-base:1.1.1.1
	phil-wifi:1.1.1.1.0.4
	phil-wifi-20190609:1.1.1.1
	pgoyette-compat-merge-20190127:1.1.1.1.2.2
	pgoyette-compat:1.1.1.1.0.2
	pgoyette-compat-20190127:1.1.1.1
	gcc-7-4-0:1.1.1.1
	FSF:1.1.1;
locks; strict;
comment	@# @;


1.1
date	2019.01.19.10.14.11;	author mrg;	state Exp;
branches
	1.1.1.1;
next	;
commitid	VQ8OwWIg5RS9kn8B;

1.1.1.1
date	2019.01.19.10.14.11;	author mrg;	state Exp;
branches
	1.1.1.1.2.1
	1.1.1.1.4.1
	1.1.1.1.6.1;
next	1.1.1.2;
commitid	VQ8OwWIg5RS9kn8B;

1.1.1.2
date	2019.10.01.09.36.06;	author mrg;	state Exp;
branches;
next	1.1.1.3;
commitid	smvgr2IPAQDr89FB;

1.1.1.3
date	2020.03.11.08.15.49;	author mrg;	state Exp;
branches;
next	1.1.1.4;
commitid	AhKhCnGPUZgytXZB;

1.1.1.4
date	2020.08.11.05.10.39;	author mrg;	state Exp;
branches;
next	1.1.1.5;
commitid	5dBRDT7i6e65xBjC;

1.1.1.5
date	2020.08.11.05.30.09;	author mrg;	state Exp;
branches;
next	1.1.1.6;
commitid	7AI4OfpLi4eqEBjC;

1.1.1.6
date	2020.09.05.07.52.09;	author mrg;	state Exp;
branches;
next	1.1.1.7;
commitid	ZRYA7IOuwfMjAPmC;

1.1.1.7
date	2021.04.10.22.10.04;	author mrg;	state Exp;
branches;
next	1.1.1.8;
commitid	eC4g0MRpqTvEkNOC;

1.1.1.8
date	2022.07.22.19.52.36;	author mrg;	state Exp;
branches;
next	1.1.1.9;
commitid	fUYPgdKzIHqhwVMD;

1.1.1.9
date	2023.07.30.05.21.20;	author mrg;	state Exp;
branches
	1.1.1.9.2.1;
next	1.1.1.10;
commitid	tk6nV4mbc9nVEMyE;

1.1.1.10
date	2024.06.30.07.35.40;	author mrg;	state Exp;
branches;
next	1.1.1.11;
commitid	m7BwZsPdfJvuHYfF;

1.1.1.11
date	2025.07.21.02.43.41;	author mrg;	state Exp;
branches;
next	1.1.1.12;
commitid	9k1gPU4fqf8VHy3G;

1.1.1.12
date	2025.09.13.23.45.48;	author mrg;	state Exp;
branches;
next	;
commitid	KwhwN4krNWa6XBaG;

1.1.1.1.2.1
date	2019.01.19.10.14.11;	author pgoyette;	state dead;
branches;
next	1.1.1.1.2.2;
commitid	JKpcmvSjdT25dl9B;

1.1.1.1.2.2
date	2019.01.26.21.59.39;	author pgoyette;	state Exp;
branches;
next	;
commitid	JKpcmvSjdT25dl9B;

1.1.1.1.4.1
date	2019.01.19.10.14.11;	author christos;	state dead;
branches;
next	1.1.1.1.4.2;
commitid	jtc8rnCzWiEEHGqB;

1.1.1.1.4.2
date	2019.06.10.21.54.58;	author christos;	state Exp;
branches;
next	1.1.1.1.4.3;
commitid	jtc8rnCzWiEEHGqB;

1.1.1.1.4.3
date	2020.04.13.07.58.43;	author martin;	state Exp;
branches;
next	;
commitid	X01YhRUPVUDaec4C;

1.1.1.1.6.1
date	2020.08.14.10.45.31;	author martin;	state Exp;
branches;
next	;
commitid	N4xCrirfb6ezh1kC;

1.1.1.9.2.1
date	2024.07.01.01.00.59;	author perseant;	state Exp;
branches;
next	1.1.1.9.2.2;
commitid	NkoYLLCQWWw9v4gF;

1.1.1.9.2.2
date	2025.08.02.05.25.54;	author perseant;	state Exp;
branches;
next	;
commitid	23j6GFaDws3O875G;


desc
@@


1.1
log
@Initial revision
@
text
@// <variant> -*- C++ -*-

// Copyright (C) 2016-2017 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @@file variant
 *  This is the <variant> C++ Library header.
 */

#ifndef _GLIBCXX_VARIANT
#define _GLIBCXX_VARIANT 1

#pragma GCC system_header

#if __cplusplus >= 201703L

#include <type_traits>
#include <utility>
#include <bits/enable_special_members.h>
#include <bits/functexcept.h>
#include <bits/move.h>
#include <bits/functional_hash.h>
#include <bits/invoke.h>
#include <ext/aligned_buffer.h>
#include <bits/parse_numbers.h>
#include <bits/stl_iterator_base_types.h>
#include <bits/stl_iterator_base_funcs.h>
#include <bits/stl_construct.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __detail
{
namespace __variant
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<size_t _Np, typename... _Types>
    struct _Nth_type;

  template<size_t _Np, typename _First, typename... _Rest>
    struct _Nth_type<_Np, _First, _Rest...>
    : _Nth_type<_Np-1, _Rest...> { };

  template<typename _First, typename... _Rest>
    struct _Nth_type<0, _First, _Rest...>
    { using type = _First; };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __variant
} // namespace __detail

_GLIBCXX_BEGIN_NAMESPACE_VERSION

#define __cpp_lib_variant 201603

  template<typename... _Types> class tuple;
  template<typename... _Types> class variant;
  template <typename> struct hash;

  template<typename _Variant>
    struct variant_size;

  template<typename _Variant>
    struct variant_size<const _Variant> : variant_size<_Variant> {};

  template<typename _Variant>
    struct variant_size<volatile _Variant> : variant_size<_Variant> {};

  template<typename _Variant>
    struct variant_size<const volatile _Variant> : variant_size<_Variant> {};

  template<typename... _Types>
    struct variant_size<variant<_Types...>>
    : std::integral_constant<size_t, sizeof...(_Types)> {};

  template<typename _Variant>
    inline constexpr size_t variant_size_v = variant_size<_Variant>::value;

  template<size_t _Np, typename _Variant>
    struct variant_alternative;

  template<size_t _Np, typename _First, typename... _Rest>
    struct variant_alternative<_Np, variant<_First, _Rest...>>
    : variant_alternative<_Np-1, variant<_Rest...>> {};

  template<typename _First, typename... _Rest>
    struct variant_alternative<0, variant<_First, _Rest...>>
    { using type = _First; };

  template<size_t _Np, typename _Variant>
    using variant_alternative_t =
      typename variant_alternative<_Np, _Variant>::type;

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, const _Variant>
    { using type = add_const_t<variant_alternative_t<_Np, _Variant>>; };

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, volatile _Variant>
    { using type = add_volatile_t<variant_alternative_t<_Np, _Variant>>; };

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, const volatile _Variant>
    { using type = add_cv_t<variant_alternative_t<_Np, _Variant>>; };

  inline constexpr size_t variant_npos = -1;

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&
    get(variant<_Types...>&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&&
    get(variant<_Types...>&&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>> const&
    get(const variant<_Types...>&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>> const&&
    get(const variant<_Types...>&&);

_GLIBCXX_END_NAMESPACE_VERSION

namespace __detail
{
namespace __variant
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
  // Returns the first apparence of _Tp in _Types.
  // Returns sizeof...(_Types) if _Tp is not in _Types.
  template<typename _Tp, typename... _Types>
    struct __index_of : std::integral_constant<size_t, 0> {};

  template<typename _Tp, typename... _Types>
    inline constexpr size_t __index_of_v = __index_of<_Tp, _Types...>::value;

  template<typename _Tp, typename _First, typename... _Rest>
    struct __index_of<_Tp, _First, _Rest...> :
      std::integral_constant<size_t, is_same_v<_Tp, _First>
	? 0 : __index_of_v<_Tp, _Rest...> + 1> {};

  // _Uninitialized<T> is guaranteed to be a literal type, even if T is not.
  // We have to do this, because [basic.types]p10.5.3 (n4606) is not implemented
  // yet. When it's implemented, _Uninitialized<T> can be changed to the alias
  // to T, therefore equivalent to being removed entirely.
  //
  // Another reason we may not want to remove _Uninitialzied<T> may be that, we
  // want _Uninitialized<T> to be trivially destructible, no matter whether T
  // is; but we will see.
  template<typename _Type, bool = std::is_literal_type_v<_Type>>
    struct _Uninitialized;

  template<typename _Type>
    struct _Uninitialized<_Type, true>
    {
      template<typename... _Args>
      constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args)
      : _M_storage(std::forward<_Args>(__args)...)
      { }

      constexpr const _Type& _M_get() const &
      { return _M_storage; }

      constexpr _Type& _M_get() &
      { return _M_storage; }

      constexpr const _Type&& _M_get() const &&
      { return std::move(_M_storage); }

      constexpr _Type&& _M_get() &&
      { return std::move(_M_storage); }

      _Type _M_storage;
    };

  template<typename _Type>
    struct _Uninitialized<_Type, false>
    {
      template<typename... _Args>
      constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args)
      { ::new (&_M_storage) _Type(std::forward<_Args>(__args)...); }

      const _Type& _M_get() const &
      { return *_M_storage._M_ptr(); }

      _Type& _M_get() &
      { return *_M_storage._M_ptr(); }

      const _Type&& _M_get() const &&
      { return std::move(*_M_storage._M_ptr()); }

      _Type&& _M_get() &&
      { return std::move(*_M_storage._M_ptr()); }

      __gnu_cxx::__aligned_membuf<_Type> _M_storage;
    };

  template<typename _Ref>
    _Ref __ref_cast(void* __ptr)
    {
      return static_cast<_Ref>(*static_cast<remove_reference_t<_Ref>*>(__ptr));
    }

  template<typename _Union>
    constexpr decltype(auto) __get(in_place_index_t<0>, _Union&& __u)
    { return std::forward<_Union>(__u)._M_first._M_get(); }

  template<size_t _Np, typename _Union>
    constexpr decltype(auto) __get(in_place_index_t<_Np>, _Union&& __u)
    {
      return __variant::__get(in_place_index<_Np-1>,
			      std::forward<_Union>(__u)._M_rest);
    }

  // Returns the typed storage for __v.
  template<size_t _Np, typename _Variant>
    constexpr decltype(auto) __get(_Variant&& __v)
    {
      return __variant::__get(std::in_place_index<_Np>,
			      std::forward<_Variant>(__v)._M_u);
    }

  // Various functions as "vtable" entries, where those vtables are used by
  // polymorphic operations.
  template<typename _Lhs, typename _Rhs>
    void
    __erased_ctor(void* __lhs, void* __rhs)
    {
      using _Type = remove_reference_t<_Lhs>;
      ::new (__lhs) _Type(__variant::__ref_cast<_Rhs>(__rhs));
    }

  template<typename _Variant, size_t _Np>
    void
    __erased_dtor(_Variant&& __v)
    { std::_Destroy(std::__addressof(__variant::__get<_Np>(__v))); }

  template<typename _Lhs, typename _Rhs>
    void
    __erased_assign(void* __lhs, void* __rhs)
    {
      __variant::__ref_cast<_Lhs>(__lhs) = __variant::__ref_cast<_Rhs>(__rhs);
    }

  template<typename _Lhs, typename _Rhs>
    void
    __erased_swap(void* __lhs, void* __rhs)
    {
      using std::swap;
      swap(__variant::__ref_cast<_Lhs>(__lhs),
	   __variant::__ref_cast<_Rhs>(__rhs));
    }

#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP, __NAME) \
  template<typename _Variant, size_t _Np> \
    constexpr bool \
    __erased_##__NAME(const _Variant& __lhs, const _Variant& __rhs) \
    { \
      return __variant::__get<_Np>(std::forward<_Variant>(__lhs)) \
	  __OP __variant::__get<_Np>(std::forward<_Variant>(__rhs)); \
    }

  _VARIANT_RELATION_FUNCTION_TEMPLATE(<, less)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(<=, less_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(==, equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(!=, not_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>=, greater_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>, greater)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE

  template<typename _Tp>
    size_t
    __erased_hash(void* __t)
    {
      return std::hash<remove_cv_t<remove_reference_t<_Tp>>>{}(
	  __variant::__ref_cast<_Tp>(__t));
    }

  // Defines members and ctors.
  template<typename... _Types>
    union _Variadic_union { };

  template<typename _First, typename... _Rest>
    union _Variadic_union<_First, _Rest...>
    {
      constexpr _Variadic_union() : _M_rest() { }

      template<typename... _Args>
	constexpr _Variadic_union(in_place_index_t<0>, _Args&&... __args)
	: _M_first(in_place_index<0>, std::forward<_Args>(__args)...)
	{ }

      template<size_t _Np, typename... _Args>
	constexpr _Variadic_union(in_place_index_t<_Np>, _Args&&... __args)
	: _M_rest(in_place_index<_Np-1>, std::forward<_Args>(__args)...)
	{ }

      _Uninitialized<_First> _M_first;
      _Variadic_union<_Rest...> _M_rest;
    };

  // Defines index and the dtor, possibly trivial.
  template<bool __trivially_destructible, typename... _Types>
    struct _Variant_storage;

  template <typename... _Types>
  using __select_index =
    typename __select_int::_Select_int_base<sizeof...(_Types) + 1,
					    unsigned char,
					    unsigned short>::type::value_type;

  template<typename... _Types>
    struct _Variant_storage<false, _Types...>
    {
      template<size_t... __indices>
	static constexpr void (*_S_vtable[])(const _Variant_storage&) =
	    { &__erased_dtor<const _Variant_storage&, __indices>... };

      constexpr _Variant_storage() : _M_index(variant_npos) { }

      template<size_t _Np, typename... _Args>
	constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
	: _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...),
	_M_index(_Np)
	{ }

      template<size_t... __indices>
	constexpr void _M_reset_impl(std::index_sequence<__indices...>)
	{
	  if (_M_index != __index_type(variant_npos))
	    _S_vtable<__indices...>[_M_index](*this);
	}

      void _M_reset()
      {
	_M_reset_impl(std::index_sequence_for<_Types...>{});
	_M_index = variant_npos;
      }

      ~_Variant_storage()
      { _M_reset(); }

      _Variadic_union<_Types...> _M_u;
      using __index_type = __select_index<_Types...>;
      __index_type _M_index;
    };

  template<typename... _Types>
    struct _Variant_storage<true, _Types...>
    {
      constexpr _Variant_storage() : _M_index(variant_npos) { }

      template<size_t _Np, typename... _Args>
	constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
	: _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...),
	_M_index(_Np)
	{ }

      void _M_reset()
      { _M_index = variant_npos; }

      _Variadic_union<_Types...> _M_u;
      using __index_type = __select_index<_Types...>;
      __index_type _M_index;
    };

  // Helps SFINAE on special member functions. Otherwise it can live in variant
  // class.
  template<typename... _Types>
    struct _Variant_base :
      _Variant_storage<(std::is_trivially_destructible_v<_Types> && ...),
			_Types...>
    {
      using _Storage =
	  _Variant_storage<(std::is_trivially_destructible_v<_Types> && ...),
			    _Types...>;

      constexpr
      _Variant_base()
      noexcept(is_nothrow_default_constructible_v<
		 variant_alternative_t<0, variant<_Types...>>>)
      : _Variant_base(in_place_index<0>) { }

      _Variant_base(const _Variant_base& __rhs)
      {
	if (__rhs._M_valid())
	  {
	    static constexpr void (*_S_vtable[])(void*, void*) =
	      { &__erased_ctor<_Types&, const _Types&>... };
	    _S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	    this->_M_index = __rhs._M_index;
	  }
      }

      _Variant_base(_Variant_base&& __rhs)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...))
      {
	if (__rhs._M_valid())
	  {
	    static constexpr void (*_S_vtable[])(void*, void*) =
	      { &__erased_ctor<_Types&, _Types&&>... };
	    _S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	    this->_M_index = __rhs._M_index;
	  }
      }

      template<size_t _Np, typename... _Args>
	constexpr explicit
	_Variant_base(in_place_index_t<_Np> __i, _Args&&... __args)
	: _Storage(__i, std::forward<_Args>(__args)...)
	{ }

      _Variant_base&
      operator=(const _Variant_base& __rhs)
      {
	if (this->_M_index == __rhs._M_index)
	  {
	    if (__rhs._M_valid())
	      {
		static constexpr void (*_S_vtable[])(void*, void*) =
		  { &__erased_assign<_Types&, const _Types&>... };
		_S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	      }
	  }
	else
	  {
	    _Variant_base __tmp(__rhs);
	    this->~_Variant_base();
	    __try
	      {
		::new (this) _Variant_base(std::move(__tmp));
	      }
	    __catch (...)
	      {
		this->_M_index = variant_npos;
		__throw_exception_again;
	      }
	  }
	__glibcxx_assert(this->_M_index == __rhs._M_index);
	return *this;
      }

      void _M_destructive_move(_Variant_base&& __rhs)
      {
	this->~_Variant_base();
	__try
	  {
	    ::new (this) _Variant_base(std::move(__rhs));
	  }
	__catch (...)
	  {
	    this->_M_index = variant_npos;
	    __throw_exception_again;
	  }
      }

      _Variant_base&
      operator=(_Variant_base&& __rhs)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)
	  && (is_nothrow_move_assignable_v<_Types> && ...))
      {
	if (this->_M_index == __rhs._M_index)
	  {
	    if (__rhs._M_valid())
	      {
		static constexpr void (*_S_vtable[])(void*, void*) =
		  { &__erased_assign<_Types&, _Types&&>... };
		_S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	      }
	  }
	else
	  {
	    _M_destructive_move(std::move(__rhs));
	  }
	return *this;
      }

      void*
      _M_storage() const
      {
	return const_cast<void*>(static_cast<const void*>(
	    std::addressof(_Storage::_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
	return this->_M_index !=
	  typename _Storage::__index_type(variant_npos);
      }
    };

  // For how many times does _Tp appear in _Tuple?
  template<typename _Tp, typename _Tuple>
    struct __tuple_count;

  template<typename _Tp, typename _Tuple>
    inline constexpr size_t __tuple_count_v =
      __tuple_count<_Tp, _Tuple>::value;

  template<typename _Tp, typename... _Types>
    struct __tuple_count<_Tp, tuple<_Types...>>
    : integral_constant<size_t, 0> { };

  template<typename _Tp, typename _First, typename... _Rest>
    struct __tuple_count<_Tp, tuple<_First, _Rest...>>
    : integral_constant<
	size_t,
	__tuple_count_v<_Tp, tuple<_Rest...>> + is_same_v<_Tp, _First>> { };

  // TODO: Reuse this in <tuple> ?
  template<typename _Tp, typename... _Types>
    inline constexpr bool __exactly_once =
      __tuple_count_v<_Tp, tuple<_Types...>> == 1;

  // Takes _Types and create an overloaded _S_fun for each type.
  // If a type appears more than once in _Types, create only one overload.
  template<typename... _Types>
    struct __overload_set
    { static void _S_fun(); };

  template<typename _First, typename... _Rest>
    struct __overload_set<_First, _Rest...> : __overload_set<_Rest...>
    {
      using __overload_set<_Rest...>::_S_fun;
      static integral_constant<size_t, sizeof...(_Rest)> _S_fun(_First);
    };

  template<typename... _Rest>
    struct __overload_set<void, _Rest...> : __overload_set<_Rest...>
    {
      using __overload_set<_Rest...>::_S_fun;
    };

  // Helper for variant(_Tp&&) and variant::operator=(_Tp&&).
  // __accepted_index maps the arbitrary _Tp to an alternative type in _Variant.
  template<typename _Tp, typename _Variant, typename = void>
    struct __accepted_index
    { static constexpr size_t value = variant_npos; };

  template<typename _Tp, typename... _Types>
    struct __accepted_index<
      _Tp, variant<_Types...>,
      decltype(__overload_set<_Types...>::_S_fun(std::declval<_Tp>()),
	       std::declval<void>())>
    {
      static constexpr size_t value = sizeof...(_Types) - 1
	- decltype(__overload_set<_Types...>::
		   _S_fun(std::declval<_Tp>()))::value;
    };

  // Returns the raw storage for __v.
  template<typename _Variant>
    void* __get_storage(_Variant&& __v)
    { return __v._M_storage(); }

  // Used for storing multi-dimensional vtable.
  template<typename _Tp, size_t... _Dimensions>
    struct _Multi_array
    {
      constexpr const _Tp&
      _M_access() const
      { return _M_data; }

      _Tp _M_data;
    };

  template<typename _Tp, size_t __first, size_t... __rest>
    struct _Multi_array<_Tp, __first, __rest...>
    {
      template<typename... _Args>
	constexpr const _Tp&
	_M_access(size_t __first_index, _Args... __rest_indices) const
	{ return _M_arr[__first_index]._M_access(__rest_indices...); }

      _Multi_array<_Tp, __rest...> _M_arr[__first];
    };

  // Creates a multi-dimensional vtable recursively.
  //
  // For example,
  // visit([](auto, auto){},
  //       variant<int, char>(),  // typedef'ed as V1
  //       variant<float, double, long double>())  // typedef'ed as V2
  // will trigger instantiations of:
  // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 2, 3>,
  //                   tuple<V1&&, V2&&>, std::index_sequence<>>
  //   __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 3>,
  //                     tuple<V1&&, V2&&>, std::index_sequence<0>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<0, 0>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<0, 1>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<0, 2>>
  //   __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 3>,
  //                     tuple<V1&&, V2&&>, std::index_sequence<1>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<1, 0>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<1, 1>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<1, 2>>
  // The returned multi-dimensional vtable can be fast accessed by the visitor
  // using index calculation.
  template<typename _Array_type, typename _Variant_tuple, typename _Index_seq>
    struct __gen_vtable_impl;

  template<typename _Result_type, typename _Visitor, size_t... __dimensions,
	   typename... _Variants, size_t... __indices>
    struct __gen_vtable_impl<
	_Multi_array<_Result_type (*)(_Visitor, _Variants...), __dimensions...>,
	tuple<_Variants...>, std::index_sequence<__indices...>>
    {
      using _Next =
	  remove_reference_t<typename _Nth_type<sizeof...(__indices),
			     _Variants...>::type>;
      using _Array_type =
	  _Multi_array<_Result_type (*)(_Visitor, _Variants...),
		       __dimensions...>;

      static constexpr _Array_type
      _S_apply()
      {
	_Array_type __vtable{};
	_S_apply_all_alts(
	  __vtable, make_index_sequence<variant_size_v<_Next>>());
	return __vtable;
      }

      template<size_t... __var_indices>
	static constexpr void
	_S_apply_all_alts(_Array_type& __vtable,
			  std::index_sequence<__var_indices...>)
	{
	  (_S_apply_single_alt<__var_indices>(
	     __vtable._M_arr[__var_indices]), ...);
	}

      template<size_t __index, typename _Tp>
	static constexpr void
	_S_apply_single_alt(_Tp& __element)
	{
	  using _Alternative = variant_alternative_t<__index, _Next>;
	  __element = __gen_vtable_impl<
	    remove_reference_t<
	      decltype(__element)>, tuple<_Variants...>,
	      std::index_sequence<__indices..., __index>>::_S_apply();
	}
    };

  template<typename _Result_type, typename _Visitor, typename... _Variants,
	   size_t... __indices>
    struct __gen_vtable_impl<
      _Multi_array<_Result_type (*)(_Visitor, _Variants...)>,
		   tuple<_Variants...>, std::index_sequence<__indices...>>
    {
      using _Array_type =
	  _Multi_array<_Result_type (*)(_Visitor&&, _Variants...)>;

      decltype(auto)
      static constexpr __visit_invoke(_Visitor&& __visitor, _Variants... __vars)
      {
	return std::__invoke(std::forward<_Visitor>(__visitor),
	    std::get<__indices>(std::forward<_Variants>(__vars))...);
      }

      static constexpr auto
      _S_apply()
      { return _Array_type{&__visit_invoke}; }
    };

  template<typename _Result_type, typename _Visitor, typename... _Variants>
    struct __gen_vtable
    {
      using _Func_ptr = _Result_type (*)(_Visitor&&, _Variants...);
      using _Array_type =
	  _Multi_array<_Func_ptr,
		       variant_size_v<remove_reference_t<_Variants>>...>;

      static constexpr _Array_type
      _S_apply()
      {
	return __gen_vtable_impl<_Array_type, tuple<_Variants...>,
				 std::index_sequence<>>::_S_apply();
      }

      static constexpr auto _S_vtable = _S_apply();
    };

  template<size_t _Np, typename _Tp>
    struct _Base_dedup : public _Tp { };

  template<typename _Variant, typename __indices>
    struct _Variant_hash_base;

  template<typename... _Types, size_t... __indices>
    struct _Variant_hash_base<variant<_Types...>,
			      std::index_sequence<__indices...>>
    : _Base_dedup<__indices, __poison_hash<remove_const_t<_Types>>>... { };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __variant
} // namespace __detail

_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<typename _Tp, typename... _Types>
    inline constexpr bool holds_alternative(const variant<_Types...>& __v)
    noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      return __v.index() == __detail::__variant::__index_of_v<_Tp, _Types...>;
    }

  template<typename _Tp, typename... _Types>
    constexpr inline _Tp& get(variant<_Types...>& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(__v);
    }

  template<typename _Tp, typename... _Types>
    constexpr inline _Tp&& get(variant<_Types...>&& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	std::move(__v));
    }

  template<typename _Tp, typename... _Types>
    constexpr inline const _Tp& get(const variant<_Types...>& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(__v);
    }

  template<typename _Tp, typename... _Types>
    constexpr inline const _Tp&& get(const variant<_Types...>&& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	std::move(__v));
    }

  template<size_t _Np, typename... _Types>
    constexpr inline
    add_pointer_t<variant_alternative_t<_Np, variant<_Types...>>>
    get_if(variant<_Types...>* __ptr) noexcept
    {
      using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>;
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      static_assert(!is_void_v<_Alternative_type>, "_Tp should not be void");
      if (__ptr && __ptr->index() == _Np)
	return &__detail::__variant::__get<_Np>(*__ptr);
      return nullptr;
    }

  template<size_t _Np, typename... _Types>
    constexpr inline
    add_pointer_t<const variant_alternative_t<_Np, variant<_Types...>>>
    get_if(const variant<_Types...>* __ptr) noexcept
    {
      using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>;
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      static_assert(!is_void_v<_Alternative_type>, "_Tp should not be void");
      if (__ptr && __ptr->index() == _Np)
	return &__detail::__variant::__get<_Np>(*__ptr);
      return nullptr;
    }

  template<typename _Tp, typename... _Types>
    constexpr inline add_pointer_t<_Tp>
    get_if(variant<_Types...>* __ptr) noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get_if<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	  __ptr);
    }

  template<typename _Tp, typename... _Types>
    constexpr inline add_pointer_t<const _Tp>
    get_if(const variant<_Types...>* __ptr)
    noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get_if<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	  __ptr);
    }

  struct monostate { };

#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP, __NAME) \
  template<typename... _Types> \
    constexpr bool operator __OP(const variant<_Types...>& __lhs, \
				 const variant<_Types...>& __rhs) \
    { \
      return __lhs._M_##__NAME(__rhs, std::index_sequence_for<_Types...>{}); \
    } \
\
  constexpr bool operator __OP(monostate, monostate) noexcept \
  { return 0 __OP 0; }

  _VARIANT_RELATION_FUNCTION_TEMPLATE(<, less)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(<=, less_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(==, equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(!=, not_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>=, greater_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>, greater)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE

  template<typename _Visitor, typename... _Variants>
    constexpr decltype(auto) visit(_Visitor&&, _Variants&&...);

  template<typename... _Types>
    inline enable_if_t<(is_move_constructible_v<_Types> && ...)
			&& (is_swappable_v<_Types> && ...)>
    swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

  template<typename... _Types>
    enable_if_t<!((is_move_constructible_v<_Types> && ...)
		   && (is_swappable_v<_Types> && ...))>
    swap(variant<_Types...>&, variant<_Types...>&) = delete;

  class bad_variant_access : public exception
  {
  public:
    bad_variant_access() noexcept : _M_reason("Unknown reason") { }
    const char* what() const noexcept override
    { return _M_reason; }

  private:
    bad_variant_access(const char* __reason) : _M_reason(__reason) { }

    const char* _M_reason;

    friend void __throw_bad_variant_access(const char* __what);
  };

  inline void
  __throw_bad_variant_access(const char* __what)
  { _GLIBCXX_THROW_OR_ABORT(bad_variant_access(__what)); }

  template<typename... _Types>
    class variant
    : private __detail::__variant::_Variant_base<_Types...>,
      private _Enable_default_constructor<
	is_default_constructible_v<
	  variant_alternative_t<0, variant<_Types...>>>, variant<_Types...>>,
      private _Enable_copy_move<
	(is_copy_constructible_v<_Types> && ...),
	(is_copy_constructible_v<_Types> && ...)
	     && (is_move_constructible_v<_Types> && ...)
	     && (is_copy_assignable_v<_Types> && ...),
	(is_move_constructible_v<_Types> && ...),
	(is_move_constructible_v<_Types> && ...)
	     && (is_move_assignable_v<_Types> && ...),
	variant<_Types...>>
    {
    private:
      static_assert(sizeof...(_Types) > 0,
		    "variant must have at least one alternative");
      static_assert(!(std::is_reference_v<_Types> || ...),
		    "variant must have no reference alternative");
      static_assert(!(std::is_void_v<_Types> || ...),
		    "variant must have no void alternative");

      using _Base = __detail::__variant::_Variant_base<_Types...>;
      using _Default_ctor_enabler =
	_Enable_default_constructor<
	  is_default_constructible_v<
	    variant_alternative_t<0, variant<_Types...>>>, variant<_Types...>>;

      template<typename _Tp>
	static constexpr bool
	__exactly_once = __detail::__variant::__exactly_once<_Tp, _Types...>;

      template<typename _Tp>
	static constexpr size_t __accepted_index =
	  __detail::__variant::__accepted_index<_Tp&&, variant>::value;

      template<size_t _Np, bool = _Np < sizeof...(_Types)>
	struct __to_type_impl;

      template<size_t _Np>
	struct __to_type_impl<_Np, true>
	{ using type = variant_alternative_t<_Np, variant>; };

      template<size_t _Np>
	using __to_type = typename __to_type_impl<_Np>::type;

      template<typename _Tp>
	using __accepted_type = __to_type<__accepted_index<_Tp>>;

      template<typename _Tp>
	static constexpr size_t __index_of =
	  __detail::__variant::__index_of_v<_Tp, _Types...>;

    public:
      constexpr variant()
      noexcept(is_nothrow_default_constructible_v<__to_type<0>>) = default;
      variant(const variant&) = default;
      variant(variant&&)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)) = default;

      template<typename _Tp,
	       typename = enable_if_t<!is_same_v<decay_t<_Tp>, variant>>,
	       typename = enable_if_t<(sizeof...(_Types)>0)>,
	       typename = enable_if_t<__exactly_once<__accepted_type<_Tp&&>>
			  && is_constructible_v<__accepted_type<_Tp&&>, _Tp&&>>>
	constexpr
	variant(_Tp&& __t)
	noexcept(is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp&&>)
	: variant(in_place_index<__accepted_index<_Tp&&>>, std::forward<_Tp>(__t))
	{ __glibcxx_assert(holds_alternative<__accepted_type<_Tp&&>>(*this)); }

      template<typename _Tp, typename... _Args,
	       typename = enable_if_t<__exactly_once<_Tp>
			  && is_constructible_v<_Tp, _Args&&...>>>
	constexpr explicit
	variant(in_place_type_t<_Tp>, _Args&&... __args)
	: variant(in_place_index<__index_of<_Tp>>, std::forward<_Args>(__args)...)
	{ __glibcxx_assert(holds_alternative<_Tp>(*this)); }

      template<typename _Tp, typename _Up, typename... _Args,
	       typename = enable_if_t<__exactly_once<_Tp>
			  && is_constructible_v<
			    _Tp, initializer_list<_Up>&, _Args&&...>>>
	constexpr explicit
	variant(in_place_type_t<_Tp>, initializer_list<_Up> __il,
		_Args&&... __args)
	: variant(in_place_index<__index_of<_Tp>>, __il,
		  std::forward<_Args>(__args)...)
	{ __glibcxx_assert(holds_alternative<_Tp>(*this)); }

      template<size_t _Np, typename... _Args,
	       typename = enable_if_t<
		 is_constructible_v<__to_type<_Np>, _Args&&...>>>
	constexpr explicit
	variant(in_place_index_t<_Np>, _Args&&... __args)
	: _Base(in_place_index<_Np>, std::forward<_Args>(__args)...),
	_Default_ctor_enabler(_Enable_default_constructor_tag{})
	{ __glibcxx_assert(index() == _Np); }

      template<size_t _Np, typename _Up, typename... _Args,
	       typename = enable_if_t<is_constructible_v<__to_type<_Np>,
				      initializer_list<_Up>&, _Args&&...>>>
	constexpr explicit
	variant(in_place_index_t<_Np>, initializer_list<_Up> __il,
		_Args&&... __args)
	: _Base(in_place_index<_Np>, __il, std::forward<_Args>(__args)...),
	_Default_ctor_enabler(_Enable_default_constructor_tag{})
	{ __glibcxx_assert(index() == _Np); }

      ~variant() = default;

      variant& operator=(const variant&) = default;
      variant& operator=(variant&&)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)
	  && (is_nothrow_move_assignable_v<_Types> && ...)) = default;

      template<typename _Tp>
	enable_if_t<__exactly_once<__accepted_type<_Tp&&>>
		    && is_constructible_v<__accepted_type<_Tp&&>, _Tp&&>
		    && is_assignable_v<__accepted_type<_Tp&&>&, _Tp&&>
		    && !is_same_v<decay_t<_Tp>, variant>, variant&>
	operator=(_Tp&& __rhs)
	noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp&&>
		 && is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp&&>)
	{
	  constexpr auto __index = __accepted_index<_Tp&&>;
	  if (index() == __index)
	    std::get<__index>(*this) = std::forward<_Tp>(__rhs);
	  else
	    this->emplace<__index>(std::forward<_Tp>(__rhs));
	  __glibcxx_assert(holds_alternative<__accepted_type<_Tp&&>>(*this));
	  return *this;
	}

      template<typename _Tp, typename... _Args>
	enable_if_t<is_constructible_v<_Tp, _Args...> && __exactly_once<_Tp>,
		    _Tp&>
	emplace(_Args&&... __args)
	{
	  auto& ret =
	    this->emplace<__index_of<_Tp>>(std::forward<_Args>(__args)...);
	  __glibcxx_assert(holds_alternative<_Tp>(*this));
	  return ret;
	}

      template<typename _Tp, typename _Up, typename... _Args>
	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
		    && __exactly_once<_Tp>,
		    _Tp&>
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	{
	  auto& ret =
	    this->emplace<__index_of<_Tp>>(__il,
					   std::forward<_Args>(__args)...);
	  __glibcxx_assert(holds_alternative<_Tp>(*this));
	  return ret;
	}

      template<size_t _Np, typename... _Args>
	enable_if_t<is_constructible_v<variant_alternative_t<_Np, variant>,
				       _Args...>,
		    variant_alternative_t<_Np, variant>&>
	emplace(_Args&&... __args)
	{
	  static_assert(_Np < sizeof...(_Types),
			"The index should be in [0, number of alternatives)");
	  this->~variant();
	  __try
	    {
	      ::new (this) variant(in_place_index<_Np>,
				   std::forward<_Args>(__args)...);
	    }
	  __catch (...)
	    {
	      this->_M_index = variant_npos;
	      __throw_exception_again;
	    }
	  __glibcxx_assert(index() == _Np);
	  return std::get<_Np>(*this);
	}

      template<size_t _Np, typename _Up, typename... _Args>
	enable_if_t<is_constructible_v<variant_alternative_t<_Np, variant>,
				       initializer_list<_Up>&, _Args...>,
		    variant_alternative_t<_Np, variant>&>
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	{
	  static_assert(_Np < sizeof...(_Types),
			"The index should be in [0, number of alternatives)");
	  this->~variant();
	  __try
	    {
	      ::new (this) variant(in_place_index<_Np>, __il,
				   std::forward<_Args>(__args)...);
	    }
	  __catch (...)
	    {
	      this->_M_index = variant_npos;
	      __throw_exception_again;
	    }
	  __glibcxx_assert(index() == _Np);
	  return std::get<_Np>(*this);
	}

      constexpr bool valueless_by_exception() const noexcept
      { return !this->_M_valid(); }

      constexpr size_t index() const noexcept
      {
	if (this->_M_index ==
	    typename _Base::_Storage::__index_type(variant_npos))
	  return variant_npos;
	return this->_M_index;
      }

      void
      swap(variant& __rhs)
      noexcept((__is_nothrow_swappable<_Types>::value && ...)
	       && is_nothrow_move_constructible_v<variant>)
      {
	if (this->index() == __rhs.index())
	  {
	    if (this->_M_valid())
	      {
		static constexpr void (*_S_vtable[])(void*, void*) =
		  { &__detail::__variant::__erased_swap<_Types&, _Types&>... };
		_S_vtable[__rhs._M_index](this->_M_storage(),
					  __rhs._M_storage());
	      }
	  }
	else if (!this->_M_valid())
	  {
	    this->_M_destructive_move(std::move(__rhs));
	    __rhs._M_reset();
	  }
	else if (!__rhs._M_valid())
	  {
	    __rhs._M_destructive_move(std::move(*this));
	    this->_M_reset();
	  }
	else
	  {
	    auto __tmp = std::move(__rhs);
	    __rhs._M_destructive_move(std::move(*this));
	    this->_M_destructive_move(std::move(__tmp));
	  }
      }

    private:
#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP, __NAME) \
      template<size_t... __indices> \
	static constexpr bool \
	(*_S_erased_##__NAME[])(const variant&, const variant&) = \
	  { &__detail::__variant::__erased_##__NAME< \
                const variant&, __indices>... }; \
      template<size_t... __indices> \
	constexpr inline bool \
	_M_##__NAME(const variant& __rhs, \
		    std::index_sequence<__indices...>) const \
	{ \
	  auto __lhs_index = this->index(); \
	  auto __rhs_index = __rhs.index(); \
	  if (__lhs_index != __rhs_index || valueless_by_exception()) \
	    /* Modulo addition. */ \
	    return __lhs_index + 1 __OP __rhs_index + 1; \
	  return _S_erased_##__NAME<__indices...>[__lhs_index](*this, __rhs); \
	}

      _VARIANT_RELATION_FUNCTION_TEMPLATE(<, less)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(<=, less_equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(==, equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(!=, not_equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>=, greater_equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>, greater)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE

#ifdef __clang__
    public:
      using _Base::_M_u; // See https://bugs.llvm.org/show_bug.cgi?id=31852
    private:
#endif

      template<size_t _Np, typename _Vp>
	friend constexpr decltype(auto) __detail::__variant::
#if _GLIBCXX_INLINE_VERSION
        __7:: // Required due to PR c++/59256
#endif
	__get(_Vp&& __v);

      template<typename _Vp>
	friend void* __detail::__variant::
#if _GLIBCXX_INLINE_VERSION
        __7:: // Required due to PR c++/59256
#endif
        __get_storage(_Vp&& __v);

#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP) \
      template<typename... _Tp> \
	friend constexpr bool \
	operator __OP(const variant<_Tp...>& __lhs, \
		      const variant<_Tp...>& __rhs);

      _VARIANT_RELATION_FUNCTION_TEMPLATE(<)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(<=)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(==)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(!=)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>=)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE
    };

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&
    get(variant<_Types...>& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(__v);
    }

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&&
    get(variant<_Types...>&& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(std::move(__v));
    }

  template<size_t _Np, typename... _Types>
    constexpr const variant_alternative_t<_Np, variant<_Types...>>&
    get(const variant<_Types...>& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(__v);
    }

  template<size_t _Np, typename... _Types>
    constexpr const variant_alternative_t<_Np, variant<_Types...>>&&
    get(const variant<_Types...>&& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(std::move(__v));
    }

  template<typename _Visitor, typename... _Variants>
    constexpr decltype(auto)
    visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      if ((__variants.valueless_by_exception() || ...))
	__throw_bad_variant_access("Unexpected index");

      using _Result_type =
	decltype(std::forward<_Visitor>(__visitor)(
	    std::get<0>(std::forward<_Variants>(__variants))...));

      constexpr auto& __vtable = __detail::__variant::__gen_vtable<
	_Result_type, _Visitor&&, _Variants&&...>::_S_vtable;

      auto __func_ptr = __vtable._M_access(__variants.index()...);
      return (*__func_ptr)(std::forward<_Visitor>(__visitor),
			   std::forward<_Variants>(__variants)...);
    }

  template<bool, typename... _Types>
    struct __variant_hash_call_base_impl
    {
      size_t
      operator()(const variant<_Types...>& __t) const
      noexcept((is_nothrow_invocable_v<hash<decay_t<_Types>>, _Types> && ...))
      {
	if (!__t.valueless_by_exception())
	  {
	    namespace __edv = __detail::__variant;
	    static constexpr size_t (*_S_vtable[])(void*) =
	      { &__edv::__erased_hash<const _Types&>... };
	    return hash<size_t>{}(__t.index())
	      + _S_vtable[__t.index()](__edv::__get_storage(__t));
	  }
	return hash<size_t>{}(__t.index());
      }
    };

  template<typename... _Types>
    struct __variant_hash_call_base_impl<false, _Types...> {};

  template<typename... _Types>
    using __variant_hash_call_base =
    __variant_hash_call_base_impl<(__poison_hash<remove_const_t<_Types>>::
				   __enable_hash_call &&...), _Types...>;

  template<typename... _Types>
    struct hash<variant<_Types...>>
    : private __detail::__variant::_Variant_hash_base<
        variant<_Types...>, std::index_sequence_for<_Types...>>,
      public __variant_hash_call_base<_Types...>
    {
      using result_type = size_t;
      using argument_type = variant<_Types...>;
    };

  template<>
    struct hash<monostate>
    {
      using result_type = size_t;
      using argument_type = monostate;

      size_t
      operator()(const monostate& __t) const noexcept
      {
	constexpr size_t __magic_monostate_hash = -7777;
	return __magic_monostate_hash;
      }
    };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++17

#endif // _GLIBCXX_VARIANT
@


1.1.1.1
log
@import GCC 7.4.0.  main changes include:

The non-standard C++0x type traits has_trivial_default_constructor,
has_trivial_copy_constructor and has_trivial_copy_assign have been
removed.

On ARM targets (arm*-*-*), a bug introduced in GCC 5 that affects
conformance to the procedure call standard (AAPCS) has been fixed.

Many optimiser improvements

DWARF-5 support.

Many new and enhanced warnings.

Warnings about format strings now underline the pertinent part of
the string, and can offer suggested fixes.

Several new warnings related to buffer overflows and buffer
truncation.

New __builtin_add_overflow_p, __builtin_sub_overflow_p,
__builtin_mul_overflow_p built-ins added that test for overflow.

The C++ front end has experimental support for all of the current
C++17 draft.

The -fverbose-asm option has been expanded to prints comments
showing the source lines that correspond to the assembly.

The gcc and g++ driver programs will now provide suggestions for
misspelled arguments to command-line options.


AArch64 specific:

GCC has been updated to the latest revision of the procedure call
standard (AAPCS64) to provide support for parameter passing when
data types have been over-aligned.

The ARMv8.2-A and ARMv8.3-A architecture are now supported.

ARM specific:

Support for the ARMv5 and ARMv5E architectures has been
deprecated (which have no known implementations).

A new command-line option -mpure-code has been added. It does not
allow constant data to be placed in code sections.

x86 specific:

Support for the AVX-512 4FMAPS, 4VNNIW, VPOPCNTDQ and Software
Guard Extensions (SGX) ISA extensions has been added.

PPC specific:

GCC now diagnoses inline assembly that clobbers register r2.

RISC-V specific:

Support for the RISC-V instruction set has been added.

SH specific:

Support for SH5/SH64 has been removed.

Support for SH2A has been enhanced.
@
text
@@


1.1.1.1.6.1
log
@Pull up the following, all via patch, requested by mrg in ticket #1049:

	external/gpl3/gcc/dist/ChangeLog
	external/gpl3/gcc/dist/LAST_UPDATED
	external/gpl3/gcc/dist/MD5SUMS
	external/gpl3/gcc/dist/NEWS
	external/gpl3/gcc/dist/config/ChangeLog
	external/gpl3/gcc/dist/contrib/ChangeLog
	external/gpl3/gcc/dist/contrib/test_summary
	external/gpl3/gcc/dist/contrib/header-tools/ChangeLog
	external/gpl3/gcc/dist/contrib/reghunt/ChangeLog
	external/gpl3/gcc/dist/contrib/regression/ChangeLog
	external/gpl3/gcc/dist/fixincludes/ChangeLog
	external/gpl3/gcc/dist/fixincludes/fixincl.x
	external/gpl3/gcc/dist/fixincludes/inclhack.def
	external/gpl3/gcc/dist/fixincludes/tests/base/architecture/ppc/math.h
	external/gpl3/gcc/dist/fixincludes/tests/base/dispatch/object.h
	external/gpl3/gcc/dist/fixincludes/tests/base/os/availability.h
	external/gpl3/gcc/dist/fixincludes/tests/base/os/base.h
	external/gpl3/gcc/dist/gcc/BASE-VER
	external/gpl3/gcc/dist/gcc/ChangeLog
	external/gpl3/gcc/dist/gcc/DATESTAMP
	external/gpl3/gcc/dist/gcc/builtins.c
	external/gpl3/gcc/dist/gcc/calls.c
	external/gpl3/gcc/dist/gcc/cfgcleanup.c
	external/gpl3/gcc/dist/gcc/cfghooks.c
	external/gpl3/gcc/dist/gcc/cfghooks.h
	external/gpl3/gcc/dist/gcc/cfgloop.h
	external/gpl3/gcc/dist/gcc/cfgloopmanip.c
	external/gpl3/gcc/dist/gcc/cfgrtl.c
	external/gpl3/gcc/dist/gcc/combine.c
	external/gpl3/gcc/dist/gcc/config.gcc
	external/gpl3/gcc/dist/gcc/convert.c
	external/gpl3/gcc/dist/gcc/dce.c
	external/gpl3/gcc/dist/gcc/df-core.c
	external/gpl3/gcc/dist/gcc/dse.c
	external/gpl3/gcc/dist/gcc/dwarf2out.c
	external/gpl3/gcc/dist/gcc/except.c
	external/gpl3/gcc/dist/gcc/explow.c
	external/gpl3/gcc/dist/gcc/expmed.c
	external/gpl3/gcc/dist/gcc/expr.c
	external/gpl3/gcc/dist/gcc/final.c
	external/gpl3/gcc/dist/gcc/fold-const.c
	external/gpl3/gcc/dist/gcc/function.c
	external/gpl3/gcc/dist/gcc/gcse.c
	external/gpl3/gcc/dist/gcc/gengtype-lex.c
	external/gpl3/gcc/dist/gcc/ggc-page.c
	external/gpl3/gcc/dist/gcc/gimple-fold.c
	external/gpl3/gcc/dist/gcc/gimple-pretty-print.c
	external/gpl3/gcc/dist/gcc/gimple-ssa-sprintf.c
	external/gpl3/gcc/dist/gcc/gimple-ssa-strength-reduction.c
	external/gpl3/gcc/dist/gcc/gimple.c
	external/gpl3/gcc/dist/gcc/gimple.h
	external/gpl3/gcc/dist/gcc/gimplify.c
	external/gpl3/gcc/dist/gcc/graphite-scop-detection.c
	external/gpl3/gcc/dist/gcc/input.c
	external/gpl3/gcc/dist/gcc/internal-fn.c
	external/gpl3/gcc/dist/gcc/internal-fn.h
	external/gpl3/gcc/dist/gcc/ipa-cp.c
	external/gpl3/gcc/dist/gcc/ipa-icf-gimple.c
	external/gpl3/gcc/dist/gcc/ipa-inline.c
	external/gpl3/gcc/dist/gcc/ipa-prop.c
	external/gpl3/gcc/dist/gcc/ipa-pure-const.c
	external/gpl3/gcc/dist/gcc/ipa-reference.c
	external/gpl3/gcc/dist/gcc/ipa-utils.c
	external/gpl3/gcc/dist/gcc/ipa-utils.h
	external/gpl3/gcc/dist/gcc/ira.c
	external/gpl3/gcc/dist/gcc/loop-unroll.c
	external/gpl3/gcc/dist/gcc/lra-constraints.c
	external/gpl3/gcc/dist/gcc/lra.c
	external/gpl3/gcc/dist/gcc/lto-streamer-in.c
	external/gpl3/gcc/dist/gcc/lto-streamer-out.c
	external/gpl3/gcc/dist/gcc/lto-streamer.h
	external/gpl3/gcc/dist/gcc/lto-wrapper.c
	external/gpl3/gcc/dist/gcc/match.pd
	external/gpl3/gcc/dist/gcc/omp-expand.c
	external/gpl3/gcc/dist/gcc/omp-low.c
	external/gpl3/gcc/dist/gcc/omp-simd-clone.c
	external/gpl3/gcc/dist/gcc/optabs.c
	external/gpl3/gcc/dist/gcc/optc-save-gen.awk
	external/gpl3/gcc/dist/gcc/opth-gen.awk
	external/gpl3/gcc/dist/gcc/opts-common.c
	external/gpl3/gcc/dist/gcc/opts-global.c
	external/gpl3/gcc/dist/gcc/opts.c
	external/gpl3/gcc/dist/gcc/resource.c
	external/gpl3/gcc/dist/gcc/rtl.h
	external/gpl3/gcc/dist/gcc/rtlanal.c
	external/gpl3/gcc/dist/gcc/store-motion.c
	external/gpl3/gcc/dist/gcc/symtab.c
	external/gpl3/gcc/dist/gcc/toplev.c
	external/gpl3/gcc/dist/gcc/tree-cfg.c
	external/gpl3/gcc/dist/gcc/tree-complex.c
	external/gpl3/gcc/dist/gcc/tree-core.h
	external/gpl3/gcc/dist/gcc/tree-data-ref.c
	external/gpl3/gcc/dist/gcc/tree-data-ref.h
	external/gpl3/gcc/dist/gcc/tree-inline.c
	external/gpl3/gcc/dist/gcc/tree-inline.h
	external/gpl3/gcc/dist/gcc/tree-loop-distribution.c
	external/gpl3/gcc/dist/gcc/tree-outof-ssa.c
	external/gpl3/gcc/dist/gcc/tree-scalar-evolution.c
	external/gpl3/gcc/dist/gcc/tree-sra.c
	external/gpl3/gcc/dist/gcc/tree-ssa-copy.c
	external/gpl3/gcc/dist/gcc/tree-ssa-dom.c
	external/gpl3/gcc/dist/gcc/tree-ssa-forwprop.c
	external/gpl3/gcc/dist/gcc/tree-ssa-loop-ch.c
	external/gpl3/gcc/dist/gcc/tree-ssa-loop-ivcanon.c
	external/gpl3/gcc/dist/gcc/tree-ssa-loop-ivopts.c
	external/gpl3/gcc/dist/gcc/tree-ssa-loop-split.c
	external/gpl3/gcc/dist/gcc/tree-ssa-math-opts.c
	external/gpl3/gcc/dist/gcc/tree-ssa-phiopt.c
	external/gpl3/gcc/dist/gcc/tree-ssa-phiprop.c
	external/gpl3/gcc/dist/gcc/tree-ssa-pre.c
	external/gpl3/gcc/dist/gcc/tree-ssa-reassoc.c
	external/gpl3/gcc/dist/gcc/tree-ssa-sccvn.c
	external/gpl3/gcc/dist/gcc/tree-ssa-sccvn.h
	external/gpl3/gcc/dist/gcc/tree-ssa-sink.c
	external/gpl3/gcc/dist/gcc/tree-ssa-strlen.c
	external/gpl3/gcc/dist/gcc/tree-ssa-structalias.c
	external/gpl3/gcc/dist/gcc/tree-ssanames.c
	external/gpl3/gcc/dist/gcc/tree-streamer-in.c
	external/gpl3/gcc/dist/gcc/tree-streamer-out.c
	external/gpl3/gcc/dist/gcc/tree-vect-data-refs.c
	external/gpl3/gcc/dist/gcc/tree-vect-slp.c
	external/gpl3/gcc/dist/gcc/tree-vect-stmts.c
	external/gpl3/gcc/dist/gcc/tree-vrp.c
	external/gpl3/gcc/dist/gcc/tree.c
	external/gpl3/gcc/dist/gcc/tree.h
	external/gpl3/gcc/dist/gcc/valtrack.c
	external/gpl3/gcc/dist/gcc/varasm.c
	external/gpl3/gcc/dist/gcc/xcoffout.c
	external/gpl3/gcc/dist/gcc/xcoffout.h
	external/gpl3/gcc/dist/gcc/brig/ChangeLog
	external/gpl3/gcc/dist/gcc/c/ChangeLog
	external/gpl3/gcc/dist/gcc/c/c-decl.c
	external/gpl3/gcc/dist/gcc/c/c-parser.c
	external/gpl3/gcc/dist/gcc/c/c-tree.h
	external/gpl3/gcc/dist/gcc/c/c-typeck.c
	external/gpl3/gcc/dist/gcc/c-family/ChangeLog
	external/gpl3/gcc/dist/gcc/c-family/c-ada-spec.c
	external/gpl3/gcc/dist/gcc/c-family/c-common.c
	external/gpl3/gcc/dist/gcc/c-family/c-lex.c
	external/gpl3/gcc/dist/gcc/c-family/c-omp.c
	external/gpl3/gcc/dist/gcc/config/darwin-c.c
	external/gpl3/gcc/dist/gcc/config/darwin-driver.c
	external/gpl3/gcc/dist/gcc/config/darwin-protos.h
	external/gpl3/gcc/dist/gcc/config/darwin.c
	external/gpl3/gcc/dist/gcc/config/darwin.h
	external/gpl3/gcc/dist/gcc/config/darwin.opt
	external/gpl3/gcc/dist/gcc/config/darwin10.h
	external/gpl3/gcc/dist/gcc/config/darwin9.h
	external/gpl3/gcc/dist/gcc/config/aarch64/aarch64-c.c
	external/gpl3/gcc/dist/gcc/config/aarch64/aarch64.md
	external/gpl3/gcc/dist/gcc/config/aarch64/cortex-a57-fma-steering.c
	external/gpl3/gcc/dist/gcc/config/aarch64/iterators.md
	external/gpl3/gcc/dist/gcc/config/alpha/alpha.c
	external/gpl3/gcc/dist/gcc/config/arm/arm.c
	external/gpl3/gcc/dist/gcc/config/arm/arm.h
	external/gpl3/gcc/dist/gcc/config/arm/arm.md
	external/gpl3/gcc/dist/gcc/config/arm/constraints.md
	external/gpl3/gcc/dist/gcc/config/arm/neon.md
	external/gpl3/gcc/dist/gcc/config/arm/t-rtems
	external/gpl3/gcc/dist/gcc/config/avr/avr.c
	external/gpl3/gcc/dist/gcc/config/i386/avx2intrin.h
	external/gpl3/gcc/dist/gcc/config/i386/avxintrin.h
	external/gpl3/gcc/dist/gcc/config/i386/cpuid.h
	external/gpl3/gcc/dist/gcc/config/i386/darwin.h
	external/gpl3/gcc/dist/gcc/config/i386/darwin32-biarch.h
	external/gpl3/gcc/dist/gcc/config/i386/darwin64-biarch.h
	external/gpl3/gcc/dist/gcc/config/i386/darwin64.h
	external/gpl3/gcc/dist/gcc/config/i386/emmintrin.h
	external/gpl3/gcc/dist/gcc/config/i386/i386-builtin.def
	external/gpl3/gcc/dist/gcc/config/i386/i386.c
	external/gpl3/gcc/dist/gcc/config/i386/i386.h
	external/gpl3/gcc/dist/gcc/config/i386/i386.md
	external/gpl3/gcc/dist/gcc/config/i386/sse.md
	external/gpl3/gcc/dist/gcc/config/i386/t-darwin
	external/gpl3/gcc/dist/gcc/config/i386/t-darwin32-biarch
	external/gpl3/gcc/dist/gcc/config/i386/t-darwin64
	external/gpl3/gcc/dist/gcc/config/i386/t-darwin64-biarch
	external/gpl3/gcc/dist/gcc/config/nvptx/nvptx.c
	external/gpl3/gcc/dist/gcc/config/pa/pa.c
	external/gpl3/gcc/dist/gcc/config/pa/pa.md
	external/gpl3/gcc/dist/gcc/config/rs6000/altivec.h
	external/gpl3/gcc/dist/gcc/config/rs6000/altivec.md
	external/gpl3/gcc/dist/gcc/config/rs6000/crypto.md
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin.h
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin.md
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin32-biarch.h
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin64-biarch.h
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin64.h
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin7.h
	external/gpl3/gcc/dist/gcc/config/rs6000/rs6000-builtin.def
	external/gpl3/gcc/dist/gcc/config/rs6000/rs6000-c.c
	external/gpl3/gcc/dist/gcc/config/rs6000/rs6000.c
	external/gpl3/gcc/dist/gcc/config/rs6000/rs6000.md
	external/gpl3/gcc/dist/gcc/config/rs6000/t-darwin32-biarch
	external/gpl3/gcc/dist/gcc/config/rs6000/t-darwin64
	external/gpl3/gcc/dist/gcc/config/rs6000/t-darwin64-biarch
	external/gpl3/gcc/dist/gcc/config/rs6000/t-darwin8
	external/gpl3/gcc/dist/gcc/config/rs6000/t-linux
	external/gpl3/gcc/dist/gcc/config/rs6000/vsx.md
	external/gpl3/gcc/dist/gcc/config/s390/s390-builtins.def
	external/gpl3/gcc/dist/gcc/config/s390/s390.c
	external/gpl3/gcc/dist/gcc/config/s390/s390.md
	external/gpl3/gcc/dist/gcc/config/s390/vector.md
	external/gpl3/gcc/dist/gcc/config/s390/vx-builtins.md
	external/gpl3/gcc/dist/gcc/config/sh/sh.c
	external/gpl3/gcc/dist/gcc/config/sh/sh.h
	external/gpl3/gcc/dist/gcc/config/sh/sh.md
	external/gpl3/gcc/dist/gcc/config/sparc/sparc.c
	external/gpl3/gcc/dist/gcc/config/sparc/sparc.md
	external/gpl3/gcc/dist/gcc/config/xtensa/xtensa.c
	external/gpl3/gcc/dist/gcc/cp/ChangeLog
	external/gpl3/gcc/dist/gcc/cp/call.c
	external/gpl3/gcc/dist/gcc/cp/class.c
	external/gpl3/gcc/dist/gcc/cp/config-lang.in
	external/gpl3/gcc/dist/gcc/cp/constexpr.c
	external/gpl3/gcc/dist/gcc/cp/cp-tree.h
	external/gpl3/gcc/dist/gcc/cp/decl.c
	external/gpl3/gcc/dist/gcc/cp/decl2.c
	external/gpl3/gcc/dist/gcc/cp/init.c
	external/gpl3/gcc/dist/gcc/cp/lambda.c
	external/gpl3/gcc/dist/gcc/cp/optimize.c
	external/gpl3/gcc/dist/gcc/cp/parser.c
	external/gpl3/gcc/dist/gcc/cp/pt.c
	external/gpl3/gcc/dist/gcc/cp/semantics.c
	external/gpl3/gcc/dist/gcc/cp/typeck.c
	external/gpl3/gcc/dist/gcc/cp/vtable-class-hierarchy.c
	external/gpl3/gcc/dist/gcc/doc/cpp.1
	external/gpl3/gcc/dist/gcc/doc/cpp.info
	external/gpl3/gcc/dist/gcc/doc/cppinternals.info
	external/gpl3/gcc/dist/gcc/doc/extend.texi
	external/gpl3/gcc/dist/gcc/doc/fsf-funding.7
	external/gpl3/gcc/dist/gcc/doc/g++.1
	external/gpl3/gcc/dist/gcc/doc/gcc.1
	external/gpl3/gcc/dist/gcc/doc/gcc.info
	external/gpl3/gcc/dist/gcc/doc/gccinstall.info
	external/gpl3/gcc/dist/gcc/doc/gccint.info
	external/gpl3/gcc/dist/gcc/doc/gcov-dump.1
	external/gpl3/gcc/dist/gcc/doc/gcov-tool.1
	external/gpl3/gcc/dist/gcc/doc/gcov.1
	external/gpl3/gcc/dist/gcc/doc/gfdl.7
	external/gpl3/gcc/dist/gcc/doc/gfortran.1
	external/gpl3/gcc/dist/gcc/doc/gpl.7
	external/gpl3/gcc/dist/gcc/doc/invoke.texi
	external/gpl3/gcc/dist/gcc/doc/sourcebuild.texi
	external/gpl3/gcc/dist/gcc/jit/ChangeLog
	external/gpl3/gcc/dist/gcc/lto/ChangeLog
	external/gpl3/gcc/dist/gcc/objc/ChangeLog
	external/gpl3/gcc/dist/gcc/objc/objc-act.c
	external/gpl3/gcc/dist/gcc/objc/objc-act.h
	external/gpl3/gcc/dist/gcc/objcp/ChangeLog
	external/gpl3/gcc/dist/gcc/objcp/config-lang.in
	external/gpl3/gcc/dist/include/ChangeLog
	external/gpl3/gcc/dist/intl/ChangeLog
	external/gpl3/gcc/dist/libbacktrace/ChangeLog
	external/gpl3/gcc/dist/libcc1/ChangeLog
	external/gpl3/gcc/dist/libcpp/ChangeLog
	external/gpl3/gcc/dist/libcpp/line-map.c
	external/gpl3/gcc/dist/libdecnumber/ChangeLog
	external/gpl3/gcc/dist/libgcc/ChangeLog
	external/gpl3/gcc/dist/libgcc/config.host
	external/gpl3/gcc/dist/libgcc/config/t-darwin
	external/gpl3/gcc/dist/libgcc/config/libbid/ChangeLog
	external/gpl3/gcc/dist/libgcc/config/rs6000/darwin-vecsave.S
	external/gpl3/gcc/dist/libgcc/config/rs6000/t-darwin
	external/gpl3/gcc/dist/libgcc/config/rs6000/t-darwin64
	external/gpl3/gcc/dist/libgomp/ChangeLog
	external/gpl3/gcc/dist/libgomp/plugin/plugin-hsa.c
	external/gpl3/gcc/dist/libhsail-rt/ChangeLog
	external/gpl3/gcc/dist/libiberty/ChangeLog
	external/gpl3/gcc/dist/libiberty/simple-object-elf.c
	external/gpl3/gcc/dist/libobjc/ChangeLog
	external/gpl3/gcc/dist/libsanitizer/ChangeLog
	external/gpl3/gcc/dist/libssp/ChangeLog
	external/gpl3/gcc/dist/libstdc++-v3/ChangeLog
	external/gpl3/gcc/dist/libstdc++-v3/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/acinclude.m4
	external/gpl3/gcc/dist/libstdc++-v3/configure
	external/gpl3/gcc/dist/libstdc++-v3/configure.ac
	external/gpl3/gcc/dist/libstdc++-v3/configure.host
	external/gpl3/gcc/dist/libstdc++-v3/doc/Makefile.am
	external/gpl3/gcc/dist/libstdc++-v3/doc/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/doc/html/manual/documentation_hacking.html
	external/gpl3/gcc/dist/libstdc++-v3/doc/html/manual/memory.html
	external/gpl3/gcc/dist/libstdc++-v3/doc/html/manual/status.html
	external/gpl3/gcc/dist/libstdc++-v3/doc/xml/manual/allocator.xml
	external/gpl3/gcc/dist/libstdc++-v3/doc/xml/manual/documentation_hacking.xml
	external/gpl3/gcc/dist/libstdc++-v3/doc/xml/manual/shared_ptr.xml
	external/gpl3/gcc/dist/libstdc++-v3/doc/xml/manual/status_cxx2017.xml
	external/gpl3/gcc/dist/libstdc++-v3/include/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/include/bits/char_traits.h
	external/gpl3/gcc/dist/libstdc++-v3/include/bits/forward_list.tcc
	external/gpl3/gcc/dist/libstdc++-v3/include/bits/random.h
	external/gpl3/gcc/dist/libstdc++-v3/include/bits/stl_uninitialized.h
	external/gpl3/gcc/dist/libstdc++-v3/include/bits/unique_ptr.h
	external/gpl3/gcc/dist/libstdc++-v3/include/experimental/any
	external/gpl3/gcc/dist/libstdc++-v3/include/experimental/type_traits
	external/gpl3/gcc/dist/libstdc++-v3/include/experimental/bits/fs_path.h
	external/gpl3/gcc/dist/libstdc++-v3/include/std/any
	external/gpl3/gcc/dist/libstdc++-v3/include/std/optional
	external/gpl3/gcc/dist/libstdc++-v3/include/std/variant
	external/gpl3/gcc/dist/libstdc++-v3/libsupc++/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/libsupc++/cxxabi.h
	external/gpl3/gcc/dist/libstdc++-v3/libsupc++/guard_error.cc
	external/gpl3/gcc/dist/libstdc++-v3/libsupc++/hash_bytes.cc
	external/gpl3/gcc/dist/libstdc++-v3/libsupc++/new_opa.cc
	external/gpl3/gcc/dist/libstdc++-v3/python/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/python/libstdcxx/v6/xmethods.py
	external/gpl3/gcc/dist/libstdc++-v3/scripts/make_exports.pl
	external/gpl3/gcc/dist/libstdc++-v3/src/Makefile.am
	external/gpl3/gcc/dist/libstdc++-v3/src/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/src/c++11/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/src/c++17/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/src/c++98/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/src/filesystem/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/src/filesystem/path.cc
	external/gpl3/gcc/dist/lto-plugin/ChangeLog
	external/gpl3/gcc/dist/maintainer-scripts/ChangeLog
	external/gpl3/gcc/lib/libgcc/arch/powerpc64/auto-target.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/aarch64/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/alpha/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/arm/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/armeb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earm/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmeb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmhf/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmhfeb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv4/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv4eb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv6/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv6eb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv6hf/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv6hfeb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv7/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv7eb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv7hf/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv7hfeb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/hppa/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/i386/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/ia64/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/m68000/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/m68k/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/mips64eb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/mips64el/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/mipseb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/mipsel/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/powerpc/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/powerpc64/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/riscv32/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/riscv64/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/sh3eb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/sh3el/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/sparc/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/sparc64/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/vax/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/x86_64/gcov-iov.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/aarch64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/aarch64/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/alpha/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/alpha/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/arm/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/arm/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/armeb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/armeb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earm/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earm/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmeb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmeb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmhf/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmhf/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmhfeb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmhfeb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv4/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv4/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv4eb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv4eb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6eb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6eb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6hf/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6hf/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6hfeb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6hfeb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7eb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7eb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7hf/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7hf/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7hfeb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7hfeb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/hppa/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/hppa/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/i386/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/i386/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/ia64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/ia64/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/m68000/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/m68000/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/m68k/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/m68k/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mips64eb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mips64eb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mips64el/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mips64el/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mipseb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mipseb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mipsel/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mipsel/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/powerpc/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/powerpc/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/powerpc64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/powerpc64/defs.mk
	external/gpl3/gcc/lib/libstdc++-v3/arch/powerpc64/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/riscv32/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/riscv32/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/riscv64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/riscv64/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sh3eb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sh3eb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sh3el/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sh3el/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sparc/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sparc/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sparc64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sparc64/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/vax/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/vax/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/x86_64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/x86_64/gstdint.h
	external/gpl3/gcc/usr.bin/common/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/aarch64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/aarch64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/aarch64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/aarch64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/aarch64/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/alpha/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/alpha/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/alpha/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/alpha/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/alpha/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/arm/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/arm/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/arm/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/arm/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/arm/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/armeb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/armeb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/armeb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/armeb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/armeb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earm/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earm/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earm/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earm/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earm/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmeb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmeb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmeb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmeb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmeb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhf/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhf/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhf/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmhf/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmhf/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhfeb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhfeb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhfeb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmhfeb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmhfeb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4eb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4eb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4eb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4eb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4eb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6eb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6eb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6eb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6eb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6eb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hf/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hf/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hf/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hf/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hf/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hfeb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hfeb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hfeb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hfeb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hfeb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7eb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7eb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7eb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7eb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7eb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hf/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hf/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hf/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hf/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hf/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hfeb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hfeb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hfeb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hfeb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hfeb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/hppa/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/hppa/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/hppa/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/hppa/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/hppa/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/i386/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/i386/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/i386/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/i386/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/i386/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/ia64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/ia64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/ia64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/ia64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/ia64/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68000/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68000/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68000/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/m68000/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/m68000/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68k/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68k/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68k/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/m68k/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/m68k/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64eb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64eb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64eb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/mips64eb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/mips64eb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64el/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64el/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64el/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/mips64el/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/mips64el/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipseb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipseb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipseb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/mipseb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/mipseb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipsel/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipsel/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipsel/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/mipsel/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/mipsel/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc64/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv32/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv32/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv32/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/riscv32/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/riscv32/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/riscv64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/riscv64/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3eb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3eb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3eb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/sh3eb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/sh3eb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3el/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3el/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3el/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/sh3el/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/sh3el/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/sparc/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/sparc/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/sparc64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/sparc64/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/vax/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/vax/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/vax/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/vax/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/vax/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/x86_64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/x86_64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/x86_64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/x86_64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/x86_64/plugin-version.h

Import GCC 7.5.0.
@
text
@d74 1
a74 1
#define __cpp_lib_variant 201606L
@


1.1.1.2
log
@import GCC 8.3.  it includes these new features:
- many optimisations improved: inter-procedural, profile-directed,
  LTO, loops including user-controllable unroll support, and more.
- columns numbers added to line numbers in dwarf
- gcov extended significantly
- many sanitizer updates
- many new warning messages
- many better hints and more useful error messages
- minor ABI changes on x86-64 libstdc++, and some c++17 modes
- draft c++2a features
- better c++17 experimental support
- Armv8.4-A supported, better 8.2-A and 8.3-A support, including
  32 bit arm port.  cortex a-55, a-75 and a-55.a-75 combo support.
- in the GCC bugzilla, 8.1 shows 1149 bugs fixed, 8.2 shows 100, and
  8.3 shows 158.
@
text
@d3 1
a3 1
// Copyright (C) 2016-2018 Free Software Foundation, Inc.
a50 2
_GLIBCXX_BEGIN_NAMESPACE_VERSION

d55 2
d68 1
d72 2
d144 2
d150 1
a301 40
  template<typename... _Types>
    struct _Traits
    {
      static constexpr bool _S_default_ctor =
	  is_default_constructible_v<typename _Nth_type<0, _Types...>::type>;
      static constexpr bool _S_copy_ctor =
	  (is_copy_constructible_v<_Types> && ...);
      static constexpr bool _S_move_ctor =
	  (is_move_constructible_v<_Types> && ...);
      static constexpr bool _S_copy_assign =
	  _S_copy_ctor && _S_move_ctor
	  && (is_copy_assignable_v<_Types> && ...);
      static constexpr bool _S_move_assign =
	  _S_move_ctor
	  && (is_move_assignable_v<_Types> && ...);

      static constexpr bool _S_trivial_dtor =
	  (is_trivially_destructible_v<_Types> && ...);
      static constexpr bool _S_trivial_copy_ctor =
	  (is_trivially_copy_constructible_v<_Types> && ...);
      static constexpr bool _S_trivial_move_ctor =
	  (is_trivially_move_constructible_v<_Types> && ...);
      static constexpr bool _S_trivial_copy_assign =
	  _S_trivial_dtor && (is_trivially_copy_assignable_v<_Types> && ...);
      static constexpr bool _S_trivial_move_assign =
	  _S_trivial_dtor && (is_trivially_move_assignable_v<_Types> && ...);

      // The following nothrow traits are for non-trivial SMFs. Trivial SMFs
      // are always nothrow.
      static constexpr bool _S_nothrow_default_ctor =
	  is_nothrow_default_constructible_v<
	      typename _Nth_type<0, _Types...>::type>;
      static constexpr bool _S_nothrow_copy_ctor = false;
      static constexpr bool _S_nothrow_move_ctor =
	  (is_nothrow_move_constructible_v<_Types> && ...);
      static constexpr bool _S_nothrow_copy_assign = false;
      static constexpr bool _S_nothrow_move_assign =
	  _S_nothrow_move_ctor && (is_nothrow_move_assignable_v<_Types> && ...);
    };

a365 13
      void*
      _M_storage() const
      {
	return const_cast<void*>(static_cast<const void*>(
	    std::addressof(_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
	return this->_M_index != __index_type(variant_npos);
      }

a384 13
      void*
      _M_storage() const
      {
	return const_cast<void*>(static_cast<const void*>(
	    std::addressof(_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
	return this->_M_index != __index_type(variant_npos);
      }

d390 2
d393 7
a399 2
    using _Variant_storage_alias =
	_Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>;
d401 5
a405 2
  // The following are (Copy|Move) (ctor|assign) layers for forwarding
  // triviality and handling non-trivial SMF behaviors.
d407 1
a407 8
  template<bool, typename... _Types>
    struct _Copy_ctor_base : _Variant_storage_alias<_Types...>
    {
      using _Base = _Variant_storage_alias<_Types...>;
      using _Base::_Base;

      _Copy_ctor_base(const _Copy_ctor_base& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor)
d413 1
a413 1
	    _S_vtable[__rhs._M_index](this->_M_storage(), __rhs._M_storage());
d418 2
a419 24
      _Copy_ctor_base(_Copy_ctor_base&&) = default;
      _Copy_ctor_base& operator=(const _Copy_ctor_base&) = default;
      _Copy_ctor_base& operator=(_Copy_ctor_base&&) = default;
    };

  template<typename... _Types>
    struct _Copy_ctor_base<true, _Types...> : _Variant_storage_alias<_Types...>
    {
      using _Base = _Variant_storage_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Copy_ctor_alias =
	_Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>;

  template<bool, typename... _Types>
    struct _Move_ctor_base : _Copy_ctor_alias<_Types...>
    {
      using _Base = _Copy_ctor_alias<_Types...>;
      using _Base::_Base;

      _Move_ctor_base(_Move_ctor_base&& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_move_ctor)
d425 1
a425 1
	    _S_vtable[__rhs._M_index](this->_M_storage(), __rhs._M_storage());
d430 5
a434 13
      void _M_destructive_move(_Move_ctor_base&& __rhs)
      {
	this->~_Move_ctor_base();
	__try
	  {
	    ::new (this) _Move_ctor_base(std::move(__rhs));
	  }
	__catch (...)
	  {
	    this->_M_index = variant_npos;
	    __throw_exception_again;
	  }
      }
d436 2
a437 31
      _Move_ctor_base(const _Move_ctor_base&) = default;
      _Move_ctor_base& operator=(const _Move_ctor_base&) = default;
      _Move_ctor_base& operator=(_Move_ctor_base&&) = default;
    };

  template<typename... _Types>
    struct _Move_ctor_base<true, _Types...> : _Copy_ctor_alias<_Types...>
    {
      using _Base = _Copy_ctor_alias<_Types...>;
      using _Base::_Base;

      void _M_destructive_move(_Move_ctor_base&& __rhs)
      {
	this->~_Move_ctor_base();
	::new (this) _Move_ctor_base(std::move(__rhs));
      }
    };

  template<typename... _Types>
    using _Move_ctor_alias =
	_Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>;

  template<bool, typename... _Types>
    struct _Copy_assign_base : _Move_ctor_alias<_Types...>
    {
      using _Base = _Move_ctor_alias<_Types...>;
      using _Base::_Base;

      _Copy_assign_base&
      operator=(const _Copy_assign_base& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_copy_assign)
d445 1
a445 2
		_S_vtable[__rhs._M_index](this->_M_storage(),
					  __rhs._M_storage());
d450 11
a460 2
	    _Copy_assign_base __tmp(__rhs);
	    this->_M_destructive_move(std::move(__tmp));
d466 13
a478 11
      _Copy_assign_base(const _Copy_assign_base&) = default;
      _Copy_assign_base(_Copy_assign_base&&) = default;
      _Copy_assign_base& operator=(_Copy_assign_base&&) = default;
    };

  template<typename... _Types>
    struct _Copy_assign_base<true, _Types...> : _Move_ctor_alias<_Types...>
    {
      using _Base = _Move_ctor_alias<_Types...>;
      using _Base::_Base;
    };
d480 4
a483 14
  template<typename... _Types>
    using _Copy_assign_alias =
	_Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign,
			  _Types...>;

  template<bool, typename... _Types>
    struct _Move_assign_base : _Copy_assign_alias<_Types...>
    {
      using _Base = _Copy_assign_alias<_Types...>;
      using _Base::_Base;

      _Move_assign_base&
      operator=(_Move_assign_base&& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_move_assign)
d491 1
a491 2
		_S_vtable[__rhs._M_index]
		  (this->_M_storage(), __rhs._M_storage());
d496 1
a496 2
	    _Move_assign_base __tmp(std::move(__rhs));
	    this->_M_destructive_move(std::move(__tmp));
a497 1
	__glibcxx_assert(this->_M_index == __rhs._M_index);
d501 6
a506 4
      _Move_assign_base(const _Move_assign_base&) = default;
      _Move_assign_base(_Move_assign_base&&) = default;
      _Move_assign_base& operator=(const _Move_assign_base&) = default;
    };
d508 6
a513 32
  template<typename... _Types>
    struct _Move_assign_base<true, _Types...> : _Copy_assign_alias<_Types...>
    {
      using _Base = _Copy_assign_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Move_assign_alias =
	_Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign,
			  _Types...>;

  template<typename... _Types>
    struct _Variant_base : _Move_assign_alias<_Types...>
    {
      using _Base = _Move_assign_alias<_Types...>;

      constexpr
      _Variant_base()
	  noexcept(_Traits<_Types...>::_S_nothrow_default_ctor)
      : _Variant_base(in_place_index<0>) { }

      template<size_t _Np, typename... _Args>
	constexpr explicit
	_Variant_base(in_place_index_t<_Np> __i, _Args&&... __args)
	: _Base(__i, std::forward<_Args>(__args)...)
	{ }

      _Variant_base(const _Variant_base&) = default;
      _Variant_base(_Variant_base&&) = default;
      _Variant_base& operator=(const _Variant_base&) = default;
      _Variant_base& operator=(_Variant_base&&) = default;
d725 1
d729 2
d889 2
a890 2
	__detail::__variant::_Traits<_Types...>::_S_default_ctor,
	  variant<_Types...>>,
d892 7
a898 4
	__detail::__variant::_Traits<_Types...>::_S_copy_ctor,
	__detail::__variant::_Traits<_Types...>::_S_copy_assign,
	__detail::__variant::_Traits<_Types...>::_S_move_ctor,
	__detail::__variant::_Traits<_Types...>::_S_move_assign,
d912 2
a913 2
	  __detail::__variant::_Traits<_Types...>::_S_default_ctor,
	    variant<_Types...>>;
a939 2
      using _Traits = __detail::__variant::_Traits<_Types...>;

d941 5
a945 6
      variant() = default;
      variant(const variant& __rhs) = default;
      variant(variant&&) = default;
      variant& operator=(const variant&) = default;
      variant& operator=(variant&&) = default;
      ~variant() = default;
d955 1
a955 2
	: variant(in_place_index<__accepted_index<_Tp&&>>,
		  std::forward<_Tp>(__t))
d963 1
a963 2
	: variant(in_place_index<__index_of<_Tp>>,
		  std::forward<_Args>(__args)...)
d996 7
d1097 1
a1097 1
	    typename _Base::__index_type(variant_npos))
d1141 1
a1141 1
		const variant&, __indices>... }; \
d1171 5
a1175 1
	friend constexpr decltype(auto) __detail::__variant::__get(_Vp&& __v);
d1178 5
a1182 1
	friend void* __detail::__variant::__get_storage(_Vp&& __v);
d1293 1
a1293 1
	variant<_Types...>, std::index_sequence_for<_Types...>>,
d1296 2
a1297 2
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = variant<_Types...>;
d1303 2
a1304 2
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = monostate;
a1313 5
  template<typename... _Types>
    struct __is_fast_hash<hash<variant<_Types...>>>
    : bool_constant<(__is_fast_hash<_Types>::value && ...)>
    { };

@


1.1.1.3
log
@import GCC 8.4.  it fixes at least these 210 PRs in GCC bugzilla:

90095 93348 89906 89766 86747 87770 89588 89753 88235 89762 89684 89946
89965 90010 90026 90733 90810 90840 90842 90867 91623 92930 93073 93402
93505 93576 93744 93820 93908 85762 86429 86521 87327 87480 87513 87554
87685 87748 88183 88380 88394 88419 88690 88820 89381 89422 89576 89831
89917 90951 92003 92852 93140 80791 89358 89970 90899 89212 89419 92745
93684 93789 88273 91826 92376 84746 89497 89595 89664 89711 89725 90018
90316 90900 91108 91293 91772 92763 93054 93246 90313 92420 93434 93767
88530 89517 91838 79262 84680 85459 85711 85860 86567 87008 87651 87652
88469 89546 89827 90197 93072 93241 81800 89190 85400 91472 91854 92095
92131 92575 93704 60228 61414 65782 89405 89498 89703 89752 90187 90193
90898 91401 91450 91665 92296 92384 92438 92615 92648 92723 92732 92904
93087 93228 93515 93905 82081 92859 89712 89876 92106 82645 78552 81266
85965 89102 90165 90299 90532 91436 92059 93205 93325 93562 90359 91280
91375 92674 92704 93439 92768 80938 83361 90563 92113 92961 87833 89848
89902 89903 92022 93828 78179 79221 82920 84016 87015 88075 89077 89266
90454 90634 91226 92154 92664 92886 93065 92692 92629 80590 91944 92899
92977 93463 89601 88025 91660 91845 90498 91077 84487 86119 89174 89981
91550 92569 84135 84974 90872 93714
@
text
@d71 1
a71 1
#define __cpp_lib_variant 201606L
d812 3
a814 2
	    remove_reference_t<decltype(__element)>, tuple<_Variants...>,
	    std::index_sequence<__indices..., __index>>::_S_apply();
d827 2
a828 2
      static constexpr decltype(auto)
      __visit_invoke(_Visitor&& __visitor, _Variants... __vars)
d831 1
a831 1
	    __variant::__get<__indices>(std::forward<_Variants>(__vars))...);
d872 2
a873 2
    constexpr bool
    holds_alternative(const variant<_Types...>& __v) noexcept
d881 1
a881 1
    constexpr _Tp& get(variant<_Types...>& __v)
d890 1
a890 1
    constexpr _Tp&& get(variant<_Types...>&& __v)
d900 1
a900 1
    constexpr const _Tp& get(const variant<_Types...>& __v)
d909 1
a909 1
    constexpr const _Tp&& get(const variant<_Types...>&& __v)
d919 2
a920 1
    constexpr add_pointer_t<variant_alternative_t<_Np, variant<_Types...>>>
d933 1
a933 1
    constexpr
d947 1
a947 1
    constexpr add_pointer_t<_Tp>
d958 1
a958 1
    constexpr add_pointer_t<const _Tp>
a1078 11
      template<typename _Tp>
	struct __is_in_place_tag : false_type { };
      template<typename _Tp>
	struct __is_in_place_tag<in_place_type_t<_Tp>> : true_type { };
      template<size_t _Np>
	struct __is_in_place_tag<in_place_index_t<_Np>> : true_type { };

      template<typename _Tp>
	static constexpr bool __not_in_place_tag
	  = !__is_in_place_tag<decay_t<_Tp>>::value;

a1089 1
	       typename = enable_if_t<__not_in_place_tag<_Tp>>,
d1278 1
a1278 1
	constexpr bool \
@


1.1.1.4
log
@import GCC 7.5.0.  doing this here so that the vendor branch has
the code we'll merge into gcc.old and the netbsd-9 tree gcc tree.
GCC 8.4.0 will be imported immediately on top of this again,
restoring the current status.

these PRs in the GCC bugzilla are fixed with this update:

89869 80693 89795 84272 85593 86669 87148 87647 87895 88103 88107 88563
88870 88976 89002 89187 89195 89234 89303 89314 89354 89361 89403 89412
89512 89520 89590 89621 89663 89679 89704 89734 89872 89933 90090 90208
87075 85870 89009 89242 88167 80864 81933 85890 86608 87145 88857 89024
89119 89214 89511 89612 89705 89400 81740 82186 84552 86554 87609 88105
88149 88415 88739 88903 89135 89223 89296 89505 89572 89677 89698 89710
90006 90020 90071 90328 90474 91126 91162 91812 91887 90075 88998 89945
87047 87506 88074 88656 88740 91137 89008 84010 89349 91136 91347 91995
89397 87030 60702 78884 85594 87649 87725 88181 88470 88553 88568 88588
88620 88644 88906 88949 89246 89587 89726 89768 89796 89998 90108 90756
90950 91704 88825 88983 86538 51333 89446 90220 91308 92143 89392 90213
90278 91131 91200 91510 89037 91481 87673 88418 88938 88948 90547 27221
58321 61250 67183 67958 77583 83531 86215 88648 88720 88726 89091 89466
89629 90105 90329 90585 90760 90924 91087 89222 81956 71861 35031 69455
81849 82993 85798 88138 88155 88169 88205 88206 88228 88249 88269 88376
77703 80260 82077 86248 88393 90786 57048 66089 66695 67679 68009 71723
72714 84394 85544 87734 88298 90937 91557 63891 64132 65342 68649 68717
71066 71860 71935 77746 78421 78645 78865 78983 79485 79540 85953 88326
89651 90744
@
text
@d3 1
a3 1
// Copyright (C) 2016-2017 Free Software Foundation, Inc.
d51 2
a56 2
_GLIBCXX_BEGIN_NAMESPACE_VERSION

a67 1
_GLIBCXX_END_NAMESPACE_VERSION
a70 2
_GLIBCXX_BEGIN_NAMESPACE_VERSION

a140 2
_GLIBCXX_END_NAMESPACE_VERSION

a144 1
_GLIBCXX_BEGIN_NAMESPACE_VERSION
d296 40
d400 13
d432 13
a449 2
  // Helps SFINAE on special member functions. Otherwise it can live in variant
  // class.
d451 5
a455 7
    struct _Variant_base :
      _Variant_storage<(std::is_trivially_destructible_v<_Types> && ...),
			_Types...>
    {
      using _Storage =
	  _Variant_storage<(std::is_trivially_destructible_v<_Types> && ...),
			    _Types...>;
d457 5
a461 5
      constexpr
      _Variant_base()
      noexcept(is_nothrow_default_constructible_v<
		 variant_alternative_t<0, variant<_Types...>>>)
      : _Variant_base(in_place_index<0>) { }
d463 2
a464 1
      _Variant_base(const _Variant_base& __rhs)
d470 1
a470 1
	    _S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
d475 24
a498 2
      _Variant_base(_Variant_base&& __rhs)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...))
d504 1
a504 1
	    _S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
d509 41
a549 5
      template<size_t _Np, typename... _Args>
	constexpr explicit
	_Variant_base(in_place_index_t<_Np> __i, _Args&&... __args)
	: _Storage(__i, std::forward<_Args>(__args)...)
	{ }
d551 3
a553 2
      _Variant_base&
      operator=(const _Variant_base& __rhs)
d561 2
a562 1
		_S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
d567 2
a568 11
	    _Variant_base __tmp(__rhs);
	    this->~_Variant_base();
	    __try
	      {
		::new (this) _Variant_base(std::move(__tmp));
	      }
	    __catch (...)
	      {
		this->_M_index = variant_npos;
		__throw_exception_again;
	      }
d574 22
a595 13
      void _M_destructive_move(_Variant_base&& __rhs)
      {
	this->~_Variant_base();
	__try
	  {
	    ::new (this) _Variant_base(std::move(__rhs));
	  }
	__catch (...)
	  {
	    this->_M_index = variant_npos;
	    __throw_exception_again;
	  }
      }
d597 3
a599 4
      _Variant_base&
      operator=(_Variant_base&& __rhs)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)
	  && (is_nothrow_move_assignable_v<_Types> && ...))
d607 2
a608 1
		_S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
d613 2
a614 1
	    _M_destructive_move(std::move(__rhs));
d616 1
d620 32
a651 6
      void*
      _M_storage() const
      {
	return const_cast<void*>(static_cast<const void*>(
	    std::addressof(_Storage::_M_u)));
      }
d653 4
a656 6
      constexpr bool
      _M_valid() const noexcept
      {
	return this->_M_index !=
	  typename _Storage::__index_type(variant_npos);
      }
d812 2
a813 3
	    remove_reference_t<
	      decltype(__element)>, tuple<_Variants...>,
	      std::index_sequence<__indices..., __index>>::_S_apply();
d826 2
a827 2
      decltype(auto)
      static constexpr __visit_invoke(_Visitor&& __visitor, _Variants... __vars)
d830 1
a830 1
	    std::get<__indices>(std::forward<_Variants>(__vars))...);
a866 1
_GLIBCXX_END_NAMESPACE_VERSION
a869 2
_GLIBCXX_BEGIN_NAMESPACE_VERSION

d871 2
a872 2
    inline constexpr bool holds_alternative(const variant<_Types...>& __v)
    noexcept
d880 1
a880 1
    constexpr inline _Tp& get(variant<_Types...>& __v)
d889 1
a889 1
    constexpr inline _Tp&& get(variant<_Types...>&& __v)
d899 1
a899 1
    constexpr inline const _Tp& get(const variant<_Types...>& __v)
d908 1
a908 1
    constexpr inline const _Tp&& get(const variant<_Types...>&& __v)
d918 1
a918 2
    constexpr inline
    add_pointer_t<variant_alternative_t<_Np, variant<_Types...>>>
d931 1
a931 1
    constexpr inline
d945 1
a945 1
    constexpr inline add_pointer_t<_Tp>
d956 1
a956 1
    constexpr inline add_pointer_t<const _Tp>
d1027 2
a1028 2
	is_default_constructible_v<
	  variant_alternative_t<0, variant<_Types...>>>, variant<_Types...>>,
d1030 4
a1033 7
	(is_copy_constructible_v<_Types> && ...),
	(is_copy_constructible_v<_Types> && ...)
	     && (is_move_constructible_v<_Types> && ...)
	     && (is_copy_assignable_v<_Types> && ...),
	(is_move_constructible_v<_Types> && ...),
	(is_move_constructible_v<_Types> && ...)
	     && (is_move_assignable_v<_Types> && ...),
d1047 2
a1048 2
	  is_default_constructible_v<
	    variant_alternative_t<0, variant<_Types...>>>, variant<_Types...>>;
d1075 13
d1089 6
a1094 5
      constexpr variant()
      noexcept(is_nothrow_default_constructible_v<__to_type<0>>) = default;
      variant(const variant&) = default;
      variant(variant&&)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)) = default;
d1099 1
d1105 2
a1106 1
	: variant(in_place_index<__accepted_index<_Tp&&>>, std::forward<_Tp>(__t))
d1114 2
a1115 1
	: variant(in_place_index<__index_of<_Tp>>, std::forward<_Args>(__args)...)
a1147 7
      ~variant() = default;

      variant& operator=(const variant&) = default;
      variant& operator=(variant&&)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)
	  && (is_nothrow_move_assignable_v<_Types> && ...)) = default;

d1242 1
a1242 1
	    typename _Base::_Storage::__index_type(variant_npos))
d1286 1
a1286 1
                const variant&, __indices>... }; \
d1288 1
a1288 1
	constexpr inline bool \
d1316 1
a1316 5
	friend constexpr decltype(auto) __detail::__variant::
#if _GLIBCXX_INLINE_VERSION
        __7:: // Required due to PR c++/59256
#endif
	__get(_Vp&& __v);
d1319 1
a1319 5
	friend void* __detail::__variant::
#if _GLIBCXX_INLINE_VERSION
        __7:: // Required due to PR c++/59256
#endif
        __get_storage(_Vp&& __v);
d1430 1
a1430 1
        variant<_Types...>, std::index_sequence_for<_Types...>>,
d1433 2
a1434 2
      using result_type = size_t;
      using argument_type = variant<_Types...>;
d1440 2
a1441 2
      using result_type = size_t;
      using argument_type = monostate;
d1451 5
@


1.1.1.5
log
@re-import GCC 8.4.0.
@
text
@d3 1
a3 1
// Copyright (C) 2016-2018 Free Software Foundation, Inc.
a50 2
_GLIBCXX_BEGIN_NAMESPACE_VERSION

d55 2
d68 1
d72 2
d144 2
d150 1
a301 40
  template<typename... _Types>
    struct _Traits
    {
      static constexpr bool _S_default_ctor =
	  is_default_constructible_v<typename _Nth_type<0, _Types...>::type>;
      static constexpr bool _S_copy_ctor =
	  (is_copy_constructible_v<_Types> && ...);
      static constexpr bool _S_move_ctor =
	  (is_move_constructible_v<_Types> && ...);
      static constexpr bool _S_copy_assign =
	  _S_copy_ctor && _S_move_ctor
	  && (is_copy_assignable_v<_Types> && ...);
      static constexpr bool _S_move_assign =
	  _S_move_ctor
	  && (is_move_assignable_v<_Types> && ...);

      static constexpr bool _S_trivial_dtor =
	  (is_trivially_destructible_v<_Types> && ...);
      static constexpr bool _S_trivial_copy_ctor =
	  (is_trivially_copy_constructible_v<_Types> && ...);
      static constexpr bool _S_trivial_move_ctor =
	  (is_trivially_move_constructible_v<_Types> && ...);
      static constexpr bool _S_trivial_copy_assign =
	  _S_trivial_dtor && (is_trivially_copy_assignable_v<_Types> && ...);
      static constexpr bool _S_trivial_move_assign =
	  _S_trivial_dtor && (is_trivially_move_assignable_v<_Types> && ...);

      // The following nothrow traits are for non-trivial SMFs. Trivial SMFs
      // are always nothrow.
      static constexpr bool _S_nothrow_default_ctor =
	  is_nothrow_default_constructible_v<
	      typename _Nth_type<0, _Types...>::type>;
      static constexpr bool _S_nothrow_copy_ctor = false;
      static constexpr bool _S_nothrow_move_ctor =
	  (is_nothrow_move_constructible_v<_Types> && ...);
      static constexpr bool _S_nothrow_copy_assign = false;
      static constexpr bool _S_nothrow_move_assign =
	  _S_nothrow_move_ctor && (is_nothrow_move_assignable_v<_Types> && ...);
    };

a365 13
      void*
      _M_storage() const
      {
	return const_cast<void*>(static_cast<const void*>(
	    std::addressof(_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
	return this->_M_index != __index_type(variant_npos);
      }

a384 13
      void*
      _M_storage() const
      {
	return const_cast<void*>(static_cast<const void*>(
	    std::addressof(_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
	return this->_M_index != __index_type(variant_npos);
      }

d390 2
d393 7
a399 2
    using _Variant_storage_alias =
	_Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>;
d401 5
a405 8
  // The following are (Copy|Move) (ctor|assign) layers for forwarding
  // triviality and handling non-trivial SMF behaviors.

  template<bool, typename... _Types>
    struct _Copy_ctor_base : _Variant_storage_alias<_Types...>
    {
      using _Base = _Variant_storage_alias<_Types...>;
      using _Base::_Base;
d407 1
a407 2
      _Copy_ctor_base(const _Copy_ctor_base& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor)
d413 1
a413 1
	    _S_vtable[__rhs._M_index](this->_M_storage(), __rhs._M_storage());
d418 2
a419 24
      _Copy_ctor_base(_Copy_ctor_base&&) = default;
      _Copy_ctor_base& operator=(const _Copy_ctor_base&) = default;
      _Copy_ctor_base& operator=(_Copy_ctor_base&&) = default;
    };

  template<typename... _Types>
    struct _Copy_ctor_base<true, _Types...> : _Variant_storage_alias<_Types...>
    {
      using _Base = _Variant_storage_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Copy_ctor_alias =
	_Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>;

  template<bool, typename... _Types>
    struct _Move_ctor_base : _Copy_ctor_alias<_Types...>
    {
      using _Base = _Copy_ctor_alias<_Types...>;
      using _Base::_Base;

      _Move_ctor_base(_Move_ctor_base&& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_move_ctor)
d425 1
a425 1
	    _S_vtable[__rhs._M_index](this->_M_storage(), __rhs._M_storage());
d430 5
a434 41
      void _M_destructive_move(_Move_ctor_base&& __rhs)
      {
	this->~_Move_ctor_base();
	__try
	  {
	    ::new (this) _Move_ctor_base(std::move(__rhs));
	  }
	__catch (...)
	  {
	    this->_M_index = variant_npos;
	    __throw_exception_again;
	  }
      }

      _Move_ctor_base(const _Move_ctor_base&) = default;
      _Move_ctor_base& operator=(const _Move_ctor_base&) = default;
      _Move_ctor_base& operator=(_Move_ctor_base&&) = default;
    };

  template<typename... _Types>
    struct _Move_ctor_base<true, _Types...> : _Copy_ctor_alias<_Types...>
    {
      using _Base = _Copy_ctor_alias<_Types...>;
      using _Base::_Base;

      void _M_destructive_move(_Move_ctor_base&& __rhs)
      {
	this->~_Move_ctor_base();
	::new (this) _Move_ctor_base(std::move(__rhs));
      }
    };

  template<typename... _Types>
    using _Move_ctor_alias =
	_Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>;

  template<bool, typename... _Types>
    struct _Copy_assign_base : _Move_ctor_alias<_Types...>
    {
      using _Base = _Move_ctor_alias<_Types...>;
      using _Base::_Base;
d436 2
a437 3
      _Copy_assign_base&
      operator=(const _Copy_assign_base& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_copy_assign)
d445 1
a445 2
		_S_vtable[__rhs._M_index](this->_M_storage(),
					  __rhs._M_storage());
d450 11
a460 2
	    _Copy_assign_base __tmp(__rhs);
	    this->_M_destructive_move(std::move(__tmp));
d466 13
a478 16
      _Copy_assign_base(const _Copy_assign_base&) = default;
      _Copy_assign_base(_Copy_assign_base&&) = default;
      _Copy_assign_base& operator=(_Copy_assign_base&&) = default;
    };

  template<typename... _Types>
    struct _Copy_assign_base<true, _Types...> : _Move_ctor_alias<_Types...>
    {
      using _Base = _Move_ctor_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Copy_assign_alias =
	_Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign,
			  _Types...>;
d480 4
a483 9
  template<bool, typename... _Types>
    struct _Move_assign_base : _Copy_assign_alias<_Types...>
    {
      using _Base = _Copy_assign_alias<_Types...>;
      using _Base::_Base;

      _Move_assign_base&
      operator=(_Move_assign_base&& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_move_assign)
d491 1
a491 2
		_S_vtable[__rhs._M_index]
		  (this->_M_storage(), __rhs._M_storage());
d496 1
a496 2
	    _Move_assign_base __tmp(std::move(__rhs));
	    this->_M_destructive_move(std::move(__tmp));
a497 1
	__glibcxx_assert(this->_M_index == __rhs._M_index);
d501 6
a506 4
      _Move_assign_base(const _Move_assign_base&) = default;
      _Move_assign_base(_Move_assign_base&&) = default;
      _Move_assign_base& operator=(const _Move_assign_base&) = default;
    };
d508 6
a513 32
  template<typename... _Types>
    struct _Move_assign_base<true, _Types...> : _Copy_assign_alias<_Types...>
    {
      using _Base = _Copy_assign_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Move_assign_alias =
	_Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign,
			  _Types...>;

  template<typename... _Types>
    struct _Variant_base : _Move_assign_alias<_Types...>
    {
      using _Base = _Move_assign_alias<_Types...>;

      constexpr
      _Variant_base()
	  noexcept(_Traits<_Types...>::_S_nothrow_default_ctor)
      : _Variant_base(in_place_index<0>) { }

      template<size_t _Np, typename... _Args>
	constexpr explicit
	_Variant_base(in_place_index_t<_Np> __i, _Args&&... __args)
	: _Base(__i, std::forward<_Args>(__args)...)
	{ }

      _Variant_base(const _Variant_base&) = default;
      _Variant_base(_Variant_base&&) = default;
      _Variant_base& operator=(const _Variant_base&) = default;
      _Variant_base& operator=(_Variant_base&&) = default;
d669 3
a671 2
	    remove_reference_t<decltype(__element)>, tuple<_Variants...>,
	    std::index_sequence<__indices..., __index>>::_S_apply();
d684 2
a685 2
      static constexpr decltype(auto)
      __visit_invoke(_Visitor&& __visitor, _Variants... __vars)
d688 1
a688 1
	    __variant::__get<__indices>(std::forward<_Variants>(__vars))...);
d725 1
d729 2
d732 2
a733 2
    constexpr bool
    holds_alternative(const variant<_Types...>& __v) noexcept
d741 1
a741 1
    constexpr _Tp& get(variant<_Types...>& __v)
d750 1
a750 1
    constexpr _Tp&& get(variant<_Types...>&& __v)
d760 1
a760 1
    constexpr const _Tp& get(const variant<_Types...>& __v)
d769 1
a769 1
    constexpr const _Tp&& get(const variant<_Types...>&& __v)
d779 2
a780 1
    constexpr add_pointer_t<variant_alternative_t<_Np, variant<_Types...>>>
d793 1
a793 1
    constexpr
d807 1
a807 1
    constexpr add_pointer_t<_Tp>
d818 1
a818 1
    constexpr add_pointer_t<const _Tp>
d889 2
a890 2
	__detail::__variant::_Traits<_Types...>::_S_default_ctor,
	  variant<_Types...>>,
d892 7
a898 4
	__detail::__variant::_Traits<_Types...>::_S_copy_ctor,
	__detail::__variant::_Traits<_Types...>::_S_copy_assign,
	__detail::__variant::_Traits<_Types...>::_S_move_ctor,
	__detail::__variant::_Traits<_Types...>::_S_move_assign,
d912 2
a913 2
	  __detail::__variant::_Traits<_Types...>::_S_default_ctor,
	    variant<_Types...>>;
a939 13
      using _Traits = __detail::__variant::_Traits<_Types...>;

      template<typename _Tp>
	struct __is_in_place_tag : false_type { };
      template<typename _Tp>
	struct __is_in_place_tag<in_place_type_t<_Tp>> : true_type { };
      template<size_t _Np>
	struct __is_in_place_tag<in_place_index_t<_Np>> : true_type { };

      template<typename _Tp>
	static constexpr bool __not_in_place_tag
	  = !__is_in_place_tag<decay_t<_Tp>>::value;

d941 5
a945 6
      variant() = default;
      variant(const variant& __rhs) = default;
      variant(variant&&) = default;
      variant& operator=(const variant&) = default;
      variant& operator=(variant&&) = default;
      ~variant() = default;
a949 1
	       typename = enable_if_t<__not_in_place_tag<_Tp>>,
d955 1
a955 2
	: variant(in_place_index<__accepted_index<_Tp&&>>,
		  std::forward<_Tp>(__t))
d963 1
a963 2
	: variant(in_place_index<__index_of<_Tp>>,
		  std::forward<_Args>(__args)...)
d996 7
d1097 1
a1097 1
	    typename _Base::__index_type(variant_npos))
d1141 1
a1141 1
		const variant&, __indices>... }; \
d1143 1
a1143 1
	constexpr bool \
d1171 5
a1175 1
	friend constexpr decltype(auto) __detail::__variant::__get(_Vp&& __v);
d1178 5
a1182 1
	friend void* __detail::__variant::__get_storage(_Vp&& __v);
d1293 1
a1293 1
	variant<_Types...>, std::index_sequence_for<_Types...>>,
d1296 2
a1297 2
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = variant<_Types...>;
d1303 2
a1304 2
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = monostate;
a1313 5
  template<typename... _Types>
    struct __is_fast_hash<hash<variant<_Types...>>>
    : bool_constant<(__is_fast_hash<_Types>::value && ...)>
    { };

@


1.1.1.6
log
@initial import of GCC 9.3.0.  changes include:

- live patching support
- shell completion help
- generally better diagnostic output (less verbose/more useful)
- diagnostics and optimisation choices can be emitted in json
- asan memory usage reduction
- many general, and specific to switch, inter-procedure,
  profile and link-time optimisations.  from the release notes:
  "Overall compile time of Firefox 66 and LibreOffice 6.2.3 on
  an 8-core machine was reduced by about 5% compared to GCC 8.3"
- OpenMP 5.0 support
- better spell-guesser
- partial experimental support for c2x and c++2a
- c++17 is no longer experimental
- arm AAPCS GCC 6-8 structure passing bug fixed, may cause
  incompatibility (restored compat with GCC 5 and earlier.)
- openrisc support
@
text
@d3 1
a3 1
// Copyright (C) 2016-2019 Free Software Foundation, Inc.
a140 21
  template<bool __use_index=false,
	   bool __same_return_types = true,
	   typename _Visitor, typename... _Variants>
    constexpr decltype(auto)
    __do_visit(_Visitor&& __visitor, _Variants&&... __variants);

  template <typename... _Types, typename _Tp>
    decltype(auto)
    __variant_cast(_Tp&& __rhs)
    {
      if constexpr (is_lvalue_reference_v<_Tp>)
	{
	  if constexpr (is_const_v<remove_reference_t<_Tp>>)
	    return static_cast<const variant<_Types...>&>(__rhs);
	  else
	    return static_cast<variant<_Types...>&>(__rhs);
	}
      else
        return static_cast<variant<_Types...>&&>(__rhs);
    }

a157 7
  // used for raw visitation
  struct __variant_cookie {};
  // used for raw visitation with indices passed in
  struct __variant_idx_cookie { using type = __variant_idx_cookie; };
  // a more explanatory name than 'true'
  inline constexpr auto __visit_with_index = bool_constant<true>{};

d173 3
a175 4
	constexpr
	_Uninitialized(in_place_index_t<0>, _Args&&... __args)
	: _M_storage(std::forward<_Args>(__args)...)
	{ }
d177 1
a177 1
      constexpr const _Type& _M_get() const & noexcept
d180 1
a180 1
      constexpr _Type& _M_get() & noexcept
d183 1
a183 1
      constexpr const _Type&& _M_get() const && noexcept
d186 1
a186 1
      constexpr _Type&& _M_get() && noexcept
d196 2
a197 6
	constexpr
	_Uninitialized(in_place_index_t<0>, _Args&&... __args)
	{
	  ::new ((void*)std::addressof(_M_storage))
	    _Type(std::forward<_Args>(__args)...);
	}
d199 1
a199 1
      const _Type& _M_get() const & noexcept
d202 1
a202 1
      _Type& _M_get() & noexcept
d205 1
a205 1
      const _Type&& _M_get() const && noexcept
d208 1
a208 1
      _Type&& _M_get() && noexcept
d214 6
d221 1
a221 2
    constexpr decltype(auto)
    __get(in_place_index_t<0>, _Union&& __u) noexcept
d225 1
a225 2
    constexpr decltype(auto)
    __get(in_place_index_t<_Np>, _Union&& __u) noexcept
d233 1
a233 2
    constexpr decltype(auto)
    __get(_Variant&& __v) noexcept
d239 57
d306 1
a306 1
	  _S_copy_ctor
d319 1
a319 2
	  _S_trivial_dtor && _S_trivial_copy_ctor
	  && (is_trivially_copy_assignable_v<_Types> && ...);
d321 1
a321 2
	  _S_trivial_dtor && _S_trivial_move_ctor
	  && (is_trivially_move_assignable_v<_Types> && ...);
d333 1
a333 2
	  _S_nothrow_move_ctor
	  && (is_nothrow_move_assignable_v<_Types> && ...);
a358 27
  // _Never_valueless_alt is true for variant alternatives that can
  // always be placed in a variant without it becoming valueless.

  // For suitably-small, trivially copyable types we can create temporaries
  // on the stack and then memcpy them into place.
  template<typename _Tp>
    struct _Never_valueless_alt
    : __and_<bool_constant<sizeof(_Tp) <= 256>, is_trivially_copyable<_Tp>>
    { };

  // Specialize _Never_valueless_alt for other types which have a
  // non-throwing and cheap move construction and move assignment operator,
  // so that emplacing the type will provide the strong exception-safety
  // guarantee, by creating and moving a temporary.
  // Whether _Never_valueless_alt<T> is true or not affects the ABI of a
  // variant using that alternative, so we can't change the value later!

  // True if every alternative in _Types... can be emplaced in a variant
  // without it becoming valueless. If this is true, variant<_Types...>
  // can never be valueless, which enables some minor optimizations.
  template <typename... _Types>
    constexpr bool __never_valueless()
    {
      return _Traits<_Types...>::_S_move_assign
	&& (_Never_valueless_alt<_Types>::value && ...);
    }

d364 4
a367 4
    using __select_index =
      typename __select_int::_Select_int_base<sizeof...(_Types),
					      unsigned char,
					      unsigned short>::type::value_type;
d372 4
d384 6
a389 11
      constexpr void _M_reset_impl()
      {
	__do_visit([](auto&& __this_mem) mutable
		   -> __detail::__variant::__variant_cookie
	  {
	    if constexpr (!is_same_v<remove_reference_t<decltype(__this_mem)>,
			  __variant_cookie>)
	      std::_Destroy(std::__addressof(__this_mem));
	    return {};
	  }, __variant_cast<_Types...>(*this));
      }
d393 1
a393 1
	_M_reset_impl();
a409 2
	if constexpr (__never_valueless<_Types...>())
	  return true;
a441 2
	if constexpr (__never_valueless<_Types...>())
	  return true;
a453 23
  template<typename _Tp, typename _Up>
    void __variant_construct_single(_Tp&& __lhs, _Up&& __rhs_mem)
    {
      void* __storage = std::addressof(__lhs._M_u);
      using _Type = remove_reference_t<decltype(__rhs_mem)>;
      if constexpr (!is_same_v<_Type, __variant_cookie>)
        ::new (__storage)
	  _Type(std::forward<decltype(__rhs_mem)>(__rhs_mem));
    }

  template<typename... _Types, typename _Tp, typename _Up>
    void __variant_construct(_Tp&& __lhs, _Up&& __rhs)
    {
      __lhs._M_index = __rhs._M_index;
      __do_visit([&__lhs](auto&& __rhs_mem) mutable
		 -> __detail::__variant::__variant_cookie
        {
	  __variant_construct_single(std::forward<_Tp>(__lhs),
	      std::forward<decltype(__rhs_mem)>(__rhs_mem));
	  return {};
	}, __variant_cast<_Types...>(std::forward<_Up>(__rhs)));
    }

d466 7
a472 1
	__variant_construct<_Types...>(*this, __rhs);
d500 7
a506 1
	__variant_construct<_Types...>(*this, std::move(__rhs));
d509 13
a521 15
      template<typename _Up>
        void _M_destructive_move(unsigned short __rhs_index, _Up&& __rhs)
        {
	  this->_M_reset();
	  __variant_construct_single(*this, std::forward<_Up>(__rhs));
	  this->_M_index = __rhs_index;
	}

      template<typename _Up>
        void _M_destructive_copy(unsigned short __rhs_index, const _Up& __rhs)
        {
	  this->_M_reset();
	  __variant_construct_single(*this, __rhs);
	  this->_M_index = __rhs_index;
	}
d534 5
a538 15
      template<typename _Up>
        void _M_destructive_move(unsigned short __rhs_index, _Up&& __rhs)
        {
	  this->_M_reset();
	  __variant_construct_single(*this, std::forward<_Up>(__rhs));
	  this->_M_index = __rhs_index;
	}

      template<typename _Up>
        void _M_destructive_copy(unsigned short __rhs_index, const _Up& __rhs)
        {
	  this->_M_reset();
	  __variant_construct_single(*this, __rhs);
	  this->_M_index = __rhs_index;
	}
d555 1
a555 3
	__do_visit<__visit_with_index>([this](auto&& __rhs_mem,
					      auto __rhs_index) mutable
	    -> __detail::__variant::__variant_idx_cookie
d557 1
a557 1
	    if constexpr (__rhs_index != variant_npos)
d559 4
a562 19
		if (this->_M_index == __rhs_index)
		  __variant::__get<__rhs_index>(*this) = __rhs_mem;
		else
		  {
		    using __rhs_type = __remove_cvref_t<decltype(__rhs_mem)>;
		    if constexpr (is_nothrow_copy_constructible_v<__rhs_type>
			|| !is_nothrow_move_constructible_v<__rhs_type>)
		      // The standard says this->emplace<__rhs_type>(__rhs_mem)
		      // should be used here, but _M_destructive_copy is
		      // equivalent in this case. Either copy construction
		      // doesn't throw, so _M_destructive_copy gives strong
		      // exception safety guarantee, or both copy construction
		      // and move construction can throw, so emplace only gives
		      // basic exception safety anyway.
		      this->_M_destructive_copy(__rhs_index, __rhs_mem);
		    else
		      __variant_cast<_Types...>(*this)
			= variant<_Types...>(__rhs_mem);
		  }
d564 7
a570 4
	    else
	      this->_M_reset();
	    return {};
	  }, __variant_cast<_Types...>(__rhs));
d588 2
a589 1
      _Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign, _Types...>;
d601 1
a601 3
	__do_visit<__visit_with_index>([this](auto&& __rhs_mem,
					      auto __rhs_index) mutable
	    -> __detail::__variant::__variant_idx_cookie
d603 1
a603 1
	    if constexpr (__rhs_index != variant_npos)
d605 4
a608 5
		if (this->_M_index == __rhs_index)
		  __variant::__get<__rhs_index>(*this) = std::move(__rhs_mem);
		else
		  __variant_cast<_Types...>(*this)
		    .template emplace<__rhs_index>(std::move(__rhs_mem));
d610 7
a616 4
	    else
	      this->_M_reset();
	    return {};
	  }, __variant_cast<_Types...>(__rhs));
d634 2
a635 1
      _Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign, _Types...>;
d702 1
a702 2
  // __accepted_index maps an arbitrary _Tp to an alternative type in _Variant
  // (or to variant_npos).
d710 2
a711 1
      void_t<decltype(__overload_set<_Types...>::_S_fun(std::declval<_Tp>()))>>
d723 1
a723 16
  template <typename _Maybe_variant_cookie, typename _Variant>
    struct _Extra_visit_slot_needed
    {
      template <typename> struct _Variant_never_valueless;

      template <typename... _Types>
	struct _Variant_never_valueless<variant<_Types...>>
	: bool_constant<__never_valueless<_Types...>()> {};

      static constexpr bool value =
	(is_same_v<_Maybe_variant_cookie, __variant_cookie>
	 || is_same_v<_Maybe_variant_cookie, __variant_idx_cookie>)
	&& !_Variant_never_valueless<__remove_cvref_t<_Variant>>::value;
    };

  // Used for storing a multi-dimensional vtable.
d725 1
a725 5
    struct _Multi_array;

  // Partial specialization with rank zero, stores a single _Tp element.
  template<typename _Tp>
    struct _Multi_array<_Tp>
d734 3
a736 17
  // Partial specialization with rank >= 1.
  template<typename _Ret,
	   typename _Visitor,
	   typename... _Variants,
	   size_t __first, size_t... __rest>
    struct _Multi_array<_Ret(*)(_Visitor, _Variants...), __first, __rest...>
    {
      static constexpr size_t __index =
	sizeof...(_Variants) - sizeof...(__rest) - 1;

      using _Variant = typename _Nth_type<__index, _Variants...>::type;

      static constexpr int __do_cookie =
	_Extra_visit_slot_needed<_Ret, _Variant>::value ? 1 : 0;

      using _Tp = _Ret(*)(_Visitor, _Variants...);

d740 1
a740 4
        {
	  return _M_arr[__first_index + __do_cookie]
	    ._M_access(__rest_indices...);
	}
d742 1
a742 1
      _Multi_array<_Tp, __rest...> _M_arr[__first + __do_cookie];
a746 4
  // The __same_return_types non-type template parameter specifies whether
  // to enforce that all visitor invocations return the same type. This is
  // required by std::visit but not std::visit<R>.
  //
d752 1
a752 1
  // __gen_vtable_impl<true, _Multi_array<void(*)(V1&&, V2&&), 2, 3>,
d754 1
a754 1
  //   __gen_vtable_impl<true, _Multi_array<void(*)(V1&&, V2&&), 3>,
d756 1
a756 1
  //     __gen_vtable_impl<true, _Multi_array<void(*)(V1&&, V2&&)>,
d758 1
a758 1
  //     __gen_vtable_impl<true, _Multi_array<void(*)(V1&&, V2&&)>,
d760 1
a760 1
  //     __gen_vtable_impl<true, _Multi_array<void(*)(V1&&, V2&&)>,
d762 1
a762 1
  //   __gen_vtable_impl<true, _Multi_array<void(*)(V1&&, V2&&), 3>,
d764 1
a764 1
  //     __gen_vtable_impl<true, _Multi_array<void(*)(V1&&, V2&&)>,
d766 1
a766 1
  //     __gen_vtable_impl<true, _Multi_array<void(*)(V1&&, V2&&)>,
d768 1
a768 1
  //     __gen_vtable_impl<true, _Multi_array<void(*)(V1&&, V2&&)>,
d772 1
a772 2
  template<bool __same_return_types,
	   typename _Array_type, typename _Variant_tuple, typename _Index_seq>
d775 1
a775 9
  // Defines the _S_apply() member that returns a _Multi_array populated
  // with function pointers that perform the visitation expressions e(m)
  // for each valid pack of indexes into the variant types _Variants.
  //
  // This partial specialization builds up the index sequences by recursively
  // calling _S_apply() on the next specialization of __gen_vtable_impl.
  // The base case of the recursion defines the actual function pointers.
  template<bool __same_return_types,
	   typename _Result_type, typename _Visitor, size_t... __dimensions,
a777 1
        __same_return_types,
d802 2
a803 7
	  if constexpr (_Extra_visit_slot_needed<_Result_type, _Next>::value)
	    (_S_apply_single_alt<true, __var_indices>(
	      __vtable._M_arr[__var_indices + 1],
	      &(__vtable._M_arr[0])), ...);
	  else
	    (_S_apply_single_alt<false, __var_indices>(
	      __vtable._M_arr[__var_indices]), ...);
d806 1
a806 1
      template<bool __do_cookie, size_t __index, typename _Tp>
d808 1
a808 1
	_S_apply_single_alt(_Tp& __element, _Tp* __cookie_element = nullptr)
d811 3
a813 20
	  if constexpr (__do_cookie)
	    {
	      __element = __gen_vtable_impl<
		__same_return_types,
		_Tp,
		tuple<_Variants...>,
		std::index_sequence<__indices..., __index>>::_S_apply();
	      *__cookie_element = __gen_vtable_impl<
		__same_return_types,
		_Tp,
		tuple<_Variants...>,
		std::index_sequence<__indices..., variant_npos>>::_S_apply();
	    }
	  else
	    {
	      __element = __gen_vtable_impl<
		__same_return_types,
		remove_reference_t<decltype(__element)>, tuple<_Variants...>,
		std::index_sequence<__indices..., __index>>::_S_apply();
	    }
d817 1
a817 5
  // This partial specialization is the base case for the recursion.
  // It populates a _Multi_array element with the address of a function
  // that invokes the visitor with the alternatives specified by __indices.
  template<bool __same_return_types,
	   typename _Result_type, typename _Visitor, typename... _Variants,
a819 1
      __same_return_types,
d824 1
a824 47
	  _Multi_array<_Result_type (*)(_Visitor, _Variants...)>;

      template<size_t __index, typename _Variant>
	static constexpr decltype(auto)
	__element_by_index_or_cookie(_Variant&& __var) noexcept
        {
	  if constexpr (__index != variant_npos)
	    return __variant::__get<__index>(std::forward<_Variant>(__var));
	  else
	    return __variant_cookie{};
	}

      static constexpr decltype(auto)
      __visit_invoke_impl(_Visitor&& __visitor, _Variants... __vars)
      {
	// For raw visitation using indices, pass the indices to the visitor:
	if constexpr (is_same_v<_Result_type, __variant_idx_cookie>)
	  return std::__invoke(std::forward<_Visitor>(__visitor),
	      __element_by_index_or_cookie<__indices>(
		std::forward<_Variants>(__vars))...,
	      integral_constant<size_t, __indices>()...);
	// For std::visit<cv void>, cast the result to void:
	else if constexpr (!__same_return_types &&
			   std::is_void_v<_Result_type>)
	  return (void)std::__invoke(std::forward<_Visitor>(__visitor),
	      __element_by_index_or_cookie<__indices>(
		std::forward<_Variants>(__vars))...);
	else
	  return std::__invoke(std::forward<_Visitor>(__visitor),
	      __element_by_index_or_cookie<__indices>(
		std::forward<_Variants>(__vars))...);
      }

      static constexpr decltype(auto)
      __do_visit_invoke(_Visitor&& __visitor, _Variants... __vars)
      {
	return __visit_invoke_impl(std::forward<_Visitor>(__visitor),
				   std::forward<_Variants>(__vars)...);
      }

      // Perform the implicit conversion to _Result_type for std::visit<R>.
      static constexpr _Result_type
      __do_visit_invoke_r(_Visitor&& __visitor, _Variants... __vars)
      {
	return __visit_invoke_impl(std::forward<_Visitor>(__visitor),
				   std::forward<_Variants>(__vars)...);
      }
d829 2
a830 6
	if constexpr (__same_return_types)
	  return __do_visit_invoke(std::forward<_Visitor>(__visitor),
				   std::forward<_Variants>(__vars)...);
	else
	  return __do_visit_invoke_r(std::forward<_Visitor>(__visitor),
				     std::forward<_Variants>(__vars)...);
d838 1
a838 2
  template<bool __same_return_types,
	   typename _Result_type, typename _Visitor, typename... _Variants>
d841 1
d843 1
a843 1
	  _Multi_array<_Result_type (*)(_Visitor, _Variants...),
d846 8
a853 4
      static constexpr _Array_type _S_vtable
	= __gen_vtable_impl<__same_return_types,
			    _Array_type, tuple<_Variants...>,
			    std::index_sequence<>>::_S_apply();
a869 10
  template<size_t _Np, typename _Variant, typename... _Args>
    void __variant_construct_by_index(_Variant& __v, _Args&&... __args)
    {
      __v._M_index = _Np;
      auto&& __storage = __detail::__variant::__get<_Np>(__v);
      ::new ((void*)std::addressof(__storage))
        remove_reference_t<decltype(__storage)>
	  (std::forward<_Args>(__args)...);
    }

d926 1
a926 1
	return std::addressof(__detail::__variant::__get<_Np>(*__ptr));
d940 1
a940 1
	return std::addressof(__detail::__variant::__get<_Np>(*__ptr));
d957 2
a958 1
    get_if(const variant<_Types...>* __ptr) noexcept
d974 1
a974 21
      bool __ret = true; \
      __do_visit<__detail::__variant::__visit_with_index>( \
        [&__ret, &__lhs] \
		 (auto&& __rhs_mem, auto __rhs_index) mutable \
		   -> __detail::__variant::__variant_idx_cookie \
        { \
	  if constexpr (__rhs_index != variant_npos) \
	    { \
	      if (__lhs.index() == __rhs_index) \
	        { \
		  auto& __this_mem = std::get<__rhs_index>(__lhs);	\
                  __ret = __this_mem __OP __rhs_mem; \
                } \
	      else \
		__ret = (__lhs.index() + 1) __OP (__rhs_index + 1); \
            } \
          else \
            __ret = (__lhs.index() + 1) __OP (__rhs_index + 1); \
	  return {}; \
	}, __rhs); \
      return __ret; \
a1036 6
      template <typename... _UTypes, typename _Tp>
	friend decltype(auto) __variant_cast(_Tp&&);
      template<size_t _Np, typename _Variant, typename... _Args>
	friend void __variant_construct_by_index(_Variant& __v,
						 _Args&&... __args);

a1050 4
	static constexpr bool __not_self
	  = !is_same_v<__remove_cvref_t<_Tp>, variant>;

      template<typename _Tp>
d1058 2
a1059 2
      template<size_t _Np, typename = enable_if_t<(_Np < sizeof...(_Types))>>
	using __to_type = variant_alternative_t<_Np, variant>;
d1061 8
a1068 1
      template<typename _Tp, typename = enable_if_t<__not_self<_Tp>>>
d1086 1
a1086 1
	  = !__is_in_place_tag<__remove_cvref_t<_Tp>>::value;
d1097 2
a1098 1
	       typename = enable_if_t<sizeof...(_Types) != 0>,
d1100 2
a1101 3
	       typename _Tj = __accepted_type<_Tp&&>,
	       typename = enable_if_t<__exactly_once<_Tj>
				      && is_constructible_v<_Tj, _Tp>>>
d1104 1
a1104 1
	noexcept(is_nothrow_constructible_v<_Tj, _Tp>)
d1107 1
a1107 1
	{ }
d1111 1
a1111 1
				      && is_constructible_v<_Tp, _Args...>>>
d1116 1
a1116 1
	{ }
d1120 2
a1121 2
				      && is_constructible_v<_Tp,
					   initializer_list<_Up>&, _Args...>>>
d1127 1
a1127 1
	{ }
d1130 2
a1131 2
	       typename _Tp = __to_type<_Np>,
	       typename = enable_if_t<is_constructible_v<_Tp, _Args...>>>
d1136 1
a1136 1
	{ }
d1139 2
a1140 4
	       typename _Tp = __to_type<_Np>,
	       typename = enable_if_t<is_constructible_v<_Tp,
							 initializer_list<_Up>&,
							 _Args...>>>
d1146 1
a1146 1
	{ }
d1150 3
a1152 3
		    && is_constructible_v<__accepted_type<_Tp&&>, _Tp>
		    && is_assignable_v<__accepted_type<_Tp&&>&, _Tp>,
		    variant&>
d1154 2
a1155 2
	noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp>
		 && is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp>)
d1161 2
a1162 8
	    {
	      using _Tj = __accepted_type<_Tp&&>;
	      if constexpr (is_nothrow_constructible_v<_Tj, _Tp>
			    || !is_nothrow_move_constructible_v<_Tj>)
		this->emplace<__index>(std::forward<_Tp>(__rhs));
	      else
		operator=(variant(std::forward<_Tp>(__rhs)));
	    }
d1171 4
a1174 2
	  constexpr size_t __index = __index_of<_Tp>;
	  return this->emplace<__index>(std::forward<_Args>(__args)...);
d1183 5
a1187 2
	  constexpr size_t __index = __index_of<_Tp>;
	  return this->emplace<__index>(__il, std::forward<_Args>(__args)...);
d1198 2
a1199 4
	  using type = variant_alternative_t<_Np, variant>;
	  // Provide the strong exception-safety guarantee when possible,
	  // to avoid becoming valueless.
	  if constexpr (is_nothrow_constructible_v<type, _Args...>)
d1201 2
a1202 3
	      this->_M_reset();
	      __variant_construct_by_index<_Np>(*this,
		  std::forward<_Args>(__args)...);
d1204 1
a1204 1
	  else if constexpr (is_scalar_v<type>)
d1206 2
a1207 30
	      // This might invoke a potentially-throwing conversion operator:
	      const type __tmp(std::forward<_Args>(__args)...);
	      // But these steps won't throw:
	      this->_M_reset();
	      __variant_construct_by_index<_Np>(*this, __tmp);
	    }
	  else if constexpr (__detail::__variant::_Never_valueless_alt<type>()
	      && _Traits::_S_move_assign)
	    {
	      // This construction might throw:
	      variant __tmp(in_place_index<_Np>,
			    std::forward<_Args>(__args)...);
	      // But _Never_valueless_alt<type> means this won't:
	      *this = std::move(__tmp);
	    }
	  else
	    {
	      // This case only provides the basic exception-safety guarantee,
	      // i.e. the variant can become valueless.
	      this->_M_reset();
	      __try
		{
		  __variant_construct_by_index<_Np>(*this,
		    std::forward<_Args>(__args)...);
		}
	      __catch (...)
		{
		  this->_M_index = variant_npos;
		  __throw_exception_again;
		}
d1209 1
d1221 2
a1222 6
	  using type = variant_alternative_t<_Np, variant>;
	  // Provide the strong exception-safety guarantee when possible,
	  // to avoid becoming valueless.
	  if constexpr (is_nothrow_constructible_v<type,
						   initializer_list<_Up>&,
						   _Args...>)
d1224 2
a1225 3
	      this->_M_reset();
	      __variant_construct_by_index<_Np>(*this, __il,
		  std::forward<_Args>(__args)...);
d1227 1
a1227 2
	  else if constexpr (__detail::__variant::_Never_valueless_alt<type>()
	      && _Traits::_S_move_assign)
d1229 2
a1230 21
	      // This construction might throw:
	      variant __tmp(in_place_index<_Np>, __il,
			    std::forward<_Args>(__args)...);
	      // But _Never_valueless_alt<type> means this won't:
	      *this = std::move(__tmp);
	    }
	  else
	    {
	      // This case only provides the basic exception-safety guarantee,
	      // i.e. the variant can become valueless.
	      this->_M_reset();
	      __try
		{
		  __variant_construct_by_index<_Np>(*this, __il,
		    std::forward<_Args>(__args)...);
		}
	      __catch (...)
		{
		  this->_M_index = variant_npos;
		  __throw_exception_again;
		}
d1232 1
d1252 1
a1252 4
	__do_visit<__detail::__variant::__visit_with_index>(
	  [this, &__rhs](auto&& __rhs_mem,
			 auto __rhs_index) mutable
	    -> __detail::__variant::__variant_idx_cookie
d1254 1
a1254 1
	    if constexpr (__rhs_index != variant_npos)
d1256 4
a1259 23
		if (this->index() == __rhs_index)
		  {
		    auto& __this_mem =
		      std::get<__rhs_index>(*this);
		    using std::swap;
		    swap(__this_mem, __rhs_mem);
		  }
		else
		  {
		    if (this->index() != variant_npos)
		      {
			auto __tmp(std::move(__rhs_mem));
			__rhs = std::move(*this);
			this->_M_destructive_move(__rhs_index,
						  std::move(__tmp));
		      }
		    else
		      {
			this->_M_destructive_move(__rhs_index,
						  std::move(__rhs_mem));
			__rhs._M_reset();
		      }
		  }
d1261 17
a1277 10
	    else
	      {
		if (this->index() != variant_npos)
		  {
		    __rhs = std::move(*this);
		    this->_M_reset();
		  }
	      }
	    return {};
	  }, __rhs);
d1281 25
d1307 3
a1309 1
#if defined(__clang__) && __clang_major__ <= 7
d1316 1
a1316 2
	friend constexpr decltype(auto)
	__detail::__variant::__get(_Vp&& __v) noexcept;
d1381 1
a1381 3
  template<bool __use_index,
	   bool __same_return_types,
	   typename _Visitor, typename... _Variants>
d1383 1
a1383 1
    __do_visit(_Visitor&& __visitor, _Variants&&... __variants)
d1385 2
a1386 2
      using _Deduced_type = std::invoke_result<_Visitor,
	decltype(std::get<0>(std::declval<_Variants>()))...>;
d1388 3
a1390 3
      using _Result_type = typename std::conditional_t<__use_index,
	__detail::__variant::__variant_idx_cookie,
	_Deduced_type>::type;
a1392 1
	__same_return_types,
a1399 28
  template<typename _Visitor, typename... _Variants>
    constexpr decltype(auto)
    visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      if ((__variants.valueless_by_exception() || ...))
	__throw_bad_variant_access("Unexpected index");

      return __do_visit(std::forward<_Visitor>(__visitor),
			std::forward<_Variants>(__variants)...);
    }

#if __cplusplus > 201703L
  template<typename _Res, typename _Visitor, typename... _Variants>
    constexpr _Res
    visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      if ((__variants.valueless_by_exception() || ...))
	__throw_bad_variant_access("Unexpected index");

      if constexpr (std::is_void_v<_Res>)
        (void) __do_visit<false, false>(std::forward<_Visitor>(__visitor),
					std::forward<_Variants>(__variants)...);
      else
	return __do_visit<false, false>(std::forward<_Visitor>(__visitor),
					std::forward<_Variants>(__variants)...);
    }
#endif

d1407 1
a1407 3
	size_t __ret;
	__do_visit([&__t, &__ret](auto&& __t_mem) mutable
		   -> __detail::__variant::__variant_cookie
d1409 7
a1415 10
	    using _Type = __remove_cvref_t<decltype(__t_mem)>;
	    if constexpr (!is_same_v<_Type,
			             __detail::__variant::__variant_cookie>)
	      __ret = std::hash<size_t>{}(__t.index())
		      + std::hash<_Type>{}(__t_mem);
	    else
	      __ret = std::hash<size_t>{}(__t.index());
	    return {};
	  }, __t);
	return __ret;
@


1.1.1.7
log
@initial import of GCC 10.3.0.  main changes include:

caveats:
- ABI issue between c++14 and c++17 fixed
- profile mode is removed from libstdc++
- -fno-common is now the default

new features:
- new flags -fallocation-dce, -fprofile-partial-training,
  -fprofile-reproducible, -fprofile-prefix-path, and -fanalyzer
- many new compile and link time optimisations
- enhanced drive optimisations
- openacc 2.6 support
- openmp 5.0 features
- new warnings: -Wstring-compare and -Wzero-length-bounds
- extended warnings: -Warray-bounds, -Wformat-overflow,
  -Wrestrict, -Wreturn-local-addr, -Wstringop-overflow,
  -Warith-conversion, -Wmismatched-tags, and -Wredundant-tags
- some likely C2X features implemented
- more C++20 implemented
- many new arm & intel CPUs known

hundreds of reported bugs are fixed.  full list of changes
can be found at:

   https://gcc.gnu.org/gcc-10/changes.html
@
text
@d3 1
a3 1
// Copyright (C) 2016-2020 Free Software Foundation, Inc.
a47 3
#if __cplusplus > 201703L
# include <compare>
#endif
d141 3
a143 1
  template<typename _Result_type, typename _Visitor, typename... _Variants>
d166 1
a166 1
  // Returns the first appearence of _Tp in _Types.
d183 2
a184 2
  // Used to enable deduction (and same-type checking) for std::visit:
  template<typename> struct __deduce_visit_result { };
d186 9
a194 21
  // Visit variants that might be valueless.
  template<typename _Visitor, typename... _Variants>
    constexpr void
    __raw_visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      std::__do_visit<__variant_cookie>(std::forward<_Visitor>(__visitor),
				        std::forward<_Variants>(__variants)...);
    }

  // Visit variants that might be valueless, passing indices to the visitor.
  template<typename _Visitor, typename... _Variants>
    constexpr void
    __raw_idx_visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      std::__do_visit<__variant_idx_cookie>(std::forward<_Visitor>(__visitor),
	  std::forward<_Variants>(__variants)...);
    }

  // _Uninitialized<T> is guaranteed to be a trivially destructible type,
  // even if T is not.
  template<typename _Type, bool = std::is_trivially_destructible_v<_Type>>
d375 1
a375 4
      constexpr
      _Variant_storage()
      : _M_index(static_cast<__index_type>(variant_npos))
      { }
d378 1
a378 2
	constexpr
	_Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
d380 1
a380 1
	_M_index{_Np}
d383 1
a383 1
      void _M_reset()
d385 2
a386 4
	if (!_M_valid()) [[unlikely]]
	  return;

	std::__do_visit<void>([](auto&& __this_mem) mutable
d388 4
a391 1
	    std::_Destroy(std::__addressof(__this_mem));
d393 1
d395 4
a398 1
	_M_index = static_cast<__index_type>(variant_npos);
d405 1
a405 1
      _M_storage() const noexcept
d414 1
a414 1
	if constexpr (__variant::__never_valueless<_Types...>())
d427 1
a427 4
      constexpr
      _Variant_storage()
      : _M_index(static_cast<__index_type>(variant_npos))
      { }
d430 1
a430 2
	constexpr
	_Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
d432 1
a432 1
	_M_index{_Np}
d435 2
a436 2
      void _M_reset() noexcept
      { _M_index = static_cast<__index_type>(variant_npos); }
d439 1
a439 1
      _M_storage() const noexcept
d448 1
a448 1
	if constexpr (__variant::__never_valueless<_Types...>())
d450 1
a450 1
	return this->_M_index != static_cast<__index_type>(variant_npos);
d476 2
a477 1
      __variant::__raw_visit([&__lhs](auto&& __rhs_mem) mutable
d481 1
d586 3
a588 2
	__variant::__raw_idx_visit(
	  [this](auto&& __rhs_mem, auto __rhs_index) mutable
d609 1
a609 2
			= variant<_Types...>(std::in_place_index<__rhs_index>,
					     __rhs_mem);
d614 1
d645 3
a647 2
	__variant::__raw_idx_visit(
	  [this](auto&& __rhs_mem, auto __rhs_index) mutable
d659 1
d725 5
a729 2
  // Helper used to check for valid conversions that don't involve narrowing.
  template<typename _Ti> struct _Arr { _Ti _M_x[1]; };
d731 2
a732 15
  // Build an imaginary function FUN(Ti) for each alternative type Ti
  template<size_t _Ind, typename _Tp, typename _Ti,
	   bool _Ti_is_cv_bool = is_same_v<remove_cv_t<_Ti>, bool>,
	   typename = void>
    struct _Build_FUN
    {
      // This function means 'using _Build_FUN<I, T, Ti>::_S_fun;' is valid,
      // but only static functions will be considered in the call below.
      void _S_fun();
    };

  // ... for which Ti x[] = {std::forward<T>(t)}; is well-formed,
  template<size_t _Ind, typename _Tp, typename _Ti>
    struct _Build_FUN<_Ind, _Tp, _Ti, false,
		      void_t<decltype(_Arr<_Ti>{{std::declval<_Tp>()}})>>
d734 2
a735 2
      // This is the FUN function for type _Ti, with index _Ind
      static integral_constant<size_t, _Ind> _S_fun(_Ti);
d738 2
a739 16
  // ... and if Ti is cv bool, remove_cvref_t<T> is bool.
  template<size_t _Ind, typename _Tp, typename _Ti>
    struct _Build_FUN<_Ind, _Tp, _Ti, true,
		      enable_if_t<is_same_v<__remove_cvref_t<_Tp>, bool>>>
    {
      // This is the FUN function for when _Ti is cv bool, with index _Ind
      static integral_constant<size_t, _Ind> _S_fun(_Ti);
    };

  template<typename _Tp, typename _Variant,
	   typename = make_index_sequence<variant_size_v<_Variant>>>
    struct _Build_FUNs;

  template<typename _Tp, typename... _Ti, size_t... _Ind>
    struct _Build_FUNs<_Tp, variant<_Ti...>, index_sequence<_Ind...>>
    : _Build_FUN<_Ind, _Tp, _Ti>...
d741 1
a741 1
      using _Build_FUN<_Ind, _Tp, _Ti>::_S_fun...;
d744 3
a746 7
  // The index j of the overload FUN(Tj) selected by overload resolution
  // for FUN(std::forward<_Tp>(t))
  template<typename _Tp, typename _Variant>
    using _FUN_type
      = decltype(_Build_FUNs<_Tp, _Variant>::_S_fun(std::declval<_Tp>()));

  // The index selected for FUN(std::forward<T>(t)), or variant_npos if none.
d749 1
a749 2
    : integral_constant<size_t, variant_npos>
    { };
d751 9
a759 4
  template<typename _Tp, typename _Variant>
    struct __accepted_index<_Tp, _Variant, void_t<_FUN_type<_Tp, _Variant>>>
    : _FUN_type<_Tp, _Variant>
    { };
d763 1
a763 1
    void* __get_storage(_Variant&& __v) noexcept
d773 1
a773 1
	: bool_constant<__variant::__never_valueless<_Types...>()> {};
d789 1
a789 28
      template<typename>
	struct __untag_result
	: false_type
	{ using element_type = _Tp; };

      template <typename... _Args>
	struct __untag_result<const void(*)(_Args...)>
	: false_type
	{ using element_type = void(*)(_Args...); };

      template <typename... _Args>
	struct __untag_result<__variant_cookie(*)(_Args...)>
	: false_type
	{ using element_type = void(*)(_Args...); };

      template <typename... _Args>
	struct __untag_result<__variant_idx_cookie(*)(_Args...)>
	: false_type
	{ using element_type = void(*)(_Args...); };

      template <typename _Res, typename... _Args>
	struct __untag_result<__deduce_visit_result<_Res>(*)(_Args...)>
	: true_type
	{ using element_type = _Res(*)(_Args...); };

      using __result_is_deduced = __untag_result<_Tp>;

      constexpr const typename __untag_result<_Tp>::element_type&
d793 1
a793 1
      typename __untag_result<_Tp>::element_type _M_data;
d814 1
a814 1
	constexpr decltype(auto)
d826 4
d835 1
a835 1
  // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 2, 3>,
d837 1
a837 1
  //   __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 3>,
d839 1
a839 1
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
d841 1
a841 1
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
d843 1
a843 1
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
d845 1
a845 1
  //   __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 3>,
d847 1
a847 1
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
d849 1
a849 1
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
d851 1
a851 1
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
d855 2
a856 1
  template<typename _Array_type, typename _Index_seq>
d866 2
a867 1
  template<typename _Result_type, typename _Visitor, size_t... __dimensions,
d870 1
d872 1
a872 1
	std::index_sequence<__indices...>>
d908 1
d912 1
d914 1
d917 1
d919 1
d925 2
a926 1
		remove_reference_t<decltype(__element)>,
d935 2
a936 1
  template<typename _Result_type, typename _Visitor, typename... _Variants,
d939 1
d941 1
a941 1
		   std::index_sequence<__indices...>>
d957 1
a957 1
      __visit_invoke(_Visitor&& __visitor, _Variants... __vars)
d959 1
d961 1
a961 3
	  // For raw visitation using indices, pass the indices to the visitor
	  // and discard the return value:
	  std::__invoke(std::forward<_Visitor>(__visitor),
d965 4
a968 3
	else if constexpr (is_same_v<_Result_type, __variant_cookie>)
	  // For raw visitation without indices, and discard the return value:
	  std::__invoke(std::forward<_Visitor>(__visitor),
d971 1
a971 2
	else if constexpr (_Array_type::__result_is_deduced::value)
	  // For the usual std::visit case deduce the return value:
d975 26
a1000 4
	else // for std::visit<R> use INVOKE<R>
	  return std::__invoke_r<_Result_type>(
	      std::forward<_Visitor>(__visitor),
	      __variant::__get<__indices>(std::forward<_Variants>(__vars))...);
d1008 2
a1009 1
  template<typename _Result_type, typename _Visitor, typename... _Variants>
d1017 3
a1019 1
	= __gen_vtable_impl<_Array_type, std::index_sequence<>>::_S_apply();
d1051 1
a1051 1
		    "T must occur exactly once in alternatives");
d1059 2
a1060 2
		    "T must occur exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
d1068 2
a1069 2
		    "T must occur exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
d1078 2
a1079 2
		    "T must occur exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
d1087 2
a1088 2
		    "T must occur exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
d1099 2
a1100 2
		    "The index must be in [0, number of alternatives)");
      static_assert(!is_void_v<_Alternative_type>, "_Tp must not be void");
d1113 2
a1114 2
		    "The index must be in [0, number of alternatives)");
      static_assert(!is_void_v<_Alternative_type>, "_Tp must not be void");
d1125 2
a1126 2
		    "T must occur exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
d1136 2
a1137 2
		    "T must occur exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
d1150 4
a1153 2
      __detail::__variant::__raw_idx_visit( \
        [&__ret, &__lhs] (auto&& __rhs_mem, auto __rhs_index) mutable \
d1167 1
d1170 4
a1173 1
    }
a1183 39
  constexpr bool operator==(monostate, monostate) noexcept { return true; }

#ifdef __cpp_lib_three_way_comparison
  template<typename... _Types>
    requires (three_way_comparable<_Types> && ...)
    constexpr
    common_comparison_category_t<compare_three_way_result_t<_Types>...>
    operator<=>(const variant<_Types...>& __v, const variant<_Types...>& __w)
    {
      common_comparison_category_t<compare_three_way_result_t<_Types>...> __ret
	= strong_ordering::equal;

      __detail::__variant::__raw_idx_visit(
	[&__ret, &__v] (auto&& __w_mem, auto __w_index) mutable
	{
	  if constexpr (__w_index != variant_npos)
	    {
	      if (__v.index() == __w_index)
		{
		  auto& __this_mem = std::get<__w_index>(__v);
		  __ret = __this_mem <=> __w_mem;
		  return;
		}
	    }
	  __ret = (__v.index() + 1) <=> (__w_index + 1);
	}, __w);
      return __ret;
    }

  constexpr strong_ordering
  operator<=>(monostate, monostate) noexcept { return strong_ordering::equal; }
#else
  constexpr bool operator!=(monostate, monostate) noexcept { return false; }
  constexpr bool operator<(monostate, monostate) noexcept { return false; }
  constexpr bool operator>(monostate, monostate) noexcept { return false; }
  constexpr bool operator<=(monostate, monostate) noexcept { return true; }
  constexpr bool operator>=(monostate, monostate) noexcept { return true; }
#endif

d1202 1
a1202 2
    bad_variant_access() noexcept { }

d1207 1
a1207 1
    bad_variant_access(const char* __reason) noexcept : _M_reason(__reason) { }
d1209 1
a1209 2
    // Must point to a string with static storage duration:
    const char* _M_reason = "bad variant access";
a1213 1
  // Must only be called with a string literal
a1217 9
  inline void
  __throw_bad_variant_access(bool __valueless)
  {
    if (__valueless) [[__unlikely__]]
      __throw_bad_variant_access("std::get: variant is valueless");
    else
      __throw_bad_variant_access("std::get: wrong index for variant");
  }

d1260 2
a1261 2
	static constexpr size_t __accepted_index
	  = __detail::__variant::__accepted_index<_Tp, variant>::value;
d1303 1
a1303 1
	: variant(in_place_index<__accepted_index<_Tp>>,
d1357 1
a1357 1
	  constexpr auto __index = __accepted_index<_Tp>;
d1398 1
a1398 1
			"The index must be in [0, number of alternatives)");
d1451 1
a1451 1
			"The index must be in [0, number of alternatives)");
d1496 4
a1499 7
	using __index_type = typename _Base::__index_type;
	if constexpr (__detail::__variant::__never_valueless<_Types...>())
	  return this->_M_index;
	else if constexpr (sizeof...(_Types) <= __index_type(-1) / 2)
	  return make_signed_t<__index_type>(this->_M_index);
	else
	  return size_t(__index_type(this->_M_index + 1)) - 1;
d1507 4
a1510 2
	__detail::__variant::__raw_idx_visit(
	  [this, &__rhs](auto&& __rhs_mem, auto __rhs_index) mutable
d1523 1
a1523 1
		    if (!this->valueless_by_exception()) [[__likely__]]
d1540 1
a1540 1
		if (!this->valueless_by_exception()) [[__likely__]]
d1546 1
d1563 1
a1563 2
	friend void*
	__detail::__variant::__get_storage(_Vp&& __v) noexcept;
d1586 1
a1586 1
		    "The index must be in [0, number of alternatives)");
d1588 1
a1588 1
	__throw_bad_variant_access(__v.valueless_by_exception());
d1597 1
a1597 1
		    "The index must be in [0, number of alternatives)");
d1599 1
a1599 1
	__throw_bad_variant_access(__v.valueless_by_exception());
d1608 1
a1608 1
		    "The index must be in [0, number of alternatives)");
d1610 1
a1610 1
	__throw_bad_variant_access(__v.valueless_by_exception());
d1619 1
a1619 1
		    "The index must be in [0, number of alternatives)");
d1621 1
a1621 1
	__throw_bad_variant_access(__v.valueless_by_exception());
d1625 3
a1627 1
  template<typename _Result_type, typename _Visitor, typename... _Variants>
d1631 7
d1639 1
d1652 1
a1652 4
	__throw_bad_variant_access("std::visit: variant is valueless");

      using _Result_type = std::invoke_result_t<_Visitor,
	decltype(std::get<0>(std::declval<_Variants>()))...>;
d1654 2
a1655 4
      using _Tag = __detail::__variant::__deduce_visit_result<_Result_type>;

      return std::__do_visit<_Tag>(std::forward<_Visitor>(__visitor),
				   std::forward<_Variants>(__variants)...);
d1664 1
a1664 1
	__throw_bad_variant_access("std::visit<R>: variant is valueless");
d1666 6
a1671 2
      return std::__do_visit<_Res>(std::forward<_Visitor>(__visitor),
				   std::forward<_Variants>(__variants)...);
d1683 2
a1684 2
	__detail::__variant::__raw_visit(
	  [&__t, &__ret](auto&& __t_mem) mutable
d1693 1
d1724 1
a1724 1
      operator()(const monostate&) const noexcept
@


1.1.1.8
log
@initial import of GCC 10.4.0 sources.

mostly a large list of PRs fixed (210 total), plus one x86-64
specific change related to MMX and 64 bit integer return.

https://gcc.gnu.org/gcc-10/changes.html links to the full list
of PRs fixed.
@
text
@d26 1
a26 1
 *  This is the `<variant>` C++ Library header.
a1055 8
  template<size_t _Np, typename _Variant>
    using __get_t = decltype(std::get<_Np>(std::declval<_Variant>()));

  // Return type of std::visit.
  template<typename _Visitor, typename... _Variants>
    using __visit_result_t
      = invoke_result_t<_Visitor, __get_t<0, _Variants>...>;

d1241 1
a1241 2
    constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...>
    visit(_Visitor&&, _Variants&&...);
d1707 1
a1707 1
    constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...>
d1713 2
a1714 2
      using _Result_type
	= __detail::__variant::__visit_result_t<_Visitor, _Variants...>;
@


1.1.1.9
log
@initial import of GCC 12.3.0.

major changes in GCC 11 included:

- The default mode for C++ is now -std=gnu++17 instead of -std=gnu++14.
- When building GCC itself, the host compiler must now support C++11,
  rather than C++98.
- Some short options of the gcov tool have been renamed: -i to -j and
  -j to -H.
- ThreadSanitizer improvements.
- Introduce Hardware-assisted AddressSanitizer support.
- For targets that produce DWARF debugging information GCC now defaults
  to DWARF version 5. This can produce up to 25% more compact debug
  information compared to earlier versions.
- Many optimisations.
- The existing malloc attribute has been extended so that it can be
  used to identify allocator/deallocator API pairs. A pair of new
  -Wmismatched-dealloc and -Wmismatched-new-delete warnings are added.
- Other new warnings:
  -Wsizeof-array-div, enabled by -Wall, warns about divisions of two
    sizeof operators when the first one is applied to an array and the
    divisor does not equal the size of the array element.
  -Wstringop-overread, enabled by default, warns about calls to string
    functions reading past the end of the arrays passed to them as
    arguments.
  -Wtsan, enabled by default, warns about unsupported features in
    ThreadSanitizer (currently std::atomic_thread_fence).
- Enchanced warnings:
  -Wfree-nonheap-object detects many more instances of calls to
    deallocation functions with pointers not returned from a dynamic
    memory allocation function.
  -Wmaybe-uninitialized diagnoses passing pointers or references to
    uninitialized memory to functions taking const-qualified arguments.
  -Wuninitialized detects reads from uninitialized dynamically
    allocated memory.
  -Warray-parameter warns about functions with inconsistent array forms.
  -Wvla-parameter warns about functions with inconsistent VLA forms.
- Several new features from the upcoming C2X revision of the ISO C
  standard are supported with -std=c2x and -std=gnu2x.
- Several C++20 features have been implemented.
- The C++ front end has experimental support for some of the upcoming
  C++23 draft.
- Several new C++ warnings.
- Enhanced Arm, AArch64, x86, and RISC-V CPU support.
- The implementation of how program state is tracked within
  -fanalyzer has been completely rewritten with many enhancements.

see https://gcc.gnu.org/gcc-11/changes.html for a full list.

major changes in GCC 12 include:

- An ABI incompatibility between C and C++ when passing or returning
  by value certain aggregates containing zero width bit-fields has
  been discovered on various targets. x86-64, ARM and AArch64
  will always ignore them (so there is a C ABI incompatibility
  between GCC 11 and earlier with GCC 12 or later), PowerPC64 ELFv2
  always take them into account (so there is a C++ ABI
  incompatibility, GCC 4.4 and earlier compatible with GCC 12 or
  later, incompatible with GCC 4.5 through GCC 11). RISC-V has
  changed the handling of these already starting with GCC 10. As
  the ABI requires, MIPS takes them into account handling function
  return values so there is a C++ ABI incompatibility with GCC 4.5
  through 11.
- STABS: Support for emitting the STABS debugging format is
  deprecated and will be removed in the next release. All ports now
  default to emit DWARF (version 2 or later) debugging info or are
  obsoleted.
- Vectorization is enabled at -O2 which is now equivalent to the
  original -O2 -ftree-vectorize -fvect-cost-model=very-cheap.
- GCC now supports the ShadowCallStack sanitizer.
- Support for __builtin_shufflevector compatible with the clang
  language extension was added.
- Support for attribute unavailable was added.
- Support for __builtin_dynamic_object_size compatible with the
  clang language extension was added.
- New warnings:
  -Wbidi-chars warns about potentially misleading UTF-8
    bidirectional control characters.
  -Warray-compare warns about comparisons between two operands of
    array type.
- Some new features from the upcoming C2X revision of the ISO C
  standard are supported with -std=c2x and -std=gnu2x.
- Several C++23 features have been implemented.
- Many C++ enhancements across warnings and -f options.

see https://gcc.gnu.org/gcc-12/changes.html for a full list.
@
text
@d3 1
a3 1
// Copyright (C) 2016-2022 Free Software Foundation, Inc.
a35 1
#include <initializer_list>
d37 1
d39 2
a40 1
#include <bits/exception_defines.h>
d43 1
d48 1
a48 2
#include <bits/utility.h> // in_place_index_t
#if __cplusplus >= 202002L
a51 8
#if __cpp_concepts >= 202002L && __cpp_constexpr >= 201811L
// P2231R1 constexpr needs constexpr unions and constrained destructors.
# define __cpp_lib_variant 202106L
#else
# include <ext/aligned_buffer.h> // Use __aligned_membuf instead of union.
# define __cpp_lib_variant 202102L
#endif

d56 20
a98 8
  template<typename... _Types>
    inline constexpr size_t
    variant_size_v<variant<_Types...>> = sizeof...(_Types);

  template<typename... _Types>
    inline constexpr size_t
    variant_size_v<const variant<_Types...>> = sizeof...(_Types);

d102 3
a104 4
  template<size_t _Np, typename... _Types>
    struct variant_alternative<_Np, variant<_Types...>>
    {
      static_assert(_Np < sizeof...(_Types));
d106 3
a108 2
      using type = typename _Nth_type<_Np, _Types...>::type;
    };
a148 1
    _GLIBCXX20_CONSTEXPR
d167 13
d185 1
a185 1
  template<typename _Tp> struct __deduce_visit_result { using type = _Tp; };
a204 23
  // The __as function templates implement the exposition-only "as-variant"

  template<typename... _Types>
    constexpr std::variant<_Types...>&
    __as(std::variant<_Types...>& __v) noexcept
    { return __v; }

  template<typename... _Types>
    constexpr const std::variant<_Types...>&
    __as(const std::variant<_Types...>& __v) noexcept
    { return __v; }

  template<typename... _Types>
    constexpr std::variant<_Types...>&&
    __as(std::variant<_Types...>&& __v) noexcept
    { return std::move(__v); }

  template<typename... _Types>
    constexpr const std::variant<_Types...>&&
    __as(const std::variant<_Types...>&& __v) noexcept
    { return std::move(__v); }

  // For C++17:
a206 3
  // For C++20:
  // _Uninitialized<T> is trivially destructible iff T is, so _Variant_union
  // needs a constrained non-trivial destructor.
a236 33
#if __cpp_lib_variant >= 202106L
      template<typename... _Args>
	constexpr
	_Uninitialized(in_place_index_t<0>, _Args&&... __args)
	: _M_storage(std::forward<_Args>(__args)...)
	{ }

      constexpr ~_Uninitialized() { }

      _Uninitialized(const _Uninitialized&) = default;
      _Uninitialized(_Uninitialized&&) = default;
      _Uninitialized& operator=(const _Uninitialized&) = default;
      _Uninitialized& operator=(_Uninitialized&&) = default;

      constexpr const _Type& _M_get() const & noexcept
      { return _M_storage; }

      constexpr _Type& _M_get() & noexcept
      { return _M_storage; }

      constexpr const _Type&& _M_get() const && noexcept
      { return std::move(_M_storage); }

      constexpr _Type&& _M_get() && noexcept
      { return std::move(_M_storage); }

      struct _Empty_byte { };

      union {
	_Empty_byte _M_empty;
	_Type _M_storage;
      };
#else
a257 1
#endif
d260 5
d267 1
a267 1
    __get_n(_Union&& __u) noexcept
d269 2
a270 9
      if constexpr (_Np == 0)
	return std::forward<_Union>(__u)._M_first._M_get();
      else if constexpr (_Np == 1)
	return std::forward<_Union>(__u)._M_rest._M_first._M_get();
      else if constexpr (_Np == 2)
	return std::forward<_Union>(__u)._M_rest._M_rest._M_first._M_get();
      else
	return __variant::__get_n<_Np - 3>(
		 std::forward<_Union>(__u)._M_rest._M_rest._M_rest);
d277 4
a280 1
    { return __variant::__get_n<_Np>(std::forward<_Variant>(__v)._M_u); }
d327 1
a327 7
    union _Variadic_union
    {
      _Variadic_union() = default;

      template<size_t _Np, typename... _Args>
	_Variadic_union(in_place_index_t<_Np>, _Args&&...) = delete;
    };
d335 1
a335 2
	constexpr
	_Variadic_union(in_place_index_t<0>, _Args&&... __args)
d340 1
a340 2
	constexpr
	_Variadic_union(in_place_index_t<_Np>, _Args&&... __args)
a343 14
#if __cpp_lib_variant >= 202106L
      _Variadic_union(const _Variadic_union&) = default;
      _Variadic_union(_Variadic_union&&) = default;
      _Variadic_union& operator=(const _Variadic_union&) = default;
      _Variadic_union& operator=(_Variadic_union&&) = default;

      ~_Variadic_union() = default;

      constexpr ~_Variadic_union()
	requires (!__has_trivial_destructor(_First))
	      || (!__has_trivial_destructor(_Variadic_union<_Rest...>))
      { }
#endif

d400 1
a400 2
      constexpr void
      _M_reset()
a412 1
      _GLIBCXX20_CONSTEXPR
d416 7
d451 1
a451 2
      constexpr void
      _M_reset() noexcept
d454 7
a465 6
	// It would be nice if we could just return true for -fno-exceptions.
	// It's possible (but inadvisable) that a std::variant could become
	// valueless in a translation unit compiled with -fexceptions and then
	// be passed to functions compiled with -fno-exceptions. We would need
	// some #ifdef _GLIBCXX_NO_EXCEPTIONS_GLOBALLY property to elide all
	// checks for valueless_by_exception().
a473 13
  // Implementation of v.emplace<N>(args...).
  template<size_t _Np, bool _Triv, typename... _Types, typename... _Args>
    _GLIBCXX20_CONSTEXPR
    inline void
    __emplace(_Variant_storage<_Triv, _Types...>& __v, _Args&&... __args)
    {
      __v._M_reset();
      auto* __addr = std::__addressof(__variant::__get_n<_Np>(__v._M_u));
      std::_Construct(__addr, std::forward<_Args>(__args)...);
      // Construction didn't throw, so can set the new index now:
      __v._M_index = _Np;
    }

d478 21
a507 1
      _GLIBCXX20_CONSTEXPR
d511 1
a511 9
	__variant::__raw_idx_visit(
	  [this](auto&& __rhs_mem, auto __rhs_index) mutable
	  {
	    constexpr size_t __j = __rhs_index;
	    if constexpr (__j != variant_npos)
	      std::_Construct(std::__addressof(this->_M_u),
			      in_place_index<__j>, __rhs_mem);
	  }, __variant_cast<_Types...>(__rhs));
	this->_M_index = __rhs._M_index;
a535 1
      _GLIBCXX20_CONSTEXPR
d539 1
a539 10
	__variant::__raw_idx_visit(
	  [this](auto&& __rhs_mem, auto __rhs_index) mutable
	  {
	    constexpr size_t __j = __rhs_index;
	    if constexpr (__j != variant_npos)
	      std::_Construct(std::__addressof(this->_M_u),
			      in_place_index<__j>,
			      std::forward<decltype(__rhs_mem)>(__rhs_mem));
	  }, __variant_cast<_Types...>(std::move(__rhs)));
	this->_M_index = __rhs._M_index;
d542 16
d568 16
a595 1
      _GLIBCXX20_CONSTEXPR
d603 1
a603 6
	    constexpr size_t __j = __rhs_index;
	    if constexpr (__j == variant_npos)
	      this->_M_reset(); // Make *this valueless.
	    else if (this->_M_index == __j)
	      __variant::__get<__j>(*this) = __rhs_mem;
	    else
d605 2
a606 4
		using _Tj = typename _Nth_type<__j, _Types...>::type;
		if constexpr (is_nothrow_copy_constructible_v<_Tj>
			      || !is_nothrow_move_constructible_v<_Tj>)
		  __variant::__emplace<__j>(*this, __rhs_mem);
d609 15
a623 3
		    using _Variant = variant<_Types...>;
		    _Variant& __self = __variant_cast<_Types...>(*this);
		    __self = _Variant(in_place_index<__j>, __rhs_mem);
d626 2
a653 1
      _GLIBCXX20_CONSTEXPR
d661 1
a661 2
	    constexpr size_t __j = __rhs_index;
	    if constexpr (__j != variant_npos)
d663 2
a664 2
		if (this->_M_index == __j)
		  __variant::__get<__j>(*this) = std::move(__rhs_mem);
d666 2
a667 11
		  {
		    using _Tj = typename _Nth_type<__j, _Types...>::type;
		    if constexpr (is_nothrow_move_constructible_v<_Tj>)
		      __variant::__emplace<__j>(*this, std::move(__rhs_mem));
		    else
		      {
			using _Variant = variant<_Types...>;
			_Variant& __self = __variant_cast<_Types...>(*this);
			__self.template emplace<__j>(std::move(__rhs_mem));
		      }
		  }
d697 2
a698 1
      _Variant_base() noexcept(_Traits<_Types...>::_S_nothrow_default_ctor)
d713 8
d722 13
a734 2
    inline constexpr bool __exactly_once
      = std::__find_uniq_type_in_pack<_Tp, _Types...>() < sizeof...(_Types);
d739 4
a742 2
  // "Build an imaginary function FUN(Ti) for each alternative type Ti"
  template<size_t _Ind, typename _Tp, typename _Ti, typename = void>
d750 1
a750 1
  // "... for which Ti x[] = {std::forward<T>(t)}; is well-formed."
d752 1
a752 1
    struct _Build_FUN<_Ind, _Tp, _Ti,
d759 9
d796 5
d974 1
a974 1
	      auto __tmp_element = __gen_vtable_impl<
a976 4
	      static_assert(is_same_v<_Tp, decltype(__tmp_element)>,
			    "std::visit requires the visitor to have the same "
			    "return type for all alternatives of a variant");
	      __element = __tmp_element;
d1031 1
a1031 18
      {
	if constexpr (_Array_type::__result_is_deduced::value)
	  {
	    constexpr bool __visit_ret_type_mismatch =
	      !is_same_v<typename _Result_type::type,
			 decltype(__visit_invoke(std::declval<_Visitor>(),
				    std::declval<_Variants>()...))>;
	    if constexpr (__visit_ret_type_mismatch)
	      {
		struct __cannot_match {};
		return __cannot_match{};
	      }
	    else
	      return _Array_type{&__visit_invoke};
	  }
	else
	  return _Array_type{&__visit_invoke};
      }
d1056 2
a1057 6
  // Equivalent to decltype(get<_Np>(as-variant(declval<_Variant>())))
  template<size_t _Np, typename _Variant,
      typename _AsV = decltype(__variant::__as(std::declval<_Variant>())),
      typename _Tp = variant_alternative_t<_Np, remove_reference_t<_AsV>>>
    using __get_t
      = __conditional_t<is_lvalue_reference_v<_Variant>, _Tp&, _Tp&&>;
d1064 2
a1065 2
  template<typename _Tp, typename... _Types>
    constexpr inline bool __same_types = (is_same_v<_Tp, _Types> && ...);
d1067 2
a1068 2
  template <typename _Visitor, typename _Variant, size_t... _Idxs>
    constexpr bool __check_visitor_results(std::index_sequence<_Idxs...>)
d1070 5
a1074 3
      return __same_types<
	invoke_result_t<_Visitor, __get_t<_Idxs, _Variant>>...
	>;
a1076 3
} // namespace __variant
} // namespace __detail

d1083 1
a1083 1
      return __v.index() == std::__find_uniq_type_in_pack<_Tp, _Types...>();
d1087 1
a1087 2
    constexpr _Tp&
    get(variant<_Types...>& __v)
d1092 1
a1092 2
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get<__n>(__v);
d1096 1
a1096 2
    constexpr _Tp&&
    get(variant<_Types...>&& __v)
d1101 2
a1102 2
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get<__n>(std::move(__v));
d1106 1
a1106 2
    constexpr const _Tp&
    get(const variant<_Types...>& __v)
d1111 1
a1111 2
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get<__n>(__v);
d1115 1
a1115 2
    constexpr const _Tp&&
    get(const variant<_Types...>&& __v)
d1120 2
a1121 2
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get<__n>(std::move(__v));
d1158 2
a1159 2
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get_if<__n>(__ptr);
d1169 2
a1170 2
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get_if<__n>(__ptr);
a1252 1
    _GLIBCXX20_CONSTEXPR
d1310 4
a1313 2
	friend _GLIBCXX20_CONSTEXPR decltype(auto)
	__variant_cast(_Tp&&);
d1341 1
a1341 1
	using __to_type = typename _Nth_type<_Np, _Types...>::type;
d1347 2
a1348 2
	static constexpr size_t __index_of
	  = std::__find_uniq_type_in_pack<_Tp, _Types...>();
d1369 1
a1369 1
      _GLIBCXX20_CONSTEXPR ~variant() = default;
a1425 1
	_GLIBCXX20_CONSTEXPR
d1444 1
a1444 3
		// _GLIBCXX_RESOLVE_LIB_DEFECTS
		// 3585. converting assignment with immovable alternative
		this->emplace<__index>(_Tj(std::forward<_Tp>(__rhs)));
a1449 1
	_GLIBCXX20_CONSTEXPR
a1458 1
	_GLIBCXX20_CONSTEXPR
d1469 3
a1471 3
	_GLIBCXX20_CONSTEXPR
	enable_if_t<is_constructible_v<__to_type<_Np>, _Args...>,
		    __to_type<_Np>&>
d1474 3
a1476 2
	  namespace __variant = std::__detail::__variant;
	  using type = typename _Nth_type<_Np, _Types...>::type;
d1481 3
a1483 1
	      __variant::__emplace<_Np>(*this, std::forward<_Args>(__args)...);
d1489 3
a1491 2
	      // But this won't throw:
	      __variant::__emplace<_Np>(*this, __tmp);
d1493 1
a1493 1
	  else if constexpr (__variant::_Never_valueless_alt<type>()
d1506 11
a1516 1
	      __variant::__emplace<_Np>(*this, std::forward<_Args>(__args)...);
d1522 1
a1522 2
	_GLIBCXX20_CONSTEXPR
	enable_if_t<is_constructible_v<__to_type<_Np>,
d1524 1
a1524 1
		    __to_type<_Np>&>
d1527 3
a1529 2
	  namespace __variant = std::__detail::__variant;
	  using type = typename _Nth_type<_Np, _Types...>::type;
d1536 3
a1538 2
	      __variant::__emplace<_Np>(*this, __il,
					std::forward<_Args>(__args)...);
d1540 1
a1540 1
	  else if constexpr (__variant::_Never_valueless_alt<type>()
d1553 11
a1563 2
	      __variant::__emplace<_Np>(*this, __il,
					std::forward<_Args>(__args)...);
a1567 6
      template<size_t _Np, typename... _Args>
	enable_if_t<!(_Np < sizeof...(_Types))> emplace(_Args&&...) = delete;

      template<typename _Tp, typename... _Args>
	enable_if_t<!__exactly_once<_Tp>> emplace(_Args&&...) = delete;

a1581 1
      _GLIBCXX20_CONSTEXPR
d1587 1
a1587 13
	static_assert((is_move_constructible_v<_Types> && ...));

	// Handle this here to simplify the visitation.
	if (__rhs.valueless_by_exception()) [[__unlikely__]]
	  {
	    if (!this->valueless_by_exception()) [[__likely__]]
	      __rhs.swap(*this);
	    return;
	  }

	namespace __variant = __detail::__variant;

	__variant::__raw_idx_visit(
d1590 1
a1590 2
	    constexpr size_t __j = __rhs_index;
	    if constexpr (__j != variant_npos)
d1592 1
a1592 1
		if (this->index() == __j)
d1594 2
d1597 1
a1597 1
		    swap(std::get<__j>(*this), __rhs_mem);
d1601 7
a1607 4
		    auto __tmp(std::move(__rhs_mem));

		    if constexpr (_Traits::_S_trivial_move_assign)
		      __rhs = std::move(*this);
d1609 13
a1621 10
		      __variant::__raw_idx_visit(
			[&__rhs](auto&& __this_mem, auto __this_index) mutable
			{
			  constexpr size_t __k = __this_index;
			  if constexpr (__k != variant_npos)
			    __variant::__emplace<__k>(__rhs,
						      std::move(__this_mem));
			}, *this);

		    __variant::__emplace<__j>(*this, std::move(__tmp));
d1627 2
d1632 1
a1634 1
    private:
d1639 4
a1702 1
  /// @@cond undocumented
d1707 2
a1708 16
      // Get the silly case of visiting no variants out of the way first.
      if constexpr (sizeof...(_Variants) == 0)
	{
	  if constexpr (is_void_v<_Result_type>)
	    return (void) std::forward<_Visitor>(__visitor)();
	  else
	    return std::forward<_Visitor>(__visitor)();
	}
      else
	{
	  constexpr size_t __max = 11; // "These go to eleven."

	  // The type of the first variant in the pack.
	  using _V0 = typename _Nth_type<0, _Variants...>::type;
	  // The number of alternatives in that first variant.
	  constexpr auto __n = variant_size_v<remove_reference_t<_V0>>;
d1710 3
a1712 71
	  if constexpr (sizeof...(_Variants) > 1 || __n > __max)
	    {
	      // Use a jump table for the general case.
	      constexpr auto& __vtable = __detail::__variant::__gen_vtable<
		_Result_type, _Visitor&&, _Variants&&...>::_S_vtable;

	      auto __func_ptr = __vtable._M_access(__variants.index()...);
	      return (*__func_ptr)(std::forward<_Visitor>(__visitor),
				   std::forward<_Variants>(__variants)...);
	    }
	  else // We have a single variant with a small number of alternatives.
	    {
	      // A name for the first variant in the pack.
	      _V0& __v0
		= [](_V0& __v, ...) -> _V0& { return __v; }(__variants...);

	      using __detail::__variant::_Multi_array;
	      using __detail::__variant::__gen_vtable_impl;
	      using _Ma = _Multi_array<_Result_type (*)(_Visitor&&, _V0&&)>;

#ifdef _GLIBCXX_DEBUG
# define _GLIBCXX_VISIT_UNREACHABLE __builtin_trap
#else
# define _GLIBCXX_VISIT_UNREACHABLE __builtin_unreachable
#endif

#define _GLIBCXX_VISIT_CASE(N)						\
  case N:								\
  {									\
    if constexpr (N < __n)						\
      {									\
	return __gen_vtable_impl<_Ma, index_sequence<N>>::		\
	  __visit_invoke(std::forward<_Visitor>(__visitor),		\
			 std::forward<_V0>(__v0));		\
      }									\
    else _GLIBCXX_VISIT_UNREACHABLE();					\
  }

	      switch (__v0.index())
		{
		  _GLIBCXX_VISIT_CASE(0)
		  _GLIBCXX_VISIT_CASE(1)
		  _GLIBCXX_VISIT_CASE(2)
		  _GLIBCXX_VISIT_CASE(3)
		  _GLIBCXX_VISIT_CASE(4)
		  _GLIBCXX_VISIT_CASE(5)
		  _GLIBCXX_VISIT_CASE(6)
		  _GLIBCXX_VISIT_CASE(7)
		  _GLIBCXX_VISIT_CASE(8)
		  _GLIBCXX_VISIT_CASE(9)
		  _GLIBCXX_VISIT_CASE(10)
		case variant_npos:
		  using __detail::__variant::__variant_idx_cookie;
		  using __detail::__variant::__variant_cookie;
		  if constexpr (is_same_v<_Result_type, __variant_idx_cookie>
				|| is_same_v<_Result_type, __variant_cookie>)
		    {
		      using _Npos = index_sequence<variant_npos>;
		      return __gen_vtable_impl<_Ma, _Npos>::
			__visit_invoke(std::forward<_Visitor>(__visitor),
				       std::forward<_V0>(__v0));
		    }
		  else
		    _GLIBCXX_VISIT_UNREACHABLE();
		default:
		  _GLIBCXX_VISIT_UNREACHABLE();
		}
#undef _GLIBCXX_VISIT_CASE
#undef _GLIBCXX_VISIT_UNREACHABLE
	    }
	}
a1713 1
  /// @@endcond
d1719 1
a1719 3
      namespace __variant = std::__detail::__variant;

      if ((__variant::__as(__variants).valueless_by_exception() || ...))
d1727 2
a1728 23
      if constexpr (sizeof...(_Variants) == 1)
	{
	  using _Vp = decltype(__variant::__as(std::declval<_Variants>()...));

	  constexpr bool __visit_rettypes_match = __detail::__variant::
	    __check_visitor_results<_Visitor, _Vp>(
	      make_index_sequence<variant_size_v<remove_reference_t<_Vp>>>());
	  if constexpr (!__visit_rettypes_match)
	    {
	      static_assert(__visit_rettypes_match,
			  "std::visit requires the visitor to have the same "
			  "return type for all alternatives of a variant");
	      return;
	    }
	  else
	    return std::__do_visit<_Tag>(
	      std::forward<_Visitor>(__visitor),
	      static_cast<_Vp>(__variants)...);
	}
      else
	return std::__do_visit<_Tag>(
	  std::forward<_Visitor>(__visitor),
	  __variant::__as(std::forward<_Variants>(__variants))...);
d1736 1
a1736 3
      namespace __variant = std::__detail::__variant;

      if ((__variant::__as(__variants).valueless_by_exception() || ...))
d1740 1
a1740 1
	  __variant::__as(std::forward<_Variants>(__variants))...);
a1743 1
  /// @@cond undocumented
a1773 1
  /// @@endcond
@


1.1.1.9.2.1
log
@Sync with HEAD.
@
text
@a323 27
  // Gets the _Uninitialized to construct into for __u.
  template<size_t _Np, typename _Union>
    constexpr decltype(auto)
    __construct_n(_Union& __u) noexcept
    {
      if constexpr (_Np == 0)
	return &__u._M_first;
      else if constexpr (_Np == 1)
	{
	  std::_Construct(&__u._M_rest);
	  return &__u._M_rest._M_first;
	}
      else if constexpr (_Np == 2)
	{
	  std::_Construct(&__u._M_rest);
	  std::_Construct(&__u._M_rest._M_rest);
	  return &__u._M_rest._M_rest._M_first;
	}
      else
	{
	  std::_Construct(&__u._M_rest);
	  std::_Construct(&__u._M_rest._M_rest);
	  std::_Construct(&__u._M_rest._M_rest._M_rest);
	  return __variant::__construct_n<_Np - 3>(__u._M_rest._M_rest._M_rest);
	}
    }

d540 2
a541 3
      auto* __addr = __variant::__construct_n<_Np>(__v._M_u);
      std::_Construct(__addr, in_place_index<0>,
		      std::forward<_Args>(__args)...);
d1125 1
d1136 1
d1147 1
d1158 1
@


1.1.1.9.2.2
log
@Sync with HEAD
@
text
@d494 1
a494 1
	if (!_M_valid()) [[__unlikely__]]
@


1.1.1.10
log
@import GCC 12.4.0.

this includes at least 85 GCC PRs fixed, 2 C, 17 C++, 16 libstdc++-v3,
at least 13 target-specific (x86, arm64, riscv mostly), and at least
24 optimisation PRs.
@
text
@a323 27
  // Gets the _Uninitialized to construct into for __u.
  template<size_t _Np, typename _Union>
    constexpr decltype(auto)
    __construct_n(_Union& __u) noexcept
    {
      if constexpr (_Np == 0)
	return &__u._M_first;
      else if constexpr (_Np == 1)
	{
	  std::_Construct(&__u._M_rest);
	  return &__u._M_rest._M_first;
	}
      else if constexpr (_Np == 2)
	{
	  std::_Construct(&__u._M_rest);
	  std::_Construct(&__u._M_rest._M_rest);
	  return &__u._M_rest._M_rest._M_first;
	}
      else
	{
	  std::_Construct(&__u._M_rest);
	  std::_Construct(&__u._M_rest._M_rest);
	  std::_Construct(&__u._M_rest._M_rest._M_rest);
	  return __variant::__construct_n<_Np - 3>(__u._M_rest._M_rest._M_rest);
	}
    }

d540 2
a541 3
      auto* __addr = __variant::__construct_n<_Np>(__v._M_u);
      std::_Construct(__addr, in_place_index<0>,
		      std::forward<_Args>(__args)...);
d1125 1
d1136 1
d1147 1
d1158 1
@


1.1.1.11
log
@initial import of GCC 12.5.0.

this is the final GCC 12 release, and fixes at least 241 specific bugs
in the GCC bugzilla:

   https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=12.5

though many are in components we don't ship in base (ada, fortran, etc.)
@
text
@d494 1
a494 1
	if (!_M_valid()) [[__unlikely__]]
@


1.1.1.12
log
@initial import of GCC 14.3.0.

major changes in GCC 13:
- improved sanitizer
- zstd debug info compression
- LTO improvements
- SARIF based diagnostic support
- new warnings: -Wxor-used-as-pow, -Wenum-int-mismatch, -Wself-move,
  -Wdangling-reference
- many new -Wanalyzer* specific warnings
- enhanced warnings: -Wpessimizing-move, -Wredundant-move
- new attributes to mark file descriptors, c++23 "assume"
- several C23 features added
- several C++23 features added
- many new features for Arm, x86, RISC-V

major changes in GCC 14:
- more strict C99 or newer support
- ia64* marked deprecated (but seemingly still in GCC 15.)
- several new hardening features
- support for "hardbool", which can have user supplied values of true/false
- explicit support for stack scrubbing upon function exit
- better auto-vectorisation support
- added clang-compatible __has_feature and __has_extension
- more C23, including -std=c23
- several C++26 features added
- better diagnostics in C++ templates
- new warnings: -Wnrvo, Welaborated-enum-base
- many new features for Arm, x86, RISC-V
- possible ABI breaking change for SPARC64 and small structures with arrays
  of floats.
@
text
@d3 1
a3 1
// Copyright (C) 2016-2024 Free Software Foundation, Inc.
d34 1
a34 3
#define __glibcxx_want_freestanding_variant
#define __glibcxx_want_variant
#include <bits/version.h>
a35 1
#ifdef __cpp_lib_variant // C++ >= 17
d42 2
a43 1
#include <bits/parse_numbers.h> // _Select_int
d51 4
a54 2
// C++ < 20 || __cpp_concepts < 202002L || __cpp_constexpr < 201811L
#if __cpp_lib_variant < 202106L
d56 1
a58 1

d111 1
a111 1
    { using type = const variant_alternative_t<_Np, _Variant>; };
d115 1
a115 1
    { using type = volatile variant_alternative_t<_Np, _Variant>; };
d119 1
a119 1
    { using type = const volatile variant_alternative_t<_Np, _Variant>; };
d395 1
a395 1
  template<bool __trivially_destructible, typename... _Types>
d404 2
a405 2
  template<bool __trivially_destructible, typename _First, typename... _Rest>
    union _Variadic_union<__trivially_destructible, _First, _Rest...>
d430 2
a431 1
	requires (!__trivially_destructible)
d436 1
a436 1
      _Variadic_union<__trivially_destructible, _Rest...> _M_rest;
d517 1
a517 1
      _Variadic_union<false, _Types...> _M_u;
d555 1
a555 1
      _Variadic_union<true, _Types...> _M_u;
d796 1
a796 1
      void _S_fun() = delete;
d827 3
a829 2
    inline constexpr size_t
    __accepted_index = variant_npos;
d832 3
a834 3
    inline constexpr size_t
    __accepted_index<_Tp, _Variant, void_t<_FUN_type<_Tp, _Variant>>>
      = _FUN_type<_Tp, _Variant>::value;
d836 14
a849 14
  template<typename _Maybe_variant_cookie, typename _Variant,
	   typename = __remove_cvref_t<_Variant>>
    inline constexpr bool
    __extra_visit_slot_needed = false;

  template<typename _Var, typename... _Types>
    inline constexpr bool
    __extra_visit_slot_needed<__variant_cookie, _Var, variant<_Types...>>
      = !__variant::__never_valueless<_Types...>();

  template<typename _Var, typename... _Types>
    inline constexpr bool
    __extra_visit_slot_needed<__variant_idx_cookie, _Var, variant<_Types...>>
      = !__variant::__never_valueless<_Types...>();
a863 2
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wignored-qualifiers"
a867 1
#pragma GCC diagnostic pop
d906 1
a906 1
	__extra_visit_slot_needed<_Ret, _Variant> ? 1 : 0;
d985 1
a985 1
	  if constexpr (__extra_visit_slot_needed<_Result_type, _Next>)
d1362 3
d1379 4
a1382 7
#ifdef __STRICT_ANSI__
      static_assert(((std::is_object_v<_Types> && !is_array_v<_Types>) && ...),
		    "variant alternatives must be non-array object types");
#else
      static_assert((std::is_object_v<_Types> && ...),
		    "variant alternatives must be object types");
#endif
d1385 4
d1400 1
a1400 1
	  = __detail::__variant::__accepted_index<_Tp, variant>;
d1423 1
a1423 2
	  = !__is_in_place_type_v<__remove_cvref_t<_Tp>>
	      && !__is_in_place_index_v<__remove_cvref_t<_Tp>>;
d1426 1
a1426 10
#if __cpp_concepts
      variant() requires is_default_constructible_v<__to_type<0>> = default;
#else
      template<typename _Tp0 = __to_type<0>,
	       typename = enable_if_t<is_default_constructible_v<_Tp0>>>
	constexpr
	variant() noexcept(is_nothrow_default_constructible_v<__to_type<0>>)
	{ }
#endif

d1471 2
a1472 1
	: _Base(in_place_index<_Np>, std::forward<_Args>(__args)...)
d1483 2
a1484 1
	: _Base(in_place_index<_Np>, __il, std::forward<_Args>(__args)...)
d1967 2
a1968 1
#endif // __cpp_lib_variant
@


1.1.1.1.4.1
log
@file variant was added on branch phil-wifi on 2019-06-10 21:54:58 +0000
@
text
@d1 1319
@


1.1.1.1.4.2
log
@Sync with HEAD
@
text
@a0 1319
// <variant> -*- C++ -*-

// Copyright (C) 2016-2017 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @@file variant
 *  This is the <variant> C++ Library header.
 */

#ifndef _GLIBCXX_VARIANT
#define _GLIBCXX_VARIANT 1

#pragma GCC system_header

#if __cplusplus >= 201703L

#include <type_traits>
#include <utility>
#include <bits/enable_special_members.h>
#include <bits/functexcept.h>
#include <bits/move.h>
#include <bits/functional_hash.h>
#include <bits/invoke.h>
#include <ext/aligned_buffer.h>
#include <bits/parse_numbers.h>
#include <bits/stl_iterator_base_types.h>
#include <bits/stl_iterator_base_funcs.h>
#include <bits/stl_construct.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __detail
{
namespace __variant
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<size_t _Np, typename... _Types>
    struct _Nth_type;

  template<size_t _Np, typename _First, typename... _Rest>
    struct _Nth_type<_Np, _First, _Rest...>
    : _Nth_type<_Np-1, _Rest...> { };

  template<typename _First, typename... _Rest>
    struct _Nth_type<0, _First, _Rest...>
    { using type = _First; };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __variant
} // namespace __detail

_GLIBCXX_BEGIN_NAMESPACE_VERSION

#define __cpp_lib_variant 201603

  template<typename... _Types> class tuple;
  template<typename... _Types> class variant;
  template <typename> struct hash;

  template<typename _Variant>
    struct variant_size;

  template<typename _Variant>
    struct variant_size<const _Variant> : variant_size<_Variant> {};

  template<typename _Variant>
    struct variant_size<volatile _Variant> : variant_size<_Variant> {};

  template<typename _Variant>
    struct variant_size<const volatile _Variant> : variant_size<_Variant> {};

  template<typename... _Types>
    struct variant_size<variant<_Types...>>
    : std::integral_constant<size_t, sizeof...(_Types)> {};

  template<typename _Variant>
    inline constexpr size_t variant_size_v = variant_size<_Variant>::value;

  template<size_t _Np, typename _Variant>
    struct variant_alternative;

  template<size_t _Np, typename _First, typename... _Rest>
    struct variant_alternative<_Np, variant<_First, _Rest...>>
    : variant_alternative<_Np-1, variant<_Rest...>> {};

  template<typename _First, typename... _Rest>
    struct variant_alternative<0, variant<_First, _Rest...>>
    { using type = _First; };

  template<size_t _Np, typename _Variant>
    using variant_alternative_t =
      typename variant_alternative<_Np, _Variant>::type;

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, const _Variant>
    { using type = add_const_t<variant_alternative_t<_Np, _Variant>>; };

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, volatile _Variant>
    { using type = add_volatile_t<variant_alternative_t<_Np, _Variant>>; };

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, const volatile _Variant>
    { using type = add_cv_t<variant_alternative_t<_Np, _Variant>>; };

  inline constexpr size_t variant_npos = -1;

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&
    get(variant<_Types...>&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&&
    get(variant<_Types...>&&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>> const&
    get(const variant<_Types...>&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>> const&&
    get(const variant<_Types...>&&);

_GLIBCXX_END_NAMESPACE_VERSION

namespace __detail
{
namespace __variant
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
  // Returns the first apparence of _Tp in _Types.
  // Returns sizeof...(_Types) if _Tp is not in _Types.
  template<typename _Tp, typename... _Types>
    struct __index_of : std::integral_constant<size_t, 0> {};

  template<typename _Tp, typename... _Types>
    inline constexpr size_t __index_of_v = __index_of<_Tp, _Types...>::value;

  template<typename _Tp, typename _First, typename... _Rest>
    struct __index_of<_Tp, _First, _Rest...> :
      std::integral_constant<size_t, is_same_v<_Tp, _First>
	? 0 : __index_of_v<_Tp, _Rest...> + 1> {};

  // _Uninitialized<T> is guaranteed to be a literal type, even if T is not.
  // We have to do this, because [basic.types]p10.5.3 (n4606) is not implemented
  // yet. When it's implemented, _Uninitialized<T> can be changed to the alias
  // to T, therefore equivalent to being removed entirely.
  //
  // Another reason we may not want to remove _Uninitialzied<T> may be that, we
  // want _Uninitialized<T> to be trivially destructible, no matter whether T
  // is; but we will see.
  template<typename _Type, bool = std::is_literal_type_v<_Type>>
    struct _Uninitialized;

  template<typename _Type>
    struct _Uninitialized<_Type, true>
    {
      template<typename... _Args>
      constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args)
      : _M_storage(std::forward<_Args>(__args)...)
      { }

      constexpr const _Type& _M_get() const &
      { return _M_storage; }

      constexpr _Type& _M_get() &
      { return _M_storage; }

      constexpr const _Type&& _M_get() const &&
      { return std::move(_M_storage); }

      constexpr _Type&& _M_get() &&
      { return std::move(_M_storage); }

      _Type _M_storage;
    };

  template<typename _Type>
    struct _Uninitialized<_Type, false>
    {
      template<typename... _Args>
      constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args)
      { ::new (&_M_storage) _Type(std::forward<_Args>(__args)...); }

      const _Type& _M_get() const &
      { return *_M_storage._M_ptr(); }

      _Type& _M_get() &
      { return *_M_storage._M_ptr(); }

      const _Type&& _M_get() const &&
      { return std::move(*_M_storage._M_ptr()); }

      _Type&& _M_get() &&
      { return std::move(*_M_storage._M_ptr()); }

      __gnu_cxx::__aligned_membuf<_Type> _M_storage;
    };

  template<typename _Ref>
    _Ref __ref_cast(void* __ptr)
    {
      return static_cast<_Ref>(*static_cast<remove_reference_t<_Ref>*>(__ptr));
    }

  template<typename _Union>
    constexpr decltype(auto) __get(in_place_index_t<0>, _Union&& __u)
    { return std::forward<_Union>(__u)._M_first._M_get(); }

  template<size_t _Np, typename _Union>
    constexpr decltype(auto) __get(in_place_index_t<_Np>, _Union&& __u)
    {
      return __variant::__get(in_place_index<_Np-1>,
			      std::forward<_Union>(__u)._M_rest);
    }

  // Returns the typed storage for __v.
  template<size_t _Np, typename _Variant>
    constexpr decltype(auto) __get(_Variant&& __v)
    {
      return __variant::__get(std::in_place_index<_Np>,
			      std::forward<_Variant>(__v)._M_u);
    }

  // Various functions as "vtable" entries, where those vtables are used by
  // polymorphic operations.
  template<typename _Lhs, typename _Rhs>
    void
    __erased_ctor(void* __lhs, void* __rhs)
    {
      using _Type = remove_reference_t<_Lhs>;
      ::new (__lhs) _Type(__variant::__ref_cast<_Rhs>(__rhs));
    }

  template<typename _Variant, size_t _Np>
    void
    __erased_dtor(_Variant&& __v)
    { std::_Destroy(std::__addressof(__variant::__get<_Np>(__v))); }

  template<typename _Lhs, typename _Rhs>
    void
    __erased_assign(void* __lhs, void* __rhs)
    {
      __variant::__ref_cast<_Lhs>(__lhs) = __variant::__ref_cast<_Rhs>(__rhs);
    }

  template<typename _Lhs, typename _Rhs>
    void
    __erased_swap(void* __lhs, void* __rhs)
    {
      using std::swap;
      swap(__variant::__ref_cast<_Lhs>(__lhs),
	   __variant::__ref_cast<_Rhs>(__rhs));
    }

#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP, __NAME) \
  template<typename _Variant, size_t _Np> \
    constexpr bool \
    __erased_##__NAME(const _Variant& __lhs, const _Variant& __rhs) \
    { \
      return __variant::__get<_Np>(std::forward<_Variant>(__lhs)) \
	  __OP __variant::__get<_Np>(std::forward<_Variant>(__rhs)); \
    }

  _VARIANT_RELATION_FUNCTION_TEMPLATE(<, less)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(<=, less_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(==, equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(!=, not_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>=, greater_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>, greater)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE

  template<typename _Tp>
    size_t
    __erased_hash(void* __t)
    {
      return std::hash<remove_cv_t<remove_reference_t<_Tp>>>{}(
	  __variant::__ref_cast<_Tp>(__t));
    }

  // Defines members and ctors.
  template<typename... _Types>
    union _Variadic_union { };

  template<typename _First, typename... _Rest>
    union _Variadic_union<_First, _Rest...>
    {
      constexpr _Variadic_union() : _M_rest() { }

      template<typename... _Args>
	constexpr _Variadic_union(in_place_index_t<0>, _Args&&... __args)
	: _M_first(in_place_index<0>, std::forward<_Args>(__args)...)
	{ }

      template<size_t _Np, typename... _Args>
	constexpr _Variadic_union(in_place_index_t<_Np>, _Args&&... __args)
	: _M_rest(in_place_index<_Np-1>, std::forward<_Args>(__args)...)
	{ }

      _Uninitialized<_First> _M_first;
      _Variadic_union<_Rest...> _M_rest;
    };

  // Defines index and the dtor, possibly trivial.
  template<bool __trivially_destructible, typename... _Types>
    struct _Variant_storage;

  template <typename... _Types>
  using __select_index =
    typename __select_int::_Select_int_base<sizeof...(_Types) + 1,
					    unsigned char,
					    unsigned short>::type::value_type;

  template<typename... _Types>
    struct _Variant_storage<false, _Types...>
    {
      template<size_t... __indices>
	static constexpr void (*_S_vtable[])(const _Variant_storage&) =
	    { &__erased_dtor<const _Variant_storage&, __indices>... };

      constexpr _Variant_storage() : _M_index(variant_npos) { }

      template<size_t _Np, typename... _Args>
	constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
	: _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...),
	_M_index(_Np)
	{ }

      template<size_t... __indices>
	constexpr void _M_reset_impl(std::index_sequence<__indices...>)
	{
	  if (_M_index != __index_type(variant_npos))
	    _S_vtable<__indices...>[_M_index](*this);
	}

      void _M_reset()
      {
	_M_reset_impl(std::index_sequence_for<_Types...>{});
	_M_index = variant_npos;
      }

      ~_Variant_storage()
      { _M_reset(); }

      _Variadic_union<_Types...> _M_u;
      using __index_type = __select_index<_Types...>;
      __index_type _M_index;
    };

  template<typename... _Types>
    struct _Variant_storage<true, _Types...>
    {
      constexpr _Variant_storage() : _M_index(variant_npos) { }

      template<size_t _Np, typename... _Args>
	constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
	: _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...),
	_M_index(_Np)
	{ }

      void _M_reset()
      { _M_index = variant_npos; }

      _Variadic_union<_Types...> _M_u;
      using __index_type = __select_index<_Types...>;
      __index_type _M_index;
    };

  // Helps SFINAE on special member functions. Otherwise it can live in variant
  // class.
  template<typename... _Types>
    struct _Variant_base :
      _Variant_storage<(std::is_trivially_destructible_v<_Types> && ...),
			_Types...>
    {
      using _Storage =
	  _Variant_storage<(std::is_trivially_destructible_v<_Types> && ...),
			    _Types...>;

      constexpr
      _Variant_base()
      noexcept(is_nothrow_default_constructible_v<
		 variant_alternative_t<0, variant<_Types...>>>)
      : _Variant_base(in_place_index<0>) { }

      _Variant_base(const _Variant_base& __rhs)
      {
	if (__rhs._M_valid())
	  {
	    static constexpr void (*_S_vtable[])(void*, void*) =
	      { &__erased_ctor<_Types&, const _Types&>... };
	    _S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	    this->_M_index = __rhs._M_index;
	  }
      }

      _Variant_base(_Variant_base&& __rhs)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...))
      {
	if (__rhs._M_valid())
	  {
	    static constexpr void (*_S_vtable[])(void*, void*) =
	      { &__erased_ctor<_Types&, _Types&&>... };
	    _S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	    this->_M_index = __rhs._M_index;
	  }
      }

      template<size_t _Np, typename... _Args>
	constexpr explicit
	_Variant_base(in_place_index_t<_Np> __i, _Args&&... __args)
	: _Storage(__i, std::forward<_Args>(__args)...)
	{ }

      _Variant_base&
      operator=(const _Variant_base& __rhs)
      {
	if (this->_M_index == __rhs._M_index)
	  {
	    if (__rhs._M_valid())
	      {
		static constexpr void (*_S_vtable[])(void*, void*) =
		  { &__erased_assign<_Types&, const _Types&>... };
		_S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	      }
	  }
	else
	  {
	    _Variant_base __tmp(__rhs);
	    this->~_Variant_base();
	    __try
	      {
		::new (this) _Variant_base(std::move(__tmp));
	      }
	    __catch (...)
	      {
		this->_M_index = variant_npos;
		__throw_exception_again;
	      }
	  }
	__glibcxx_assert(this->_M_index == __rhs._M_index);
	return *this;
      }

      void _M_destructive_move(_Variant_base&& __rhs)
      {
	this->~_Variant_base();
	__try
	  {
	    ::new (this) _Variant_base(std::move(__rhs));
	  }
	__catch (...)
	  {
	    this->_M_index = variant_npos;
	    __throw_exception_again;
	  }
      }

      _Variant_base&
      operator=(_Variant_base&& __rhs)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)
	  && (is_nothrow_move_assignable_v<_Types> && ...))
      {
	if (this->_M_index == __rhs._M_index)
	  {
	    if (__rhs._M_valid())
	      {
		static constexpr void (*_S_vtable[])(void*, void*) =
		  { &__erased_assign<_Types&, _Types&&>... };
		_S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	      }
	  }
	else
	  {
	    _M_destructive_move(std::move(__rhs));
	  }
	return *this;
      }

      void*
      _M_storage() const
      {
	return const_cast<void*>(static_cast<const void*>(
	    std::addressof(_Storage::_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
	return this->_M_index !=
	  typename _Storage::__index_type(variant_npos);
      }
    };

  // For how many times does _Tp appear in _Tuple?
  template<typename _Tp, typename _Tuple>
    struct __tuple_count;

  template<typename _Tp, typename _Tuple>
    inline constexpr size_t __tuple_count_v =
      __tuple_count<_Tp, _Tuple>::value;

  template<typename _Tp, typename... _Types>
    struct __tuple_count<_Tp, tuple<_Types...>>
    : integral_constant<size_t, 0> { };

  template<typename _Tp, typename _First, typename... _Rest>
    struct __tuple_count<_Tp, tuple<_First, _Rest...>>
    : integral_constant<
	size_t,
	__tuple_count_v<_Tp, tuple<_Rest...>> + is_same_v<_Tp, _First>> { };

  // TODO: Reuse this in <tuple> ?
  template<typename _Tp, typename... _Types>
    inline constexpr bool __exactly_once =
      __tuple_count_v<_Tp, tuple<_Types...>> == 1;

  // Takes _Types and create an overloaded _S_fun for each type.
  // If a type appears more than once in _Types, create only one overload.
  template<typename... _Types>
    struct __overload_set
    { static void _S_fun(); };

  template<typename _First, typename... _Rest>
    struct __overload_set<_First, _Rest...> : __overload_set<_Rest...>
    {
      using __overload_set<_Rest...>::_S_fun;
      static integral_constant<size_t, sizeof...(_Rest)> _S_fun(_First);
    };

  template<typename... _Rest>
    struct __overload_set<void, _Rest...> : __overload_set<_Rest...>
    {
      using __overload_set<_Rest...>::_S_fun;
    };

  // Helper for variant(_Tp&&) and variant::operator=(_Tp&&).
  // __accepted_index maps the arbitrary _Tp to an alternative type in _Variant.
  template<typename _Tp, typename _Variant, typename = void>
    struct __accepted_index
    { static constexpr size_t value = variant_npos; };

  template<typename _Tp, typename... _Types>
    struct __accepted_index<
      _Tp, variant<_Types...>,
      decltype(__overload_set<_Types...>::_S_fun(std::declval<_Tp>()),
	       std::declval<void>())>
    {
      static constexpr size_t value = sizeof...(_Types) - 1
	- decltype(__overload_set<_Types...>::
		   _S_fun(std::declval<_Tp>()))::value;
    };

  // Returns the raw storage for __v.
  template<typename _Variant>
    void* __get_storage(_Variant&& __v)
    { return __v._M_storage(); }

  // Used for storing multi-dimensional vtable.
  template<typename _Tp, size_t... _Dimensions>
    struct _Multi_array
    {
      constexpr const _Tp&
      _M_access() const
      { return _M_data; }

      _Tp _M_data;
    };

  template<typename _Tp, size_t __first, size_t... __rest>
    struct _Multi_array<_Tp, __first, __rest...>
    {
      template<typename... _Args>
	constexpr const _Tp&
	_M_access(size_t __first_index, _Args... __rest_indices) const
	{ return _M_arr[__first_index]._M_access(__rest_indices...); }

      _Multi_array<_Tp, __rest...> _M_arr[__first];
    };

  // Creates a multi-dimensional vtable recursively.
  //
  // For example,
  // visit([](auto, auto){},
  //       variant<int, char>(),  // typedef'ed as V1
  //       variant<float, double, long double>())  // typedef'ed as V2
  // will trigger instantiations of:
  // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 2, 3>,
  //                   tuple<V1&&, V2&&>, std::index_sequence<>>
  //   __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 3>,
  //                     tuple<V1&&, V2&&>, std::index_sequence<0>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<0, 0>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<0, 1>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<0, 2>>
  //   __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 3>,
  //                     tuple<V1&&, V2&&>, std::index_sequence<1>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<1, 0>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<1, 1>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<1, 2>>
  // The returned multi-dimensional vtable can be fast accessed by the visitor
  // using index calculation.
  template<typename _Array_type, typename _Variant_tuple, typename _Index_seq>
    struct __gen_vtable_impl;

  template<typename _Result_type, typename _Visitor, size_t... __dimensions,
	   typename... _Variants, size_t... __indices>
    struct __gen_vtable_impl<
	_Multi_array<_Result_type (*)(_Visitor, _Variants...), __dimensions...>,
	tuple<_Variants...>, std::index_sequence<__indices...>>
    {
      using _Next =
	  remove_reference_t<typename _Nth_type<sizeof...(__indices),
			     _Variants...>::type>;
      using _Array_type =
	  _Multi_array<_Result_type (*)(_Visitor, _Variants...),
		       __dimensions...>;

      static constexpr _Array_type
      _S_apply()
      {
	_Array_type __vtable{};
	_S_apply_all_alts(
	  __vtable, make_index_sequence<variant_size_v<_Next>>());
	return __vtable;
      }

      template<size_t... __var_indices>
	static constexpr void
	_S_apply_all_alts(_Array_type& __vtable,
			  std::index_sequence<__var_indices...>)
	{
	  (_S_apply_single_alt<__var_indices>(
	     __vtable._M_arr[__var_indices]), ...);
	}

      template<size_t __index, typename _Tp>
	static constexpr void
	_S_apply_single_alt(_Tp& __element)
	{
	  using _Alternative = variant_alternative_t<__index, _Next>;
	  __element = __gen_vtable_impl<
	    remove_reference_t<
	      decltype(__element)>, tuple<_Variants...>,
	      std::index_sequence<__indices..., __index>>::_S_apply();
	}
    };

  template<typename _Result_type, typename _Visitor, typename... _Variants,
	   size_t... __indices>
    struct __gen_vtable_impl<
      _Multi_array<_Result_type (*)(_Visitor, _Variants...)>,
		   tuple<_Variants...>, std::index_sequence<__indices...>>
    {
      using _Array_type =
	  _Multi_array<_Result_type (*)(_Visitor&&, _Variants...)>;

      decltype(auto)
      static constexpr __visit_invoke(_Visitor&& __visitor, _Variants... __vars)
      {
	return std::__invoke(std::forward<_Visitor>(__visitor),
	    std::get<__indices>(std::forward<_Variants>(__vars))...);
      }

      static constexpr auto
      _S_apply()
      { return _Array_type{&__visit_invoke}; }
    };

  template<typename _Result_type, typename _Visitor, typename... _Variants>
    struct __gen_vtable
    {
      using _Func_ptr = _Result_type (*)(_Visitor&&, _Variants...);
      using _Array_type =
	  _Multi_array<_Func_ptr,
		       variant_size_v<remove_reference_t<_Variants>>...>;

      static constexpr _Array_type
      _S_apply()
      {
	return __gen_vtable_impl<_Array_type, tuple<_Variants...>,
				 std::index_sequence<>>::_S_apply();
      }

      static constexpr auto _S_vtable = _S_apply();
    };

  template<size_t _Np, typename _Tp>
    struct _Base_dedup : public _Tp { };

  template<typename _Variant, typename __indices>
    struct _Variant_hash_base;

  template<typename... _Types, size_t... __indices>
    struct _Variant_hash_base<variant<_Types...>,
			      std::index_sequence<__indices...>>
    : _Base_dedup<__indices, __poison_hash<remove_const_t<_Types>>>... { };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __variant
} // namespace __detail

_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<typename _Tp, typename... _Types>
    inline constexpr bool holds_alternative(const variant<_Types...>& __v)
    noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      return __v.index() == __detail::__variant::__index_of_v<_Tp, _Types...>;
    }

  template<typename _Tp, typename... _Types>
    constexpr inline _Tp& get(variant<_Types...>& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(__v);
    }

  template<typename _Tp, typename... _Types>
    constexpr inline _Tp&& get(variant<_Types...>&& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	std::move(__v));
    }

  template<typename _Tp, typename... _Types>
    constexpr inline const _Tp& get(const variant<_Types...>& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(__v);
    }

  template<typename _Tp, typename... _Types>
    constexpr inline const _Tp&& get(const variant<_Types...>&& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	std::move(__v));
    }

  template<size_t _Np, typename... _Types>
    constexpr inline
    add_pointer_t<variant_alternative_t<_Np, variant<_Types...>>>
    get_if(variant<_Types...>* __ptr) noexcept
    {
      using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>;
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      static_assert(!is_void_v<_Alternative_type>, "_Tp should not be void");
      if (__ptr && __ptr->index() == _Np)
	return &__detail::__variant::__get<_Np>(*__ptr);
      return nullptr;
    }

  template<size_t _Np, typename... _Types>
    constexpr inline
    add_pointer_t<const variant_alternative_t<_Np, variant<_Types...>>>
    get_if(const variant<_Types...>* __ptr) noexcept
    {
      using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>;
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      static_assert(!is_void_v<_Alternative_type>, "_Tp should not be void");
      if (__ptr && __ptr->index() == _Np)
	return &__detail::__variant::__get<_Np>(*__ptr);
      return nullptr;
    }

  template<typename _Tp, typename... _Types>
    constexpr inline add_pointer_t<_Tp>
    get_if(variant<_Types...>* __ptr) noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get_if<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	  __ptr);
    }

  template<typename _Tp, typename... _Types>
    constexpr inline add_pointer_t<const _Tp>
    get_if(const variant<_Types...>* __ptr)
    noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get_if<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	  __ptr);
    }

  struct monostate { };

#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP, __NAME) \
  template<typename... _Types> \
    constexpr bool operator __OP(const variant<_Types...>& __lhs, \
				 const variant<_Types...>& __rhs) \
    { \
      return __lhs._M_##__NAME(__rhs, std::index_sequence_for<_Types...>{}); \
    } \
\
  constexpr bool operator __OP(monostate, monostate) noexcept \
  { return 0 __OP 0; }

  _VARIANT_RELATION_FUNCTION_TEMPLATE(<, less)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(<=, less_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(==, equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(!=, not_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>=, greater_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>, greater)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE

  template<typename _Visitor, typename... _Variants>
    constexpr decltype(auto) visit(_Visitor&&, _Variants&&...);

  template<typename... _Types>
    inline enable_if_t<(is_move_constructible_v<_Types> && ...)
			&& (is_swappable_v<_Types> && ...)>
    swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

  template<typename... _Types>
    enable_if_t<!((is_move_constructible_v<_Types> && ...)
		   && (is_swappable_v<_Types> && ...))>
    swap(variant<_Types...>&, variant<_Types...>&) = delete;

  class bad_variant_access : public exception
  {
  public:
    bad_variant_access() noexcept : _M_reason("Unknown reason") { }
    const char* what() const noexcept override
    { return _M_reason; }

  private:
    bad_variant_access(const char* __reason) : _M_reason(__reason) { }

    const char* _M_reason;

    friend void __throw_bad_variant_access(const char* __what);
  };

  inline void
  __throw_bad_variant_access(const char* __what)
  { _GLIBCXX_THROW_OR_ABORT(bad_variant_access(__what)); }

  template<typename... _Types>
    class variant
    : private __detail::__variant::_Variant_base<_Types...>,
      private _Enable_default_constructor<
	is_default_constructible_v<
	  variant_alternative_t<0, variant<_Types...>>>, variant<_Types...>>,
      private _Enable_copy_move<
	(is_copy_constructible_v<_Types> && ...),
	(is_copy_constructible_v<_Types> && ...)
	     && (is_move_constructible_v<_Types> && ...)
	     && (is_copy_assignable_v<_Types> && ...),
	(is_move_constructible_v<_Types> && ...),
	(is_move_constructible_v<_Types> && ...)
	     && (is_move_assignable_v<_Types> && ...),
	variant<_Types...>>
    {
    private:
      static_assert(sizeof...(_Types) > 0,
		    "variant must have at least one alternative");
      static_assert(!(std::is_reference_v<_Types> || ...),
		    "variant must have no reference alternative");
      static_assert(!(std::is_void_v<_Types> || ...),
		    "variant must have no void alternative");

      using _Base = __detail::__variant::_Variant_base<_Types...>;
      using _Default_ctor_enabler =
	_Enable_default_constructor<
	  is_default_constructible_v<
	    variant_alternative_t<0, variant<_Types...>>>, variant<_Types...>>;

      template<typename _Tp>
	static constexpr bool
	__exactly_once = __detail::__variant::__exactly_once<_Tp, _Types...>;

      template<typename _Tp>
	static constexpr size_t __accepted_index =
	  __detail::__variant::__accepted_index<_Tp&&, variant>::value;

      template<size_t _Np, bool = _Np < sizeof...(_Types)>
	struct __to_type_impl;

      template<size_t _Np>
	struct __to_type_impl<_Np, true>
	{ using type = variant_alternative_t<_Np, variant>; };

      template<size_t _Np>
	using __to_type = typename __to_type_impl<_Np>::type;

      template<typename _Tp>
	using __accepted_type = __to_type<__accepted_index<_Tp>>;

      template<typename _Tp>
	static constexpr size_t __index_of =
	  __detail::__variant::__index_of_v<_Tp, _Types...>;

    public:
      constexpr variant()
      noexcept(is_nothrow_default_constructible_v<__to_type<0>>) = default;
      variant(const variant&) = default;
      variant(variant&&)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)) = default;

      template<typename _Tp,
	       typename = enable_if_t<!is_same_v<decay_t<_Tp>, variant>>,
	       typename = enable_if_t<(sizeof...(_Types)>0)>,
	       typename = enable_if_t<__exactly_once<__accepted_type<_Tp&&>>
			  && is_constructible_v<__accepted_type<_Tp&&>, _Tp&&>>>
	constexpr
	variant(_Tp&& __t)
	noexcept(is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp&&>)
	: variant(in_place_index<__accepted_index<_Tp&&>>, std::forward<_Tp>(__t))
	{ __glibcxx_assert(holds_alternative<__accepted_type<_Tp&&>>(*this)); }

      template<typename _Tp, typename... _Args,
	       typename = enable_if_t<__exactly_once<_Tp>
			  && is_constructible_v<_Tp, _Args&&...>>>
	constexpr explicit
	variant(in_place_type_t<_Tp>, _Args&&... __args)
	: variant(in_place_index<__index_of<_Tp>>, std::forward<_Args>(__args)...)
	{ __glibcxx_assert(holds_alternative<_Tp>(*this)); }

      template<typename _Tp, typename _Up, typename... _Args,
	       typename = enable_if_t<__exactly_once<_Tp>
			  && is_constructible_v<
			    _Tp, initializer_list<_Up>&, _Args&&...>>>
	constexpr explicit
	variant(in_place_type_t<_Tp>, initializer_list<_Up> __il,
		_Args&&... __args)
	: variant(in_place_index<__index_of<_Tp>>, __il,
		  std::forward<_Args>(__args)...)
	{ __glibcxx_assert(holds_alternative<_Tp>(*this)); }

      template<size_t _Np, typename... _Args,
	       typename = enable_if_t<
		 is_constructible_v<__to_type<_Np>, _Args&&...>>>
	constexpr explicit
	variant(in_place_index_t<_Np>, _Args&&... __args)
	: _Base(in_place_index<_Np>, std::forward<_Args>(__args)...),
	_Default_ctor_enabler(_Enable_default_constructor_tag{})
	{ __glibcxx_assert(index() == _Np); }

      template<size_t _Np, typename _Up, typename... _Args,
	       typename = enable_if_t<is_constructible_v<__to_type<_Np>,
				      initializer_list<_Up>&, _Args&&...>>>
	constexpr explicit
	variant(in_place_index_t<_Np>, initializer_list<_Up> __il,
		_Args&&... __args)
	: _Base(in_place_index<_Np>, __il, std::forward<_Args>(__args)...),
	_Default_ctor_enabler(_Enable_default_constructor_tag{})
	{ __glibcxx_assert(index() == _Np); }

      ~variant() = default;

      variant& operator=(const variant&) = default;
      variant& operator=(variant&&)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)
	  && (is_nothrow_move_assignable_v<_Types> && ...)) = default;

      template<typename _Tp>
	enable_if_t<__exactly_once<__accepted_type<_Tp&&>>
		    && is_constructible_v<__accepted_type<_Tp&&>, _Tp&&>
		    && is_assignable_v<__accepted_type<_Tp&&>&, _Tp&&>
		    && !is_same_v<decay_t<_Tp>, variant>, variant&>
	operator=(_Tp&& __rhs)
	noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp&&>
		 && is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp&&>)
	{
	  constexpr auto __index = __accepted_index<_Tp&&>;
	  if (index() == __index)
	    std::get<__index>(*this) = std::forward<_Tp>(__rhs);
	  else
	    this->emplace<__index>(std::forward<_Tp>(__rhs));
	  __glibcxx_assert(holds_alternative<__accepted_type<_Tp&&>>(*this));
	  return *this;
	}

      template<typename _Tp, typename... _Args>
	enable_if_t<is_constructible_v<_Tp, _Args...> && __exactly_once<_Tp>,
		    _Tp&>
	emplace(_Args&&... __args)
	{
	  auto& ret =
	    this->emplace<__index_of<_Tp>>(std::forward<_Args>(__args)...);
	  __glibcxx_assert(holds_alternative<_Tp>(*this));
	  return ret;
	}

      template<typename _Tp, typename _Up, typename... _Args>
	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
		    && __exactly_once<_Tp>,
		    _Tp&>
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	{
	  auto& ret =
	    this->emplace<__index_of<_Tp>>(__il,
					   std::forward<_Args>(__args)...);
	  __glibcxx_assert(holds_alternative<_Tp>(*this));
	  return ret;
	}

      template<size_t _Np, typename... _Args>
	enable_if_t<is_constructible_v<variant_alternative_t<_Np, variant>,
				       _Args...>,
		    variant_alternative_t<_Np, variant>&>
	emplace(_Args&&... __args)
	{
	  static_assert(_Np < sizeof...(_Types),
			"The index should be in [0, number of alternatives)");
	  this->~variant();
	  __try
	    {
	      ::new (this) variant(in_place_index<_Np>,
				   std::forward<_Args>(__args)...);
	    }
	  __catch (...)
	    {
	      this->_M_index = variant_npos;
	      __throw_exception_again;
	    }
	  __glibcxx_assert(index() == _Np);
	  return std::get<_Np>(*this);
	}

      template<size_t _Np, typename _Up, typename... _Args>
	enable_if_t<is_constructible_v<variant_alternative_t<_Np, variant>,
				       initializer_list<_Up>&, _Args...>,
		    variant_alternative_t<_Np, variant>&>
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	{
	  static_assert(_Np < sizeof...(_Types),
			"The index should be in [0, number of alternatives)");
	  this->~variant();
	  __try
	    {
	      ::new (this) variant(in_place_index<_Np>, __il,
				   std::forward<_Args>(__args)...);
	    }
	  __catch (...)
	    {
	      this->_M_index = variant_npos;
	      __throw_exception_again;
	    }
	  __glibcxx_assert(index() == _Np);
	  return std::get<_Np>(*this);
	}

      constexpr bool valueless_by_exception() const noexcept
      { return !this->_M_valid(); }

      constexpr size_t index() const noexcept
      {
	if (this->_M_index ==
	    typename _Base::_Storage::__index_type(variant_npos))
	  return variant_npos;
	return this->_M_index;
      }

      void
      swap(variant& __rhs)
      noexcept((__is_nothrow_swappable<_Types>::value && ...)
	       && is_nothrow_move_constructible_v<variant>)
      {
	if (this->index() == __rhs.index())
	  {
	    if (this->_M_valid())
	      {
		static constexpr void (*_S_vtable[])(void*, void*) =
		  { &__detail::__variant::__erased_swap<_Types&, _Types&>... };
		_S_vtable[__rhs._M_index](this->_M_storage(),
					  __rhs._M_storage());
	      }
	  }
	else if (!this->_M_valid())
	  {
	    this->_M_destructive_move(std::move(__rhs));
	    __rhs._M_reset();
	  }
	else if (!__rhs._M_valid())
	  {
	    __rhs._M_destructive_move(std::move(*this));
	    this->_M_reset();
	  }
	else
	  {
	    auto __tmp = std::move(__rhs);
	    __rhs._M_destructive_move(std::move(*this));
	    this->_M_destructive_move(std::move(__tmp));
	  }
      }

    private:
#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP, __NAME) \
      template<size_t... __indices> \
	static constexpr bool \
	(*_S_erased_##__NAME[])(const variant&, const variant&) = \
	  { &__detail::__variant::__erased_##__NAME< \
                const variant&, __indices>... }; \
      template<size_t... __indices> \
	constexpr inline bool \
	_M_##__NAME(const variant& __rhs, \
		    std::index_sequence<__indices...>) const \
	{ \
	  auto __lhs_index = this->index(); \
	  auto __rhs_index = __rhs.index(); \
	  if (__lhs_index != __rhs_index || valueless_by_exception()) \
	    /* Modulo addition. */ \
	    return __lhs_index + 1 __OP __rhs_index + 1; \
	  return _S_erased_##__NAME<__indices...>[__lhs_index](*this, __rhs); \
	}

      _VARIANT_RELATION_FUNCTION_TEMPLATE(<, less)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(<=, less_equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(==, equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(!=, not_equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>=, greater_equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>, greater)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE

#ifdef __clang__
    public:
      using _Base::_M_u; // See https://bugs.llvm.org/show_bug.cgi?id=31852
    private:
#endif

      template<size_t _Np, typename _Vp>
	friend constexpr decltype(auto) __detail::__variant::
#if _GLIBCXX_INLINE_VERSION
        __7:: // Required due to PR c++/59256
#endif
	__get(_Vp&& __v);

      template<typename _Vp>
	friend void* __detail::__variant::
#if _GLIBCXX_INLINE_VERSION
        __7:: // Required due to PR c++/59256
#endif
        __get_storage(_Vp&& __v);

#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP) \
      template<typename... _Tp> \
	friend constexpr bool \
	operator __OP(const variant<_Tp...>& __lhs, \
		      const variant<_Tp...>& __rhs);

      _VARIANT_RELATION_FUNCTION_TEMPLATE(<)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(<=)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(==)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(!=)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>=)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE
    };

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&
    get(variant<_Types...>& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(__v);
    }

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&&
    get(variant<_Types...>&& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(std::move(__v));
    }

  template<size_t _Np, typename... _Types>
    constexpr const variant_alternative_t<_Np, variant<_Types...>>&
    get(const variant<_Types...>& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(__v);
    }

  template<size_t _Np, typename... _Types>
    constexpr const variant_alternative_t<_Np, variant<_Types...>>&&
    get(const variant<_Types...>&& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(std::move(__v));
    }

  template<typename _Visitor, typename... _Variants>
    constexpr decltype(auto)
    visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      if ((__variants.valueless_by_exception() || ...))
	__throw_bad_variant_access("Unexpected index");

      using _Result_type =
	decltype(std::forward<_Visitor>(__visitor)(
	    std::get<0>(std::forward<_Variants>(__variants))...));

      constexpr auto& __vtable = __detail::__variant::__gen_vtable<
	_Result_type, _Visitor&&, _Variants&&...>::_S_vtable;

      auto __func_ptr = __vtable._M_access(__variants.index()...);
      return (*__func_ptr)(std::forward<_Visitor>(__visitor),
			   std::forward<_Variants>(__variants)...);
    }

  template<bool, typename... _Types>
    struct __variant_hash_call_base_impl
    {
      size_t
      operator()(const variant<_Types...>& __t) const
      noexcept((is_nothrow_invocable_v<hash<decay_t<_Types>>, _Types> && ...))
      {
	if (!__t.valueless_by_exception())
	  {
	    namespace __edv = __detail::__variant;
	    static constexpr size_t (*_S_vtable[])(void*) =
	      { &__edv::__erased_hash<const _Types&>... };
	    return hash<size_t>{}(__t.index())
	      + _S_vtable[__t.index()](__edv::__get_storage(__t));
	  }
	return hash<size_t>{}(__t.index());
      }
    };

  template<typename... _Types>
    struct __variant_hash_call_base_impl<false, _Types...> {};

  template<typename... _Types>
    using __variant_hash_call_base =
    __variant_hash_call_base_impl<(__poison_hash<remove_const_t<_Types>>::
				   __enable_hash_call &&...), _Types...>;

  template<typename... _Types>
    struct hash<variant<_Types...>>
    : private __detail::__variant::_Variant_hash_base<
        variant<_Types...>, std::index_sequence_for<_Types...>>,
      public __variant_hash_call_base<_Types...>
    {
      using result_type = size_t;
      using argument_type = variant<_Types...>;
    };

  template<>
    struct hash<monostate>
    {
      using result_type = size_t;
      using argument_type = monostate;

      size_t
      operator()(const monostate& __t) const noexcept
      {
	constexpr size_t __magic_monostate_hash = -7777;
	return __magic_monostate_hash;
      }
    };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++17

#endif // _GLIBCXX_VARIANT
@


1.1.1.1.4.3
log
@Mostly merge changes from HEAD upto 20200411
@
text
@d3 1
a3 1
// Copyright (C) 2016-2018 Free Software Foundation, Inc.
a50 2
_GLIBCXX_BEGIN_NAMESPACE_VERSION

d55 2
d68 1
d72 3
a74 1
#define __cpp_lib_variant 201606L
d144 2
d150 1
a301 40
  template<typename... _Types>
    struct _Traits
    {
      static constexpr bool _S_default_ctor =
	  is_default_constructible_v<typename _Nth_type<0, _Types...>::type>;
      static constexpr bool _S_copy_ctor =
	  (is_copy_constructible_v<_Types> && ...);
      static constexpr bool _S_move_ctor =
	  (is_move_constructible_v<_Types> && ...);
      static constexpr bool _S_copy_assign =
	  _S_copy_ctor && _S_move_ctor
	  && (is_copy_assignable_v<_Types> && ...);
      static constexpr bool _S_move_assign =
	  _S_move_ctor
	  && (is_move_assignable_v<_Types> && ...);

      static constexpr bool _S_trivial_dtor =
	  (is_trivially_destructible_v<_Types> && ...);
      static constexpr bool _S_trivial_copy_ctor =
	  (is_trivially_copy_constructible_v<_Types> && ...);
      static constexpr bool _S_trivial_move_ctor =
	  (is_trivially_move_constructible_v<_Types> && ...);
      static constexpr bool _S_trivial_copy_assign =
	  _S_trivial_dtor && (is_trivially_copy_assignable_v<_Types> && ...);
      static constexpr bool _S_trivial_move_assign =
	  _S_trivial_dtor && (is_trivially_move_assignable_v<_Types> && ...);

      // The following nothrow traits are for non-trivial SMFs. Trivial SMFs
      // are always nothrow.
      static constexpr bool _S_nothrow_default_ctor =
	  is_nothrow_default_constructible_v<
	      typename _Nth_type<0, _Types...>::type>;
      static constexpr bool _S_nothrow_copy_ctor = false;
      static constexpr bool _S_nothrow_move_ctor =
	  (is_nothrow_move_constructible_v<_Types> && ...);
      static constexpr bool _S_nothrow_copy_assign = false;
      static constexpr bool _S_nothrow_move_assign =
	  _S_nothrow_move_ctor && (is_nothrow_move_assignable_v<_Types> && ...);
    };

a365 13
      void*
      _M_storage() const
      {
	return const_cast<void*>(static_cast<const void*>(
	    std::addressof(_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
	return this->_M_index != __index_type(variant_npos);
      }

a384 13
      void*
      _M_storage() const
      {
	return const_cast<void*>(static_cast<const void*>(
	    std::addressof(_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
	return this->_M_index != __index_type(variant_npos);
      }

d390 2
d393 7
a399 2
    using _Variant_storage_alias =
	_Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>;
d401 5
a405 8
  // The following are (Copy|Move) (ctor|assign) layers for forwarding
  // triviality and handling non-trivial SMF behaviors.

  template<bool, typename... _Types>
    struct _Copy_ctor_base : _Variant_storage_alias<_Types...>
    {
      using _Base = _Variant_storage_alias<_Types...>;
      using _Base::_Base;
d407 1
a407 2
      _Copy_ctor_base(const _Copy_ctor_base& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor)
d413 1
a413 1
	    _S_vtable[__rhs._M_index](this->_M_storage(), __rhs._M_storage());
d418 2
a419 24
      _Copy_ctor_base(_Copy_ctor_base&&) = default;
      _Copy_ctor_base& operator=(const _Copy_ctor_base&) = default;
      _Copy_ctor_base& operator=(_Copy_ctor_base&&) = default;
    };

  template<typename... _Types>
    struct _Copy_ctor_base<true, _Types...> : _Variant_storage_alias<_Types...>
    {
      using _Base = _Variant_storage_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Copy_ctor_alias =
	_Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>;

  template<bool, typename... _Types>
    struct _Move_ctor_base : _Copy_ctor_alias<_Types...>
    {
      using _Base = _Copy_ctor_alias<_Types...>;
      using _Base::_Base;

      _Move_ctor_base(_Move_ctor_base&& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_move_ctor)
d425 1
a425 1
	    _S_vtable[__rhs._M_index](this->_M_storage(), __rhs._M_storage());
d430 5
a434 41
      void _M_destructive_move(_Move_ctor_base&& __rhs)
      {
	this->~_Move_ctor_base();
	__try
	  {
	    ::new (this) _Move_ctor_base(std::move(__rhs));
	  }
	__catch (...)
	  {
	    this->_M_index = variant_npos;
	    __throw_exception_again;
	  }
      }

      _Move_ctor_base(const _Move_ctor_base&) = default;
      _Move_ctor_base& operator=(const _Move_ctor_base&) = default;
      _Move_ctor_base& operator=(_Move_ctor_base&&) = default;
    };

  template<typename... _Types>
    struct _Move_ctor_base<true, _Types...> : _Copy_ctor_alias<_Types...>
    {
      using _Base = _Copy_ctor_alias<_Types...>;
      using _Base::_Base;

      void _M_destructive_move(_Move_ctor_base&& __rhs)
      {
	this->~_Move_ctor_base();
	::new (this) _Move_ctor_base(std::move(__rhs));
      }
    };

  template<typename... _Types>
    using _Move_ctor_alias =
	_Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>;

  template<bool, typename... _Types>
    struct _Copy_assign_base : _Move_ctor_alias<_Types...>
    {
      using _Base = _Move_ctor_alias<_Types...>;
      using _Base::_Base;
d436 2
a437 3
      _Copy_assign_base&
      operator=(const _Copy_assign_base& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_copy_assign)
d445 1
a445 2
		_S_vtable[__rhs._M_index](this->_M_storage(),
					  __rhs._M_storage());
d450 11
a460 2
	    _Copy_assign_base __tmp(__rhs);
	    this->_M_destructive_move(std::move(__tmp));
d466 13
a478 16
      _Copy_assign_base(const _Copy_assign_base&) = default;
      _Copy_assign_base(_Copy_assign_base&&) = default;
      _Copy_assign_base& operator=(_Copy_assign_base&&) = default;
    };

  template<typename... _Types>
    struct _Copy_assign_base<true, _Types...> : _Move_ctor_alias<_Types...>
    {
      using _Base = _Move_ctor_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Copy_assign_alias =
	_Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign,
			  _Types...>;
d480 4
a483 9
  template<bool, typename... _Types>
    struct _Move_assign_base : _Copy_assign_alias<_Types...>
    {
      using _Base = _Copy_assign_alias<_Types...>;
      using _Base::_Base;

      _Move_assign_base&
      operator=(_Move_assign_base&& __rhs)
	  noexcept(_Traits<_Types...>::_S_nothrow_move_assign)
d491 1
a491 2
		_S_vtable[__rhs._M_index]
		  (this->_M_storage(), __rhs._M_storage());
d496 1
a496 2
	    _Move_assign_base __tmp(std::move(__rhs));
	    this->_M_destructive_move(std::move(__tmp));
a497 1
	__glibcxx_assert(this->_M_index == __rhs._M_index);
d501 6
a506 4
      _Move_assign_base(const _Move_assign_base&) = default;
      _Move_assign_base(_Move_assign_base&&) = default;
      _Move_assign_base& operator=(const _Move_assign_base&) = default;
    };
d508 6
a513 32
  template<typename... _Types>
    struct _Move_assign_base<true, _Types...> : _Copy_assign_alias<_Types...>
    {
      using _Base = _Copy_assign_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Move_assign_alias =
	_Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign,
			  _Types...>;

  template<typename... _Types>
    struct _Variant_base : _Move_assign_alias<_Types...>
    {
      using _Base = _Move_assign_alias<_Types...>;

      constexpr
      _Variant_base()
	  noexcept(_Traits<_Types...>::_S_nothrow_default_ctor)
      : _Variant_base(in_place_index<0>) { }

      template<size_t _Np, typename... _Args>
	constexpr explicit
	_Variant_base(in_place_index_t<_Np> __i, _Args&&... __args)
	: _Base(__i, std::forward<_Args>(__args)...)
	{ }

      _Variant_base(const _Variant_base&) = default;
      _Variant_base(_Variant_base&&) = default;
      _Variant_base& operator=(const _Variant_base&) = default;
      _Variant_base& operator=(_Variant_base&&) = default;
d669 3
a671 2
	    remove_reference_t<decltype(__element)>, tuple<_Variants...>,
	    std::index_sequence<__indices..., __index>>::_S_apply();
d684 2
a685 2
      static constexpr decltype(auto)
      __visit_invoke(_Visitor&& __visitor, _Variants... __vars)
d688 1
a688 1
	    __variant::__get<__indices>(std::forward<_Variants>(__vars))...);
d725 1
d729 2
d732 2
a733 2
    constexpr bool
    holds_alternative(const variant<_Types...>& __v) noexcept
d741 1
a741 1
    constexpr _Tp& get(variant<_Types...>& __v)
d750 1
a750 1
    constexpr _Tp&& get(variant<_Types...>&& __v)
d760 1
a760 1
    constexpr const _Tp& get(const variant<_Types...>& __v)
d769 1
a769 1
    constexpr const _Tp&& get(const variant<_Types...>&& __v)
d779 2
a780 1
    constexpr add_pointer_t<variant_alternative_t<_Np, variant<_Types...>>>
d793 1
a793 1
    constexpr
d807 1
a807 1
    constexpr add_pointer_t<_Tp>
d818 1
a818 1
    constexpr add_pointer_t<const _Tp>
d889 2
a890 2
	__detail::__variant::_Traits<_Types...>::_S_default_ctor,
	  variant<_Types...>>,
d892 7
a898 4
	__detail::__variant::_Traits<_Types...>::_S_copy_ctor,
	__detail::__variant::_Traits<_Types...>::_S_copy_assign,
	__detail::__variant::_Traits<_Types...>::_S_move_ctor,
	__detail::__variant::_Traits<_Types...>::_S_move_assign,
d912 2
a913 2
	  __detail::__variant::_Traits<_Types...>::_S_default_ctor,
	    variant<_Types...>>;
a939 13
      using _Traits = __detail::__variant::_Traits<_Types...>;

      template<typename _Tp>
	struct __is_in_place_tag : false_type { };
      template<typename _Tp>
	struct __is_in_place_tag<in_place_type_t<_Tp>> : true_type { };
      template<size_t _Np>
	struct __is_in_place_tag<in_place_index_t<_Np>> : true_type { };

      template<typename _Tp>
	static constexpr bool __not_in_place_tag
	  = !__is_in_place_tag<decay_t<_Tp>>::value;

d941 5
a945 6
      variant() = default;
      variant(const variant& __rhs) = default;
      variant(variant&&) = default;
      variant& operator=(const variant&) = default;
      variant& operator=(variant&&) = default;
      ~variant() = default;
a949 1
	       typename = enable_if_t<__not_in_place_tag<_Tp>>,
d955 1
a955 2
	: variant(in_place_index<__accepted_index<_Tp&&>>,
		  std::forward<_Tp>(__t))
d963 1
a963 2
	: variant(in_place_index<__index_of<_Tp>>,
		  std::forward<_Args>(__args)...)
d996 7
d1097 1
a1097 1
	    typename _Base::__index_type(variant_npos))
d1141 1
a1141 1
		const variant&, __indices>... }; \
d1143 1
a1143 1
	constexpr bool \
d1171 5
a1175 1
	friend constexpr decltype(auto) __detail::__variant::__get(_Vp&& __v);
d1178 5
a1182 1
	friend void* __detail::__variant::__get_storage(_Vp&& __v);
d1293 1
a1293 1
	variant<_Types...>, std::index_sequence_for<_Types...>>,
d1296 2
a1297 2
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = variant<_Types...>;
d1303 2
a1304 2
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = monostate;
a1313 5
  template<typename... _Types>
    struct __is_fast_hash<hash<variant<_Types...>>>
    : bool_constant<(__is_fast_hash<_Types>::value && ...)>
    { };

@


1.1.1.1.2.1
log
@file variant was added on branch pgoyette-compat on 2019-01-26 21:59:39 +0000
@
text
@d1 1319
@


1.1.1.1.2.2
log
@Sync with HEAD
@
text
@a0 1319
// <variant> -*- C++ -*-

// Copyright (C) 2016-2017 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @@file variant
 *  This is the <variant> C++ Library header.
 */

#ifndef _GLIBCXX_VARIANT
#define _GLIBCXX_VARIANT 1

#pragma GCC system_header

#if __cplusplus >= 201703L

#include <type_traits>
#include <utility>
#include <bits/enable_special_members.h>
#include <bits/functexcept.h>
#include <bits/move.h>
#include <bits/functional_hash.h>
#include <bits/invoke.h>
#include <ext/aligned_buffer.h>
#include <bits/parse_numbers.h>
#include <bits/stl_iterator_base_types.h>
#include <bits/stl_iterator_base_funcs.h>
#include <bits/stl_construct.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __detail
{
namespace __variant
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<size_t _Np, typename... _Types>
    struct _Nth_type;

  template<size_t _Np, typename _First, typename... _Rest>
    struct _Nth_type<_Np, _First, _Rest...>
    : _Nth_type<_Np-1, _Rest...> { };

  template<typename _First, typename... _Rest>
    struct _Nth_type<0, _First, _Rest...>
    { using type = _First; };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __variant
} // namespace __detail

_GLIBCXX_BEGIN_NAMESPACE_VERSION

#define __cpp_lib_variant 201603

  template<typename... _Types> class tuple;
  template<typename... _Types> class variant;
  template <typename> struct hash;

  template<typename _Variant>
    struct variant_size;

  template<typename _Variant>
    struct variant_size<const _Variant> : variant_size<_Variant> {};

  template<typename _Variant>
    struct variant_size<volatile _Variant> : variant_size<_Variant> {};

  template<typename _Variant>
    struct variant_size<const volatile _Variant> : variant_size<_Variant> {};

  template<typename... _Types>
    struct variant_size<variant<_Types...>>
    : std::integral_constant<size_t, sizeof...(_Types)> {};

  template<typename _Variant>
    inline constexpr size_t variant_size_v = variant_size<_Variant>::value;

  template<size_t _Np, typename _Variant>
    struct variant_alternative;

  template<size_t _Np, typename _First, typename... _Rest>
    struct variant_alternative<_Np, variant<_First, _Rest...>>
    : variant_alternative<_Np-1, variant<_Rest...>> {};

  template<typename _First, typename... _Rest>
    struct variant_alternative<0, variant<_First, _Rest...>>
    { using type = _First; };

  template<size_t _Np, typename _Variant>
    using variant_alternative_t =
      typename variant_alternative<_Np, _Variant>::type;

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, const _Variant>
    { using type = add_const_t<variant_alternative_t<_Np, _Variant>>; };

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, volatile _Variant>
    { using type = add_volatile_t<variant_alternative_t<_Np, _Variant>>; };

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, const volatile _Variant>
    { using type = add_cv_t<variant_alternative_t<_Np, _Variant>>; };

  inline constexpr size_t variant_npos = -1;

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&
    get(variant<_Types...>&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&&
    get(variant<_Types...>&&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>> const&
    get(const variant<_Types...>&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>> const&&
    get(const variant<_Types...>&&);

_GLIBCXX_END_NAMESPACE_VERSION

namespace __detail
{
namespace __variant
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
  // Returns the first apparence of _Tp in _Types.
  // Returns sizeof...(_Types) if _Tp is not in _Types.
  template<typename _Tp, typename... _Types>
    struct __index_of : std::integral_constant<size_t, 0> {};

  template<typename _Tp, typename... _Types>
    inline constexpr size_t __index_of_v = __index_of<_Tp, _Types...>::value;

  template<typename _Tp, typename _First, typename... _Rest>
    struct __index_of<_Tp, _First, _Rest...> :
      std::integral_constant<size_t, is_same_v<_Tp, _First>
	? 0 : __index_of_v<_Tp, _Rest...> + 1> {};

  // _Uninitialized<T> is guaranteed to be a literal type, even if T is not.
  // We have to do this, because [basic.types]p10.5.3 (n4606) is not implemented
  // yet. When it's implemented, _Uninitialized<T> can be changed to the alias
  // to T, therefore equivalent to being removed entirely.
  //
  // Another reason we may not want to remove _Uninitialzied<T> may be that, we
  // want _Uninitialized<T> to be trivially destructible, no matter whether T
  // is; but we will see.
  template<typename _Type, bool = std::is_literal_type_v<_Type>>
    struct _Uninitialized;

  template<typename _Type>
    struct _Uninitialized<_Type, true>
    {
      template<typename... _Args>
      constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args)
      : _M_storage(std::forward<_Args>(__args)...)
      { }

      constexpr const _Type& _M_get() const &
      { return _M_storage; }

      constexpr _Type& _M_get() &
      { return _M_storage; }

      constexpr const _Type&& _M_get() const &&
      { return std::move(_M_storage); }

      constexpr _Type&& _M_get() &&
      { return std::move(_M_storage); }

      _Type _M_storage;
    };

  template<typename _Type>
    struct _Uninitialized<_Type, false>
    {
      template<typename... _Args>
      constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args)
      { ::new (&_M_storage) _Type(std::forward<_Args>(__args)...); }

      const _Type& _M_get() const &
      { return *_M_storage._M_ptr(); }

      _Type& _M_get() &
      { return *_M_storage._M_ptr(); }

      const _Type&& _M_get() const &&
      { return std::move(*_M_storage._M_ptr()); }

      _Type&& _M_get() &&
      { return std::move(*_M_storage._M_ptr()); }

      __gnu_cxx::__aligned_membuf<_Type> _M_storage;
    };

  template<typename _Ref>
    _Ref __ref_cast(void* __ptr)
    {
      return static_cast<_Ref>(*static_cast<remove_reference_t<_Ref>*>(__ptr));
    }

  template<typename _Union>
    constexpr decltype(auto) __get(in_place_index_t<0>, _Union&& __u)
    { return std::forward<_Union>(__u)._M_first._M_get(); }

  template<size_t _Np, typename _Union>
    constexpr decltype(auto) __get(in_place_index_t<_Np>, _Union&& __u)
    {
      return __variant::__get(in_place_index<_Np-1>,
			      std::forward<_Union>(__u)._M_rest);
    }

  // Returns the typed storage for __v.
  template<size_t _Np, typename _Variant>
    constexpr decltype(auto) __get(_Variant&& __v)
    {
      return __variant::__get(std::in_place_index<_Np>,
			      std::forward<_Variant>(__v)._M_u);
    }

  // Various functions as "vtable" entries, where those vtables are used by
  // polymorphic operations.
  template<typename _Lhs, typename _Rhs>
    void
    __erased_ctor(void* __lhs, void* __rhs)
    {
      using _Type = remove_reference_t<_Lhs>;
      ::new (__lhs) _Type(__variant::__ref_cast<_Rhs>(__rhs));
    }

  template<typename _Variant, size_t _Np>
    void
    __erased_dtor(_Variant&& __v)
    { std::_Destroy(std::__addressof(__variant::__get<_Np>(__v))); }

  template<typename _Lhs, typename _Rhs>
    void
    __erased_assign(void* __lhs, void* __rhs)
    {
      __variant::__ref_cast<_Lhs>(__lhs) = __variant::__ref_cast<_Rhs>(__rhs);
    }

  template<typename _Lhs, typename _Rhs>
    void
    __erased_swap(void* __lhs, void* __rhs)
    {
      using std::swap;
      swap(__variant::__ref_cast<_Lhs>(__lhs),
	   __variant::__ref_cast<_Rhs>(__rhs));
    }

#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP, __NAME) \
  template<typename _Variant, size_t _Np> \
    constexpr bool \
    __erased_##__NAME(const _Variant& __lhs, const _Variant& __rhs) \
    { \
      return __variant::__get<_Np>(std::forward<_Variant>(__lhs)) \
	  __OP __variant::__get<_Np>(std::forward<_Variant>(__rhs)); \
    }

  _VARIANT_RELATION_FUNCTION_TEMPLATE(<, less)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(<=, less_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(==, equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(!=, not_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>=, greater_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>, greater)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE

  template<typename _Tp>
    size_t
    __erased_hash(void* __t)
    {
      return std::hash<remove_cv_t<remove_reference_t<_Tp>>>{}(
	  __variant::__ref_cast<_Tp>(__t));
    }

  // Defines members and ctors.
  template<typename... _Types>
    union _Variadic_union { };

  template<typename _First, typename... _Rest>
    union _Variadic_union<_First, _Rest...>
    {
      constexpr _Variadic_union() : _M_rest() { }

      template<typename... _Args>
	constexpr _Variadic_union(in_place_index_t<0>, _Args&&... __args)
	: _M_first(in_place_index<0>, std::forward<_Args>(__args)...)
	{ }

      template<size_t _Np, typename... _Args>
	constexpr _Variadic_union(in_place_index_t<_Np>, _Args&&... __args)
	: _M_rest(in_place_index<_Np-1>, std::forward<_Args>(__args)...)
	{ }

      _Uninitialized<_First> _M_first;
      _Variadic_union<_Rest...> _M_rest;
    };

  // Defines index and the dtor, possibly trivial.
  template<bool __trivially_destructible, typename... _Types>
    struct _Variant_storage;

  template <typename... _Types>
  using __select_index =
    typename __select_int::_Select_int_base<sizeof...(_Types) + 1,
					    unsigned char,
					    unsigned short>::type::value_type;

  template<typename... _Types>
    struct _Variant_storage<false, _Types...>
    {
      template<size_t... __indices>
	static constexpr void (*_S_vtable[])(const _Variant_storage&) =
	    { &__erased_dtor<const _Variant_storage&, __indices>... };

      constexpr _Variant_storage() : _M_index(variant_npos) { }

      template<size_t _Np, typename... _Args>
	constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
	: _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...),
	_M_index(_Np)
	{ }

      template<size_t... __indices>
	constexpr void _M_reset_impl(std::index_sequence<__indices...>)
	{
	  if (_M_index != __index_type(variant_npos))
	    _S_vtable<__indices...>[_M_index](*this);
	}

      void _M_reset()
      {
	_M_reset_impl(std::index_sequence_for<_Types...>{});
	_M_index = variant_npos;
      }

      ~_Variant_storage()
      { _M_reset(); }

      _Variadic_union<_Types...> _M_u;
      using __index_type = __select_index<_Types...>;
      __index_type _M_index;
    };

  template<typename... _Types>
    struct _Variant_storage<true, _Types...>
    {
      constexpr _Variant_storage() : _M_index(variant_npos) { }

      template<size_t _Np, typename... _Args>
	constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
	: _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...),
	_M_index(_Np)
	{ }

      void _M_reset()
      { _M_index = variant_npos; }

      _Variadic_union<_Types...> _M_u;
      using __index_type = __select_index<_Types...>;
      __index_type _M_index;
    };

  // Helps SFINAE on special member functions. Otherwise it can live in variant
  // class.
  template<typename... _Types>
    struct _Variant_base :
      _Variant_storage<(std::is_trivially_destructible_v<_Types> && ...),
			_Types...>
    {
      using _Storage =
	  _Variant_storage<(std::is_trivially_destructible_v<_Types> && ...),
			    _Types...>;

      constexpr
      _Variant_base()
      noexcept(is_nothrow_default_constructible_v<
		 variant_alternative_t<0, variant<_Types...>>>)
      : _Variant_base(in_place_index<0>) { }

      _Variant_base(const _Variant_base& __rhs)
      {
	if (__rhs._M_valid())
	  {
	    static constexpr void (*_S_vtable[])(void*, void*) =
	      { &__erased_ctor<_Types&, const _Types&>... };
	    _S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	    this->_M_index = __rhs._M_index;
	  }
      }

      _Variant_base(_Variant_base&& __rhs)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...))
      {
	if (__rhs._M_valid())
	  {
	    static constexpr void (*_S_vtable[])(void*, void*) =
	      { &__erased_ctor<_Types&, _Types&&>... };
	    _S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	    this->_M_index = __rhs._M_index;
	  }
      }

      template<size_t _Np, typename... _Args>
	constexpr explicit
	_Variant_base(in_place_index_t<_Np> __i, _Args&&... __args)
	: _Storage(__i, std::forward<_Args>(__args)...)
	{ }

      _Variant_base&
      operator=(const _Variant_base& __rhs)
      {
	if (this->_M_index == __rhs._M_index)
	  {
	    if (__rhs._M_valid())
	      {
		static constexpr void (*_S_vtable[])(void*, void*) =
		  { &__erased_assign<_Types&, const _Types&>... };
		_S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	      }
	  }
	else
	  {
	    _Variant_base __tmp(__rhs);
	    this->~_Variant_base();
	    __try
	      {
		::new (this) _Variant_base(std::move(__tmp));
	      }
	    __catch (...)
	      {
		this->_M_index = variant_npos;
		__throw_exception_again;
	      }
	  }
	__glibcxx_assert(this->_M_index == __rhs._M_index);
	return *this;
      }

      void _M_destructive_move(_Variant_base&& __rhs)
      {
	this->~_Variant_base();
	__try
	  {
	    ::new (this) _Variant_base(std::move(__rhs));
	  }
	__catch (...)
	  {
	    this->_M_index = variant_npos;
	    __throw_exception_again;
	  }
      }

      _Variant_base&
      operator=(_Variant_base&& __rhs)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)
	  && (is_nothrow_move_assignable_v<_Types> && ...))
      {
	if (this->_M_index == __rhs._M_index)
	  {
	    if (__rhs._M_valid())
	      {
		static constexpr void (*_S_vtable[])(void*, void*) =
		  { &__erased_assign<_Types&, _Types&&>... };
		_S_vtable[__rhs._M_index](_M_storage(), __rhs._M_storage());
	      }
	  }
	else
	  {
	    _M_destructive_move(std::move(__rhs));
	  }
	return *this;
      }

      void*
      _M_storage() const
      {
	return const_cast<void*>(static_cast<const void*>(
	    std::addressof(_Storage::_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
	return this->_M_index !=
	  typename _Storage::__index_type(variant_npos);
      }
    };

  // For how many times does _Tp appear in _Tuple?
  template<typename _Tp, typename _Tuple>
    struct __tuple_count;

  template<typename _Tp, typename _Tuple>
    inline constexpr size_t __tuple_count_v =
      __tuple_count<_Tp, _Tuple>::value;

  template<typename _Tp, typename... _Types>
    struct __tuple_count<_Tp, tuple<_Types...>>
    : integral_constant<size_t, 0> { };

  template<typename _Tp, typename _First, typename... _Rest>
    struct __tuple_count<_Tp, tuple<_First, _Rest...>>
    : integral_constant<
	size_t,
	__tuple_count_v<_Tp, tuple<_Rest...>> + is_same_v<_Tp, _First>> { };

  // TODO: Reuse this in <tuple> ?
  template<typename _Tp, typename... _Types>
    inline constexpr bool __exactly_once =
      __tuple_count_v<_Tp, tuple<_Types...>> == 1;

  // Takes _Types and create an overloaded _S_fun for each type.
  // If a type appears more than once in _Types, create only one overload.
  template<typename... _Types>
    struct __overload_set
    { static void _S_fun(); };

  template<typename _First, typename... _Rest>
    struct __overload_set<_First, _Rest...> : __overload_set<_Rest...>
    {
      using __overload_set<_Rest...>::_S_fun;
      static integral_constant<size_t, sizeof...(_Rest)> _S_fun(_First);
    };

  template<typename... _Rest>
    struct __overload_set<void, _Rest...> : __overload_set<_Rest...>
    {
      using __overload_set<_Rest...>::_S_fun;
    };

  // Helper for variant(_Tp&&) and variant::operator=(_Tp&&).
  // __accepted_index maps the arbitrary _Tp to an alternative type in _Variant.
  template<typename _Tp, typename _Variant, typename = void>
    struct __accepted_index
    { static constexpr size_t value = variant_npos; };

  template<typename _Tp, typename... _Types>
    struct __accepted_index<
      _Tp, variant<_Types...>,
      decltype(__overload_set<_Types...>::_S_fun(std::declval<_Tp>()),
	       std::declval<void>())>
    {
      static constexpr size_t value = sizeof...(_Types) - 1
	- decltype(__overload_set<_Types...>::
		   _S_fun(std::declval<_Tp>()))::value;
    };

  // Returns the raw storage for __v.
  template<typename _Variant>
    void* __get_storage(_Variant&& __v)
    { return __v._M_storage(); }

  // Used for storing multi-dimensional vtable.
  template<typename _Tp, size_t... _Dimensions>
    struct _Multi_array
    {
      constexpr const _Tp&
      _M_access() const
      { return _M_data; }

      _Tp _M_data;
    };

  template<typename _Tp, size_t __first, size_t... __rest>
    struct _Multi_array<_Tp, __first, __rest...>
    {
      template<typename... _Args>
	constexpr const _Tp&
	_M_access(size_t __first_index, _Args... __rest_indices) const
	{ return _M_arr[__first_index]._M_access(__rest_indices...); }

      _Multi_array<_Tp, __rest...> _M_arr[__first];
    };

  // Creates a multi-dimensional vtable recursively.
  //
  // For example,
  // visit([](auto, auto){},
  //       variant<int, char>(),  // typedef'ed as V1
  //       variant<float, double, long double>())  // typedef'ed as V2
  // will trigger instantiations of:
  // __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 2, 3>,
  //                   tuple<V1&&, V2&&>, std::index_sequence<>>
  //   __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 3>,
  //                     tuple<V1&&, V2&&>, std::index_sequence<0>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<0, 0>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<0, 1>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<0, 2>>
  //   __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&), 3>,
  //                     tuple<V1&&, V2&&>, std::index_sequence<1>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<1, 0>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<1, 1>>
  //     __gen_vtable_impl<_Multi_array<void(*)(V1&&, V2&&)>,
  //                       tuple<V1&&, V2&&>, std::index_sequence<1, 2>>
  // The returned multi-dimensional vtable can be fast accessed by the visitor
  // using index calculation.
  template<typename _Array_type, typename _Variant_tuple, typename _Index_seq>
    struct __gen_vtable_impl;

  template<typename _Result_type, typename _Visitor, size_t... __dimensions,
	   typename... _Variants, size_t... __indices>
    struct __gen_vtable_impl<
	_Multi_array<_Result_type (*)(_Visitor, _Variants...), __dimensions...>,
	tuple<_Variants...>, std::index_sequence<__indices...>>
    {
      using _Next =
	  remove_reference_t<typename _Nth_type<sizeof...(__indices),
			     _Variants...>::type>;
      using _Array_type =
	  _Multi_array<_Result_type (*)(_Visitor, _Variants...),
		       __dimensions...>;

      static constexpr _Array_type
      _S_apply()
      {
	_Array_type __vtable{};
	_S_apply_all_alts(
	  __vtable, make_index_sequence<variant_size_v<_Next>>());
	return __vtable;
      }

      template<size_t... __var_indices>
	static constexpr void
	_S_apply_all_alts(_Array_type& __vtable,
			  std::index_sequence<__var_indices...>)
	{
	  (_S_apply_single_alt<__var_indices>(
	     __vtable._M_arr[__var_indices]), ...);
	}

      template<size_t __index, typename _Tp>
	static constexpr void
	_S_apply_single_alt(_Tp& __element)
	{
	  using _Alternative = variant_alternative_t<__index, _Next>;
	  __element = __gen_vtable_impl<
	    remove_reference_t<
	      decltype(__element)>, tuple<_Variants...>,
	      std::index_sequence<__indices..., __index>>::_S_apply();
	}
    };

  template<typename _Result_type, typename _Visitor, typename... _Variants,
	   size_t... __indices>
    struct __gen_vtable_impl<
      _Multi_array<_Result_type (*)(_Visitor, _Variants...)>,
		   tuple<_Variants...>, std::index_sequence<__indices...>>
    {
      using _Array_type =
	  _Multi_array<_Result_type (*)(_Visitor&&, _Variants...)>;

      decltype(auto)
      static constexpr __visit_invoke(_Visitor&& __visitor, _Variants... __vars)
      {
	return std::__invoke(std::forward<_Visitor>(__visitor),
	    std::get<__indices>(std::forward<_Variants>(__vars))...);
      }

      static constexpr auto
      _S_apply()
      { return _Array_type{&__visit_invoke}; }
    };

  template<typename _Result_type, typename _Visitor, typename... _Variants>
    struct __gen_vtable
    {
      using _Func_ptr = _Result_type (*)(_Visitor&&, _Variants...);
      using _Array_type =
	  _Multi_array<_Func_ptr,
		       variant_size_v<remove_reference_t<_Variants>>...>;

      static constexpr _Array_type
      _S_apply()
      {
	return __gen_vtable_impl<_Array_type, tuple<_Variants...>,
				 std::index_sequence<>>::_S_apply();
      }

      static constexpr auto _S_vtable = _S_apply();
    };

  template<size_t _Np, typename _Tp>
    struct _Base_dedup : public _Tp { };

  template<typename _Variant, typename __indices>
    struct _Variant_hash_base;

  template<typename... _Types, size_t... __indices>
    struct _Variant_hash_base<variant<_Types...>,
			      std::index_sequence<__indices...>>
    : _Base_dedup<__indices, __poison_hash<remove_const_t<_Types>>>... { };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __variant
} // namespace __detail

_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<typename _Tp, typename... _Types>
    inline constexpr bool holds_alternative(const variant<_Types...>& __v)
    noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      return __v.index() == __detail::__variant::__index_of_v<_Tp, _Types...>;
    }

  template<typename _Tp, typename... _Types>
    constexpr inline _Tp& get(variant<_Types...>& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(__v);
    }

  template<typename _Tp, typename... _Types>
    constexpr inline _Tp&& get(variant<_Types...>&& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	std::move(__v));
    }

  template<typename _Tp, typename... _Types>
    constexpr inline const _Tp& get(const variant<_Types...>& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(__v);
    }

  template<typename _Tp, typename... _Types>
    constexpr inline const _Tp&& get(const variant<_Types...>&& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	std::move(__v));
    }

  template<size_t _Np, typename... _Types>
    constexpr inline
    add_pointer_t<variant_alternative_t<_Np, variant<_Types...>>>
    get_if(variant<_Types...>* __ptr) noexcept
    {
      using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>;
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      static_assert(!is_void_v<_Alternative_type>, "_Tp should not be void");
      if (__ptr && __ptr->index() == _Np)
	return &__detail::__variant::__get<_Np>(*__ptr);
      return nullptr;
    }

  template<size_t _Np, typename... _Types>
    constexpr inline
    add_pointer_t<const variant_alternative_t<_Np, variant<_Types...>>>
    get_if(const variant<_Types...>* __ptr) noexcept
    {
      using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>;
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      static_assert(!is_void_v<_Alternative_type>, "_Tp should not be void");
      if (__ptr && __ptr->index() == _Np)
	return &__detail::__variant::__get<_Np>(*__ptr);
      return nullptr;
    }

  template<typename _Tp, typename... _Types>
    constexpr inline add_pointer_t<_Tp>
    get_if(variant<_Types...>* __ptr) noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get_if<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	  __ptr);
    }

  template<typename _Tp, typename... _Types>
    constexpr inline add_pointer_t<const _Tp>
    get_if(const variant<_Types...>* __ptr)
    noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
		    "T should occur for exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp should not be void");
      return std::get_if<__detail::__variant::__index_of_v<_Tp, _Types...>>(
	  __ptr);
    }

  struct monostate { };

#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP, __NAME) \
  template<typename... _Types> \
    constexpr bool operator __OP(const variant<_Types...>& __lhs, \
				 const variant<_Types...>& __rhs) \
    { \
      return __lhs._M_##__NAME(__rhs, std::index_sequence_for<_Types...>{}); \
    } \
\
  constexpr bool operator __OP(monostate, monostate) noexcept \
  { return 0 __OP 0; }

  _VARIANT_RELATION_FUNCTION_TEMPLATE(<, less)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(<=, less_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(==, equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(!=, not_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>=, greater_equal)
  _VARIANT_RELATION_FUNCTION_TEMPLATE(>, greater)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE

  template<typename _Visitor, typename... _Variants>
    constexpr decltype(auto) visit(_Visitor&&, _Variants&&...);

  template<typename... _Types>
    inline enable_if_t<(is_move_constructible_v<_Types> && ...)
			&& (is_swappable_v<_Types> && ...)>
    swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

  template<typename... _Types>
    enable_if_t<!((is_move_constructible_v<_Types> && ...)
		   && (is_swappable_v<_Types> && ...))>
    swap(variant<_Types...>&, variant<_Types...>&) = delete;

  class bad_variant_access : public exception
  {
  public:
    bad_variant_access() noexcept : _M_reason("Unknown reason") { }
    const char* what() const noexcept override
    { return _M_reason; }

  private:
    bad_variant_access(const char* __reason) : _M_reason(__reason) { }

    const char* _M_reason;

    friend void __throw_bad_variant_access(const char* __what);
  };

  inline void
  __throw_bad_variant_access(const char* __what)
  { _GLIBCXX_THROW_OR_ABORT(bad_variant_access(__what)); }

  template<typename... _Types>
    class variant
    : private __detail::__variant::_Variant_base<_Types...>,
      private _Enable_default_constructor<
	is_default_constructible_v<
	  variant_alternative_t<0, variant<_Types...>>>, variant<_Types...>>,
      private _Enable_copy_move<
	(is_copy_constructible_v<_Types> && ...),
	(is_copy_constructible_v<_Types> && ...)
	     && (is_move_constructible_v<_Types> && ...)
	     && (is_copy_assignable_v<_Types> && ...),
	(is_move_constructible_v<_Types> && ...),
	(is_move_constructible_v<_Types> && ...)
	     && (is_move_assignable_v<_Types> && ...),
	variant<_Types...>>
    {
    private:
      static_assert(sizeof...(_Types) > 0,
		    "variant must have at least one alternative");
      static_assert(!(std::is_reference_v<_Types> || ...),
		    "variant must have no reference alternative");
      static_assert(!(std::is_void_v<_Types> || ...),
		    "variant must have no void alternative");

      using _Base = __detail::__variant::_Variant_base<_Types...>;
      using _Default_ctor_enabler =
	_Enable_default_constructor<
	  is_default_constructible_v<
	    variant_alternative_t<0, variant<_Types...>>>, variant<_Types...>>;

      template<typename _Tp>
	static constexpr bool
	__exactly_once = __detail::__variant::__exactly_once<_Tp, _Types...>;

      template<typename _Tp>
	static constexpr size_t __accepted_index =
	  __detail::__variant::__accepted_index<_Tp&&, variant>::value;

      template<size_t _Np, bool = _Np < sizeof...(_Types)>
	struct __to_type_impl;

      template<size_t _Np>
	struct __to_type_impl<_Np, true>
	{ using type = variant_alternative_t<_Np, variant>; };

      template<size_t _Np>
	using __to_type = typename __to_type_impl<_Np>::type;

      template<typename _Tp>
	using __accepted_type = __to_type<__accepted_index<_Tp>>;

      template<typename _Tp>
	static constexpr size_t __index_of =
	  __detail::__variant::__index_of_v<_Tp, _Types...>;

    public:
      constexpr variant()
      noexcept(is_nothrow_default_constructible_v<__to_type<0>>) = default;
      variant(const variant&) = default;
      variant(variant&&)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)) = default;

      template<typename _Tp,
	       typename = enable_if_t<!is_same_v<decay_t<_Tp>, variant>>,
	       typename = enable_if_t<(sizeof...(_Types)>0)>,
	       typename = enable_if_t<__exactly_once<__accepted_type<_Tp&&>>
			  && is_constructible_v<__accepted_type<_Tp&&>, _Tp&&>>>
	constexpr
	variant(_Tp&& __t)
	noexcept(is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp&&>)
	: variant(in_place_index<__accepted_index<_Tp&&>>, std::forward<_Tp>(__t))
	{ __glibcxx_assert(holds_alternative<__accepted_type<_Tp&&>>(*this)); }

      template<typename _Tp, typename... _Args,
	       typename = enable_if_t<__exactly_once<_Tp>
			  && is_constructible_v<_Tp, _Args&&...>>>
	constexpr explicit
	variant(in_place_type_t<_Tp>, _Args&&... __args)
	: variant(in_place_index<__index_of<_Tp>>, std::forward<_Args>(__args)...)
	{ __glibcxx_assert(holds_alternative<_Tp>(*this)); }

      template<typename _Tp, typename _Up, typename... _Args,
	       typename = enable_if_t<__exactly_once<_Tp>
			  && is_constructible_v<
			    _Tp, initializer_list<_Up>&, _Args&&...>>>
	constexpr explicit
	variant(in_place_type_t<_Tp>, initializer_list<_Up> __il,
		_Args&&... __args)
	: variant(in_place_index<__index_of<_Tp>>, __il,
		  std::forward<_Args>(__args)...)
	{ __glibcxx_assert(holds_alternative<_Tp>(*this)); }

      template<size_t _Np, typename... _Args,
	       typename = enable_if_t<
		 is_constructible_v<__to_type<_Np>, _Args&&...>>>
	constexpr explicit
	variant(in_place_index_t<_Np>, _Args&&... __args)
	: _Base(in_place_index<_Np>, std::forward<_Args>(__args)...),
	_Default_ctor_enabler(_Enable_default_constructor_tag{})
	{ __glibcxx_assert(index() == _Np); }

      template<size_t _Np, typename _Up, typename... _Args,
	       typename = enable_if_t<is_constructible_v<__to_type<_Np>,
				      initializer_list<_Up>&, _Args&&...>>>
	constexpr explicit
	variant(in_place_index_t<_Np>, initializer_list<_Up> __il,
		_Args&&... __args)
	: _Base(in_place_index<_Np>, __il, std::forward<_Args>(__args)...),
	_Default_ctor_enabler(_Enable_default_constructor_tag{})
	{ __glibcxx_assert(index() == _Np); }

      ~variant() = default;

      variant& operator=(const variant&) = default;
      variant& operator=(variant&&)
      noexcept((is_nothrow_move_constructible_v<_Types> && ...)
	  && (is_nothrow_move_assignable_v<_Types> && ...)) = default;

      template<typename _Tp>
	enable_if_t<__exactly_once<__accepted_type<_Tp&&>>
		    && is_constructible_v<__accepted_type<_Tp&&>, _Tp&&>
		    && is_assignable_v<__accepted_type<_Tp&&>&, _Tp&&>
		    && !is_same_v<decay_t<_Tp>, variant>, variant&>
	operator=(_Tp&& __rhs)
	noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp&&>
		 && is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp&&>)
	{
	  constexpr auto __index = __accepted_index<_Tp&&>;
	  if (index() == __index)
	    std::get<__index>(*this) = std::forward<_Tp>(__rhs);
	  else
	    this->emplace<__index>(std::forward<_Tp>(__rhs));
	  __glibcxx_assert(holds_alternative<__accepted_type<_Tp&&>>(*this));
	  return *this;
	}

      template<typename _Tp, typename... _Args>
	enable_if_t<is_constructible_v<_Tp, _Args...> && __exactly_once<_Tp>,
		    _Tp&>
	emplace(_Args&&... __args)
	{
	  auto& ret =
	    this->emplace<__index_of<_Tp>>(std::forward<_Args>(__args)...);
	  __glibcxx_assert(holds_alternative<_Tp>(*this));
	  return ret;
	}

      template<typename _Tp, typename _Up, typename... _Args>
	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
		    && __exactly_once<_Tp>,
		    _Tp&>
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	{
	  auto& ret =
	    this->emplace<__index_of<_Tp>>(__il,
					   std::forward<_Args>(__args)...);
	  __glibcxx_assert(holds_alternative<_Tp>(*this));
	  return ret;
	}

      template<size_t _Np, typename... _Args>
	enable_if_t<is_constructible_v<variant_alternative_t<_Np, variant>,
				       _Args...>,
		    variant_alternative_t<_Np, variant>&>
	emplace(_Args&&... __args)
	{
	  static_assert(_Np < sizeof...(_Types),
			"The index should be in [0, number of alternatives)");
	  this->~variant();
	  __try
	    {
	      ::new (this) variant(in_place_index<_Np>,
				   std::forward<_Args>(__args)...);
	    }
	  __catch (...)
	    {
	      this->_M_index = variant_npos;
	      __throw_exception_again;
	    }
	  __glibcxx_assert(index() == _Np);
	  return std::get<_Np>(*this);
	}

      template<size_t _Np, typename _Up, typename... _Args>
	enable_if_t<is_constructible_v<variant_alternative_t<_Np, variant>,
				       initializer_list<_Up>&, _Args...>,
		    variant_alternative_t<_Np, variant>&>
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	{
	  static_assert(_Np < sizeof...(_Types),
			"The index should be in [0, number of alternatives)");
	  this->~variant();
	  __try
	    {
	      ::new (this) variant(in_place_index<_Np>, __il,
				   std::forward<_Args>(__args)...);
	    }
	  __catch (...)
	    {
	      this->_M_index = variant_npos;
	      __throw_exception_again;
	    }
	  __glibcxx_assert(index() == _Np);
	  return std::get<_Np>(*this);
	}

      constexpr bool valueless_by_exception() const noexcept
      { return !this->_M_valid(); }

      constexpr size_t index() const noexcept
      {
	if (this->_M_index ==
	    typename _Base::_Storage::__index_type(variant_npos))
	  return variant_npos;
	return this->_M_index;
      }

      void
      swap(variant& __rhs)
      noexcept((__is_nothrow_swappable<_Types>::value && ...)
	       && is_nothrow_move_constructible_v<variant>)
      {
	if (this->index() == __rhs.index())
	  {
	    if (this->_M_valid())
	      {
		static constexpr void (*_S_vtable[])(void*, void*) =
		  { &__detail::__variant::__erased_swap<_Types&, _Types&>... };
		_S_vtable[__rhs._M_index](this->_M_storage(),
					  __rhs._M_storage());
	      }
	  }
	else if (!this->_M_valid())
	  {
	    this->_M_destructive_move(std::move(__rhs));
	    __rhs._M_reset();
	  }
	else if (!__rhs._M_valid())
	  {
	    __rhs._M_destructive_move(std::move(*this));
	    this->_M_reset();
	  }
	else
	  {
	    auto __tmp = std::move(__rhs);
	    __rhs._M_destructive_move(std::move(*this));
	    this->_M_destructive_move(std::move(__tmp));
	  }
      }

    private:
#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP, __NAME) \
      template<size_t... __indices> \
	static constexpr bool \
	(*_S_erased_##__NAME[])(const variant&, const variant&) = \
	  { &__detail::__variant::__erased_##__NAME< \
                const variant&, __indices>... }; \
      template<size_t... __indices> \
	constexpr inline bool \
	_M_##__NAME(const variant& __rhs, \
		    std::index_sequence<__indices...>) const \
	{ \
	  auto __lhs_index = this->index(); \
	  auto __rhs_index = __rhs.index(); \
	  if (__lhs_index != __rhs_index || valueless_by_exception()) \
	    /* Modulo addition. */ \
	    return __lhs_index + 1 __OP __rhs_index + 1; \
	  return _S_erased_##__NAME<__indices...>[__lhs_index](*this, __rhs); \
	}

      _VARIANT_RELATION_FUNCTION_TEMPLATE(<, less)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(<=, less_equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(==, equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(!=, not_equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>=, greater_equal)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>, greater)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE

#ifdef __clang__
    public:
      using _Base::_M_u; // See https://bugs.llvm.org/show_bug.cgi?id=31852
    private:
#endif

      template<size_t _Np, typename _Vp>
	friend constexpr decltype(auto) __detail::__variant::
#if _GLIBCXX_INLINE_VERSION
        __7:: // Required due to PR c++/59256
#endif
	__get(_Vp&& __v);

      template<typename _Vp>
	friend void* __detail::__variant::
#if _GLIBCXX_INLINE_VERSION
        __7:: // Required due to PR c++/59256
#endif
        __get_storage(_Vp&& __v);

#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP) \
      template<typename... _Tp> \
	friend constexpr bool \
	operator __OP(const variant<_Tp...>& __lhs, \
		      const variant<_Tp...>& __rhs);

      _VARIANT_RELATION_FUNCTION_TEMPLATE(<)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(<=)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(==)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(!=)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>=)
      _VARIANT_RELATION_FUNCTION_TEMPLATE(>)

#undef _VARIANT_RELATION_FUNCTION_TEMPLATE
    };

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&
    get(variant<_Types...>& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(__v);
    }

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&&
    get(variant<_Types...>&& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(std::move(__v));
    }

  template<size_t _Np, typename... _Types>
    constexpr const variant_alternative_t<_Np, variant<_Types...>>&
    get(const variant<_Types...>& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(__v);
    }

  template<size_t _Np, typename... _Types>
    constexpr const variant_alternative_t<_Np, variant<_Types...>>&&
    get(const variant<_Types...>&& __v)
    {
      static_assert(_Np < sizeof...(_Types),
		    "The index should be in [0, number of alternatives)");
      if (__v.index() != _Np)
	__throw_bad_variant_access("Unexpected index");
      return __detail::__variant::__get<_Np>(std::move(__v));
    }

  template<typename _Visitor, typename... _Variants>
    constexpr decltype(auto)
    visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      if ((__variants.valueless_by_exception() || ...))
	__throw_bad_variant_access("Unexpected index");

      using _Result_type =
	decltype(std::forward<_Visitor>(__visitor)(
	    std::get<0>(std::forward<_Variants>(__variants))...));

      constexpr auto& __vtable = __detail::__variant::__gen_vtable<
	_Result_type, _Visitor&&, _Variants&&...>::_S_vtable;

      auto __func_ptr = __vtable._M_access(__variants.index()...);
      return (*__func_ptr)(std::forward<_Visitor>(__visitor),
			   std::forward<_Variants>(__variants)...);
    }

  template<bool, typename... _Types>
    struct __variant_hash_call_base_impl
    {
      size_t
      operator()(const variant<_Types...>& __t) const
      noexcept((is_nothrow_invocable_v<hash<decay_t<_Types>>, _Types> && ...))
      {
	if (!__t.valueless_by_exception())
	  {
	    namespace __edv = __detail::__variant;
	    static constexpr size_t (*_S_vtable[])(void*) =
	      { &__edv::__erased_hash<const _Types&>... };
	    return hash<size_t>{}(__t.index())
	      + _S_vtable[__t.index()](__edv::__get_storage(__t));
	  }
	return hash<size_t>{}(__t.index());
      }
    };

  template<typename... _Types>
    struct __variant_hash_call_base_impl<false, _Types...> {};

  template<typename... _Types>
    using __variant_hash_call_base =
    __variant_hash_call_base_impl<(__poison_hash<remove_const_t<_Types>>::
				   __enable_hash_call &&...), _Types...>;

  template<typename... _Types>
    struct hash<variant<_Types...>>
    : private __detail::__variant::_Variant_hash_base<
        variant<_Types...>, std::index_sequence_for<_Types...>>,
      public __variant_hash_call_base<_Types...>
    {
      using result_type = size_t;
      using argument_type = variant<_Types...>;
    };

  template<>
    struct hash<monostate>
    {
      using result_type = size_t;
      using argument_type = monostate;

      size_t
      operator()(const monostate& __t) const noexcept
      {
	constexpr size_t __magic_monostate_hash = -7777;
	return __magic_monostate_hash;
      }
    };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++17

#endif // _GLIBCXX_VARIANT
@