[thirdparty/gcc.git] / libstdc++-v3 / include / experimental / bits / simd_converter.h

// Generic simd conversions -*- C++ -*-

// Copyright (C) 2020-2024 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/>.

#ifndef _GLIBCXX_EXPERIMENTAL_SIMD_CONVERTER_H_
#define _GLIBCXX_EXPERIMENTAL_SIMD_CONVERTER_H_

#if __cplusplus >= 201703L

_GLIBCXX_SIMD_BEGIN_NAMESPACE
// _SimdConverter scalar -> scalar {{{
template <typename _From, typename _To>
  struct _SimdConverter<_From, simd_abi::scalar, _To, simd_abi::scalar,
			enable_if_t<!is_same_v<_From, _To>>>
  {
    _GLIBCXX_SIMD_INTRINSIC constexpr _To operator()(_From __a) const noexcept
    { return static_cast<_To>(__a); }
  };

// }}}
// _SimdConverter scalar -> "native" {{{
template <typename _From, typename _To, typename _Abi>
  struct _SimdConverter<_From, simd_abi::scalar, _To, _Abi,
			enable_if_t<!is_same_v<_Abi, simd_abi::scalar>>>
  {
    using _Ret = typename _Abi::template __traits<_To>::_SimdMember;

    template <typename... _More>
      _GLIBCXX_SIMD_INTRINSIC constexpr _Ret
      operator()(_From __a, _More... __more) const noexcept
      {
	static_assert(sizeof...(_More) + 1 == _Abi::template _S_size<_To>);
	static_assert(conjunction_v<is_same<_From, _More>...>);
	return __make_vector<_To>(__a, __more...);
      }
  };

// }}}
// _SimdConverter "native 1" -> "native 2" {{{
template <typename _From, typename _To, typename _AFrom, typename _ATo>
  struct _SimdConverter<
    _From, _AFrom, _To, _ATo,
    enable_if_t<!disjunction_v<
      __is_fixed_size_abi<_AFrom>, __is_fixed_size_abi<_ATo>,
      is_same<_AFrom, simd_abi::scalar>, is_same<_ATo, simd_abi::scalar>,
      conjunction<is_same<_From, _To>, is_same<_AFrom, _ATo>>>>>
  {
    using _Arg = typename _AFrom::template __traits<_From>::_SimdMember;
    using _Ret = typename _ATo::template __traits<_To>::_SimdMember;
    using _V = __vector_type_t<_To, simd_size_v<_To, _ATo>>;

    template <typename... _More>
      _GLIBCXX_SIMD_INTRINSIC constexpr _Ret
      operator()(_Arg __a, _More... __more) const noexcept
      { return __vector_convert<_V>(__a, __more...); }
  };

// }}}
// _SimdConverter scalar -> fixed_size<1> {{{1
template <typename _From, typename _To>
  struct _SimdConverter<_From, simd_abi::scalar, _To, simd_abi::fixed_size<1>,
			void>
  {
    _GLIBCXX_SIMD_INTRINSIC constexpr _SimdTuple<_To, simd_abi::scalar>
    operator()(_From __x) const noexcept
    { return {static_cast<_To>(__x)}; }
  };

// _SimdConverter fixed_size<1> -> scalar {{{1
template <typename _From, typename _To>
  struct _SimdConverter<_From, simd_abi::fixed_size<1>, _To, simd_abi::scalar,
			void>
  {
    _GLIBCXX_SIMD_INTRINSIC constexpr _To
    operator()(_SimdTuple<_From, simd_abi::scalar> __x) const noexcept
    { return {static_cast<_To>(__x.first)}; }
  };

// _SimdConverter fixed_size<_Np> -> fixed_size<_Np> {{{1
template <typename _From, typename _To, int _Np>
  struct _SimdConverter<_From, simd_abi::fixed_size<_Np>, _To,
			simd_abi::fixed_size<_Np>,
			enable_if_t<!is_same_v<_From, _To>>>
  {
    using _Ret = __fixed_size_storage_t<_To, _Np>;
    using _Arg = __fixed_size_storage_t<_From, _Np>;

    _GLIBCXX_SIMD_INTRINSIC constexpr _Ret
    operator()(const _Arg& __x) const noexcept
    {
      if constexpr (is_same_v<_From, _To>)
	return __x;

      // special case (optimize) int signedness casts
      else if constexpr (sizeof(_From) == sizeof(_To)
			 && is_integral_v<_From> && is_integral_v<_To>)
	return __bit_cast<_Ret>(__x);

      // special case if all ABI tags in _Ret are scalar
      else if constexpr (__is_scalar_abi<typename _Ret::_FirstAbi>())
	{
	  return __call_with_subscripts(
	    __x, make_index_sequence<_Np>(),
	    [](auto... __values) constexpr _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA -> _Ret {
	      return __make_simd_tuple<_To, decltype((void) __values,
						     simd_abi::scalar())...>(
		static_cast<_To>(__values)...);
	    });
	}

      // from one vector to one vector
      else if constexpr (_Arg::_S_first_size == _Ret::_S_first_size)
	{
	  _SimdConverter<_From, typename _Arg::_FirstAbi, _To,
			 typename _Ret::_FirstAbi>
	    __native_cvt;
	  if constexpr (_Arg::_S_tuple_size == 1)
	    return {__native_cvt(__x.first)};
	  else
	    {
	      constexpr size_t _NRemain = _Np - _Arg::_S_first_size;
	      _SimdConverter<_From, simd_abi::fixed_size<_NRemain>, _To,
			     simd_abi::fixed_size<_NRemain>>
		__remainder_cvt;
	      return {__native_cvt(__x.first), __remainder_cvt(__x.second)};
	    }
	}

      // from one vector to multiple vectors
      else if constexpr (_Arg::_S_first_size > _Ret::_S_first_size)
	{
	  const auto __multiple_return_chunks
	    = __convert_all<__vector_type_t<_To, _Ret::_S_first_size>>(
	      __x.first);
	  constexpr auto __converted = __multiple_return_chunks.size()
				       * _Ret::_FirstAbi::template _S_size<_To>;
	  constexpr auto __remaining = _Np - __converted;
	  if constexpr (_Arg::_S_tuple_size == 1 && __remaining == 0)
	    return __to_simd_tuple<_To, _Np>(__multiple_return_chunks);
	  else if constexpr (_Arg::_S_tuple_size == 1)
	    { // e.g. <int, 3> -> <double, 2, 1> or <short, 7> -> <double, 4, 2,
	      // 1>
	      using _RetRem
		= __remove_cvref_t<decltype(__simd_tuple_pop_front<__converted>(
		  _Ret()))>;
	      const auto __return_chunks2
		= __convert_all<__vector_type_t<_To, _RetRem::_S_first_size>, 0,
				__converted>(__x.first);
	      constexpr auto __converted2
		= __converted
		  + __return_chunks2.size() * _RetRem::_S_first_size;
	      if constexpr (__converted2 == _Np)
		return __to_simd_tuple<_To, _Np>(__multiple_return_chunks,
						 __return_chunks2);
	      else
		{
		  using _RetRem2 = __remove_cvref_t<
		    decltype(__simd_tuple_pop_front<__return_chunks2.size()
						    * _RetRem::_S_first_size>(
		      _RetRem()))>;
		  const auto __return_chunks3 = __convert_all<
		    __vector_type_t<_To, _RetRem2::_S_first_size>, 0,
		    __converted2>(__x.first);
		  constexpr auto __converted3
		    = __converted2
		      + __return_chunks3.size() * _RetRem2::_S_first_size;
		  if constexpr (__converted3 == _Np)
		    return __to_simd_tuple<_To, _Np>(__multiple_return_chunks,
						     __return_chunks2,
						     __return_chunks3);
		  else
		    {
		      using _RetRem3
			= __remove_cvref_t<decltype(__simd_tuple_pop_front<
						    __return_chunks3.size()
						    * _RetRem2::_S_first_size>(
			  _RetRem2()))>;
		      const auto __return_chunks4 = __convert_all<
			__vector_type_t<_To, _RetRem3::_S_first_size>, 0,
			__converted3>(__x.first);
		      constexpr auto __converted4
			= __converted3
			  + __return_chunks4.size() * _RetRem3::_S_first_size;
		      if constexpr (__converted4 == _Np)
			return __to_simd_tuple<_To, _Np>(
			  __multiple_return_chunks, __return_chunks2,
			  __return_chunks3, __return_chunks4);
		      else
			__assert_unreachable<_To>();
		    }
		}
	    }
	  else
	    {
	      constexpr size_t _NRemain = _Np - _Arg::_S_first_size;
	      _SimdConverter<_From, simd_abi::fixed_size<_NRemain>, _To,
			     simd_abi::fixed_size<_NRemain>>
		__remainder_cvt;
	      return __simd_tuple_concat(
		__to_simd_tuple<_To, _Arg::_S_first_size>(
		  __multiple_return_chunks),
		__remainder_cvt(__x.second));
	    }
	}

      // from multiple vectors to one vector
      // _Arg::_S_first_size < _Ret::_S_first_size
      // a) heterogeneous input at the end of the tuple (possible with partial
      //    native registers in _Ret)
      else if constexpr (_Ret::_S_tuple_size == 1
			 && _Np % _Arg::_S_first_size != 0)
	{
	  static_assert(_Ret::_FirstAbi::template _S_is_partial<_To>);
	  return _Ret{__generate_from_n_evaluations<
	    _Np, typename _VectorTraits<typename _Ret::_FirstType>::type>(
	    [&](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	      return static_cast<_To>(__x[__i]);
	    })};
	}
      else
	{
	  static_assert(_Arg::_S_tuple_size > 1);
	  constexpr auto __n
	    = __div_roundup(_Ret::_S_first_size, _Arg::_S_first_size);
	  return __call_with_n_evaluations<__n>(
	    [&__x](auto... __uncvted) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	      // assuming _Arg Abi tags for all __i are _Arg::_FirstAbi
	      _SimdConverter<_From, typename _Arg::_FirstAbi, _To,
			     typename _Ret::_FirstAbi>
		__native_cvt;
	      if constexpr (_Ret::_S_tuple_size == 1)
		return _Ret{__native_cvt(__uncvted...)};
	      else
		return _Ret{
		  __native_cvt(__uncvted...),
		  _SimdConverter<
		    _From, simd_abi::fixed_size<_Np - _Ret::_S_first_size>, _To,
		    simd_abi::fixed_size<_Np - _Ret::_S_first_size>>()(
		    __simd_tuple_pop_front<_Ret::_S_first_size>(__x))};
	    }, [&__x](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	      return __get_tuple_at<__i>(__x);
	    });
	}
    }
  };

// _SimdConverter "native" -> fixed_size<_Np> {{{1
// i.e. 1 register to ? registers
template <typename _From, typename _Ap, typename _To, int _Np>
  struct _SimdConverter<_From, _Ap, _To, simd_abi::fixed_size<_Np>,
			enable_if_t<!__is_fixed_size_abi_v<_Ap>>>
  {
    static_assert(
      _Np == simd_size_v<_From, _Ap>,
      "_SimdConverter to fixed_size only works for equal element counts");

    using _Ret = __fixed_size_storage_t<_To, _Np>;

    _GLIBCXX_SIMD_INTRINSIC constexpr _Ret
    operator()(typename _SimdTraits<_From, _Ap>::_SimdMember __x) const noexcept
    {
      if constexpr (_Ret::_S_tuple_size == 1)
	return {__vector_convert<typename _Ret::_FirstType::_BuiltinType>(__x)};
      else
	{
	  using _FixedNp = simd_abi::fixed_size<_Np>;
	  _SimdConverter<_From, _FixedNp, _To, _FixedNp> __fixed_cvt;
	  using _FromFixedStorage = __fixed_size_storage_t<_From, _Np>;
	  if constexpr (_FromFixedStorage::_S_tuple_size == 1)
	    return __fixed_cvt(_FromFixedStorage{__x});
	  else if constexpr (_FromFixedStorage::_S_tuple_size == 2)
	    {
	      _FromFixedStorage __tmp;
	      static_assert(sizeof(__tmp) <= sizeof(__x));
	      __builtin_memcpy(&__tmp.first, &__x, sizeof(__tmp.first));
	      __builtin_memcpy(&__tmp.second.first,
			       reinterpret_cast<const char*>(&__x)
				 + sizeof(__tmp.first),
			       sizeof(__tmp.second.first));
	      return __fixed_cvt(__tmp);
	    }
	  else
	    __assert_unreachable<_From>();
	}
    }
  };

// _SimdConverter fixed_size<_Np> -> "native" {{{1
// i.e. ? register to 1 registers
template <typename _From, int _Np, typename _To, typename _Ap>
  struct _SimdConverter<_From, simd_abi::fixed_size<_Np>, _To, _Ap,
			enable_if_t<!__is_fixed_size_abi_v<_Ap>>>
  {
    static_assert(
      _Np == simd_size_v<_To, _Ap>,
      "_SimdConverter to fixed_size only works for equal element counts");

    using _Arg = __fixed_size_storage_t<_From, _Np>;

    _GLIBCXX_SIMD_INTRINSIC constexpr
      typename _SimdTraits<_To, _Ap>::_SimdMember
      operator()(const _Arg& __x) const noexcept
    {
      if constexpr (_Arg::_S_tuple_size == 1)
	return __vector_convert<__vector_type_t<_To, _Np>>(__x.first);
      else if constexpr (_Arg::_S_is_homogeneous)
	return __call_with_n_evaluations<_Arg::_S_tuple_size>(
	  [](auto... __members) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	    if constexpr ((is_convertible_v<decltype(__members), _To> && ...))
	      return __vector_type_t<_To, _Np>{static_cast<_To>(__members)...};
	    else
	      return __vector_convert<__vector_type_t<_To, _Np>>(__members...);
	  }, [&](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	    return __get_tuple_at<__i>(__x);
	  });
      else if constexpr (__fixed_size_storage_t<_To, _Np>::_S_tuple_size == 1)
	{
	  _SimdConverter<_From, simd_abi::fixed_size<_Np>, _To,
			 simd_abi::fixed_size<_Np>>
	    __fixed_cvt;
	  return __fixed_cvt(__x).first;
	}
      else
	{
	  const _SimdWrapper<_From, _Np> __xv
	    = __generate_from_n_evaluations<_Np, __vector_type_t<_From, _Np>>(
		[&](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA { return __x[__i]; });
	  return __vector_convert<__vector_type_t<_To, _Np>>(__xv);
	}
    }
  };

// }}}1
_GLIBCXX_SIMD_END_NAMESPACE
#endif // __cplusplus >= 201703L
#endif // _GLIBCXX_EXPERIMENTAL_SIMD_CONVERTER_H_

// vim: foldmethod=marker sw=2 noet ts=8 sts=2 tw=80
Commit	Line	Data
2bcceb6f MK	1	// Generic simd conversions -- C++ --
2bcceb6f MK	2
a945c346	3	// Copyright (C) 2020-2024 Free Software Foundation, Inc.
2bcceb6f MK	4	//
	5	// This file is part of the GNU ISO C++ Library. This library is free
	6	// software; you can redistribute it and/or modify it under the
	7	// terms of the GNU General Public License as published by the
	8	// Free Software Foundation; either version 3, or (at your option)
	9	// any later version.
	10
	11	// This library is distributed in the hope that it will be useful,
	12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	// GNU General Public License for more details.
	15
	16	// Under Section 7 of GPL version 3, you are granted additional
	17	// permissions described in the GCC Runtime Library Exception, version
	18	// 3.1, as published by the Free Software Foundation.
	19
	20	// You should have received a copy of the GNU General Public License and
	21	// a copy of the GCC Runtime Library Exception along with this program;
	22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
	23	// <http://www.gnu.org/licenses/>.
	24
	25	#ifndef _GLIBCXX_EXPERIMENTAL_SIMD_CONVERTER_H_
	26	#define _GLIBCXX_EXPERIMENTAL_SIMD_CONVERTER_H_
	27
	28	#if __cplusplus >= 201703L
	29
	30	_GLIBCXX_SIMD_BEGIN_NAMESPACE
	31	// _SimdConverter scalar -> scalar {{{
	32	template <typename _From, typename _To>
	33	struct _SimdConverter<_From, simd_abi::scalar, _To, simd_abi::scalar,
	34	enable_if_t<!is_same_v<_From, _To>>>
	35	{
	36	_GLIBCXX_SIMD_INTRINSIC constexpr _To operator()(_From __a) const noexcept
	37	{ return static_cast<_To>(__a); }
	38	};
	39
	40	// }}}
	41	// _SimdConverter scalar -> "native" {{{
	42	template <typename _From, typename _To, typename _Abi>
	43	struct _SimdConverter<_From, simd_abi::scalar, _To, _Abi,
	44	enable_if_t<!is_same_v<_Abi, simd_abi::scalar>>>
	45	{
	46	using _Ret = typename _Abi::template __traits<_To>::_SimdMember;
	47
	48	template <typename... _More>
	49	_GLIBCXX_SIMD_INTRINSIC constexpr _Ret
	50	operator()(_From __a, _More... __more) const noexcept
	51	{
	52	static_assert(sizeof...(_More) + 1 == _Abi::template _S_size<_To>);
	53	static_assert(conjunction_v<is_same<_From, _More>...>);
	54	return __make_vector<_To>(__a, __more...);
	55	}
	56	};
	57
	58	// }}}
	59	// _SimdConverter "native 1" -> "native 2" {{{
	60	template <typename _From, typename _To, typename _AFrom, typename _ATo>
	61	struct _SimdConverter<
	62	_From, _AFrom, _To, _ATo,
	63	enable_if_t<!disjunction_v<
	64	__is_fixed_size_abi<_AFrom>, __is_fixed_size_abi<_ATo>,
	65	is_same<_AFrom, simd_abi::scalar>, is_same<_ATo, simd_abi::scalar>,
	66	conjunction<is_same<_From, _To>, is_same<_AFrom, _ATo>>>>>
	67	{
68	using _Arg = typename _AFrom::template __traits<_From>::_SimdMember;
69	using _Ret = typename _ATo::template __traits<_To>::_SimdMember;
70	using _V = __vector_type_t<_To, simd_size_v<_To, _ATo>>;
71
72	template <typename... _More>
73	_GLIBCXX_SIMD_INTRINSIC constexpr _Ret
74	operator()(_Arg __a, _More... __more) const noexcept
75	{ return __vector_convert<_V>(__a, __more...); }
76	};
77
78	// }}}
79	// _SimdConverter scalar -> fixed_size<1> {{{1
80	template <typename _From, typename _To>
81	struct _SimdConverter<_From, simd_abi::scalar, _To, simd_abi::fixed_size<1>,
82	void>
83	{
84	_GLIBCXX_SIMD_INTRINSIC constexpr _SimdTuple<_To, simd_abi::scalar>
85	operator()(_From __x) const noexcept
86	{ return {static_cast<_To>(__x)}; }
87	};
88
89	// _SimdConverter fixed_size<1> -> scalar {{{1
90	template <typename _From, typename _To>
91	struct _SimdConverter<_From, simd_abi::fixed_size<1>, _To, simd_abi::scalar,
92	void>
93	{
94	_GLIBCXX_SIMD_INTRINSIC constexpr _To
95	operator()(_SimdTuple<_From, simd_abi::scalar> __x) const noexcept
96	{ return {static_cast<_To>(__x.first)}; }
97	};
98
99	// _SimdConverter fixed_size<_Np> -> fixed_size<_Np> {{{1
100	template <typename _From, typename _To, int _Np>
101	struct _SimdConverter<_From, simd_abi::fixed_size<_Np>, _To,
102	simd_abi::fixed_size<_Np>,
103	enable_if_t<!is_same_v<_From, _To>>>
104	{
105	using _Ret = __fixed_size_storage_t<_To, _Np>;
106	using _Arg = __fixed_size_storage_t<_From, _Np>;
107
108	_GLIBCXX_SIMD_INTRINSIC constexpr _Ret
109	operator()(const _Arg& __x) const noexcept
110	{
111	if constexpr (is_same_v<_From, _To>)
112	return __x;
113
114	// special case (optimize) int signedness casts
115	else if constexpr (sizeof(_From) == sizeof(_To)
116	&& is_integral_v<_From> && is_integral_v<_To>)
117	return __bit_cast<_Ret>(__x);
118
119	// special case if all ABI tags in _Ret are scalar
120	else if constexpr (__is_scalar_abi<typename _Ret::_FirstAbi>())
121	{
122	return __call_with_subscripts(
123	__x, make_index_sequence<_Np>(),
53b55701	124	[](auto... __values) constexpr _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA -> _Ret {
2bcceb6f MK	125	return __make_simd_tuple<_To, decltype((void) __values,
	126	simd_abi::scalar())...>(
	127	static_cast<_To>(__values)...);
	128	});
	129	}
	130
	131	// from one vector to one vector
	132	else if constexpr (_Arg::_S_first_size == _Ret::_S_first_size)
	133	{
	134	_SimdConverter<_From, typename _Arg::_FirstAbi, _To,
	135	typename _Ret::_FirstAbi>
	136	__native_cvt;
	137	if constexpr (_Arg::_S_tuple_size == 1)
	138	return {__native_cvt(__x.first)};
	139	else
	140	{
	141	constexpr size_t _NRemain = _Np - _Arg::_S_first_size;
	142	_SimdConverter<_From, simd_abi::fixed_size<_NRemain>, _To,
	143	simd_abi::fixed_size<_NRemain>>
	144	__remainder_cvt;
	145	return {__native_cvt(__x.first), __remainder_cvt(__x.second)};
	146	}
	147	}
	148
	149	// from one vector to multiple vectors
	150	else if constexpr (_Arg::_S_first_size > _Ret::_S_first_size)
	151	{
	152	const auto __multiple_return_chunks
	153	= __convert_all<__vector_type_t<_To, _Ret::_S_first_size>>(
	154	__x.first);
	155	constexpr auto __converted = __multiple_return_chunks.size()
	156	* _Ret::_FirstAbi::template _S_size<_To>;
	157	constexpr auto __remaining = _Np - __converted;
	158	if constexpr (_Arg::_S_tuple_size == 1 && __remaining == 0)
	159	return __to_simd_tuple<_To, _Np>(__multiple_return_chunks);
	160	else if constexpr (_Arg::_S_tuple_size == 1)
	161	{ // e.g. <int, 3> -> <double, 2, 1> or <short, 7> -> <double, 4, 2,
	162	// 1>
	163	using _RetRem
	164	= __remove_cvref_t<decltype(__simd_tuple_pop_front<__converted>(
	165	_Ret()))>;
	166	const auto __return_chunks2
	167	= __convert_all<__vector_type_t<_To, _RetRem::_S_first_size>, 0,
	168	__converted>(__x.first);
	169	constexpr auto __converted2
	170	= __converted
	171	+ __return_chunks2.size() * _RetRem::_S_first_size;
	172	if constexpr (__converted2 == _Np)
	173	return __to_simd_tuple<_To, _Np>(__multiple_return_chunks,
	174	__return_chunks2);
	175	else
	176	{
	177	using _RetRem2 = __remove_cvref_t<
	178	decltype(__simd_tuple_pop_front<__return_chunks2.size()
	179	* _RetRem::_S_first_size>(
	180	_RetRem()))>;
	181	const auto __return_chunks3 = __convert_all<
	182	__vector_type_t<_To, _RetRem2::_S_first_size>, 0,
	183	__converted2>(__x.first);
	184	constexpr auto __converted3
	185	= __converted2
	186	+ __return_chunks3.size() * _RetRem2::_S_first_size;
	187	if constexpr (__converted3 == _Np)
	188	return __to_simd_tuple<_To, _Np>(__multiple_return_chunks,
189	__return_chunks2,
190	__return_chunks3);
191	else
192	{
193	using _RetRem3
194	= __remove_cvref_t<decltype(__simd_tuple_pop_front<
195	__return_chunks3.size()
196	* _RetRem2::_S_first_size>(
197	_RetRem2()))>;
198	const auto __return_chunks4 = __convert_all<
199	__vector_type_t<_To, _RetRem3::_S_first_size>, 0,
200	__converted3>(__x.first);
201	constexpr auto __converted4
202	= __converted3
203	+ __return_chunks4.size() * _RetRem3::_S_first_size;
204	if constexpr (__converted4 == _Np)
205	return __to_simd_tuple<_To, _Np>(
206	__multiple_return_chunks, __return_chunks2,
207	__return_chunks3, __return_chunks4);
208	else
209	__assert_unreachable<_To>();
210	}
211	}
212	}
213	else
214	{
215	constexpr size_t _NRemain = _Np - _Arg::_S_first_size;
216	_SimdConverter<_From, simd_abi::fixed_size<_NRemain>, _To,
217	simd_abi::fixed_size<_NRemain>>
218	__remainder_cvt;
219	return __simd_tuple_concat(
220	__to_simd_tuple<_To, _Arg::_S_first_size>(
221	__multiple_return_chunks),
222	__remainder_cvt(__x.second));
223	}
224	}
225
226	// from multiple vectors to one vector
227	// _Arg::_S_first_size < _Ret::_S_first_size
228	// a) heterogeneous input at the end of the tuple (possible with partial
229	// native registers in _Ret)
230	else if constexpr (_Ret::_S_tuple_size == 1
231	&& _Np % _Arg::_S_first_size != 0)
232	{
233	static_assert(_Ret::_FirstAbi::template _S_is_partial<_To>);
234	return _Ret{__generate_from_n_evaluations<
235	_Np, typename _VectorTraits<typename _Ret::_FirstType>::type>(
53b55701 MK	236	[&](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	237	return static_cast<_To>(__x[__i]);
	238	})};
2bcceb6f MK	239	}
	240	else
	241	{
	242	static_assert(_Arg::_S_tuple_size > 1);
	243	constexpr auto __n
	244	= __div_roundup(_Ret::_S_first_size, _Arg::_S_first_size);
	245	return __call_with_n_evaluations<__n>(
53b55701	246	[&__x](auto... __uncvted) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
2bcceb6f MK	247	// assuming _Arg Abi tags for all __i are _Arg::_FirstAbi
	248	_SimdConverter<_From, typename _Arg::_FirstAbi, _To,
	249	typename _Ret::_FirstAbi>
	250	__native_cvt;
	251	if constexpr (_Ret::_S_tuple_size == 1)
	252	return _Ret{__native_cvt(__uncvted...)};
	253	else
	254	return _Ret{
	255	__native_cvt(__uncvted...),
	256	_SimdConverter<
	257	_From, simd_abi::fixed_size<_Np - _Ret::_S_first_size>, _To,
	258	simd_abi::fixed_size<_Np - _Ret::_S_first_size>>()(
	259	__simd_tuple_pop_front<_Ret::_S_first_size>(__x))};
53b55701 MK	260	}, [&__x](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	261	return __get_tuple_at<__i>(__x);
	262	});
2bcceb6f MK	263	}
	264	}
	265	};
	266
	267	// _SimdConverter "native" -> fixed_size<_Np> {{{1
	268	// i.e. 1 register to ? registers
	269	template <typename _From, typename _Ap, typename _To, int _Np>
	270	struct _SimdConverter<_From, _Ap, _To, simd_abi::fixed_size<_Np>,
	271	enable_if_t<!__is_fixed_size_abi_v<_Ap>>>
	272	{
	273	static_assert(
	274	_Np == simd_size_v<_From, _Ap>,
	275	"_SimdConverter to fixed_size only works for equal element counts");
	276
	277	using _Ret = __fixed_size_storage_t<_To, _Np>;
	278
	279	_GLIBCXX_SIMD_INTRINSIC constexpr _Ret
	280	operator()(typename _SimdTraits<_From, _Ap>::_SimdMember __x) const noexcept
	281	{
	282	if constexpr (_Ret::_S_tuple_size == 1)
	283	return {__vector_convert<typename _Ret::_FirstType::_BuiltinType>(__x)};
	284	else
	285	{
	286	using _FixedNp = simd_abi::fixed_size<_Np>;
	287	_SimdConverter<_From, _FixedNp, _To, _FixedNp> __fixed_cvt;
	288	using _FromFixedStorage = __fixed_size_storage_t<_From, _Np>;
	289	if constexpr (_FromFixedStorage::_S_tuple_size == 1)
	290	return __fixed_cvt(_FromFixedStorage{__x});
	291	else if constexpr (_FromFixedStorage::_S_tuple_size == 2)
	292	{
	293	_FromFixedStorage __tmp;
	294	static_assert(sizeof(__tmp) <= sizeof(__x));
	295	__builtin_memcpy(&__tmp.first, &__x, sizeof(__tmp.first));
	296	__builtin_memcpy(&__tmp.second.first,
	297	reinterpret_cast<const char*>(&__x)
	298	+ sizeof(__tmp.first),
	299	sizeof(__tmp.second.first));
	300	return __fixed_cvt(__tmp);
	301	}
	302	else
	303	__assert_unreachable<_From>();
	304	}
	305	}
	306	};
	307
	308	// _SimdConverter fixed_size<_Np> -> "native" {{{1
	309	// i.e. ? register to 1 registers
	310	template <typename _From, int _Np, typename _To, typename _Ap>
	311	struct _SimdConverter<_From, simd_abi::fixed_size<_Np>, _To, _Ap,
	312	enable_if_t<!__is_fixed_size_abi_v<_Ap>>>
	313	{
	314	static_assert(
	315	_Np == simd_size_v<_To, _Ap>,
	316	"_SimdConverter to fixed_size only works for equal element counts");
	317
	318	using _Arg = __fixed_size_storage_t<_From, _Np>;
	319
	320	_GLIBCXX_SIMD_INTRINSIC constexpr
	321	typename _SimdTraits<_To, _Ap>::_SimdMember
343f01f4	322	operator()(const _Arg& __x) const noexcept
2bcceb6f MK	323	{
	324	if constexpr (_Arg::_S_tuple_size == 1)
	325	return __vector_convert<__vector_type_t<_To, _Np>>(__x.first);
	326	else if constexpr (_Arg::_S_is_homogeneous)
	327	return __call_with_n_evaluations<_Arg::_S_tuple_size>(
53b55701	328	[](auto... __members) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
2bcceb6f MK	329	if constexpr ((is_convertible_v<decltype(__members), _To> && ...))
	330	return __vector_type_t<_To, _Np>{static_cast<_To>(__members)...};
	331	else
	332	return __vector_convert<__vector_type_t<_To, _Np>>(__members...);
53b55701 MK	333	}, [&](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	334	return __get_tuple_at<__i>(__x);
	335	});
2bcceb6f MK	336	else if constexpr (__fixed_size_storage_t<_To, _Np>::_S_tuple_size == 1)
	337	{
	338	_SimdConverter<_From, simd_abi::fixed_size<_Np>, _To,
	339	simd_abi::fixed_size<_Np>>
	340	__fixed_cvt;
	341	return __fixed_cvt(__x).first;
	342	}
	343	else
	344	{
	345	const _SimdWrapper<_From, _Np> __xv
	346	= __generate_from_n_evaluations<_Np, __vector_type_t<_From, _Np>>(
53b55701	347	[&](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA { return __x[__i]; });
2bcceb6f MK	348	return __vector_convert<__vector_type_t<_To, _Np>>(__xv);
	349	}
	350	}
	351	};
	352
	353	// }}}1
	354	_GLIBCXX_SIMD_END_NAMESPACE
	355	#endif // __cplusplus >= 201703L
	356	#endif // _GLIBCXX_EXPERIMENTAL_SIMD_CONVERTER_H_
	357
	358	// vim: foldmethod=marker sw=2 noet ts=8 sts=2 tw=80