diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs index a123356323b04..e764b3147074f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs @@ -416,7 +416,40 @@ public abstract class PackedSimd public static unsafe Vector128 LoadScalarVector128(nint* address) { throw new PlatformNotSupportedException(); } public static unsafe Vector128 LoadScalarVector128(nuint* address) { throw new PlatformNotSupportedException(); } - // Floating-point sign bit operations + public static unsafe Vector128 LoadScalarAndSplatVector128(sbyte* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(byte* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(short* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(ushort* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(int* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(uint* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(long* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(ulong* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(float* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(double* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(nint* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndSplatVector128(nuint* address) { throw new PlatformNotSupportedException(); } + + public static unsafe Vector128 LoadScalarAndInsert(sbyte* address, Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(byte* address, Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(short* address, Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(ushort* address, Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(int* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(uint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(long* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(ulong* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(float* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(double* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(nint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadScalarAndInsert(nuint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } + + public static unsafe Vector128 LoadWideningVector128(sbyte* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadWideningVector128(byte* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadWideningVector128(short* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadWideningVector128(ushort* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadWideningVector128(int* address) { throw new PlatformNotSupportedException(); } + public static unsafe Vector128 LoadWideningVector128(uint* address) { throw new PlatformNotSupportedException(); } + + // Floating-point sign bit operations public static Vector128 Negate(Vector128 value) { throw new PlatformNotSupportedException(); } public static Vector128 Negate(Vector128 value) { throw new PlatformNotSupportedException(); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs index 76e50ea895eac..5f3554b58b768 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs @@ -1803,7 +1803,160 @@ public abstract class PackedSimd [Intrinsic] public static unsafe Vector128 LoadScalarVector128(nuint* address) => LoadScalarVector128(address); - // Floating-point sign bit operations + /// + /// v128.load8_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(sbyte* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load8_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(byte* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load16_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(short* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load16_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(ushort* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load32_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(int* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load32_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(uint* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load64_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(long* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load64_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(ulong* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load64_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(float* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load64_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(double* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load64_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(nint* address) => LoadScalarAndSplatVector128(address); + /// + /// v128.load64_splat + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndSplatVector128(nuint* address) => LoadScalarAndSplatVector128(address); + + /// + /// v128.load8_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(sbyte* address, Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx16 + /// + /// v128.load8_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(byte* address, Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx16 + /// + /// v128.load16_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(short* address, Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx8 + /// + /// v128.load16_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(ushort* address, Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx8 + /// + /// v128.load32_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(int* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx4 + /// + /// v128.load32_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(uint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx4 + /// + /// v128.load64_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(long* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx2 + /// + /// v128.load64_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(ulong* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx2 + /// + /// v128.load32_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(float* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx4 + /// + /// v128.load64_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(double* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx2 + /// + /// v128.load32_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(nint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx4 + /// + /// v128.load32_lane + /// + [Intrinsic] + public static unsafe Vector128 LoadScalarAndInsert(nuint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx4 + + /// + /// v128.load8x8_s + /// + [Intrinsic] + public static unsafe Vector128 LoadWideningVector128(sbyte* address) => LoadWideningVector128(address); + /// + /// v128.load8x8_u + /// + [Intrinsic] + public static unsafe Vector128 LoadWideningVector128(byte* address) => LoadWideningVector128(address); + /// + /// v128.load16x4_s + /// + [Intrinsic] + public static unsafe Vector128 LoadWideningVector128(short* address) => LoadWideningVector128(address); + /// + /// v128.load16x4_u + /// + [Intrinsic] + public static unsafe Vector128 LoadWideningVector128(ushort* address) => LoadWideningVector128(address); + /// + /// v128.load32x2_s + /// + [Intrinsic] + public static unsafe Vector128 LoadWideningVector128(int* address) => LoadWideningVector128(address); + /// + /// v128.load32x2_u + /// + [Intrinsic] + public static unsafe Vector128 LoadWideningVector128(uint* address) => LoadWideningVector128(address); + + // Floating-point sign bit operations /// /// f32x4.neg diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs index f28e242d5b3bc..8dd71a08c9b7b 100644 --- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs +++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs @@ -6598,6 +6598,36 @@ public abstract partial class PackedSimd public static unsafe Vector128 LoadScalarVector128(double* address) { throw null; } public static unsafe Vector128 LoadScalarVector128(nint* address) { throw null; } public static unsafe Vector128 LoadScalarVector128(nuint* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(sbyte* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(byte* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(short* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(ushort* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(int* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(uint* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(long* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(ulong* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(float* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(double* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(nint* address) { throw null; } + public static unsafe Vector128 LoadScalarAndSplatVector128(nuint* address) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(sbyte* address, Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(byte* address, Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(short* address, Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(ushort* address, Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(int* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(uint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(long* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(ulong* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(float* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(double* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(nint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw null; } + public static unsafe Vector128 LoadScalarAndInsert(nuint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw null; } + public static unsafe Vector128 LoadWideningVector128(sbyte* address) { throw null; } + public static unsafe Vector128 LoadWideningVector128(byte* address) { throw null; } + public static unsafe Vector128 LoadWideningVector128(short* address) { throw null; } + public static unsafe Vector128 LoadWideningVector128(ushort* address) { throw null; } + public static unsafe Vector128 LoadWideningVector128(int* address) { throw null; } + public static unsafe Vector128 LoadWideningVector128(uint* address) { throw null; } public static Vector128 Negate(Vector128 value) { throw null; } public static Vector128 Negate(Vector128 value) { throw null; } public static Vector128 Abs(Vector128 value) { throw null; } diff --git a/src/mono/mono/mini/mini-llvm.c b/src/mono/mono/mini/mini-llvm.c index 20ee76582070c..8f3fdb59ba6e1 100644 --- a/src/mono/mono/mini/mini-llvm.c +++ b/src/mono/mono/mini/mini-llvm.c @@ -10103,6 +10103,115 @@ MONO_RESTORE_WARNING break; } + case OP_WASM_SIMD_LOAD_SCALAR_INSERT: { + LLVMTypeRef rtype; + switch(inst_c1_type (ins)) { + case MONO_TYPE_I1: + case MONO_TYPE_U1: + rtype = v128_i1_t; + break; + case MONO_TYPE_I2: + case MONO_TYPE_U2: + rtype = v128_i2_t; + break; + case MONO_TYPE_I: + case MONO_TYPE_U: + case MONO_TYPE_I4: + case MONO_TYPE_U4: + case MONO_TYPE_R4: + rtype = v128_i4_t; + break; + case MONO_TYPE_I8: + case MONO_TYPE_U8: + case MONO_TYPE_R8: + rtype = v128_i8_t; + break; + default: + g_assert_not_reached(); + } + LLVMTypeRef srctype = LLVMGetElementType (rtype); + LLVMValueRef addr = convert (ctx, lhs, pointer_type (srctype)); + LLVMValueRef scalar = mono_llvm_build_aligned_load (builder, srctype, addr, "", FALSE, 1); + LLVMTypeRef vtype = LLVMTypeOf (rhs); + LLVMValueRef vec = vtype == rtype ? rhs : LLVMBuildBitCast(builder, rhs, rtype, ""); + vec = LLVMBuildInsertElement (builder, vec, scalar, arg3, ""); + if (vtype != rtype) + vec = LLVMBuildBitCast(builder, vec, vtype, ""); + values [ins->dreg] = vec; + break; + } + case OP_WASM_SIMD_LOAD_WIDENING: { + MonoTypeEnum ptype = inst_c1_type (ins); + LLVMTypeRef srctype = NULL, dsttype = NULL; + switch(ptype) { + case MONO_TYPE_U1: + case MONO_TYPE_I1: + srctype = v64_i1_t; + dsttype = v128_i2_t; + break; + case MONO_TYPE_U2: + case MONO_TYPE_I2: + srctype = v64_i2_t; + dsttype = v128_i4_t; + break; + case MONO_TYPE_U: + case MONO_TYPE_I: + case MONO_TYPE_U4: + case MONO_TYPE_I4: + srctype = v64_i4_t; + dsttype = v128_i8_t; + break; + default: + g_assert_not_reached(); + } + LLVMValueRef addr = convert (ctx, lhs, pointer_type (srctype)); + LLVMValueRef narrow = mono_llvm_build_aligned_load (builder, srctype, addr, "", FALSE, 1); + values [ins->dreg] = primitive_type_is_unsigned (ptype) ? LLVMBuildZExt (builder, narrow, dsttype, "") : LLVMBuildSExt (builder, narrow, dsttype, ""); + break; + } + case OP_WASM_SIMD_LOAD_SCALAR_SPLAT: { + int elems; + LLVMTypeRef rtype; + switch(inst_c1_type (ins)) { + case MONO_TYPE_I1: + case MONO_TYPE_U1: + rtype = v128_i1_t; + elems = 16; + break; + case MONO_TYPE_I2: + case MONO_TYPE_U2: + rtype = v128_i2_t; + elems = 8; + break; + case MONO_TYPE_I: + case MONO_TYPE_U: + case MONO_TYPE_I4: + case MONO_TYPE_U4: + rtype = v128_i4_t; + elems = 4; + break; + case MONO_TYPE_R4: + rtype = v128_r4_t; + elems = 4; + break; + case MONO_TYPE_I8: + case MONO_TYPE_U8: + rtype = v128_i8_t; + elems = 2; + break; + case MONO_TYPE_R8: + rtype = v128_r8_t; + elems = 2; + break; + default: + g_assert_not_reached(); + } + LLVMTypeRef srctype = LLVMGetElementType (rtype); + LLVMValueRef addr = convert (ctx, lhs, pointer_type (srctype)); + LLVMValueRef scalar = mono_llvm_build_aligned_load (builder, srctype, addr, "", FALSE, 1); + values [ins->dreg] = broadcast_element (ctx, scalar, elems); + break; + } #endif #if defined(TARGET_ARM64) || defined(TARGET_X86) || defined(TARGET_AMD64) || defined(TARGET_WASM) case OP_XEQUAL: { diff --git a/src/mono/mono/mini/mini-ops.h b/src/mono/mono/mini/mini-ops.h index 66f64648b5fd6..ca630c64a5c57 100644 --- a/src/mono/mono/mini/mini-ops.h +++ b/src/mono/mono/mini/mini-ops.h @@ -867,6 +867,9 @@ MINI_OP(OP_WASM_EXTMUL_UPPER_U, "wasm_extmul_upper_u", XREG, XREG, XREG) MINI_OP(OP_WASM_SIMD_CONV_R8_TO_R4, "wasm_simd_conv_r8_to_r4", XREG, XREG, NONE) MINI_OP(OP_WASM_SIMD_CONV_R8_TO_I4_ZERO, "wasm_simd_conv_r8_to_i4_zero", XREG, XREG, NONE) MINI_OP(OP_WASM_SIMD_CONV_U4_TO_R8_LOW, "wasm_simd_conv_u4_to_r8_low", XREG, XREG, NONE) +MINI_OP3(OP_WASM_SIMD_LOAD_SCALAR_INSERT, "wasm_simd_load_scalar_insert", XREG, IREG, XREG, IREG) +MINI_OP(OP_WASM_SIMD_LOAD_SCALAR_SPLAT, "wasm_simd_load_scalar_splat_i1", XREG, IREG, NONE) +MINI_OP(OP_WASM_SIMD_LOAD_WIDENING, "wasm_simd_load_widening", XREG, IREG, NONE) MINI_OP(OP_WASM_SIMD_SEXT_LOWER, "wasm_simd_ext_lower_s", XREG, XREG, NONE) MINI_OP(OP_WASM_SIMD_SEXT_UPPER, "wasm_simd_ext_upper_s", XREG, XREG, NONE) MINI_OP(OP_WASM_SIMD_ZEXT_LOWER, "wasm_simd_ext_lower_u", XREG, XREG, NONE) diff --git a/src/mono/mono/mini/simd-intrinsics.c b/src/mono/mono/mini/simd-intrinsics.c index dca9ccbd73ccc..80fe4302b52f2 100644 --- a/src/mono/mono/mini/simd-intrinsics.c +++ b/src/mono/mono/mini/simd-intrinsics.c @@ -5248,8 +5248,11 @@ static SimdIntrinsic packedsimd_methods [] = { {SN_Dot, OP_XOP_X_X_X, INTRINS_WASM_DOT}, {SN_ExtractLane}, {SN_Floor, OP_XOP_OVR_X_X, INTRINS_SIMD_FLOOR}, + {SN_LoadScalarAndInsert, OP_WASM_SIMD_LOAD_SCALAR_INSERT}, + {SN_LoadScalarAndSplatVector128, OP_WASM_SIMD_LOAD_SCALAR_SPLAT}, {SN_LoadScalarVector128}, {SN_LoadVector128, OP_LOADX_MEMBASE}, + {SN_LoadWideningVector128, OP_WASM_SIMD_LOAD_WIDENING}, {SN_Max, OP_XBINOP, OP_IMIN, OP_XBINOP, OP_IMIN_UN, OP_XBINOP, OP_FMIN}, {SN_Min, OP_XBINOP, OP_IMAX, OP_XBINOP, OP_IMAX_UN, OP_XBINOP, OP_FMAX}, {SN_Multiply}, diff --git a/src/mono/mono/mini/simd-methods.h b/src/mono/mono/mini/simd-methods.h index 777e4d79df1bc..1320ea2ce9d56 100644 --- a/src/mono/mono/mini/simd-methods.h +++ b/src/mono/mono/mini/simd-methods.h @@ -645,6 +645,9 @@ METHOD(ConvertToDoubleLower) METHOD(ConvertToInt32Saturate) METHOD(ConvertToUnsignedInt32Saturate) METHOD(ExtractLane) +METHOD(LoadScalarAndInsert) +METHOD(LoadScalarAndSplatVector128) +METHOD(LoadWideningVector128) METHOD(MultiplyRoundedSaturateQ15) METHOD(PseudoMax) METHOD(PseudoMin)