Index ⭢ UJIT ⭢ asmjit::ujit::UniCompiler

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

Pipeline compiler.

Public Members

Members

BackendCompiler* cc = nullptr

const VecConstTable& ct

ScalarOpBehavior _scalar_op_behavior {}

FMinFMaxOpBehavior _fmin_fmax_op_hehavior {}

FMAddOpBehavior _fmadd_op_behavior {}

CpuFeatures _features {}

UniOptFlags _opt_flags = UniOptFlags::kNone

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

FuncNode* _func_node = nullptr

BaseNode* _func_init = nullptr

BaseNode* _func_end = 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() noexcept

Construction & Destruction

UniCompiler(BackendCompiler* cc, const CpuFeatures& features, UniOptFlags opt_flags) noexcept

Allocators

Arena& arena() 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_hehavior() const noexcept

FMAddOpBehavior fmadd_op_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

UniOptFlags opt_flags() const noexcept

bool has_opt_flag(UniOptFlags flag) 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

Function

void init_function(FuncNode* func_node) noexcept

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

Utilities

Label new_label() const noexcept

void align(AlignMode align_mode, uint32_t alignment) noexcept

void bind(const Label& label) noexcept

template<typename Dst, typename Src>

void shift_or_rotate_left(const Dst& dst, const Src& src, uint32_t n) noexcept

template<typename Dst, typename Src>

void shift_or_rotate_right(const Dst& dst, const Src& src, uint32_t n) noexcept

template<typename VecOrMem>

void v_mod_pd(const Vec& d, const Vec& a, const VecOrMem& b) noexcept

Virtual Registers & Memory (Target Independent)

Gp new_gp32() noexcept

Gp new_gp64() noexcept

Gp new_gpz() noexcept

template<typename... Args>

Gp new_gp32(const char* name, Args&&... args) noexcept

template<typename... Args>

Gp new_gp64(const char* name, Args&&... args) noexcept

template<typename... Args>

Gp new_gpz(const char* name, Args&&... args) noexcept

template<typename RegT>

RegT new_similar_reg(const RegT& ref) noexcept

template<typename RegT, typename... Args>

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

template<typename... Args>

Vec new_vec(const char* name, Args&&... args) noexcept

template<typename... Args>

Vec new_vec(VecWidth vw, const char* name, Args&&... args) noexcept

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

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

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

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

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

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

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

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

Mem tmp_stack(StackId id, uint32_t size) noexcept

Compiler Utilities

void embed_jump_table(const Label* jump_table, size_t jump_table_size, const Label& jump_table_base, uint32_t entry_size) noexcept

Constants (X86|X86_64)

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

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

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

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

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

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

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

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

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

Mem _get_mem_const(const void* c) noexcept

Vec _new_vecConst(const void* c, bool is_unique_const) noexcept

Emit - General Purpose Instructions

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

void emit_m(UniOpM op, const Mem& m) noexcept

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

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

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

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

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

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

void emit_j(const Operand_& target) noexcept

void emit_j_if(const Label& target, const Condition& condition) noexcept

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void store_zero_reg(const Mem& dst) noexcept

void store_zero_u8(const Mem& dst) noexcept

void store_zero_u16(const Mem& dst) noexcept

void store_zero_u32(const Mem& dst) noexcept

void store_zero_u64(const Mem& dst) noexcept

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

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

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

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

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

void cmov(const Gp& dst, const Gp& sel, const Condition& condition) noexcept

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

template<typename Sel1, typename Sel2>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void inc(const Gp& dst) noexcept

void dec(const Gp& dst) noexcept

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void j(const Gp& target) noexcept

void j(const Label& target) noexcept

void j(const Label& target, const Condition& condition) noexcept

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

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

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

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

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

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

void i_prefetch(const Mem& mem) noexcept

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

Emit - Vector Instructions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

void s_round_f32(const Dst& dst, const Src& src) noexcept

template<typename Dst, typename Src>

void s_round_f64(const Dst& dst, const Src& src) noexcept

template<typename Dst, typename Src>

void v_round_f32(const Dst& dst, const Src& src) noexcept

template<typename Dst, typename Src>

void v_round_f64(const Dst& dst, const Src& src) noexcept

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

template<typename Dst, typename Src>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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