Grok  10.0.3
Classes | Namespaces | Macros | Typedefs | Functions | Variables
rvv-inl.h File Reference
#include <riscv_vector.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

 hwy
 
 hwy::HWY_NAMESPACE
 
 hwy::HWY_NAMESPACE::detail
 

Macros

#define HWY_RVV_IF_POW2_IN(D, min, max)    hwy::EnableIf<(min) <= Pow2(D()) && Pow2(D()) <= (max)>* = nullptr
 
#define HWY_RVV_FOREACH_B(X_MACRO, NAME, OP)
 
#define HWY_RVV_FOREACH_08_TRUNC(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16_TRUNC(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_32_TRUNC(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_64_TRUNC(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_08_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_32_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_64_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_08_LE2(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16_LE2(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_32_LE2(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_64_LE2(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_08_EXT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16_EXT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_32_EXT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_64_EXT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_08_ALL(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16_ALL(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_32_ALL(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_64_ALL(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_08_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16_VIRT(X_MACRO, BASE, CHAR, NAME, OP)    X_MACRO(BASE, CHAR, 16, 32, 8, mf4, mf2, mf8, -3, /*MLEN=*/64, NAME, OP)
 
#define HWY_RVV_FOREACH_32_VIRT(X_MACRO, BASE, CHAR, NAME, OP)    X_MACRO(BASE, CHAR, 32, 64, 16, mf2, m1, mf4, -2, /*MLEN=*/64, NAME, OP)
 
#define HWY_RVV_FOREACH_64_VIRT(X_MACRO, BASE, CHAR, NAME, OP)    X_MACRO(BASE, CHAR, 64, __, 32, m1, m2, mf2, -1, /*MLEN=*/64, NAME, OP)
 
#define HWY_RVV_FOREACH_08_ALL_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16_ALL_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_32_ALL_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_64_ALL_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_08_LE2_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16_LE2_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_32_LE2_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_64_LE2_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_08_EXT_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16_EXT_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_32_EXT_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_64_EXT_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_08_DEMOTE_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16_DEMOTE_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_32_DEMOTE_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_64_DEMOTE_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_08, LMULS)(X_MACRO, uint, u, NAME, OP)
 
#define HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_16, LMULS)(X_MACRO, uint, u, NAME, OP)
 
#define HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, uint, u, NAME, OP)
 
#define HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, uint, u, NAME, OP)
 
#define HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_08, LMULS)(X_MACRO, int, i, NAME, OP)
 
#define HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_16, LMULS)(X_MACRO, int, i, NAME, OP)
 
#define HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, int, i, NAME, OP)
 
#define HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, int, i, NAME, OP)
 
#define HWY_RVV_FOREACH_F16(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_F32(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, float, f, NAME, OP)
 
#define HWY_RVV_FOREACH_F64(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, float, f, NAME, OP)
 
#define HWY_RVV_FOREACH_UI08(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_UI16(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_UI32(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_UI64(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_UI3264(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_U163264(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_I163264(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_UI163264(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_F3264(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_U(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_I(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_F(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH_UI(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_FOREACH(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_T(BASE, SEW)   BASE##SEW##_t
 
#define HWY_RVV_D(BASE, SEW, N, SHIFT)   Simd<HWY_RVV_T(BASE, SEW), N, SHIFT>
 
#define HWY_RVV_V(BASE, SEW, LMUL)   v##BASE##SEW##LMUL##_t
 
#define HWY_RVV_M(MLEN)   vbool##MLEN##_t
 
#define HWY_SPECIALIZE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_LANES(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_AVL(SEW, SHIFT)    Lanes(ScalableTag<HWY_RVV_T(uint, SEW), SHIFT>())
 
#define HWY_RVV_RETV_ARGV(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETV_ARGVS(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETV_ARGVV(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETM_ARGM(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SET(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_UNDEFINED(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_TRUNC(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_EXT(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_EXT_VIRT(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CAST_U8(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CAST_I8(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CAST_U(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CAST_IF(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CAST_VIRT_U(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CAST_VIRT_IF(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_IOTA(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SHIFT(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SHIFT_VV(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SHIFT_II(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_FMA(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETM_ARGVV(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETM_ARGVS(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETM_ARGMM(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_IF_THEN_ELSE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_IF_THEN_ZERO_ELSE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_VEC_FROM_MASK(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_FIND_FIRST_TRUE(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_ALL_TRUE(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_COUNT_TRUE(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_LOAD(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_MASKED_LOAD(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_STORE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_BLENDED_STORE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_STOREN(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SCATTER(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_GATHER(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_NATIVE_LOAD_STORE_INTERLEAVED
 
#define HWY_RVV_LOAD2(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_LOAD3(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_LOAD4(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_STORE2(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_STORE3(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_STORE4(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_PROMOTE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, LMUL, LMUL_IN, SHIFT, ADD)
 
#define HWY_RVV_PROMOTE_X2(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN)
 
#define HWY_RVV_PROMOTE_X4(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN)
 
#define HWY_RVV_DEMOTE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_DEMOTE_I_TO_U(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_DEMOTE_F(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CONVERT(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_NEAREST(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SLIDE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SLIDE1(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_GET_LANE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_TABLE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_COMPRESS(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_REDUCE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_LOAD_MASK_BITS(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_STORE_MASK_BITS(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETV_ARGV2(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 

Typedefs

template<class D >
using hwy::HWY_NAMESPACE::MFromD = decltype(MaskFromVec(Zero(D())))
 
template<class DF >
using hwy::HWY_NAMESPACE::DU16FromDF = RepartitionToNarrow< RebindToUnsigned< DF > >
 

Functions

 HWY_BEFORE_NAMESPACE ()
 
template<typename T , size_t N, int kPow2>
constexpr size_t hwy::HWY_NAMESPACE::MLenFromD (Simd< T, N, kPow2 >)
 
template<size_t N, int kPow2>
HWY_API size_t hwy::HWY_NAMESPACE::Lanes (Simd< bfloat16_t, N, kPow2 >)
 
template<size_t N, int kPow2>
decltype(Set(Simd< uint16_t, N, kPow2 >(), 0)) hwy::HWY_NAMESPACE::Set (Simd< bfloat16_t, N, kPow2 > d, bfloat16_t arg)
 
template<typename T , size_t N, int kPow2>
HWY_API VFromD< Simd< T, N, kPow2 > > hwy::HWY_NAMESPACE::Zero (Simd< T, N, kPow2 > d)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Undefined (D d)
 
template<size_t N, int kPow2>
HWY_INLINE VFromD< Simd< uint16_t, N, kPow2 > > hwy::HWY_NAMESPACE::detail::BitCastFromByte (Simd< bfloat16_t, N, kPow2 >, VFromD< Simd< uint8_t, N, kPow2 >> v)
 
template<class D , class FromV >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::BitCast (D d, FromV v)
 
template<class V , class DU = RebindToUnsigned<DFromV<V>>>
HWY_INLINE VFromD< DU > hwy::HWY_NAMESPACE::detail::BitCastToUnsigned (V v)
 
template<class D , class DU = RebindToUnsigned<D>>
HWY_INLINE VFromD< DU > hwy::HWY_NAMESPACE::detail::Iota0 (const D)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Not (const V v)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::And (const V a, const V b)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Or (const V a, const V b)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Xor (const V a, const V b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::AndNot (const V not_a, const V b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Or3 (V o1, V o2, V o3)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::OrAnd (const V o, const V a1, const V a2)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::CopySignToAbs (const V abs, const V sign)
 
template<class VU8 >
HWY_API VFromD< Repartition< uint64_t, DFromV< VU8 > > > hwy::HWY_NAMESPACE::SumsOf8 (const VU8 v)
 
template<int kBits, class V >
HWY_APIhwy::HWY_NAMESPACE::RotateRight (const V v)
 
template<class V >
HWY_API auto hwy::HWY_NAMESPACE::Ge (V a, V b) -> decltype(a==b)
 
template<class V >
HWY_API auto hwy::HWY_NAMESPACE::Gt (V a, V b) -> decltype(a==b)
 
template<class V >
HWY_API auto hwy::HWY_NAMESPACE::TestBit (const V a, const V bit) -> decltype(Eq(a, bit))
 
template<class M , class V >
HWY_APIhwy::HWY_NAMESPACE::IfThenElseZero (const M mask, const V yes)
 
template<class V >
HWY_API auto hwy::HWY_NAMESPACE::MaskFromVec (const V v) -> decltype(Eq(v, v))
 
template<class D , typename MFrom >
HWY_API MFromD< D > hwy::HWY_NAMESPACE::RebindMask (const D, const MFrom mask)
 
template<class D , HWY_IF_NOT_FLOAT_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::VecFromMask (const D d, MFromD< D > mask)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::IfVecThenElse (const V mask, const V yes, const V no)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::ZeroIfNegative (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::BroadcastSignBit (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::IfNegativeThenElse (V v, V yes, V no)
 
template<class D >
HWY_API bool hwy::HWY_NAMESPACE::AllFalse (D d, MFromD< D > m)
 
template<size_t N, int kPow2>
HWY_API VFromD< Simd< uint16_t, N, kPow2 > > 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 (VFromD< Simd< uint16_t, N, kPow2 >> 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<class V , class D , typename T >
HWY_API void hwy::HWY_NAMESPACE::Stream (const V v, D d, T *HWY_RESTRICT aligned)
 
template<class D , HWY_IF_LANE_SIZE_D(D, 4) >
HWY_API void hwy::HWY_NAMESPACE::ScatterIndex (VFromD< D > v, D d, TFromD< D > *HWY_RESTRICT base, const VFromD< RebindToSigned< D >> index)
 
template<class D , HWY_IF_LANE_SIZE_D(D, 4) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::GatherIndex (D d, const TFromD< D > *HWY_RESTRICT base, const VFromD< RebindToSigned< D >> index)
 
template<size_t N, int kPow2>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< int16_t, N, kPow2 > d, VFromD< Rebind< uint8_t, decltype(d)>> v) -> VFromD< decltype(d)>
 
template<size_t N, int kPow2>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< int32_t, N, kPow2 > d, VFromD< Rebind< uint8_t, decltype(d)>> v) -> VFromD< decltype(d)>
 
template<size_t N, int kPow2>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< int32_t, N, kPow2 > d, VFromD< Rebind< uint16_t, decltype(d)>> v) -> VFromD< decltype(d)>
 
template<size_t N, int kPow2>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< float32_t, N, kPow2 > d, VFromD< Rebind< bfloat16_t, decltype(d)>> v) -> VFromD< decltype(d)>
 
template<size_t N>
HWY_API vuint8mf8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, -3 > d, const vint32mf2_t v)
 
template<size_t N>
HWY_API vuint8mf4_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, -2 > d, const vint32m1_t v)
 
template<size_t N>
HWY_API vuint8mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, -1 > d, const vint32m2_t v)
 
template<size_t N>
HWY_API vuint8m1_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, 0 > d, const vint32m4_t v)
 
template<size_t N>
HWY_API vuint8m2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, 1 > d, const vint32m8_t v)
 
HWY_API vuint8mf8_t hwy::HWY_NAMESPACE::U8FromU32 (const vuint32mf2_t v)
 
HWY_API vuint8mf4_t hwy::HWY_NAMESPACE::U8FromU32 (const vuint32m1_t v)
 
HWY_API vuint8mf2_t hwy::HWY_NAMESPACE::U8FromU32 (const vuint32m2_t v)
 
HWY_API vuint8m1_t hwy::HWY_NAMESPACE::U8FromU32 (const vuint32m4_t v)
 
HWY_API vuint8m2_t hwy::HWY_NAMESPACE::U8FromU32 (const vuint32m8_t v)
 
template<size_t N>
HWY_API vint8mf8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, -3 > d, const vint32mf2_t v)
 
template<size_t N>
HWY_API vint8mf4_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, -2 > d, const vint32m1_t v)
 
template<size_t N>
HWY_API vint8mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, -1 > d, const vint32m2_t v)
 
template<size_t N>
HWY_API vint8m1_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, 0 > d, const vint32m4_t v)
 
template<size_t N>
HWY_API vint8m2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, 1 > d, const vint32m8_t v)
 
 hwy::HWY_NAMESPACE::HWY_RVV_FOREACH_F64 (HWY_RVV_DEMOTE_F, DemoteTo, vfncvt_rod_f_f_w_f, _DEMOTE_VIRT) template< size_t N > HWY_API vint32mf2_t DemoteTo(Simd< int32_t
 
template<size_t N>
HWY_API vint32mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, -1 > d, const vfloat64m1_t v)
 
template<size_t N>
HWY_API vint32m1_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, 0 > d, const vfloat64m2_t v)
 
template<size_t N>
HWY_API vint32m2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, 1 > d, const vfloat64m4_t v)
 
template<size_t N>
HWY_API vint32m4_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, 2 > d, const vfloat64m8_t v)
 
template<size_t N, int kPow2>
HWY_API VFromD< Simd< uint16_t, N, kPow2 > > hwy::HWY_NAMESPACE::DemoteTo (Simd< bfloat16_t, N, kPow2 > d, VFromD< Simd< float, N, kPow2+1 >> v)
 
template<typename T , size_t N, int kPow2>
size_t hwy::HWY_NAMESPACE::detail::LanesPerBlock (Simd< T, N, kPow2 > d)
 
template<class D , class V >
HWY_INLINEhwy::HWY_NAMESPACE::detail::OffsetsOf128BitBlocks (const D d, const V iota0)
 
template<size_t kLanes, class D >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::detail::FirstNPerBlock (D)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatUpperLower (const D d, const V hi, const V lo)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatLowerLower (const D d, const V hi, const V lo)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatUpperUpper (const D d, const V hi, const V lo)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatLowerUpper (const D d, const V hi, const V lo)
 
template<class D2 , class V >
HWY_API VFromD< D2 > hwy::HWY_NAMESPACE::Combine (D2 d2, const V hi, const V lo)
 
template<class D2 , class V >
HWY_API VFromD< D2 > hwy::HWY_NAMESPACE::ZeroExtendVector (D2 d2, const V lo)
 
template<class D >
constexpr bool hwy::HWY_NAMESPACE::detail::IsSupportedLMUL (D d)
 
template<class DH , hwy::EnableIf< detail::IsSupportedLMUL(DH())> * = nullptr>
HWY_API VFromD< DH > hwy::HWY_NAMESPACE::LowerHalf (const DH, const VFromD< Twice< DH >> v)
 
template<class DH , class V , hwy::EnableIf<!detail::IsSupportedLMUL(DH())> * = nullptr>
HWY_APIhwy::HWY_NAMESPACE::LowerHalf (const DH, const V v)
 
template<class V >
HWY_API VFromD< Half< DFromV< V > > > hwy::HWY_NAMESPACE::LowerHalf (const V v)
 
template<class DH >
HWY_API VFromD< DH > hwy::HWY_NAMESPACE::UpperHalf (const DH d2, const VFromD< Twice< DH >> v)
 
template<class V >
HWY_API TFromV< V > hwy::HWY_NAMESPACE::ExtractLane (V v, size_t i)
 
template<class V , HWY_IF_NOT_LANE_SIZE_V(V, 1) >
HWY_APIhwy::HWY_NAMESPACE::InsertLane (const V v, size_t i, TFromV< V > t)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::OddEven (const V a, const V b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::DupEven (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::DupOdd (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::OddEvenBlocks (const V odd, const V even)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::SwapAdjacentBlocks (const V v)
 
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<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatOdd (D d, const V hi, const V lo)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatEven (D d, const V hi, const V lo)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse (D, VFromD< D > v)
 
template<class D , HWY_IF_LANE_SIZE_D(D, 2) , HWY_RVV_IF_POW2_IN(D, -1, 3) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse2 (D d, const VFromD< D > v)
 
template<class D , class V = VFromD<D>, HWY_IF_LANE_SIZE_D(D, 8) >
HWY_APIhwy::HWY_NAMESPACE::Reverse2 (D, const V 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 D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::ReverseBlocks (D d, V v)
 
template<class V , class M >
HWY_APIhwy::HWY_NAMESPACE::CompressNot (V v, const M mask)
 
template<class V , class M >
HWY_APIhwy::HWY_NAMESPACE::CompressBlocksNot (V v, const M mask)
 
template<class V , class M , class D >
HWY_API size_t hwy::HWY_NAMESPACE::CompressStore (const V v, const M mask, const D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<class V , class M , class D >
HWY_API size_t hwy::HWY_NAMESPACE::CompressBlendedStore (const V v, const M mask, const D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<size_t kBytes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::CombineShiftRightBytes (const D d, const V hi, const V lo)
 
template<size_t kLanes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::CombineShiftRightLanes (const D d, const V hi, V lo)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle2301 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle2103 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle0321 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle1032 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle01 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle0123 (const V v)
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2 - 3 >> v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2 - 2 >> v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2 - 1 >> v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< decltype(d)> v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2+1 >> v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2+2 >> v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2+3 >> v) -> VFromD< decltype(d)>
 
template<class VT , class VI >
HWY_API VI hwy::HWY_NAMESPACE::TableLookupBytes (const VT vt, const VI vi)
 
template<class VT , class VI >
HWY_API VI hwy::HWY_NAMESPACE::TableLookupBytesOr0 (const VT vt, const VI idx)
 
template<int kLane, class V >
HWY_APIhwy::HWY_NAMESPACE::Broadcast (const V v)
 
template<size_t kLanes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftLanes (D d, const V v)
 
template<size_t kLanes, class V >
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftLanes (const V v)
 
template<int kBytes, class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::ShiftLeftBytes (D d, const VFromD< D > v)
 
template<int kBytes, class V >
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftBytes (const V v)
 
template<size_t kLanes, typename T , size_t N, int kPow2, class V = VFromD<Simd<T, N, kPow2>>>
HWY_APIhwy::HWY_NAMESPACE::ShiftRightLanes (const Simd< T, N, kPow2 > d, V v)
 
template<int kBytes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::ShiftRightBytes (const D d, const V v)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::InterleaveLower (D d, const V a, const V b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::InterleaveLower (const V a, const V b)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::InterleaveUpper (const D d, const V a, const V b)
 
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 DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::ZipLower (V a, 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<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::SumOfLanes (D d, const VFromD< D > v)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MinOfLanes (D d, const VFromD< D > v)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MaxOfLanes (D d, const VFromD< D > v)
 
template<class V >
decltype(MaskFromVec(v)) HWY_APIhwy::HWY_NAMESPACE::Round (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Trunc (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Ceil (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Floor (const V v)
 
template<class V >
HWY_API MFromD< DFromV< V > > hwy::HWY_NAMESPACE::IsNaN (const V v)
 
template<class V , class D = DFromV<V>>
HWY_API MFromD< D > hwy::HWY_NAMESPACE::IsInf (const V v)
 
template<class V , class D = DFromV<V>>
HWY_API MFromD< D > hwy::HWY_NAMESPACE::IsFinite (const V 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 V , HWY_IF_LANE_SIZE_V(V, 4) , class D = DFromV<V>, class DW = RepartitionToWide<D>>
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::MulEven (const V a, const V b)
 
template<class V , HWY_IF_LANE_SIZE_V(V, 8) >
HWY_INLINEhwy::HWY_NAMESPACE::MulEven (const V a, const V b)
 
template<class V , HWY_IF_LANE_SIZE_V(V, 8) >
HWY_INLINEhwy::HWY_NAMESPACE::MulOdd (const V a, const V b)
 
template<size_t N, int kPow2>
HWY_API VFromD< Simd< uint16_t, N, kPow2 > > hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< bfloat16_t, N, kPow2 > dbf16, VFromD< RepartitionToWide< decltype(dbf16)>> a, VFromD< RepartitionToWide< decltype(dbf16)>> b)
 
template<size_t N, int kPow2>
HWY_API auto hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< float, N, kPow2 > df32, VFromD< DU16FromDF< decltype(df32)>> a, VFromD< DU16FromDF< decltype(df32)>> b, const VFromD< decltype(df32)> sum0, VFromD< decltype(df32)> &sum1) -> VFromD< decltype(df32)>
 
template<class D >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::Lt128 (D d, const VFromD< D > a, const VFromD< D > b)
 
template<class D >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::Lt128Upper (D d, const VFromD< D > a, const VFromD< D > b)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::Min128 (D d, const VFromD< D > a, const VFromD< D > b)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::Max128 (D d, const VFromD< D > a, const VFromD< D > b)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::Min128Upper (D d, const VFromD< D > a, const VFromD< D > b)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::Max128Upper (D d, const VFromD< D > a, const VFromD< D > b)
 
 HWY_AFTER_NAMESPACE ()
 

Variables

 hwy::HWY_NAMESPACE::N
 
 hwy::HWY_NAMESPACE::d
 
const vfloat64m1_t hwy::HWY_NAMESPACE::v
 

Macro Definition Documentation

◆ HWY_NATIVE_LOAD_STORE_INTERLEAVED

#define HWY_NATIVE_LOAD_STORE_INTERLEAVED

◆ HWY_RVV_ALL_TRUE

#define HWY_RVV_ALL_TRUE (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <class D> \
HWY_API bool AllTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return AllFalse(d, vmnot_m_b##MLEN(m, Lanes(d))); \
}
d
Definition: rvv-inl.h:1742
HWY_API bool AllTrue(const Full128< T > d, const Mask128< T > m)
Definition: arm_neon-inl.h:5305
constexpr size_t MLenFromD(Simd< T, N, kPow2 >)
Definition: rvv-inl.h:43
HWY_API size_t Lanes(Simd< bfloat16_t, N, kPow2 >)
Definition: rvv-inl.h:428
HWY_API bool AllFalse(D d, MFromD< D > m)
Definition: rvv-inl.h:1234
#define HWY_RVV_M(MLEN)
Definition: rvv-inl.h:388

◆ HWY_RVV_AVL

#define HWY_RVV_AVL (   SEW,
  SHIFT 
)     Lanes(ScalableTag<HWY_RVV_T(uint, SEW), SHIFT>())

◆ HWY_RVV_BLENDED_STORE

#define HWY_RVV_BLENDED_STORE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_M(MLEN) m, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL##_m(m, p, v, Lanes(d)); \
}
#define HWY_RESTRICT
Definition: base.h:61
N
Definition: rvv-inl.h:1742
const vfloat64m1_t v
Definition: rvv-inl.h:1742
#define HWY_RVV_D(BASE, SEW, N, SHIFT)
Definition: rvv-inl.h:386
#define HWY_RVV_V(BASE, SEW, LMUL)
Definition: rvv-inl.h:387
#define HWY_RVV_T(BASE, SEW)
Definition: rvv-inl.h:385

◆ HWY_RVV_CAST_I8

#define HWY_RVV_CAST_I8 (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <typename T, size_t N> \
HWY_API vuint8##LMUL##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
vint8##LMUL##_t v) { \
return vreinterpret_v_i8##LMUL##_u8##LMUL(v); \
} \
template <size_t N> \
HWY_API vint8##LMUL##_t BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMUL##_t v) { \
return vreinterpret_v_u8##LMUL##_i8##LMUL(v); \
}
HWY_INLINE VFromD< Simd< uint16_t, N, kPow2 > > BitCastFromByte(Simd< bfloat16_t, N, kPow2 >, VFromD< Simd< uint8_t, N, kPow2 >> v)
Definition: rvv-inl.h:676
HWY_INLINE Vec128< uint8_t, N > BitCastToByte(Vec128< uint8_t, N > v)
Definition: arm_neon-inl.h:852

◆ HWY_RVV_CAST_IF

#define HWY_RVV_CAST_IF (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <typename T, size_t N> \
HWY_API vuint8##LMUL##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_u##SEW##LMUL##_u8##LMUL( \
v##OP##_v_##CHAR##SEW##LMUL##_u##SEW##LMUL(v)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMUL##_t v) { \
return v##OP##_v_u##SEW##LMUL##_##CHAR##SEW##LMUL( \
v##OP##_v_u8##LMUL##_u##SEW##LMUL(v)); \
}

◆ HWY_RVV_CAST_U

#define HWY_RVV_CAST_U (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <typename T, size_t N> \
HWY_API vuint8##LMUL##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL##_u8##LMUL(v); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMUL##_t v) { \
return v##OP##_v_u8##LMUL##_##CHAR##SEW##LMUL(v); \
}

◆ HWY_RVV_CAST_U8

#define HWY_RVV_CAST_U8 (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <typename T, size_t N> \
HWY_API vuint8##LMUL##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
vuint8##LMUL##_t v) { \
return v; \
} \
template <size_t N> \
HWY_API vuint8##LMUL##_t BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMUL##_t v) { \
return v; \
}

◆ HWY_RVV_CAST_VIRT_IF

#define HWY_RVV_CAST_VIRT_IF (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <typename T, size_t N> \
HWY_API vuint8##LMULH##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return detail::Trunc(v##OP##_v_u##SEW##LMUL##_u8##LMUL( \
v##OP##_v_##CHAR##SEW##LMUL##_u##SEW##LMUL(v))); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMULH##_t v) { \
HWY_RVV_D(uint, 8, N, SHIFT + 1) d2; \
const vuint8##LMUL##_t v2 = detail::Ext(d2, v); \
return v##OP##_v_u##SEW##LMUL##_##CHAR##SEW##LMUL( \
v##OP##_v_u8##LMUL##_u##SEW##LMUL(v2)); \
}
HWY_API V Trunc(const V v)
Definition: rvv-inl.h:2727

◆ HWY_RVV_CAST_VIRT_U

#define HWY_RVV_CAST_VIRT_U (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <typename T, size_t N> \
HWY_API vuint8##LMULH##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return detail::Trunc(v##OP##_v_##CHAR##SEW##LMUL##_u8##LMUL(v)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMULH##_t v) { \
HWY_RVV_D(uint, 8, N, SHIFT + 1) d2; \
const vuint8##LMUL##_t v2 = detail::Ext(d2, v); \
return v##OP##_v_u8##LMUL##_##CHAR##SEW##LMUL(v2); \
}

◆ HWY_RVV_COMPRESS

#define HWY_RVV_COMPRESS (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_M(MLEN) mask) { \
return v##OP##_vm_##CHAR##SEW##LMUL(mask, v, v, HWY_RVV_AVL(SEW, SHIFT)); \
}
#define HWY_API
Definition: base.h:120
#define HWY_RVV_AVL(SEW, SHIFT)
Definition: rvv-inl.h:436

◆ HWY_RVV_CONVERT

#define HWY_RVV_CONVERT (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) ConvertTo( \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, HWY_RVV_V(int, SEW, LMUL) v) { \
return vfcvt_f_x_v_f##SEW##LMUL(v, Lanes(d)); \
} \
/* Truncates (rounds toward zero). */ \
template <size_t N> \
HWY_API HWY_RVV_V(int, SEW, LMUL) ConvertTo(HWY_RVV_D(int, SEW, N, SHIFT) d, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return vfcvt_rtz_x_f_v_i##SEW##LMUL(v, Lanes(d)); \
} \
HWY_API Vec128< float > ConvertTo(Full128< float >, const Vec128< int32_t > v)
Definition: arm_neon-inl.h:3273

◆ HWY_RVV_COUNT_TRUE

#define HWY_RVV_COUNT_TRUE (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <class D> \
HWY_API size_t CountTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return vcpop_m_b##MLEN(m, Lanes(d)); \
}
HWY_INLINE size_t CountTrue(hwy::SizeTag< 1 >, const Mask128< T > mask)
Definition: arm_neon-inl.h:5207

◆ HWY_RVV_D

#define HWY_RVV_D (   BASE,
  SEW,
  N,
  SHIFT 
)    Simd<HWY_RVV_T(BASE, SEW), N, SHIFT>

◆ HWY_RVV_DEMOTE

#define HWY_RVV_DEMOTE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEWH, LMULH) NAME( \
HWY_RVV_D(BASE, SEWH, N, SHIFT - 1) d, HWY_RVV_V(BASE, SEW, LMUL) v) { \
return OP##CHAR##SEWH##LMULH(v, 0, Lanes(d)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEWH, LMULH) NAME##Shr16( \
HWY_RVV_D(BASE, SEWH, N, SHIFT - 1) d, HWY_RVV_V(BASE, SEW, LMUL) v) { \
return OP##CHAR##SEWH##LMULH(v, 16, Lanes(d)); \
}

◆ HWY_RVV_DEMOTE_F

#define HWY_RVV_DEMOTE_F (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEWH, LMULH) NAME( \
HWY_RVV_D(BASE, SEWH, N, SHIFT - 1) d, HWY_RVV_V(BASE, SEW, LMUL) v) { \
return OP##SEWH##LMULH(v, Lanes(d)); \
}

◆ HWY_RVV_DEMOTE_I_TO_U

#define HWY_RVV_DEMOTE_I_TO_U (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(uint, SEWH, LMULH) NAME( \
HWY_RVV_D(uint, SEWH, N, SHIFT - 1) d, HWY_RVV_V(int, SEW, LMUL) v) { \
/* First clamp negative numbers to zero to match x86 packus. */ \
return detail::DemoteTo(d, detail::BitCastToUnsigned(detail::MaxS(v, 0))); \
}
HWY_INLINE VFromD< DU > BitCastToUnsigned(V v)
Definition: rvv-inl.h:691
HWY_API VFromD< Simd< uint16_t, N, kPow2 > > DemoteTo(Simd< bfloat16_t, N, kPow2 > d, VFromD< Simd< float, N, kPow2+1 >> v)
Definition: rvv-inl.h:1763

◆ HWY_RVV_EXT

#define HWY_RVV_EXT (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMULD) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT + 1) /* d2 */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL##_##CHAR##SEW##LMULD(v); /* no AVL */ \
}

◆ HWY_RVV_EXT_VIRT

#define HWY_RVV_EXT_VIRT (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT + 1) /* d2 */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v; \
}

◆ HWY_RVV_FIND_FIRST_TRUE

#define HWY_RVV_FIND_FIRST_TRUE (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <class D> \
HWY_API intptr_t FindFirstTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return vfirst_m_b##MLEN(m, Lanes(d)); \
}
HWY_API intptr_t FindFirstTrue(const Simd< T, N, 0 > d, const Mask128< T, N > mask)
Definition: arm_neon-inl.h:5280

◆ HWY_RVV_FMA

#define HWY_RVV_FMA (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) mul, HWY_RVV_V(BASE, SEW, LMUL) x, \
HWY_RVV_V(BASE, SEW, LMUL) add) { \
return v##OP##_vv_##CHAR##SEW##LMUL(add, mul, x, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_FOREACH

#define HWY_RVV_FOREACH (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_U(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_F(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_U(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:358

◆ HWY_RVV_FOREACH_08_ALL

#define HWY_RVV_FOREACH_08_ALL (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_08_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m8, __, m4, 3, /*MLEN=*/1, NAME, OP)
#define HWY_RVV_FOREACH_08_EXT(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:158

◆ HWY_RVV_FOREACH_08_ALL_VIRT

#define HWY_RVV_FOREACH_08_ALL_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_08_ALL(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_08_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define HWY_RVV_FOREACH_08_ALL(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:175

◆ HWY_RVV_FOREACH_08_DEMOTE

#define HWY_RVV_FOREACH_08_DEMOTE (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 8, 16, __, mf4, mf2, mf8, -2, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, mf2, m1, mf4, -1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m1, m2, mf2, 0, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m2, m4, m1, 1, /*MLEN=*/4, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m4, m8, m2, 2, /*MLEN=*/2, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m8, __, m4, 3, /*MLEN=*/1, NAME, OP)

◆ HWY_RVV_FOREACH_08_DEMOTE_VIRT

#define HWY_RVV_FOREACH_08_DEMOTE_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_08_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_08_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define HWY_RVV_FOREACH_08_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:105

◆ HWY_RVV_FOREACH_08_EXT

#define HWY_RVV_FOREACH_08_EXT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_08_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m4, m8, m2, 2, /*MLEN=*/2, NAME, OP)
#define HWY_RVV_FOREACH_08_LE2(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:135

◆ HWY_RVV_FOREACH_08_EXT_VIRT

#define HWY_RVV_FOREACH_08_EXT_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_08_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_08_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

◆ HWY_RVV_FOREACH_08_LE2

#define HWY_RVV_FOREACH_08_LE2 (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 8, 16, __, mf8, mf4, __, -3, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, mf4, mf2, mf8, -2, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, mf2, m1, mf4, -1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m1, m2, mf2, 0, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m2, m4, m1, 1, /*MLEN=*/4, NAME, OP)

◆ HWY_RVV_FOREACH_08_LE2_VIRT

#define HWY_RVV_FOREACH_08_LE2_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_08_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_08_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

◆ HWY_RVV_FOREACH_08_TRUNC

#define HWY_RVV_FOREACH_08_TRUNC (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 8, 16, __, mf4, mf2, mf8, -2, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, mf2, m1, mf4, -1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m1, m2, mf2, 0, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m2, m4, m1, 1, /*MLEN=*/4, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m4, m8, m2, 2, /*MLEN=*/2, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m8, __, m4, 3, /*MLEN=*/1, NAME, OP)

◆ HWY_RVV_FOREACH_08_VIRT

#define HWY_RVV_FOREACH_08_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)

◆ HWY_RVV_FOREACH_16_ALL

#define HWY_RVV_FOREACH_16_ALL (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_16_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m8, __, m4, 3, /*MLEN=*/2, NAME, OP)
#define HWY_RVV_FOREACH_16_EXT(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:162

◆ HWY_RVV_FOREACH_16_ALL_VIRT

#define HWY_RVV_FOREACH_16_ALL_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_16_ALL(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_16_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define HWY_RVV_FOREACH_16_ALL(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:179

◆ HWY_RVV_FOREACH_16_DEMOTE

#define HWY_RVV_FOREACH_16_DEMOTE (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 16, 32, 8, mf4, mf2, mf8, -2, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, mf2, m1, mf4, -1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m1, m2, mf2, 0, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m2, m4, m1, 1, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m4, m8, m2, 2, /*MLEN=*/4, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m8, __, m4, 3, /*MLEN=*/2, NAME, OP)

◆ HWY_RVV_FOREACH_16_DEMOTE_VIRT

#define HWY_RVV_FOREACH_16_DEMOTE_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_16_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_16_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define HWY_RVV_FOREACH_16_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:113

◆ HWY_RVV_FOREACH_16_EXT

#define HWY_RVV_FOREACH_16_EXT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_16_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m4, m8, m2, 2, /*MLEN=*/4, NAME, OP)
#define HWY_RVV_FOREACH_16_LE2(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:142

◆ HWY_RVV_FOREACH_16_EXT_VIRT

#define HWY_RVV_FOREACH_16_EXT_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_16_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_16_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

◆ HWY_RVV_FOREACH_16_LE2

#define HWY_RVV_FOREACH_16_LE2 (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 16, 32, 8, mf4, mf2, mf8, -2, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, mf2, m1, mf4, -1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m1, m2, mf2, 0, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m2, m4, m1, 1, /*MLEN=*/8, NAME, OP)

◆ HWY_RVV_FOREACH_16_LE2_VIRT

#define HWY_RVV_FOREACH_16_LE2_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_16_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_16_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

◆ HWY_RVV_FOREACH_16_TRUNC

#define HWY_RVV_FOREACH_16_TRUNC (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 16, 32, 8, mf2, m1, mf4, -1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m1, m2, mf2, 0, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m2, m4, m1, 1, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m4, m8, m2, 2, /*MLEN=*/4, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m8, __, m4, 3, /*MLEN=*/2, NAME, OP)

◆ HWY_RVV_FOREACH_16_VIRT

#define HWY_RVV_FOREACH_16_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)     X_MACRO(BASE, CHAR, 16, 32, 8, mf4, mf2, mf8, -3, /*MLEN=*/64, NAME, OP)

◆ HWY_RVV_FOREACH_32_ALL

#define HWY_RVV_FOREACH_32_ALL (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_32_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m8, __, m4, 3, /*MLEN=*/4, NAME, OP)
#define HWY_RVV_FOREACH_32_EXT(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:166

◆ HWY_RVV_FOREACH_32_ALL_VIRT

#define HWY_RVV_FOREACH_32_ALL_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_32_ALL(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_32_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define HWY_RVV_FOREACH_32_ALL(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:183

◆ HWY_RVV_FOREACH_32_DEMOTE

#define HWY_RVV_FOREACH_32_DEMOTE (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 32, 64, 16, mf2, m1, mf4, -1, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m1, m2, mf2, 0, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m2, m4, m1, 1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m4, m8, m2, 2, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m8, __, m4, 3, /*MLEN=*/4, NAME, OP)

◆ HWY_RVV_FOREACH_32_DEMOTE_VIRT

#define HWY_RVV_FOREACH_32_DEMOTE_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_32_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_32_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define HWY_RVV_FOREACH_32_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:121

◆ HWY_RVV_FOREACH_32_EXT

#define HWY_RVV_FOREACH_32_EXT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_32_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m4, m8, m2, 2, /*MLEN=*/8, NAME, OP)
#define HWY_RVV_FOREACH_32_LE2(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:148

◆ HWY_RVV_FOREACH_32_EXT_VIRT

#define HWY_RVV_FOREACH_32_EXT_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_32_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_32_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

◆ HWY_RVV_FOREACH_32_LE2

#define HWY_RVV_FOREACH_32_LE2 (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 32, 64, 16, mf2, m1, mf4, -1, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m1, m2, mf2, 0, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m2, m4, m1, 1, /*MLEN=*/16, NAME, OP)

◆ HWY_RVV_FOREACH_32_LE2_VIRT

#define HWY_RVV_FOREACH_32_LE2_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_32_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_32_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

◆ HWY_RVV_FOREACH_32_TRUNC

#define HWY_RVV_FOREACH_32_TRUNC (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 32, 64, 16, m1, m2, mf2, 0, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m2, m4, m1, 1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m4, m8, m2, 2, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m8, __, m4, 3, /*MLEN=*/4, NAME, OP)

◆ HWY_RVV_FOREACH_32_VIRT

#define HWY_RVV_FOREACH_32_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)     X_MACRO(BASE, CHAR, 32, 64, 16, mf2, m1, mf4, -2, /*MLEN=*/64, NAME, OP)

◆ HWY_RVV_FOREACH_64_ALL

#define HWY_RVV_FOREACH_64_ALL (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_64_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m8, __, m4, 3, /*MLEN=*/8, NAME, OP)
#define HWY_RVV_FOREACH_64_EXT(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:170

◆ HWY_RVV_FOREACH_64_ALL_VIRT

#define HWY_RVV_FOREACH_64_ALL_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_64_ALL(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_64_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define HWY_RVV_FOREACH_64_ALL(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:187

◆ HWY_RVV_FOREACH_64_DEMOTE

#define HWY_RVV_FOREACH_64_DEMOTE (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 64, __, 32, m1, m2, mf2, 0, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m2, m4, m1, 1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m4, m8, m2, 2, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m8, __, m4, 3, /*MLEN=*/8, NAME, OP)

◆ HWY_RVV_FOREACH_64_DEMOTE_VIRT

#define HWY_RVV_FOREACH_64_DEMOTE_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_64_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_64_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define HWY_RVV_FOREACH_64_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:128

◆ HWY_RVV_FOREACH_64_EXT

#define HWY_RVV_FOREACH_64_EXT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_64_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m4, m8, m2, 2, /*MLEN=*/16, NAME, OP)
#define HWY_RVV_FOREACH_64_LE2(X_MACRO, BASE, CHAR, NAME, OP)
Definition: rvv-inl.h:153

◆ HWY_RVV_FOREACH_64_EXT_VIRT

#define HWY_RVV_FOREACH_64_EXT_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_64_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_64_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

◆ HWY_RVV_FOREACH_64_LE2

#define HWY_RVV_FOREACH_64_LE2 (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 64, __, 32, m1, m2, mf2, 0, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m2, m4, m1, 1, /*MLEN=*/32, NAME, OP)

◆ HWY_RVV_FOREACH_64_LE2_VIRT

#define HWY_RVV_FOREACH_64_LE2_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_64_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_64_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

◆ HWY_RVV_FOREACH_64_TRUNC

#define HWY_RVV_FOREACH_64_TRUNC (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 64, __, 32, m2, m4, m1, 1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m4, m8, m2, 2, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m8, __, m4, 3, /*MLEN=*/8, NAME, OP)

◆ HWY_RVV_FOREACH_64_VIRT

#define HWY_RVV_FOREACH_64_VIRT (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)     X_MACRO(BASE, CHAR, 64, __, 32, m1, m2, mf2, -1, /*MLEN=*/64, NAME, OP)

◆ HWY_RVV_FOREACH_B

#define HWY_RVV_FOREACH_B (   X_MACRO,
  NAME,
  OP 
)
Value:
X_MACRO(64, 0, 64, NAME, OP) \
X_MACRO(32, 0, 32, NAME, OP) \
X_MACRO(16, 0, 16, NAME, OP) \
X_MACRO(8, 0, 8, NAME, OP) \
X_MACRO(8, 1, 4, NAME, OP) \
X_MACRO(8, 2, 2, NAME, OP) \
X_MACRO(8, 3, 1, NAME, OP)

◆ HWY_RVV_FOREACH_F

#define HWY_RVV_FOREACH_F (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_F16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_F3264(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_F16(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:311

◆ HWY_RVV_FOREACH_F16

#define HWY_RVV_FOREACH_F16 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)

◆ HWY_RVV_FOREACH_F32

#define HWY_RVV_FOREACH_F32 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)     HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, float, f, NAME, OP)

◆ HWY_RVV_FOREACH_F3264

#define HWY_RVV_FOREACH_F3264 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_F32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_F64(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_F32(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:313

◆ HWY_RVV_FOREACH_F64

#define HWY_RVV_FOREACH_F64 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)     HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, float, f, NAME, OP)

◆ HWY_RVV_FOREACH_I

#define HWY_RVV_FOREACH_I (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:297

◆ HWY_RVV_FOREACH_I08

#define HWY_RVV_FOREACH_I08 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)     HWY_CONCAT(HWY_RVV_FOREACH_08, LMULS)(X_MACRO, int, i, NAME, OP)

◆ HWY_RVV_FOREACH_I16

#define HWY_RVV_FOREACH_I16 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)     HWY_CONCAT(HWY_RVV_FOREACH_16, LMULS)(X_MACRO, int, i, NAME, OP)

◆ HWY_RVV_FOREACH_I163264

#define HWY_RVV_FOREACH_I163264 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:299

◆ HWY_RVV_FOREACH_I32

#define HWY_RVV_FOREACH_I32 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)     HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, int, i, NAME, OP)

◆ HWY_RVV_FOREACH_I64

#define HWY_RVV_FOREACH_I64 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)     HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, int, i, NAME, OP)

◆ HWY_RVV_FOREACH_U

#define HWY_RVV_FOREACH_U (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:287

◆ HWY_RVV_FOREACH_U08

#define HWY_RVV_FOREACH_U08 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)     HWY_CONCAT(HWY_RVV_FOREACH_08, LMULS)(X_MACRO, uint, u, NAME, OP)

◆ HWY_RVV_FOREACH_U16

#define HWY_RVV_FOREACH_U16 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)     HWY_CONCAT(HWY_RVV_FOREACH_16, LMULS)(X_MACRO, uint, u, NAME, OP)

◆ HWY_RVV_FOREACH_U163264

#define HWY_RVV_FOREACH_U163264 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:289

◆ HWY_RVV_FOREACH_U32

#define HWY_RVV_FOREACH_U32 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)     HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, uint, u, NAME, OP)

◆ HWY_RVV_FOREACH_U64

#define HWY_RVV_FOREACH_U64 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)     HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, uint, u, NAME, OP)

◆ HWY_RVV_FOREACH_UI

#define HWY_RVV_FOREACH_UI (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_U(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I(X_MACRO, NAME, OP, LMULS)

◆ HWY_RVV_FOREACH_UI08

#define HWY_RVV_FOREACH_UI08 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP, LMULS)

◆ HWY_RVV_FOREACH_UI16

#define HWY_RVV_FOREACH_UI16 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP, LMULS)

◆ HWY_RVV_FOREACH_UI163264

#define HWY_RVV_FOREACH_UI163264 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_U163264(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I163264(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_U163264(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:339

◆ HWY_RVV_FOREACH_UI32

#define HWY_RVV_FOREACH_UI32 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:291

◆ HWY_RVV_FOREACH_UI3264

#define HWY_RVV_FOREACH_UI3264 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_UI32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_UI64(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_UI32(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:327

◆ HWY_RVV_FOREACH_UI64

#define HWY_RVV_FOREACH_UI64 (   X_MACRO,
  NAME,
  OP,
  LMULS 
)
Value:
HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP, LMULS)
Definition: rvv-inl.h:293

◆ HWY_RVV_GATHER

#define HWY_RVV_GATHER (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT base, \
HWY_RVV_V(int, SEW, LMUL) offset) { \
return v##OP##ei##SEW##_v_##CHAR##SEW##LMUL( \
base, detail::BitCastToUnsigned(offset), Lanes(d)); \
}

◆ HWY_RVV_GET_LANE

#define HWY_RVV_GET_LANE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_T(BASE, SEW) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_s_##CHAR##SEW##LMUL##_##CHAR##SEW(v); /* no AVL */ \
}

◆ HWY_RVV_IF_POW2_IN

#define HWY_RVV_IF_POW2_IN (   D,
  min,
  max 
)     hwy::EnableIf<(min) <= Pow2(D()) && Pow2(D()) <= (max)>* = nullptr

◆ HWY_RVV_IF_THEN_ELSE

#define HWY_RVV_IF_THEN_ELSE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_M(MLEN) m, HWY_RVV_V(BASE, SEW, LMUL) yes, \
HWY_RVV_V(BASE, SEW, LMUL) no) { \
return v##OP##_vvm_##CHAR##SEW##LMUL(m, no, yes, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_IF_THEN_ZERO_ELSE

#define HWY_RVV_IF_THEN_ZERO_ELSE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_M(MLEN) m, HWY_RVV_V(BASE, SEW, LMUL) no) { \
return v##OP##_##CHAR##SEW##LMUL(m, no, 0, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_IOTA

#define HWY_RVV_IOTA (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d) { \
return v##OP##_##CHAR##SEW##LMUL(Lanes(d)); \
}

◆ HWY_RVV_LANES

#define HWY_RVV_LANES (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API size_t NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d) { \
size_t actual = v##OP##SEW##LMUL(); \
/* Common case of full vectors: avoid any extra instructions. */ \
/* actual includes LMUL, so do not shift again. */ \
if (detail::IsFull(d)) return actual; \
/* Check for virtual LMUL, e.g. "uint16mf8_t" (not provided by */ \
/* intrinsics). In this case the actual LMUL is 1/4, so divide by */ \
/* another factor of two. */ \
if (detail::ScaleByPower(128 / SEW, SHIFT) == 1) actual >>= 1; \
return HWY_MIN(actual, N); \
}
#define HWY_MIN(a, b)
Definition: base.h:125
constexpr size_t ScaleByPower(size_t N, int pow2)
Definition: ops/shared-inl.h:111
constexpr bool IsFull(Simd< T, N, kPow2 >)
Definition: ops/shared-inl.h:103

◆ HWY_RVV_LOAD

#define HWY_RVV_LOAD (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL(p, Lanes(d)); \
}

◆ HWY_RVV_LOAD2

#define HWY_RVV_LOAD2 (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT unaligned, \
HWY_RVV_V(BASE, SEW, LMUL) & v0, \
HWY_RVV_V(BASE, SEW, LMUL) & v1) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(&v0, &v1, unaligned, Lanes(d)); \
}

◆ HWY_RVV_LOAD3

#define HWY_RVV_LOAD3 (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT unaligned, \
HWY_RVV_V(BASE, SEW, LMUL) & v0, \
HWY_RVV_V(BASE, SEW, LMUL) & v1, \
HWY_RVV_V(BASE, SEW, LMUL) & v2) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(&v0, &v1, &v2, unaligned, Lanes(d)); \
}

◆ HWY_RVV_LOAD4

#define HWY_RVV_LOAD4 (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API void NAME( \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT aligned, \
HWY_RVV_V(BASE, SEW, LMUL) & v0, HWY_RVV_V(BASE, SEW, LMUL) & v1, \
HWY_RVV_V(BASE, SEW, LMUL) & v2, HWY_RVV_V(BASE, SEW, LMUL) & v3) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(&v0, &v1, &v2, &v3, aligned, \
Lanes(d)); \
}

◆ HWY_RVV_LOAD_MASK_BITS

#define HWY_RVV_LOAD_MASK_BITS (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
NAME(hwy::SizeTag<MLEN> /* tag */, const uint8_t* bits, size_t N) { \
return OP##_v_b##MLEN(bits, N); \
}
#define HWY_INLINE
Definition: base.h:62
Definition: base.h:358

◆ HWY_RVV_M

#define HWY_RVV_M (   MLEN)    vbool##MLEN##_t

◆ HWY_RVV_MASKED_LOAD

#define HWY_RVV_MASKED_LOAD (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_M(MLEN) m, HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL##_m(m, Zero(d), p, Lanes(d)); \
}
HWY_API VFromD< Simd< T, N, kPow2 > > Zero(Simd< T, N, kPow2 > d)
Definition: rvv-inl.h:498

◆ HWY_RVV_NEAREST

#define HWY_RVV_NEAREST (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(int, SEW, LMUL) NearestInt(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return vfcvt_x_f_v_i##SEW##LMUL(v, HWY_RVV_AVL(SEW, SHIFT)); \
}
HWY_API Vec128< int32_t, N > NearestInt(const Vec128< float, N > v)
Definition: arm_neon-inl.h:3424

◆ HWY_RVV_PROMOTE [1/2]

#define HWY_RVV_PROMOTE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEWD, LMULD) NAME( \
HWY_RVV_D(BASE, SEWD, N, SHIFT + 1) d, HWY_RVV_V(BASE, SEW, LMUL) v) { \
return OP##CHAR##SEWD##LMULD(v, Lanes(d)); \
}

◆ HWY_RVV_PROMOTE [2/2]

#define HWY_RVV_PROMOTE (   OP,
  BASE,
  CHAR,
  BITS,
  BASE_IN,
  BITS_IN,
  LMUL,
  LMUL_IN,
  SHIFT,
  ADD 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, BITS, LMUL) \
PromoteTo(HWY_RVV_D(BASE, BITS, N, SHIFT + ADD) d, \
HWY_RVV_V(BASE_IN, BITS_IN, LMUL_IN) v) { \
return OP##CHAR##BITS##LMUL(v, Lanes(d)); \
}

◆ HWY_RVV_PROMOTE_X2

#define HWY_RVV_PROMOTE_X2 (   OP,
  BASE,
  CHAR,
  BITS,
  BASE_IN,
  BITS_IN 
)
Value:
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m1, mf2, -2, 1) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m1, mf2, -1, 1) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m2, m1, 0, 1) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m4, m2, 1, 1) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m8, m4, 2, 1)
#define HWY_RVV_PROMOTE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
Definition: rvv-inl.h:1552

◆ HWY_RVV_PROMOTE_X4

#define HWY_RVV_PROMOTE_X4 (   OP,
  BASE,
  CHAR,
  BITS,
  BASE_IN,
  BITS_IN 
)
Value:
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, mf2, mf8, -3, 2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m1, mf4, -2, 2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m2, mf2, -1, 2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m4, m1, 0, 2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m8, m2, 1, 2)

◆ HWY_RVV_REDUCE

#define HWY_RVV_REDUCE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <class D> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(D d, HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(BASE, SEW, m1) v0) { \
return Set(d, GetLane(v##OP##_vs_##CHAR##SEW##LMUL##_##CHAR##SEW##m1( \
v0, v, v0, Lanes(d)))); \
}
decltype(Set(Simd< uint16_t, N, kPow2 >(), 0)) Set(Simd< bfloat16_t, N, kPow2 > d, bfloat16_t arg)
Definition: rvv-inl.h:487
HWY_API TFromV< V > GetLane(const V v)
Definition: arm_neon-inl.h:1061

◆ HWY_RVV_RETM_ARGM

#define HWY_RVV_RETM_ARGM (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_M(MLEN) NAME(HWY_RVV_M(MLEN) m) { \
return vm##OP##_m_b##MLEN(m, ~0ull); \
}

◆ HWY_RVV_RETM_ARGMM

#define HWY_RVV_RETM_ARGMM (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_M(MLEN) NAME(HWY_RVV_M(MLEN) a, HWY_RVV_M(MLEN) b) { \
return vm##OP##_mm_b##MLEN(b, a, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETM_ARGVS

#define HWY_RVV_RETM_ARGVS (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_T(BASE, SEW) b) { \
return v##OP##_##CHAR##SEW##LMUL##_b##MLEN(a, b, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETM_ARGVV

#define HWY_RVV_RETM_ARGVV (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_V(BASE, SEW, LMUL) b) { \
return v##OP##_vv_##CHAR##SEW##LMUL##_b##MLEN(a, b, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETV_ARGV

#define HWY_RVV_RETV_ARGV (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL(v, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETV_ARGV2

#define HWY_RVV_RETV_ARGV2 (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, v, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETV_ARGVS

#define HWY_RVV_RETV_ARGVS (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_T(BASE, SEW) b) { \
return v##OP##_##CHAR##SEW##LMUL(a, b, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETV_ARGVV

#define HWY_RVV_RETV_ARGVV (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_V(BASE, SEW, LMUL) b) { \
return v##OP##_vv_##CHAR##SEW##LMUL(a, b, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SCATTER

#define HWY_RVV_SCATTER (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_V(BASE, SEW, LMUL) v, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT base, \
HWY_RVV_V(int, SEW, LMUL) offset) { \
return v##OP##ei##SEW##_v_##CHAR##SEW##LMUL( \
base, detail::BitCastToUnsigned(offset), v, Lanes(d)); \
}

◆ HWY_RVV_SET

#define HWY_RVV_SET (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, HWY_RVV_T(BASE, SEW) arg) { \
return v##OP##_##CHAR##SEW##LMUL(arg, Lanes(d)); \
}

◆ HWY_RVV_SHIFT

#define HWY_RVV_SHIFT (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <int kBits> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_vx_##CHAR##SEW##LMUL(v, kBits, HWY_RVV_AVL(SEW, SHIFT)); \
} \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME##Same(HWY_RVV_V(BASE, SEW, LMUL) v, int bits) { \
return v##OP##_vx_##CHAR##SEW##LMUL(v, static_cast<uint8_t>(bits), \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SHIFT_II

#define HWY_RVV_SHIFT_II (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(BASE, SEW, LMUL) bits) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, detail::BitCastToUnsigned(bits), \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SHIFT_VV

#define HWY_RVV_SHIFT_VV (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(BASE, SEW, LMUL) bits) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, bits, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SLIDE

#define HWY_RVV_SLIDE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) dst, HWY_RVV_V(BASE, SEW, LMUL) src, \
size_t lanes) { \
return v##OP##_vx_##CHAR##SEW##LMUL(dst, src, lanes, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SLIDE1

#define HWY_RVV_SLIDE1 (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_##CHAR##SEW##LMUL(v, 0, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_STORE

#define HWY_RVV_STORE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_V(BASE, SEW, LMUL) v, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL(p, v, Lanes(d)); \
}

◆ HWY_RVV_STORE2

#define HWY_RVV_STORE2 (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_V(BASE, SEW, LMUL) v0, \
HWY_RVV_V(BASE, SEW, LMUL) v1, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT unaligned) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(unaligned, v0, v1, Lanes(d)); \
}

◆ HWY_RVV_STORE3

#define HWY_RVV_STORE3 (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API void NAME( \
HWY_RVV_V(BASE, SEW, LMUL) v0, HWY_RVV_V(BASE, SEW, LMUL) v1, \
HWY_RVV_V(BASE, SEW, LMUL) v2, HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT unaligned) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(unaligned, v0, v1, v2, Lanes(d)); \
}

◆ HWY_RVV_STORE4

#define HWY_RVV_STORE4 (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API void NAME( \
HWY_RVV_V(BASE, SEW, LMUL) v0, HWY_RVV_V(BASE, SEW, LMUL) v1, \
HWY_RVV_V(BASE, SEW, LMUL) v2, HWY_RVV_V(BASE, SEW, LMUL) v3, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT aligned) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(aligned, v0, v1, v2, v3, Lanes(d)); \
}

◆ HWY_RVV_STORE_MASK_BITS

#define HWY_RVV_STORE_MASK_BITS (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <class D> \
HWY_API size_t NAME(D d, HWY_RVV_M(MLEN) m, uint8_t* bits) { \
const size_t N = Lanes(d); \
OP##_v_b##MLEN(bits, m, N); \
/* Non-full byte, need to clear the undefined upper bits. */ \
/* Use MaxLanes and sizeof(T) to move some checks to compile-time. */ \
constexpr bool kLessThan8 = \
detail::ScaleByPower(16 / sizeof(TFromD<D>), Pow2(d)) < 8; \
if (MaxLanes(d) < 8 || (kLessThan8 && N < 8)) { \
const int mask = (1 << N) - 1; \
bits[0] = static_cast<uint8_t>(bits[0] & mask); \
} \
return (N + 7) / 8; \
}
HWY_INLINE constexpr HWY_MAYBE_UNUSED int Pow2(D)
Definition: ops/shared-inl.h:252
HWY_INLINE constexpr HWY_MAYBE_UNUSED size_t MaxLanes(D)
Definition: ops/shared-inl.h:276

◆ HWY_RVV_STOREN

#define HWY_RVV_STOREN (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API void NAME(size_t count, HWY_RVV_V(BASE, SEW, LMUL) v, \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL(p, v, count); \
}

◆ HWY_RVV_T

#define HWY_RVV_T (   BASE,
  SEW 
)    BASE##SEW##_t

◆ HWY_RVV_TABLE

#define HWY_RVV_TABLE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(uint, SEW, LMUL) idx) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, idx, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_TRUNC

#define HWY_RVV_TRUNC (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMULH) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL##_##CHAR##SEW##LMULH(v); /* no AVL */ \
}

◆ HWY_RVV_UNDEFINED

#define HWY_RVV_UNDEFINED (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) /* tag */) { \
return v##OP##_##CHAR##SEW##LMUL(); /* no AVL */ \
}

◆ HWY_RVV_V

#define HWY_RVV_V (   BASE,
  SEW,
  LMUL 
)    v##BASE##SEW##LMUL##_t

◆ HWY_RVV_VEC_FROM_MASK

#define HWY_RVV_VEC_FROM_MASK (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v0, HWY_RVV_M(MLEN) m) { \
return v##OP##_##CHAR##SEW##LMUL##_m(m, v0, v0, 1, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_SPECIALIZE

#define HWY_SPECIALIZE (   BASE,
  CHAR,
  SEW,
  SEWD,
  SEWH,
  LMUL,
  LMULD,
  LMULH,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <> \
struct DFromV_t<HWY_RVV_V(BASE, SEW, LMUL)> { \
using Lane = HWY_RVV_T(BASE, SEW); \
using type = ScalableTag<Lane, SHIFT>; \
};

Function Documentation

◆ HWY_AFTER_NAMESPACE()

HWY_AFTER_NAMESPACE ( )

◆ HWY_BEFORE_NAMESPACE()

HWY_BEFORE_NAMESPACE ( )