arm_sve-inl.h File Reference
`#include <arm_sve.h>`
`#include <stddef.h>`
`#include <stdint.h>`
`#include "hwy/base.h"`
`#include "hwy/ops/shared-inl.h"`

Go to the source code of this file.

## Classes

struct | hwy::HWY_NAMESPACE::DFromV_t< V >
struct | hwy::HWY_NAMESPACE::CompressIsPartition< T >

## Namespaces

namespace | hwy
namespace | hwy::HWY_NAMESPACE
namespace | hwy::HWY_NAMESPACE::detail

## Macros

#define | HWY_SVE_IS_POW2 1
#define | HWY_SVE_FOREACH_U08(X_MACRO, NAME, OP) X_MACRO(uint, u, 8, 8, NAME, OP)
#define | HWY_SVE_FOREACH_U16(X_MACRO, NAME, OP) X_MACRO(uint, u, 16, 8, NAME, OP)
#define | HWY_SVE_FOREACH_U32(X_MACRO, NAME, OP) X_MACRO(uint, u, 32, 16, NAME, OP)
#define | HWY_SVE_FOREACH_U64(X_MACRO, NAME, OP) X_MACRO(uint, u, 64, 32, NAME, OP)
#define | HWY_SVE_FOREACH_I08(X_MACRO, NAME, OP) X_MACRO(int, s, 8, 8, NAME, OP)
#define | HWY_SVE_FOREACH_I16(X_MACRO, NAME, OP) X_MACRO(int, s, 16, 8, NAME, OP)
#define | HWY_SVE_FOREACH_I32(X_MACRO, NAME, OP) X_MACRO(int, s, 32, 16, NAME, OP)
#define | HWY_SVE_FOREACH_I64(X_MACRO, NAME, OP) X_MACRO(int, s, 64, 32, NAME, OP)
#define | HWY_SVE_FOREACH_F16(X_MACRO, NAME, OP) X_MACRO(float, f, 16, 16, NAME, OP)
#define | HWY_SVE_FOREACH_F32(X_MACRO, NAME, OP) X_MACRO(float, f, 32, 16, NAME, OP)
#define | HWY_SVE_FOREACH_F64(X_MACRO, NAME, OP) X_MACRO(float, f, 64, 32, NAME, OP)
#define | HWY_SVE_FOREACH_U(X_MACRO, NAME, OP)
#define | HWY_SVE_FOREACH_I(X_MACRO, NAME, OP)
#define | HWY_SVE_FOREACH_F(X_MACRO, NAME, OP)
#define | HWY_SVE_FOREACH_UI08(X_MACRO, NAME, OP)
#define | HWY_SVE_FOREACH_UI16(X_MACRO, NAME, OP)
#define | HWY_SVE_FOREACH_UI32(X_MACRO, NAME, OP)
#define | HWY_SVE_FOREACH_UI64(X_MACRO, NAME, OP)
#define | HWY_SVE_FOREACH_UIF3264(X_MACRO, NAME, OP)
#define | HWY_SVE_FOREACH_UI(X_MACRO, NAME, OP)
#define | HWY_SVE_FOREACH_IF(X_MACRO, NAME, OP)
#define | HWY_SVE_FOREACH(X_MACRO, NAME, OP)
#define | HWY_SVE_T(BASE, BITS) BASE##BITS##_t
#define | HWY_SVE_D(BASE, BITS, N, POW2) Simd<HWY_SVE_T(BASE, BITS), N, POW2>
#define | HWY_SVE_V(BASE, BITS) sv##BASE##BITS##_t
#define | HWY_SPECIALIZE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_RETV_ARGPV(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_RETV_ARGV(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_RETV_ARGPVN(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_RETV_ARGVN(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_RETV_ARGPVV(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_RETV_ARGVV(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_RETV_ARGVVV(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_ALL_PTRUE(BITS) svptrue_pat_b##BITS(SV_ALL)
#define | HWY_SVE_PTRUE(BITS) HWY_SVE_ALL_PTRUE(BITS)
#define | HWY_SVE_FIRSTN(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_WRAP_PTRUE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_SET(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_UNDEFINED(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_CAST_NOP(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_CAST(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_RETV_ARGPVN_SWAP(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_RETV_ARGPVV_SWAP(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_NATIVE_POPCNT
#define | HWY_SVE_POPCNT(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_RETV_ARGPVN_MASK(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_SHIFT_N(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_SHIFT(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_NATIVE_I64MULLO
#define | HWY_SVE_FMA(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_COUNT_TRUE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_COUNT_TRUE_FULL(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_IF_THEN_ELSE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_COMPARE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_COMPARE_N(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_IF_VEC(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_LOAD(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_MASKED_LOAD(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_LOAD_DUP128(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_STORE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_BLENDED_STORE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_SCATTER_OFFSET(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_SCATTER_INDEX(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_GATHER_OFFSET(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_GATHER_INDEX(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_NATIVE_LOAD_STORE_INTERLEAVED
#define | HWY_SVE_LOAD2(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_LOAD3(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_LOAD4(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_STORE2(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_STORE3(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_STORE4(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_PROMOTE_TO(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_CONCAT_EVERY_SECOND(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_SPLICE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_CONVERT(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_IOTA(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_EXT(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_REDUCE_ADD(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_REDUCE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_GET_LANE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_ODD_EVEN(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_TABLE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_REVERSE(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_COMPRESS(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_BROADCAST(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_MUL_EVEN(BASE, CHAR, BITS, HALF, NAME, OP)
#define | HWY_SVE_DUP(BASE, CHAR, BITS, HALF, NAME, OP)

## Typedefs

template<class D >
using | hwy::HWY_NAMESPACE::MFromD = decltype(FirstN(D(), 0))

## Functions

| HWY_BEFORE_NAMESPACE ()
HWY_INLINE size_t | hwy::HWY_NAMESPACE::detail::AllHardwareLanes (hwy::SizeTag< 1 >)
HWY_INLINE size_t | hwy::HWY_NAMESPACE::detail::AllHardwareLanes (hwy::SizeTag< 2 >)
HWY_INLINE size_t | hwy::HWY_NAMESPACE::detail::AllHardwareLanes (hwy::SizeTag< 4 >)
HWY_INLINE size_t | hwy::HWY_NAMESPACE::detail::AllHardwareLanes (hwy::SizeTag< 8 >)
template<typename T , size_t N, int kPow2>
HWY_API constexpr size_t | hwy::HWY_NAMESPACE::Lanes (Simd< T, N, kPow2 >)
HWY_API svbool_t | hwy::HWY_NAMESPACE::detail::PFalse ()
template<class D >
svbool_t | hwy::HWY_NAMESPACE::detail::MakeMask (D d)
template<size_t N, int kPow2>
svuint16_t | hwy::HWY_NAMESPACE::Set (Simd< bfloat16_t, N, kPow2 > d, bfloat16_t arg)
template<class D >
VFromD< D > | hwy::HWY_NAMESPACE::Zero (D d)
template<size_t N, int kPow2>
HWY_INLINE svuint16_t | hwy::HWY_NAMESPACE::detail::BitCastFromByte (Simd< bfloat16_t, N, kPow2 >, svuint8_t v)
template<class D , class FromV >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::BitCast (D d, FromV v)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::And (const V a, const V b)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::Or (const V a, const V b)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::Xor (const V a, const V b)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::AndNot (const V a, const V b)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::Xor3 (const V x1, const V x2, const V x3)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Or3 (V o1, V o2, V o3)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::OrAnd (const V o, const V a1, const V a2)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::CopySign (const V magn, const V sign)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::CopySignToAbs (const V abs, const V sign)
HWY_API svuint64_t | hwy::HWY_NAMESPACE::SumsOf8 (const svuint8_t v)
template<int kBits, class V >
HWY_API V | hwy::HWY_NAMESPACE::RotateRight (const V v)
HWY_API svint16_t | hwy::HWY_NAMESPACE::MulFixedPoint15 (svint16_t a, svint16_t b)
template<class D , typename MFrom >
HWY_API svbool_t | hwy::HWY_NAMESPACE::RebindMask (const D, const MFrom mask)
HWY_API svbool_t | hwy::HWY_NAMESPACE::Not (svbool_t m)
HWY_API svbool_t | hwy::HWY_NAMESPACE::And (svbool_t a, svbool_t b)
HWY_API svbool_t | hwy::HWY_NAMESPACE::AndNot (svbool_t a, svbool_t b)
HWY_API svbool_t | hwy::HWY_NAMESPACE::Or (svbool_t a, svbool_t b)
HWY_API svbool_t | hwy::HWY_NAMESPACE::Xor (svbool_t a, svbool_t b)
HWY_API svbool_t | hwy::HWY_NAMESPACE::ExclusiveNeither (svbool_t a, svbool_t b)
template<class D >
HWY_API bool | hwy::HWY_NAMESPACE::AllFalse (D d, svbool_t m)
template<class D >
HWY_API bool | hwy::HWY_NAMESPACE::AllTrue (D d, svbool_t m)
template<class D >
HWY_API intptr_t | hwy::HWY_NAMESPACE::FindFirstTrue (D d, svbool_t m)
template<class D >
HWY_API size_t | hwy::HWY_NAMESPACE::FindKnownFirstTrue (D d, svbool_t m)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::IfThenElseZero (const svbool_t mask, const V yes)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::IfThenZeroElse (const svbool_t mask, const V no)
template<class V >
HWY_API svbool_t | hwy::HWY_NAMESPACE::Gt (const V a, const V b)
template<class V >
HWY_API svbool_t | hwy::HWY_NAMESPACE::Ge (const V a, const V b)
template<class V >
HWY_API svbool_t | hwy::HWY_NAMESPACE::TestBit (const V a, const V bit)
template<class V >
HWY_API svbool_t | hwy::HWY_NAMESPACE::MaskFromVec (const V v)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::VecFromMask (const D d, svbool_t mask)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::IfVecThenElse (const V mask, const V yes, const V no)
template<class V >
HWY_API svbool_t | hwy::HWY_NAMESPACE::IsNaN (const V v)
template<class V >
HWY_API svbool_t | hwy::HWY_NAMESPACE::IsInf (const V v)
template<class V >
HWY_API svbool_t | hwy::HWY_NAMESPACE::IsFinite (const V v)
template<size_t N, int kPow2>
HWY_API svuint16_t | hwy::HWY_NAMESPACE::Load (Simd< bfloat16_t, N, kPow2 > d, const bfloat16_t *HWY_RESTRICT p)
template<size_t N, int kPow2>
HWY_API void | hwy::HWY_NAMESPACE::Store (svuint16_t v, Simd< bfloat16_t, N, kPow2 > d, bfloat16_t *HWY_RESTRICT p)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::LoadU (D d, const TFromD< D > *HWY_RESTRICT p)
template<class V , class D >
HWY_API void | hwy::HWY_NAMESPACE::StoreU (const V v, D d, TFromD< D > *HWY_RESTRICT p)
template<size_t N, int kPow2>
HWY_API svuint32_t | hwy::HWY_NAMESPACE::PromoteTo (Simd< uint32_t, N, kPow2 > dto, svuint8_t vfrom)
template<size_t N, int kPow2>
HWY_API svint32_t | hwy::HWY_NAMESPACE::PromoteTo (Simd< int32_t, N, kPow2 > dto, svint8_t vfrom)
template<size_t N, int kPow2>
HWY_API svint16_t | hwy::HWY_NAMESPACE::PromoteTo (Simd< int16_t, N, kPow2 > dto, svuint8_t vfrom)
template<size_t N, int kPow2>
HWY_API svint32_t | hwy::HWY_NAMESPACE::PromoteTo (Simd< int32_t, N, kPow2 > dto, svuint16_t vfrom)
template<size_t N, int kPow2>
HWY_API svint32_t | hwy::HWY_NAMESPACE::PromoteTo (Simd< int32_t, N, kPow2 > dto, svuint8_t vfrom)
template<size_t N, int kPow2>
HWY_API svfloat32_t | hwy::HWY_NAMESPACE::PromoteTo (Simd< float32_t, N, kPow2 >, const svfloat16_t v)
template<size_t N, int kPow2>
HWY_API svfloat64_t | hwy::HWY_NAMESPACE::PromoteTo (Simd< float64_t, N, kPow2 >, const svfloat32_t v)
template<size_t N, int kPow2>
HWY_API svfloat64_t | hwy::HWY_NAMESPACE::PromoteTo (Simd< float64_t, N, kPow2 >, const svint32_t v)
template<size_t N, int kPow2>
HWY_API svfloat32_t | hwy::HWY_NAMESPACE::detail::PromoteUpperTo (Simd< float, N, kPow2 > df, svfloat16_t v)
template<typename TN , class VU >
VU | hwy::HWY_NAMESPACE::detail::SaturateU (VU v)
template<typename TN , class VI >
VI | hwy::HWY_NAMESPACE::detail::SaturateI (VI v)
template<size_t N, int kPow2>
HWY_API svuint8_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, kPow2 > dn, const svint16_t v)
template<size_t N, int kPow2>
HWY_API svuint16_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< uint16_t, N, kPow2 > dn, const svint32_t v)
template<size_t N, int kPow2>
HWY_API svuint8_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, kPow2 > dn, const svint32_t v)
HWY_API svuint8_t | hwy::HWY_NAMESPACE::U8FromU32 (const svuint32_t v)
template<size_t N, int kPow2>
HWY_API svuint8_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, kPow2 >, const svuint64_t v)
template<size_t N, int kPow2>
HWY_API svuint16_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, kPow2 >, const svuint64_t v)
template<size_t N, int kPow2>
HWY_API svuint32_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, kPow2 >, const svuint64_t v)
template<size_t N, int kPow2>
HWY_API svuint8_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, kPow2 >, const svuint32_t v)
template<size_t N, int kPow2>
HWY_API svuint16_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, kPow2 >, const svuint32_t v)
template<size_t N, int kPow2>
HWY_API svuint8_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, kPow2 >, const svuint16_t v)
template<size_t N, int kPow2>
HWY_API svint8_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, kPow2 > dn, const svint16_t v)
template<size_t N, int kPow2>
HWY_API svint16_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int16_t, N, kPow2 > dn, const svint32_t v)
template<size_t N, int kPow2>
HWY_API svint8_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, kPow2 > dn, const svint32_t v)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::ConcatOdd (D d, VFromD< D > hi, VFromD< D > lo)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::ConcatEven (D d, VFromD< D > hi, VFromD< D > lo)
template<size_t N, int kPow2>
HWY_API svfloat16_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< float16_t, N, kPow2 > d, const svfloat32_t v)
template<size_t N, int kPow2>
HWY_API svuint16_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< bfloat16_t, N, kPow2 >, svfloat32_t v)
template<size_t N, int kPow2>
HWY_API svfloat32_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< float32_t, N, kPow2 > d, const svfloat64_t v)
template<size_t N, int kPow2>
HWY_API svint32_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, kPow2 > d, const svfloat64_t v)
template<class VF , class DI = RebindToSigned<DFromV<VF>>>
HWY_API VFromD< DI > | hwy::HWY_NAMESPACE::NearestInt (VF v)
template<class D , HWY_IF_FLOAT_D(D) >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Iota (const D d, TFromD< D > first)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::InterleaveLower (D d, const V a, const V b)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::InterleaveLower (const V a, const V b)
template<class D , class V = VFromD<D>, hwy::EnableIf< detail::IsFull(D())> * = nullptr>
HWY_API V | hwy::HWY_NAMESPACE::InterleaveUpper (D d, const V a, const V b)
template<class D , HWY_IF_LANE_SIZE_D(D, 1) >
svbool_t | hwy::HWY_NAMESPACE::detail::MaskLowerHalf (D d)
template<class D >
svbool_t | hwy::HWY_NAMESPACE::detail::MaskUpperHalf (D d)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ConcatUpperLower (const D d, const V hi, const V lo)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ConcatLowerLower (const D d, const V hi, const V lo)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ConcatLowerUpper (const D d, const V hi, const V lo)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ConcatUpperUpper (const D d, const V hi, const V lo)
template<class D , class V2 >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Combine (const D d, const V2 hi, const V2 lo)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ZeroExtendVector (const D d, const V lo)
template<class D2 , class V >
HWY_API V | hwy::HWY_NAMESPACE::LowerHalf (D2, const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::LowerHalf (const V v)
template<class DH , class V >
HWY_API V | hwy::HWY_NAMESPACE::UpperHalf (const DH dh, const V v)
template<class D , class V >
V | hwy::HWY_NAMESPACE::SumOfLanes (D d, V v)
template<class D , class V >
V | hwy::HWY_NAMESPACE::MinOfLanes (D d, V v)
template<class D , class V >
V | hwy::HWY_NAMESPACE::MaxOfLanes (D d, V v)
template<class V >
HWY_API TFromV< V > | hwy::HWY_NAMESPACE::GetLane (const V v)
template<class V >
HWY_API TFromV< V > | hwy::HWY_NAMESPACE::ExtractLane (V v, size_t i)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::InsertLane (const V v, size_t i, TFromV< V > t)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::DupEven (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::DupOdd (const V v)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::OddEven (const V odd, const V even)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::OddEvenBlocks (const V odd, const V even)
template<class D , class VI >
HWY_API VFromD< RebindToUnsigned< D > > | hwy::HWY_NAMESPACE::IndicesFromVec (D d, VI vec)
template<class D , typename TI >
HWY_API VFromD< RebindToUnsigned< D > > | hwy::HWY_NAMESPACE::SetTableIndices (D d, const TI *idx)
template<typename T , size_t N, int kPow2>
constexpr size_t | hwy::HWY_NAMESPACE::detail::LanesPerBlock (Simd< T, N, kPow2 >)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::SwapAdjacentBlocks (const V v)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::Reverse (D d, V v)
template<class D , HWY_IF_LANE_SIZE_D(D, 2) >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Reverse2 (D d, const VFromD< D > v)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Reverse4 (D d, const VFromD< D > v)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Reverse8 (D d, const VFromD< D > v)
template<class V , HWY_IF_LANE_SIZE_V(V, 8) >
HWY_API V | hwy::HWY_NAMESPACE::Compress (V v, svbool_t mask)
HWY_API svfloat16_t | hwy::HWY_NAMESPACE::Compress (svfloat16_t v, svbool_t mask16)
template<class V , typename T = TFromV<V>, HWY_IF_LANE_SIZE_ONE_OF(T, 0x14) >
HWY_API V | hwy::HWY_NAMESPACE::CompressNot (V v, const svbool_t mask)
template<class V , HWY_IF_LANE_SIZE_V(V, 8) >
HWY_API V | hwy::HWY_NAMESPACE::CompressNot (V v, svbool_t mask)
HWY_API svuint64_t | hwy::HWY_NAMESPACE::CompressBlocksNot (svuint64_t v, svbool_t mask)
template<class V , class D , HWY_IF_NOT_LANE_SIZE_D(D, 1) >
HWY_API size_t | hwy::HWY_NAMESPACE::CompressStore (const V v, const svbool_t mask, const D d, TFromD< D > *HWY_RESTRICT unaligned)
template<class V , class D , HWY_IF_NOT_LANE_SIZE_D(D, 1) >
HWY_API size_t | hwy::HWY_NAMESPACE::CompressBlendedStore (const V v, const svbool_t mask, const D d, TFromD< D > *HWY_RESTRICT unaligned)
template<size_t kBytes, class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::CombineShiftRightBytes (const D d, const V hi, const V lo)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle2301 (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle2103 (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle0321 (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle1032 (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle01 (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle0123 (const V v)
template<class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::ReverseBlocks (D d, V v)
template<class V , class VI >
HWY_API VI | hwy::HWY_NAMESPACE::TableLookupBytes (const V v, const VI idx)
template<class V , class VI >
HWY_API VI | hwy::HWY_NAMESPACE::TableLookupBytesOr0 (const V bytes, const VI from)
template<int kLane, class V >
HWY_API V | hwy::HWY_NAMESPACE::Broadcast (const V v)
template<size_t kLanes, class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::ShiftLeftLanes (D d, const V v)
template<size_t kLanes, class V >
HWY_API V | hwy::HWY_NAMESPACE::ShiftLeftLanes (const V v)
template<size_t kLanes, class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::ShiftRightLanes (D d, V v)
template<int kBytes, class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::ShiftLeftBytes (const D d, const V v)
template<int kBytes, class V >
HWY_API V | hwy::HWY_NAMESPACE::ShiftLeftBytes (const V v)
template<int kBytes, class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::ShiftRightBytes (const D d, const V v)
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > | hwy::HWY_NAMESPACE::ZipLower (DW dw, V a, V b)
template<class V , class D = DFromV<V>, class DW = RepartitionToWide<D>>
HWY_API VFromD< DW > | hwy::HWY_NAMESPACE::ZipLower (const V a, const V b)
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > | hwy::HWY_NAMESPACE::ZipUpper (DW dw, V a, V b)
template<size_t N, int kPow2>
HWY_API svfloat32_t | hwy::HWY_NAMESPACE::PromoteTo (Simd< float32_t, N, kPow2 > df32, const svuint16_t v)
template<size_t N, int kPow2>
HWY_API svuint16_t | hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< bfloat16_t, N, kPow2 > dbf16, svfloat32_t a, svfloat32_t b)
template<size_t N, int kPow2>
HWY_API svint16_t | hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< int16_t, N, kPow2 > d16, svint32_t a, svint32_t b)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::ZeroIfNegative (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::BroadcastSignBit (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::IfNegativeThenElse (V v, V yes, V no)
template<class D , HWY_IF_LANE_SIZE_D(D, 1) >
HWY_INLINE svbool_t | hwy::HWY_NAMESPACE::LoadMaskBits (D d, const uint8_t *HWY_RESTRICT bits)
template<class T , HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINE svuint8_t | hwy::HWY_NAMESPACE::detail::BoolFromMask (svbool_t m)
HWY_INLINE svuint64_t | hwy::HWY_NAMESPACE::detail::BitsFromBool (svuint8_t x)
template<class D >
HWY_API size_t | hwy::HWY_NAMESPACE::StoreMaskBits (D d, svbool_t m, uint8_t *bits)
template<class V , class D = DFromV<V>, HWY_IF_NOT_LANE_SIZE_D(D, 1) >
HWY_INLINE V | hwy::HWY_NAMESPACE::CompressBits (V v, const uint8_t *HWY_RESTRICT bits)
template<class D , HWY_IF_NOT_LANE_SIZE_D(D, 1) >
HWY_API size_t | hwy::HWY_NAMESPACE::CompressBitsStore (VFromD< D > v, const uint8_t *HWY_RESTRICT bits, D d, TFromD< D > *HWY_RESTRICT unaligned)
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > | hwy::HWY_NAMESPACE::MulEven (const V a, const V b)
HWY_API svuint64_t | hwy::HWY_NAMESPACE::MulEven (const svuint64_t a, const svuint64_t b)
HWY_API svuint64_t | hwy::HWY_NAMESPACE::MulOdd (const svuint64_t a, const svuint64_t b)
template<size_t N, int kPow2>
HWY_API svfloat32_t | hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< float, N, kPow2 > df32, svuint16_t a, svuint16_t b, const svfloat32_t sum0, svfloat32_t &sum1)
template<size_t N, int kPow2>
HWY_API svint32_t | hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< int32_t, N, kPow2 > d32, svint16_t a, svint16_t b, const svint32_t sum0, svint32_t &sum1)
template<class VW >
HWY_API VW | hwy::HWY_NAMESPACE::RearrangeToOddPlusEven (const VW sum0, const VW sum1)
template<class D >
HWY_INLINE svuint64_t | hwy::HWY_NAMESPACE::detail::Lt128Vec (D d, const svuint64_t a, const svuint64_t b)
template<class D >
HWY_INLINE svbool_t | hwy::HWY_NAMESPACE::Lt128 (D d, const svuint64_t a, const svuint64_t b)
template<class D >
HWY_INLINE svbool_t | hwy::HWY_NAMESPACE::Lt128Upper (D d, svuint64_t a, svuint64_t b)
template<class D >
HWY_INLINE svuint64_t | hwy::HWY_NAMESPACE::detail::Eq128Vec (D d, const svuint64_t a, const svuint64_t b)
template<class D >
HWY_INLINE svuint64_t | hwy::HWY_NAMESPACE::detail::Ne128Vec (D d, const svuint64_t a, const svuint64_t b)
template<class D >
HWY_INLINE svbool_t | hwy::HWY_NAMESPACE::Eq128 (D d, const svuint64_t a, const svuint64_t b)
template<class D >
HWY_INLINE svbool_t | hwy::HWY_NAMESPACE::Ne128 (D d, const svuint64_t a, const svuint64_t b)
template<class D >
HWY_INLINE svbool_t | hwy::HWY_NAMESPACE::Eq128Upper (D d, svuint64_t a, svuint64_t b)
template<class D >
HWY_INLINE svbool_t | hwy::HWY_NAMESPACE::Ne128Upper (D d, svuint64_t a, svuint64_t b)
template<class D >
HWY_INLINE svuint64_t | hwy::HWY_NAMESPACE::Min128 (D d, const svuint64_t a, const svuint64_t b)
template<class D >
HWY_INLINE svuint64_t | hwy::HWY_NAMESPACE::Max128 (D d, const svuint64_t a, const svuint64_t b)
template<class D >
HWY_INLINE svuint64_t | hwy::HWY_NAMESPACE::Min128Upper (D d, const svuint64_t a, const svuint64_t b)
template<class D >
HWY_INLINE svuint64_t | hwy::HWY_NAMESPACE::Max128Upper (D d, const svuint64_t a, const svuint64_t b)
| HWY_AFTER_NAMESPACE ()

## Macro Definition Documentation

## HWY_NATIVE_I64MULLO

#define HWY_NATIVE_I64MULLO

## HWY_NATIVE_LOAD_STORE_INTERLEAVED

#define HWY_NATIVE_LOAD_STORE_INTERLEAVED

## HWY_NATIVE_POPCNT

#define HWY_NATIVE_POPCNT

## HWY_SPECIALIZE

#define HWY_SPECIALIZE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <> \
struct DFromV_t<HWY_SVE_V(BASE, BITS)> { \
using type = ScalableTag<HWY_SVE_T(BASE, BITS)>; \
};
HWY_SVE_V
#define HWY_SVE_V(BASE, BITS)
Definition arm_sve-inl.h:134
HWY_SVE_T
#define HWY_SVE_T(BASE, BITS)
Definition arm_sve-inl.h:132

## HWY_SVE_ALL_PTRUE

#define HWY_SVE_ALL_PTRUE | ( |  | BITS | ) | svptrue_pat_b##BITS(SV_ALL)

## HWY_SVE_BLENDED_STORE

#define HWY_SVE_BLENDED_STORE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v, svbool_t m, \
HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT p) { \
sv##OP##_##CHAR##BITS(m, p, v); \
}
HWY_SVE_D
#define HWY_SVE_D(BASE, BITS, N, POW2)
Definition arm_sve-inl.h:133
HWY_RESTRICT
#define HWY_RESTRICT
Definition base.h:64
HWY_API
#define HWY_API
Definition base.h:129

## HWY_SVE_BROADCAST

#define HWY_SVE_BROADCAST | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <int kLane> \
HWY_INLINE HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS(v, kLane); \
}
HWY_INLINE
#define HWY_INLINE
Definition base.h:70

## HWY_SVE_CAST

#define HWY_SVE_CAST | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_INLINE svuint8_t BitCastToByte(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_u8_##CHAR##BITS(v); \
} \
template <size_t N, int kPow2> \
HWY_INLINE HWY_SVE_V(BASE, BITS) \
BitCastFromByte(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, svuint8_t v) { \
return sv##OP##_##CHAR##BITS##_u8(v); \
}

## HWY_SVE_CAST_NOP

#define HWY_SVE_CAST_NOP | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) BitCastToByte(HWY_SVE_V(BASE, BITS) v) { \
return v; \
} \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) BitCastFromByte( \
HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, HWY_SVE_V(BASE, BITS) v) { \
return v; \
}

## HWY_SVE_COMPARE

#define HWY_SVE_COMPARE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API svbool_t NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS(HWY_SVE_PTRUE(BITS), a, b); \
}
HWY_SVE_PTRUE
#define HWY_SVE_PTRUE(BITS)
Definition arm_sve-inl.h:213

## HWY_SVE_COMPARE_N

#define HWY_SVE_COMPARE_N | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API svbool_t NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_T(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS(HWY_SVE_PTRUE(BITS), a, b); \
}

## HWY_SVE_COMPRESS

#define HWY_SVE_COMPRESS | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v, svbool_t mask) { \
return sv##OP##_##CHAR##BITS(mask, v); \
}

## HWY_SVE_CONCAT_EVERY_SECOND

#define HWY_SVE_CONCAT_EVERY_SECOND | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_INLINE HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) hi, HWY_SVE_V(BASE, BITS) lo) { \
return sv##OP##_##CHAR##BITS(lo, hi); \
}

## HWY_SVE_CONVERT

#define HWY_SVE_CONVERT | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
/* signed integers */ \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, HWY_SVE_V(int, BITS) v) { \
return sv##OP##_##CHAR##BITS##_s##BITS##_x(HWY_SVE_PTRUE(BITS), v); \
} \
/* unsigned integers */ \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, HWY_SVE_V(uint, BITS) v) { \
return sv##OP##_##CHAR##BITS##_u##BITS##_x(HWY_SVE_PTRUE(BITS), v); \
} \
/* Truncates (rounds toward zero). */ \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(int, BITS) \
NAME(HWY_SVE_D(int, BITS, N, kPow2) /* d */, HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_s##BITS##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v); \
}

## HWY_SVE_COUNT_TRUE

#define HWY_SVE_COUNT_TRUE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API size_t NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, svbool_t m) { \
return sv##OP##_b##BITS(detail::MakeMask(d), m); \
}

## HWY_SVE_COUNT_TRUE_FULL

#define HWY_SVE_COUNT_TRUE_FULL | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API size_t NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, svbool_t m) { \
return sv##OP##_b##BITS(svptrue_b##BITS(), m); \
}

## HWY_SVE_D

#define HWY_SVE_D | ( |  | BASE,
|  |  | BITS,
|  |  | N,
|  |  | POW2
| ) |  | Simd<HWY_SVE_T(BASE, BITS), N, POW2>

## HWY_SVE_DUP

#define HWY_SVE_DUP | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API svbool_t NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /*d*/, svbool_t m) { \
return sv##OP##_b##BITS(m, m); \
}

## HWY_SVE_EXT

#define HWY_SVE_EXT | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t kIndex> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) hi, HWY_SVE_V(BASE, BITS) lo) { \
return sv##OP##_##CHAR##BITS(lo, hi, kIndex); \
}

## HWY_SVE_FIRSTN

#define HWY_SVE_FIRSTN | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API svbool_t NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, size_t count) { \
const size_t limit = detail::IsFull(d) ? count : HWY_MIN(Lanes(d), count); \
return sv##OP##_b##BITS##_u32(uint32_t{0}, static_cast<uint32_t>(limit)); \
}
HWY_MIN
#define HWY_MIN(a, b)
Definition base.h:134

## HWY_SVE_FMA

#define HWY_SVE_FMA | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) mul, HWY_SVE_V(BASE, BITS) x, \
HWY_SVE_V(BASE, BITS) add) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), x, mul, add); \
}

## HWY_SVE_FOREACH

#define HWY_SVE_FOREACH | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_U(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F(X_MACRO, NAME, OP)
HWY_SVE_FOREACH_U
#define HWY_SVE_FOREACH_U(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:77

## HWY_SVE_FOREACH_F

#define HWY_SVE_FOREACH_F | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_F16(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F64(X_MACRO, NAME, OP)
HWY_SVE_FOREACH_F16
#define HWY_SVE_FOREACH_F16(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:69

## HWY_SVE_FOREACH_F16

#define HWY_SVE_FOREACH_F16 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(float, f, 16, 16, NAME, OP)

## HWY_SVE_FOREACH_F32

#define HWY_SVE_FOREACH_F32 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(float, f, 32, 16, NAME, OP)

## HWY_SVE_FOREACH_F64

#define HWY_SVE_FOREACH_F64 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(float, f, 64, 32, NAME, OP)

## HWY_SVE_FOREACH_I

#define HWY_SVE_FOREACH_I | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_I08(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I16(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I64(X_MACRO, NAME, OP)
HWY_SVE_FOREACH_I08
#define HWY_SVE_FOREACH_I08(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:63

## HWY_SVE_FOREACH_I08

#define HWY_SVE_FOREACH_I08 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(int, s, 8, 8, NAME, OP)

## HWY_SVE_FOREACH_I16

#define HWY_SVE_FOREACH_I16 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(int, s, 16, 8, NAME, OP)

## HWY_SVE_FOREACH_I32

#define HWY_SVE_FOREACH_I32 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(int, s, 32, 16, NAME, OP)

## HWY_SVE_FOREACH_I64

#define HWY_SVE_FOREACH_I64 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(int, s, 64, 32, NAME, OP)

## HWY_SVE_FOREACH_IF

#define HWY_SVE_FOREACH_IF | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_I(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F(X_MACRO, NAME, OP)
HWY_SVE_FOREACH_I
#define HWY_SVE_FOREACH_I(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:83

## HWY_SVE_FOREACH_U

#define HWY_SVE_FOREACH_U | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_U08(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_U16(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_U32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_U64(X_MACRO, NAME, OP)
HWY_SVE_FOREACH_U08
#define HWY_SVE_FOREACH_U08(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:55

## HWY_SVE_FOREACH_U08

#define HWY_SVE_FOREACH_U08 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(uint, u, 8, 8, NAME, OP)

## HWY_SVE_FOREACH_U16

#define HWY_SVE_FOREACH_U16 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(uint, u, 16, 8, NAME, OP)

## HWY_SVE_FOREACH_U32

#define HWY_SVE_FOREACH_U32 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(uint, u, 32, 16, NAME, OP)

## HWY_SVE_FOREACH_U64

#define HWY_SVE_FOREACH_U64 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(uint, u, 64, 32, NAME, OP)

## HWY_SVE_FOREACH_UI

#define HWY_SVE_FOREACH_UI | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_U(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I(X_MACRO, NAME, OP)

## HWY_SVE_FOREACH_UI08

#define HWY_SVE_FOREACH_UI08 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_U08(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I08(X_MACRO, NAME, OP)

## HWY_SVE_FOREACH_UI16

#define HWY_SVE_FOREACH_UI16 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_U16(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I16(X_MACRO, NAME, OP)
HWY_SVE_FOREACH_U16
#define HWY_SVE_FOREACH_U16(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:56

## HWY_SVE_FOREACH_UI32

#define HWY_SVE_FOREACH_UI32 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_U32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I32(X_MACRO, NAME, OP)
HWY_SVE_FOREACH_U32
#define HWY_SVE_FOREACH_U32(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:57

## HWY_SVE_FOREACH_UI64

#define HWY_SVE_FOREACH_UI64 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_U64(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I64(X_MACRO, NAME, OP)
HWY_SVE_FOREACH_U64
#define HWY_SVE_FOREACH_U64(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:59

## HWY_SVE_FOREACH_UIF3264

#define HWY_SVE_FOREACH_UIF3264 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_SVE_FOREACH_UI32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_UI64(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F64(X_MACRO, NAME, OP)
HWY_SVE_FOREACH_UI32
#define HWY_SVE_FOREACH_UI32(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:103

## HWY_SVE_GATHER_INDEX

#define HWY_SVE_GATHER_INDEX | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT base, \
HWY_SVE_V(int, BITS) index) { \
return sv##OP##_s##BITS##index_##CHAR##BITS(detail::MakeMask(d), base, \
index); \
}

## HWY_SVE_GATHER_OFFSET

#define HWY_SVE_GATHER_OFFSET | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT base, \
HWY_SVE_V(int, BITS) offset) { \
return sv##OP##_s##BITS##offset_##CHAR##BITS(detail::MakeMask(d), base, \
offset); \
}

## HWY_SVE_GET_LANE

#define HWY_SVE_GET_LANE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_INLINE HWY_SVE_T(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) v, svbool_t mask) { \
return sv##OP##_##CHAR##BITS(mask, v); \
}

## HWY_SVE_IF_THEN_ELSE

#define HWY_SVE_IF_THEN_ELSE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(svbool_t m, HWY_SVE_V(BASE, BITS) yes, HWY_SVE_V(BASE, BITS) no) { \
return sv##OP##_##CHAR##BITS(m, yes, no); \
}

## HWY_SVE_IF_VEC

#define HWY_SVE_IF_VEC | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) mask, HWY_SVE_V(BASE, BITS) yes, \
HWY_SVE_V(BASE, BITS) no) { \
return sv##OP##_##CHAR##BITS(yes, no, mask); \
}

## HWY_SVE_IOTA

#define HWY_SVE_IOTA | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, \
HWY_SVE_T(BASE, BITS) first) { \
return sv##OP##_##CHAR##BITS(first, 1); \
}

## HWY_SVE_IS_POW2

#define HWY_SVE_IS_POW2 1

## HWY_SVE_LOAD

#define HWY_SVE_LOAD | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT p) { \
return sv##OP##_##CHAR##BITS(detail::MakeMask(d), p); \
}

## HWY_SVE_LOAD2

#define HWY_SVE_LOAD2 | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned, \
HWY_SVE_V(BASE, BITS) & v0, HWY_SVE_V(BASE, BITS) & v1) { \
const sv##BASE##BITS##x2_t tuple = \
sv##OP##_##CHAR##BITS(detail::MakeMask(d), unaligned); \
v0 = svget2(tuple, 0); \
v1 = svget2(tuple, 1); \
}

## HWY_SVE_LOAD3

#define HWY_SVE_LOAD3 | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned, \
HWY_SVE_V(BASE, BITS) & v0, HWY_SVE_V(BASE, BITS) & v1, \
HWY_SVE_V(BASE, BITS) & v2) { \
const sv##BASE##BITS##x3_t tuple = \
sv##OP##_##CHAR##BITS(detail::MakeMask(d), unaligned); \
v0 = svget3(tuple, 0); \
v1 = svget3(tuple, 1); \
v2 = svget3(tuple, 2); \
}

## HWY_SVE_LOAD4

#define HWY_SVE_LOAD4 | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned, \
HWY_SVE_V(BASE, BITS) & v0, HWY_SVE_V(BASE, BITS) & v1, \
HWY_SVE_V(BASE, BITS) & v2, HWY_SVE_V(BASE, BITS) & v3) { \
const sv##BASE##BITS##x4_t tuple = \
sv##OP##_##CHAR##BITS(detail::MakeMask(d), unaligned); \
v0 = svget4(tuple, 0); \
v1 = svget4(tuple, 1); \
v2 = svget4(tuple, 2); \
v3 = svget4(tuple, 3); \
}

## HWY_SVE_LOAD_DUP128

#define HWY_SVE_LOAD_DUP128 | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT p) { \
/* All-true predicate to load all 128 bits. */ \
return sv##OP##_##CHAR##BITS(HWY_SVE_PTRUE(8), p); \
}

## HWY_SVE_MASKED_LOAD

#define HWY_SVE_MASKED_LOAD | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(svbool_t m, HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT p) { \
return sv##OP##_##CHAR##BITS(m, p); \
}

## HWY_SVE_MUL_EVEN

#define HWY_SVE_MUL_EVEN | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, HALF) a, HWY_SVE_V(BASE, HALF) b) { \
return sv##OP##_##CHAR##BITS(a, b); \
}

## HWY_SVE_ODD_EVEN

#define HWY_SVE_ODD_EVEN | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) odd, HWY_SVE_V(BASE, BITS) even) { \
return sv##OP##_##CHAR##BITS(even, odd, /*xor=*/0); \
}

## HWY_SVE_POPCNT

#define HWY_SVE_POPCNT | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return BitCast(DFromV<decltype(v)>(), \
sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v)); \
}

## HWY_SVE_PROMOTE_TO

#define HWY_SVE_PROMOTE_TO | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) NAME( \
HWY_SVE_D(BASE, BITS, N, kPow2) /* tag */, HWY_SVE_V(BASE, HALF) v) { \
return sv##OP##_##CHAR##BITS(v); \
}

## HWY_SVE_PTRUE

#define HWY_SVE_PTRUE | ( |  | BITS | ) | HWY_SVE_ALL_PTRUE(BITS)

## HWY_SVE_REDUCE

#define HWY_SVE_REDUCE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_T(BASE, BITS) NAME(svbool_t pg, HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS(pg, v); \
}

## HWY_SVE_REDUCE_ADD

#define HWY_SVE_REDUCE_ADD | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_T(BASE, BITS) NAME(svbool_t pg, HWY_SVE_V(BASE, BITS) v) { \
/* The intrinsic returns [u]int64_t; truncate to T so we can broadcast. */ \
using T = HWY_SVE_T(BASE, BITS); \
using TU = MakeUnsigned<T>; \
constexpr uint64_t kMask = LimitsMax<TU>(); \
return static_cast<T>(static_cast<TU>( \
static_cast<uint64_t>(sv##OP##_##CHAR##BITS(pg, v)) & kMask)); \
}

## HWY_SVE_RETV_ARGPV

#define HWY_SVE_RETV_ARGPV | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v); \
}

## HWY_SVE_RETV_ARGPVN

#define HWY_SVE_RETV_ARGPVN | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_T(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), a, b); \
}

## HWY_SVE_RETV_ARGPVN_MASK

#define HWY_SVE_RETV_ARGPVN_MASK | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(svbool_t pg, HWY_SVE_V(BASE, BITS) a, HWY_SVE_T(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_z(pg, a, b); \
}

## HWY_SVE_RETV_ARGPVN_SWAP

#define HWY_SVE_RETV_ARGPVN_SWAP | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_T(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), b, a); \
}

## HWY_SVE_RETV_ARGPVV

#define HWY_SVE_RETV_ARGPVV | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), a, b); \
}

## HWY_SVE_RETV_ARGPVV_SWAP

#define HWY_SVE_RETV_ARGPVV_SWAP | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), b, a); \
}

## HWY_SVE_RETV_ARGV

#define HWY_SVE_RETV_ARGV | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS(v); \
}

## HWY_SVE_RETV_ARGVN

#define HWY_SVE_RETV_ARGVN | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_T(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS(a, b); \
}

## HWY_SVE_RETV_ARGVV

#define HWY_SVE_RETV_ARGVV | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS(a, b); \
}

## HWY_SVE_RETV_ARGVVV

#define HWY_SVE_RETV_ARGVVV | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b, \
HWY_SVE_V(BASE, BITS) c) { \
return sv##OP##_##CHAR##BITS(a, b, c); \
}

## HWY_SVE_REVERSE

#define HWY_SVE_REVERSE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS(v); \
}

## HWY_SVE_SCATTER_INDEX

#define HWY_SVE_SCATTER_INDEX | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API void NAME( \
HWY_SVE_V(BASE, BITS) v, HWY_SVE_D(BASE, BITS, N, kPow2) d, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT base, HWY_SVE_V(int, BITS) index) { \
sv##OP##_s##BITS##index_##CHAR##BITS(detail::MakeMask(d), base, index, v); \
}

## HWY_SVE_SCATTER_OFFSET

#define HWY_SVE_SCATTER_OFFSET | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v, \
HWY_SVE_D(BASE, BITS, N, kPow2) d, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT base, \
HWY_SVE_V(int, BITS) offset) { \
sv##OP##_s##BITS##offset_##CHAR##BITS(detail::MakeMask(d), base, offset, \
v); \
}

## HWY_SVE_SET

#define HWY_SVE_SET | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, \
HWY_SVE_T(BASE, BITS) arg) { \
return sv##OP##_##CHAR##BITS(arg); \
}

## HWY_SVE_SHIFT

#define HWY_SVE_SHIFT | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) v, HWY_SVE_V(BASE, BITS) bits) { \
const RebindToUnsigned<DFromV<decltype(v)>> du; \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v, \
BitCast(du, bits)); \
}

## HWY_SVE_SHIFT_N

#define HWY_SVE_SHIFT_N | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <int kBits> \
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v, kBits); \
} \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME##Same(HWY_SVE_V(BASE, BITS) v, HWY_SVE_T(uint, BITS) bits) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v, bits); \
}

## HWY_SVE_SPLICE

#define HWY_SVE_SPLICE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME( \
HWY_SVE_V(BASE, BITS) hi, HWY_SVE_V(BASE, BITS) lo, svbool_t mask) { \
return sv##OP##_##CHAR##BITS(mask, lo, hi); \
}

## HWY_SVE_STORE

#define HWY_SVE_STORE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v, \
HWY_SVE_D(BASE, BITS, N, kPow2) d, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT p) { \
sv##OP##_##CHAR##BITS(detail::MakeMask(d), p, v); \
}

## HWY_SVE_STORE2

#define HWY_SVE_STORE2 | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v0, HWY_SVE_V(BASE, BITS) v1, \
HWY_SVE_D(BASE, BITS, N, kPow2) d, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned) { \
const sv##BASE##BITS##x2_t tuple = svcreate2##_##CHAR##BITS(v0, v1); \
sv##OP##_##CHAR##BITS(detail::MakeMask(d), unaligned, tuple); \
}

## HWY_SVE_STORE3

#define HWY_SVE_STORE3 | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v0, HWY_SVE_V(BASE, BITS) v1, \
HWY_SVE_V(BASE, BITS) v2, \
HWY_SVE_D(BASE, BITS, N, kPow2) d, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned) { \
const sv##BASE##BITS##x3_t triple = svcreate3##_##CHAR##BITS(v0, v1, v2); \
sv##OP##_##CHAR##BITS(detail::MakeMask(d), unaligned, triple); \
}

## HWY_SVE_STORE4

#define HWY_SVE_STORE4 | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v0, HWY_SVE_V(BASE, BITS) v1, \
HWY_SVE_V(BASE, BITS) v2, HWY_SVE_V(BASE, BITS) v3, \
HWY_SVE_D(BASE, BITS, N, kPow2) d, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned) { \
const sv##BASE##BITS##x4_t quad = \
svcreate4##_##CHAR##BITS(v0, v1, v2, v3); \
sv##OP##_##CHAR##BITS(detail::MakeMask(d), unaligned, quad); \
}

## HWY_SVE_T

#define HWY_SVE_T | ( |  | BASE,
|  |  | BITS
| ) |  | BASE##BITS##_t

## HWY_SVE_TABLE

#define HWY_SVE_TABLE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) v, HWY_SVE_V(uint, BITS) idx) { \
return sv##OP##_##CHAR##BITS(v, idx); \
}

## HWY_SVE_UNDEFINED

#define HWY_SVE_UNDEFINED | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */) { \
return sv##OP##_##CHAR##BITS(); \
}

## HWY_SVE_V

#define HWY_SVE_V | ( |  | BASE,
|  |  | BITS
| ) |  | sv##BASE##BITS##_t

## HWY_SVE_WRAP_PTRUE

#define HWY_SVE_WRAP_PTRUE | ( |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | HALF,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N, int kPow2> \
HWY_API svbool_t NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */) { \
return HWY_SVE_PTRUE(BITS); \
} \
template <size_t N, int kPow2> \
HWY_API svbool_t All##NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */) { \
return HWY_SVE_ALL_PTRUE(BITS); \
}
HWY_SVE_ALL_PTRUE
#define HWY_SVE_ALL_PTRUE(BITS)
Definition arm_sve-inl.h:210

## Function Documentation

## HWY_AFTER_NAMESPACE()

HWY_AFTER_NAMESPACE | ( |  | ) |

## HWY_BEFORE_NAMESPACE()

HWY_BEFORE_NAMESPACE | ( |  | ) |