INTRINS_BEXTR_I64,
#if defined(TARGET_AMD64) || defined(TARGET_X86)
INTRINS_SSE_PMOVMSKB,
+ INTRINS_SSE_MOVMSK_PS,
+ INTRINS_SSE_MOVMSK_PD,
INTRINS_SSE_PSRLI_W,
INTRINS_SSE_PSRAI_W,
INTRINS_SSE_PSLLI_W,
INTRINS_SSE_DPPS,
INTRINS_SSE_ROUNDSS,
INTRINS_SSE_ROUNDPD,
+ INTRINS_SSE_PTESTZ,
+ INTRINS_SSE_INSERTPS,
+ INTRINS_SSE_PSHUFB,
#endif
#ifdef TARGET_WASM
INTRINS_WASM_ANYTRUE_V16,
{
switch (type) {
case MONO_TYPE_I1:
+ case MONO_TYPE_U1:
return LLVMVectorType (LLVMInt8Type (), 16);
+ case MONO_TYPE_U2:
case MONO_TYPE_I2:
return LLVMVectorType (LLVMInt16Type (), 8);
+ case MONO_TYPE_U4:
case MONO_TYPE_I4:
return LLVMVectorType (LLVMInt32Type (), 4);
+ case MONO_TYPE_U8:
case MONO_TYPE_I8:
return LLVMVectorType (LLVMInt64Type (), 2);
case MONO_TYPE_R8:
return ltype;
}
-/*
- * type_to_llvm_type:
- *
- * Return the LLVM type corresponding to T.
- */
static LLVMTypeRef
-type_to_llvm_type (EmitContext *ctx, MonoType *t)
+primitive_type_to_llvm_type (MonoTypeEnum type)
{
- if (t->byref)
- return ThisType ();
-
- t = mini_get_underlying_type (t);
-
- switch (t->type) {
- case MONO_TYPE_VOID:
- return LLVMVoidType ();
+ switch (type) {
case MONO_TYPE_I1:
- return LLVMInt8Type ();
- case MONO_TYPE_I2:
- return LLVMInt16Type ();
- case MONO_TYPE_I4:
- return LLVMInt32Type ();
case MONO_TYPE_U1:
return LLVMInt8Type ();
+ case MONO_TYPE_I2:
case MONO_TYPE_U2:
return LLVMInt16Type ();
+ case MONO_TYPE_I4:
case MONO_TYPE_U4:
return LLVMInt32Type ();
case MONO_TYPE_I8:
case MONO_TYPE_I:
case MONO_TYPE_U:
return IntPtrType ();
+ default:
+ return NULL;
+ }
+}
+
+/*
+ * type_to_llvm_type:
+ *
+ * Return the LLVM type corresponding to T.
+ */
+static LLVMTypeRef
+type_to_llvm_type (EmitContext *ctx, MonoType *t)
+{
+ if (t->byref)
+ return ThisType ();
+
+ t = mini_get_underlying_type (t);
+
+ LLVMTypeRef prim_llvm_type = primitive_type_to_llvm_type (t->type);
+ if (prim_llvm_type != NULL)
+ return prim_llvm_type;
+
+ switch (t->type) {
+ case MONO_TYPE_VOID:
+ return LLVMVoidType ();
case MONO_TYPE_OBJECT:
return ObjRefType ();
case MONO_TYPE_PTR: {
return lpad_bb;
}
+static LLVMValueRef
+create_const_vector_i32 (const int *mask, int count)
+{
+ LLVMValueRef *llvm_mask = g_new (LLVMValueRef, count);
+ for (int i = 0; i < count; i++)
+ llvm_mask [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
+ LLVMValueRef vec = LLVMConstVector (llvm_mask, count);
+ g_free (llvm_mask);
+ return vec;
+}
+
+static LLVMValueRef
+create_const_vector_4_i32 (int v0, int v1, int v2, int v3)
+{
+ LLVMValueRef mask [4];
+ mask [0] = LLVMConstInt (LLVMInt32Type (), v0, FALSE);
+ mask [1] = LLVMConstInt (LLVMInt32Type (), v1, FALSE);
+ mask [2] = LLVMConstInt (LLVMInt32Type (), v2, FALSE);
+ mask [3] = LLVMConstInt (LLVMInt32Type (), v3, FALSE);
+ return LLVMConstVector (mask, 4);
+}
+
+static LLVMValueRef
+create_const_vector_2_i32 (int v0, int v1)
+{
+ LLVMValueRef mask [2];
+ mask [0] = LLVMConstInt (LLVMInt32Type (), v0, FALSE);
+ mask [1] = LLVMConstInt (LLVMInt32Type (), v1, FALSE);
+ return LLVMConstVector (mask, 2);
+}
static void
emit_llvmonly_handler_start (EmitContext *ctx, MonoBasicBlock *bb, LLVMBasicBlockRef cbb)
}
#if defined(TARGET_X86) || defined(TARGET_AMD64)
+ case OP_SSE_MOVMSK: {
+ LLVMValueRef args [1];
+ if (ins->inst_c1 == MONO_TYPE_R4) {
+ args [0] = lhs;
+ values [ins->dreg] = LLVMBuildCall (builder, get_intrins (ctx, INTRINS_SSE_MOVMSK_PS), args, 1, dname);
+ } else if (ins->inst_c1 == MONO_TYPE_R8) {
+ args [0] = lhs;
+ values [ins->dreg] = LLVMBuildCall (builder, get_intrins (ctx, INTRINS_SSE_MOVMSK_PD), args, 1, dname);
+ } else {
+ args [0] = convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I1));
+ values [ins->dreg] = LLVMBuildCall (builder, get_intrins (ctx, INTRINS_SSE_PMOVMSKB), args, 1, dname);
+ }
+ break;
+ }
+
+ case OP_SSE_MOVS:
+ case OP_SSE_MOVS2: {
+ if (ins->inst_c1 == MONO_TYPE_R4)
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, rhs, lhs, create_const_vector_4_i32 (0, 5, 6, 7), "");
+ else if (ins->inst_c1 == MONO_TYPE_R8)
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, rhs, lhs, create_const_vector_2_i32 (0, 3), "");
+ else if (ins->inst_c1 == MONO_TYPE_I8 || ins->inst_c1 == MONO_TYPE_U8)
+ values [ins->dreg] = LLVMBuildInsertElement (builder, lhs,
+ LLVMConstInt (LLVMInt64Type (), 0, FALSE),
+ LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
+ else
+ g_assert_not_reached (); // will be needed for other types later
+ break;
+ }
+
+ case OP_SSE_MOVEHL: {
+ if (ins->inst_c1 == MONO_TYPE_R4)
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, rhs, create_const_vector_4_i32 (6, 7, 2, 3), "");
+ else
+ g_assert_not_reached ();
+ break;
+ }
+
+ case OP_SSE_MOVELH: {
+ if (ins->inst_c1 == MONO_TYPE_R4)
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, rhs, create_const_vector_4_i32 (0, 1, 4, 5), "");
+ else
+ g_assert_not_reached ();
+ break;
+ }
+
+ case OP_SSE_UNPACKLO: {
+ if (ins->inst_c1 == MONO_TYPE_R8 || ins->inst_c1 == MONO_TYPE_I8 || ins->inst_c1 == MONO_TYPE_U8) {
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, rhs, create_const_vector_2_i32 (0, 2), "");
+ } else if (ins->inst_c1 == MONO_TYPE_R4 || ins->inst_c1 == MONO_TYPE_I4 || ins->inst_c1 == MONO_TYPE_U4) {
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, rhs, create_const_vector_4_i32 (0, 4, 1, 5), "");
+ } else if (ins->inst_c1 == MONO_TYPE_I2 || ins->inst_c1 == MONO_TYPE_U2) {
+ const int mask_values [] = { 0, 8, 1, 9, 2, 10, 3, 11 };
+ LLVMValueRef shuffled = LLVMBuildShuffleVector (builder,
+ convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I2)),
+ convert (ctx, rhs, type_to_simd_type (MONO_TYPE_I2)),
+ create_const_vector_i32 (mask_values, 8), "");
+ values [ins->dreg] = convert (ctx, shuffled, type_to_simd_type (ins->inst_c1));
+ } else if (ins->inst_c1 == MONO_TYPE_I1 || ins->inst_c1 == MONO_TYPE_U1) {
+ const int mask_values [] = { 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23 };
+ LLVMValueRef shuffled = LLVMBuildShuffleVector (builder,
+ convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I1)),
+ convert (ctx, rhs, type_to_simd_type (MONO_TYPE_I1)),
+ create_const_vector_i32 (mask_values, 16), "");
+ values [ins->dreg] = convert (ctx, shuffled, type_to_simd_type (ins->inst_c1));
+ } else {
+ g_assert_not_reached ();
+ }
+ break;
+ }
+
+ case OP_SSE_UNPACKHI: {
+ if (ins->inst_c1 == MONO_TYPE_R8 || ins->inst_c1 == MONO_TYPE_I8 || ins->inst_c1 == MONO_TYPE_U8) {
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, rhs, create_const_vector_2_i32 (1, 3), "");
+ } else if (ins->inst_c1 == MONO_TYPE_R4 || ins->inst_c1 == MONO_TYPE_I4 || ins->inst_c1 == MONO_TYPE_U4) {
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, rhs, create_const_vector_4_i32 (2, 6, 3, 7), "");
+ } else if (ins->inst_c1 == MONO_TYPE_I2 || ins->inst_c1 == MONO_TYPE_U2) {
+ const int mask_values [] = { 4, 12, 5, 13, 6, 14, 7, 15 };
+ LLVMValueRef shuffled = LLVMBuildShuffleVector (builder,
+ convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I2)),
+ convert (ctx, rhs, type_to_simd_type (MONO_TYPE_I2)),
+ create_const_vector_i32 (mask_values, 8), "");
+ values [ins->dreg] = convert (ctx, shuffled, type_to_simd_type (ins->inst_c1));
+ } else if (ins->inst_c1 == MONO_TYPE_I1 || ins->inst_c1 == MONO_TYPE_U1) {
+ const int mask_values [] = { 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31 };
+ LLVMValueRef shuffled = LLVMBuildShuffleVector (builder,
+ convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I1)),
+ convert (ctx, rhs, type_to_simd_type (MONO_TYPE_I1)),
+ create_const_vector_i32 (mask_values, 16), "");
+ values [ins->dreg] = convert (ctx, shuffled, type_to_simd_type (ins->inst_c1));
+ } else {
+ g_assert_not_reached ();
+ }
+ break;
+ }
+
+ case OP_SSE_LOADU: {
+ LLVMValueRef dst_ptr = convert (ctx, lhs, LLVMPointerType (primitive_type_to_llvm_type (ins->inst_c1), 0));
+ LLVMValueRef dst_vec = LLVMBuildBitCast (builder, dst_ptr, LLVMPointerType (type_to_simd_type (ins->inst_c1), 0), "");
+ values [ins->dreg] = mono_llvm_build_aligned_load (builder, dst_vec, "", FALSE, ins->inst_c0); // inst_c0 is alignment
+ break;
+ }
+
+ case OP_SSE_STORE: {
+ LLVMValueRef dst_vec = convert (ctx, lhs, LLVMPointerType (LLVMTypeOf (rhs), 0));
+ mono_llvm_build_aligned_store (builder, rhs, dst_vec, FALSE, ins->inst_c0);
+ break;
+ }
+
+ case OP_SSE_STORES: {
+ LLVMValueRef first_elem = LLVMBuildExtractElement (builder, rhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
+ LLVMValueRef dst = convert (ctx, lhs, LLVMPointerType (LLVMTypeOf (first_elem), 0));
+ mono_llvm_build_aligned_store (builder, first_elem, dst, FALSE, 1);
+ break;
+ }
+
+ case OP_SSE_SHUFFLE: {
+ LLVMValueRef shuffle_vec = create_const_vector_4_i32 (
+ ((ins->inst_c0 >> 0) & 0x3) + 0, // take two elements from lhs
+ ((ins->inst_c0 >> 2) & 0x3) + 0,
+ ((ins->inst_c0 >> 4) & 0x3) + 4, // and two from rhs
+ ((ins->inst_c0 >> 6) & 0x3) + 4);
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, rhs, shuffle_vec, "");
+ break;
+ }
+
+ case OP_SSE2_SHUFFLE: {
+ LLVMValueRef right_vec;
+ LLVMValueRef shuffle_vec;
+ if (ins->inst_c1 == MONO_TYPE_R8) {
+ right_vec = rhs;
+ shuffle_vec = create_const_vector_2_i32 (
+ ((ins->inst_c0 >> 0) & 0x1) + 0,
+ ((ins->inst_c0 >> 1) & 0x1) + 2);
+ } else {
+ right_vec = LLVMGetUndef (LLVMVectorType (LLVMInt32Type (), 4));
+ shuffle_vec = create_const_vector_4_i32 (
+ (ins->inst_c0 >> 0) & 0x3,
+ (ins->inst_c0 >> 2) & 0x3,
+ (ins->inst_c0 >> 4) & 0x3,
+ (ins->inst_c0 >> 6) & 0x3);
+ }
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, right_vec, shuffle_vec, "");
+ break;
+ }
+
+ case OP_SSE_OR: {
+ LLVMValueRef vec_lhs_i64 = convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I8));
+ LLVMValueRef vec_rhs_i64 = convert (ctx, rhs, type_to_simd_type (MONO_TYPE_I8));
+ LLVMValueRef vec_and = LLVMBuildOr (builder, vec_lhs_i64, vec_rhs_i64, "");
+ values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_simd_type (ins->inst_c1), "");
+ break;
+ }
+
+ case OP_SSE_XOR: {
+ LLVMValueRef vec_lhs_i64 = convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I8));
+ LLVMValueRef vec_rhs_i64 = convert (ctx, rhs, type_to_simd_type (MONO_TYPE_I8));
+ LLVMValueRef vec_and = LLVMBuildXor (builder, vec_lhs_i64, vec_rhs_i64, "");
+ values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_simd_type (ins->inst_c1), "");
+ break;
+ }
+
+ case OP_SSE_AND: {
+ LLVMValueRef vec_lhs_i64 = convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I8));
+ LLVMValueRef vec_rhs_i64 = convert (ctx, rhs, type_to_simd_type (MONO_TYPE_I8));
+ LLVMValueRef vec_and = LLVMBuildAnd (builder, vec_lhs_i64, vec_rhs_i64, "");
+ values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_simd_type (ins->inst_c1), "");
+ break;
+ }
+
+ case OP_SSE_ANDN: {
+ LLVMValueRef minus_one [2];
+ minus_one [0] = LLVMConstInt (LLVMInt64Type (), -1, FALSE);
+ minus_one [1] = LLVMConstInt (LLVMInt64Type (), -1, FALSE);
+ LLVMValueRef vec_lhs_i64 = convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I8));
+ LLVMValueRef vec_xor = LLVMBuildXor (builder, vec_lhs_i64, LLVMConstVector (minus_one, 2), "");
+ LLVMValueRef vec_rhs_i64 = convert (ctx, rhs, type_to_simd_type (MONO_TYPE_I8));
+ LLVMValueRef vec_and = LLVMBuildAnd (builder, vec_rhs_i64, vec_xor, "");
+ values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_simd_type (ins->inst_c1), "");
+ break;
+ }
+
+ case OP_SSE2_PACKUS: {
+ LLVMValueRef args [2];
+ args [0] = convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I2));
+ args [1] = convert (ctx, rhs, type_to_simd_type (MONO_TYPE_I2));
+ values [ins->dreg] = convert (ctx,
+ LLVMBuildCall (builder, get_intrins (ctx, INTRINS_SSE_PACKUSWB), args, 2, dname),
+ type_to_simd_type (ins->inst_c1));
+ break;
+ }
+
+ case OP_SSE2_SRLI: {
+ LLVMValueRef args [] = { lhs, rhs };
+ values [ins->dreg] = convert (ctx,
+ LLVMBuildCall (builder, get_intrins (ctx, INTRINS_SSE_PSRLI_W), args, 2, dname),
+ type_to_simd_type (ins->inst_c1));
+ break;
+ }
+
+ case OP_SSSE3_SHUFFLE: {
+ LLVMValueRef args [] = { lhs, rhs };
+ values [ins->dreg] = LLVMBuildCall (builder, get_intrins (ctx, INTRINS_SSE_PSHUFB), args, 2, dname);
+ break;
+ }
+
+ case OP_SSE3_MOVDDUP: {
+ values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs,
+ LLVMGetUndef (LLVMVectorType (LLVMDoubleType (), 2)),
+ LLVMConstNull (LLVMVectorType (LLVMInt32Type (), 2)), "");
+ break;
+ }
+
+ case OP_CREATE_SCALAR_UNSAFE: {
+ values [ins->dreg] = LLVMBuildInsertElement (builder,
+ LLVMGetUndef (simd_class_to_llvm_type (ctx, ins->klass)),
+ convert (ctx, lhs, primitive_type_to_llvm_type (ins->inst_c1)),
+ LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
+ break;
+ }
+
case OP_SSE41_ROUNDSS: {
LLVMValueRef args [3];
values [ins->dreg] = LLVMBuildCall (builder, get_intrins (ctx, INTRINS_SSE_ROUNDPD), args, 2, dname);
break;
}
+
+ case OP_SSE41_INSERT: {
+ if (ins->inst_c1 == MONO_TYPE_R4) {
+ // special case for <float> overload
+ LLVMValueRef args [3];
+ args [0] = values [ins->sreg1];
+ args [1] = values [ins->sreg2];
+ args [2] = convert (ctx, values [ins->sreg3], LLVMInt8Type ());
+ values [ins->dreg] = LLVMBuildCall (builder, get_intrins (ctx, INTRINS_SSE_INSERTPS), args, 3, dname);
+ } else {
+ // other overloads are implemented with `insertelement`
+ values [ins->dreg] = LLVMBuildInsertElement (builder,
+ values [ins->sreg1],
+ convert (ctx, values [ins->sreg2], primitive_type_to_llvm_type (ins->inst_c1)),
+ convert (ctx, values [ins->sreg3], LLVMInt8Type ()), dname);
+ }
+ break;
+ }
+
+ case OP_SSE41_PTESTZ: {
+ LLVMValueRef args [2];
+ args [0] = convert (ctx, lhs, type_to_simd_type (MONO_TYPE_I8));
+ args [1] = convert (ctx, rhs, type_to_simd_type (MONO_TYPE_I8));
+ LLVMValueRef call = LLVMBuildCall (builder, get_intrins (ctx, INTRINS_SSE_PTESTZ), args, 2, dname);
+ LLVMValueRef cmp_zero = LLVMBuildICmp (builder, LLVMIntNE, call, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
+ values [ins->dreg] = LLVMBuildZExt (builder, cmp_zero, LLVMInt8Type (), "");
+ break;
+ }
#endif
#ifdef ENABLE_NETCORE
{INTRINS_PDEP_I64, "llvm.x86.bmi.pdep.64"},
#if defined(TARGET_AMD64) || defined(TARGET_X86)
{INTRINS_SSE_PMOVMSKB, "llvm.x86.sse2.pmovmskb.128"},
+ {INTRINS_SSE_MOVMSK_PS, "llvm.x86.sse.movmsk.ps"},
+ {INTRINS_SSE_MOVMSK_PD, "llvm.x86.sse2.movmsk.pd"},
{INTRINS_SSE_PSRLI_W, "llvm.x86.sse2.psrli.w"},
{INTRINS_SSE_PSRAI_W, "llvm.x86.sse2.psrai.w"},
{INTRINS_SSE_PSLLI_W, "llvm.x86.sse2.pslli.w"},
{INTRINS_SSE_PSUBUSB, "llvm.x86.sse2.psubus.b"},
{INTRINS_SSE_PAVGB, "llvm.x86.sse2.pavg.b"},
{INTRINS_SSE_PAUSE, "llvm.x86.sse2.pause"},
+ {INTRINS_SSE_PSHUFB, "llvm.x86.ssse3.pshuf.b.128"},
{INTRINS_SSE_DPPS, "llvm.x86.sse41.dpps"},
{INTRINS_SSE_ROUNDSS, "llvm.x86.sse41.round.ss"},
{INTRINS_SSE_ROUNDPD, "llvm.x86.sse41.round.pd"},
+ {INTRINS_SSE_PTESTZ, "llvm.x86.sse41.ptestz"},
+ {INTRINS_SSE_INSERTPS, "llvm.x86.sse41.insertps"},
#endif
#ifdef TARGET_WASM
{INTRINS_WASM_ANYTRUE_V16, "llvm.wasm.anytrue.v16i8"},
arg_types [0] = type_to_simd_type (MONO_TYPE_I1);
AddFunc (module, name, ret_type, arg_types, 1);
break;
+ case INTRINS_SSE_MOVMSK_PS:
+ AddFunc1 (module, name, LLVMInt32Type (), type_to_simd_type (MONO_TYPE_R4));
+ break;
+ case INTRINS_SSE_MOVMSK_PD:
+ AddFunc1 (module, name, LLVMInt32Type (), type_to_simd_type (MONO_TYPE_R8));
+ break;
case INTRINS_SSE_PSRLI_W:
case INTRINS_SSE_PSRAI_W:
case INTRINS_SSE_PSLLI_W:
case INTRINS_SSE_ADDSUBPD:
add_sse_binary (module, name, MONO_TYPE_R8);
break;
+ case INTRINS_SSE_PSHUFB:
case INTRINS_SE_PADDSB:
case INTRINS_SSE_PSUBSB:
case INTRINS_SSE_PADDUSB:
case INTRINS_SSE_PAVGB:
add_sse_binary (module, name, MONO_TYPE_I1);
break;
+ case INTRINS_SSE_PTESTZ:
+ ret_type = type_to_simd_type (MONO_TYPE_I8);
+ AddFunc2 (module, name, LLVMInt32Type (), ret_type, ret_type);
+ break;
+ case INTRINS_SSE_INSERTPS:
+ ret_type = type_to_simd_type (MONO_TYPE_R4);
+ arg_types [0] = ret_type;
+ arg_types [1] = ret_type;
+ arg_types [2] = LLVMInt8Type ();
+ AddFunc (module, name, ret_type, arg_types, 3);
+ break;
case INTRINS_SSE_PAUSE:
AddFunc (module, "llvm.x86.sse2.pause", LLVMVoidType (), NULL, 0);
break;
/* multiply all 4 single precision float elements, add them together, and store the result to the lowest element */
MINI_OP(OP_DPPS, "dpps", XREG, XREG, XREG)
-/* sse 4.1 */
+/* sse 1 */
+/* inst_c1 is target type */
+MINI_OP(OP_SSE_LOADU, "sse_loadu", XREG, XREG, NONE)
+MINI_OP(OP_SSE_MOVMSK, "sse_movmsk", IREG, XREG, NONE)
+MINI_OP(OP_SSE_STORE, "sse_store", NONE, XREG, XREG)
+MINI_OP(OP_SSE_STORES, "sse_stores", NONE, XREG, XREG)
+MINI_OP(OP_SSE_MOVS, "sse_movs", XREG, XREG, NONE)
+MINI_OP(OP_SSE_MOVS2, "sse_movs2", XREG, XREG, XREG)
+MINI_OP(OP_SSE_MOVEHL, "sse_movehl", XREG, XREG, XREG)
+MINI_OP(OP_SSE_MOVELH, "sse_movelh", XREG, XREG, XREG)
+MINI_OP(OP_SSE_UNPACKLO, "sse_unpacklo", XREG, XREG, XREG)
+MINI_OP(OP_SSE_UNPACKHI, "sse_unpackhi", XREG, XREG, XREG)
+MINI_OP(OP_SSE_SHUFFLE, "sse_shuffle", XREG, XREG, XREG)
+MINI_OP(OP_SSE_AND, "sse_and", XREG, XREG, XREG)
+MINI_OP(OP_SSE_OR, "sse_or", XREG, XREG, XREG)
+MINI_OP(OP_SSE_XOR, "sse_xor", XREG, XREG, XREG)
+MINI_OP(OP_SSE_ANDN, "sse_andn", XREG, XREG, XREG)
+
+/* sse 2 */
+MINI_OP(OP_SSE2_PACKUS, "sse2_packus", XREG, XREG, XREG)
+MINI_OP(OP_SSE2_SRLI, "sse2_srli", XREG, XREG, XREG)
+MINI_OP(OP_SSE2_SHUFFLE, "sse2_shuffle", XREG, XREG, XREG)
+
+/* sse 3 */
+MINI_OP(OP_SSE3_MOVDDUP, "sse3_movddup", XREG, XREG, NONE)
+
+/* ssse 3 */
+MINI_OP(OP_SSSE3_SHUFFLE, "ssse3_shuffle", XREG, XREG, XREG)
+/* sse 4.1 */
/* inst_c0 is the rounding mode: 0 = round, 1 = floor, 2 = ceiling */
MINI_OP(OP_SSE41_ROUNDPD, "roundpd", XREG, XREG, NONE)
MINI_OP(OP_SSE41_ROUNDSS, "roundss", XREG, XREG, NONE)
+MINI_OP3(OP_SSE41_INSERT, "sse41_insert", XREG, XREG, XREG, IREG)
+MINI_OP(OP_SSE41_PTESTZ, "sse41_ptestz", IREG, XREG, XREG)
/* Intel BMI1 */
/* Count trailing zeroes, return 32/64 if the input is 0 */
#endif
+MINI_OP(OP_CREATE_SCALAR_UNSAFE, "create_scalar_unsafe", XREG, XREG, NONE)
+
MINI_OP(OP_XMOVE, "xmove", XREG, XREG, NONE)
MINI_OP(OP_XZERO, "xzero", XREG, NONE, NONE)
MINI_OP(OP_XONES, "xones", XREG, NONE, NONE)
} else if (spec [MONO_INST_DEST] == 'i') {
ins->dreg = alloc_ireg (cfg);
ins->type = STACK_I4;
- } else {
- g_assert_not_reached ();
}
ins->sreg1 = sreg1;
ins->sreg2 = sreg2;
}
static MonoInst*
-emit_xcompare (MonoCompile *cfg, MonoClass *klass, MonoType *etype, MonoInst *arg1, MonoInst *arg2)
+emit_simd_ins_for_sig (MonoCompile *cfg, MonoClass *klass, int opcode, int instc0, int instc1, MonoMethodSignature *fsig, MonoInst **args)
+{
+ g_assert (fsig->param_count <= 3);
+ MonoInst* ins = emit_simd_ins (cfg, klass, opcode,
+ fsig->param_count > 0 ? args [0]->dreg : -1,
+ fsig->param_count > 1 ? args [1]->dreg : -1);
+ if (instc0 != -1)
+ ins->inst_c0 = instc0;
+ if (instc1 != -1)
+ ins->inst_c1 = instc1;
+ if (fsig->param_count == 3)
+ ins->sreg3 = args [2]->dreg;
+ return ins;
+}
+
+static gboolean
+is_hw_intrinsics_class (MonoClass *klass, const char *name, gboolean *is_64bit)
+{
+ const char *class_name = m_class_get_name (klass);
+ if ((!strcmp (class_name, "X64") || !strcmp (class_name, "Arm64")) && klass->nested_in) {
+ *is_64bit = TRUE;
+ return !strcmp (m_class_get_name (klass->nested_in), name);
+ } else {
+ *is_64bit = FALSE;
+ return !strcmp (class_name, name);
+ }
+}
+
+static MonoTypeEnum
+get_underlying_type (MonoType* type)
+{
+ MonoClass* klass = mono_class_from_mono_type_internal (type);
+ if (type->type == MONO_TYPE_PTR) // e.g. int* => MONO_TYPE_I4
+ return m_class_get_byval_arg (m_class_get_element_class (klass))->type;
+ else if (type->type == MONO_TYPE_GENERICINST) // e.g. Vector128<int> => MONO_TYPE_I4
+ return mono_class_get_context (klass)->class_inst->type_argv [0]->type;
+ else
+ return type->type;
+}
+
+static MonoInst*
+emit_xcompare (MonoCompile *cfg, MonoClass *klass, MonoTypeEnum etype, MonoInst *arg1, MonoInst *arg2)
{
MonoInst *ins;
- gboolean is_fp = etype->type == MONO_TYPE_R4 || etype->type == MONO_TYPE_R8;
+ gboolean is_fp = etype == MONO_TYPE_R4 || etype == MONO_TYPE_R8;
ins = emit_simd_ins (cfg, klass, is_fp ? OP_XCOMPARE_FP : OP_XCOMPARE, arg1->dreg, arg2->dreg);
ins->inst_c0 = CMP_EQ;
- ins->inst_c1 = etype->type;
+ ins->inst_c1 = etype;
return ins;
}
g_assert (vector_type->type == MONO_TYPE_GENERICINST);
klass = mono_class_from_mono_type_internal (vector_type);
- g_assert (!strcmp (m_class_get_name (klass), "Vector`1"));
+ g_assert (
+ !strcmp (m_class_get_name (klass), "Vector`1") ||
+ !strcmp (m_class_get_name (klass), "Vector128`1") ||
+ !strcmp (m_class_get_name (klass), "Vector256`1"));
etype = mono_class_get_context (klass)->class_inst->type_argv [0];
return etype;
}
case SN_get_AllOnes: {
/* Compare a zero vector with itself */
ins = emit_simd_ins (cfg, klass, OP_XZERO, -1, -1);
- return emit_xcompare (cfg, klass, etype, ins, ins);
+ return emit_xcompare (cfg, klass, etype->type, ins, ins);
}
case SN_get_Item: {
if (!COMPILE_LLVM (cfg))
return emit_simd_ins (cfg, klass, OP_XEQUAL, sreg1, args [1]->dreg);
} else if (fsig->param_count == 2 && mono_metadata_type_equal (fsig->ret, type) && mono_metadata_type_equal (fsig->params [0], type) && mono_metadata_type_equal (fsig->params [1], type)) {
/* Per element equality */
- return emit_xcompare (cfg, klass, etype, args [0], args [1]);
+ return emit_xcompare (cfg, klass, etype->type, args [0], args [1]);
}
break;
case SN_op_Equality:
case SN_LessThanOrEqual:
g_assert (fsig->param_count == 2 && mono_metadata_type_equal (fsig->ret, type) && mono_metadata_type_equal (fsig->params [0], type) && mono_metadata_type_equal (fsig->params [1], type));
is_unsigned = etype->type == MONO_TYPE_U1 || etype->type == MONO_TYPE_U2 || etype->type == MONO_TYPE_U4 || etype->type == MONO_TYPE_U8;
- ins = emit_xcompare (cfg, klass, etype, args [0], args [1]);
+ ins = emit_xcompare (cfg, klass, etype->type, args [0], args [1]);
switch (id) {
case SN_GreaterThan:
ins->inst_c0 = is_unsigned ? CMP_GT_UN : CMP_GT;
#ifdef TARGET_AMD64
+static guint16 sse_methods [] = {
+ SN_Add,
+ SN_And,
+ SN_AndNot,
+ SN_CompareEqual,
+ SN_CompareNotEqual,
+ SN_Divide,
+ SN_LoadAlignedVector128,
+ SN_LoadVector128,
+ SN_MoveHighToLow,
+ SN_MoveLowToHigh,
+ SN_MoveMask,
+ SN_MoveScalar,
+ SN_Multiply,
+ SN_Or,
+ SN_Shuffle,
+ SN_Store,
+ SN_StoreAligned,
+ SN_Subtract,
+ SN_UnpackHigh,
+ SN_UnpackLow,
+ SN_Xor,
+ SN_get_IsSupported
+};
+
+static guint16 sse2_methods [] = {
+ SN_Add,
+ SN_And,
+ SN_AndNot,
+ SN_CompareEqual,
+ SN_CompareGreaterThan,
+ SN_CompareLessThan,
+ SN_CompareNotEqual,
+ SN_LoadAlignedVector128,
+ SN_LoadVector128,
+ SN_MoveMask,
+ SN_MoveScalar,
+ SN_Or,
+ SN_PackUnsignedSaturate,
+ SN_ShiftRightLogical,
+ SN_Shuffle,
+ SN_Store,
+ SN_StoreAligned,
+ SN_StoreScalar,
+ SN_Subtract,
+ SN_UnpackHigh,
+ SN_UnpackLow,
+ SN_Xor,
+ SN_get_IsSupported
+};
+
+static guint16 ssse3_methods [] = {
+ SN_Shuffle,
+ SN_get_IsSupported
+};
+
+static guint16 sse3_methods [] = {
+ SN_MoveAndDuplicate,
+ SN_get_IsSupported
+};
+
+static guint16 sse41_methods [] = {
+ SN_Insert,
+ SN_Max,
+ SN_Min,
+ SN_TestZ,
+ SN_get_IsSupported
+};
+
static guint16 popcnt_methods [] = {
SN_PopCount,
SN_get_IsSupported
static MonoInst*
emit_x86_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
{
- const char *class_name;
- const char *class_ns;
MonoInst *ins;
int id;
gboolean supported, is_64bit;
MonoClass *klass = cmethod->klass;
+ MonoTypeEnum arg0_type = fsig->param_count > 0 ? get_underlying_type (fsig->params [0]) : MONO_TYPE_VOID;
+
+ if (is_hw_intrinsics_class (klass, "Sse", &is_64bit)) {
+ if (!COMPILE_LLVM (cfg))
+ return NULL;
+ id = lookup_intrins (sse_methods, sizeof (sse_methods), cmethod);
+ if (id == -1)
+ return NULL;
+
+ supported = (mini_get_cpu_features (cfg) & MONO_CPU_X86_SSE) != 0 &&
+ m_class_get_image (cfg->method->klass) == mono_get_corlib (); // We only support the subset used by corelib
+
+ switch (id) {
+ case SN_get_IsSupported:
+ EMIT_NEW_ICONST (cfg, ins, supported ? 1 : 0);
+ ins->type = STACK_I4;
+ return ins;
+ case SN_LoadAlignedVector128:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_LOADU, 16 /*alignment*/, arg0_type, fsig, args);
+ case SN_LoadVector128:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_LOADU, 1 /*alignment*/, arg0_type, fsig, args);
+ case SN_MoveMask:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_MOVMSK, -1, arg0_type, fsig, args);
+ case SN_MoveScalar:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_MOVS2, -1, arg0_type, fsig, args);
+ case SN_CompareNotEqual:
+ return emit_simd_ins_for_sig (cfg, klass, OP_XCOMPARE_FP, CMP_NE, arg0_type, fsig, args);
+ case SN_CompareEqual:
+ return emit_simd_ins_for_sig (cfg, klass, OP_XCOMPARE_FP, CMP_EQ, arg0_type, fsig, args);
+ case SN_And:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_AND, -1, arg0_type, fsig, args);
+ case SN_AndNot:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_ANDN, -1, arg0_type, fsig, args);
+ case SN_Or:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_OR, -1, arg0_type, fsig, args);
+ case SN_Xor:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_XOR, -1, arg0_type, fsig, args);
+ case SN_Multiply:
+ return emit_simd_ins_for_sig (cfg, klass, OP_XBINOP, OP_FMUL, arg0_type, fsig, args);
+ case SN_Divide:
+ return emit_simd_ins_for_sig (cfg, klass, OP_XBINOP, OP_FDIV, arg0_type, fsig, args);
+ case SN_Add:
+ return emit_simd_ins_for_sig (cfg, klass, OP_XBINOP, OP_FADD, arg0_type, fsig, args);
+ case SN_Subtract:
+ return emit_simd_ins_for_sig (cfg, klass, OP_XBINOP, OP_FSUB, arg0_type, fsig, args);
+ case SN_Shuffle: {
+ if (args [2]->opcode != OP_ICONST) {
+ mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);
+ mono_error_set_generic_error (cfg->error, "System",
+ "InvalidOperationException", "mask in Sse.Shuffle must be constant.");
+ return NULL;
+ }
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_SHUFFLE, args [2]->inst_c0 /*mask*/, arg0_type, fsig, args);
+ }
+ case SN_MoveHighToLow:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_MOVEHL, -1, arg0_type, fsig, args);
+ case SN_MoveLowToHigh:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_MOVELH, -1, arg0_type, fsig, args);
+ case SN_UnpackLow:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_UNPACKLO, -1, arg0_type, fsig, args);
+ case SN_UnpackHigh:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_UNPACKHI, -1, arg0_type, fsig, args);
+ case SN_Store:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_STORE, 1 /*alignment*/, arg0_type, fsig, args);
+ case SN_StoreAligned:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_STORE, 16 /*alignment*/, arg0_type, fsig, args);
+ default:
+ return NULL;
+ }
+ }
+
+ if (is_hw_intrinsics_class (klass, "Sse2", &is_64bit)) {
+ if (!COMPILE_LLVM (cfg))
+ return NULL;
+ id = lookup_intrins (sse2_methods, sizeof (sse2_methods), cmethod);
+ if (id == -1)
+ return NULL;
+
+ supported = (mini_get_cpu_features (cfg) & MONO_CPU_X86_SSE2) != 0 &&
+ m_class_get_image (cfg->method->klass) == mono_get_corlib (); // We only support the subset used by corelib
+
+ switch (id) {
+ case SN_get_IsSupported: {
+ EMIT_NEW_ICONST (cfg, ins, supported ? 1 : 0);
+ ins->type = STACK_I4;
+ return ins;
+ }
+ case SN_Subtract:
+ return emit_simd_ins_for_sig (cfg, klass, OP_XBINOP, arg0_type == MONO_TYPE_R8 ? OP_FSUB : OP_ISUB, arg0_type, fsig, args);
+ case SN_Add:
+ return emit_simd_ins_for_sig (cfg, klass, OP_XBINOP, arg0_type == MONO_TYPE_R8 ? OP_FADD : OP_IADD, arg0_type, fsig, args);
+ case SN_And:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_AND, -1, arg0_type, fsig, args);
+ case SN_AndNot:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_ANDN, -1, arg0_type, fsig, args);
+ case SN_CompareNotEqual:
+ return emit_simd_ins_for_sig (cfg, klass, arg0_type == MONO_TYPE_R8 ? OP_XCOMPARE_FP : OP_XCOMPARE, CMP_NE, arg0_type, fsig, args);
+ case SN_CompareEqual:
+ return emit_simd_ins_for_sig (cfg, klass, arg0_type == MONO_TYPE_R8 ? OP_XCOMPARE_FP : OP_XCOMPARE, CMP_EQ, arg0_type, fsig, args);
+ case SN_CompareGreaterThan:
+ return emit_simd_ins_for_sig (cfg, klass, arg0_type == MONO_TYPE_R8 ? OP_XCOMPARE_FP : OP_XCOMPARE, CMP_GT, arg0_type, fsig, args);
+ case SN_CompareLessThan:
+ return emit_simd_ins_for_sig (cfg, klass, arg0_type == MONO_TYPE_R8 ? OP_XCOMPARE_FP : OP_XCOMPARE, CMP_LT, arg0_type, fsig, args);
+ case SN_LoadAlignedVector128:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_LOADU, 16 /*alignment*/, arg0_type, fsig, args);
+ case SN_LoadVector128:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_LOADU, 1 /*alignment*/, arg0_type, fsig, args);
+ case SN_MoveMask:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_MOVMSK, -1, arg0_type, fsig, args);
+ case SN_MoveScalar:
+ return emit_simd_ins_for_sig (cfg, klass, fsig->param_count == 2 ? OP_SSE_MOVS2 : OP_SSE_MOVS, -1, arg0_type, fsig, args);
+ case SN_PackUnsignedSaturate:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE2_PACKUS, -1, arg0_type, fsig, args);
+ case SN_ShiftRightLogical: {
+ if (arg0_type != MONO_TYPE_U2 || fsig->params [1]->type != MONO_TYPE_U1)
+ return NULL; // TODO: implement other overloads
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE2_SRLI, -1, arg0_type, fsig, args);
+ }
+ case SN_Shuffle: {
+ if ((arg0_type == MONO_TYPE_R8 && args [2]->opcode != OP_ICONST) ||
+ (arg0_type != MONO_TYPE_R8 && args [1]->opcode != OP_ICONST)) {
+ mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);
+ mono_error_set_generic_error (cfg->error, "System", "InvalidOperationException",
+ "mask in Sse2.Shuffle must be constant.");
+ return NULL;
+ }
+ ins = emit_simd_ins_for_sig (cfg, klass, OP_SSE2_SHUFFLE, -1, arg0_type, fsig, args);
+ ins->sreg3 = -1; // last arg is always a constant mask
+ if (arg0_type == MONO_TYPE_R8) { // "double" overload accepts two vectors
+ ins->sreg2 = args [1]->dreg;
+ ins->inst_c0 = args [2]->inst_c0; // mask
+ } else {
+ ins->sreg2 = args [0]->dreg;
+ ins->inst_c0 = args [1]->inst_c0; // mask
+ }
+ return ins;
+ }
+ case SN_Store:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_STORE, 1 /*alignment*/, arg0_type, fsig, args);
+ case SN_StoreAligned:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_STORE, 16 /*alignment*/, arg0_type, fsig, args);
+ case SN_StoreScalar:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_STORES, -1, arg0_type, fsig, args);
+ case SN_UnpackLow:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_UNPACKLO, -1, arg0_type, fsig, args);
+ case SN_UnpackHigh:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_UNPACKHI, -1, arg0_type, fsig, args);
+ case SN_Or:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_OR, -1, arg0_type, fsig, args);
+ case SN_Xor:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE_XOR, -1, arg0_type, fsig, args);
+ default:
+ return NULL;
+ }
+ }
+
+ if (is_hw_intrinsics_class (klass, "Sse3", &is_64bit)) {
+ if (!COMPILE_LLVM (cfg))
+ return NULL;
+ id = lookup_intrins (sse3_methods, sizeof (sse3_methods), cmethod);
+ if (id == -1)
+ return NULL;
+
+ supported = (mini_get_cpu_features (cfg) & MONO_CPU_X86_SSE3) != 0 &&
+ m_class_get_image (cfg->method->klass) == mono_get_corlib (); // We only support the subset used by corelib
- class_ns = m_class_get_name_space (klass);
- class_name = m_class_get_name (klass);
- if (!strcmp (class_name, "Popcnt") || (!strcmp (class_name, "X64") && cmethod->klass->nested_in && !strcmp (m_class_get_name (cmethod->klass->nested_in), "Popcnt"))) {
+ switch (id) {
+ case SN_get_IsSupported:
+ EMIT_NEW_ICONST (cfg, ins, supported ? 1 : 0);
+ ins->type = STACK_I4;
+ return ins;
+ case SN_MoveAndDuplicate:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE3_MOVDDUP, -1, arg0_type, fsig, args);
+ default:
+ return NULL;
+ }
+ }
+
+ if (is_hw_intrinsics_class (klass, "Ssse3", &is_64bit)) {
+ if (!COMPILE_LLVM (cfg))
+ return NULL;
+ id = lookup_intrins (ssse3_methods, sizeof (ssse3_methods), cmethod);
+ if (id == -1)
+ return NULL;
+
+ supported = (mini_get_cpu_features (cfg) & MONO_CPU_X86_SSSE3) != 0 &&
+ m_class_get_image (cfg->method->klass) == mono_get_corlib (); // We only support the subset used by corelib
+
+ switch (id) {
+ case SN_get_IsSupported:
+ EMIT_NEW_ICONST (cfg, ins, supported ? 1 : 0);
+ ins->type = STACK_I4;
+ return ins;
+ case SN_Shuffle:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSSE3_SHUFFLE, -1, arg0_type, fsig, args);
+ default:
+ return NULL;
+ }
+ }
+
+ if (is_hw_intrinsics_class (klass, "Sse41", &is_64bit)) {
+ if (!COMPILE_LLVM (cfg))
+ return NULL;
+ id = lookup_intrins (sse41_methods, sizeof (sse41_methods), cmethod);
+ if (id == -1)
+ return NULL;
+
+ supported = COMPILE_LLVM (cfg) && (mini_get_cpu_features (cfg) & MONO_CPU_X86_SSE41) != 0 &&
+ m_class_get_image (cfg->method->klass) == mono_get_corlib (); // We only support the subset used by corelib
+
+ switch (id) {
+ case SN_get_IsSupported:
+ EMIT_NEW_ICONST (cfg, ins, supported ? 1 : 0);
+ ins->type = STACK_I4;
+ return ins;
+ case SN_Insert:
+ if (args [2]->opcode != OP_ICONST) {
+ mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);
+ mono_error_set_generic_error (cfg->error, "System",
+ "InvalidOperationException", "index in Sse41.Insert must be constant.");
+ return NULL;
+ }
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE41_INSERT, -1, arg0_type, fsig, args);
+ case SN_Max:
+ return emit_simd_ins_for_sig (cfg, klass, OP_XBINOP, OP_IMAX, arg0_type, fsig, args);
+ case SN_Min:
+ return emit_simd_ins_for_sig (cfg, klass, OP_XBINOP, OP_IMIN, arg0_type, fsig, args);
+ case SN_TestZ:
+ return emit_simd_ins_for_sig (cfg, klass, OP_SSE41_PTESTZ, -1, arg0_type, fsig, args);
+ default:
+ return NULL;
+ }
+ }
+
+ if (is_hw_intrinsics_class (klass, "Popcnt", &is_64bit)) {
id = lookup_intrins (popcnt_methods, sizeof (popcnt_methods), cmethod);
if (id == -1)
return NULL;
supported = (mini_get_cpu_features (cfg) & MONO_CPU_X86_POPCNT) != 0;
- is_64bit = !strcmp (class_name, "X64");
switch (id) {
case SN_get_IsSupported:
return NULL;
}
}
- if (!strcmp (class_name, "Lzcnt") || (!strcmp (class_name, "X64") && cmethod->klass->nested_in && !strcmp (m_class_get_name (cmethod->klass->nested_in), "Lzcnt"))) {
+ if (is_hw_intrinsics_class (klass, "Lzcnt", &is_64bit)) {
id = lookup_intrins (lzcnt_methods, sizeof (lzcnt_methods), cmethod);
if (id == -1)
return NULL;
supported = (mini_get_cpu_features (cfg) & MONO_CPU_X86_LZCNT) != 0;
- is_64bit = !strcmp (class_name, "X64");
switch (id) {
case SN_get_IsSupported:
return NULL;
}
}
- if (!strcmp (class_name, "Bmi1") || (!strcmp (class_name, "X64") && cmethod->klass->nested_in && !strcmp (m_class_get_name (cmethod->klass->nested_in), "Bmi1"))) {
+ if (is_hw_intrinsics_class (klass, "Bmi1", &is_64bit)) {
if (!COMPILE_LLVM (cfg))
return NULL;
id = lookup_intrins (bmi1_methods, sizeof (bmi1_methods), cmethod);
g_assert (id != -1);
supported = (mini_get_cpu_features (cfg) & MONO_CPU_X86_BMI1) != 0;
- is_64bit = !strcmp (class_name, "X64");
switch (id) {
case SN_get_IsSupported:
g_assert_not_reached ();
}
}
- if (!strcmp (class_name, "Bmi2") || (!strcmp (class_name, "X64") && cmethod->klass->nested_in && !strcmp (m_class_get_name (cmethod->klass->nested_in), "Bmi2"))) {
+ if (is_hw_intrinsics_class (klass, "Bmi2", &is_64bit)) {
if (!COMPILE_LLVM (cfg))
return NULL;
id = lookup_intrins (bmi2_methods, sizeof (bmi2_methods), cmethod);
g_assert (id != -1);
supported = (mini_get_cpu_features (cfg) & MONO_CPU_X86_BMI2) != 0;
- is_64bit = !strcmp (class_name, "X64");
switch (id) {
case SN_get_IsSupported:
}
#endif
+static guint16 vector_128_methods [] = {
+ SN_AsByte,
+ SN_AsDouble,
+ SN_AsInt16,
+ SN_AsInt32,
+ SN_AsInt64,
+ SN_AsSByte,
+ SN_AsSingle,
+ SN_AsUInt16,
+ SN_AsUInt32,
+ SN_AsUInt64,
+ SN_Create,
+ SN_CreateScalarUnsafe,
+};
+
static guint16 vector_128_t_methods [] = {
SN_get_Count,
+ SN_get_Zero,
};
static MonoInst*
+emit_vector128 (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
+{
+ MonoInst *ins;
+ MonoType *type, *etype;
+ MonoClass *klass;
+ int id;
+
+ if (!COMPILE_LLVM (cfg))
+ return NULL;
+
+ klass = cmethod->klass;
+ id = lookup_intrins (vector_128_methods, sizeof (vector_128_methods), cmethod);
+ if (id == -1)
+ return NULL;
+
+ if (!strcmp (m_class_get_name (cfg->method->klass), "Vector256"))
+ return NULL; // TODO: Fix Vector256.WithUpper/WithLower
+
+ MonoTypeEnum arg0_type = fsig->param_count > 0 ? get_underlying_type (fsig->params [0]) : MONO_TYPE_VOID;
+
+ switch (id) {
+ case SN_AsByte:
+ case SN_AsDouble:
+ case SN_AsInt16:
+ case SN_AsInt32:
+ case SN_AsInt64:
+ case SN_AsSByte:
+ case SN_AsSingle:
+ case SN_AsUInt16:
+ case SN_AsUInt32:
+ case SN_AsUInt64:
+ return emit_simd_ins (cfg, klass, OP_XCAST, args [0]->dreg, -1);
+ case SN_Create: {
+ MonoType *etype = get_vector_t_elem_type (fsig->ret);
+ if (fsig->param_count == 1 && mono_metadata_type_equal (fsig->params [0], etype)) {
+ return emit_simd_ins (cfg, klass, type_to_expand_op (etype), args [0]->dreg, -1);
+ } else {
+ // TODO: Optimize Create(a1, a2, a3 ...) overloads
+ break;
+ }
+ }
+ case SN_CreateScalarUnsafe:
+ return emit_simd_ins_for_sig (cfg, klass, OP_CREATE_SCALAR_UNSAFE, -1, arg0_type, fsig, args);
+ default:
+ break;
+ }
+
+ return NULL;
+}
+
+static MonoInst*
emit_vector128_t (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
{
MonoInst *ins;
break;
EMIT_NEW_ICONST (cfg, ins, len);
return ins;
+ case SN_get_Zero: {
+ return emit_simd_ins (cfg, klass, OP_XZERO, -1, -1);
+ }
default:
break;
}
if (!strcmp (class_ns, "System.Runtime.Intrinsics")) {
if (!strcmp (class_name, "Vector128`1"))
return emit_vector128_t (cfg, cmethod, fsig, args);
+ if (!strcmp (class_name, "Vector128"))
+ return emit_vector128 (cfg, cmethod, fsig, args);
if (!strcmp (class_name, "Vector256`1"))
return emit_vector256_t (cfg, cmethod, fsig, args);
}
METHOD(ConvertToDouble)
METHOD(Narrow)
METHOD(Widen)
-// BMI1
+// Vector128
+METHOD(AsByte)
+METHOD(AsDouble)
+METHOD(AsInt16)
+METHOD(AsInt32)
+METHOD(AsInt64)
+METHOD(AsSByte)
+METHOD(AsSingle)
+METHOD(AsUInt16)
+METHOD(AsUInt32)
+METHOD(AsUInt64)
+METHOD(Create)
+METHOD(CreateScalarUnsafe)
+// Bmi1
METHOD(AndNot)
METHOD(BitFieldExtract)
METHOD(ExtractLowestSetBit)
METHOD(GetMaskUpToLowestSetBit)
METHOD(ResetLowestSetBit)
METHOD(TrailingZeroCount)
-// BMI2
+// Bmi2
METHOD(ZeroHighBits)
METHOD(MultiplyNoFlags)
METHOD(ParallelBitDeposit)
METHOD(ParallelBitExtract)
+// Sse
+METHOD(Add)
+METHOD(CompareNotEqual)
+METHOD(Divide)
+METHOD(Store)
+METHOD(Subtract)
+METHOD(CompareEqual)
+METHOD(LoadVector128)
+METHOD(MoveHighToLow)
+METHOD(MoveLowToHigh)
+METHOD(MoveMask)
+METHOD(MoveScalar)
+METHOD(Multiply)
+METHOD(Shuffle)
+METHOD(UnpackHigh)
+METHOD(UnpackLow)
+// Sse2
+METHOD(And)
+METHOD(Or)
+METHOD(LoadAlignedVector128)
+METHOD(Xor)
+METHOD(CompareGreaterThan)
+METHOD(PackUnsignedSaturate)
+METHOD(StoreScalar)
+METHOD(StoreAligned)
+METHOD(ShiftRightLogical)
+METHOD(CompareLessThan)
+// Sse3
+METHOD(MoveAndDuplicate)
+// Sse41
+METHOD(Insert)
+METHOD(TestZ)
\ No newline at end of file
echo "Failed: $$failures"
endif
+run-tests-mono: prepare
+ failures=0; \
+ counter=0; \
+ test_prj_dir=''; \
+ test_prj_name=''; \
+ test_projects=$$(find tests -type f -name "*.csproj"); \
+ for test_prj in $$test_projects; do \
+ counter=$$((counter+1)); \
+ echo "Running $$test_prj_dir"; \
+ test_prj_dir=$$(dirname $$test_prj); \
+ test_prj_name=$$(basename $$test_prj); \
+ test_prj_name=$${test_prj_name%.*}; \
+ $(DOTNET) build -c Release $$test_prj; \
+ MONO_ENV_OPTIONS="--debug $(MONO_ENV_OPTIONS)" COMPlus_DebugWriteToStdErr=1 ./dotnet --fx-version "$(NETCOREAPP_VERSION)" $$test_prj_dir/bin/netcoreapp3.0/$$test_prj_name.dll; \
+ if [ $$? -ne 0 ]; then \
+ failures=$$((failures+1)); \
+ fi; \
+ done; \
+ echo "======================"; \
+ echo "Tests Count: $$counter"; \
+ echo "Failed: $$failures"
+
run-tests-coreclr-%: prepare update-tests-coreclr
@echo ""
@echo "***************** $* *********************"
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+ <Optimize>True</Optimize>
+ <DebugType>Full</DebugType>
+ <OutputPath>bin</OutputPath>
+ <TargetFramework>netcoreapp3.0</TargetFramework>
+ <EnableSourceControlManagerQueries>false</EnableSourceControlManagerQueries>
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+</Project>
--- /dev/null
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+using System.Text;
+
+class HWIntrinsicsTests
+{
+ static void Main ()
+ {
+ bool generateReferenceData = false; // enable to update SRI-reference-data.txt (e.g. on CoreCLR for Mono)
+ int failures = 0;
+ string refDataFile = Path.Combine (Path.GetDirectoryName (Assembly.GetExecutingAssembly ().Location), "../../SRI-reference-data.txt");
+ string [] refData = null;
+
+ if (generateReferenceData)
+ File.Delete (refDataFile);
+ else
+ refData = File.ReadAllLines (refDataFile);
+
+ int sse1Methods = typeof (Sse).GetMethods ().Length;
+ int sse2Methods = typeof (Sse2).GetMethods ().Length;
+ int sse3Methods = typeof (Sse3).GetMethods ().Length;
+ int ssse3Methods = typeof (Ssse3).GetMethods ().Length;
+ int sse41Methods = typeof (Sse41).GetMethods ().Length;
+ int sse42Methods = typeof (Sse42).GetMethods ().Length;
+
+ Console.WriteLine ($"Sse: {sse1Methods} methods");
+ Console.WriteLine ($"Sse2: {sse2Methods} methods");
+ Console.WriteLine ($"Sse3: {sse3Methods} methods");
+ Console.WriteLine ($"Ssse3: {ssse3Methods} methods");
+ Console.WriteLine ($"Sse41: {sse41Methods} methods");
+ Console.WriteLine ($"Sse42: {sse42Methods} methods");
+ Console.WriteLine ();
+
+ if (sse1Methods != 92)
+ throw new Exception ("New changes in Sse (don't forget to update simd-intrinsics-netcore.c if necessary)");
+ if (sse2Methods != 302)
+ throw new Exception ("New changes in Sse2 (don't forget to update simd-intrinsics-netcore.c if necessary)");
+ if (sse3Methods != 23)
+ throw new Exception ("New changes in Sse3 (don't forget to update simd-intrinsics-netcore.c if necessary)");
+ if (ssse3Methods != 29)
+ throw new Exception ("New changes in Ssse3 (don't forget to update simd-intrinsics-netcore.c if necessary)");
+ if (sse41Methods != 144)
+ throw new Exception ("New changes in Sse41 (don't forget to update simd-intrinsics-netcore.c if necessary)");
+ if (sse42Methods != 9)
+ throw new Exception ("New changes in Sse42 (don't forget to update simd-intrinsics-netcore.c if necessary)");
+
+ int skipped = 0;
+ var tests = new SseTests ();
+ foreach (var method in typeof (SseTests).GetMethods ()
+ .OrderBy (m => m.Name) // TODO: the default order is different in Mono
+ .Where (m => m.GetParameters ().Length == 0 && m.DeclaringType == typeof (SseTests)))
+ {
+ try
+ {
+ // clear test data each iteration
+ tests.ReloadArrays ();
+ var obj = method.Invoke (tests, null);
+ string array2Data = tests.GetArray2Data ();
+ string actualResult = $"{method.Name}: {obj}. array2: ({array2Data})\n";
+ if (generateReferenceData)
+ {
+ File.AppendAllText (refDataFile, actualResult);
+ }
+ else
+ {
+ var expectedResult = refData.FirstOrDefault (l => l.StartsWith (method.Name));
+ if (expectedResult.Trim ('\r', '\n', ' ') != actualResult.Trim ('\r', '\n', ' '))
+ {
+ Console.WriteLine ($"[FAIL] Expected: {expectedResult}, Actual: {actualResult}");
+ failures++;
+ }
+ }
+ }
+ catch (TargetInvocationException e)
+ {
+ if (e.GetBaseException () is PlatformNotSupportedException) // Not supported by Mono yet
+ {
+ skipped++;
+ continue;
+ }
+ throw;
+ }
+ }
+
+ Console.WriteLine ();
+ Console.WriteLine ("Skipped: " + skipped);
+ Console.WriteLine ("Done.");
+
+ if (failures != 0)
+ throw new Exception ("Test failed.");
+ }
+}
+
+public unsafe class SseTests
+{
+ Random rand = new Random (42);
+ float* pArray1Float = null;
+ float* pArray2Float = null;
+ double* pArray1Double = null;
+ double* pArray2Double = null;
+ byte* pArray1 = null;
+ byte* pArray2 = null;
+
+ // some SRI methods require memory to be aligned to 16bytes boundary (in case of Vector128)
+ static T* AllocateAligned<T> (int elements) where T : unmanaged
+ {
+ IntPtr ptr = Marshal.AllocHGlobal (elements * sizeof (T) + 15);
+ return (T*)(16 * (((long)ptr + 15) / 16));
+ }
+
+ public void ReloadArrays ()
+ {
+ if (pArray1Float == null)
+ {
+ pArray1Float = AllocateAligned<float> (4);
+ pArray2Float = AllocateAligned<float> (4);
+ pArray1Double = AllocateAligned<double> (2);
+ pArray2Double = AllocateAligned<double> (2);
+ pArray1 = AllocateAligned<byte> (16);
+ pArray2 = AllocateAligned<byte> (16);
+ }
+
+ for (byte i = 0; i < 16; i++)
+ {
+ pArray1 [i] = i;
+ pArray2 [i] = 0;
+ }
+
+ for (int i = 0; i < 4; i++)
+ {
+ pArray1Float [i] = i / 2f;
+ pArray2Float [i] = 0;
+ }
+
+ for (int i = 0; i < 2; i++)
+ {
+ pArray1Double [i] = i / 3f;
+ pArray2Double [i] = 0;
+ }
+ }
+
+ private bool IsEmpty<T> (T* array) where T : unmanaged
+ {
+ for (var i = 0; i < Vector128<T>.Count; i++)
+ {
+ var item = array [i];
+ if (item is float f && f != 0.0f)
+ return false;
+ if (item is double d && d != 0.0f)
+ return false;
+ if (item is byte b && b != 0)
+ return false;
+ }
+ return true;
+ }
+
+ private string PrintArray<T> (T* array) where T : unmanaged
+ {
+ var sb = new StringBuilder ();
+ sb.Append ("<");
+ for (var i = 0; i < Vector128<T>.Count; i++)
+ sb.Append (array [i]).Append (", ");
+ sb.Append (">");
+ return sb.ToString ().Replace (", >", ">");
+ }
+
+ public string GetArray2Data ()
+ {
+ if (!IsEmpty (pArray2))
+ return PrintArray (pArray2);
+ if (!IsEmpty (pArray2Float))
+ return PrintArray (pArray2Float);
+ if (!IsEmpty (pArray2Double))
+ return PrintArray (pArray2Double);
+ return "";
+ }
+
+ [MethodImpl (MethodImplOptions.NoInlining)]
+ Vector128<T> GetV128<T> () where T : unmanaged
+ {
+ int randMult = 1;
+ int rand0_10 = rand.Next (0, 11);
+ if (rand0_10 % 3 == 0)
+ randMult = -1;
+ else if (rand0_10 > 8)
+ randMult = 0;
+
+ if (typeof(T) == typeof (float))
+ {
+ return Vector128.Create (
+ (float)(rand.Next () * randMult) / 2.0f,
+ (float)(rand.Next () * randMult) / 3.0f,
+ (float)(rand.Next () * randMult) / 4.0f,
+ (float)(rand.Next () * randMult) / 5.0f).As<float, T> ();
+ }
+ else if (typeof(T) == typeof (double))
+ {
+ return Vector128.Create (
+ (double)(rand.Next () * randMult),
+ (double)(rand.Next () * randMult)).As<double, T> ();
+ }
+
+ return Vector128.Create (
+ rand.Next (0, int.MaxValue) * randMult,
+ rand.Next (0, int.MaxValue) * randMult,
+ rand.Next (0, int.MaxValue) * randMult,
+ rand.Next (0, int.MaxValue) * randMult).As<int, T> ();
+ }
+
+ T Get<T> ()
+ {
+ int randMult = 1;
+ int rand0_10 = rand.Next (0, 11);
+ if (rand0_10 % 3 == 0)
+ randMult = -1;
+ else if (rand0_10 > 8)
+ randMult = 0;
+
+ if (typeof (T) == typeof (float))
+ return (T)(object)(float)((rand.Next() * randMult) / 2.0f);
+ if (typeof (T) == typeof (double))
+ return (T)(object)(double)((rand.Next() * randMult) / 2.0);
+ if (typeof (T) == typeof (byte))
+ return (T)(object)(byte)((rand.Next (byte.MinValue, byte.MaxValue + 1)));
+ if (typeof (T) == typeof (sbyte))
+ return (T)(object)(sbyte)((rand.Next (sbyte.MinValue, sbyte.MaxValue + 1)));
+ if (typeof (T) == typeof (short))
+ return (T)(object)(short)((rand.Next (short.MinValue, short.MaxValue + 1)));
+ if (typeof (T) == typeof (ushort))
+ return (T)(object)(ushort)((rand.Next (ushort.MinValue, ushort.MaxValue + 1)));
+ if (typeof (T) == typeof (int))
+ return (T)(object)(int)((rand.Next (int.MinValue, int.MaxValue)));
+ if (typeof (T) == typeof (uint))
+ return (T)(object)(uint)((rand.Next (int.MinValue, int.MaxValue)));
+ if (typeof (T) == typeof (long))
+ return (T)(object)(long)((rand.Next (int.MinValue, int.MaxValue)));
+ if (typeof (T) == typeof (ulong))
+ return (T)(object)(ulong)((rand.Next (int.MinValue, int.MaxValue)));
+ throw new NotSupportedException ();
+ }
+
+ public Vector128<Single> Sse_Add_0() => Sse.Add(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_AddScalar_1() => Sse.AddScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_And_2() => Sse.And(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_AndNot_3() => Sse.AndNot(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareEqual_4() => Sse.CompareEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareGreaterThan_5() => Sse.CompareGreaterThan(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareGreaterThanOrEqual_6() => Sse.CompareGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareLessThan_7() => Sse.CompareLessThan(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareLessThanOrEqual_8() => Sse.CompareLessThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareNotEqual_9() => Sse.CompareNotEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareNotGreaterThan_10() => Sse.CompareNotGreaterThan(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareNotGreaterThanOrEqual_11() => Sse.CompareNotGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareNotLessThan_12() => Sse.CompareNotLessThan(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareNotLessThanOrEqual_13() => Sse.CompareNotLessThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareOrdered_14() => Sse.CompareOrdered(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarEqual_15() => Sse.CompareScalarEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarGreaterThan_16() => Sse.CompareScalarGreaterThan(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarGreaterThanOrEqual_17() => Sse.CompareScalarGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarLessThan_18() => Sse.CompareScalarLessThan(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarLessThanOrEqual_19() => Sse.CompareScalarLessThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarNotEqual_20() => Sse.CompareScalarNotEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarNotGreaterThan_21() => Sse.CompareScalarNotGreaterThan(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarNotGreaterThanOrEqual_22() => Sse.CompareScalarNotGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarNotLessThan_23() => Sse.CompareScalarNotLessThan(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarNotLessThanOrEqual_24() => Sse.CompareScalarNotLessThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarOrdered_25() => Sse.CompareScalarOrdered(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarOrderedEqual_26() => Sse.CompareScalarOrderedEqual(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarOrderedGreaterThan_27() => Sse.CompareScalarOrderedGreaterThan(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarOrderedGreaterThanOrEqual_28() => Sse.CompareScalarOrderedGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarOrderedLessThan_29() => Sse.CompareScalarOrderedLessThan(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarOrderedLessThanOrEqual_30() => Sse.CompareScalarOrderedLessThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarOrderedNotEqual_31() => Sse.CompareScalarOrderedNotEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareScalarUnordered_32() => Sse.CompareScalarUnordered(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarUnorderedEqual_33() => Sse.CompareScalarUnorderedEqual(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarUnorderedGreaterThan_34() => Sse.CompareScalarUnorderedGreaterThan(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarUnorderedGreaterThanOrEqual_35() => Sse.CompareScalarUnorderedGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarUnorderedLessThan_36() => Sse.CompareScalarUnorderedLessThan(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarUnorderedLessThanOrEqual_37() => Sse.CompareScalarUnorderedLessThanOrEqual(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse_CompareScalarUnorderedNotEqual_38() => Sse.CompareScalarUnorderedNotEqual(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_CompareUnordered_39() => Sse.CompareUnordered(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_ConvertScalarToVector128Single_40() => Sse.ConvertScalarToVector128Single(GetV128<Single>(), Get<System.Int32>());
+ public Int32 Sse_ConvertToInt32_41() => Sse.ConvertToInt32(GetV128<Single>());
+ public Int32 Sse_ConvertToInt32WithTruncation_42() => Sse.ConvertToInt32WithTruncation(GetV128<Single>());
+ public Vector128<Single> Sse_Divide_43() => Sse.Divide(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_DivideScalar_44() => Sse.DivideScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_LoadAlignedVector128_46() => Sse.LoadAlignedVector128((pArray1Float));
+ public Vector128<Single> Sse_LoadHigh_47() => Sse.LoadHigh(GetV128<Single>(), pArray1Float);
+ public Vector128<Single> Sse_LoadLow_48() => Sse.LoadLow(GetV128<Single>(), pArray1Float);
+ public Vector128<Single> Sse_LoadScalarVector128_49() => Sse.LoadScalarVector128(pArray1Float);
+ public Vector128<Single> Sse_LoadVector128_50() => Sse.LoadVector128(pArray1Float);
+ public Vector128<Single> Sse_Max_51() => Sse.Max(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_MaxScalar_52() => Sse.MaxScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_Min_53() => Sse.Min(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_MinScalar_54() => Sse.MinScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_MoveHighToLow_55() => Sse.MoveHighToLow(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_MoveLowToHigh_56() => Sse.MoveLowToHigh(GetV128<Single>(), GetV128<Single>());
+ public Int32 Sse_MoveMask_57() => Sse.MoveMask(GetV128<Single>());
+ public Vector128<Single> Sse_MoveScalar_58() => Sse.MoveScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_Multiply_59() => Sse.Multiply(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_MultiplyScalar_60() => Sse.MultiplyScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_Or_61() => Sse.Or(GetV128<Single>(), GetV128<Single>());
+ public void Sse_Prefetch0_62() => Sse.Prefetch0(pArray1);
+ public void Sse_Prefetch1_63() => Sse.Prefetch1(pArray1);
+ public void Sse_Prefetch2_64() => Sse.Prefetch2(pArray1);
+ public void Sse_PrefetchNonTemporal_65() => Sse.PrefetchNonTemporal(pArray1);
+ public Vector128<Single> Sse_Reciprocal_66() => Sse.Reciprocal(GetV128<Single>());
+ public Vector128<Single> Sse_ReciprocalScalar_67() => Sse.ReciprocalScalar(GetV128<Single>());
+ public Vector128<Single> Sse_ReciprocalScalar_68() => Sse.ReciprocalScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_ReciprocalSqrt_69() => Sse.ReciprocalSqrt(GetV128<Single>());
+ public Vector128<Single> Sse_ReciprocalSqrtScalar_70() => Sse.ReciprocalSqrtScalar(GetV128<Single>());
+ public Vector128<Single> Sse_ReciprocalSqrtScalar_71() => Sse.ReciprocalSqrtScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_Shuffle_72() => Sse.Shuffle(GetV128<Single>(), GetV128<Single>(), 22);
+ public Vector128<Single> Sse_Sqrt_73() => Sse.Sqrt(GetV128<Single>());
+ public Vector128<Single> Sse_SqrtScalar_74() => Sse.SqrtScalar(GetV128<Single>());
+ public Vector128<Single> Sse_SqrtScalar_75() => Sse.SqrtScalar(GetV128<Single>(), GetV128<Single>());
+ public void Sse_Store_76() => Sse.Store(pArray2Float, GetV128<Single>());
+ public void Sse_StoreAligned_77() => Sse.StoreAligned((pArray2Float), GetV128<Single>());
+ public void Sse_StoreAlignedNonTemporal_78() => Sse.StoreAlignedNonTemporal((pArray2Float), GetV128<Single>());
+ public void Sse_StoreFence_79() => Sse.StoreFence();
+ public void Sse_StoreHigh_80() => Sse.StoreHigh(pArray2Float, GetV128<Single>());
+ public void Sse_StoreLow_81() => Sse.StoreLow(pArray2Float, GetV128<Single>());
+ public void Sse_StoreScalar_82() => Sse.StoreScalar(pArray2Float, GetV128<Single>());
+ public Vector128<Single> Sse_Subtract_83() => Sse.Subtract(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_SubtractScalar_84() => Sse.SubtractScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_UnpackHigh_85() => Sse.UnpackHigh(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_UnpackLow_86() => Sse.UnpackLow(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse_Xor_87() => Sse.Xor(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Byte> Sse2_Add_0() => Sse2.Add(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<SByte> Sse2_Add_1() => Sse2.Add(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_Add_2() => Sse2.Add(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_Add_3() => Sse2.Add(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_Add_4() => Sse2.Add(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_Add_5() => Sse2.Add(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse2_Add_6() => Sse2.Add(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse2_Add_7() => Sse2.Add(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Double> Sse2_Add_8() => Sse2.Add(GetV128<Double>(), GetV128<Double>());
+ public Vector128<SByte> Sse2_AddSaturate_9() => Sse2.AddSaturate(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Byte> Sse2_AddSaturate_10() => Sse2.AddSaturate(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<Int16> Sse2_AddSaturate_11() => Sse2.AddSaturate(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_AddSaturate_12() => Sse2.AddSaturate(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Double> Sse2_AddScalar_13() => Sse2.AddScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Byte> Sse2_And_14() => Sse2.And(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<SByte> Sse2_And_15() => Sse2.And(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_And_16() => Sse2.And(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_And_17() => Sse2.And(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_And_18() => Sse2.And(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_And_19() => Sse2.And(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse2_And_20() => Sse2.And(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse2_And_21() => Sse2.And(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Double> Sse2_And_22() => Sse2.And(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Byte> Sse2_AndNot_23() => Sse2.AndNot(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<SByte> Sse2_AndNot_24() => Sse2.AndNot(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_AndNot_25() => Sse2.AndNot(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_AndNot_26() => Sse2.AndNot(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_AndNot_27() => Sse2.AndNot(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_AndNot_28() => Sse2.AndNot(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse2_AndNot_29() => Sse2.AndNot(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse2_AndNot_30() => Sse2.AndNot(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Double> Sse2_AndNot_31() => Sse2.AndNot(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Byte> Sse2_Average_32() => Sse2.Average(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<UInt16> Sse2_Average_33() => Sse2.Average(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<SByte> Sse2_CompareEqual_34() => Sse2.CompareEqual(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Byte> Sse2_CompareEqual_35() => Sse2.CompareEqual(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<Int16> Sse2_CompareEqual_36() => Sse2.CompareEqual(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_CompareEqual_37() => Sse2.CompareEqual(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_CompareEqual_38() => Sse2.CompareEqual(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_CompareEqual_39() => Sse2.CompareEqual(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Double> Sse2_CompareEqual_40() => Sse2.CompareEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<SByte> Sse2_CompareGreaterThan_41() => Sse2.CompareGreaterThan(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_CompareGreaterThan_42() => Sse2.CompareGreaterThan(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int32> Sse2_CompareGreaterThan_43() => Sse2.CompareGreaterThan(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<Double> Sse2_CompareGreaterThan_44() => Sse2.CompareGreaterThan(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareGreaterThanOrEqual_45() => Sse2.CompareGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<SByte> Sse2_CompareLessThan_46() => Sse2.CompareLessThan(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_CompareLessThan_47() => Sse2.CompareLessThan(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int32> Sse2_CompareLessThan_48() => Sse2.CompareLessThan(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<Double> Sse2_CompareLessThan_49() => Sse2.CompareLessThan(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareLessThanOrEqual_50() => Sse2.CompareLessThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareNotEqual_51() => Sse2.CompareNotEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareNotGreaterThan_52() => Sse2.CompareNotGreaterThan(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareNotGreaterThanOrEqual_53() => Sse2.CompareNotGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareNotLessThan_54() => Sse2.CompareNotLessThan(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareNotLessThanOrEqual_55() => Sse2.CompareNotLessThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareOrdered_56() => Sse2.CompareOrdered(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarEqual_57() => Sse2.CompareScalarEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarGreaterThan_58() => Sse2.CompareScalarGreaterThan(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarGreaterThanOrEqual_59() => Sse2.CompareScalarGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarLessThan_60() => Sse2.CompareScalarLessThan(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarLessThanOrEqual_61() => Sse2.CompareScalarLessThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarNotEqual_62() => Sse2.CompareScalarNotEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarNotGreaterThan_63() => Sse2.CompareScalarNotGreaterThan(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarNotGreaterThanOrEqual_64() => Sse2.CompareScalarNotGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarNotLessThan_65() => Sse2.CompareScalarNotLessThan(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarNotLessThanOrEqual_66() => Sse2.CompareScalarNotLessThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarOrdered_67() => Sse2.CompareScalarOrdered(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarOrderedEqual_68() => Sse2.CompareScalarOrderedEqual(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarOrderedGreaterThan_69() => Sse2.CompareScalarOrderedGreaterThan(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarOrderedGreaterThanOrEqual_70() => Sse2.CompareScalarOrderedGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarOrderedLessThan_71() => Sse2.CompareScalarOrderedLessThan(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarOrderedLessThanOrEqual_72() => Sse2.CompareScalarOrderedLessThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarOrderedNotEqual_73() => Sse2.CompareScalarOrderedNotEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareScalarUnordered_74() => Sse2.CompareScalarUnordered(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarUnorderedEqual_75() => Sse2.CompareScalarUnorderedEqual(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarUnorderedGreaterThan_76() => Sse2.CompareScalarUnorderedGreaterThan(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarUnorderedGreaterThanOrEqual_77() => Sse2.CompareScalarUnorderedGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarUnorderedLessThan_78() => Sse2.CompareScalarUnorderedLessThan(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarUnorderedLessThanOrEqual_79() => Sse2.CompareScalarUnorderedLessThanOrEqual(GetV128<Double>(), GetV128<Double>());
+ public Boolean Sse2_CompareScalarUnorderedNotEqual_80() => Sse2.CompareScalarUnorderedNotEqual(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_CompareUnordered_81() => Sse2.CompareUnordered(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_ConvertScalarToVector128Double_82() => Sse2.ConvertScalarToVector128Double(GetV128<Double>(), Get<System.Int32>());
+ public Vector128<Double> Sse2_ConvertScalarToVector128Double_83() => Sse2.ConvertScalarToVector128Double(GetV128<Double>(), GetV128<Single>());
+ public Vector128<Int32> Sse2_ConvertScalarToVector128Int32_84() => Sse2.ConvertScalarToVector128Int32(Get<System.Int32>());
+ public Vector128<Single> Sse2_ConvertScalarToVector128Single_85() => Sse2.ConvertScalarToVector128Single(GetV128<Single>(), GetV128<Double>());
+ public Vector128<UInt32> Sse2_ConvertScalarToVector128UInt32_86() => Sse2.ConvertScalarToVector128UInt32(Get<System.UInt32>());
+ public Int32 Sse2_ConvertToInt32_87() => Sse2.ConvertToInt32(GetV128<Double>());
+ public Int32 Sse2_ConvertToInt32_88() => Sse2.ConvertToInt32(GetV128<Int32>());
+ public Int32 Sse2_ConvertToInt32WithTruncation_89() => Sse2.ConvertToInt32WithTruncation(GetV128<Double>());
+ public UInt32 Sse2_ConvertToUInt32_90() => Sse2.ConvertToUInt32(GetV128<UInt32>());
+ public Vector128<Double> Sse2_ConvertToVector128Double_91() => Sse2.ConvertToVector128Double(GetV128<Int32>());
+ public Vector128<Double> Sse2_ConvertToVector128Double_92() => Sse2.ConvertToVector128Double(GetV128<Single>());
+ public Vector128<Int32> Sse2_ConvertToVector128Int32_93() => Sse2.ConvertToVector128Int32(GetV128<Single>());
+ public Vector128<Int32> Sse2_ConvertToVector128Int32_94() => Sse2.ConvertToVector128Int32(GetV128<Double>());
+ public Vector128<Int32> Sse2_ConvertToVector128Int32WithTruncation_95() => Sse2.ConvertToVector128Int32WithTruncation(GetV128<Single>());
+ public Vector128<Int32> Sse2_ConvertToVector128Int32WithTruncation_96() => Sse2.ConvertToVector128Int32WithTruncation(GetV128<Double>());
+ public Vector128<Single> Sse2_ConvertToVector128Single_97() => Sse2.ConvertToVector128Single(GetV128<Int32>());
+ public Vector128<Single> Sse2_ConvertToVector128Single_98() => Sse2.ConvertToVector128Single(GetV128<Double>());
+ public Vector128<Double> Sse2_Divide_99() => Sse2.Divide(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_DivideScalar_100() => Sse2.DivideScalar(GetV128<Double>(), GetV128<Double>());
+ public UInt16 Sse2_Extract_101() => Sse2.Extract(GetV128<UInt16>(), Get<System.Byte>());
+ public Vector128<Int16> Sse2_Insert_103() => Sse2.Insert(GetV128<Int16>(), Get<System.Int16>(), Get<System.Byte>());
+ public Vector128<UInt16> Sse2_Insert_104() => Sse2.Insert(GetV128<UInt16>(), Get<System.UInt16>(), Get<System.Byte>());
+ public Vector128<SByte> Sse2_LoadAlignedVector128_105() => Sse2.LoadAlignedVector128(((sbyte*)pArray1));
+ public Vector128<Byte> Sse2_LoadAlignedVector128_106() => Sse2.LoadAlignedVector128(((byte*)pArray1));
+ public Vector128<Int16> Sse2_LoadAlignedVector128_107() => Sse2.LoadAlignedVector128(((short*)pArray1));
+ public Vector128<UInt16> Sse2_LoadAlignedVector128_108() => Sse2.LoadAlignedVector128(((ushort*)pArray1));
+ public Vector128<Int32> Sse2_LoadAlignedVector128_109() => Sse2.LoadAlignedVector128(((int*)pArray1));
+ public Vector128<UInt32> Sse2_LoadAlignedVector128_110() => Sse2.LoadAlignedVector128(((uint*)pArray1));
+ public Vector128<Int64> Sse2_LoadAlignedVector128_111() => Sse2.LoadAlignedVector128(((long*)pArray1));
+ public Vector128<UInt64> Sse2_LoadAlignedVector128_112() => Sse2.LoadAlignedVector128(((ulong*)pArray1));
+ public Vector128<Double> Sse2_LoadAlignedVector128_113() => Sse2.LoadAlignedVector128((pArray1Double));
+ public void Sse2_LoadFence_114() => Sse2.LoadFence();
+ public Vector128<Double> Sse2_LoadHigh_115() => Sse2.LoadHigh(GetV128<Double>(), pArray1Double);
+ public Vector128<Double> Sse2_LoadLow_116() => Sse2.LoadLow(GetV128<Double>(), pArray1Double);
+ public Vector128<Double> Sse2_LoadScalarVector128_117() => Sse2.LoadScalarVector128(pArray1Double);
+ public Vector128<Int32> Sse2_LoadScalarVector128_118() => Sse2.LoadScalarVector128((int*)pArray1);
+ public Vector128<UInt32> Sse2_LoadScalarVector128_119() => Sse2.LoadScalarVector128((uint*)pArray1);
+ public Vector128<Int64> Sse2_LoadScalarVector128_120() => Sse2.LoadScalarVector128((long*)pArray1);
+ public Vector128<UInt64> Sse2_LoadScalarVector128_121() => Sse2.LoadScalarVector128((ulong*)pArray1);
+ public Vector128<SByte> Sse2_LoadVector128_122() => Sse2.LoadVector128((sbyte*)pArray1);
+ public Vector128<Byte> Sse2_LoadVector128_123() => Sse2.LoadVector128((byte*)pArray1);
+ public Vector128<Int16> Sse2_LoadVector128_124() => Sse2.LoadVector128((short*)pArray1);
+ public Vector128<UInt16> Sse2_LoadVector128_125() => Sse2.LoadVector128((ushort*)pArray1);
+ public Vector128<Int32> Sse2_LoadVector128_126() => Sse2.LoadVector128((int*)pArray1);
+ public Vector128<UInt32> Sse2_LoadVector128_127() => Sse2.LoadVector128((uint*)pArray1);
+ public Vector128<Int64> Sse2_LoadVector128_128() => Sse2.LoadVector128((long*)pArray1);
+ public Vector128<UInt64> Sse2_LoadVector128_129() => Sse2.LoadVector128((ulong*)pArray1);
+ public Vector128<Double> Sse2_LoadVector128_130() => Sse2.LoadVector128(pArray1Double);
+ public void Sse2_MaskMove_131() => Sse2.MaskMove(GetV128<SByte>(), GetV128<SByte>(), (sbyte*)pArray1);
+ public void Sse2_MaskMove_132() => Sse2.MaskMove(GetV128<Byte>(), GetV128<Byte>(), (byte*)pArray1);
+ public Vector128<Byte> Sse2_Max_133() => Sse2.Max(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<Int16> Sse2_Max_134() => Sse2.Max(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Double> Sse2_Max_135() => Sse2.Max(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_MaxScalar_136() => Sse2.MaxScalar(GetV128<Double>(), GetV128<Double>());
+ public void Sse2_MemoryFence_137() => Sse2.MemoryFence();
+ public Vector128<Byte> Sse2_Min_138() => Sse2.Min(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<Int16> Sse2_Min_139() => Sse2.Min(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Double> Sse2_Min_140() => Sse2.Min(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse2_MinScalar_141() => Sse2.MinScalar(GetV128<Double>(), GetV128<Double>());
+ public Int32 Sse2_MoveMask_142() => Sse2.MoveMask(GetV128<SByte>());
+ public Int32 Sse2_MoveMask_143() => Sse2.MoveMask(GetV128<Byte>());
+ public Int32 Sse2_MoveMask_144() => Sse2.MoveMask(GetV128<Double>());
+ public Vector128<Double> Sse2_MoveScalar_145() => Sse2.MoveScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Int64> Sse2_MoveScalar_146() => Sse2.MoveScalar(GetV128<Int64>());
+ public Vector128<UInt64> Sse2_MoveScalar_147() => Sse2.MoveScalar(GetV128<UInt64>());
+ public Vector128<UInt64> Sse2_Multiply_148() => Sse2.Multiply(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Double> Sse2_Multiply_149() => Sse2.Multiply(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Int32> Sse2_MultiplyAddAdjacent_150() => Sse2.MultiplyAddAdjacent(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int16> Sse2_MultiplyHigh_151() => Sse2.MultiplyHigh(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_MultiplyHigh_152() => Sse2.MultiplyHigh(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int16> Sse2_MultiplyLow_153() => Sse2.MultiplyLow(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_MultiplyLow_154() => Sse2.MultiplyLow(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Double> Sse2_MultiplyScalar_155() => Sse2.MultiplyScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Byte> Sse2_Or_156() => Sse2.Or(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<SByte> Sse2_Or_157() => Sse2.Or(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_Or_158() => Sse2.Or(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_Or_159() => Sse2.Or(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_Or_160() => Sse2.Or(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_Or_161() => Sse2.Or(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse2_Or_162() => Sse2.Or(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse2_Or_163() => Sse2.Or(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Double> Sse2_Or_164() => Sse2.Or(GetV128<Double>(), GetV128<Double>());
+ public Vector128<SByte> Sse2_PackSignedSaturate_165() => Sse2.PackSignedSaturate(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int16> Sse2_PackSignedSaturate_166() => Sse2.PackSignedSaturate(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<Byte> Sse2_PackUnsignedSaturate_167() => Sse2.PackUnsignedSaturate(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int16> Sse2_ShiftLeftLogical_168() => Sse2.ShiftLeftLogical(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_ShiftLeftLogical_169() => Sse2.ShiftLeftLogical(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_ShiftLeftLogical_170() => Sse2.ShiftLeftLogical(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_ShiftLeftLogical_171() => Sse2.ShiftLeftLogical(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse2_ShiftLeftLogical_172() => Sse2.ShiftLeftLogical(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse2_ShiftLeftLogical_173() => Sse2.ShiftLeftLogical(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Int16> Sse2_ShiftLeftLogical_174() => Sse2.ShiftLeftLogical(GetV128<Int16>(), Get<System.Byte>());
+ public Vector128<UInt16> Sse2_ShiftLeftLogical_175() => Sse2.ShiftLeftLogical(GetV128<UInt16>(), Get<System.Byte>());
+ public Vector128<Int32> Sse2_ShiftLeftLogical_176() => Sse2.ShiftLeftLogical(GetV128<Int32>(), Get<System.Byte>());
+ public Vector128<UInt32> Sse2_ShiftLeftLogical_177() => Sse2.ShiftLeftLogical(GetV128<UInt32>(), Get<System.Byte>());
+ public Vector128<Int64> Sse2_ShiftLeftLogical_178() => Sse2.ShiftLeftLogical(GetV128<Int64>(), Get<System.Byte>());
+ public Vector128<UInt64> Sse2_ShiftLeftLogical_179() => Sse2.ShiftLeftLogical(GetV128<UInt64>(), Get<System.Byte>());
+ public Vector128<SByte> Sse2_ShiftLeftLogical128BitLane_180() => Sse2.ShiftLeftLogical128BitLane(GetV128<SByte>(), Get<System.Byte>());
+ public Vector128<Byte> Sse2_ShiftLeftLogical128BitLane_181() => Sse2.ShiftLeftLogical128BitLane(GetV128<Byte>(), Get<System.Byte>());
+ public Vector128<Int16> Sse2_ShiftLeftLogical128BitLane_182() => Sse2.ShiftLeftLogical128BitLane(GetV128<Int16>(), Get<System.Byte>());
+ public Vector128<UInt16> Sse2_ShiftLeftLogical128BitLane_183() => Sse2.ShiftLeftLogical128BitLane(GetV128<UInt16>(), Get<System.Byte>());
+ public Vector128<Int32> Sse2_ShiftLeftLogical128BitLane_184() => Sse2.ShiftLeftLogical128BitLane(GetV128<Int32>(), Get<System.Byte>());
+ public Vector128<UInt32> Sse2_ShiftLeftLogical128BitLane_185() => Sse2.ShiftLeftLogical128BitLane(GetV128<UInt32>(), Get<System.Byte>());
+ public Vector128<Int64> Sse2_ShiftLeftLogical128BitLane_186() => Sse2.ShiftLeftLogical128BitLane(GetV128<Int64>(), Get<System.Byte>());
+ public Vector128<UInt64> Sse2_ShiftLeftLogical128BitLane_187() => Sse2.ShiftLeftLogical128BitLane(GetV128<UInt64>(), Get<System.Byte>());
+ public Vector128<Int16> Sse2_ShiftRightArithmetic_188() => Sse2.ShiftRightArithmetic(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int32> Sse2_ShiftRightArithmetic_189() => Sse2.ShiftRightArithmetic(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<Int16> Sse2_ShiftRightArithmetic_190() => Sse2.ShiftRightArithmetic(GetV128<Int16>(), Get<System.Byte>());
+ public Vector128<Int32> Sse2_ShiftRightArithmetic_191() => Sse2.ShiftRightArithmetic(GetV128<Int32>(), Get<System.Byte>());
+ public Vector128<Int16> Sse2_ShiftRightLogical_192() => Sse2.ShiftRightLogical(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_ShiftRightLogical_193() => Sse2.ShiftRightLogical(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_ShiftRightLogical_194() => Sse2.ShiftRightLogical(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_ShiftRightLogical_195() => Sse2.ShiftRightLogical(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse2_ShiftRightLogical_196() => Sse2.ShiftRightLogical(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse2_ShiftRightLogical_197() => Sse2.ShiftRightLogical(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Int16> Sse2_ShiftRightLogical_198() => Sse2.ShiftRightLogical(GetV128<Int16>(), Get<System.Byte>());
+ public Vector128<UInt16> Sse2_ShiftRightLogical_199() => Sse2.ShiftRightLogical(GetV128<UInt16>(), Get<System.Byte>());
+ public Vector128<Int32> Sse2_ShiftRightLogical_200() => Sse2.ShiftRightLogical(GetV128<Int32>(), Get<System.Byte>());
+ public Vector128<UInt32> Sse2_ShiftRightLogical_201() => Sse2.ShiftRightLogical(GetV128<UInt32>(), Get<System.Byte>());
+ public Vector128<Int64> Sse2_ShiftRightLogical_202() => Sse2.ShiftRightLogical(GetV128<Int64>(), Get<System.Byte>());
+ public Vector128<UInt64> Sse2_ShiftRightLogical_203() => Sse2.ShiftRightLogical(GetV128<UInt64>(), Get<System.Byte>());
+ public Vector128<SByte> Sse2_ShiftRightLogical128BitLane_204() => Sse2.ShiftRightLogical128BitLane(GetV128<SByte>(), Get<System.Byte>());
+ public Vector128<Byte> Sse2_ShiftRightLogical128BitLane_205() => Sse2.ShiftRightLogical128BitLane(GetV128<Byte>(), Get<System.Byte>());
+ public Vector128<Int16> Sse2_ShiftRightLogical128BitLane_206() => Sse2.ShiftRightLogical128BitLane(GetV128<Int16>(), Get<System.Byte>());
+ public Vector128<UInt16> Sse2_ShiftRightLogical128BitLane_207() => Sse2.ShiftRightLogical128BitLane(GetV128<UInt16>(), Get<System.Byte>());
+ public Vector128<Int32> Sse2_ShiftRightLogical128BitLane_208() => Sse2.ShiftRightLogical128BitLane(GetV128<Int32>(), Get<System.Byte>());
+ public Vector128<UInt32> Sse2_ShiftRightLogical128BitLane_209() => Sse2.ShiftRightLogical128BitLane(GetV128<UInt32>(), Get<System.Byte>());
+ public Vector128<Int64> Sse2_ShiftRightLogical128BitLane_210() => Sse2.ShiftRightLogical128BitLane(GetV128<Int64>(), Get<System.Byte>());
+ public Vector128<UInt64> Sse2_ShiftRightLogical128BitLane_211() => Sse2.ShiftRightLogical128BitLane(GetV128<UInt64>(), Get<System.Byte>());
+ public Vector128<UInt32> Sse2_Shuffle_212() => Sse2.Shuffle(GetV128<UInt32>(), 12);
+ public Vector128<Double> Sse2_Shuffle_213() => Sse2.Shuffle(GetV128<Double>(), GetV128<Double>(), 3);
+ public Vector128<Int32> Sse2_Shuffle_214() => Sse2.Shuffle(GetV128<Int32>(), 42);
+ public Vector128<Int16> Sse2_ShuffleHigh_215() => Sse2.ShuffleHigh(GetV128<Int16>(), 23);
+ public Vector128<UInt16> Sse2_ShuffleHigh_216() => Sse2.ShuffleHigh(GetV128<UInt16>(), 12);
+ public Vector128<Int16> Sse2_ShuffleLow_217() => Sse2.ShuffleLow(GetV128<Int16>(), 5);
+ public Vector128<UInt16> Sse2_ShuffleLow_218() => Sse2.ShuffleLow(GetV128<UInt16>(), 3);
+ public Vector128<Double> Sse2_Sqrt_219() => Sse2.Sqrt(GetV128<Double>());
+ public Vector128<Double> Sse2_SqrtScalar_220() => Sse2.SqrtScalar(GetV128<Double>());
+ public Vector128<Double> Sse2_SqrtScalar_221() => Sse2.SqrtScalar(GetV128<Double>(), GetV128<Double>());
+ public void Sse2_Store_222() => Sse2.Store((sbyte*)pArray2, GetV128<SByte>());
+ public void Sse2_Store_223() => Sse2.Store((byte*)pArray2, GetV128<Byte>());
+ public void Sse2_Store_224() => Sse2.Store((short*)pArray2, GetV128<Int16>());
+ public void Sse2_Store_225() => Sse2.Store((ushort*)pArray2, GetV128<UInt16>());
+ public void Sse2_Store_226() => Sse2.Store((int*)pArray2, GetV128<Int32>());
+ public void Sse2_Store_227() => Sse2.Store((uint*)pArray2, GetV128<UInt32>());
+ public void Sse2_Store_228() => Sse2.Store((long*)pArray2, GetV128<Int64>());
+ public void Sse2_Store_229() => Sse2.Store((ulong*)pArray2, GetV128<UInt64>());
+ public void Sse2_Store_230() => Sse2.Store(pArray1Double, GetV128<Double>());
+ public void Sse2_StoreAligned_231() => Sse2.StoreAligned(((sbyte*)pArray2), GetV128<SByte>());
+ public void Sse2_StoreAligned_232() => Sse2.StoreAligned(((byte*)pArray2), GetV128<Byte>());
+ public void Sse2_StoreAligned_233() => Sse2.StoreAligned(((short*)pArray2), GetV128<Int16>());
+ public void Sse2_StoreAligned_234() => Sse2.StoreAligned(((ushort*)pArray2), GetV128<UInt16>());
+ public void Sse2_StoreAligned_235() => Sse2.StoreAligned(((int*)pArray2), GetV128<Int32>());
+ public void Sse2_StoreAligned_236() => Sse2.StoreAligned(((uint*)pArray2), GetV128<UInt32>());
+ public void Sse2_StoreAligned_237() => Sse2.StoreAligned(((long*)pArray2), GetV128<Int64>());
+ public void Sse2_StoreAligned_238() => Sse2.StoreAligned(((ulong*)pArray2), GetV128<UInt64>());
+ public void Sse2_StoreAligned_239() => Sse2.StoreAligned((pArray2Double), GetV128<Double>());
+ public void Sse2_StoreAlignedNonTemporal_240() => Sse2.StoreAlignedNonTemporal(((sbyte*)pArray2), GetV128<SByte>());
+ public void Sse2_StoreAlignedNonTemporal_241() => Sse2.StoreAlignedNonTemporal(((byte*)pArray2), GetV128<Byte>());
+ public void Sse2_StoreAlignedNonTemporal_242() => Sse2.StoreAlignedNonTemporal(((short*)pArray2), GetV128<Int16>());
+ public void Sse2_StoreAlignedNonTemporal_243() => Sse2.StoreAlignedNonTemporal(((ushort*)pArray2), GetV128<UInt16>());
+ public void Sse2_StoreAlignedNonTemporal_244() => Sse2.StoreAlignedNonTemporal(((int*)pArray2), GetV128<Int32>());
+ public void Sse2_StoreAlignedNonTemporal_245() => Sse2.StoreAlignedNonTemporal(((uint*)pArray2), GetV128<UInt32>());
+ public void Sse2_StoreAlignedNonTemporal_246() => Sse2.StoreAlignedNonTemporal(((long*)pArray2), GetV128<Int64>());
+ public void Sse2_StoreAlignedNonTemporal_247() => Sse2.StoreAlignedNonTemporal(((ulong*)pArray2), GetV128<UInt64>());
+ public void Sse2_StoreAlignedNonTemporal_248() => Sse2.StoreAlignedNonTemporal((pArray2Double), GetV128<Double>());
+ public void Sse2_StoreHigh_249() => Sse2.StoreHigh(pArray2Double, GetV128<Double>());
+ public void Sse2_StoreLow_250() => Sse2.StoreLow(pArray2Double, GetV128<Double>());
+ public void Sse2_StoreNonTemporal_251() => Sse2.StoreNonTemporal((int*)pArray2, Get<System.Int32>());
+ public void Sse2_StoreNonTemporal_252() => Sse2.StoreNonTemporal((uint*)pArray2, Get<System.UInt32>());
+ public void Sse2_StoreScalar_253() => Sse2.StoreScalar(pArray2Double, GetV128<Double>());
+ public void Sse2_StoreScalar_254() => Sse2.StoreScalar((long*)pArray2, GetV128<Int64>());
+ public void Sse2_StoreScalar_255() => Sse2.StoreScalar((ulong*)pArray2, GetV128<UInt64>());
+ public Vector128<Byte> Sse2_Subtract_256() => Sse2.Subtract(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<SByte> Sse2_Subtract_257() => Sse2.Subtract(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_Subtract_258() => Sse2.Subtract(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_Subtract_259() => Sse2.Subtract(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_Subtract_260() => Sse2.Subtract(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_Subtract_261() => Sse2.Subtract(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse2_Subtract_262() => Sse2.Subtract(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse2_Subtract_263() => Sse2.Subtract(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Double> Sse2_Subtract_264() => Sse2.Subtract(GetV128<Double>(), GetV128<Double>());
+ public Vector128<SByte> Sse2_SubtractSaturate_265() => Sse2.SubtractSaturate(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_SubtractSaturate_266() => Sse2.SubtractSaturate(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Byte> Sse2_SubtractSaturate_267() => Sse2.SubtractSaturate(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<UInt16> Sse2_SubtractSaturate_268() => Sse2.SubtractSaturate(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Double> Sse2_SubtractScalar_269() => Sse2.SubtractScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<UInt16> Sse2_SumAbsoluteDifferences_270() => Sse2.SumAbsoluteDifferences(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<Byte> Sse2_UnpackHigh_271() => Sse2.UnpackHigh(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<SByte> Sse2_UnpackHigh_272() => Sse2.UnpackHigh(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_UnpackHigh_273() => Sse2.UnpackHigh(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_UnpackHigh_274() => Sse2.UnpackHigh(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_UnpackHigh_275() => Sse2.UnpackHigh(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_UnpackHigh_276() => Sse2.UnpackHigh(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse2_UnpackHigh_277() => Sse2.UnpackHigh(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse2_UnpackHigh_278() => Sse2.UnpackHigh(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Double> Sse2_UnpackHigh_279() => Sse2.UnpackHigh(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Byte> Sse2_UnpackLow_280() => Sse2.UnpackLow(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<SByte> Sse2_UnpackLow_281() => Sse2.UnpackLow(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_UnpackLow_282() => Sse2.UnpackLow(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_UnpackLow_283() => Sse2.UnpackLow(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_UnpackLow_284() => Sse2.UnpackLow(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_UnpackLow_285() => Sse2.UnpackLow(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse2_UnpackLow_286() => Sse2.UnpackLow(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse2_UnpackLow_287() => Sse2.UnpackLow(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Double> Sse2_UnpackLow_288() => Sse2.UnpackLow(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Byte> Sse2_Xor_289() => Sse2.Xor(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<SByte> Sse2_Xor_290() => Sse2.Xor(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Sse2_Xor_291() => Sse2.Xor(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse2_Xor_292() => Sse2.Xor(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse2_Xor_293() => Sse2.Xor(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse2_Xor_294() => Sse2.Xor(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse2_Xor_295() => Sse2.Xor(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse2_Xor_296() => Sse2.Xor(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Double> Sse2_Xor_297() => Sse2.Xor(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse3_AddSubtract_0() => Sse3.AddSubtract(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Double> Sse3_AddSubtract_1() => Sse3.AddSubtract(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse3_HorizontalAdd_3() => Sse3.HorizontalAdd(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Double> Sse3_HorizontalAdd_4() => Sse3.HorizontalAdd(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse3_HorizontalSubtract_5() => Sse3.HorizontalSubtract(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Double> Sse3_HorizontalSubtract_6() => Sse3.HorizontalSubtract(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Double> Sse3_LoadAndDuplicateToVector128_7() => Sse3.LoadAndDuplicateToVector128(pArray1Double);
+ public Vector128<SByte> Sse3_LoadDquVector128_8() => Sse3.LoadDquVector128((sbyte*)pArray1);
+ public Vector128<Byte> Sse3_LoadDquVector128_9() => Sse3.LoadDquVector128((byte*)pArray1);
+ public Vector128<Int16> Sse3_LoadDquVector128_10() => Sse3.LoadDquVector128((short*)pArray1);
+ public Vector128<UInt16> Sse3_LoadDquVector128_11() => Sse3.LoadDquVector128((ushort*)pArray1);
+ public Vector128<Int32> Sse3_LoadDquVector128_12() => Sse3.LoadDquVector128((int*)pArray1);
+ public Vector128<UInt32> Sse3_LoadDquVector128_13() => Sse3.LoadDquVector128((uint*)pArray1);
+ public Vector128<Int64> Sse3_LoadDquVector128_14() => Sse3.LoadDquVector128((long*)pArray1);
+ public Vector128<UInt64> Sse3_LoadDquVector128_15() => Sse3.LoadDquVector128((ulong*)pArray1);
+ public Vector128<Double> Sse3_MoveAndDuplicate_16() => Sse3.MoveAndDuplicate(GetV128<Double>());
+ public Vector128<Single> Sse3_MoveHighAndDuplicate_17() => Sse3.MoveHighAndDuplicate(GetV128<Single>());
+ public Vector128<Single> Sse3_MoveLowAndDuplicate_18() => Sse3.MoveLowAndDuplicate(GetV128<Single>());
+ public Vector128<Byte> Ssse3_Abs_0() => Ssse3.Abs(GetV128<SByte>());
+ public Vector128<UInt16> Ssse3_Abs_1() => Ssse3.Abs(GetV128<Int16>());
+ public Vector128<UInt32> Ssse3_Abs_2() => Ssse3.Abs(GetV128<Int32>());
+ public Vector128<SByte> Ssse3_AlignRight_3() => Ssse3.AlignRight(GetV128<SByte>(), GetV128<SByte>(), Get<System.Byte>());
+ public Vector128<Byte> Ssse3_AlignRight_4() => Ssse3.AlignRight(GetV128<Byte>(), GetV128<Byte>(), Get<System.Byte>());
+ public Vector128<Int16> Ssse3_AlignRight_5() => Ssse3.AlignRight(GetV128<Int16>(), GetV128<Int16>(), Get<System.Byte>());
+ public Vector128<UInt16> Ssse3_AlignRight_6() => Ssse3.AlignRight(GetV128<UInt16>(), GetV128<UInt16>(), Get<System.Byte>());
+ public Vector128<Int32> Ssse3_AlignRight_7() => Ssse3.AlignRight(GetV128<Int32>(), GetV128<Int32>(), Get<System.Byte>());
+ public Vector128<UInt32> Ssse3_AlignRight_8() => Ssse3.AlignRight(GetV128<UInt32>(), GetV128<UInt32>(), Get<System.Byte>());
+ public Vector128<Int64> Ssse3_AlignRight_9() => Ssse3.AlignRight(GetV128<Int64>(), GetV128<Int64>(), Get<System.Byte>());
+ public Vector128<UInt64> Ssse3_AlignRight_10() => Ssse3.AlignRight(GetV128<UInt64>(), GetV128<UInt64>(), Get<System.Byte>());
+ public Vector128<Int16> Ssse3_HorizontalAdd_12() => Ssse3.HorizontalAdd(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int32> Ssse3_HorizontalAdd_13() => Ssse3.HorizontalAdd(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<Int16> Ssse3_HorizontalAddSaturate_14() => Ssse3.HorizontalAddSaturate(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int16> Ssse3_HorizontalSubtract_15() => Ssse3.HorizontalSubtract(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int32> Ssse3_HorizontalSubtract_16() => Ssse3.HorizontalSubtract(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<Int16> Ssse3_HorizontalSubtractSaturate_17() => Ssse3.HorizontalSubtractSaturate(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int16> Ssse3_MultiplyAddAdjacent_18() => Ssse3.MultiplyAddAdjacent(GetV128<Byte>(), GetV128<SByte>());
+ public Vector128<Int16> Ssse3_MultiplyHighRoundScale_19() => Ssse3.MultiplyHighRoundScale(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<SByte> Ssse3_Shuffle_20() => Ssse3.Shuffle(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Byte> Ssse3_Shuffle_21() => Ssse3.Shuffle(GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<SByte> Ssse3_Sign_22() => Ssse3.Sign(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Int16> Ssse3_Sign_23() => Ssse3.Sign(GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<Int32> Ssse3_Sign_24() => Ssse3.Sign(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<Int16> Sse41_Blend_0() => Sse41.Blend(GetV128<Int16>(), GetV128<Int16>(), Get<System.Byte>());
+ public Vector128<UInt16> Sse41_Blend_1() => Sse41.Blend(GetV128<UInt16>(), GetV128<UInt16>(), Get<System.Byte>());
+ public Vector128<Single> Sse41_Blend_2() => Sse41.Blend(GetV128<Single>(), GetV128<Single>(), Get<System.Byte>());
+ public Vector128<Double> Sse41_Blend_3() => Sse41.Blend(GetV128<Double>(), GetV128<Double>(), Get<System.Byte>());
+ public Vector128<SByte> Sse41_BlendVariable_4() => Sse41.BlendVariable(GetV128<SByte>(), GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<Byte> Sse41_BlendVariable_5() => Sse41.BlendVariable(GetV128<Byte>(), GetV128<Byte>(), GetV128<Byte>());
+ public Vector128<Int16> Sse41_BlendVariable_6() => Sse41.BlendVariable(GetV128<Int16>(), GetV128<Int16>(), GetV128<Int16>());
+ public Vector128<UInt16> Sse41_BlendVariable_7() => Sse41.BlendVariable(GetV128<UInt16>(), GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse41_BlendVariable_8() => Sse41.BlendVariable(GetV128<Int32>(), GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse41_BlendVariable_9() => Sse41.BlendVariable(GetV128<UInt32>(), GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<Int64> Sse41_BlendVariable_10() => Sse41.BlendVariable(GetV128<Int64>(), GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse41_BlendVariable_11() => Sse41.BlendVariable(GetV128<UInt64>(), GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Single> Sse41_BlendVariable_12() => Sse41.BlendVariable(GetV128<Single>(), GetV128<Single>(), GetV128<Single>());
+ public Vector128<Double> Sse41_BlendVariable_13() => Sse41.BlendVariable(GetV128<Double>(), GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse41_Ceiling_14() => Sse41.Ceiling(GetV128<Single>());
+ public Vector128<Double> Sse41_Ceiling_15() => Sse41.Ceiling(GetV128<Double>());
+ public Vector128<Double> Sse41_CeilingScalar_16() => Sse41.CeilingScalar(GetV128<Double>());
+ public Vector128<Single> Sse41_CeilingScalar_17() => Sse41.CeilingScalar(GetV128<Single>());
+ public Vector128<Double> Sse41_CeilingScalar_18() => Sse41.CeilingScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse41_CeilingScalar_19() => Sse41.CeilingScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Int64> Sse41_CompareEqual_20() => Sse41.CompareEqual(GetV128<Int64>(), GetV128<Int64>());
+ public Vector128<UInt64> Sse41_CompareEqual_21() => Sse41.CompareEqual(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Int16> Sse41_ConvertToVector128Int16_22() => Sse41.ConvertToVector128Int16(GetV128<SByte>());
+ public Vector128<Int16> Sse41_ConvertToVector128Int16_23() => Sse41.ConvertToVector128Int16(GetV128<Byte>());
+ public Vector128<Int16> Sse41_ConvertToVector128Int16_24() => Sse41.ConvertToVector128Int16((sbyte*)pArray1);
+ public Vector128<Int16> Sse41_ConvertToVector128Int16_25() => Sse41.ConvertToVector128Int16((byte*)pArray1);
+ public Vector128<Int32> Sse41_ConvertToVector128Int32_26() => Sse41.ConvertToVector128Int32(GetV128<SByte>());
+ public Vector128<Int32> Sse41_ConvertToVector128Int32_27() => Sse41.ConvertToVector128Int32(GetV128<Byte>());
+ public Vector128<Int32> Sse41_ConvertToVector128Int32_28() => Sse41.ConvertToVector128Int32(GetV128<Int16>());
+ public Vector128<Int32> Sse41_ConvertToVector128Int32_29() => Sse41.ConvertToVector128Int32(GetV128<UInt16>());
+ public Vector128<Int32> Sse41_ConvertToVector128Int32_30() => Sse41.ConvertToVector128Int32((sbyte*)pArray1);
+ public Vector128<Int32> Sse41_ConvertToVector128Int32_31() => Sse41.ConvertToVector128Int32((byte*)pArray1);
+ public Vector128<Int32> Sse41_ConvertToVector128Int32_32() => Sse41.ConvertToVector128Int32((short*)pArray1);
+ public Vector128<Int32> Sse41_ConvertToVector128Int32_33() => Sse41.ConvertToVector128Int32((ushort*)pArray1);
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_34() => Sse41.ConvertToVector128Int64(GetV128<SByte>());
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_35() => Sse41.ConvertToVector128Int64(GetV128<Byte>());
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_36() => Sse41.ConvertToVector128Int64(GetV128<Int16>());
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_37() => Sse41.ConvertToVector128Int64(GetV128<UInt16>());
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_38() => Sse41.ConvertToVector128Int64(GetV128<Int32>());
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_39() => Sse41.ConvertToVector128Int64(GetV128<UInt32>());
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_40() => Sse41.ConvertToVector128Int64((sbyte*)pArray1);
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_41() => Sse41.ConvertToVector128Int64((byte*)pArray1);
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_42() => Sse41.ConvertToVector128Int64((short*)pArray1);
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_43() => Sse41.ConvertToVector128Int64((ushort*)pArray1);
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_44() => Sse41.ConvertToVector128Int64((int*)pArray1);
+ public Vector128<Int64> Sse41_ConvertToVector128Int64_45() => Sse41.ConvertToVector128Int64((uint*)pArray1);
+ public Vector128<Single> Sse41_DotProduct_46() => Sse41.DotProduct(GetV128<Single>(), GetV128<Single>(), Get<System.Byte>());
+ public Vector128<Double> Sse41_DotProduct_47() => Sse41.DotProduct(GetV128<Double>(), GetV128<Double>(), Get<System.Byte>());
+ public Byte Sse41_Extract_48() => Sse41.Extract(GetV128<Byte>(), Get<System.Byte>());
+ public Int32 Sse41_Extract_49() => Sse41.Extract(GetV128<Int32>(), Get<System.Byte>());
+ public UInt32 Sse41_Extract_50() => Sse41.Extract(GetV128<UInt32>(), Get<System.Byte>());
+ public Single Sse41_Extract_51() => Sse41.Extract(GetV128<Single>(), Get<System.Byte>());
+ public Vector128<Single> Sse41_Floor_52() => Sse41.Floor(GetV128<Single>());
+ public Vector128<Double> Sse41_Floor_53() => Sse41.Floor(GetV128<Double>());
+ public Vector128<Double> Sse41_FloorScalar_54() => Sse41.FloorScalar(GetV128<Double>());
+ public Vector128<Single> Sse41_FloorScalar_55() => Sse41.FloorScalar(GetV128<Single>());
+ public Vector128<Double> Sse41_FloorScalar_56() => Sse41.FloorScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse41_FloorScalar_57() => Sse41.FloorScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<SByte> Sse41_Insert_59() => Sse41.Insert(GetV128<SByte>(), Get<System.SByte>(), 4);
+ public Vector128<Byte> Sse41_Insert_60() => Sse41.Insert(GetV128<Byte>(), Get<System.Byte>(), 3);
+ public Vector128<Int32> Sse41_Insert_61() => Sse41.Insert(GetV128<Int32>(), Get<System.Int32>(), 2);
+ public Vector128<UInt32> Sse41_Insert_62() => Sse41.Insert(GetV128<UInt32>(), Get<System.UInt32>(), 1);
+ public Vector128<Single> Sse41_Insert_63() => Sse41.Insert(GetV128<Single>(), GetV128<Single>(), 0x10);
+ public Vector128<SByte> Sse41_LoadAlignedVector128NonTemporal_64() => Sse41.LoadAlignedVector128NonTemporal(((sbyte*)pArray1));
+ public Vector128<Byte> Sse41_LoadAlignedVector128NonTemporal_65() => Sse41.LoadAlignedVector128NonTemporal(((byte*)pArray1));
+ public Vector128<Int16> Sse41_LoadAlignedVector128NonTemporal_66() => Sse41.LoadAlignedVector128NonTemporal(((short*)pArray1));
+ public Vector128<UInt16> Sse41_LoadAlignedVector128NonTemporal_67() => Sse41.LoadAlignedVector128NonTemporal(((ushort*)pArray1));
+ public Vector128<Int32> Sse41_LoadAlignedVector128NonTemporal_68() => Sse41.LoadAlignedVector128NonTemporal(((int*)pArray1));
+ public Vector128<UInt32> Sse41_LoadAlignedVector128NonTemporal_69() => Sse41.LoadAlignedVector128NonTemporal(((uint*)pArray1));
+ public Vector128<Int64> Sse41_LoadAlignedVector128NonTemporal_70() => Sse41.LoadAlignedVector128NonTemporal(((long*)pArray1));
+ public Vector128<UInt64> Sse41_LoadAlignedVector128NonTemporal_71() => Sse41.LoadAlignedVector128NonTemporal(((ulong*)pArray1));
+ public Vector128<SByte> Sse41_Max_72() => Sse41.Max(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<UInt16> Sse41_Max_73() => Sse41.Max(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse41_Max_74() => Sse41.Max(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse41_Max_75() => Sse41.Max(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<SByte> Sse41_Min_76() => Sse41.Min(GetV128<SByte>(), GetV128<SByte>());
+ public Vector128<UInt16> Sse41_Min_77() => Sse41.Min(GetV128<UInt16>(), GetV128<UInt16>());
+ public Vector128<Int32> Sse41_Min_78() => Sse41.Min(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse41_Min_79() => Sse41.Min(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<UInt16> Sse41_MinHorizontal_80() => Sse41.MinHorizontal(GetV128<UInt16>());
+ public Vector128<UInt16> Sse41_MultipleSumAbsoluteDifferences_81() => Sse41.MultipleSumAbsoluteDifferences(GetV128<Byte>(), GetV128<Byte>(), Get<System.Byte>());
+ public Vector128<Int64> Sse41_Multiply_82() => Sse41.Multiply(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<Int32> Sse41_MultiplyLow_83() => Sse41.MultiplyLow(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<UInt32> Sse41_MultiplyLow_84() => Sse41.MultiplyLow(GetV128<UInt32>(), GetV128<UInt32>());
+ public Vector128<UInt16> Sse41_PackUnsignedSaturate_85() => Sse41.PackUnsignedSaturate(GetV128<Int32>(), GetV128<Int32>());
+ public Vector128<Double> Sse41_RoundCurrentDirection_86() => Sse41.RoundCurrentDirection(GetV128<Double>());
+ public Vector128<Single> Sse41_RoundCurrentDirection_87() => Sse41.RoundCurrentDirection(GetV128<Single>());
+ public Vector128<Double> Sse41_RoundCurrentDirectionScalar_88() => Sse41.RoundCurrentDirectionScalar(GetV128<Double>());
+ public Vector128<Double> Sse41_RoundCurrentDirectionScalar_89() => Sse41.RoundCurrentDirectionScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse41_RoundCurrentDirectionScalar_90() => Sse41.RoundCurrentDirectionScalar(GetV128<Single>());
+ public Vector128<Single> Sse41_RoundCurrentDirectionScalar_91() => Sse41.RoundCurrentDirectionScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse41_RoundToNearestInteger_92() => Sse41.RoundToNearestInteger(GetV128<Single>());
+ public Vector128<Double> Sse41_RoundToNearestInteger_93() => Sse41.RoundToNearestInteger(GetV128<Double>());
+ public Vector128<Double> Sse41_RoundToNearestIntegerScalar_94() => Sse41.RoundToNearestIntegerScalar(GetV128<Double>());
+ public Vector128<Double> Sse41_RoundToNearestIntegerScalar_95() => Sse41.RoundToNearestIntegerScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse41_RoundToNearestIntegerScalar_96() => Sse41.RoundToNearestIntegerScalar(GetV128<Single>());
+ public Vector128<Single> Sse41_RoundToNearestIntegerScalar_97() => Sse41.RoundToNearestIntegerScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Single> Sse41_RoundToNegativeInfinity_98() => Sse41.RoundToNegativeInfinity(GetV128<Single>());
+ public Vector128<Double> Sse41_RoundToNegativeInfinity_99() => Sse41.RoundToNegativeInfinity(GetV128<Double>());
+ public Vector128<Double> Sse41_RoundToNegativeInfinityScalar_100() => Sse41.RoundToNegativeInfinityScalar(GetV128<Double>());
+ public Vector128<Double> Sse41_RoundToNegativeInfinityScalar_101() => Sse41.RoundToNegativeInfinityScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse41_RoundToNegativeInfinityScalar_102() => Sse41.RoundToNegativeInfinityScalar(GetV128<Single>());
+ public Vector128<Single> Sse41_RoundToNegativeInfinityScalar_103() => Sse41.RoundToNegativeInfinityScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Double> Sse41_RoundToPositiveInfinity_104() => Sse41.RoundToPositiveInfinity(GetV128<Double>());
+ public Vector128<Single> Sse41_RoundToPositiveInfinity_105() => Sse41.RoundToPositiveInfinity(GetV128<Single>());
+ public Vector128<Double> Sse41_RoundToPositiveInfinityScalar_106() => Sse41.RoundToPositiveInfinityScalar(GetV128<Double>());
+ public Vector128<Double> Sse41_RoundToPositiveInfinityScalar_107() => Sse41.RoundToPositiveInfinityScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse41_RoundToPositiveInfinityScalar_108() => Sse41.RoundToPositiveInfinityScalar(GetV128<Single>());
+ public Vector128<Single> Sse41_RoundToPositiveInfinityScalar_109() => Sse41.RoundToPositiveInfinityScalar(GetV128<Single>(), GetV128<Single>());
+ public Vector128<Double> Sse41_RoundToZero_110() => Sse41.RoundToZero(GetV128<Double>());
+ public Vector128<Single> Sse41_RoundToZero_111() => Sse41.RoundToZero(GetV128<Single>());
+ public Vector128<Double> Sse41_RoundToZeroScalar_112() => Sse41.RoundToZeroScalar(GetV128<Double>());
+ public Vector128<Double> Sse41_RoundToZeroScalar_113() => Sse41.RoundToZeroScalar(GetV128<Double>(), GetV128<Double>());
+ public Vector128<Single> Sse41_RoundToZeroScalar_114() => Sse41.RoundToZeroScalar(GetV128<Single>());
+ public Vector128<Single> Sse41_RoundToZeroScalar_115() => Sse41.RoundToZeroScalar(GetV128<Single>(), GetV128<Single>());
+ public Boolean Sse41_TestC_116() => Sse41.TestC(GetV128<SByte>(), GetV128<SByte>());
+ public Boolean Sse41_TestC_117() => Sse41.TestC(GetV128<Byte>(), GetV128<Byte>());
+ public Boolean Sse41_TestC_118() => Sse41.TestC(GetV128<Int16>(), GetV128<Int16>());
+ public Boolean Sse41_TestC_119() => Sse41.TestC(GetV128<UInt16>(), GetV128<UInt16>());
+ public Boolean Sse41_TestC_120() => Sse41.TestC(GetV128<Int32>(), GetV128<Int32>());
+ public Boolean Sse41_TestC_121() => Sse41.TestC(GetV128<UInt32>(), GetV128<UInt32>());
+ public Boolean Sse41_TestC_122() => Sse41.TestC(GetV128<Int64>(), GetV128<Int64>());
+ public Boolean Sse41_TestC_123() => Sse41.TestC(GetV128<UInt64>(), GetV128<UInt64>());
+ public Boolean Sse41_TestNotZAndNotC_124() => Sse41.TestNotZAndNotC(GetV128<SByte>(), GetV128<SByte>());
+ public Boolean Sse41_TestNotZAndNotC_125() => Sse41.TestNotZAndNotC(GetV128<Byte>(), GetV128<Byte>());
+ public Boolean Sse41_TestNotZAndNotC_126() => Sse41.TestNotZAndNotC(GetV128<Int16>(), GetV128<Int16>());
+ public Boolean Sse41_TestNotZAndNotC_127() => Sse41.TestNotZAndNotC(GetV128<UInt16>(), GetV128<UInt16>());
+ public Boolean Sse41_TestNotZAndNotC_128() => Sse41.TestNotZAndNotC(GetV128<Int32>(), GetV128<Int32>());
+ public Boolean Sse41_TestNotZAndNotC_129() => Sse41.TestNotZAndNotC(GetV128<UInt32>(), GetV128<UInt32>());
+ public Boolean Sse41_TestNotZAndNotC_130() => Sse41.TestNotZAndNotC(GetV128<Int64>(), GetV128<Int64>());
+ public Boolean Sse41_TestNotZAndNotC_131() => Sse41.TestNotZAndNotC(GetV128<UInt64>(), GetV128<UInt64>());
+ public Boolean Sse41_TestZ_132() => Sse41.TestZ(GetV128<SByte>(), GetV128<SByte>());
+ public Boolean Sse41_TestZ_133() => Sse41.TestZ(GetV128<Byte>(), GetV128<Byte>());
+ public Boolean Sse41_TestZ_134() => Sse41.TestZ(GetV128<Int16>(), GetV128<Int16>());
+ public Boolean Sse41_TestZ_135() => Sse41.TestZ(GetV128<UInt16>(), GetV128<UInt16>());
+ public Boolean Sse41_TestZ_136() => Sse41.TestZ(GetV128<Int32>(), GetV128<Int32>());
+ public Boolean Sse41_TestZ_137() => Sse41.TestZ(GetV128<UInt32>(), GetV128<UInt32>());
+ public Boolean Sse41_TestZ_138() => Sse41.TestZ(GetV128<Int64>(), GetV128<Int64>());
+ public Boolean Sse41_TestZ_139() => Sse41.TestZ(GetV128<UInt64>(), GetV128<UInt64>());
+ public Vector128<Int64> Sse42_CompareGreaterThan_0() => Sse42.CompareGreaterThan(GetV128<Int64>(), GetV128<Int64>());
+ public UInt32 Sse42_Crc32_1() => Sse42.Crc32(Get<System.UInt32>(), Get<System.Byte>());
+ public UInt32 Sse42_Crc32_2() => Sse42.Crc32(Get<System.UInt32>(), Get<System.UInt16>());
+ public UInt32 Sse42_Crc32_3() => Sse42.Crc32(Get<System.UInt32>(), Get<System.UInt32>());
+
+ public Vector128<byte> Vector128_Create_1() => Vector128.Create(Get<byte>());
+ public Vector128<sbyte> Vector128_Create_2() => Vector128.Create(Get<sbyte>());
+ public Vector128<short> Vector128_Create_3() => Vector128.Create(Get<short>());
+ public Vector128<ushort> Vector128_Create_4() => Vector128.Create(Get<ushort>());
+ public Vector128<int> Vector128_Create_5() => Vector128.Create(Get<int>());
+ public Vector128<uint> Vector128_Create_6() => Vector128.Create(Get<uint>());
+ public Vector128<long> Vector128_Create_7() => Vector128.Create(Get<long>());
+ public Vector128<ulong> Vector128_Create_8() => Vector128.Create(Get<ulong>());
+ public Vector128<float> Vector128_Create_9() => Vector128.Create(Get<float>());
+ public Vector128<double> Vector128_Create_10() => Vector128.Create(Get<double>());
+ public Vector128<double> Vector128_Create_11() => Vector128.Create(Get<double>(), Get<double>());
+ public Vector128<long> Vector128_Create_12() => Vector128.Create(Get<long>(), Get<long>());
+ public Vector128<ulong> Vector128_Create_13() => Vector128.Create(Get<ulong>(), Get<ulong>());
+ public Vector128<float> Vector128_Create_14() => Vector128.Create(Get<float>(), Get<float>(), Get<float>(), Get<float>());
+ public Vector128<int> Vector128_Create_15() => Vector128.Create(Get<int>(), Get<int>(), Get<int>(), Get<int>());
+ public Vector128<uint> Vector128_Create_16() => Vector128.Create(Get<uint>(), Get<uint>(), Get<uint>(), Get<uint>());
+ public Vector128<ushort> Vector128_Create_17() => Vector128.Create(Get<ushort>(), Get<ushort>(), Get<ushort>(), Get<ushort>(), Get<ushort>(), Get<ushort>(), Get<ushort>(), Get<ushort>());
+ public Vector128<short> Vector128_Create_18() => Vector128.Create(Get<short>(), Get<short>(), Get<short>(), Get<short>(), Get<short>(), Get<short>(), Get<short>(), Get<short>());
+ public Vector128<sbyte> Vector128_Create_20() => Vector128.Create(Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>());
+
+ public int Vector128_CreateScalarUnsafe_1() => Sse2.Add(Vector128.CreateScalarUnsafe(42), Vector128.CreateScalarUnsafe(8)).GetElement(0);
+ public double Vector128_CreateScalarUnsafe_2() => Sse2.Add(Vector128.CreateScalarUnsafe(42.0), Vector128.CreateScalarUnsafe(8.0)).GetElement(0);
+
+ public Vector128<byte> Vector128_int_to_byte() => Vector128_Create_15().AsByte();
+ public Vector128<ulong> Vector128_int_to_ulong() => Vector128_Create_15().AsUInt64();
+ public Vector128<int> Vector128_byte_to_int() => Vector128_Create_20().AsInt32();
+}
\ No newline at end of file
--- /dev/null
+GetArray2Data: . array2: ()
+ReloadArrays: . array2: ()
+Sse_Add_0: <929125630, 457013920, 373885180, 399296580>. array2: ()
+Sse_AddScalar_1: <831905660, 361925120, 171923890, 163625200>. array2: ()
+Sse_And_2: <37962244, 63456256, 77604050, 337699840>. array2: ()
+Sse_AndNot_3: <-7.530605E-39, -9.442987E-38, -1.5179037E-36, -2.3605184E-38>. array2: ()
+Sse_CompareEqual_4: <0, 0, 0, 0>. array2: ()
+Sse_CompareGreaterThan_5: <0, 0, 0, 0>. array2: ()
+Sse_CompareGreaterThanOrEqual_6: <0, 0, NaN, 0>. array2: ()
+Sse_CompareLessThan_7: <0, 0, 0, 0>. array2: ()
+Sse_CompareLessThanOrEqual_8: <0, 0, 0, 0>. array2: ()
+Sse_CompareNotEqual_9: <NaN, NaN, NaN, NaN>. array2: ()
+Sse_CompareNotGreaterThan_10: <0, NaN, 0, NaN>. array2: ()
+Sse_CompareNotGreaterThanOrEqual_11: <0, 0, 0, 0>. array2: ()
+Sse_CompareNotLessThan_12: <0, NaN, NaN, 0>. array2: ()
+Sse_CompareNotLessThanOrEqual_13: <0, 0, 0, 0>. array2: ()
+Sse_CompareOrdered_14: <NaN, NaN, NaN, NaN>. array2: ()
+Sse_CompareScalarEqual_15: <0, 165247660, 501148420, 424096580>. array2: ()
+Sse_CompareScalarGreaterThan_16: <0, -510012770, -65459412, -256915410>. array2: ()
+Sse_CompareScalarGreaterThanOrEqual_17: <NaN, 678421950, 435046200, 55114016>. array2: ()
+Sse_CompareScalarLessThan_18: <0, 286352260, 67081924, 391137340>. array2: ()
+Sse_CompareScalarLessThanOrEqual_19: <NaN, -588649900, -401212100, -120477656>. array2: ()
+Sse_CompareScalarNotEqual_20: <NaN, 198373810, 122680850, 358035900>. array2: ()
+Sse_CompareScalarNotGreaterThan_21: <0, 675093900, 250508290, 382580160>. array2: ()
+Sse_CompareScalarNotGreaterThanOrEqual_22: <NaN, 79479856, 432719200, 149407550>. array2: ()
+Sse_CompareScalarNotLessThan_23: <0, -669115970, -28078068, -23915620>. array2: ()
+Sse_CompareScalarNotLessThanOrEqual_24: <0, -263062030, -243626220, -327881220>. array2: ()
+Sse_CompareScalarOrdered_25: <NaN, 424523140, 329012580, 166258130>. array2: ()
+Sse_CompareScalarOrderedEqual_26: False. array2: ()
+Sse_CompareScalarOrderedGreaterThan_27: True. array2: ()
+Sse_CompareScalarOrderedGreaterThanOrEqual_28: False. array2: ()
+Sse_CompareScalarOrderedLessThan_29: False. array2: ()
+Sse_CompareScalarOrderedLessThanOrEqual_30: True. array2: ()
+Sse_CompareScalarOrderedNotEqual_31: True. array2: ()
+Sse_CompareScalarUnordered_32: <0, 0, 0, 0>. array2: ()
+Sse_CompareScalarUnorderedEqual_33: False. array2: ()
+Sse_CompareScalarUnorderedGreaterThan_34: False. array2: ()
+Sse_CompareScalarUnorderedGreaterThanOrEqual_35: True. array2: ()
+Sse_CompareScalarUnorderedLessThan_36: False. array2: ()
+Sse_CompareScalarUnorderedLessThanOrEqual_37: False. array2: ()
+Sse_CompareScalarUnorderedNotEqual_38: True. array2: ()
+Sse_CompareUnordered_39: <0, 0, 0, 0>. array2: ()
+Sse_ConvertScalarToVector128Single_40: <1.7130938E+09, 673981570, 435517900, 284626240>. array2: ()
+Sse_ConvertToInt32_41: -200472784. array2: ()
+Sse_ConvertToInt32WithTruncation_42: 476591168. array2: ()
+Sse_Divide_43: <0.4255711, 1.6555679, 1.080426, 2.3567653>. array2: ()
+Sse_DivideScalar_44: <Infinity, 94416510, 474155170, 220063580>. array2: ()
+Sse_LoadAlignedVector128_46: <0, 0.5, 1, 1.5>. array2: ()
+Sse_LoadHigh_47: <213905200, 534451330, 0, 0.5>. array2: ()
+Sse_LoadLow_48: <0, 0.5, 526352540, 304848960>. array2: ()
+Sse_LoadScalarVector128_49: <0, 0, 0, 0>. array2: ()
+Sse_LoadVector128_50: <0, 0.5, 1, 1.5>. array2: ()
+Sse_Max_51: <-304293300, -344651520, -332293340, -228331310>. array2: ()
+Sse_MaxScalar_52: <0, 0, 0, 0>. array2: ()
+Sse_Min_53: <-659012200, -329070240, -410852960, -194900770>. array2: ()
+Sse_MinScalar_54: <303572000, 262783810, 75313750, 48754888>. array2: ()
+Sse_MoveHighToLow_55: <152952030, 120658176, 416098600, 151711410>. array2: ()
+Sse_MoveLowToHigh_56: <594499460, 78836810, 799263700, 431919140>. array2: ()
+Sse_MoveMask_57: 0. array2: ()
+Sse_MoveScalar_58: <581809900, 70783160, 158188660, 309818560>. array2: ()
+Sse_Multiply_59: <-8.335214E+16, -4.255089E+16, -7.327157E+16, -2.6699806E+15>. array2: ()
+Sse_MultiplyScalar_60: <1.7725418E+17, 160780880, 114840160, 312372350>. array2: ()
+Sse_Or_61: <-1.0672764E+09, -8.5731497E+09, -307076030, -389938500>. array2: ()
+Sse_Prefetch0_62: . array2: ()
+Sse_Prefetch1_63: . array2: ()
+Sse_Prefetch2_64: . array2: ()
+Sse_PrefetchNonTemporal_65: . array2: ()
+Sse_Reciprocal_66: <-1.2159944E-08, -1.1204975E-08, -1.8821993E-09, -7.841663E-09>. array2: ()
+Sse_ReciprocalScalar_67: <3.4578989E-09, 56211220, 81027630, 106894210>. array2: ()
+Sse_ReciprocalScalar_68: <1.2871624E-09, 448893340, 230181550, 34451628>. array2: ()
+Sse_ReciprocalSqrt_69: <4.287809E-05, 0.0001977086, 4.4345856E-05, 8.9362264E-05>. array2: ()
+Sse_ReciprocalSqrtScalar_70: <NaN, -647177900, -458123200, -197744160>. array2: ()
+Sse_ReciprocalSqrtScalar_71: <NaN, 437562400, 312167300, 75870080>. array2: ()
+Sse_Shuffle_72: <103318530, 633020600, 519279620, 446014980>. array2: ()
+Sse_Sqrt_73: <32375.541, 18467.787, 10546.897, 13361.126>. array2: ()
+Sse_SqrtScalar_74: <NaN, -127137670, -374733950, -304894900>. array2: ()
+Sse_SqrtScalar_75: <0, -161208180, -370718370, -192715920>. array2: ()
+Sse_Store_76: . array2: (<524471360, 692894400, 517360540, 111962010>)
+Sse_StoreAligned_77: . array2: (<668176450, 603658900, 34112764, 33997604>)
+Sse_StoreAlignedNonTemporal_78: . array2: (<411258080, 295905300, 370917700, 136368000>)
+Sse_StoreFence_79: . array2: ()
+Sse_StoreHigh_80: . array2: (<-89017680, -350302900, 0, 0>)
+Sse_StoreLow_81: . array2: (<-934469570, -384415970, 0, 0>)
+Sse_StoreScalar_82: . array2: (<630363700, 0, 0, 0>)
+Sse_Subtract_83: <388175420, -28251904, -262372130, -16946368>. array2: ()
+Sse_SubtractScalar_84: <1.2341728E+09, 81653990, 332236930, 231184850>. array2: ()
+Sse_UnpackHigh_85: <234336190, -201399150, 11366093, -227744130>. array2: ()
+Sse_UnpackLow_86: <-460082180, 976768400, -71266130, 684022100>. array2: ()
+Sse_Xor_87: <5.454208E-37, 7.558558E-37, 2.2277044E-38, 3.4608778E-35>. array2: ()
+Sse2_Add_0: <157, 30, 117, 68, 254, 250, 198, 109, 226, 191, 114, 70, 98, 64, 124, 115>. array2: ()
+Sse2_Add_1: <111, -100, 31, 18, -104, 36, 62, 15, 116, -33, -46, -39, -31, -69, 75, -12>. array2: ()
+Sse2_Add_2: <-17349, 32646, 27366, 17847, -14439, 23263, -28227, 26507>. array2: ()
+Sse2_Add_3: <48597, 44533, 11015, 30391, 1888, 41608, 61458, 29007>. array2: ()
+Sse2_Add_4: <-2099012909, -1214463057, 748055490, 587046172>. array2: ()
+Sse2_Add_5: <2692053887, 675414813, 2668354831, 2361717631>. array2: ()
+Sse2_Add_6: <-5569845745187161295, 8239220397857138507>. array2: ()
+Sse2_Add_7: <313415891815243217, 1695776975936769365>. array2: ()
+Sse2_Add_8: <-1377217479, -1656960814>. array2: ()
+Sse2_AddSaturate_10: <255, 255, 255, 255, 180, 229, 94, 255, 255, 255, 255, 255, 255, 255, 245, 223>. array2: ()
+Sse2_AddSaturate_11: <32767, 22517, -782, 24849, 21420, 11609, 15738, 32767>. array2: ()
+Sse2_AddSaturate_12: <65535, 65535, 64391, 65535, 65535, 65535, 65535, 65535>. array2: ()
+Sse2_AddSaturate_9: <30, -24, 56, -11, 39, 80, 124, -91, -30, -63, 34, -24, 49, 33, 116, -108>. array2: ()
+Sse2_AddScalar_13: <1949344437, 759608663>. array2: ()
+Sse2_And_14: <225, 216, 33, 65, 4, 90, 0, 20, 64, 0, 0, 0, 121, 64, 24, 28>. array2: ()
+Sse2_And_15: <-62, 40, 32, 68, 91, 8, 66, 20, 0, 32, -108, 1, 16, 64, 36, 17>. array2: ()
+Sse2_And_16: <8280, 2066, 10244, 17476, 2112, 668, 1248, 108>. array2: ()
+Sse2_And_17: <17713, 8192, 51449, 4120, 1280, 770, 8738, 608>. array2: ()
+Sse2_And_18: <1485444, 603982148, 9310754, 1078465665>. array2: ()
+Sse2_And_19: <2674703, 537657472, 176440336, 142610944>. array2: ()
+Sse2_And_20: <2459037974327738368, 2396479261679681876>. array2: ()
+Sse2_And_21: <5332368611468922716, 576462964233077344>. array2: ()
+Sse2_And_22: <1343127624, 1688764441>. array2: ()
+Sse2_AndNot_23: <0, 65, 217, 228, 14, 22, 64, 132, 136, 129, 61, 192, 36, 32, 198, 140>. array2: ()
+Sse2_AndNot_24: <4, -117, 73, 64, 26, -84, 36, 32, 1, 4, 80, 6, -128, 3, -96, 4>. array2: ()
+Sse2_AndNot_25: <-32112, 2875, 15473, 14848, 6145, 5914, 66, 10025>. array2: ()
+Sse2_AndNot_26: <4117, 2596, 32778, 1472, 40198, 16402, 228, 4164>. array2: ()
+Sse2_AndNot_27: <134387840, 1703968, 705053332, 190873920>. array2: ()
+Sse2_AndNot_28: <2217877536, 2487419010, 2370521409, 2158904832>. array2: ()
+Sse2_AndNot_29: <-8914749681309833840, -7200969722687336402>. array2: ()
+Sse2_AndNot_30: <2901470452777135120, 2596364778247046146>. array2: ()
+Sse2_AndNot_31: <-2.308464469769642E-308, -4.5392050050569185E-306>. array2: ()
+Sse2_Average_32: <121, 65, 144, 155, 187, 250, 52, 133, 208, 55, 114, 135, 121, 199, 49, 158>. array2: ()
+Sse2_Average_33: <29628, 1975, 15380, 11051, 12362, 8455, 11592, 6841>. array2: ()
+Sse2_CompareEqual_34: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_CompareEqual_35: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_CompareEqual_36: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_CompareEqual_37: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_CompareEqual_38: <0, 0, 0, 0>. array2: ()
+Sse2_CompareEqual_39: <0, 0, 0, 0>. array2: ()
+Sse2_CompareEqual_40: <0, 0>. array2: ()
+Sse2_CompareGreaterThan_41: <-1, -1, 0, 0, -1, -1, -1, 0, 0, 0, -1, 0, 0, -1, -1, 0>. array2: ()
+Sse2_CompareGreaterThan_42: <0, -1, -1, -1, -1, -1, 0, -1>. array2: ()
+Sse2_CompareGreaterThan_43: <-1, -1, -1, -1>. array2: ()
+Sse2_CompareGreaterThan_44: <0, NaN>. array2: ()
+Sse2_CompareGreaterThanOrEqual_45: <0, 0>. array2: ()
+Sse2_CompareLessThan_46: <0, 0, 0, 0, 0, -1, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_CompareLessThan_47: <-1, 0, 0, 0, -1, 0, -1, 0>. array2: ()
+Sse2_CompareLessThan_48: <0, 0, 0, 0>. array2: ()
+Sse2_CompareLessThan_49: <0, 0>. array2: ()
+Sse2_CompareLessThanOrEqual_50: <NaN, NaN>. array2: ()
+Sse2_CompareNotEqual_51: <NaN, NaN>. array2: ()
+Sse2_CompareNotGreaterThan_52: <NaN, NaN>. array2: ()
+Sse2_CompareNotGreaterThanOrEqual_53: <0, 0>. array2: ()
+Sse2_CompareNotLessThan_54: <0, 0>. array2: ()
+Sse2_CompareNotLessThanOrEqual_55: <NaN, NaN>. array2: ()
+Sse2_CompareOrdered_56: <NaN, NaN>. array2: ()
+Sse2_CompareScalarEqual_57: <0, 2083712820>. array2: ()
+Sse2_CompareScalarGreaterThan_58: <0, 1650780952>. array2: ()
+Sse2_CompareScalarGreaterThanOrEqual_59: <NaN, 708005949>. array2: ()
+Sse2_CompareScalarLessThan_60: <0, 1627148431>. array2: ()
+Sse2_CompareScalarLessThanOrEqual_61: <0, 1720855119>. array2: ()
+Sse2_CompareScalarNotEqual_62: <NaN, 1203562733>. array2: ()
+Sse2_CompareScalarNotGreaterThan_63: <0, 743511762>. array2: ()
+Sse2_CompareScalarNotGreaterThanOrEqual_64: <0, 2122767112>. array2: ()
+Sse2_CompareScalarNotLessThan_65: <0, -495948320>. array2: ()
+Sse2_CompareScalarNotLessThanOrEqual_66: <NaN, 308710313>. array2: ()
+Sse2_CompareScalarOrdered_67: <NaN, 406820521>. array2: ()
+Sse2_CompareScalarOrderedEqual_68: False. array2: ()
+Sse2_CompareScalarOrderedGreaterThan_69: False. array2: ()
+Sse2_CompareScalarOrderedGreaterThanOrEqual_70: True. array2: ()
+Sse2_CompareScalarOrderedLessThan_71: False. array2: ()
+Sse2_CompareScalarOrderedLessThanOrEqual_72: False. array2: ()
+Sse2_CompareScalarOrderedNotEqual_73: True. array2: ()
+Sse2_CompareScalarUnordered_74: <0, 1260970130>. array2: ()
+Sse2_CompareScalarUnorderedEqual_75: False. array2: ()
+Sse2_CompareScalarUnorderedGreaterThan_76: False. array2: ()
+Sse2_CompareScalarUnorderedGreaterThanOrEqual_77: False. array2: ()
+Sse2_CompareScalarUnorderedLessThan_78: False. array2: ()
+Sse2_CompareScalarUnorderedLessThanOrEqual_79: False. array2: ()
+Sse2_CompareScalarUnorderedNotEqual_80: True. array2: ()
+Sse2_CompareUnordered_81: <0, 0>. array2: ()
+Sse2_ConvertScalarToVector128Double_82: <-593819705, -1566865401>. array2: ()
+Sse2_ConvertScalarToVector128Double_83: <264559328, 0>. array2: ()
+Sse2_ConvertScalarToVector128Int32_84: <1234688916, 0, 0, 0>. array2: ()
+Sse2_ConvertScalarToVector128Single_85: <336991780, 0, 0, 0>. array2: ()
+Sse2_ConvertScalarToVector128UInt32_86: <3853626177, 0, 0, 0>. array2: ()
+Sse2_ConvertToInt32_87: 1026923545. array2: ()
+Sse2_ConvertToInt32_88: 1003953677. array2: ()
+Sse2_ConvertToInt32WithTruncation_89: -1221922084. array2: ()
+Sse2_ConvertToUInt32_90: 2969051109. array2: ()
+Sse2_ConvertToVector128Double_91: <-324237430, -610879060>. array2: ()
+Sse2_ConvertToVector128Double_92: <0, 0>. array2: ()
+Sse2_ConvertToVector128Int32_93: <401491456, 32911600, 307468416, 3629614>. array2: ()
+Sse2_ConvertToVector128Int32_94: <695640577, 175680099, 0, 0>. array2: ()
+Sse2_ConvertToVector128Int32WithTruncation_95: <-341060096, -260400640, -35966700, -315059424>. array2: ()
+Sse2_ConvertToVector128Int32WithTruncation_96: <605491771, 1198610225, 0, 0>. array2: ()
+Sse2_ConvertToVector128Single_97: <1.8590148E+09, 741157630, 88313440, 1.6104324E+09>. array2: ()
+Sse2_ConvertToVector128Single_98: <861460740, 2.0822572E+09, 0, 0>. array2: ()
+Sse2_Divide_99: <-0.41013863773247955, -2.2583900973508606>. array2: ()
+Sse2_DivideScalar_100: <0.23868365208310682, 453983282>. array2: ()
+Sse2_Extract_101: 9206. array2: ()
+Sse2_Insert_103: <0, 0, -10045, 0, 0, 0, 0, 0>. array2: ()
+Sse2_Insert_104: <20620, 35164, 54090, 58235, 16240, 65465, 19696, 17652>. array2: ()
+Sse2_LoadAlignedVector128_105: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: ()
+Sse2_LoadAlignedVector128_106: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: ()
+Sse2_LoadAlignedVector128_107: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: ()
+Sse2_LoadAlignedVector128_108: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: ()
+Sse2_LoadAlignedVector128_109: <50462976, 117835012, 185207048, 252579084>. array2: ()
+Sse2_LoadAlignedVector128_110: <50462976, 117835012, 185207048, 252579084>. array2: ()
+Sse2_LoadAlignedVector128_111: <506097522914230528, 1084818905618843912>. array2: ()
+Sse2_LoadAlignedVector128_112: <506097522914230528, 1084818905618843912>. array2: ()
+Sse2_LoadAlignedVector128_113: <0, 0.3333333432674408>. array2: ()
+Sse2_LoadFence_114: . array2: ()
+Sse2_LoadHigh_115: <242191237, 0>. array2: ()
+Sse2_LoadLow_116: <0, 0>. array2: ()
+Sse2_LoadScalarVector128_117: <0, 0>. array2: ()
+Sse2_LoadScalarVector128_118: <50462976, 0, 0, 0>. array2: ()
+Sse2_LoadScalarVector128_119: <50462976, 0, 0, 0>. array2: ()
+Sse2_LoadScalarVector128_120: <506097522914230528, 0>. array2: ()
+Sse2_LoadScalarVector128_121: <506097522914230528, 0>. array2: ()
+Sse2_LoadVector128_122: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: ()
+Sse2_LoadVector128_123: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: ()
+Sse2_LoadVector128_124: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: ()
+Sse2_LoadVector128_125: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: ()
+Sse2_LoadVector128_126: <50462976, 117835012, 185207048, 252579084>. array2: ()
+Sse2_LoadVector128_127: <50462976, 117835012, 185207048, 252579084>. array2: ()
+Sse2_LoadVector128_128: <506097522914230528, 1084818905618843912>. array2: ()
+Sse2_LoadVector128_129: <506097522914230528, 1084818905618843912>. array2: ()
+Sse2_LoadVector128_130: <0, 0.3333333432674408>. array2: ()
+Sse2_MaskMove_131: . array2: ()
+Sse2_MaskMove_132: . array2: ()
+Sse2_Max_133: <46, 154, 117, 221, 251, 245, 249, 212, 128, 167, 140, 244, 205, 138, 224, 238>. array2: ()
+Sse2_Max_134: <17360, 32429, 18775, 858, 14102, 30506, -5851, 30258>. array2: ()
+Sse2_Max_135: <0, 0>. array2: ()
+Sse2_MaxScalar_136: <1355081192, 371420829>. array2: ()
+Sse2_MemoryFence_137: . array2: ()
+Sse2_Min_138: <117, 60, 0, 28, 52, 46, 24, 73, 91, 55, 124, 123, 212, 167, 206, 71>. array2: ()
+Sse2_Min_139: <4773, -26258, -31045, -14134, -19902, -7278, 200, -20325>. array2: ()
+Sse2_Min_140: <-498292418, -287844603>. array2: ()
+Sse2_MinScalar_141: <-719494121, 556225841>. array2: ()
+Sse2_MoveMask_142: 0. array2: ()
+Sse2_MoveMask_143: 17749. array2: ()
+Sse2_MoveMask_144: 3. array2: ()
+Sse2_MoveScalar_145: <358216876, 14573030>. array2: ()
+Sse2_MoveScalar_146: <8026354353478850732, 0>. array2: ()
+Sse2_MoveScalar_147: <11960848426434193404, 0>. array2: ()
+Sse2_Multiply_148: <946464580954712675, 1322844109440369358>. array2: ()
+Sse2_Multiply_149: <3.889913259521027E+18, 4.28768515710415E+17>. array2: ()
+Sse2_MultiplyAddAdjacent_150: <0, 0, 0, 0>. array2: ()
+Sse2_MultiplyHigh_151: <-136, -665, -3509, -2039, 681, -3653, -2098, -2340>. array2: ()
+Sse2_MultiplyHigh_152: <26601, 1648, 2913, 1028, 2499, 1409, 42537, 3604>. array2: ()
+Sse2_MultiplyLow_153: <18244, -27954, -20206, 24690, 3356, 12024, -31581, -73>. array2: ()
+Sse2_MultiplyLow_154: <47482, 14636, 24333, 13435, 33030, 46832, 57179, 12537>. array2: ()
+Sse2_MultiplyScalar_155: <-5.863772895193802E+17, 1111050795>. array2: ()
+Sse2_Or_156: <247, 124, 221, 191, 116, 178, 185, 249, 127, 223, 127, 207, 185, 211, 231, 131>. array2: ()
+Sse2_Or_157: <-3, -68, -69, -65, 65, 89, -1, -23, -39, -20, -41, -2, -1, -11, -12, -1>. array2: ()
+Sse2_Or_158: <-1159, -16514, 32723, -4130, 18431, -1, 24238, -16525>. array2: ()
+Sse2_Or_159: <64282, 25131, 53526, 24527, 15801, 20397, 6444, 9233>. array2: ()
+Sse2_Or_160: <-1363169726, -427819146, -16777987, -123350034>. array2: ()
+Sse2_Or_161: <4021272047, 3992975279, 3681512439, 4277138431>. array2: ()
+Sse2_Or_162: <8070443587545201599, 9219844371637592951>. array2: ()
+Sse2_Or_163: <9104447756691958458, 8610876712411787262>. array2: ()
+Sse2_Or_164: <6406789608, 2012196350>. array2: ()
+Sse2_PackSignedSaturate_165: <-128, -128, 127, -128, 127, -128, 127, -128, 127, 127, 127, 127, -128, 127, 127, 127>. array2: ()
+Sse2_PackSignedSaturate_166: <-32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768>. array2: ()
+Sse2_PackUnsignedSaturate_167: <0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0>. array2: ()
+Sse2_ShiftLeftLogical_168: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical_169: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical_170: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical_171: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical_172: <0, 0>. array2: ()
+Sse2_ShiftLeftLogical_173: <0, 0>. array2: ()
+Sse2_ShiftLeftLogical_174: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical_175: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical_176: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical_177: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical_178: <0, 0>. array2: ()
+Sse2_ShiftLeftLogical_179: <0, 0>. array2: ()
+Sse2_ShiftLeftLogical128BitLane_180: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical128BitLane_181: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical128BitLane_182: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical128BitLane_183: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical128BitLane_184: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftLeftLogical128BitLane_185: <0, 2927165440, 1053439790, 1500076848>. array2: ()
+Sse2_ShiftLeftLogical128BitLane_186: <0, 0>. array2: ()
+Sse2_ShiftLeftLogical128BitLane_187: <0, 0>. array2: ()
+Sse2_ShiftRightArithmetic_188: <-1, 0, 0, 0, -1, 0, -1, 0>. array2: ()
+Sse2_ShiftRightArithmetic_189: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightArithmetic_190: <-1, 0, -1, 0, -1, 0, -1, 0>. array2: ()
+Sse2_ShiftRightArithmetic_191: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical_192: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical_193: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical_194: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical_195: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical_196: <5844001493094162482, 6955472380474049021>. array2: ()
+Sse2_ShiftRightLogical_197: <0, 0>. array2: ()
+Sse2_ShiftRightLogical_198: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical_199: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical_200: <607, 772, 805, 541>. array2: ()
+Sse2_ShiftRightLogical_201: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical_202: <0, 0>. array2: ()
+Sse2_ShiftRightLogical_203: <0, 0>. array2: ()
+Sse2_ShiftRightLogical128BitLane_204: <-122, 120, 50, -69, -84, 56, 111, 51, -56, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical128BitLane_205: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical128BitLane_206: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical128BitLane_207: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical128BitLane_208: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical128BitLane_209: <0, 0, 0, 0>. array2: ()
+Sse2_ShiftRightLogical128BitLane_210: <0, 0>. array2: ()
+Sse2_ShiftRightLogical128BitLane_211: <0, 0>. array2: ()
+Sse2_Shuffle_212: <170398073, 1558314255, 170398073, 170398073>. array2: ()
+Sse2_Shuffle_213: <1028956739, 400946704>. array2: ()
+Sse2_Shuffle_214: <525659078, 525659078, 525659078, 836067957>. array2: ()
+Sse2_ShuffleHigh_215: <-30644, 9774, 5424, 9064, 22189, 20978, 20978, -13303>. array2: ()
+Sse2_ShuffleHigh_216: <15529, 15138, 12456, 25850, 11624, 18411, 11624, 11624>. array2: ()
+Sse2_ShuffleLow_217: <2167, 2167, 11159, 11159, -6897, 30123, -28312, 31844>. array2: ()
+Sse2_ShuffleLow_218: <20074, 15183, 15183, 15183, 61168, 15156, 23107, 363>. array2: ()
+Sse2_Sqrt_219: <0, 0>. array2: ()
+Sse2_SqrtScalar_220: <NaN, -857790740>. array2: ()
+Sse2_SqrtScalar_221: <NaN, 0>. array2: ()
+Sse2_Store_222: . array2: (<195, 45, 98, 147, 221, 239, 202, 231, 116, 155, 244, 160, 200, 64, 32, 146>)
+Sse2_Store_223: . array2: (<70, 19, 250, 175, 238, 14, 37, 240, 49, 43, 250, 176, 136, 252, 84, 230>)
+Sse2_Store_224: . array2: (<194, 151, 9, 235, 109, 26, 11, 183, 67, 160, 63, 166, 253, 115, 188, 164>)
+Sse2_Store_225: . array2: (<29, 146, 117, 106, 149, 161, 240, 52, 127, 242, 243, 123, 51, 244, 106, 99>)
+Sse2_Store_226: . array2: ()
+Sse2_Store_227: . array2: (<66, 56, 184, 20, 228, 16, 141, 35, 174, 186, 42, 75, 156, 29, 56, 110>)
+Sse2_Store_228: . array2: (<21, 186, 82, 120, 252, 42, 165, 83, 89, 127, 91, 41, 164, 226, 131, 91>)
+Sse2_Store_229: . array2: ()
+Sse2_Store_230: . array2: ()
+Sse2_StoreAligned_231: . array2: (<88, 151, 180, 106, 64, 107, 212, 36, 30, 113, 136, 60, 9, 52, 122, 99>)
+Sse2_StoreAligned_232: . array2: (<230, 220, 156, 17, 238, 140, 116, 98, 25, 209, 206, 34, 210, 128, 191, 39>)
+Sse2_StoreAligned_233: . array2: (<94, 50, 184, 106, 112, 183, 9, 15, 238, 235, 206, 126, 16, 245, 237, 21>)
+Sse2_StoreAligned_234: . array2: (<70, 255, 10, 176, 95, 53, 17, 165, 42, 36, 135, 211, 157, 201, 79, 187>)
+Sse2_StoreAligned_235: . array2: (<126, 69, 112, 12, 192, 218, 117, 81, 65, 61, 81, 65, 58, 102, 153, 31>)
+Sse2_StoreAligned_236: . array2: ()
+Sse2_StoreAligned_237: . array2: (<172, 114, 6, 101, 164, 156, 202, 79, 13, 12, 132, 107, 143, 185, 42, 16>)
+Sse2_StoreAligned_238: . array2: (<141, 73, 143, 71, 95, 77, 98, 97, 56, 4, 62, 49, 211, 195, 175, 75>)
+Sse2_StoreAligned_239: . array2: (<197365934, 1785457888>)
+Sse2_StoreAlignedNonTemporal_240: . array2: (<165, 74, 54, 189, 6, 179, 92, 193, 204, 212, 133, 179, 238, 167, 91, 137>)
+Sse2_StoreAlignedNonTemporal_241: . array2: (<227, 130, 78, 213, 121, 107, 223, 218, 55, 146, 69, 180, 80, 90, 20, 174>)
+Sse2_StoreAlignedNonTemporal_242: . array2: (<65, 206, 151, 81, 65, 231, 51, 81, 152, 188, 62, 25, 254, 45, 131, 99>)
+Sse2_StoreAlignedNonTemporal_243: . array2: (<240, 182, 61, 101, 14, 5, 13, 114, 24, 180, 10, 9, 173, 39, 88, 21>)
+Sse2_StoreAlignedNonTemporal_244: . array2: (<189, 198, 116, 82, 244, 2, 213, 43, 186, 149, 237, 26, 98, 171, 133, 35>)
+Sse2_StoreAlignedNonTemporal_245: . array2: (<171, 142, 164, 129, 207, 153, 231, 212, 166, 76, 109, 145, 151, 57, 79, 214>)
+Sse2_StoreAlignedNonTemporal_246: . array2: (<155, 88, 34, 11, 132, 38, 10, 85, 157, 88, 4, 34, 125, 161, 226, 0>)
+Sse2_StoreAlignedNonTemporal_247: . array2: ()
+Sse2_StoreAlignedNonTemporal_248: . array2: (<448427980, 160451659>)
+Sse2_StoreHigh_249: . array2: (<434912716, 0>)
+Sse2_StoreLow_250: . array2: (<2119419681, 0>)
+Sse2_StoreNonTemporal_251: . array2: (<183, 178, 255, 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>)
+Sse2_StoreNonTemporal_252: . array2: (<255, 104, 107, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>)
+Sse2_StoreScalar_253: . array2: ()
+Sse2_StoreScalar_254: . array2: (<77, 218, 255, 247, 122, 145, 210, 182, 0, 0, 0, 0, 0, 0, 0, 0>)
+Sse2_StoreScalar_255: . array2: (<173, 141, 34, 113, 223, 110, 135, 91, 0, 0, 0, 0, 0, 0, 0, 0>)
+Sse2_Subtract_256: <160, 230, 233, 215, 157, 62, 50, 132, 126, 224, 96, 124, 24, 75, 156, 27>. array2: ()
+Sse2_Subtract_257: <-73, -25, 74, 103, 80, -70, -44, 55, 30, -39, -89, 91, 37, 8, -85, -90>. array2: ()
+Sse2_Subtract_258: <21645, -29975, 1094, 17601, -13472, -9964, 11560, -24249>. array2: ()
+Sse2_Subtract_259: <26186, 3481, 38415, 7518, 17321, 4039, 44038, 26103>. array2: ()
+Sse2_Subtract_260: <1752063807, -2120203365, 1228453705, -2119657212>. array2: ()
+Sse2_Subtract_261: <3969082326, 2184163409, 4081145663, 4176352062>. array2: ()
+Sse2_Subtract_262: <-4910781699293484746, -3370418193084307290>. array2: ()
+Sse2_Subtract_263: <14342934063833242115, 17414808663155410193>. array2: ()
+Sse2_Subtract_264: <193503084, 843643408>. array2: ()
+Sse2_SubtractSaturate_265: <21, 1, 71, 127, -128, 68, 48, 127, -80, -19, 127, 105, 3, -128, 10, 53>. array2: ()
+Sse2_SubtractSaturate_266: <23654, 9415, -29015, -26904, -32768, -7444, 32767, -19469>. array2: ()
+Sse2_SubtractSaturate_267: <63, 171, 105, 0, 9, 0, 148, 1, 120, 0, 0, 45, 0, 59, 0, 39>. array2: ()
+Sse2_SubtractSaturate_268: <0, 0, 0, 0, 7195, 0, 0, 0>. array2: ()
+Sse2_SubtractScalar_269: <1970504049, 1505837714>. array2: ()
+Sse2_SumAbsoluteDifferences_270: <1022, 0, 0, 0, 992, 0, 0, 0>. array2: ()
+Sse2_UnpackHigh_271: <81, 59, 45, 174, 151, 115, 109, 178, 220, 64, 156, 107, 96, 28, 86, 177>. array2: ()
+Sse2_UnpackHigh_272: <4, -78, 15, 97, 85, -39, 70, 39, 85, -3, 114, 51, -86, 63, 19, 68>. array2: ()
+Sse2_UnpackHigh_273: <-24344, 10928, 20063, 8655, -23489, 23439, 12848, 27682>. array2: ()
+Sse2_UnpackHigh_274: <56624, 49657, 6555, 16770, 54792, 47497, 12329, 10935>. array2: ()
+Sse2_UnpackHigh_275: <-825727960, 1120004366, -1677873319, 440059928>. array2: ()
+Sse2_UnpackHigh_276: <3319442934, 996575506, 3072538177, 547440493>. array2: ()
+Sse2_UnpackHigh_277: <3425509541459654197, 0>. array2: ()
+Sse2_UnpackHigh_278: <9433075728538032088, 1802401848097591360>. array2: ()
+Sse2_UnpackHigh_279: <-1940783574, -88790362>. array2: ()
+Sse2_UnpackLow_280: <185, 20, 19, 134, 60, 169, 6, 226, 112, 116, 19, 133, 191, 30, 80, 223>. array2: ()
+Sse2_UnpackLow_281: <-24, -31, -112, -62, -57, 45, 120, -90, 17, 42, -63, 47, -83, -12, 1, -19>. array2: ()
+Sse2_UnpackLow_282: <12424, -6520, -32517, -20374, -22126, -7716, -15631, -8804>. array2: ()
+Sse2_UnpackLow_283: <55838, 34857, 45686, 46119, 7765, 50349, 47937, 63597>. array2: ()
+Sse2_UnpackLow_284: <1887548648, -106265407, 1948132023, -30817730>. array2: ()
+Sse2_UnpackLow_285: <1638019327, 1227734346, 291565234, 1511475018>. array2: ()
+Sse2_UnpackLow_286: <7967186738692185031, 6300179238364950333>. array2: ()
+Sse2_UnpackLow_287: <4302923488072565196, 1107715779998428353>. array2: ()
+Sse2_UnpackLow_288: <0, -1169211751>. array2: ()
+Sse2_Xor_289: <123, 176, 95, 128, 70, 47, 227, 174, 227, 215, 80, 165, 213, 114, 45, 254>. array2: ()
+Sse2_Xor_290: <12, 93, -36, -8, 125, 111, -58, -28, -48, 90, -44, -97, 7, -47, 41, -123>. array2: ()
+Sse2_Xor_291: <-29920, -4133, 13956, -16810, -24522, -15331, -17686, -32266>. array2: ()
+Sse2_Xor_292: <3063, 22132, 38842, 28704, 25905, 32058, 39706, 26936>. array2: ()
+Sse2_Xor_293: <755389418, 769245143, 76269295, 1263766898>. array2: ()
+Sse2_Xor_294: <2382442687, 3163532978, 2204809151, 4234290081>. array2: ()
+Sse2_Xor_295: <2709152929969082560, 6804690265923088076>. array2: ()
+Sse2_Xor_296: <10966841827685851620, 17485109639731884102>. array2: ()
+Sse2_Xor_297: <1.3179603345489727E-306, 2.7753908835538394E-306>. array2: ()
+Sse3_AddSubtract_0: <-288245800, 485282300, -148528380, 175195780>. array2: ()
+Sse3_AddSubtract_1: <377350428, 2880251686>. array2: ()
+Sse3_HorizontalAdd_3: <-1.4537478E+09, -608964740, 932101440, 317462530>. array2: ()
+Sse3_HorizontalAdd_4: <0, -1011215482>. array2: ()
+Sse3_HorizontalSubtract_5: <134859580, 290265800, -410409730, 225053500>. array2: ()
+Sse3_HorizontalSubtract_6: <-39981208, 772075022>. array2: ()
+Sse3_LoadAndDuplicateToVector128_7: <0, 0>. array2: ()
+Sse3_LoadDquVector128_10: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: ()
+Sse3_LoadDquVector128_11: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: ()
+Sse3_LoadDquVector128_12: <50462976, 117835012, 185207048, 252579084>. array2: ()
+Sse3_LoadDquVector128_13: <50462976, 117835012, 185207048, 252579084>. array2: ()
+Sse3_LoadDquVector128_14: <506097522914230528, 1084818905618843912>. array2: ()
+Sse3_LoadDquVector128_15: <506097522914230528, 1084818905618843912>. array2: ()
+Sse3_LoadDquVector128_8: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: ()
+Sse3_LoadDquVector128_9: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: ()
+Sse3_MoveAndDuplicate_16: <422894897, 422894897>. array2: ()
+Sse3_MoveHighAndDuplicate_17: <571501200, 571501200, 329727360, 329727360>. array2: ()
+Sse3_MoveLowAndDuplicate_18: <-189382530, -189382530, -201301700, -201301700>. array2: ()
+Sse41_Blend_0: <-28181, 8056, -26435, 1838, 18747, 5118, 1458, -6560>. array2: ()
+Sse41_Blend_1: <14880, 34662, 8325, 12447, 3177, 16199, 6880, 7815>. array2: ()
+Sse41_Blend_2: <491788830, 7742888, 361228860, 142832030>. array2: ()
+Sse41_Blend_3: <1824188881, -718259854>. array2: ()
+Sse41_BlendVariable_10: <-4986989475177804591, -3411647568405592666>. array2: ()
+Sse41_BlendVariable_11: <16427713610026539347, 17248869451145481562>. array2: ()
+Sse41_BlendVariable_12: <114734470, 113439390, 161092800, 334321300>. array2: ()
+Sse41_BlendVariable_13: <1271945793, 621651665>. array2: ()
+Sse41_BlendVariable_4: <-17, 87, 20, 53, 10, -33, 0, 65, 18, 7, 89, 73, -61, -105, -73, 48>. array2: ()
+Sse41_BlendVariable_5: <102, 26, 159, 80, 223, 125, 208, 80, 109, 87, 34, 5, 251, 3, 71, 85>. array2: ()
+Sse41_BlendVariable_6: <-31512, 848, -24102, 17728, 13830, 4091, 11118, 31413>. array2: ()
+Sse41_BlendVariable_7: <60928, 0, 6153, 5, 0, 13, 61440, 188>. array2: ()
+Sse41_BlendVariable_8: <1417959254, 237094035, 1139339792, 1710903878>. array2: ()
+Sse41_BlendVariable_9: <1936970067, 1287167484, 861093958, 1596488650>. array2: ()
+Sse41_Ceiling_14: <976807230, 387127940, 231049630, 95996256>. array2: ()
+Sse41_Ceiling_15: <-1271902475, -1320771022>. array2: ()
+Sse41_CeilingScalar_16: <596644776, 576770326>. array2: ()
+Sse41_CeilingScalar_17: <-996174700, -26349984, -199809980, -374892500>. array2: ()
+Sse41_CeilingScalar_18: <-1474400142, 1343022939>. array2: ()
+Sse41_CeilingScalar_19: <841868900, -645329300, -447306460, -27179420>. array2: ()
+Sse41_CompareEqual_20: <0, 0>. array2: ()
+Sse41_CompareEqual_21: <0, 0>. array2: ()
+Sse41_ConvertToVector128Int16_22: <-75, -56, 63, 60, -92, -10, -36, 7>. array2: ()
+Sse41_ConvertToVector128Int16_23: <242, 81, 177, 67, 109, 131, 246, 49>. array2: ()
+Sse41_ConvertToVector128Int16_24: <0, 1, 2, 3, 4, 5, 6, 7>. array2: ()
+Sse41_ConvertToVector128Int16_25: <0, 1, 2, 3, 4, 5, 6, 7>. array2: ()
+Sse41_ConvertToVector128Int32_26: <-58, 119, 104, -119>. array2: ()
+Sse41_ConvertToVector128Int32_27: <161, 95, 181, 45>. array2: ()
+Sse41_ConvertToVector128Int32_28: <-20353, -28133, -5483, -2632>. array2: ()
+Sse41_ConvertToVector128Int32_29: <58696, 60254, 11748, 60669>. array2: ()
+Sse41_ConvertToVector128Int32_30: <0, 1, 2, 3>. array2: ()
+Sse41_ConvertToVector128Int32_31: <0, 1, 2, 3>. array2: ()
+Sse41_ConvertToVector128Int32_32: <256, 770, 1284, 1798>. array2: ()
+Sse41_ConvertToVector128Int32_33: <256, 770, 1284, 1798>. array2: ()
+Sse41_ConvertToVector128Int64_34: <-89, -82>. array2: ()
+Sse41_ConvertToVector128Int64_35: <231, 107>. array2: ()
+Sse41_ConvertToVector128Int64_36: <18053, -15316>. array2: ()
+Sse41_ConvertToVector128Int64_37: <30546, 35535>. array2: ()
+Sse41_ConvertToVector128Int64_38: <2005088466, 1180082193>. array2: ()
+Sse41_ConvertToVector128Int64_39: <0, 0>. array2: ()
+Sse41_ConvertToVector128Int64_40: <0, 1>. array2: ()
+Sse41_ConvertToVector128Int64_41: <0, 1>. array2: ()
+Sse41_ConvertToVector128Int64_42: <256, 770>. array2: ()
+Sse41_ConvertToVector128Int64_43: <256, 770>. array2: ()
+Sse41_ConvertToVector128Int64_44: <50462976, 117835012>. array2: ()
+Sse41_ConvertToVector128Int64_45: <50462976, 117835012>. array2: ()
+Sse41_DotProduct_46: <0, 0, 0, 0>. array2: ()
+Sse41_DotProduct_47: <0, 0>. array2: ()
+Sse41_Extract_48: 0. array2: ()
+Sse41_Extract_49: 205898021. array2: ()
+Sse41_Extract_50: 2010097471. array2: ()
+Sse41_Extract_51: 443243500. array2: ()
+Sse41_Floor_52: <386100000, 207527100, 495481120, 19563034>. array2: ()
+Sse41_Floor_53: <1749484095, 254253946>. array2: ()
+Sse41_FloorScalar_54: <2105495297, 1615400991>. array2: ()
+Sse41_FloorScalar_55: <600926660, 470214500, 195817310, 346740700>. array2: ()
+Sse41_FloorScalar_56: <751097772, 0>. array2: ()
+Sse41_FloorScalar_57: <938370050, -39845504, -43406284, -151803180>. array2: ()
+Sse41_Insert_59: <-1, -27, 59, 87, -116, -128, -32, 82, 126, -109, -14, 83, -108, 61, 90, 39>. array2: ()
+Sse41_Insert_60: <50, 137, 132, 245, 172, 251, 139, 204, 26, 85, 175, 202, 195, 167, 175, 133>. array2: ()
+Sse41_Insert_61: <113469686, 366453791, -1696173006, 1426620191>. array2: ()
+Sse41_Insert_62: <3319556977, 1821918078, 2572121724, 2432579270>. array2: ()
+Sse41_Insert_63: <794284160, -10099458, 440350530, 106081200>. array2: ()
+Sse41_LoadAlignedVector128NonTemporal_64: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: ()
+Sse41_LoadAlignedVector128NonTemporal_65: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: ()
+Sse41_LoadAlignedVector128NonTemporal_66: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: ()
+Sse41_LoadAlignedVector128NonTemporal_67: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: ()
+Sse41_LoadAlignedVector128NonTemporal_68: <50462976, 117835012, 185207048, 252579084>. array2: ()
+Sse41_LoadAlignedVector128NonTemporal_69: <50462976, 117835012, 185207048, 252579084>. array2: ()
+Sse41_LoadAlignedVector128NonTemporal_70: <506097522914230528, 1084818905618843912>. array2: ()
+Sse41_LoadAlignedVector128NonTemporal_71: <506097522914230528, 1084818905618843912>. array2: ()
+Sse41_Max_72: <0, 62, 14, 0, 0, 23, 0, 0, 0, 44, 0, 0, 60, 0, 18, 0>. array2: ()
+Sse41_Max_73: <64529, 24246, 60292, 11349, 52920, 7767, 46095, 16553>. array2: ()
+Sse41_Max_74: <1468978862, 1260319873, 1553029212, 1159805043>. array2: ()
+Sse41_Max_75: <3303376326, 2933272066, 2724997452, 3968450988>. array2: ()
+Sse41_Min_76: <-24, -70, 89, 50, -41, -78, -86, 4, 4, 2, -54, 70, -63, -34, 67, 19>. array2: ()
+Sse41_Min_77: <19072, 10363, 7372, 16990, 17907, 25895, 25631, 8780>. array2: ()
+Sse41_Min_78: <227355155, 833264934, 182554724, 552275494>. array2: ()
+Sse41_Min_79: <1682696560, 1415080162, 1093433754, 1402296729>. array2: ()
+Sse41_MinHorizontal_80: <7625, 4, 0, 0, 0, 0, 0, 0>. array2: ()
+Sse41_MultipleSumAbsoluteDifferences_81: <510, 411, 458, 485, 446, 477, 418, 429>. array2: ()
+Sse41_Multiply_82: <0, 0>. array2: ()
+Sse41_MultiplyLow_83: <-444023120, -1604807418, -513618072, 364285130>. array2: ()
+Sse41_MultiplyLow_84: <2842399402, 3219790566, 82485812, 798265648>. array2: ()
+Sse41_PackUnsignedSaturate_85: <65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535>. array2: ()
+Sse41_RoundCurrentDirection_86: <1439949737, 982687573>. array2: ()
+Sse41_RoundCurrentDirection_87: <94789504, 306488300, 300036380, 200679310>. array2: ()
+Sse41_RoundCurrentDirectionScalar_88: <-514290506, -975606360>. array2: ()
+Sse41_RoundCurrentDirectionScalar_89: <-151982141, 1381285838>. array2: ()
+Sse41_RoundCurrentDirectionScalar_90: <1.0009005E+09, 82311576, 420004580, 377080260>. array2: ()
+Sse41_RoundCurrentDirectionScalar_91: <908986750, 0, 0, 0>. array2: ()
+Sse41_RoundToNearestInteger_92: <971570600, 342674340, 84637136, 279661020>. array2: ()
+Sse41_RoundToNearestInteger_93: <0, 0>. array2: ()
+Sse41_RoundToNearestIntegerScalar_94: <1503033702, 1356128743>. array2: ()
+Sse41_RoundToNearestIntegerScalar_95: <1958960619, 397956293>. array2: ()
+Sse41_RoundToNearestIntegerScalar_96: <115528456, 284659620, 172975940, 167663550>. array2: ()
+Sse41_RoundToNearestIntegerScalar_97: <-829306000, 0, 0, 0>. array2: ()
+Sse41_RoundToNegativeInfinity_98: <613514000, 556777100, 409394500, 70652570>. array2: ()
+Sse41_RoundToNegativeInfinity_99: <901160652, 699665279>. array2: ()
+Sse41_RoundToNegativeInfinityScalar_100: <0, 0>. array2: ()
+Sse41_RoundToNegativeInfinityScalar_101: <1083911923, -369574546>. array2: ()
+Sse41_RoundToNegativeInfinityScalar_102: <1.0058966E+09, 224250110, 97383590, 256521380>. array2: ()
+Sse41_RoundToNegativeInfinityScalar_103: <569111040, -706565950, -134511490, -170974940>. array2: ()
+Sse41_RoundToPositiveInfinity_104: <-1346950085, -1061512967>. array2: ()
+Sse41_RoundToPositiveInfinity_105: <-437554370, -688066100, -401424450, -24426856>. array2: ()
+Sse41_RoundToPositiveInfinityScalar_106: <1678875284, 1006413517>. array2: ()
+Sse41_RoundToPositiveInfinityScalar_107: <0, 1793942551>. array2: ()
+Sse41_RoundToPositiveInfinityScalar_108: <-949690750, -20584142, -125257490, -132031256>. array2: ()
+Sse41_RoundToPositiveInfinityScalar_109: <0, -7623213.5, -369909760, -333072740>. array2: ()
+Sse41_RoundToZero_110: <-164666379, -6857492>. array2: ()
+Sse41_RoundToZero_111: <-727772600, -644844740, -52200804, -334492600>. array2: ()
+Sse41_RoundToZeroScalar_112: <0, 0>. array2: ()
+Sse41_RoundToZeroScalar_113: <325755288, 284278557>. array2: ()
+Sse41_RoundToZeroScalar_114: <370526980, 450870270, 114232630, 101882510>. array2: ()
+Sse41_RoundToZeroScalar_115: <199417310, 575768600, 454732830, 146941410>. array2: ()
+Sse41_TestC_116: False. array2: ()
+Sse41_TestC_117: False. array2: ()
+Sse41_TestC_118: False. array2: ()
+Sse41_TestC_119: False. array2: ()
+Sse41_TestC_120: False. array2: ()
+Sse41_TestC_121: False. array2: ()
+Sse41_TestC_122: False. array2: ()
+Sse41_TestC_123: False. array2: ()
+Sse41_TestNotZAndNotC_124: True. array2: ()
+Sse41_TestNotZAndNotC_125: True. array2: ()
+Sse41_TestNotZAndNotC_126: True. array2: ()
+Sse41_TestNotZAndNotC_127: True. array2: ()
+Sse41_TestNotZAndNotC_128: True. array2: ()
+Sse41_TestNotZAndNotC_129: True. array2: ()
+Sse41_TestNotZAndNotC_130: False. array2: ()
+Sse41_TestNotZAndNotC_131: True. array2: ()
+Sse41_TestZ_132: False. array2: ()
+Sse41_TestZ_133: False. array2: ()
+Sse41_TestZ_134: True. array2: ()
+Sse41_TestZ_135: False. array2: ()
+Sse41_TestZ_136: False. array2: ()
+Sse41_TestZ_137: True. array2: ()
+Sse41_TestZ_138: True. array2: ()
+Sse41_TestZ_139: True. array2: ()
+Sse42_CompareGreaterThan_0: <-1, -1>. array2: ()
+Sse42_Crc32_1: 3048296493. array2: ()
+Sse42_Crc32_2: 720008765. array2: ()
+Sse42_Crc32_3: 1709792733. array2: ()
+Ssse3_Abs_0: <20, 123, 42, 117, 5, 108, 125, 122, 2, 74, 125, 98, 15, 83, 90, 120>. array2: ()
+Ssse3_Abs_1: <15049, 32579, 12411, 18332, 19344, 20844, 19247, 7169>. array2: ()
+Ssse3_Abs_2: <1289855926, 1521543026, 1209975474, 1048481122>. array2: ()
+Ssse3_AlignRight_10: <0, 0>. array2: ()
+Ssse3_AlignRight_3: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Ssse3_AlignRight_4: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Ssse3_AlignRight_5: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Ssse3_AlignRight_6: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Ssse3_AlignRight_7: <-588188473, -861861738, -970398219, 0>. array2: ()
+Ssse3_AlignRight_8: <0, 0, 0, 0>. array2: ()
+Ssse3_AlignRight_9: <0, 0>. array2: ()
+Ssse3_HorizontalAdd_12: <-28016, -14356, -25639, -6147, 29319, 31790, 19886, -11366>. array2: ()
+Ssse3_HorizontalAdd_13: <0, 0, 0, 0>. array2: ()
+Ssse3_HorizontalAddSaturate_14: <30343, 25832, 71, 3968, 25111, 5416, 13362, -27366>. array2: ()
+Ssse3_HorizontalSubtract_15: <-17693, -24059, 14090, 11294, -30328, 3313, -3245, -31852>. array2: ()
+Ssse3_HorizontalSubtract_16: <1423497201, 543575668, -141636812, 445982764>. array2: ()
+Ssse3_HorizontalSubtractSaturate_17: <-32768, -23864, -11719, -32768, -18996, -16034, 7266, -21252>. array2: ()
+Ssse3_MultiplyAddAdjacent_18: <-8018, -6804, 12098, -25160, 26653, -13540, 32767, 5758>. array2: ()
+Ssse3_MultiplyHighRoundScale_19: <0, 0, 0, 0, 0, 0, 0, 0>. array2: ()
+Ssse3_Shuffle_20: <41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41>. array2: ()
+Ssse3_Shuffle_21: <131, 180, 36, 211, 140, 71, 0, 36, 0, 0, 32, 252, 250, 5, 0, 245>. array2: ()
+Ssse3_Sign_22: <114, -57, 105, -103, -101, 43, -3, -94, -64, -80, -24, -55, 57, 70, -96, -85>. array2: ()
+Ssse3_Sign_23: <8146, 23251, -5348, 13795, 16285, 31796, -1712, 19564>. array2: ()
+Ssse3_Sign_24: <-1690542095, -1073268168, -1839363387, -426479517>. array2: ()
+Vector128_byte_to_int: <1881994049, -584023631, -1957556255, 1248354443>. array2: ()
+Vector128_Create_1: <37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37>. array2: ()
+Vector128_Create_10: <-112905214.5, -112905214.5>. array2: ()
+Vector128_Create_11: <1043346112.5, -989284283>. array2: ()
+Vector128_Create_12: <-1494540230, -1006562512>. array2: ()
+Vector128_Create_13: <1739630930, 18446744073526515366>. array2: ()
+Vector128_Create_14: <706899800, -723907460, -320707740, 634857800>. array2: ()
+Vector128_Create_15: <-1325323419, 815439320, -1175553948, -2143918760>. array2: ()
+Vector128_Create_16: <380379792, 702957838, 734971347, 975465225>. array2: ()
+Vector128_Create_17: <36832, 33999, 43142, 4384, 48727, 60061, 19158, 56428>. array2: ()
+Vector128_Create_18: <3028, -26498, -7017, -2304, -23167, 20218, 23682, 25060>. array2: ()
+Vector128_Create_2: <-48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48>. array2: ()
+Vector128_Create_20: <81, -49, 50, 110, -51, -100, -120, 55, -25, -37, -18, 47, 40, 62, 104, 42>. array2: ()
+Vector128_Create_3: <11289, 11289, 11289, 11289, 11289, 11289, 11289, 11289>. array2: ()
+Vector128_Create_4: <17230, 17230, 17230, 17230, 17230, 17230, 17230, 17230>. array2: ()
+Vector128_Create_5: <1644952972, 1644952972, 1644952972, 1644952972>. array2: ()
+Vector128_Create_6: <687315921, 687315921, 687315921, 687315921>. array2: ()
+Vector128_Create_7: <-1945223177, -1945223177>. array2: ()
+Vector128_Create_8: <2012609464, 2012609464>. array2: ()
+Vector128_Create_9: <7037300, 7037300, 7037300, 7037300>. array2: ()
+Vector128_CreateScalarUnsafe_1: 50. array2: ()
+Vector128_CreateScalarUnsafe_2: 50. array2: ()
+Vector128_int_to_byte: <39, 29, 58, 30, 232, 148, 103, 159, 80, 53, 164, 98, 116, 134, 103, 206>. array2: ()
+Vector128_int_to_ulong: <15148853770521024483, 12898404362374625286>. array2: ()
projects / platform / upstream / dotnet / runtime.git / commitdiff