<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/include/c++/11/experimental/bits/simd_scalar.h</h2><form method='post'><textarea name='content' class='file-edit'>// Simd scalar ABI specific implementations -*- C++ -*-

// Copyright (C) 2020-2021 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
// &lt;http://www.gnu.org/licenses/&gt;.

#ifndef _GLIBCXX_EXPERIMENTAL_SIMD_SCALAR_H_
#define _GLIBCXX_EXPERIMENTAL_SIMD_SCALAR_H_
#if __cplusplus &gt;= 201703L

#include &lt;cmath&gt;

_GLIBCXX_SIMD_BEGIN_NAMESPACE

// __promote_preserving_unsigned{{{
// work around crazy semantics of unsigned integers of lower rank than int:
// Before applying an operator the operands are promoted to int. In which case
// over- or underflow is UB, even though the operand types were unsigned.
template &lt;typename _Tp&gt;
  _GLIBCXX_SIMD_INTRINSIC constexpr decltype(auto)
  __promote_preserving_unsigned(const _Tp&amp; __x)
  {
    if constexpr (is_signed_v&lt;decltype(+__x)&gt; &amp;&amp; is_unsigned_v&lt;_Tp&gt;)
      return static_cast&lt;unsigned int&gt;(__x);
    else
      return __x;
  }

// }}}

struct _CommonImplScalar;
struct _CommonImplBuiltin;
struct _SimdImplScalar;
struct _MaskImplScalar;

// simd_abi::_Scalar {{{
struct simd_abi::_Scalar
{
  template &lt;typename _Tp&gt;
    static constexpr size_t _S_size = 1;

  template &lt;typename _Tp&gt;
    static constexpr size_t _S_full_size = 1;

  template &lt;typename _Tp&gt;
    static constexpr bool _S_is_partial = false;

  struct _IsValidAbiTag : true_type {};

  template &lt;typename _Tp&gt;
    struct _IsValidSizeFor : true_type {};

  template &lt;typename _Tp&gt;
    struct _IsValid : __is_vectorizable&lt;_Tp&gt; {};

  template &lt;typename _Tp&gt;
    static constexpr bool _S_is_valid_v = _IsValid&lt;_Tp&gt;::value;

  _GLIBCXX_SIMD_INTRINSIC static constexpr bool _S_masked(bool __x)
  { return __x; }

  using _CommonImpl = _CommonImplScalar;
  using _SimdImpl = _SimdImplScalar;
  using _MaskImpl = _MaskImplScalar;

  template &lt;typename _Tp, bool = _S_is_valid_v&lt;_Tp&gt;&gt;
    struct __traits : _InvalidTraits {};

  template &lt;typename _Tp&gt;
    struct __traits&lt;_Tp, true&gt;
    {
      using _IsValid = true_type;
      using _SimdImpl = _SimdImplScalar;
      using _MaskImpl = _MaskImplScalar;
      using _SimdMember = _Tp;
      using _MaskMember = bool;

      static constexpr size_t _S_simd_align = alignof(_SimdMember);
      static constexpr size_t _S_mask_align = alignof(_MaskMember);

      // nothing the user can spell converts to/from simd/simd_mask
      struct _SimdCastType { _SimdCastType() = delete; };
      struct _MaskCastType { _MaskCastType() = delete; };
      struct _SimdBase {};
      struct _MaskBase {};
    };
};

// }}}
// _CommonImplScalar {{{
struct _CommonImplScalar
{
  // _S_store {{{
  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static void _S_store(_Tp __x, void* __addr)
    { __builtin_memcpy(__addr, &amp;__x, sizeof(_Tp)); }

  // }}}
  // _S_store_bool_array(_BitMask) {{{
  template &lt;size_t _Np, bool _Sanitized&gt;
    _GLIBCXX_SIMD_INTRINSIC static constexpr void
    _S_store_bool_array(_BitMask&lt;_Np, _Sanitized&gt; __x, bool* __mem)
    {
      __make_dependent_t&lt;decltype(__x), _CommonImplBuiltin&gt;::_S_store_bool_array(
	__x, __mem);
    }

  // }}}
};

// }}}
// _SimdImplScalar {{{
struct _SimdImplScalar
{
  // member types {{{2
  using abi_type = simd_abi::scalar;

  template &lt;typename _Tp&gt;
    using _TypeTag = _Tp*;

  // _S_broadcast {{{2
  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static constexpr _Tp _S_broadcast(_Tp __x) noexcept
    { return __x; }

  // _S_generator {{{2
  template &lt;typename _Fp, typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static constexpr _Tp _S_generator(_Fp&amp;&amp; __gen,
							      _TypeTag&lt;_Tp&gt;)
    { return __gen(_SizeConstant&lt;0&gt;()); }

  // _S_load {{{2
  template &lt;typename _Tp, typename _Up&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_load(const _Up* __mem,
					       _TypeTag&lt;_Tp&gt;) noexcept
    { return static_cast&lt;_Tp&gt;(__mem[0]); }

  // _S_masked_load {{{2
  template &lt;typename _Tp, typename _Up&gt;
    static inline _Tp _S_masked_load(_Tp __merge, bool __k,
				     const _Up* __mem) noexcept
    {
      if (__k)
	__merge = static_cast&lt;_Tp&gt;(__mem[0]);
      return __merge;
    }

  // _S_store {{{2
  template &lt;typename _Tp, typename _Up&gt;
    static inline void _S_store(_Tp __v, _Up* __mem, _TypeTag&lt;_Tp&gt;) noexcept
    { __mem[0] = static_cast&lt;_Up&gt;(__v); }

  // _S_masked_store {{{2
  template &lt;typename _Tp, typename _Up&gt;
    static inline void _S_masked_store(const _Tp __v, _Up* __mem,
				       const bool __k) noexcept
    { if (__k) __mem[0] = __v; }

  // _S_negate {{{2
  template &lt;typename _Tp&gt;
    static constexpr inline bool _S_negate(_Tp __x) noexcept
    { return !__x; }

  // _S_reduce {{{2
  template &lt;typename _Tp, typename _BinaryOperation&gt;
    static constexpr inline _Tp
    _S_reduce(const simd&lt;_Tp, simd_abi::scalar&gt;&amp; __x, const _BinaryOperation&amp;)
    { return __x._M_data; }

  // _S_min, _S_max {{{2
  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_min(const _Tp __a, const _Tp __b)
    { return std::min(__a, __b); }

  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_max(const _Tp __a, const _Tp __b)
    { return std::max(__a, __b); }

  // _S_complement {{{2
  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_complement(_Tp __x) noexcept
    { return static_cast&lt;_Tp&gt;(~__x); }

  // _S_unary_minus {{{2
  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_unary_minus(_Tp __x) noexcept
    { return static_cast&lt;_Tp&gt;(-__x); }

  // arithmetic operators {{{2
  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_plus(_Tp __x, _Tp __y)
    {
      return static_cast&lt;_Tp&gt;(__promote_preserving_unsigned(__x)
			      + __promote_preserving_unsigned(__y));
    }

  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_minus(_Tp __x, _Tp __y)
    {
      return static_cast&lt;_Tp&gt;(__promote_preserving_unsigned(__x)
			      - __promote_preserving_unsigned(__y));
    }

  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_multiplies(_Tp __x, _Tp __y)
    {
      return static_cast&lt;_Tp&gt;(__promote_preserving_unsigned(__x)
			      * __promote_preserving_unsigned(__y));
    }

  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_divides(_Tp __x, _Tp __y)
    {
      return static_cast&lt;_Tp&gt;(__promote_preserving_unsigned(__x)
			      / __promote_preserving_unsigned(__y));
    }

  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_modulus(_Tp __x, _Tp __y)
    {
      return static_cast&lt;_Tp&gt;(__promote_preserving_unsigned(__x)
			      % __promote_preserving_unsigned(__y));
    }

  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_bit_and(_Tp __x, _Tp __y)
    {
      if constexpr (is_floating_point_v&lt;_Tp&gt;)
	{
	  using _Ip = __int_for_sizeof_t&lt;_Tp&gt;;
	  return __bit_cast&lt;_Tp&gt;(__bit_cast&lt;_Ip&gt;(__x) &amp; __bit_cast&lt;_Ip&gt;(__y));
	}
      else
	return static_cast&lt;_Tp&gt;(__promote_preserving_unsigned(__x)
				&amp; __promote_preserving_unsigned(__y));
    }

  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_bit_or(_Tp __x, _Tp __y)
    {
      if constexpr (is_floating_point_v&lt;_Tp&gt;)
	{
	  using _Ip = __int_for_sizeof_t&lt;_Tp&gt;;
	  return __bit_cast&lt;_Tp&gt;(__bit_cast&lt;_Ip&gt;(__x) | __bit_cast&lt;_Ip&gt;(__y));
	}
      else
	return static_cast&lt;_Tp&gt;(__promote_preserving_unsigned(__x)
				| __promote_preserving_unsigned(__y));
    }

  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_bit_xor(_Tp __x, _Tp __y)
    {
      if constexpr (is_floating_point_v&lt;_Tp&gt;)
	{
	  using _Ip = __int_for_sizeof_t&lt;_Tp&gt;;
	  return __bit_cast&lt;_Tp&gt;(__bit_cast&lt;_Ip&gt;(__x) ^ __bit_cast&lt;_Ip&gt;(__y));
	}
      else
	return static_cast&lt;_Tp&gt;(__promote_preserving_unsigned(__x)
				^ __promote_preserving_unsigned(__y));
    }

  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_bit_shift_left(_Tp __x, int __y)
    { return static_cast&lt;_Tp&gt;(__promote_preserving_unsigned(__x) &lt;&lt; __y); }

  template &lt;typename _Tp&gt;
    static constexpr inline _Tp _S_bit_shift_right(_Tp __x, int __y)
    { return static_cast&lt;_Tp&gt;(__promote_preserving_unsigned(__x) &gt;&gt; __y); }

  // math {{{2
  // frexp, modf and copysign implemented in simd_math.h
  template &lt;typename _Tp&gt;
    using _ST = _SimdTuple&lt;_Tp, simd_abi::scalar&gt;;

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_acos(_Tp __x)
    { return std::acos(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_asin(_Tp __x)
    { return std::asin(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_atan(_Tp __x)
    { return std::atan(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_cos(_Tp __x)
    { return std::cos(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_sin(_Tp __x)
    { return std::sin(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_tan(_Tp __x)
    { return std::tan(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_acosh(_Tp __x)
    { return std::acosh(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_asinh(_Tp __x)
    { return std::asinh(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_atanh(_Tp __x)
    { return std::atanh(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_cosh(_Tp __x)
    { return std::cosh(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_sinh(_Tp __x)
    { return std::sinh(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_tanh(_Tp __x)
    { return std::tanh(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_atan2(_Tp __x, _Tp __y)
    { return std::atan2(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_exp(_Tp __x)
    { return std::exp(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_exp2(_Tp __x)
    { return std::exp2(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_expm1(_Tp __x)
    { return std::expm1(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_log(_Tp __x)
    { return std::log(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_log10(_Tp __x)
    { return std::log10(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_log1p(_Tp __x)
    { return std::log1p(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_log2(_Tp __x)
    { return std::log2(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_logb(_Tp __x)
    { return std::logb(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _ST&lt;int&gt; _S_ilogb(_Tp __x)
    { return {std::ilogb(__x)}; }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_pow(_Tp __x, _Tp __y)
    { return std::pow(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_abs(_Tp __x)
    { return std::abs(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_fabs(_Tp __x)
    { return std::fabs(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_sqrt(_Tp __x)
    { return std::sqrt(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_cbrt(_Tp __x)
    { return std::cbrt(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_erf(_Tp __x)
    { return std::erf(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_erfc(_Tp __x)
    { return std::erfc(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_lgamma(_Tp __x)
    { return std::lgamma(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_tgamma(_Tp __x)
    { return std::tgamma(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_trunc(_Tp __x)
    { return std::trunc(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_floor(_Tp __x)
    { return std::floor(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_ceil(_Tp __x)
    { return std::ceil(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_nearbyint(_Tp __x)
    { return std::nearbyint(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_rint(_Tp __x)
    { return std::rint(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _ST&lt;long&gt; _S_lrint(_Tp __x)
    { return {std::lrint(__x)}; }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _ST&lt;long long&gt; _S_llrint(_Tp __x)
    { return {std::llrint(__x)}; }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_round(_Tp __x)
    { return std::round(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _ST&lt;long&gt; _S_lround(_Tp __x)
    { return {std::lround(__x)}; }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _ST&lt;long long&gt; _S_llround(_Tp __x)
    { return {std::llround(__x)}; }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_ldexp(_Tp __x, _ST&lt;int&gt; __y)
    { return std::ldexp(__x, __y.first); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_scalbn(_Tp __x, _ST&lt;int&gt; __y)
    { return std::scalbn(__x, __y.first); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_scalbln(_Tp __x, _ST&lt;long&gt; __y)
    { return std::scalbln(__x, __y.first); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_fmod(_Tp __x, _Tp __y)
    { return std::fmod(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_remainder(_Tp __x, _Tp __y)
    { return std::remainder(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_nextafter(_Tp __x, _Tp __y)
    { return std::nextafter(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_fdim(_Tp __x, _Tp __y)
    { return std::fdim(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_fmax(_Tp __x, _Tp __y)
    { return std::fmax(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_fmin(_Tp __x, _Tp __y)
    { return std::fmin(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_fma(_Tp __x, _Tp __y, _Tp __z)
    { return std::fma(__x, __y, __z); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC static _Tp _S_remquo(_Tp __x, _Tp __y, _ST&lt;int&gt;* __z)
    { return std::remquo(__x, __y, &amp;__z-&gt;first); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static _ST&lt;int&gt; _S_fpclassify(_Tp __x)
    { return {std::fpclassify(__x)}; }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_isfinite(_Tp __x)
    { return std::isfinite(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_isinf(_Tp __x)
    { return std::isinf(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_isnan(_Tp __x)
    { return std::isnan(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_isnormal(_Tp __x)
    { return std::isnormal(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_signbit(_Tp __x)
    { return std::signbit(__x); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_isgreater(_Tp __x, _Tp __y)
    { return std::isgreater(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_isgreaterequal(_Tp __x,
								    _Tp __y)
    { return std::isgreaterequal(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_isless(_Tp __x, _Tp __y)
    { return std::isless(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_islessequal(_Tp __x, _Tp __y)
    { return std::islessequal(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_islessgreater(_Tp __x,
								   _Tp __y)
    { return std::islessgreater(__x, __y); }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_isunordered(_Tp __x,
								 _Tp __y)
    { return std::isunordered(__x, __y); }

  // _S_increment &amp; _S_decrement{{{2
  template &lt;typename _Tp&gt;
    constexpr static inline void _S_increment(_Tp&amp; __x)
    { ++__x; }

  template &lt;typename _Tp&gt;
    constexpr static inline void _S_decrement(_Tp&amp; __x)
    { --__x; }


  // compares {{{2
  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_equal_to(_Tp __x, _Tp __y)
    { return __x == __y; }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_not_equal_to(_Tp __x,
								  _Tp __y)
    { return __x != __y; }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_less(_Tp __x, _Tp __y)
    { return __x &lt; __y; }

  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool _S_less_equal(_Tp __x,
								_Tp __y)
    { return __x &lt;= __y; }

  // smart_reference access {{{2
  template &lt;typename _Tp, typename _Up&gt;
    constexpr static void _S_set(_Tp&amp; __v, [[maybe_unused]] int __i,
				 _Up&amp;&amp; __x) noexcept
    {
      _GLIBCXX_DEBUG_ASSERT(__i == 0);
      __v = static_cast&lt;_Up&amp;&amp;&gt;(__x);
    }

  // _S_masked_assign {{{2
  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static void
    _S_masked_assign(bool __k, _Tp&amp; __lhs, _Tp __rhs)
    { if (__k) __lhs = __rhs; }

  // _S_masked_cassign {{{2
  template &lt;typename _Op, typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static void
    _S_masked_cassign(const bool __k, _Tp&amp; __lhs, const _Tp __rhs, _Op __op)
    { if (__k) __lhs = __op(_SimdImplScalar{}, __lhs, __rhs); }

  // _S_masked_unary {{{2
  template &lt;template &lt;typename&gt; class _Op, typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static _Tp _S_masked_unary(const bool __k,
								 const _Tp __v)
    { return static_cast&lt;_Tp&gt;(__k ? _Op&lt;_Tp&gt;{}(__v) : __v); }

  // }}}2
};

// }}}
// _MaskImplScalar {{{
struct _MaskImplScalar
{
  // member types {{{
  template &lt;typename _Tp&gt;
    using _TypeTag = _Tp*;

  // }}}
  // _S_broadcast {{{
  template &lt;typename&gt;
    _GLIBCXX_SIMD_INTRINSIC static constexpr bool _S_broadcast(bool __x)
    { return __x; }

  // }}}
  // _S_load {{{
  template &lt;typename&gt;
    _GLIBCXX_SIMD_INTRINSIC static constexpr bool _S_load(const bool* __mem)
    { return __mem[0]; }

  // }}}
  // _S_to_bits {{{
  _GLIBCXX_SIMD_INTRINSIC static constexpr _SanitizedBitMask&lt;1&gt;
  _S_to_bits(bool __x)
  { return __x; }

  // }}}
  // _S_convert {{{
  template &lt;typename, bool _Sanitized&gt;
    _GLIBCXX_SIMD_INTRINSIC static constexpr bool
    _S_convert(_BitMask&lt;1, _Sanitized&gt; __x)
    { return __x[0]; }

  template &lt;typename, typename _Up, typename _UAbi&gt;
    _GLIBCXX_SIMD_INTRINSIC static constexpr bool
    _S_convert(simd_mask&lt;_Up, _UAbi&gt; __x)
    { return __x[0]; }

  // }}}
  // _S_from_bitmask {{{2
  template &lt;typename _Tp&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool
    _S_from_bitmask(_SanitizedBitMask&lt;1&gt; __bits, _TypeTag&lt;_Tp&gt;) noexcept
    { return __bits[0]; }

  // _S_masked_load {{{2
  _GLIBCXX_SIMD_INTRINSIC constexpr static bool
  _S_masked_load(bool __merge, bool __mask, const bool* __mem) noexcept
  {
    if (__mask)
      __merge = __mem[0];
    return __merge;
  }

  // _S_store {{{2
  _GLIBCXX_SIMD_INTRINSIC static void _S_store(bool __v, bool* __mem) noexcept
  { __mem[0] = __v; }

  // _S_masked_store {{{2
  _GLIBCXX_SIMD_INTRINSIC static void
  _S_masked_store(const bool __v, bool* __mem, const bool __k) noexcept
  {
    if (__k)
      __mem[0] = __v;
  }

  // logical and bitwise operators {{{2
  static constexpr bool _S_logical_and(bool __x, bool __y)
  { return __x &amp;&amp; __y; }

  static constexpr bool _S_logical_or(bool __x, bool __y)
  { return __x || __y; }

  static constexpr bool _S_bit_not(bool __x)
  { return !__x; }

  static constexpr bool _S_bit_and(bool __x, bool __y)
  { return __x &amp;&amp; __y; }

  static constexpr bool _S_bit_or(bool __x, bool __y)
  { return __x || __y; }

  static constexpr bool _S_bit_xor(bool __x, bool __y)
  { return __x != __y; }

  // smart_reference access {{{2
  constexpr static void _S_set(bool&amp; __k, [[maybe_unused]] int __i,
			       bool __x) noexcept
  {
    _GLIBCXX_DEBUG_ASSERT(__i == 0);
    __k = __x;
  }

  // _S_masked_assign {{{2
  _GLIBCXX_SIMD_INTRINSIC static void _S_masked_assign(bool __k, bool&amp; __lhs,
						       bool __rhs)
  {
    if (__k)
      __lhs = __rhs;
  }

  // }}}2
  // _S_all_of {{{
  template &lt;typename _Tp, typename _Abi&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool
    _S_all_of(simd_mask&lt;_Tp, _Abi&gt; __k)
    { return __k._M_data; }

  // }}}
  // _S_any_of {{{
  template &lt;typename _Tp, typename _Abi&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool
    _S_any_of(simd_mask&lt;_Tp, _Abi&gt; __k)
    { return __k._M_data; }

  // }}}
  // _S_none_of {{{
  template &lt;typename _Tp, typename _Abi&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool
    _S_none_of(simd_mask&lt;_Tp, _Abi&gt; __k)
    { return !__k._M_data; }

  // }}}
  // _S_some_of {{{
  template &lt;typename _Tp, typename _Abi&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static bool
    _S_some_of(simd_mask&lt;_Tp, _Abi&gt;)
    { return false; }

  // }}}
  // _S_popcount {{{
  template &lt;typename _Tp, typename _Abi&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static int
    _S_popcount(simd_mask&lt;_Tp, _Abi&gt; __k)
    { return __k._M_data; }

  // }}}
  // _S_find_first_set {{{
  template &lt;typename _Tp, typename _Abi&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static int
    _S_find_first_set(simd_mask&lt;_Tp, _Abi&gt;)
    { return 0; }

  // }}}
  // _S_find_last_set {{{
  template &lt;typename _Tp, typename _Abi&gt;
    _GLIBCXX_SIMD_INTRINSIC constexpr static int
    _S_find_last_set(simd_mask&lt;_Tp, _Abi&gt;)
    { return 0; }

  // }}}
};

// }}}

_GLIBCXX_SIMD_END_NAMESPACE
#endif // __cplusplus &gt;= 201703L
#endif // _GLIBCXX_EXPERIMENTAL_SIMD_SCALAR_H_

// vim: foldmethod=marker sw=2 noet ts=8 sts=2 tw=80
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Finclude%2Fc%2B%2B%2F11%2Fexperimental%2Fbits'>Back to Directory</a>