Grok 12.0.1
Classes | Namespaces | Macros | Typedefs | Functions
rvv-inl.h File Reference
#include <riscv_vector.h>
#include "hwy/ops/shared-inl.h"

Go to the source code of this file.

Classes

struct  hwy::HWY_NAMESPACE::DFromV_t< V >
 
class  hwy::HWY_NAMESPACE::detail::AdjustSimdTagToMinVecPow2_t< D >
 
class  hwy::HWY_NAMESPACE::detail::AdjustSimdTagToMinVecPow2_t< Simd< T, N, kPow2 > >
 
struct  hwy::HWY_NAMESPACE::CompressIsPartition< T >
 
struct  hwy::HWY_NAMESPACE::detail::Vec64ValsWrapper< T >
 

Namespaces

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

Macros

#define HWY_RVV_HAVE_F16C   0
 
#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_UNCONDITIONAL(X_MACRO, NAME, OP, LMULS)    HWY_CONCAT(HWY_RVV_FOREACH_16, LMULS)(X_MACRO, float, f, NAME, OP)
 
#define HWY_RVV_FOREACH_F16(X_MACRO, NAME, OP, LMULS)
 
#define HWY_RVV_IF_EMULATED_D(D)   HWY_IF_SPECIAL_FLOAT_D(D)
 
#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_TUP(BASE, SEW, LMUL, TUP)   v##BASE##SEW##LMUL##x##TUP##_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_CAPPED_LANES_SPECIAL_CASES(BASE, SEW, LMUL)
 
#define HWY_RVV_LANES(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_LANES_VIRT(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_RETV_ARGMVV(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_MASKED_IOTA(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_NATIVE_OPERATOR_REPLACEMENTS
 
#define HWY_NATIVE_I32_SATURATED_ADDSUB
 
#define HWY_NATIVE_U32_SATURATED_ADDSUB
 
#define HWY_NATIVE_I64_SATURATED_ADDSUB
 
#define HWY_NATIVE_U64_SATURATED_ADDSUB
 
#define HWY_RVV_INSERT_VXRM(vxrm, avl)   vxrm, avl
 
#define HWY_RVV_RETV_AVERAGE(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_NATIVE_MUL_8
 
#define HWY_NATIVE_MUL_64
 
#define HWY_RVV_MUL15(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_NATIVE_INT_DIV
 
#define HWY_NATIVE_MASKED_ARITH
 
#define HWY_NATIVE_F64_APPROX_RECIP
 
#define HWY_NATIVE_F64_APPROX_RSQRT
 
#define HWY_NATIVE_INT_FMA
 
#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_NATIVE_IS_NEGATIVE
 
#define HWY_NATIVE_MASK_FALSE
 
#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_NATIVE_PROMOTE_MASK_TO
 
#define HWY_NATIVE_DEMOTE_MASK_TO
 
#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_NATIVE_LOAD_N
 
#define HWY_RVV_LOADN(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_NATIVE_STORE_N
 
#define HWY_NATIVE_SCATTER
 
#define HWY_RVV_SCATTER(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_MASKED_SCATTER(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_NATIVE_GATHER
 
#define HWY_RVV_GATHER(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_MASKED_GATHER(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_PROMOTE_X4_FROM_U8(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN)
 
#define HWY_RVV_PROMOTE_X8(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_DEMOTE_TO_SHR_16(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_NATIVE_DEMOTE_F32_TO_BF16
 
#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_UP(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SLIDE_DOWN(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_NATIVE_SLIDE1_UP_DOWN
 
#define HWY_RVV_GET_LANE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SET_AT_OR_AFTER_FIRST(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_TABLE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_TABLE16(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_MASKED_TABLE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_MASKED_TABLE16(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_IF_SAME_T_DV(D, V)    hwy::EnableIf<IsSame<NativeLaneType<TFromD<D>>, TFromV<V>>()>* = nullptr
 
#define HWY_NATIVE_REVERSE2_8
 
#define HWY_NATIVE_COMPRESS8
 
#define HWY_RVV_COMPRESS(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_NATIVE_EXPAND
 
#define HWY_RVV_NARROW(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_NATIVE_BROADCASTLANE
 
#define HWY_RVV_BROADCAST_LANE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_NATIVE_BLK_INSERT_EXTRACT
 
#define HWY_NATIVE_INTERLEAVE_WHOLE
 
#define HWY_RVV_IF_GE128_D(D)   hwy::EnableIf<detail::IsGE128(D())>* = nullptr
 
#define HWY_RVV_IF_LT128_D(D)   hwy::EnableIf<detail::IsLT128(D())>* = nullptr
 
#define HWY_RVV_IF_CAN128_D(D)    hwy::EnableIf<!detail::IsLT128(D()) && !detail::IsGE128(D())>* = nullptr
 
#define HWY_NATIVE_REDUCE_SCALAR
 
#define HWY_RVV_REDUCE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_IF_REDUCE_D(D)   hwy::EnableIf<HWY_MAX_LANES_D(D) != 1>* = nullptr
 
#define HWY_NATIVE_REDUCE_SUM_4_UI8
 
#define HWY_NATIVE_REDUCE_MINMAX_4_UI8
 
#define HWY_NATIVE_LOAD_STORE_INTERLEAVED
 
#define HWY_RVV_LOAD_STRIDED(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_STORE_STRIDED(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)
 
#define HWY_NATIVE_ISINF
 
#define HWY_RVV_WIDEN_MACC(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
 

Typedefs

template<class D >
using hwy::HWY_NAMESPACE::detail::AdjustSimdTagToMinVecPow2
 

Functions

 HWY_BEFORE_NAMESPACE ()
 
template<typename T , size_t N, int kPow2>
constexpr size_t hwy::HWY_NAMESPACE::MLenFromD (Simd< T, N, kPow2 >)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
HWY_API size_t hwy::HWY_NAMESPACE::Lanes (D)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
HWY_API size_t hwy::HWY_NAMESPACE::CappedLanes (D, size_t cap)
 
template<size_t N, int kPow2>
decltype(Set(Simd< int16_t, N, kPow2 >(), 0)) hwy::HWY_NAMESPACE::Set (Simd< hwy::bfloat16_t, N, kPow2 > d, hwy::bfloat16_t arg)
 
template<size_t N, int kPow2>
decltype(Set(Simd< uint16_t, N, kPow2 >(), 0)) hwy::HWY_NAMESPACE::Set (Simd< hwy::float16_t, N, kPow2 > d, hwy::float16_t arg)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Zero (D d)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Undefined (D)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
VFromD< D > hwy::HWY_NAMESPACE::detail::Ext (D d, VFromD< Half< D > > v)
 
template<size_t N, int kPow2>
HWY_INLINE VFromD< Simd< uint16_t, N, kPow2 > > hwy::HWY_NAMESPACE::detail::BitCastFromByte (Simd< hwy::float16_t, N, kPow2 >, VFromD< Simd< uint8_t, N, kPow2 > > v)
 
template<size_t N, int kPow2>
HWY_INLINE VFromD< Simd< int16_t, N, kPow2 > > hwy::HWY_NAMESPACE::detail::BitCastFromByte (Simd< hwy::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 , 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::Xor3 (V x1, V x2, V x3)
 
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_IF_U8_D(DFromV< VU8 >) >
HWY_API VFromD< Repartition< uint64_t, DFromV< VU8 > > > hwy::HWY_NAMESPACE::SumsOf8 (const VU8 v)
 
template<class VI8 , HWY_IF_I8_D(DFromV< VI8 >) >
HWY_API VFromD< Repartition< int64_t, DFromV< VI8 > > > hwy::HWY_NAMESPACE::SumsOf8 (const VI8 v)
 
template<int kBits, class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(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 MFromD< DFromV< V > > hwy::HWY_NAMESPACE::MaskFromVec (const V v)
 
template<class V , HWY_IF_NOT_UNSIGNED_V(V) >
HWY_API MFromD< DFromV< V > > hwy::HWY_NAMESPACE::IsNegative (V v)
 
template<class D >
HWY_API MFromD< D > hwy::HWY_NAMESPACE::MaskFalse (D d)
 
template<class D , typename MFrom >
HWY_API MFromD< D > hwy::HWY_NAMESPACE::RebindMask (const D, const MFrom mask)
 
template<class D , HWY_IF_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::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<class DTo , class DFrom , HWY_IF_T_SIZE_GT_D(DTo, sizeof(TFromD< DFrom >)) , hwy::EnableIf< IsSame< MFromD< DTo >, MFromD< DFrom > >()> * = nullptr>
HWY_API MFromD< DTo > hwy::HWY_NAMESPACE::PromoteMaskTo (DTo, DFrom, MFromD< DFrom > m)
 
template<class DTo , class DFrom , HWY_IF_T_SIZE_LE_D(DTo, sizeof(TFromD< DFrom >) - 1) , hwy::EnableIf< IsSame< MFromD< DTo >, MFromD< DFrom > >()> * = nullptr>
HWY_API MFromD< DTo > hwy::HWY_NAMESPACE::DemoteMaskTo (DTo, DFrom, MFromD< DFrom > m)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Load (D d, const TFromD< D > *HWY_RESTRICT p)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::LoadU (D d, const TFromD< D > *HWY_RESTRICT p)
 
template<class D , HWY_SVE_IF_EMULATED_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MaskedLoad (MFromD< D > m, D d, const TFromD< D > *HWY_RESTRICT p)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MaskedLoadOr (VFromD< D > no, MFromD< D > m, D d, const TFromD< D > *HWY_RESTRICT p)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::LoadN (D d, const TFromD< D > *HWY_RESTRICT p, size_t num_lanes)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::LoadNOr (VFromD< D > v, D d, const TFromD< D > *HWY_RESTRICT p, size_t num_lanes)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
HWY_API void hwy::HWY_NAMESPACE::Store (VFromD< D > v, D d, TFromD< D > *HWY_RESTRICT p)
 
template<class D , HWY_SVE_IF_EMULATED_D(D) >
HWY_API void hwy::HWY_NAMESPACE::BlendedStore (VFromD< D > v, MFromD< D > m, D d, TFromD< D > *HWY_RESTRICT p)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreN (size_t count, VFromD< D > v, D d, TFromD< D > *HWY_RESTRICT p)
 
template<class D >
HWY_API void hwy::HWY_NAMESPACE::StoreN (VFromD< D > v, D d, TFromD< D > *HWY_RESTRICT p, size_t max_lanes_to_store)
 
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_API void hwy::HWY_NAMESPACE::ScatterIndex (VFromD< D > v, D d, TFromD< D > *HWY_RESTRICT base, VFromD< RebindToSigned< D > > indices)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::GatherIndex (D d, const TFromD< D > *HWY_RESTRICT p, VFromD< RebindToSigned< D > > indices)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MaskedGatherIndex (MFromD< D > m, D d, const TFromD< D > *base, VFromD< RebindToSigned< D > > indices)
 
template<size_t N>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< int64_t, N, -1 > d, VFromD< Rebind< int16_t, decltype(d)> > v) -> VFromD< decltype(d)>
 
template<size_t N>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< uint64_t, N, -1 > 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< 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< int64_t, N, kPow2 > d, VFromD< Rebind< uint32_t, decltype(d)> > v) -> VFromD< decltype(d)>
 
template<size_t N, int kPow2>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< int64_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< int64_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< float32_t, N, kPow2 > d, VFromD< Rebind< hwy::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)
 
template<size_t N>
HWY_API vuint8mf8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, -3 > d, const vuint32mf2_t v)
 
template<size_t N>
HWY_API vuint8mf4_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, -2 > d, const vuint32m1_t v)
 
template<size_t N>
HWY_API vuint8mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, -1 > d, const vuint32m2_t v)
 
template<size_t N>
HWY_API vuint8m1_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, 0 > d, const vuint32m4_t v)
 
template<size_t N>
HWY_API vuint8m2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, 1 > d, const vuint32m8_t v)
 
template<size_t N, int kPow2>
HWY_API VFromD< Simd< uint8_t, N, kPow2 > > hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, kPow2 > d, VFromD< Simd< int64_t, N, kPow2+3 > > v)
 
template<size_t N, int kPow2>
HWY_API VFromD< Simd< uint8_t, N, kPow2 > > hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, kPow2 > d, VFromD< Simd< uint64_t, N, kPow2+3 > > v)
 
template<size_t N, int kPow2>
HWY_API VFromD< Simd< uint16_t, N, kPow2 > > hwy::HWY_NAMESPACE::DemoteTo (Simd< uint16_t, N, kPow2 > d, VFromD< Simd< int64_t, N, kPow2+2 > > v)
 
template<size_t N, int kPow2>
HWY_API VFromD< Simd< uint16_t, N, kPow2 > > hwy::HWY_NAMESPACE::DemoteTo (Simd< uint16_t, N, kPow2 > d, VFromD< Simd< uint64_t, N, kPow2+2 > > 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 vuint8mf8_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -3 > d, const VFromD< Simd< uint64_t, N, 0 > > v)
 
template<size_t N>
HWY_API vuint8mf4_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -2 > d, const VFromD< Simd< uint64_t, N, 1 > > v)
 
template<size_t N>
HWY_API vuint8mf2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -1 > d, const VFromD< Simd< uint64_t, N, 2 > > v)
 
template<size_t N>
HWY_API vuint8m1_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 0 > d, const VFromD< Simd< uint64_t, N, 3 > > v)
 
template<size_t N>
HWY_API vuint16mf4_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, -3 > d, const VFromD< Simd< uint64_t, N, -1 > > v)
 
template<size_t N>
HWY_API vuint16mf4_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, -2 > d, const VFromD< Simd< uint64_t, N, 0 > > v)
 
template<size_t N>
HWY_API vuint16mf2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, -1 > d, const VFromD< Simd< uint64_t, N, 1 > > v)
 
template<size_t N>
HWY_API vuint16m1_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, 0 > d, const VFromD< Simd< uint64_t, N, 2 > > v)
 
template<size_t N>
HWY_API vuint16m2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, 1 > d, const VFromD< Simd< uint64_t, N, 3 > > v)
 
template<size_t N>
HWY_API vuint32mf2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, -2 > d, const VFromD< Simd< uint64_t, N, -1 > > v)
 
template<size_t N>
HWY_API vuint32mf2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, -1 > d, const VFromD< Simd< uint64_t, N, 0 > > v)
 
template<size_t N>
HWY_API vuint32m1_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, 0 > d, const VFromD< Simd< uint64_t, N, 1 > > v)
 
template<size_t N>
HWY_API vuint32m2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, 1 > d, const VFromD< Simd< uint64_t, N, 2 > > v)
 
template<size_t N>
HWY_API vuint32m4_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, 2 > d, const VFromD< Simd< uint64_t, N, 3 > > v)
 
template<size_t N>
HWY_API vuint8mf8_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -3 > d, const VFromD< Simd< uint32_t, N, -1 > > v)
 
template<size_t N>
HWY_API vuint8mf4_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -2 > d, const VFromD< Simd< uint32_t, N, 0 > > v)
 
template<size_t N>
HWY_API vuint8mf2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -1 > d, const VFromD< Simd< uint32_t, N, 1 > > v)
 
template<size_t N>
HWY_API vuint8m1_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 0 > d, const VFromD< Simd< uint32_t, N, 2 > > v)
 
template<size_t N>
HWY_API vuint8m2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 1 > d, const VFromD< Simd< uint32_t, N, 3 > > v)
 
template<size_t N>
HWY_API vuint16mf4_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, -3 > d, const VFromD< Simd< uint32_t, N, -2 > > v)
 
template<size_t N>
HWY_API vuint16mf4_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, -2 > d, const VFromD< Simd< uint32_t, N, -1 > > v)
 
template<size_t N>
HWY_API vuint16mf2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, -1 > d, const VFromD< Simd< uint32_t, N, 0 > > v)
 
template<size_t N>
HWY_API vuint16m1_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, 0 > d, const VFromD< Simd< uint32_t, N, 1 > > v)
 
template<size_t N>
HWY_API vuint16m2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, 1 > d, const VFromD< Simd< uint32_t, N, 2 > > v)
 
template<size_t N>
HWY_API vuint16m4_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, 2 > d, const VFromD< Simd< uint32_t, N, 3 > > v)
 
template<size_t N>
HWY_API vuint8mf8_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -3 > d, const VFromD< Simd< uint16_t, N, -2 > > v)
 
template<size_t N>
HWY_API vuint8mf4_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -2 > d, const VFromD< Simd< uint16_t, N, -1 > > v)
 
template<size_t N>
HWY_API vuint8mf2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -1 > d, const VFromD< Simd< uint16_t, N, 0 > > v)
 
template<size_t N>
HWY_API vuint8m1_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 0 > d, const VFromD< Simd< uint16_t, N, 1 > > v)
 
template<size_t N>
HWY_API vuint8m2_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 1 > d, const VFromD< Simd< uint16_t, N, 2 > > v)
 
template<size_t N>
HWY_API vuint8m4_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 2 > d, const VFromD< Simd< uint16_t, N, 3 > > 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)
 
template<size_t N, int kPow2>
HWY_API VFromD< Simd< int8_t, N, kPow2 > > hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, kPow2 > d, VFromD< Simd< int64_t, N, kPow2+3 > > v)
 
template<size_t N, int kPow2>
HWY_API VFromD< Simd< int16_t, N, kPow2 > > hwy::HWY_NAMESPACE::DemoteTo (Simd< int16_t, N, kPow2 > d, VFromD< Simd< int64_t, N, kPow2+2 > > v)
 
template<size_t N>
HWY_API vint32mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, -2 > d, const vfloat64m1_t v)
 
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>
HWY_API vuint32mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint32_t, N, -2 > d, const vfloat64m1_t v)
 
template<size_t N>
HWY_API vuint32mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint32_t, N, -1 > d, const vfloat64m1_t v)
 
template<size_t N>
HWY_API vuint32m1_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint32_t, N, 0 > d, const vfloat64m2_t v)
 
template<size_t N>
HWY_API vuint32m2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint32_t, N, 1 > d, const vfloat64m4_t v)
 
template<size_t N>
HWY_API vuint32m4_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint32_t, N, 2 > d, const vfloat64m8_t v)
 
template<size_t N>
HWY_API vfloat32mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, -2 > d, const vint64m1_t v)
 
template<size_t N>
HWY_API vfloat32mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, -1 > d, const vint64m1_t v)
 
template<size_t N>
HWY_API vfloat32m1_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, 0 > d, const vint64m2_t v)
 
template<size_t N>
HWY_API vfloat32m2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, 1 > d, const vint64m4_t v)
 
template<size_t N>
HWY_API vfloat32m4_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, 2 > d, const vint64m8_t v)
 
template<size_t N>
HWY_API vfloat32mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, -2 > d, const vuint64m1_t v)
 
template<size_t N>
HWY_API vfloat32mf2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, -1 > d, const vuint64m1_t v)
 
template<size_t N>
HWY_API vfloat32m1_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, 0 > d, const vuint64m2_t v)
 
template<size_t N>
HWY_API vfloat32m2_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, 1 > d, const vuint64m4_t v)
 
template<size_t N>
HWY_API vfloat32m4_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, 2 > d, const vuint64m8_t v)
 
template<class V , HWY_IF_F32(TFromV< V >) >
HWY_INLINE VFromD< RebindToUnsigned< DFromV< V > > > hwy::HWY_NAMESPACE::detail::RoundF32ForDemoteToBF16 (V v)
 
template<size_t N, int kPow2>
HWY_API VFromD< Simd< hwy::bfloat16_t, N, kPow2 > > hwy::HWY_NAMESPACE::DemoteTo (Simd< hwy::bfloat16_t, N, kPow2 > d, VFromD< Simd< float, N, kPow2+1 > > v)
 
template<typename T , size_t N, int kPow2>
HWY_INLINE 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 >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::SlideUpLanes (D d, VFromD< D > v, size_t amt)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::SlideDownLanes (D d, VFromD< D > v, size_t amt)
 
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 D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Slide1Up (D d, VFromD< D > v)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Slide1Down (D d, VFromD< D > v)
 
template<class V >
HWY_API TFromV< V > hwy::HWY_NAMESPACE::ExtractLane (V v, size_t i)
 
template<class V , typename T , HWY_IF_NOT_T_SIZE_V(V, 1) >
HWY_APIhwy::HWY_NAMESPACE::InsertLane (const V v, size_t i, T t)
 
template<class D , HWY_IF_NOT_T_SIZE_D(D, 8) >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::detail::IsEven (D d)
 
template<class D , HWY_IF_NOT_T_SIZE_D(D, 8) >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::detail::IsOdd (D d)
 
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 D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::InterleaveEven (D, VFromD< D > a, VFromD< D > b)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::InterleaveOdd (D, VFromD< D > a, VFromD< D > b)
 
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 , HWY_IF_T_SIZE_D(D, 1) , HWY_IF_POW2_LE_D(D, 2) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse (D d, VFromD< D > v)
 
template<class D , HWY_IF_T_SIZE_ONE_OF_D(D,(1<< 2)|(1<< 4)|(1<< 8)) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse (D, VFromD< D > v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ChangeLMUL (D, VFromD< D > v)
 
template<class D , class V , HWY_IF_POW2_LE_D(DFromV< VFromD< D > >, DFromV< V >().Pow2() - 1) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ChangeLMUL (D d, V v)
 
template<class DTo , class VFrom >
HWY_API VFromD< DTo > hwy::HWY_NAMESPACE::ResizeBitCast (DTo, VFrom v)
 
template<class D , HWY_IF_T_SIZE_D(D, 8) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse2 (D d, VFromD< D > v)
 
template<class D , class V = VFromD<D>, HWY_IF_T_SIZE_D(D, 8) >
HWY_APIhwy::HWY_NAMESPACE::Reverse2 (D, const V v)
 
template<class D , HWY_IF_T_SIZE_D(D, 4) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse4 (D d, VFromD< D > v)
 
template<class D , HWY_IF_T_SIZE_D(D, 2) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse8 (D d, 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_IF_NOT_T_SIZE_V(V, 1) >
HWY_APIhwy::HWY_NAMESPACE::Expand (V v, const M mask)
 
template<class V , class M , HWY_IF_T_SIZE_V(V, 1) , class D = DFromV<V>, HWY_IF_POW2_LE_D(D, 2) >
HWY_APIhwy::HWY_NAMESPACE::Expand (V v, const M mask)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::LoadExpand (MFromD< D > mask, D d, const TFromD< D > *HWY_RESTRICT unaligned)
 
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<class D >
HWY_API intptr_t hwy::HWY_NAMESPACE::FindLastTrue (D d, MFromD< D > mask)
 
template<class D >
HWY_API size_t hwy::HWY_NAMESPACE::FindKnownLastTrue (D d, MFromD< D > mask)
 
template<class D , HWY_IF_NOT_T_SIZE_D(D, 8) , HWY_IF_POW2_LE_D(D, 2) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::ConcatOdd (D d, VFromD< D > hi, VFromD< D > lo)
 
template<class D , HWY_IF_V_SIZE_GT_D(D, 4) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::ConcatOdd (D, VFromD< D > hi, VFromD< D > lo)
 
template<class D , HWY_IF_NOT_T_SIZE_D(D, 8) , HWY_IF_POW2_LE_D(D, 2) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::ConcatEven (D d, VFromD< D > hi, VFromD< D > lo)
 
template<class D , HWY_IF_V_SIZE_GT_D(D, 4) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::ConcatEven (D, VFromD< D > hi, VFromD< D > lo)
 
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<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<class D , HWY_IF_POW2_LE_D(D, 2) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::TwoTablesLookupLanes (D d, VFromD< D > a, VFromD< D > b, VFromD< RebindToUnsigned< D > > idx)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::TwoTablesLookupLanes (V a, V b, VFromD< RebindToUnsigned< DFromV< V > > > idx)
 
template<int kLane, class V , class D = DFromV<V>, HWY_IF_T_SIZE_D(D, 1) , HWY_IF_POW2_LE_D(D, 2) >
HWY_APIhwy::HWY_NAMESPACE::Broadcast (const V v)
 
template<int kLane, typename V , HWY_NEON_IF_EMULATED_D(DFromV< V >) , HWY_IF_LANES_GT_D(DFromV< V >, 1) >
HWY_APIhwy::HWY_NAMESPACE::Broadcast (V v)
 
template<int kLane, class V >
HWY_APIhwy::HWY_NAMESPACE::BroadcastLane (const V v)
 
template<int kBlockIdx, class V >
HWY_APIhwy::HWY_NAMESPACE::InsertBlock (V v, VFromD< BlockDFromD< DFromV< V > > > blk_to_insert)
 
template<int kBlockIdx, class V , HWY_IF_V_SIZE_LE_V(V, 16) >
HWY_APIhwy::HWY_NAMESPACE::BroadcastBlock (V v)
 
template<int kBlockIdx, class V >
HWY_API VFromD< BlockDFromD< DFromV< V > > > hwy::HWY_NAMESPACE::ExtractBlock (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, 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 , HWY_IF_T_SIZE_ONE_OF_D(D,(1<< 1)|(1<< 2)|(1<< 4)) , HWY_IF_POW2_GT_D(D, -3) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::detail::InterleaveWhole (D d, VFromD< Half< D > > a, VFromD< Half< D > > b)
 
template<class D , HWY_IF_T_SIZE_ONE_OF_D(D,(1<< 1)|(1<< 2)|(1<< 4)) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::InterleaveWholeLower (D d, VFromD< D > a, VFromD< D > b)
 
template<class D , HWY_IF_T_SIZE_ONE_OF_D(D,(1<< 1)|(1<< 2)|(1<< 4)) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::InterleaveWholeUpper (D d, VFromD< D > a, VFromD< D > b)
 
template<class D , class V , HWY_IF_POW2_LE_D(D, 2) >
HWY_INLINEhwy::HWY_NAMESPACE::detail::InterleaveLowerBlocks (D d, const V a, const V b)
 
template<class D , class V , HWY_IF_POW2_LE_D(D, 2) >
HWY_INLINEhwy::HWY_NAMESPACE::detail::InterleaveUpperBlocks (D d, const V a, const V b)
 
template<typename T , size_t N, int kPow2>
constexpr bool hwy::HWY_NAMESPACE::detail::IsGE128 (Simd< T, N, kPow2 >)
 
template<typename T , size_t N, int kPow2>
constexpr bool hwy::HWY_NAMESPACE::detail::IsLT128 (Simd< T, N, kPow2 >)
 
template<class D , class V , HWY_RVV_IF_GE128_D(D) >
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 = VFromD<D>, hwy::EnableIf< detail::IsFull(D())> * = nullptr>
HWY_APIhwy::HWY_NAMESPACE::InterleaveUpper (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_IF_REDUCE_D(D) >
HWY_API TFromD< D > hwy::HWY_NAMESPACE::ReduceSum (D d, VFromD< D > v)
 
template<class D , typename T = TFromD<D>, HWY_IF_REDUCE_D(D) >
HWY_APIhwy::HWY_NAMESPACE::ReduceMin (D d, VFromD< D > v)
 
template<class D , typename T = TFromD<D>, HWY_IF_REDUCE_D(D) >
HWY_APIhwy::HWY_NAMESPACE::ReduceMax (D d, VFromD< D > v)
 
template<class D , HWY_IF_LANES_GT_D(D, 1) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::SumOfLanes (D d, VFromD< D > v)
 
template<class D , HWY_IF_LANES_GT_D(D, 1) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MinOfLanes (D d, VFromD< D > v)
 
template<class D , HWY_IF_LANES_GT_D(D, 1) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MaxOfLanes (D d, VFromD< D > v)
 
template<class D , typename T = TFromD<D>>
HWY_API void hwy::HWY_NAMESPACE::LoadInterleaved2 (D d, const T *HWY_RESTRICT unaligned, VFromD< D > &v0, VFromD< D > &v1)
 
template<class D , HWY_IF_LANES_PER_BLOCK_D(D, 16) >
HWY_API void hwy::HWY_NAMESPACE::LoadInterleaved3 (D d, const TFromD< D > *HWY_RESTRICT unaligned, VFromD< D > &v0, VFromD< D > &v1, VFromD< D > &v2)
 
template<class D , HWY_IF_LANES_PER_BLOCK_D(D, 16) >
HWY_API void hwy::HWY_NAMESPACE::LoadInterleaved4 (D d, const TFromD< D > *HWY_RESTRICT unaligned, VFromD< D > &v0, VFromD< D > &v1, VFromD< D > &v2, VFromD< D > &v3)
 
template<class D , typename T = TFromD<D>, HWY_IF_NOT_T_SIZE_D(D, 8) , HWY_IF_POW2_LE_D(D, 2) >
HWY_API void hwy::HWY_NAMESPACE::StoreInterleaved2 (VFromD< D > v0, VFromD< D > v1, D d, T *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_STORE_INT(D) , typename T = TFromD<D>>
HWY_API void hwy::HWY_NAMESPACE::StoreInterleaved2 (VFromD< D > v0, VFromD< D > v1, D d, T *HWY_RESTRICT unaligned)
 
template<class D , typename T = TFromD<D>>
HWY_API void hwy::HWY_NAMESPACE::StoreInterleaved3 (VFromD< D > v0, VFromD< D > v1, VFromD< D > v2, D d, T *HWY_RESTRICT unaligned)
 
template<class D , typename T = TFromD<D>>
HWY_API void hwy::HWY_NAMESPACE::StoreInterleaved4 (VFromD< D > v0, VFromD< D > v1, VFromD< D > v2, VFromD< D > v3, D d, T *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_T_SIZE_D(D, 8) , HWY_IF_V_SIZE_D(D, 8) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Dup128VecFromValues (D d, TFromD< D > t0, TFromD< D >)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3, TFromD< D > t4, TFromD< D > t5, TFromD< D > t6, TFromD< D > t7, TFromD< D > t8, TFromD< D > t9, TFromD< D > t10, TFromD< D > t11, TFromD< D > t12, TFromD< D > t13, TFromD< D > t14, TFromD< D > t15)
 
template<class D , HWY_IF_BF16_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Dup128VecFromValues (D d, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3, TFromD< D > t4, TFromD< D > t5, TFromD< D > t6, TFromD< D > t7)
 
template<class D , HWY_IF_T_SIZE_D(D, 4) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3)
 
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 , typename T2 , HWY_IF_FLOAT_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Iota (const D d, T2 first)
 
template<class V , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)|(1<< 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_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)|(1<< 4)) , class D = DFromV<V>, class DW = RepartitionToWide<D>>
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::MulOdd (const V a, const V b)
 
template<class V , HWY_IF_T_SIZE_V(V, 8) >
HWY_INLINEhwy::HWY_NAMESPACE::MulEven (const V a, const V b)
 
template<class V , HWY_IF_T_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< hwy::bfloat16_t, N, kPow2 > > hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< hwy::bfloat16_t, N, kPow2 > dbf16, VFromD< RepartitionToWide< decltype(dbf16)> > a, VFromD< RepartitionToWide< decltype(dbf16)> > b)
 
template<class DN , HWY_IF_NOT_FLOAT_NOR_SPECIAL(TFromD< DN >) , HWY_IF_POW2_LE_D(DN, 2) , class V , HWY_IF_SIGNED_V(V) , HWY_IF_T_SIZE_V(V, sizeof(TFromD< DN >) *2) , class V2 = VFromD<Repartition<TFromV<V>, DN>>, hwy::EnableIf< DFromV< V >().Pow2()==DFromV< V2 >().Pow2()> * = nullptr>
HWY_API VFromD< DN > hwy::HWY_NAMESPACE::ReorderDemote2To (DN dn, V a, V b)
 
template<class DN , HWY_IF_SPECIAL_FLOAT_D(DN) , HWY_IF_POW2_LE_D(DN, 2) , class V , HWY_IF_F32_D(DFromV< V >) , class V2 = VFromD<Repartition<TFromV<V>, DN>>, hwy::EnableIf< DFromV< V >().Pow2()==DFromV< V2 >().Pow2()> * = nullptr>
HWY_API VFromD< DN > hwy::HWY_NAMESPACE::OrderedDemote2To (DN dn, V a, V b)
 
template<class D32 , HWY_IF_F32_D(D32) , class V16 = VFromD<Repartition<bfloat16_t, D32>>>
HWY_API VFromD< D32 > hwy::HWY_NAMESPACE::WidenMulPairwiseAdd (D32 df32, V16 a, V16 b)
 
template<class D , HWY_IF_I32_D(D) , class VI16 >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::WidenMulPairwiseAdd (D d32, VI16 a, VI16 b)
 
template<size_t N, int kPow2, class DF32 = Simd<float, N, kPow2>, class VF32 = VFromD<DF32>, class DBF16 = Repartition<hwy::bfloat16_t, Simd<float, N, kPow2>>>
HWY_API VF32 hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateBF16 (Simd< float, N, kPow2 > df32, VFromD< DBF16 > a, VFromD< DBF16 > b, const VF32 sum0, VF32 &sum1)
 
template<class D32 , HWY_IF_POW2_LE_D(D32, 2) , class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateI16 (D32 d32, VFromD< D16 > a, VFromD< D16 > b, const V32 sum0, V32 &sum1)
 
template<class D32 , HWY_IF_POW2_LE_D(D32, 2) , class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateU16 (D32 d32, VFromD< D16 > a, VFromD< D16 > b, const V32 sum0, V32 &sum1)
 
template<size_t N, int kPow2, class VN , class VW >
HWY_API VW hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< float, N, kPow2 > d32, VN a, VN b, const VW sum0, VW &sum1)
 
template<size_t N, int kPow2, class VN , class VW >
HWY_API VW hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< int32_t, N, kPow2 > d32, VN a, VN b, const VW sum0, VW &sum1)
 
template<size_t N, int kPow2, class VN , class VW >
HWY_API VW hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< uint32_t, N, kPow2 > d32, VN a, VN b, const VW sum0, VW &sum1)
 
template<class VW , HWY_IF_SIGNED_V(VW) >
HWY_API VW hwy::HWY_NAMESPACE::RearrangeToOddPlusEven (const VW sum0, const VW sum1)
 
HWY_API vint32m8_t hwy::HWY_NAMESPACE::RearrangeToOddPlusEven (vint32m8_t sum0, vint32m8_t sum1)
 
HWY_API vuint32m8_t hwy::HWY_NAMESPACE::RearrangeToOddPlusEven (vuint32m8_t sum0, vuint32m8_t sum1)
 
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 MFromD< D > hwy::HWY_NAMESPACE::Eq128 (D d, const VFromD< D > a, const VFromD< D > b)
 
template<class D >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::Eq128Upper (D d, const VFromD< D > a, const VFromD< D > b)
 
template<class D >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::Ne128 (D d, const VFromD< D > a, const VFromD< D > b)
 
template<class D >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::Ne128Upper (D d, const VFromD< D > a, const VFromD< D > b)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::Min128 (D d, VFromD< D > a, VFromD< D > b)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::Max128 (D d, VFromD< D > a, VFromD< D > b)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::Min128Upper (D d, VFromD< D > a, VFromD< D > b)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::Max128Upper (D d, VFromD< D > a, VFromD< D > b)
 
 HWY_AFTER_NAMESPACE ()
 

Macro Definition Documentation

◆ HWY_IF_REDUCE_D

#define HWY_IF_REDUCE_D ( D)    hwy::EnableIf<HWY_MAX_LANES_D(D) != 1>* = nullptr

◆ HWY_NATIVE_BLK_INSERT_EXTRACT

#define HWY_NATIVE_BLK_INSERT_EXTRACT

◆ HWY_NATIVE_BROADCASTLANE

#define HWY_NATIVE_BROADCASTLANE

◆ HWY_NATIVE_COMPRESS8

#define HWY_NATIVE_COMPRESS8

◆ HWY_NATIVE_DEMOTE_F32_TO_BF16

#define HWY_NATIVE_DEMOTE_F32_TO_BF16

◆ HWY_NATIVE_DEMOTE_MASK_TO

#define HWY_NATIVE_DEMOTE_MASK_TO

◆ HWY_NATIVE_EXPAND

#define HWY_NATIVE_EXPAND

◆ HWY_NATIVE_F64_APPROX_RECIP

#define HWY_NATIVE_F64_APPROX_RECIP

◆ HWY_NATIVE_F64_APPROX_RSQRT

#define HWY_NATIVE_F64_APPROX_RSQRT

◆ HWY_NATIVE_GATHER

#define HWY_NATIVE_GATHER

◆ HWY_NATIVE_I32_SATURATED_ADDSUB

#define HWY_NATIVE_I32_SATURATED_ADDSUB

◆ HWY_NATIVE_I64_SATURATED_ADDSUB

#define HWY_NATIVE_I64_SATURATED_ADDSUB

◆ HWY_NATIVE_INT_DIV

#define HWY_NATIVE_INT_DIV

◆ HWY_NATIVE_INT_FMA

#define HWY_NATIVE_INT_FMA

◆ HWY_NATIVE_INTERLEAVE_WHOLE

#define HWY_NATIVE_INTERLEAVE_WHOLE

◆ HWY_NATIVE_IS_NEGATIVE

#define HWY_NATIVE_IS_NEGATIVE

◆ HWY_NATIVE_ISINF

#define HWY_NATIVE_ISINF

◆ HWY_NATIVE_LOAD_N

#define HWY_NATIVE_LOAD_N

◆ HWY_NATIVE_LOAD_STORE_INTERLEAVED

#define HWY_NATIVE_LOAD_STORE_INTERLEAVED

◆ HWY_NATIVE_MASK_FALSE

#define HWY_NATIVE_MASK_FALSE

◆ HWY_NATIVE_MASKED_ARITH

#define HWY_NATIVE_MASKED_ARITH

◆ HWY_NATIVE_MUL_64

#define HWY_NATIVE_MUL_64

◆ HWY_NATIVE_MUL_8

#define HWY_NATIVE_MUL_8

◆ HWY_NATIVE_OPERATOR_REPLACEMENTS

#define HWY_NATIVE_OPERATOR_REPLACEMENTS

◆ HWY_NATIVE_PROMOTE_MASK_TO

#define HWY_NATIVE_PROMOTE_MASK_TO

◆ HWY_NATIVE_REDUCE_MINMAX_4_UI8

#define HWY_NATIVE_REDUCE_MINMAX_4_UI8

◆ HWY_NATIVE_REDUCE_SCALAR

#define HWY_NATIVE_REDUCE_SCALAR

◆ HWY_NATIVE_REDUCE_SUM_4_UI8

#define HWY_NATIVE_REDUCE_SUM_4_UI8

◆ HWY_NATIVE_REVERSE2_8

#define HWY_NATIVE_REVERSE2_8

◆ HWY_NATIVE_SCATTER

#define HWY_NATIVE_SCATTER

◆ HWY_NATIVE_SLIDE1_UP_DOWN

#define HWY_NATIVE_SLIDE1_UP_DOWN

◆ HWY_NATIVE_STORE_N

#define HWY_NATIVE_STORE_N

◆ HWY_NATIVE_U32_SATURATED_ADDSUB

#define HWY_NATIVE_U32_SATURATED_ADDSUB

◆ HWY_NATIVE_U64_SATURATED_ADDSUB

#define HWY_NATIVE_U64_SATURATED_ADDSUB

◆ 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, __riscv_vmnot_m_b##MLEN(m, Lanes(d))); \
}
#define HWY_API
Definition base.h:171
#define HWY_RVV_M(MLEN)
Definition rvv-inl.h:419

◆ 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 __riscv_v##OP##SEW##_v_##CHAR##SEW##LMUL##_m( \
m, detail::NativeLanePointer(p), v, Lanes(d)); \
}
#define HWY_RESTRICT
Definition base.h:95
#define HWY_RVV_D(BASE, SEW, N, SHIFT)
Definition rvv-inl.h:416
#define HWY_RVV_V(BASE, SEW, LMUL)
Definition rvv-inl.h:417
#define HWY_RVV_T(BASE, SEW)
Definition rvv-inl.h:415

◆ HWY_RVV_BROADCAST_LANE

#define HWY_RVV_BROADCAST_LANE ( 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, size_t idx) { \
return __riscv_v##OP##_vx_##CHAR##SEW##LMUL(v, idx, \
HWY_RVV_AVL(SEW, SHIFT)); \
}
#define HWY_RVV_AVL(SEW, SHIFT)
Definition rvv-inl.h:611

◆ HWY_RVV_CAPPED_LANES_SPECIAL_CASES

#define HWY_RVV_CAPPED_LANES_SPECIAL_CASES ( BASE,
SEW,
LMUL )

◆ 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 __riscv_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 __riscv_vreinterpret_v_u8##LMUL##_i8##LMUL(v); \
}

◆ 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 __riscv_v##OP##_v_u##SEW##LMUL##_u8##LMUL( \
__riscv_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 __riscv_v##OP##_v_u##SEW##LMUL##_##CHAR##SEW##LMUL( \
__riscv_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 __riscv_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 __riscv_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(__riscv_v##OP##_v_u##SEW##LMUL##_u8##LMUL( \
__riscv_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 __riscv_v##OP##_v_u##SEW##LMUL##_##CHAR##SEW##LMUL( \
__riscv_v##OP##_v_u8##LMUL##_u##SEW##LMUL(v2)); \
}

◆ 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(__riscv_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 __riscv_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 __riscv_v##OP##_vm_##CHAR##SEW##LMUL(v, mask, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ 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 __riscv_vfcvt_f_x_v_f##SEW##LMUL(v, Lanes(d)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) ConvertTo( \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, HWY_RVV_V(uint, SEW, LMUL) v) { \
return __riscv_vfcvt_f_xu_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 __riscv_vfcvt_rtz_x_f_v_i##SEW##LMUL(v, Lanes(d)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(uint, SEW, LMUL) ConvertTo( \
HWY_RVV_D(uint, SEW, N, SHIFT) d, HWY_RVV_V(BASE, SEW, LMUL) v) { \
return __riscv_vfcvt_rtz_xu_f_v_u##SEW##LMUL(v, Lanes(d)); \
}
HWY_API Vec128< float > ConvertTo(D, Vec128< int32_t > v)
Definition arm_neon-inl.h:3971
HWY_API size_t Lanes(D)
Definition rvv-inl.h:598

◆ 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 __riscv_vcpop_m_b##MLEN(m, Lanes(d)); \
}

◆ 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 __riscv_v##OP##CHAR##SEWH##LMULH( \
v, 0, HWY_RVV_INSERT_VXRM(__RISCV_VXRM_RDN, Lanes(d))); \
}
#define HWY_RVV_INSERT_VXRM(vxrm, avl)
Definition rvv-inl.h:1123

◆ 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 __riscv_v##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) dn, HWY_RVV_V(int, SEW, LMUL) v) { \
const HWY_RVV_D(uint, SEW, N, SHIFT) du; \
/* First clamp negative numbers to zero to match x86 packus. */ \
return DemoteTo(dn, BitCast(du, detail::MaxS(v, 0))); \
}

◆ HWY_RVV_DEMOTE_TO_SHR_16

#define HWY_RVV_DEMOTE_TO_SHR_16 ( 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 __riscv_v##OP##CHAR##SEWH##LMULH( \
v, 16, HWY_RVV_INSERT_VXRM(__RISCV_VXRM_RDN, Lanes(d))); \
}

◆ 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 __riscv_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 __riscv_vfirst_m_b##MLEN(m, Lanes(d)); \
} \
template <class D> \
HWY_API size_t FindKnownFirstTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return static_cast<size_t>(__riscv_vfirst_m_b##MLEN(m, Lanes(d))); \
}

◆ 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 __riscv_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_UI(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_F(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_UI(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:406

◆ 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:184

◆ 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:201

◆ 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:131

◆ 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:161

◆ 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:188

◆ 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:205

◆ 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:139

◆ 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:168

◆ 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:192

◆ 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:209

◆ 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:147

◆ 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:174

◆ 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:196

◆ 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:213

◆ 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:154

◆ 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:179

◆ 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:345

◆ HWY_RVV_FOREACH_F16

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

◆ HWY_RVV_FOREACH_F16_UNCONDITIONAL

#define HWY_RVV_FOREACH_F16_UNCONDITIONAL ( X_MACRO,
NAME,
OP,
LMULS )    HWY_CONCAT(HWY_RVV_FOREACH_16, LMULS)(X_MACRO, float, f, NAME, OP)

◆ 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:348

◆ 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_I163264(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:323

◆ 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:325

◆ 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_U163264(X_MACRO, NAME, OP, LMULS)
#define HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:313

◆ 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:315

◆ 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)
#define HWY_RVV_FOREACH_U(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:393

◆ 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:374

◆ 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:317

◆ 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:362

◆ 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:319

◆ 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) { \
const RebindToUnsigned<decltype(d)> du; \
return __riscv_v##OP##ei##SEW##_v_##CHAR##SEW##LMUL( \
detail::NativeLanePointer(base), BitCast(du, 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 __riscv_v##OP##_s_##CHAR##SEW##LMUL##_##CHAR##SEW(v); /* no AVL */ \
}

◆ HWY_RVV_HAVE_F16C

#define HWY_RVV_HAVE_F16C   0

◆ HWY_RVV_IF_CAN128_D

#define HWY_RVV_IF_CAN128_D ( D)     hwy::EnableIf<!detail::IsLT128(D()) && !detail::IsGE128(D())>* = nullptr

◆ HWY_RVV_IF_EMULATED_D

#define HWY_RVV_IF_EMULATED_D ( D)    HWY_IF_SPECIAL_FLOAT_D(D)

◆ HWY_RVV_IF_GE128_D

#define HWY_RVV_IF_GE128_D ( D)    hwy::EnableIf<detail::IsGE128(D())>* = nullptr

◆ HWY_RVV_IF_LT128_D

#define HWY_RVV_IF_LT128_D ( D)    hwy::EnableIf<detail::IsLT128(D())>* = nullptr

◆ HWY_RVV_IF_SAME_T_DV

#define HWY_RVV_IF_SAME_T_DV ( D,
V )    hwy::EnableIf<IsSame<NativeLaneType<TFromD<D>>, TFromV<V>>()>* = 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 __riscv_v##OP##_vvm_##CHAR##SEW##LMUL(no, yes, m, \
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 __riscv_v##OP##_##CHAR##SEW##LMUL(no, 0, m, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_INSERT_VXRM

#define HWY_RVV_INSERT_VXRM ( vxrm,
avl )   vxrm, avl

Referenced by hwy::HWY_NAMESPACE::DemoteTo(), hwy::HWY_NAMESPACE::DemoteTo(), hwy::HWY_NAMESPACE::DemoteTo(), hwy::HWY_NAMESPACE::DemoteTo(), hwy::HWY_NAMESPACE::DemoteTo(), hwy::HWY_NAMESPACE::DemoteTo(), hwy::HWY_NAMESPACE::DemoteTo(), hwy::HWY_NAMESPACE::DemoteTo(), hwy::HWY_NAMESPACE::DemoteTo(), hwy::HWY_NAMESPACE::DemoteTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::TruncateTo(), hwy::HWY_NAMESPACE::U8FromU32(), hwy::HWY_NAMESPACE::U8FromU32(), hwy::HWY_NAMESPACE::U8FromU32(), hwy::HWY_NAMESPACE::U8FromU32(), and hwy::HWY_NAMESPACE::U8FromU32().

◆ 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 __riscv_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 )

◆ HWY_RVV_LANES_VIRT

#define HWY_RVV_LANES_VIRT ( 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) { \
constexpr size_t kCap = MaxLanes(d); \
/* In case of virtual LMUL (intrinsics do not provide "uint16mf8_t") */ \
/* vsetvl may or may not be correct, so do it ourselves. */ \
const size_t actual = \
detail::ScaleByPower(__riscv_vlenb() / (SEW / 8), SHIFT); \
return HWY_MIN(actual, kCap); \
} \
template <size_t N> \
HWY_API size_t Capped##NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, size_t cap) { \
/* In case of virtual LMUL (intrinsics do not provide "uint16mf8_t") */ \
/* vsetvl may or may not be correct, so do it ourselves. */ \
const size_t actual = \
detail::ScaleByPower(__riscv_vlenb() / (SEW / 8), SHIFT); \
/* If no cap, avoid an extra HWY_MIN. */ \
return detail::IsFull(d) ? HWY_MIN(actual, cap) \
: HWY_MIN(HWY_MIN(actual, cap), MaxLanes(d)); \
}
#define HWY_MIN(a, b)
Definition base.h:176

◆ 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 __riscv_v##OP##SEW##_v_##CHAR##SEW##LMUL( \
detail::NativeLanePointer(p), 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 __riscv_v##OP##_v_b##MLEN(bits, N); \
}
#define HWY_INLINE
Definition base.h:101
Definition base.h:694

◆ HWY_RVV_LOAD_STRIDED

#define HWY_RVV_LOAD_STRIDED ( 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, size_t stride) { \
return __riscv_v##OP##SEW##_v_##CHAR##SEW##LMUL( \
p, static_cast<ptrdiff_t>(stride), Lanes(d)); \
}

◆ HWY_RVV_LOADN

#define HWY_RVV_LOADN ( 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, size_t num_lanes) { \
/* Use a tail-undisturbed load in LoadN as the tail-undisturbed load */ \
/* operation below will leave any lanes past the first */ \
/* (lowest-indexed) HWY_MIN(num_lanes, Lanes(d)) lanes unchanged */ \
return __riscv_v##OP##SEW##_v_##CHAR##SEW##LMUL##_tu( \
Zero(d), detail::NativeLanePointer(p), CappedLanes(d, num_lanes)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME##Or( \
HWY_RVV_V(BASE, SEW, LMUL) no, HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p, size_t num_lanes) { \
/* Use a tail-undisturbed load in LoadNOr as the tail-undisturbed load */ \
/* operation below will set any lanes past the first */ \
/* (lowest-indexed) HWY_MIN(num_lanes, Lanes(d)) lanes to the */ \
/* corresponding lanes in no */ \
return __riscv_v##OP##SEW##_v_##CHAR##SEW##LMUL##_tu( \
no, detail::NativeLanePointer(p), CappedLanes(d, num_lanes)); \
}

◆ HWY_RVV_M

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

◆ HWY_RVV_MASKED_GATHER

#define HWY_RVV_MASKED_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_V(BASE, SEW, LMUL) no, HWY_RVV_M(MLEN) m, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT base, \
HWY_RVV_V(int, SEW, LMUL) indices) { \
const RebindToUnsigned<decltype(d)> du; \
const RebindToSigned<decltype(d)> di; \
(void)di; /* for HWY_DASSERT */ \
constexpr size_t kBits = CeilLog2(SEW / 8); \
HWY_DASSERT(AllFalse(di, Lt(indices, Zero(di)))); \
return __riscv_v##OP##ei##SEW##_v_##CHAR##SEW##LMUL##_mu( \
m, no, detail::NativeLanePointer(base), \
ShiftLeft<kBits>(BitCast(du, indices)), Lanes(d)); \
}

◆ HWY_RVV_MASKED_IOTA

#define HWY_RVV_MASKED_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, HWY_RVV_M(MLEN) mask) { \
return __riscv_v##OP##_##CHAR##SEW##LMUL(mask, Lanes(d)); \
}

◆ 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 __riscv_v##OP##SEW##_v_##CHAR##SEW##LMUL##_mu( \
m, Zero(d), detail::NativeLanePointer(p), Lanes(d)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME##Or(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_M(MLEN) m, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return __riscv_v##OP##SEW##_v_##CHAR##SEW##LMUL##_mu( \
m, v, detail::NativeLanePointer(p), Lanes(d)); \
}

◆ HWY_RVV_MASKED_SCATTER

#define HWY_RVV_MASKED_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_M(MLEN) m, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT base, \
HWY_RVV_V(int, SEW, LMUL) indices) { \
const RebindToUnsigned<decltype(d)> du; \
constexpr size_t kBits = CeilLog2(sizeof(TFromD<decltype(d)>)); \
return __riscv_v##OP##ei##SEW##_v_##CHAR##SEW##LMUL##_m( \
m, detail::NativeLanePointer(base), \
ShiftLeft<kBits>(BitCast(du, indices)), v, Lanes(d)); \
}

◆ HWY_RVV_MASKED_TABLE

#define HWY_RVV_MASKED_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_M(MLEN) mask, HWY_RVV_V(BASE, SEW, LMUL) maskedoff, \
HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(uint, SEW, LMUL) idx) { \
return __riscv_v##OP##_vv_##CHAR##SEW##LMUL##_mu(mask, maskedoff, v, idx, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_MASKED_TABLE16

#define HWY_RVV_MASKED_TABLE16 ( 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) mask, HWY_RVV_V(BASE, SEW, LMUL) maskedoff, \
HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(uint, SEWD, LMULD) idx) { \
return __riscv_v##OP##_vv_##CHAR##SEW##LMUL##_mu(mask, maskedoff, v, idx, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_MUL15

#define HWY_RVV_MUL15 ( 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 __riscv_v##OP##_vv_##CHAR##SEW##LMUL( \
a, b, HWY_RVV_INSERT_VXRM(__RISCV_VXRM_RNU, HWY_RVV_AVL(SEW, SHIFT))); \
}

◆ HWY_RVV_NARROW

#define HWY_RVV_NARROW ( BASE,
CHAR,
SEW,
SEWD,
SEWH,
LMUL,
LMULD,
LMULH,
SHIFT,
MLEN,
NAME,
OP )
Value:
template <size_t kShift> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEWD, LMULD) v) { \
return __riscv_v##OP##_wx_##CHAR##SEW##LMUL(v, kShift, \
HWY_RVV_AVL(SEWD, SHIFT + 1)); \
}

◆ 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 __riscv_vfcvt_x_f_v_i##SEW##LMUL(v, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ 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 __riscv_v##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 __riscv_v##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:2081

◆ 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, 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_PROMOTE_X4_FROM_U8

#define HWY_RVV_PROMOTE_X4_FROM_U8 ( 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_X4(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN)

◆ HWY_RVV_PROMOTE_X8

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

◆ HWY_RVV_REDUCE

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

◆ 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 __riscv_vm##OP##_m_b##MLEN(m, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ 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 __riscv_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 __riscv_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 __riscv_v##OP##_vv_##CHAR##SEW##LMUL##_b##MLEN( \
a, b, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETV_ARGMVV

#define HWY_RVV_RETV_ARGMVV ( 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) no, HWY_RVV_M(MLEN) m, \
HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_V(BASE, SEW, LMUL) b) { \
return __riscv_v##OP##_vv_##CHAR##SEW##LMUL##_mu(m, no, 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 __riscv_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 __riscv_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 __riscv_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 __riscv_v##OP##_vv_##CHAR##SEW##LMUL(a, b, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETV_AVERAGE

#define HWY_RVV_RETV_AVERAGE ( 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 __riscv_v##OP##_vv_##CHAR##SEW##LMUL( \
a, b, HWY_RVV_INSERT_VXRM(__RISCV_VXRM_RNU, 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) { \
const RebindToUnsigned<decltype(d)> du; \
return __riscv_v##OP##ei##SEW##_v_##CHAR##SEW##LMUL( \
detail::NativeLanePointer(base), BitCast(du, 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 __riscv_v##OP##_##CHAR##SEW##LMUL(arg, Lanes(d)); \
}

◆ HWY_RVV_SET_AT_OR_AFTER_FIRST

#define HWY_RVV_SET_AT_OR_AFTER_FIRST ( SEW,
SHIFT,
MLEN,
NAME,
OP )
Value:
HWY_API HWY_RVV_M(MLEN) SetAtOrAfterFirst(HWY_RVV_M(MLEN) m) { \
return Not(SetBeforeFirst(m)); \
}

◆ 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 __riscv_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 __riscv_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) { \
const HWY_RVV_D(uint, SEW, HWY_LANES(HWY_RVV_T(BASE, SEW)), SHIFT) du; \
return __riscv_v##OP##_vv_##CHAR##SEW##LMUL(v, BitCast(du, bits), \
HWY_RVV_AVL(SEW, SHIFT)); \
}
#define HWY_LANES(T)
Definition set_macros-inl.h:169

◆ 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 __riscv_v##OP##_vv_##CHAR##SEW##LMUL(v, bits, \
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 __riscv_v##OP##_##CHAR##SEW##LMUL(v, 0, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SLIDE_DOWN

#define HWY_RVV_SLIDE_DOWN ( 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) src, size_t lanes) { \
return __riscv_v##OP##_vx_##CHAR##SEW##LMUL(src, lanes, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SLIDE_UP

#define HWY_RVV_SLIDE_UP ( 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 __riscv_v##OP##_vx_##CHAR##SEW##LMUL(dst, src, lanes, \
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 __riscv_v##OP##SEW##_v_##CHAR##SEW##LMUL( \
detail::NativeLanePointer(p), v, 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); \
__riscv_v##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>), d.Pow2()) < 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_RVV_STORE_STRIDED

#define HWY_RVV_STORE_STRIDED ( 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, size_t stride) { \
return __riscv_v##OP##SEW##_v_##CHAR##SEW##LMUL( \
p, static_cast<ptrdiff_t>(stride), v, Lanes(d)); \
}

◆ 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 __riscv_v##OP##SEW##_v_##CHAR##SEW##LMUL( \
detail::NativeLanePointer(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 __riscv_v##OP##_vv_##CHAR##SEW##LMUL(v, idx, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_TABLE16

#define HWY_RVV_TABLE16 ( 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, SEWD, LMULD) idx) { \
return __riscv_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 __riscv_v##OP##_v_##CHAR##SEW##LMUL##_##CHAR##SEW##LMULH( \
v); /* no AVL */ \
}

◆ HWY_RVV_TUP

#define HWY_RVV_TUP ( BASE,
SEW,
LMUL,
TUP )   v##BASE##SEW##LMUL##x##TUP##_t

◆ 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 __riscv_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:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, HWY_RVV_M(MLEN) m) { \
/* MaskFalse requires we set all lanes for capped d and virtual LMUL. */ \
const DFromV<VFromD<decltype(d)>> d_full; \
const RebindToSigned<decltype(d_full)> di; \
using TI = TFromD<decltype(di)>; \
return BitCast(d_full, __riscv_v##OP##_i##SEW##LMUL(Zero(di), TI{-1}, m, \
Lanes(d_full))); \
}
int VFromD
Definition tuple-inl.h:25

◆ HWY_RVV_WIDEN_MACC

#define HWY_RVV_WIDEN_MACC ( 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, SEWD, LMULD) sum, \
HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_V(BASE, SEW, LMUL) b) { \
return __riscv_v##OP##CHAR##SEWD##LMULD(sum, a, b, Lanes(d)); \
}

◆ 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 ( )