Index ⭢ Universal JIT ⭢ asmjit::ujit::UniCompiler

asmjit::ujit::UniCompiler Class Reference [¶]

Universal compiler.

Public Members

Members

BackendCompiler* cc = nullptr

VecConstTableRef _ct_ref

ScalarOpBehavior _scalar_op_behavior {}

FMinFMaxOpBehavior _fmin_fmax_op_behavior {}

FMAddOpBehavior _fmadd_op_behavior {}

FloatToIntOutsideRangeBehavior _float_to_int_outside_range_behavior {}

CpuFeatures _features {}

CpuHints _cpu_hints {}

uint32_t _vec_reg_count = 0

VecWidth _vec_width = VecWidth::k128

uint8_t _vec_multiplier = 0

RegType _vec_reg_type = RegType::kNone

TypeId _vec_type_id = TypeId::kVoid

BaseNode* _func_init_hook = nullptr

Gp _gp_none

Mem _tmp_stack[size_t(StackId::kMaxValue) +1]

int32_t _common_table_offset = 0

Gp _common_table_ptr

ArenaVector<VecConstData> _vec_consts

ArenaVector<VecConstDataEx> _vec_consts_ex

Classes

struct VecConstData

struct VecConstDataEx

Public Types

enum : uint32_t

Constants

enum class StackId : uint32_t

Member Functions

UniCompiler(const UniCompiler& other) = delete

UniCompiler& operator=(const UniCompiler& other) = delete

void _init_vec_const_table_ptr()

Construction & Destruction

UniCompiler(BackendCompiler* cc, const CpuFeatures& features, CpuHints cpu_hints, VecConstTableRef ct_ref) noexcept

UniCompiler(BackendCompiler* cc, const CpuFeatures& features, CpuHints cpu_hints) noexcept

~UniCompiler() noexcept

Allocators

Arena& arena() noexcept

Constant Table

template<typename T = VecConstTable>

const T& ct() const noexcept

template<typename T = VecConstTable>

const T* ct_ptr() const noexcept

size_t ct_size() const noexcept

CPU Architecture, Features and Optimization Options

void _init_extensions(const CpuFeatures& features) noexcept

bool is_32bit() const noexcept

bool is_64bit() const noexcept

uint32_t register_size() const noexcept

ScalarOpBehavior scalar_op_behavior() const noexcept

FMinFMaxOpBehavior fmin_fmax_op_behavior() const noexcept

FMAddOpBehavior fmadd_op_behavior() const noexcept

FloatToIntOutsideRangeBehavior float_to_int_outside_range_behavior() const noexcept

bool is_scalar_op_zeroing() const noexcept

bool is_scalar_op_preserving_vec128() const noexcept

bool is_fmin_fmax_finite() const noexcept

bool is_fmin_fmax_ternary() const noexcept

bool is_fmadd_fused() const noexcept

bool is_fma_storing_to_any_register() const noexcept

bool is_fma_storing_to_any_accumulator() const noexcept

CpuHints cpu_hints() const noexcept

bool has_cpu_hint(CpuHints hint) const noexcept

OperandSignature gp_signature() const noexcept

Gp gpz(const Gp& reg) const noexcept

uint32_t vec_reg_count() const noexcept

VecWidth max_vec_width_from_cpu_features() noexcept

void init_vec_width(VecWidth vw) noexcept

bool has_masked_access_of(uint32_t data_size) const noexcept

CPU SIMD Width and SIMD Width Utilities

VecWidth vec_width() const noexcept

bool use_256bit_simd() const noexcept

bool use_512bit_simd() const noexcept

uint32_t vec_multiplier() const noexcept

VecWidth vec_width_of(DataWidth data_width, uint32_t n) const noexcept

Labels

Label new_label()

Label new_named_label(const char* name, size_t name_size = SIZE_MAX, LabelType type = LabelType::kGlobal, uint32_t parent_id = Globals::kInvalidId)

Label new_named_label(Span<const char>name, LabelType type = LabelType::kGlobal, uint32_t parent_id = Globals::kInvalidId)

Label new_anonymous_label(const char* name, size_t name_size = SIZE_MAX)

Label new_anonymous_label(Span<const char>name)

Label new_external_label(const char* name, size_t name_size = SIZE_MAX)

Label new_external_label(Span<const char>name)

Error bind(const Label& label)

Align

Error align(AlignMode align_mode, uint32_t alignment)

Embed

Error embed(const void* data, size_t data_size)

Error embed_data_array(TypeId type_id, const void* data, size_t item_count, size_t repeat_count = 1)

Error embed_int8(int8_t value, size_t repeat_count = 1)

Error embed_uint8(uint8_t value, size_t repeat_count = 1)

Error embed_int16(int16_t value, size_t repeat_count = 1)

Error embed_uint16(uint16_t value, size_t repeat_count = 1)

Error embed_int32(int32_t value, size_t repeat_count = 1)

Error embed_uint32(uint32_t value, size_t repeat_count = 1)

Error embed_int64(int64_t value, size_t repeat_count = 1)

Error embed_uint64(uint64_t value, size_t repeat_count = 1)

Error embed_float(float value, size_t repeat_count = 1)

Error embed_double(double value, size_t repeat_count = 1)

Error embed_const_pool(const Label& label, const ConstPool& pool)

Error embed_label(const Label& label, size_t data_size = 0)

Error embed_label_delta(const Label& label, const Label& base, size_t data_size = 0)

void embed_jump_table(Span<const Label>jump_table, const Label& jump_table_base, uint32_t entry_size)

Comment

Error comment(const char* data, size_t size = SIZE_MAX)

Error comment(Span<const char>data)

template<typename... Args>

Error commentf(const char* fmt, Args&&... args)

Error commentv(const char* fmt, va_list ap)

Function Management

FuncNode* func() const noexcept

void hook_func() noexcept

void unhook_func() noexcept

Error new_func_node(Out<FuncNode*>out, const FuncSignature& signature)

Error add_func_node(Out<FuncNode*>out, const FuncSignature& signature)

FuncNode* add_func(const FuncSignature& signature)

FuncNode* add_func(FuncNode* ASMJIT_NONNULL(func))

Error new_func_ret_node(Out<FuncRetNode*>out, const Operand_& o0, const Operand_& o1)

Error add_func_ret_node(Out<FuncRetNode*>out, const Operand_& o0, const Operand_& o1)

Error end_func()

Error ret()

Error ret(const Reg& o0)

Error ret(const Reg& o0, const Reg& o1)

Function Finalization

Error finalize()

Function Invocation

Error new_invoke_node(Out<InvokeNode*>out, InstId inst_id, const Operand_& o0, const FuncSignature& signature)

Error add_invoke_node(Out<InvokeNode*>out, InstId inst_id, const Operand_& o0, const FuncSignature& signature)

Virtual Registers & Memory (Target Independent)

template<typename RegT, typename... Args>

RegT new_reg(TypeId type_id, Args&&... args) noexcept

template<typename RegT, typename... Args>

RegT new_similar_reg(const RegT& ref, Args&&... args) noexcept

template<typename... Args>

Gp new_gp32(Args&&... args) noexcept

template<typename... Args>

Gp new_gp64(Args&&... args) noexcept

template<typename... Args>

Gp new_gpz(Args&&... args) noexcept

template<typename... Args>

Gp new_gp_ptr(Args&&... args) noexcept

template<typename... Args>

Vec new_vec(Args&&... args) noexcept

template<typename... Args>

Vec new_vec_with_width(VecWidth vw, Args&&... args) noexcept

template<typename... Args>

Vec new_vec128(Args&&... args) noexcept

template<typename... Args>

Vec new_vec128_f32x1(Args&&... args) noexcept

template<typename... Args>

Vec new_vec128_f64x1(Args&&... args) noexcept

template<typename... Args>

Vec new_vec128_f32x4(Args&&... args) noexcept

template<typename... Args>

Vec new_vec128_f64x2(Args&&... args) noexcept

void new_reg_array(OpArray& dst, size_t n, TypeId type_id, const char* name) noexcept

void new_reg_array(OpArray& dst, size_t n, TypeId type_id, const char* prefix, const char* name) noexcept

void new_reg_array(OpArray& dst, size_t n, const Reg& ref, const char* name) noexcept

void new_reg_array(OpArray& dst, size_t n, const Reg& ref, const char* prefix, const char* name) noexcept

void new_vec_array(OpArray& dst, size_t n, VecWidth vw, const char* name) noexcept

void new_vec_array(OpArray& dst, size_t n, VecWidth vw, const char* prefix, const char* name) noexcept

void new_vec_array(OpArray& dst, size_t n, const Vec& ref, const char* name) noexcept

void new_vec_array(OpArray& dst, size_t n, const Vec& ref, const char* prefix, const char* name) noexcept

void new_vec128_array(OpArray& dst, size_t n, const char* name) noexcept

void new_vec128_array(OpArray& dst, size_t n, const char* prefix, const char* name) noexcept

Mem tmp_stack(StackId id, uint32_t size)

Miscellaneous Helpers

void rename(const OpArray& op_array, const char* name) noexcept

void rename(const OpArray& op_array, const char* prefix, const char* name) noexcept

Constants (X86|X86_64)

Operand simd_const(const void* c, Bcst bcst_width, VecWidth const_width)

Operand simd_const(const void* c, Bcst bcst_width, const Vec& similar_to)

Operand simd_const(const void* c, Bcst bcst_width, const VecArray& similar_to)

Vec simd_vec_const(const void* c, Bcst bcst_width, VecWidth const_width)

Vec simd_vec_const(const void* c, Bcst bcst_width, const Vec& similar_to)

Vec simd_vec_const(const void* c, Bcst bcst_width, const VecArray& similar_to)

Mem simd_mem_const(const void* c, Bcst bcst_width, VecWidth const_width)

Mem simd_mem_const(const void* c, Bcst bcst_width, const Vec& similar_to)

Mem simd_mem_const(const void* c, Bcst bcst_width, const VecArray& similar_to)

Mem _get_mem_const(const void* c)

Vec _new_vec_const(const void* c, bool is_unique_const)

Emit - General Purpose Instructions

void emit_mov(const Gp& dst, const Operand_& src)

void emit_m(UniOpM op, const Mem& m)

void emit_rm(UniOpRM op, const Gp& dst, const Mem& src)

void emit_mr(UniOpMR op, const Mem& dst, const Gp& src)

void emit_cmov(const Gp& dst, const Operand_& sel, const UniCondition& condition)

void emit_select(const Gp& dst, const Operand_& sel1_, const Operand_& sel2_, const UniCondition& condition)

void emit_2i(UniOpRR op, const Gp& dst, const Operand_& src_)

void emit_3i(UniOpRRR op, const Gp& dst, const Operand_& src1_, const Operand_& src2_)

void emit_j(const Operand_& target)

void emit_j_if(const Label& target, const UniCondition& condition)

void mov(const Gp& dst, const Gp& src)

void mov(const Gp& dst, const Imm& src)

void load(const Gp& dst, const Mem& src)

void load_i8(const Gp& dst, const Mem& src)

void load_u8(const Gp& dst, const Mem& src)

void load_i16(const Gp& dst, const Mem& src)

void load_u16(const Gp& dst, const Mem& src)

void load_i32(const Gp& dst, const Mem& src)

void load_u32(const Gp& dst, const Mem& src)

void load_i64(const Gp& dst, const Mem& src)

void load_u64(const Gp& dst, const Mem& src)

void load_merge_u8(const Gp& dst, const Mem& src)

void load_shift_u8(const Gp& dst, const Mem& src)

void load_merge_u16(const Gp& dst, const Mem& src)

void load_shift_u16(const Gp& dst, const Mem& src)

void store(const Mem& dst, const Gp& src)

void store_u8(const Mem& dst, const Gp& src)

void store_u16(const Mem& dst, const Gp& src)

void store_u32(const Mem& dst, const Gp& src)

void store_u64(const Mem& dst, const Gp& src)

void prefetch(const Mem& mem)

void store_zero_reg(const Mem& dst)

void store_zero_u8(const Mem& dst)

void store_zero_u16(const Mem& dst)

void store_zero_u32(const Mem& dst)

void store_zero_u64(const Mem& dst)

void mem_add(const Mem& dst, const Gp& src)

void mem_add_u8(const Mem& dst, const Gp& src)

void mem_add_u16(const Mem& dst, const Gp& src)

void mem_add_u32(const Mem& dst, const Gp& src)

void mem_add_u64(const Mem& dst, const Gp& src)

void cmov(const Gp& dst, const Gp& sel, const UniCondition& condition)

void cmov(const Gp& dst, const Mem& sel, const UniCondition& condition)

template<typename Sel1, typename Sel2>

void select(const Gp& dst, const Sel1& sel1, const Sel2& sel2, const UniCondition& condition)

void abs(const Gp& dst, const Gp& src)

void abs(const Gp& dst, const Mem& src)

void neg(const Gp& dst, const Gp& src)

void neg(const Gp& dst, const Mem& src)

void not_(const Gp& dst, const Gp& src)

void not_(const Gp& dst, const Mem& src)

void bswap(const Gp& dst, const Gp& src)

void bswap(const Gp& dst, const Mem& src)

void clz(const Gp& dst, const Gp& src)

void clz(const Gp& dst, const Mem& src)

void ctz(const Gp& dst, const Gp& src)

void ctz(const Gp& dst, const Mem& src)

void reflect(const Gp& dst, const Gp& src)

void reflect(const Gp& dst, const Mem& src)

void inc(const Gp& dst)

void dec(const Gp& dst)

void and_(const Gp& dst, const Gp& src1, const Gp& src2)

void and_(const Gp& dst, const Gp& src1, const Mem& src2)

void and_(const Gp& dst, const Gp& src1, const Imm& src2)

void and_(const Gp& dst, const Mem& src1, const Gp& src2)

void and_(const Gp& dst, const Mem& src1, const Imm& src2)

void or_(const Gp& dst, const Gp& src1, const Gp& src2)

void or_(const Gp& dst, const Gp& src1, const Mem& src2)

void or_(const Gp& dst, const Gp& src1, const Imm& src2)

void or_(const Gp& dst, const Mem& src1, const Gp& src2)

void or_(const Gp& dst, const Mem& src1, const Imm& src2)

void xor_(const Gp& dst, const Gp& src1, const Gp& src2)

void xor_(const Gp& dst, const Gp& src1, const Mem& src2)

void xor_(const Gp& dst, const Gp& src1, const Imm& src2)

void xor_(const Gp& dst, const Mem& src1, const Gp& src2)

void xor_(const Gp& dst, const Mem& src1, const Imm& src2)

void bic(const Gp& dst, const Gp& src1, const Gp& src2)

void bic(const Gp& dst, const Gp& src1, const Mem& src2)

void bic(const Gp& dst, const Gp& src1, const Imm& src2)

void bic(const Gp& dst, const Mem& src1, const Gp& src2)

void bic(const Gp& dst, const Mem& src1, const Imm& src2)

void add(const Gp& dst, const Gp& src1, const Gp& src2)

void add(const Gp& dst, const Gp& src1, const Mem& src2)

void add(const Gp& dst, const Gp& src1, const Imm& src2)

void add(const Gp& dst, const Mem& src1, const Gp& src2)

void add(const Gp& dst, const Mem& src1, const Imm& src2)

void sub(const Gp& dst, const Gp& src1, const Gp& src2)

void sub(const Gp& dst, const Gp& src1, const Mem& src2)

void sub(const Gp& dst, const Gp& src1, const Imm& src2)

void sub(const Gp& dst, const Mem& src1, const Gp& src2)

void sub(const Gp& dst, const Mem& src1, const Imm& src2)

void mul(const Gp& dst, const Gp& src1, const Gp& src2)

void mul(const Gp& dst, const Gp& src1, const Mem& src2)

void mul(const Gp& dst, const Gp& src1, const Imm& src2)

void mul(const Gp& dst, const Mem& src1, const Gp& src2)

void mul(const Gp& dst, const Mem& src1, const Imm& src2)

void udiv(const Gp& dst, const Gp& src1, const Gp& src2)

void udiv(const Gp& dst, const Gp& src1, const Mem& src2)

void udiv(const Gp& dst, const Gp& src1, const Imm& src2)

void udiv(const Gp& dst, const Mem& src1, const Gp& src2)

void udiv(const Gp& dst, const Mem& src1, const Imm& src2)

void umod(const Gp& dst, const Gp& src1, const Gp& src2)

void umod(const Gp& dst, const Gp& src1, const Mem& src2)

void umod(const Gp& dst, const Gp& src1, const Imm& src2)

void umod(const Gp& dst, const Mem& src1, const Gp& src2)

void umod(const Gp& dst, const Mem& src1, const Imm& src2)

void smin(const Gp& dst, const Gp& src1, const Gp& src2)

void smin(const Gp& dst, const Gp& src1, const Mem& src2)

void smin(const Gp& dst, const Gp& src1, const Imm& src2)

void smin(const Gp& dst, const Mem& src1, const Gp& src2)

void smin(const Gp& dst, const Mem& src1, const Imm& src2)

void smax(const Gp& dst, const Gp& src1, const Gp& src2)

void smax(const Gp& dst, const Gp& src1, const Mem& src2)

void smax(const Gp& dst, const Gp& src1, const Imm& src2)

void smax(const Gp& dst, const Mem& src1, const Gp& src2)

void smax(const Gp& dst, const Mem& src1, const Imm& src2)

void umin(const Gp& dst, const Gp& src1, const Gp& src2)

void umin(const Gp& dst, const Gp& src1, const Mem& src2)

void umin(const Gp& dst, const Gp& src1, const Imm& src2)

void umin(const Gp& dst, const Mem& src1, const Gp& src2)

void umin(const Gp& dst, const Mem& src1, const Imm& src2)

void umax(const Gp& dst, const Gp& src1, const Gp& src2)

void umax(const Gp& dst, const Gp& src1, const Mem& src2)

void umax(const Gp& dst, const Gp& src1, const Imm& src2)

void umax(const Gp& dst, const Mem& src1, const Gp& src2)

void umax(const Gp& dst, const Mem& src1, const Imm& src2)

void shl(const Gp& dst, const Gp& src1, const Gp& src2)

void shl(const Gp& dst, const Gp& src1, const Imm& src2)

void shl(const Gp& dst, const Mem& src1, const Gp& src2)

void shl(const Gp& dst, const Mem& src1, const Imm& src2)

void shr(const Gp& dst, const Gp& src1, const Gp& src2)

void shr(const Gp& dst, const Gp& src1, const Imm& src2)

void shr(const Gp& dst, const Mem& src1, const Gp& src2)

void shr(const Gp& dst, const Mem& src1, const Imm& src2)

void sar(const Gp& dst, const Gp& src1, const Gp& src2)

void sar(const Gp& dst, const Gp& src1, const Imm& src2)

void sar(const Gp& dst, const Mem& src1, const Gp& src2)

void sar(const Gp& dst, const Mem& src1, const Imm& src2)

void rol(const Gp& dst, const Gp& src1, const Gp& src2)

void rol(const Gp& dst, const Gp& src1, const Imm& src2)

void rol(const Gp& dst, const Mem& src1, const Gp& src2)

void rol(const Gp& dst, const Mem& src1, const Imm& src2)

void ror(const Gp& dst, const Gp& src1, const Gp& src2)

void ror(const Gp& dst, const Gp& src1, const Imm& src2)

void ror(const Gp& dst, const Mem& src1, const Gp& src2)

void ror(const Gp& dst, const Mem& src1, const Imm& src2)

void sbound(const Gp& dst, const Gp& src1, const Gp& src2)

void sbound(const Gp& dst, const Gp& src1, const Mem& src2)

void j(const Gp& target)

void j(const Label& target)

void j(const Label& target, const UniCondition& condition)

void adds_u8(const Gp& dst, const Gp& src1, const Gp& src2)

void inv_u8(const Gp& dst, const Gp& src)

void div_255_u32(const Gp& dst, const Gp& src)

void mul_257_hu16(const Gp& dst, const Gp& src)

void add_scaled(const Gp& dst, const Gp& a, int b)

void add_ext(const Gp& dst, const Gp& src_, const Gp& idx_, uint32_t scale, int32_t disp = 0)

void lea(const Gp& dst, const Mem& src)

Emit - Vector Instructions

void emit_2v(UniOpVV op, const Operand_& dst_, const Operand_& src_)

void emit_2v(UniOpVV op, const OpArray& dst_, const Operand_& src_)

void emit_2v(UniOpVV op, const OpArray& dst_, const OpArray& src_)

void emit_2vi(UniOpVVI op, const Operand_& dst_, const Operand_& src_, uint32_t imm)

void emit_2vi(UniOpVVI op, const OpArray& dst_, const Operand_& src_, uint32_t imm)

void emit_2vi(UniOpVVI op, const OpArray& dst_, const OpArray& src_, uint32_t imm)

void emit_2vs(UniOpVR op, const Operand_& dst_, const Operand_& src_, uint32_t idx = 0)

void emit_vm(UniOpVM op, const Vec& dst_, const Mem& src_, Alignment alignment, uint32_t idx = 0)

void emit_vm(UniOpVM op, const OpArray& dst_, const Mem& src_, Alignment alignment, uint32_t idx = 0)

void emit_mv(UniOpMV op, const Mem& dst_, const Vec& src_, Alignment alignment, uint32_t idx = 0)

void emit_mv(UniOpMV op, const Mem& dst_, const OpArray& src_, Alignment alignment, uint32_t idx = 0)

void emit_3v(UniOpVVV op, const Operand_& dst_, const Operand_& src1_, const Operand_& src2_)

void emit_3v(UniOpVVV op, const OpArray& dst_, const Operand_& src1_, const OpArray& src2_)

void emit_3v(UniOpVVV op, const OpArray& dst_, const OpArray& src1_, const Operand_& src2_)

void emit_3v(UniOpVVV op, const OpArray& dst_, const OpArray& src1_, const OpArray& src2_)

void emit_3vi(UniOpVVVI op, const Operand_& dst_, const Operand_& src1_, const Operand_& src2_, uint32_t imm)

void emit_3vi(UniOpVVVI op, const OpArray& dst_, const Operand_& src1_, const OpArray& src2_, uint32_t imm)

void emit_3vi(UniOpVVVI op, const OpArray& dst_, const OpArray& src1_, const Operand_& src2_, uint32_t imm)

void emit_3vi(UniOpVVVI op, const OpArray& dst_, const OpArray& src1_, const OpArray& src2_, uint32_t imm)

void emit_4v(UniOpVVVV op, const Operand_& dst_, const Operand_& src1_, const Operand_& src2_, const Operand_& src3_)

void emit_4v(UniOpVVVV op, const OpArray& dst_, const Operand_& src1_, const Operand_& src2_, const OpArray& src3_)

void emit_4v(UniOpVVVV op, const OpArray& dst_, const Operand_& src1_, const OpArray& src2_, const Operand& src3_)

void emit_4v(UniOpVVVV op, const OpArray& dst_, const Operand_& src1_, const OpArray& src2_, const OpArray& src3_)

void emit_4v(UniOpVVVV op, const OpArray& dst_, const OpArray& src1_, const Operand_& src2_, const Operand& src3_)

void emit_4v(UniOpVVVV op, const OpArray& dst_, const OpArray& src1_, const Operand_& src2_, const OpArray& src3_)

void emit_4v(UniOpVVVV op, const OpArray& dst_, const OpArray& src1_, const OpArray& src2_, const Operand& src3_)

void emit_4v(UniOpVVVV op, const OpArray& dst_, const OpArray& src1_, const OpArray& src2_, const OpArray& src3_)

void s_mov(const Gp& dst, const Vec& src)

void s_mov(const Vec& dst, const Gp& src)

void s_mov_u32(const Gp& dst, const Vec& src)

void s_mov_u32(const Vec& dst, const Gp& src)

void s_mov_u64(const Gp& dst, const Vec& src)

void s_mov_u64(const Vec& dst, const Gp& src)

void s_insert_u8(const Vec& dst, const Gp& src, uint32_t idx)

void s_insert_u16(const Vec& dst, const Gp& src, uint32_t idx)

void s_insert_u32(const Vec& dst, const Gp& src, uint32_t idx)

void s_insert_u64(const Vec& dst, const Gp& src, uint32_t idx)

void s_extract_u8(const Gp& dst, const Vec& src, uint32_t idx)

void s_extract_u16(const Gp& dst, const Vec& src, uint32_t idx)

void s_extract_u32(const Gp& dst, const Vec& src, uint32_t idx)

void s_extract_u64(const Gp& dst, const Vec& src, uint32_t idx)

void s_cvt_int_to_f32(const Vec& dst, const Gp& src)

void s_cvt_int_to_f32(const Vec& dst, const Mem& src)

void s_cvt_int_to_f64(const Vec& dst, const Gp& src)

void s_cvt_int_to_f64(const Vec& dst, const Mem& src)

void s_cvt_trunc_f32_to_int(const Gp& dst, const Vec& src)

void s_cvt_trunc_f32_to_int(const Gp& dst, const Mem& src)

void s_cvt_round_f32_to_int(const Gp& dst, const Vec& src)

void s_cvt_round_f32_to_int(const Gp& dst, const Mem& src)

void s_cvt_trunc_f64_to_int(const Gp& dst, const Vec& src)

void s_cvt_trunc_f64_to_int(const Gp& dst, const Mem& src)

void s_cvt_round_f64_to_int(const Gp& dst, const Vec& src)

void s_cvt_round_f64_to_int(const Gp& dst, const Mem& src)

template<typename Dst, typename Src>

void v_mov(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_mov_u64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_u8z(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_u16z(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_u8(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_u16(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_u32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_u64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_v128_u32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_v128_u64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_v128_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_v128_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_v256_u32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_v256_u64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_v256_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_broadcast_v256_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_abs_i8(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_abs_i16(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_abs_i32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_abs_i64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_not_u32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_not_u64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_i8_lo_to_i16(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_i8_hi_to_i16(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_u8_lo_to_u16(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_u8_hi_to_u16(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_i8_to_i32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_u8_to_u32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_i16_lo_to_i32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_i16_hi_to_i32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_u16_lo_to_u32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_u16_hi_to_u32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_i32_lo_to_i64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_i32_hi_to_i64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_u32_lo_to_u64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_u32_hi_to_u64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_abs_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_abs_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_abs_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_abs_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_neg_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_neg_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_neg_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_neg_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_not_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_not_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_trunc_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_trunc_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_trunc_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_trunc_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_floor_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_floor_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_floor_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_floor_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_ceil_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_ceil_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_ceil_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_ceil_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_round_even_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_round_even_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_round_even_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_round_even_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_round_half_away_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_round_half_away_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_round_half_away_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_round_half_away_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_round_half_up_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_round_half_up_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_round_half_up_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_round_half_up_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_rcp_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_rcp_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_sqrt_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_sqrt_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_sqrt_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_sqrt_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_cvt_f32_to_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void s_cvt_f64_to_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_i32_to_f32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_f32_lo_to_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_f32_hi_to_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_f64_to_f32_lo(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_f64_to_f32_hi(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_i32_lo_to_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_i32_hi_to_f64(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_trunc_f32_to_i32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_trunc_f64_to_i32_lo(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_trunc_f64_to_i32_hi(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_round_f32_to_i32(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_round_f64_to_i32_lo(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_cvt_round_f64_to_i32_hi(const Dst& dst, const Src& src)

template<typename Dst, typename Src>

void v_slli_i16(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_slli_u16(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_slli_i32(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_slli_u32(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_slli_i64(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_slli_u64(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_srli_u16(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_srli_u32(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_srli_u64(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_srai_i16(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_srai_i32(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_srai_i64(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_sllb_u128(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_srlb_u128(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_swizzle_u16x4(const Dst& dst, const Src& src, const Swizzle4& imm)

template<typename Dst, typename Src>

void v_swizzle_lo_u16x4(const Dst& dst, const Src& src, const Swizzle4& imm)

template<typename Dst, typename Src>

void v_swizzle_hi_u16x4(const Dst& dst, const Src& src, const Swizzle4& imm)

template<typename Dst, typename Src>

void v_swizzle_u32x4(const Dst& dst, const Src& src, const Swizzle4& imm)

template<typename Dst, typename Src>

void v_swizzle_u64x2(const Dst& dst, const Src& src, const Swizzle2& imm)

template<typename Dst, typename Src>

void v_swizzle_f32x4(const Dst& dst, const Src& src, const Swizzle4& imm)

template<typename Dst, typename Src>

void v_swizzle_f64x2(const Dst& dst, const Src& src, const Swizzle2& imm)

template<typename Dst, typename Src>

void v_swizzle_u64x4(const Dst& dst, const Src& src, const Swizzle4& imm)

template<typename Dst, typename Src>

void v_swizzle_f64x4(const Dst& dst, const Src& src, const Swizzle4& imm)

template<typename Dst, typename Src>

void v_extract_v128(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_extract_v128_i32(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_extract_v128_i64(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_extract_v128_f32(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_extract_v128_f64(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_extract_v256(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_extract_v256_i32(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_extract_v256_i64(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_extract_v256_f32(const Dst& dst, const Src& src, uint32_t imm)

template<typename Dst, typename Src>

void v_extract_v256_f64(const Dst& dst, const Src& src, uint32_t imm)

void v_load8(const Vec& dst, const Mem& src)

void v_load8(const VecArray& dst, const Mem& src)

void v_loadu16(const Vec& dst, const Mem& src)

void v_loadu16(const VecArray& dst, const Mem& src)

void v_loada16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {2})

void v_loada16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {2})

void v_loadu32(const Vec& dst, const Mem& src)

void v_loadu32(const VecArray& dst, const Mem& src)

void v_loada32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu32_u32(const Vec& dst, const Mem& src)

void v_loadu32_u32(const VecArray& dst, const Mem& src)

void v_loada32_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu32_f32(const Vec& dst, const Mem& src)

void v_loadu32_f32(const VecArray& dst, const Mem& src)

void v_loada32_f32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32_f32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu64(const Vec& dst, const Mem& src)

void v_loadu64(const VecArray& dst, const Mem& src)

void v_loada64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_u32(const Vec& dst, const Mem& src)

void v_loadu64_u32(const VecArray& dst, const Mem& src)

void v_loada64_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_u64(const Vec& dst, const Mem& src)

void v_loadu64_u64(const VecArray& dst, const Mem& src)

void v_loada64_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_f32(const Vec& dst, const Mem& src)

void v_loadu64_f32(const VecArray& dst, const Mem& src)

void v_loada64_f32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_f32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_f64(const Vec& dst, const Mem& src)

void v_loadu64_f64(const VecArray& dst, const Mem& src)

void v_loada64_f64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_f64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu128(const Vec& dst, const Mem& src)

void v_loadu128(const VecArray& dst, const Mem& src)

void v_loada128(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_u32(const Vec& dst, const Mem& src)

void v_loadu128_u32(const VecArray& dst, const Mem& src)

void v_loada128_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_u64(const Vec& dst, const Mem& src)

void v_loadu128_u64(const VecArray& dst, const Mem& src)

void v_loada128_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_f32(const Vec& dst, const Mem& src)

void v_loadu128_f32(const VecArray& dst, const Mem& src)

void v_loada128_f32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_f32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_f64(const Vec& dst, const Mem& src)

void v_loadu128_f64(const VecArray& dst, const Mem& src)

void v_loada128_f64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_f64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu256(const Vec& dst, const Mem& src)

void v_loadu256(const VecArray& dst, const Mem& src)

void v_loada256(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loadu256_u32(const Vec& dst, const Mem& src)

void v_loadu256_u32(const VecArray& dst, const Mem& src)

void v_loada256_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loadu256_u64(const Vec& dst, const Mem& src)

void v_loadu256_u64(const VecArray& dst, const Mem& src)

void v_loada256_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loadu256_f32(const Vec& dst, const Mem& src)

void v_loadu256_f32(const VecArray& dst, const Mem& src)

void v_loada256_f32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256_f32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loadu256_f64(const Vec& dst, const Mem& src)

void v_loadu256_f64(const VecArray& dst, const Mem& src)

void v_loada256_f64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256_f64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loadu512(const Vec& dst, const Mem& src)

void v_loadu512(const VecArray& dst, const Mem& src)

void v_loada512(const Vec& dst, const Mem& src, Alignment alignment = Alignment {64})

void v_loada512(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {64})

void v_loadu512_u32(const Vec& dst, const Mem& src)

void v_loadu512_u32(const VecArray& dst, const Mem& src)

void v_loada512_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {64})

void v_loada512_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {64})

void v_loadu512_u64(const Vec& dst, const Mem& src)

void v_loadu512_u64(const VecArray& dst, const Mem& src)

void v_loada512_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {64})

void v_loada512_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {64})

void v_loadu512_f32(const Vec& dst, const Mem& src)

void v_loadu512_f32(const VecArray& dst, const Mem& src)

void v_loada512_f32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {64})

void v_loada512_f32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {64})

void v_loadu512_f64(const Vec& dst, const Mem& src)

void v_loadu512_f64(const VecArray& dst, const Mem& src)

void v_loada512_f64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {64})

void v_loada512_f64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {64})

void v_loaduvec(const Vec& dst, const Mem& src)

void v_loaduvec(const VecArray& dst, const Mem& src)

void v_loadavec(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_u32(const Vec& dst, const Mem& src)

void v_loaduvec_u32(const VecArray& dst, const Mem& src)

void v_loadavec_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_u64(const Vec& dst, const Mem& src)

void v_loaduvec_u64(const VecArray& dst, const Mem& src)

void v_loadavec_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_f32(const Vec& dst, const Mem& src)

void v_loaduvec_f32(const VecArray& dst, const Mem& src)

void v_loadavec_f32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_f32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_f64(const Vec& dst, const Mem& src)

void v_loaduvec_f64(const VecArray& dst, const Mem& src)

void v_loadavec_f64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_f64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadu16_u8_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu16_u8_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada16_u8_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {2})

void v_loada16_u8_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {2})

void v_loadu32_u8_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu32_u8_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada32_u8_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {2})

void v_loada32_u8_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {2})

void v_loadu64_u8_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu64_u8_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada64_u8_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {2})

void v_loada64_u8_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {2})

void v_loadu32_i8_to_i16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu32_i8_to_i16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada32_i8_to_i16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32_i8_to_i16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu32_u8_to_u16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu32_u8_to_u16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada32_u8_to_u16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32_u8_to_u16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu32_i8_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu32_i8_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada32_i8_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32_i8_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu32_u8_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu32_u8_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada32_u8_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32_u8_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu32_i16_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu32_i16_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada32_i16_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32_i16_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu32_u16_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu32_u16_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada32_u16_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32_u16_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu32_i32_to_i64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu32_i32_to_i64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada32_i32_to_i64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32_i32_to_i64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu32_u32_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu32_u32_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada32_u32_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loada32_u32_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {4})

void v_loadu64_i8_to_i16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu64_i8_to_i16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada64_i8_to_i16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_i8_to_i16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_u8_to_u16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu64_u8_to_u16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada64_u8_to_u16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_u8_to_u16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_i8_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu64_i8_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada64_i8_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_i8_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_u8_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu64_u8_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada64_u8_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_u8_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_i16_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu64_i16_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada64_i16_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_i16_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_u16_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu64_u16_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada64_u16_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_u16_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_i32_to_i64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu64_i32_to_i64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada64_i32_to_i64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_i32_to_i64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu64_u32_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu64_u32_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada64_u32_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loada64_u32_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {8})

void v_loadu128_i8_to_i16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu128_i8_to_i16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada128_i8_to_i16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_i8_to_i16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_u8_to_u16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu128_u8_to_u16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada128_u8_to_u16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_u8_to_u16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_i8_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu128_i8_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada128_i8_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_i8_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_u8_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu128_u8_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada128_u8_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_u8_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_i16_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu128_i16_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada128_i16_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_i16_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_u16_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu128_u16_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada128_u16_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_u16_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_i32_to_i64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu128_i32_to_i64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada128_i32_to_i64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_i32_to_i64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu128_u32_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu128_u32_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada128_u32_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loada128_u32_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {16})

void v_loadu256_i8_to_i16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu256_i8_to_i16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada256_i8_to_i16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256_i8_to_i16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loadu256_u8_to_u16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu256_u8_to_u16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada256_u8_to_u16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256_u8_to_u16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loadu256_i16_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu256_i16_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada256_i16_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256_i16_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loadu256_u16_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu256_u16_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada256_u16_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256_u16_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loadu256_i32_to_i64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu256_i32_to_i64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada256_i32_to_i64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256_i32_to_i64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loadu256_u32_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadu256_u32_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loada256_u32_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loada256_u32_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {32})

void v_loaduvec_i8_to_i16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loaduvec_i8_to_i16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadavec_i8_to_i16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_i8_to_i16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_u8_to_u16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loaduvec_u8_to_u16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadavec_u8_to_u16(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_u8_to_u16(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_i8_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loaduvec_i8_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadavec_i8_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_i8_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_u8_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loaduvec_u8_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadavec_u8_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_u8_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_u8_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loaduvec_u8_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadavec_u8_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_u8_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_i16_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loaduvec_i16_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadavec_i16_to_i32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_i16_to_i32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_u16_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loaduvec_u16_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadavec_u16_to_u32(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_u16_to_u32(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_i32_to_i64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loaduvec_i32_to_i64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadavec_i32_to_i64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_i32_to_i64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loaduvec_u32_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loaduvec_u32_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {1})

void v_loadavec_u32_to_u64(const Vec& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_loadavec_u32_to_u64(const VecArray& dst, const Mem& src, Alignment alignment = Alignment {0})

void v_insert_u8(const Vec& dst, const Mem& src, uint32_t idx)

void v_insert_u8(const VecArray& dst, const Mem& src, uint32_t idx)

void v_insert_u16(const Vec& dst, const Mem& src, uint32_t idx)

void v_insert_u16(const VecArray& dst, const Mem& src, uint32_t idx)

void v_insert_u32(const Vec& dst, const Mem& src, uint32_t idx)

void v_insert_u32(const VecArray& dst, const Mem& src, uint32_t idx)

void v_insert_u64(const Vec& dst, const Mem& src, uint32_t idx)

void v_insert_u64(const VecArray& dst, const Mem& src, uint32_t idx)

void v_insert_f32(const Vec& dst, const Mem& src, uint32_t idx)

void v_insert_f32(const VecArray& dst, const Mem& src, uint32_t idx)

void v_insert_f32x2(const Vec& dst, const Mem& src, uint32_t idx)

void v_insert_f32x2(const VecArray& dst, const Mem& src, uint32_t idx)

void v_insert_f64(const Vec& dst, const Mem& src, uint32_t idx)

void v_insert_f64(const VecArray& dst, const Mem& src, uint32_t idx)

void v_store8(const Mem& dst, const Vec& src)

void v_store8(const Mem& dst, const VecArray& src)

void v_storeu16(const Mem& dst, const Vec& src)

void v_storeu16(const Mem& dst, const VecArray& src)

void v_storea16(const Mem& dst, const Vec& src, Alignment alignment = Alignment(2))

void v_storea16(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(2))

void v_storeu32(const Mem& dst, const Vec& src)

void v_storeu32(const Mem& dst, const VecArray& src)

void v_storea32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(4))

void v_storea32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(4))

void v_storeu32_u32(const Mem& dst, const Vec& src)

void v_storeu32_u32(const Mem& dst, const VecArray& src)

void v_storea32_u32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(4))

void v_storea32_u32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(4))

void v_storeu32_f32(const Mem& dst, const Vec& src)

void v_storeu32_f32(const Mem& dst, const VecArray& src)

void v_storea32_f32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(4))

void v_storea32_f32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(4))

void v_storeu64(const Mem& dst, const Vec& src)

void v_storeu64(const Mem& dst, const VecArray& src)

void v_storea64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(8))

void v_storea64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(8))

void v_storeu64_u32(const Mem& dst, const Vec& src)

void v_storeu64_u32(const Mem& dst, const VecArray& src)

void v_storea64_u32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(8))

void v_storea64_u32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(8))

void v_storeu64_u64(const Mem& dst, const Vec& src)

void v_storeu64_u64(const Mem& dst, const VecArray& src)

void v_storea64_u64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(8))

void v_storea64_u64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(8))

void v_storeu64_f32(const Mem& dst, const Vec& src)

void v_storeu64_f32(const Mem& dst, const VecArray& src)

void v_storea64_f32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(8))

void v_storea64_f32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(8))

void v_storeu64_f64(const Mem& dst, const Vec& src)

void v_storeu64_f64(const Mem& dst, const VecArray& src)

void v_storea64_f64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(8))

void v_storea64_f64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(8))

void v_storeu128(const Mem& dst, const Vec& src)

void v_storeu128(const Mem& dst, const VecArray& src)

void v_storea128(const Mem& dst, const Vec& src, Alignment alignment = Alignment(16))

void v_storea128(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(16))

void v_storeu128_u32(const Mem& dst, const Vec& src)

void v_storeu128_u32(const Mem& dst, const VecArray& src)

void v_storea128_u32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(16))

void v_storea128_u32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(16))

void v_storeu128_u64(const Mem& dst, const Vec& src)

void v_storeu128_u64(const Mem& dst, const VecArray& src)

void v_storea128_u64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(16))

void v_storea128_u64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(16))

void v_storeu128_f32(const Mem& dst, const Vec& src)

void v_storeu128_f32(const Mem& dst, const VecArray& src)

void v_storea128_f32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(16))

void v_storea128_f32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(16))

void v_storeu128_f64(const Mem& dst, const Vec& src)

void v_storeu128_f64(const Mem& dst, const VecArray& src)

void v_storea128_f64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(16))

void v_storea128_f64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(16))

void v_storeu256(const Mem& dst, const Vec& src)

void v_storeu256(const Mem& dst, const VecArray& src)

void v_storea256(const Mem& dst, const Vec& src, Alignment alignment = Alignment(32))

void v_storea256(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(32))

void v_storeu256_u32(const Mem& dst, const Vec& src)

void v_storeu256_u32(const Mem& dst, const VecArray& src)

void v_storea256_u32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(32))

void v_storea256_u32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(32))

void v_storeu256_u64(const Mem& dst, const Vec& src)

void v_storeu256_u64(const Mem& dst, const VecArray& src)

void v_storea256_u64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(32))

void v_storea256_u64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(32))

void v_storeu256_f32(const Mem& dst, const Vec& src)

void v_storeu256_f32(const Mem& dst, const VecArray& src)

void v_storea256_f32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(32))

void v_storea256_f32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(32))

void v_storeu256_f64(const Mem& dst, const Vec& src)

void v_storeu256_f64(const Mem& dst, const VecArray& src)

void v_storea256_f64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(32))

void v_storea256_f64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(32))

void v_storeu512(const Mem& dst, const Vec& src)

void v_storeu512(const Mem& dst, const VecArray& src)

void v_storea512(const Mem& dst, const Vec& src, Alignment alignment = Alignment(64))

void v_storea512(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(64))

void v_storeu512_u32(const Mem& dst, const Vec& src)

void v_storeu512_u32(const Mem& dst, const VecArray& src)

void v_storea512_u32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(64))

void v_storea512_u32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(64))

void v_storeu512_u64(const Mem& dst, const Vec& src)

void v_storeu512_u64(const Mem& dst, const VecArray& src)

void v_storea512_u64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(64))

void v_storea512_u64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(64))

void v_storeu512_f32(const Mem& dst, const Vec& src)

void v_storeu512_f32(const Mem& dst, const VecArray& src)

void v_storea512_f32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(64))

void v_storea512_f32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(64))

void v_storeu512_f64(const Mem& dst, const Vec& src)

void v_storeu512_f64(const Mem& dst, const VecArray& src)

void v_storea512_f64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(64))

void v_storea512_f64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(64))

void v_storeuvec(const Mem& dst, const Vec& src)

void v_storeuvec(const Mem& dst, const VecArray& src)

void v_storeavec(const Mem& dst, const Vec& src, Alignment alignment = Alignment(0))

void v_storeavec(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(0))

void v_storeuvec_u32(const Mem& dst, const Vec& src)

void v_storeuvec_u32(const Mem& dst, const VecArray& src)

void v_storeavec_u32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(0))

void v_storeavec_u32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(0))

void v_storeuvec_u64(const Mem& dst, const Vec& src)

void v_storeuvec_u64(const Mem& dst, const VecArray& src)

void v_storeavec_u64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(0))

void v_storeavec_u64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(0))

void v_storeuvec_f32(const Mem& dst, const Vec& src)

void v_storeuvec_f32(const Mem& dst, const VecArray& src)

void v_storeavec_f32(const Mem& dst, const Vec& src, Alignment alignment = Alignment(0))

void v_storeavec_f32(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(0))

void v_storeuvec_f64(const Mem& dst, const Vec& src)

void v_storeuvec_f64(const Mem& dst, const VecArray& src)

void v_storeavec_f64(const Mem& dst, const Vec& src, Alignment alignment = Alignment(0))

void v_storeavec_f64(const Mem& dst, const VecArray& src, Alignment alignment = Alignment(0))

void v_store_extract_u16(const Mem& dst, const Vec& src, uint32_t idx)

void v_store_extract_u16(const Mem& dst, const VecArray& src, uint32_t idx)

void v_store_extract_u32(const Mem& dst, const Vec& src, uint32_t idx)

void v_store_extract_u32(const Mem& dst, const VecArray& src, uint32_t idx)

void v_store_extract_u64(const Mem& dst, const Vec& src, uint32_t idx)

void v_store_extract_u64(const Mem& dst, const VecArray& src, uint32_t idx)