From: Egor Bogatov Date: Mon, 13 Jan 2020 12:51:51 +0000 (+0300) Subject: [netcore][llvm] Implement Sse1-4.2 subsets used by corlib (mono/mono#18103) X-Git-Tag: submit/tizen/20210909.063632~10331^2~5^2~28 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=9a9f239ee7e54cde93372c9db2a6cb2ae052b942;p=platform%2Fupstream%2Fdotnet%2Fruntime.git [netcore][llvm] Implement Sse1-4.2 subsets used by corlib (mono/mono#18103) * Implement SSE41 subset used by corlib * Implement Sse2.MoveMask * only works with llvm * Implement Sse3 and Ssse3 subsets used by corlib * Implement a few SSE1 methods * Address feedback, also, implement Sse.Add/Subtract * Fix build * Implement Sse.Multiply, Sse.Store * Implement Sse.CompareNotEquals * Implement Sse.MoveScalar * Finish SSE1 corlib subset * Implement Sse.LoadVector128, Sse.Shuffle * Sse.Shuffle cleanup * Implement Sse2 APIs * More of SSE2: LoadAlignedVector128, Compare* * Implement Sse2.Unpack* and Sse2.StoreScalar * Implement Sse2.PackUnsignedSaturate * Implement Sse2.ShiftRightLogical * Implement Sse2.Shuffle * Implement Vector128.Zero * Fix CreateScalarUnsafe * Implement Vector128.As*, Fix Vector128.CreateScalarUnsafe * Fix failures * Fix failures * Fix Sse.MoveMask * remove redundant null checks * Fix AOT failures * fix compilation warrning * rename create_vector_mask_* * Fix failures found via tests * Index in Sse41.Insert has to be a constant * add local tests for mono * Update tests (cleanup) * Code cleanup * test * fix typo * Clean up * Clean up * Implement And, AndNot, Or, Xor, Divide for Sse1 * Cleanup * Fix build * limit emit_vector128 with LLVM * enable IsSupported for corlib * Fix build on wasm (if-defs issue) * Don't intrinsify Vector256 * Address feedback Commit migrated from https://github.com/mono/mono/commit/423192ed85c0b2263b46f3f4cfa63ec7b90b3f31 --- diff --git a/src/mono/mono/mini/mini-llvm.c b/src/mono/mono/mini/mini-llvm.c index 3a91bdc..0881f9a 100644 --- a/src/mono/mono/mini/mini-llvm.c +++ b/src/mono/mono/mini/mini-llvm.c @@ -336,6 +336,8 @@ typedef enum { 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, @@ -388,6 +390,9 @@ typedef enum { 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, @@ -548,11 +553,15 @@ type_to_simd_type (int type) { 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: @@ -605,32 +614,17 @@ create_llvm_type_for_type (MonoLLVMModule *module, MonoClass *klass) 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: @@ -643,6 +637,31 @@ type_to_llvm_type (EmitContext *ctx, MonoType *t) 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: { @@ -4510,6 +4529,36 @@ emit_landing_pad (EmitContext *ctx, int group_index, int group_size) 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) @@ -7378,6 +7427,227 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb) } #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]; @@ -7398,6 +7668,34 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb) 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 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 @@ -8939,6 +9237,8 @@ static IntrinsicDesc intrinsics[] = { {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"}, @@ -8988,9 +9288,12 @@ static IntrinsicDesc intrinsics[] = { {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"}, @@ -9168,6 +9471,12 @@ add_intrinsic (LLVMModuleRef module, int id) 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: @@ -9308,6 +9617,7 @@ add_intrinsic (LLVMModuleRef module, int id) 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: @@ -9315,6 +9625,17 @@ add_intrinsic (LLVMModuleRef module, int id) 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; diff --git a/src/mono/mono/mini/mini-ops.h b/src/mono/mono/mini/mini-ops.h index 4bc8669..74500e5 100644 --- a/src/mono/mono/mini/mini-ops.h +++ b/src/mono/mono/mini/mini-ops.h @@ -1004,11 +1004,41 @@ MINI_OP(OP_CVTTPS2DQ, "cvttps2dq", XREG, XREG, NONE) /* 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 */ @@ -1031,6 +1061,8 @@ MINI_OP3(OP_MULX_HL64, "mulxhl64", LREG, LREG, LREG, LREG) #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) diff --git a/src/mono/mono/mini/simd-intrinsics-netcore.c b/src/mono/mono/mini/simd-intrinsics-netcore.c index 24cbae6..acd3bae 100644 --- a/src/mono/mono/mini/simd-intrinsics-netcore.c +++ b/src/mono/mono/mini/simd-intrinsics-netcore.c @@ -181,8 +181,6 @@ emit_simd_ins (MonoCompile *cfg, MonoClass *klass, int opcode, int sreg1, int sr } 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; @@ -192,14 +190,55 @@ emit_simd_ins (MonoCompile *cfg, MonoClass *klass, int opcode, int sreg1, int sr } 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 => 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; } @@ -211,7 +250,10 @@ get_vector_t_elem_type (MonoType *vector_type) 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; } @@ -350,7 +392,7 @@ emit_sys_numerics_vector_t (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSig 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)) @@ -471,7 +513,7 @@ emit_sys_numerics_vector_t (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSig 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: @@ -493,7 +535,7 @@ emit_sys_numerics_vector_t (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSig 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; @@ -597,6 +639,75 @@ emit_sys_numerics_vector_t (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSig #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 @@ -628,22 +739,250 @@ static guint16 bmi2_methods [] = { 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: @@ -663,13 +1002,12 @@ emit_x86_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature 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: @@ -689,14 +1027,13 @@ emit_x86_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature 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: @@ -763,13 +1100,12 @@ emit_x86_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature 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: @@ -829,11 +1165,78 @@ emit_x86_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature } #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; @@ -867,6 +1270,9 @@ emit_vector128_t (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fs 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; } @@ -944,6 +1350,8 @@ mono_emit_simd_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign 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); } diff --git a/src/mono/mono/mini/simd-methods-netcore.h b/src/mono/mono/mini/simd-methods-netcore.h index efabc55..577f54d 100644 --- a/src/mono/mono/mini/simd-methods-netcore.h +++ b/src/mono/mono/mini/simd-methods-netcore.h @@ -35,15 +35,60 @@ METHOD(ConvertToSingle) 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 diff --git a/src/mono/netcore/Makefile b/src/mono/netcore/Makefile old mode 100755 new mode 100644 index 7c56582..d96668e --- a/src/mono/netcore/Makefile +++ b/src/mono/netcore/Makefile @@ -274,6 +274,28 @@ run-tests-coreclr: prepare update-tests-coreclr corerun 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 "***************** $* *********************" diff --git a/src/mono/netcore/tests/HwIntrinsics/HwIntrinsics.csproj b/src/mono/netcore/tests/HwIntrinsics/HwIntrinsics.csproj new file mode 100644 index 0000000..08cba7b --- /dev/null +++ b/src/mono/netcore/tests/HwIntrinsics/HwIntrinsics.csproj @@ -0,0 +1,11 @@ + + + Exe + True + Full + bin + netcoreapp3.0 + false + true + + diff --git a/src/mono/netcore/tests/HwIntrinsics/Program.cs b/src/mono/netcore/tests/HwIntrinsics/Program.cs new file mode 100644 index 0000000..a906f23 --- /dev/null +++ b/src/mono/netcore/tests/HwIntrinsics/Program.cs @@ -0,0 +1,844 @@ +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 (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 (4); + pArray2Float = AllocateAligned (4); + pArray1Double = AllocateAligned (2); + pArray2Double = AllocateAligned (2); + pArray1 = AllocateAligned (16); + pArray2 = AllocateAligned (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* array) where T : unmanaged + { + for (var i = 0; i < Vector128.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* array) where T : unmanaged + { + var sb = new StringBuilder (); + sb.Append ("<"); + for (var i = 0; i < Vector128.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 GetV128 () 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 (); + } + else if (typeof(T) == typeof (double)) + { + return Vector128.Create ( + (double)(rand.Next () * randMult), + (double)(rand.Next () * randMult)).As (); + } + + 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 (); + } + + T Get () + { + 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 Sse_Add_0() => Sse.Add(GetV128(), GetV128()); + public Vector128 Sse_AddScalar_1() => Sse.AddScalar(GetV128(), GetV128()); + public Vector128 Sse_And_2() => Sse.And(GetV128(), GetV128()); + public Vector128 Sse_AndNot_3() => Sse.AndNot(GetV128(), GetV128()); + public Vector128 Sse_CompareEqual_4() => Sse.CompareEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareGreaterThan_5() => Sse.CompareGreaterThan(GetV128(), GetV128()); + public Vector128 Sse_CompareGreaterThanOrEqual_6() => Sse.CompareGreaterThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareLessThan_7() => Sse.CompareLessThan(GetV128(), GetV128()); + public Vector128 Sse_CompareLessThanOrEqual_8() => Sse.CompareLessThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareNotEqual_9() => Sse.CompareNotEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareNotGreaterThan_10() => Sse.CompareNotGreaterThan(GetV128(), GetV128()); + public Vector128 Sse_CompareNotGreaterThanOrEqual_11() => Sse.CompareNotGreaterThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareNotLessThan_12() => Sse.CompareNotLessThan(GetV128(), GetV128()); + public Vector128 Sse_CompareNotLessThanOrEqual_13() => Sse.CompareNotLessThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareOrdered_14() => Sse.CompareOrdered(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarEqual_15() => Sse.CompareScalarEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarGreaterThan_16() => Sse.CompareScalarGreaterThan(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarGreaterThanOrEqual_17() => Sse.CompareScalarGreaterThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarLessThan_18() => Sse.CompareScalarLessThan(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarLessThanOrEqual_19() => Sse.CompareScalarLessThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarNotEqual_20() => Sse.CompareScalarNotEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarNotGreaterThan_21() => Sse.CompareScalarNotGreaterThan(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarNotGreaterThanOrEqual_22() => Sse.CompareScalarNotGreaterThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarNotLessThan_23() => Sse.CompareScalarNotLessThan(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarNotLessThanOrEqual_24() => Sse.CompareScalarNotLessThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarOrdered_25() => Sse.CompareScalarOrdered(GetV128(), GetV128()); + public Boolean Sse_CompareScalarOrderedEqual_26() => Sse.CompareScalarOrderedEqual(GetV128(), GetV128()); + public Boolean Sse_CompareScalarOrderedGreaterThan_27() => Sse.CompareScalarOrderedGreaterThan(GetV128(), GetV128()); + public Boolean Sse_CompareScalarOrderedGreaterThanOrEqual_28() => Sse.CompareScalarOrderedGreaterThanOrEqual(GetV128(), GetV128()); + public Boolean Sse_CompareScalarOrderedLessThan_29() => Sse.CompareScalarOrderedLessThan(GetV128(), GetV128()); + public Boolean Sse_CompareScalarOrderedLessThanOrEqual_30() => Sse.CompareScalarOrderedLessThanOrEqual(GetV128(), GetV128()); + public Boolean Sse_CompareScalarOrderedNotEqual_31() => Sse.CompareScalarOrderedNotEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareScalarUnordered_32() => Sse.CompareScalarUnordered(GetV128(), GetV128()); + public Boolean Sse_CompareScalarUnorderedEqual_33() => Sse.CompareScalarUnorderedEqual(GetV128(), GetV128()); + public Boolean Sse_CompareScalarUnorderedGreaterThan_34() => Sse.CompareScalarUnorderedGreaterThan(GetV128(), GetV128()); + public Boolean Sse_CompareScalarUnorderedGreaterThanOrEqual_35() => Sse.CompareScalarUnorderedGreaterThanOrEqual(GetV128(), GetV128()); + public Boolean Sse_CompareScalarUnorderedLessThan_36() => Sse.CompareScalarUnorderedLessThan(GetV128(), GetV128()); + public Boolean Sse_CompareScalarUnorderedLessThanOrEqual_37() => Sse.CompareScalarUnorderedLessThanOrEqual(GetV128(), GetV128()); + public Boolean Sse_CompareScalarUnorderedNotEqual_38() => Sse.CompareScalarUnorderedNotEqual(GetV128(), GetV128()); + public Vector128 Sse_CompareUnordered_39() => Sse.CompareUnordered(GetV128(), GetV128()); + public Vector128 Sse_ConvertScalarToVector128Single_40() => Sse.ConvertScalarToVector128Single(GetV128(), Get()); + public Int32 Sse_ConvertToInt32_41() => Sse.ConvertToInt32(GetV128()); + public Int32 Sse_ConvertToInt32WithTruncation_42() => Sse.ConvertToInt32WithTruncation(GetV128()); + public Vector128 Sse_Divide_43() => Sse.Divide(GetV128(), GetV128()); + public Vector128 Sse_DivideScalar_44() => Sse.DivideScalar(GetV128(), GetV128()); + public Vector128 Sse_LoadAlignedVector128_46() => Sse.LoadAlignedVector128((pArray1Float)); + public Vector128 Sse_LoadHigh_47() => Sse.LoadHigh(GetV128(), pArray1Float); + public Vector128 Sse_LoadLow_48() => Sse.LoadLow(GetV128(), pArray1Float); + public Vector128 Sse_LoadScalarVector128_49() => Sse.LoadScalarVector128(pArray1Float); + public Vector128 Sse_LoadVector128_50() => Sse.LoadVector128(pArray1Float); + public Vector128 Sse_Max_51() => Sse.Max(GetV128(), GetV128()); + public Vector128 Sse_MaxScalar_52() => Sse.MaxScalar(GetV128(), GetV128()); + public Vector128 Sse_Min_53() => Sse.Min(GetV128(), GetV128()); + public Vector128 Sse_MinScalar_54() => Sse.MinScalar(GetV128(), GetV128()); + public Vector128 Sse_MoveHighToLow_55() => Sse.MoveHighToLow(GetV128(), GetV128()); + public Vector128 Sse_MoveLowToHigh_56() => Sse.MoveLowToHigh(GetV128(), GetV128()); + public Int32 Sse_MoveMask_57() => Sse.MoveMask(GetV128()); + public Vector128 Sse_MoveScalar_58() => Sse.MoveScalar(GetV128(), GetV128()); + public Vector128 Sse_Multiply_59() => Sse.Multiply(GetV128(), GetV128()); + public Vector128 Sse_MultiplyScalar_60() => Sse.MultiplyScalar(GetV128(), GetV128()); + public Vector128 Sse_Or_61() => Sse.Or(GetV128(), GetV128()); + 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 Sse_Reciprocal_66() => Sse.Reciprocal(GetV128()); + public Vector128 Sse_ReciprocalScalar_67() => Sse.ReciprocalScalar(GetV128()); + public Vector128 Sse_ReciprocalScalar_68() => Sse.ReciprocalScalar(GetV128(), GetV128()); + public Vector128 Sse_ReciprocalSqrt_69() => Sse.ReciprocalSqrt(GetV128()); + public Vector128 Sse_ReciprocalSqrtScalar_70() => Sse.ReciprocalSqrtScalar(GetV128()); + public Vector128 Sse_ReciprocalSqrtScalar_71() => Sse.ReciprocalSqrtScalar(GetV128(), GetV128()); + public Vector128 Sse_Shuffle_72() => Sse.Shuffle(GetV128(), GetV128(), 22); + public Vector128 Sse_Sqrt_73() => Sse.Sqrt(GetV128()); + public Vector128 Sse_SqrtScalar_74() => Sse.SqrtScalar(GetV128()); + public Vector128 Sse_SqrtScalar_75() => Sse.SqrtScalar(GetV128(), GetV128()); + public void Sse_Store_76() => Sse.Store(pArray2Float, GetV128()); + public void Sse_StoreAligned_77() => Sse.StoreAligned((pArray2Float), GetV128()); + public void Sse_StoreAlignedNonTemporal_78() => Sse.StoreAlignedNonTemporal((pArray2Float), GetV128()); + public void Sse_StoreFence_79() => Sse.StoreFence(); + public void Sse_StoreHigh_80() => Sse.StoreHigh(pArray2Float, GetV128()); + public void Sse_StoreLow_81() => Sse.StoreLow(pArray2Float, GetV128()); + public void Sse_StoreScalar_82() => Sse.StoreScalar(pArray2Float, GetV128()); + public Vector128 Sse_Subtract_83() => Sse.Subtract(GetV128(), GetV128()); + public Vector128 Sse_SubtractScalar_84() => Sse.SubtractScalar(GetV128(), GetV128()); + public Vector128 Sse_UnpackHigh_85() => Sse.UnpackHigh(GetV128(), GetV128()); + public Vector128 Sse_UnpackLow_86() => Sse.UnpackLow(GetV128(), GetV128()); + public Vector128 Sse_Xor_87() => Sse.Xor(GetV128(), GetV128()); + public Vector128 Sse2_Add_0() => Sse2.Add(GetV128(), GetV128()); + public Vector128 Sse2_Add_1() => Sse2.Add(GetV128(), GetV128()); + public Vector128 Sse2_Add_2() => Sse2.Add(GetV128(), GetV128()); + public Vector128 Sse2_Add_3() => Sse2.Add(GetV128(), GetV128()); + public Vector128 Sse2_Add_4() => Sse2.Add(GetV128(), GetV128()); + public Vector128 Sse2_Add_5() => Sse2.Add(GetV128(), GetV128()); + public Vector128 Sse2_Add_6() => Sse2.Add(GetV128(), GetV128()); + public Vector128 Sse2_Add_7() => Sse2.Add(GetV128(), GetV128()); + public Vector128 Sse2_Add_8() => Sse2.Add(GetV128(), GetV128()); + public Vector128 Sse2_AddSaturate_9() => Sse2.AddSaturate(GetV128(), GetV128()); + public Vector128 Sse2_AddSaturate_10() => Sse2.AddSaturate(GetV128(), GetV128()); + public Vector128 Sse2_AddSaturate_11() => Sse2.AddSaturate(GetV128(), GetV128()); + public Vector128 Sse2_AddSaturate_12() => Sse2.AddSaturate(GetV128(), GetV128()); + public Vector128 Sse2_AddScalar_13() => Sse2.AddScalar(GetV128(), GetV128()); + public Vector128 Sse2_And_14() => Sse2.And(GetV128(), GetV128()); + public Vector128 Sse2_And_15() => Sse2.And(GetV128(), GetV128()); + public Vector128 Sse2_And_16() => Sse2.And(GetV128(), GetV128()); + public Vector128 Sse2_And_17() => Sse2.And(GetV128(), GetV128()); + public Vector128 Sse2_And_18() => Sse2.And(GetV128(), GetV128()); + public Vector128 Sse2_And_19() => Sse2.And(GetV128(), GetV128()); + public Vector128 Sse2_And_20() => Sse2.And(GetV128(), GetV128()); + public Vector128 Sse2_And_21() => Sse2.And(GetV128(), GetV128()); + public Vector128 Sse2_And_22() => Sse2.And(GetV128(), GetV128()); + public Vector128 Sse2_AndNot_23() => Sse2.AndNot(GetV128(), GetV128()); + public Vector128 Sse2_AndNot_24() => Sse2.AndNot(GetV128(), GetV128()); + public Vector128 Sse2_AndNot_25() => Sse2.AndNot(GetV128(), GetV128()); + public Vector128 Sse2_AndNot_26() => Sse2.AndNot(GetV128(), GetV128()); + public Vector128 Sse2_AndNot_27() => Sse2.AndNot(GetV128(), GetV128()); + public Vector128 Sse2_AndNot_28() => Sse2.AndNot(GetV128(), GetV128()); + public Vector128 Sse2_AndNot_29() => Sse2.AndNot(GetV128(), GetV128()); + public Vector128 Sse2_AndNot_30() => Sse2.AndNot(GetV128(), GetV128()); + public Vector128 Sse2_AndNot_31() => Sse2.AndNot(GetV128(), GetV128()); + public Vector128 Sse2_Average_32() => Sse2.Average(GetV128(), GetV128()); + public Vector128 Sse2_Average_33() => Sse2.Average(GetV128(), GetV128()); + public Vector128 Sse2_CompareEqual_34() => Sse2.CompareEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareEqual_35() => Sse2.CompareEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareEqual_36() => Sse2.CompareEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareEqual_37() => Sse2.CompareEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareEqual_38() => Sse2.CompareEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareEqual_39() => Sse2.CompareEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareEqual_40() => Sse2.CompareEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareGreaterThan_41() => Sse2.CompareGreaterThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareGreaterThan_42() => Sse2.CompareGreaterThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareGreaterThan_43() => Sse2.CompareGreaterThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareGreaterThan_44() => Sse2.CompareGreaterThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareGreaterThanOrEqual_45() => Sse2.CompareGreaterThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareLessThan_46() => Sse2.CompareLessThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareLessThan_47() => Sse2.CompareLessThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareLessThan_48() => Sse2.CompareLessThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareLessThan_49() => Sse2.CompareLessThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareLessThanOrEqual_50() => Sse2.CompareLessThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareNotEqual_51() => Sse2.CompareNotEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareNotGreaterThan_52() => Sse2.CompareNotGreaterThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareNotGreaterThanOrEqual_53() => Sse2.CompareNotGreaterThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareNotLessThan_54() => Sse2.CompareNotLessThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareNotLessThanOrEqual_55() => Sse2.CompareNotLessThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareOrdered_56() => Sse2.CompareOrdered(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarEqual_57() => Sse2.CompareScalarEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarGreaterThan_58() => Sse2.CompareScalarGreaterThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarGreaterThanOrEqual_59() => Sse2.CompareScalarGreaterThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarLessThan_60() => Sse2.CompareScalarLessThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarLessThanOrEqual_61() => Sse2.CompareScalarLessThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarNotEqual_62() => Sse2.CompareScalarNotEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarNotGreaterThan_63() => Sse2.CompareScalarNotGreaterThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarNotGreaterThanOrEqual_64() => Sse2.CompareScalarNotGreaterThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarNotLessThan_65() => Sse2.CompareScalarNotLessThan(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarNotLessThanOrEqual_66() => Sse2.CompareScalarNotLessThanOrEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarOrdered_67() => Sse2.CompareScalarOrdered(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarOrderedEqual_68() => Sse2.CompareScalarOrderedEqual(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarOrderedGreaterThan_69() => Sse2.CompareScalarOrderedGreaterThan(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarOrderedGreaterThanOrEqual_70() => Sse2.CompareScalarOrderedGreaterThanOrEqual(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarOrderedLessThan_71() => Sse2.CompareScalarOrderedLessThan(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarOrderedLessThanOrEqual_72() => Sse2.CompareScalarOrderedLessThanOrEqual(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarOrderedNotEqual_73() => Sse2.CompareScalarOrderedNotEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareScalarUnordered_74() => Sse2.CompareScalarUnordered(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarUnorderedEqual_75() => Sse2.CompareScalarUnorderedEqual(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarUnorderedGreaterThan_76() => Sse2.CompareScalarUnorderedGreaterThan(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarUnorderedGreaterThanOrEqual_77() => Sse2.CompareScalarUnorderedGreaterThanOrEqual(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarUnorderedLessThan_78() => Sse2.CompareScalarUnorderedLessThan(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarUnorderedLessThanOrEqual_79() => Sse2.CompareScalarUnorderedLessThanOrEqual(GetV128(), GetV128()); + public Boolean Sse2_CompareScalarUnorderedNotEqual_80() => Sse2.CompareScalarUnorderedNotEqual(GetV128(), GetV128()); + public Vector128 Sse2_CompareUnordered_81() => Sse2.CompareUnordered(GetV128(), GetV128()); + public Vector128 Sse2_ConvertScalarToVector128Double_82() => Sse2.ConvertScalarToVector128Double(GetV128(), Get()); + public Vector128 Sse2_ConvertScalarToVector128Double_83() => Sse2.ConvertScalarToVector128Double(GetV128(), GetV128()); + public Vector128 Sse2_ConvertScalarToVector128Int32_84() => Sse2.ConvertScalarToVector128Int32(Get()); + public Vector128 Sse2_ConvertScalarToVector128Single_85() => Sse2.ConvertScalarToVector128Single(GetV128(), GetV128()); + public Vector128 Sse2_ConvertScalarToVector128UInt32_86() => Sse2.ConvertScalarToVector128UInt32(Get()); + public Int32 Sse2_ConvertToInt32_87() => Sse2.ConvertToInt32(GetV128()); + public Int32 Sse2_ConvertToInt32_88() => Sse2.ConvertToInt32(GetV128()); + public Int32 Sse2_ConvertToInt32WithTruncation_89() => Sse2.ConvertToInt32WithTruncation(GetV128()); + public UInt32 Sse2_ConvertToUInt32_90() => Sse2.ConvertToUInt32(GetV128()); + public Vector128 Sse2_ConvertToVector128Double_91() => Sse2.ConvertToVector128Double(GetV128()); + public Vector128 Sse2_ConvertToVector128Double_92() => Sse2.ConvertToVector128Double(GetV128()); + public Vector128 Sse2_ConvertToVector128Int32_93() => Sse2.ConvertToVector128Int32(GetV128()); + public Vector128 Sse2_ConvertToVector128Int32_94() => Sse2.ConvertToVector128Int32(GetV128()); + public Vector128 Sse2_ConvertToVector128Int32WithTruncation_95() => Sse2.ConvertToVector128Int32WithTruncation(GetV128()); + public Vector128 Sse2_ConvertToVector128Int32WithTruncation_96() => Sse2.ConvertToVector128Int32WithTruncation(GetV128()); + public Vector128 Sse2_ConvertToVector128Single_97() => Sse2.ConvertToVector128Single(GetV128()); + public Vector128 Sse2_ConvertToVector128Single_98() => Sse2.ConvertToVector128Single(GetV128()); + public Vector128 Sse2_Divide_99() => Sse2.Divide(GetV128(), GetV128()); + public Vector128 Sse2_DivideScalar_100() => Sse2.DivideScalar(GetV128(), GetV128()); + public UInt16 Sse2_Extract_101() => Sse2.Extract(GetV128(), Get()); + public Vector128 Sse2_Insert_103() => Sse2.Insert(GetV128(), Get(), Get()); + public Vector128 Sse2_Insert_104() => Sse2.Insert(GetV128(), Get(), Get()); + public Vector128 Sse2_LoadAlignedVector128_105() => Sse2.LoadAlignedVector128(((sbyte*)pArray1)); + public Vector128 Sse2_LoadAlignedVector128_106() => Sse2.LoadAlignedVector128(((byte*)pArray1)); + public Vector128 Sse2_LoadAlignedVector128_107() => Sse2.LoadAlignedVector128(((short*)pArray1)); + public Vector128 Sse2_LoadAlignedVector128_108() => Sse2.LoadAlignedVector128(((ushort*)pArray1)); + public Vector128 Sse2_LoadAlignedVector128_109() => Sse2.LoadAlignedVector128(((int*)pArray1)); + public Vector128 Sse2_LoadAlignedVector128_110() => Sse2.LoadAlignedVector128(((uint*)pArray1)); + public Vector128 Sse2_LoadAlignedVector128_111() => Sse2.LoadAlignedVector128(((long*)pArray1)); + public Vector128 Sse2_LoadAlignedVector128_112() => Sse2.LoadAlignedVector128(((ulong*)pArray1)); + public Vector128 Sse2_LoadAlignedVector128_113() => Sse2.LoadAlignedVector128((pArray1Double)); + public void Sse2_LoadFence_114() => Sse2.LoadFence(); + public Vector128 Sse2_LoadHigh_115() => Sse2.LoadHigh(GetV128(), pArray1Double); + public Vector128 Sse2_LoadLow_116() => Sse2.LoadLow(GetV128(), pArray1Double); + public Vector128 Sse2_LoadScalarVector128_117() => Sse2.LoadScalarVector128(pArray1Double); + public Vector128 Sse2_LoadScalarVector128_118() => Sse2.LoadScalarVector128((int*)pArray1); + public Vector128 Sse2_LoadScalarVector128_119() => Sse2.LoadScalarVector128((uint*)pArray1); + public Vector128 Sse2_LoadScalarVector128_120() => Sse2.LoadScalarVector128((long*)pArray1); + public Vector128 Sse2_LoadScalarVector128_121() => Sse2.LoadScalarVector128((ulong*)pArray1); + public Vector128 Sse2_LoadVector128_122() => Sse2.LoadVector128((sbyte*)pArray1); + public Vector128 Sse2_LoadVector128_123() => Sse2.LoadVector128((byte*)pArray1); + public Vector128 Sse2_LoadVector128_124() => Sse2.LoadVector128((short*)pArray1); + public Vector128 Sse2_LoadVector128_125() => Sse2.LoadVector128((ushort*)pArray1); + public Vector128 Sse2_LoadVector128_126() => Sse2.LoadVector128((int*)pArray1); + public Vector128 Sse2_LoadVector128_127() => Sse2.LoadVector128((uint*)pArray1); + public Vector128 Sse2_LoadVector128_128() => Sse2.LoadVector128((long*)pArray1); + public Vector128 Sse2_LoadVector128_129() => Sse2.LoadVector128((ulong*)pArray1); + public Vector128 Sse2_LoadVector128_130() => Sse2.LoadVector128(pArray1Double); + public void Sse2_MaskMove_131() => Sse2.MaskMove(GetV128(), GetV128(), (sbyte*)pArray1); + public void Sse2_MaskMove_132() => Sse2.MaskMove(GetV128(), GetV128(), (byte*)pArray1); + public Vector128 Sse2_Max_133() => Sse2.Max(GetV128(), GetV128()); + public Vector128 Sse2_Max_134() => Sse2.Max(GetV128(), GetV128()); + public Vector128 Sse2_Max_135() => Sse2.Max(GetV128(), GetV128()); + public Vector128 Sse2_MaxScalar_136() => Sse2.MaxScalar(GetV128(), GetV128()); + public void Sse2_MemoryFence_137() => Sse2.MemoryFence(); + public Vector128 Sse2_Min_138() => Sse2.Min(GetV128(), GetV128()); + public Vector128 Sse2_Min_139() => Sse2.Min(GetV128(), GetV128()); + public Vector128 Sse2_Min_140() => Sse2.Min(GetV128(), GetV128()); + public Vector128 Sse2_MinScalar_141() => Sse2.MinScalar(GetV128(), GetV128()); + public Int32 Sse2_MoveMask_142() => Sse2.MoveMask(GetV128()); + public Int32 Sse2_MoveMask_143() => Sse2.MoveMask(GetV128()); + public Int32 Sse2_MoveMask_144() => Sse2.MoveMask(GetV128()); + public Vector128 Sse2_MoveScalar_145() => Sse2.MoveScalar(GetV128(), GetV128()); + public Vector128 Sse2_MoveScalar_146() => Sse2.MoveScalar(GetV128()); + public Vector128 Sse2_MoveScalar_147() => Sse2.MoveScalar(GetV128()); + public Vector128 Sse2_Multiply_148() => Sse2.Multiply(GetV128(), GetV128()); + public Vector128 Sse2_Multiply_149() => Sse2.Multiply(GetV128(), GetV128()); + public Vector128 Sse2_MultiplyAddAdjacent_150() => Sse2.MultiplyAddAdjacent(GetV128(), GetV128()); + public Vector128 Sse2_MultiplyHigh_151() => Sse2.MultiplyHigh(GetV128(), GetV128()); + public Vector128 Sse2_MultiplyHigh_152() => Sse2.MultiplyHigh(GetV128(), GetV128()); + public Vector128 Sse2_MultiplyLow_153() => Sse2.MultiplyLow(GetV128(), GetV128()); + public Vector128 Sse2_MultiplyLow_154() => Sse2.MultiplyLow(GetV128(), GetV128()); + public Vector128 Sse2_MultiplyScalar_155() => Sse2.MultiplyScalar(GetV128(), GetV128()); + public Vector128 Sse2_Or_156() => Sse2.Or(GetV128(), GetV128()); + public Vector128 Sse2_Or_157() => Sse2.Or(GetV128(), GetV128()); + public Vector128 Sse2_Or_158() => Sse2.Or(GetV128(), GetV128()); + public Vector128 Sse2_Or_159() => Sse2.Or(GetV128(), GetV128()); + public Vector128 Sse2_Or_160() => Sse2.Or(GetV128(), GetV128()); + public Vector128 Sse2_Or_161() => Sse2.Or(GetV128(), GetV128()); + public Vector128 Sse2_Or_162() => Sse2.Or(GetV128(), GetV128()); + public Vector128 Sse2_Or_163() => Sse2.Or(GetV128(), GetV128()); + public Vector128 Sse2_Or_164() => Sse2.Or(GetV128(), GetV128()); + public Vector128 Sse2_PackSignedSaturate_165() => Sse2.PackSignedSaturate(GetV128(), GetV128()); + public Vector128 Sse2_PackSignedSaturate_166() => Sse2.PackSignedSaturate(GetV128(), GetV128()); + public Vector128 Sse2_PackUnsignedSaturate_167() => Sse2.PackUnsignedSaturate(GetV128(), GetV128()); + public Vector128 Sse2_ShiftLeftLogical_168() => Sse2.ShiftLeftLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftLeftLogical_169() => Sse2.ShiftLeftLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftLeftLogical_170() => Sse2.ShiftLeftLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftLeftLogical_171() => Sse2.ShiftLeftLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftLeftLogical_172() => Sse2.ShiftLeftLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftLeftLogical_173() => Sse2.ShiftLeftLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftLeftLogical_174() => Sse2.ShiftLeftLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical_175() => Sse2.ShiftLeftLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical_176() => Sse2.ShiftLeftLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical_177() => Sse2.ShiftLeftLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical_178() => Sse2.ShiftLeftLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical_179() => Sse2.ShiftLeftLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical128BitLane_180() => Sse2.ShiftLeftLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical128BitLane_181() => Sse2.ShiftLeftLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical128BitLane_182() => Sse2.ShiftLeftLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical128BitLane_183() => Sse2.ShiftLeftLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical128BitLane_184() => Sse2.ShiftLeftLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical128BitLane_185() => Sse2.ShiftLeftLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical128BitLane_186() => Sse2.ShiftLeftLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftLeftLogical128BitLane_187() => Sse2.ShiftLeftLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftRightArithmetic_188() => Sse2.ShiftRightArithmetic(GetV128(), GetV128()); + public Vector128 Sse2_ShiftRightArithmetic_189() => Sse2.ShiftRightArithmetic(GetV128(), GetV128()); + public Vector128 Sse2_ShiftRightArithmetic_190() => Sse2.ShiftRightArithmetic(GetV128(), Get()); + public Vector128 Sse2_ShiftRightArithmetic_191() => Sse2.ShiftRightArithmetic(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical_192() => Sse2.ShiftRightLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftRightLogical_193() => Sse2.ShiftRightLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftRightLogical_194() => Sse2.ShiftRightLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftRightLogical_195() => Sse2.ShiftRightLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftRightLogical_196() => Sse2.ShiftRightLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftRightLogical_197() => Sse2.ShiftRightLogical(GetV128(), GetV128()); + public Vector128 Sse2_ShiftRightLogical_198() => Sse2.ShiftRightLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical_199() => Sse2.ShiftRightLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical_200() => Sse2.ShiftRightLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical_201() => Sse2.ShiftRightLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical_202() => Sse2.ShiftRightLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical_203() => Sse2.ShiftRightLogical(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical128BitLane_204() => Sse2.ShiftRightLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical128BitLane_205() => Sse2.ShiftRightLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical128BitLane_206() => Sse2.ShiftRightLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical128BitLane_207() => Sse2.ShiftRightLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical128BitLane_208() => Sse2.ShiftRightLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical128BitLane_209() => Sse2.ShiftRightLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical128BitLane_210() => Sse2.ShiftRightLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_ShiftRightLogical128BitLane_211() => Sse2.ShiftRightLogical128BitLane(GetV128(), Get()); + public Vector128 Sse2_Shuffle_212() => Sse2.Shuffle(GetV128(), 12); + public Vector128 Sse2_Shuffle_213() => Sse2.Shuffle(GetV128(), GetV128(), 3); + public Vector128 Sse2_Shuffle_214() => Sse2.Shuffle(GetV128(), 42); + public Vector128 Sse2_ShuffleHigh_215() => Sse2.ShuffleHigh(GetV128(), 23); + public Vector128 Sse2_ShuffleHigh_216() => Sse2.ShuffleHigh(GetV128(), 12); + public Vector128 Sse2_ShuffleLow_217() => Sse2.ShuffleLow(GetV128(), 5); + public Vector128 Sse2_ShuffleLow_218() => Sse2.ShuffleLow(GetV128(), 3); + public Vector128 Sse2_Sqrt_219() => Sse2.Sqrt(GetV128()); + public Vector128 Sse2_SqrtScalar_220() => Sse2.SqrtScalar(GetV128()); + public Vector128 Sse2_SqrtScalar_221() => Sse2.SqrtScalar(GetV128(), GetV128()); + public void Sse2_Store_222() => Sse2.Store((sbyte*)pArray2, GetV128()); + public void Sse2_Store_223() => Sse2.Store((byte*)pArray2, GetV128()); + public void Sse2_Store_224() => Sse2.Store((short*)pArray2, GetV128()); + public void Sse2_Store_225() => Sse2.Store((ushort*)pArray2, GetV128()); + public void Sse2_Store_226() => Sse2.Store((int*)pArray2, GetV128()); + public void Sse2_Store_227() => Sse2.Store((uint*)pArray2, GetV128()); + public void Sse2_Store_228() => Sse2.Store((long*)pArray2, GetV128()); + public void Sse2_Store_229() => Sse2.Store((ulong*)pArray2, GetV128()); + public void Sse2_Store_230() => Sse2.Store(pArray1Double, GetV128()); + public void Sse2_StoreAligned_231() => Sse2.StoreAligned(((sbyte*)pArray2), GetV128()); + public void Sse2_StoreAligned_232() => Sse2.StoreAligned(((byte*)pArray2), GetV128()); + public void Sse2_StoreAligned_233() => Sse2.StoreAligned(((short*)pArray2), GetV128()); + public void Sse2_StoreAligned_234() => Sse2.StoreAligned(((ushort*)pArray2), GetV128()); + public void Sse2_StoreAligned_235() => Sse2.StoreAligned(((int*)pArray2), GetV128()); + public void Sse2_StoreAligned_236() => Sse2.StoreAligned(((uint*)pArray2), GetV128()); + public void Sse2_StoreAligned_237() => Sse2.StoreAligned(((long*)pArray2), GetV128()); + public void Sse2_StoreAligned_238() => Sse2.StoreAligned(((ulong*)pArray2), GetV128()); + public void Sse2_StoreAligned_239() => Sse2.StoreAligned((pArray2Double), GetV128()); + public void Sse2_StoreAlignedNonTemporal_240() => Sse2.StoreAlignedNonTemporal(((sbyte*)pArray2), GetV128()); + public void Sse2_StoreAlignedNonTemporal_241() => Sse2.StoreAlignedNonTemporal(((byte*)pArray2), GetV128()); + public void Sse2_StoreAlignedNonTemporal_242() => Sse2.StoreAlignedNonTemporal(((short*)pArray2), GetV128()); + public void Sse2_StoreAlignedNonTemporal_243() => Sse2.StoreAlignedNonTemporal(((ushort*)pArray2), GetV128()); + public void Sse2_StoreAlignedNonTemporal_244() => Sse2.StoreAlignedNonTemporal(((int*)pArray2), GetV128()); + public void Sse2_StoreAlignedNonTemporal_245() => Sse2.StoreAlignedNonTemporal(((uint*)pArray2), GetV128()); + public void Sse2_StoreAlignedNonTemporal_246() => Sse2.StoreAlignedNonTemporal(((long*)pArray2), GetV128()); + public void Sse2_StoreAlignedNonTemporal_247() => Sse2.StoreAlignedNonTemporal(((ulong*)pArray2), GetV128()); + public void Sse2_StoreAlignedNonTemporal_248() => Sse2.StoreAlignedNonTemporal((pArray2Double), GetV128()); + public void Sse2_StoreHigh_249() => Sse2.StoreHigh(pArray2Double, GetV128()); + public void Sse2_StoreLow_250() => Sse2.StoreLow(pArray2Double, GetV128()); + public void Sse2_StoreNonTemporal_251() => Sse2.StoreNonTemporal((int*)pArray2, Get()); + public void Sse2_StoreNonTemporal_252() => Sse2.StoreNonTemporal((uint*)pArray2, Get()); + public void Sse2_StoreScalar_253() => Sse2.StoreScalar(pArray2Double, GetV128()); + public void Sse2_StoreScalar_254() => Sse2.StoreScalar((long*)pArray2, GetV128()); + public void Sse2_StoreScalar_255() => Sse2.StoreScalar((ulong*)pArray2, GetV128()); + public Vector128 Sse2_Subtract_256() => Sse2.Subtract(GetV128(), GetV128()); + public Vector128 Sse2_Subtract_257() => Sse2.Subtract(GetV128(), GetV128()); + public Vector128 Sse2_Subtract_258() => Sse2.Subtract(GetV128(), GetV128()); + public Vector128 Sse2_Subtract_259() => Sse2.Subtract(GetV128(), GetV128()); + public Vector128 Sse2_Subtract_260() => Sse2.Subtract(GetV128(), GetV128()); + public Vector128 Sse2_Subtract_261() => Sse2.Subtract(GetV128(), GetV128()); + public Vector128 Sse2_Subtract_262() => Sse2.Subtract(GetV128(), GetV128()); + public Vector128 Sse2_Subtract_263() => Sse2.Subtract(GetV128(), GetV128()); + public Vector128 Sse2_Subtract_264() => Sse2.Subtract(GetV128(), GetV128()); + public Vector128 Sse2_SubtractSaturate_265() => Sse2.SubtractSaturate(GetV128(), GetV128()); + public Vector128 Sse2_SubtractSaturate_266() => Sse2.SubtractSaturate(GetV128(), GetV128()); + public Vector128 Sse2_SubtractSaturate_267() => Sse2.SubtractSaturate(GetV128(), GetV128()); + public Vector128 Sse2_SubtractSaturate_268() => Sse2.SubtractSaturate(GetV128(), GetV128()); + public Vector128 Sse2_SubtractScalar_269() => Sse2.SubtractScalar(GetV128(), GetV128()); + public Vector128 Sse2_SumAbsoluteDifferences_270() => Sse2.SumAbsoluteDifferences(GetV128(), GetV128()); + public Vector128 Sse2_UnpackHigh_271() => Sse2.UnpackHigh(GetV128(), GetV128()); + public Vector128 Sse2_UnpackHigh_272() => Sse2.UnpackHigh(GetV128(), GetV128()); + public Vector128 Sse2_UnpackHigh_273() => Sse2.UnpackHigh(GetV128(), GetV128()); + public Vector128 Sse2_UnpackHigh_274() => Sse2.UnpackHigh(GetV128(), GetV128()); + public Vector128 Sse2_UnpackHigh_275() => Sse2.UnpackHigh(GetV128(), GetV128()); + public Vector128 Sse2_UnpackHigh_276() => Sse2.UnpackHigh(GetV128(), GetV128()); + public Vector128 Sse2_UnpackHigh_277() => Sse2.UnpackHigh(GetV128(), GetV128()); + public Vector128 Sse2_UnpackHigh_278() => Sse2.UnpackHigh(GetV128(), GetV128()); + public Vector128 Sse2_UnpackHigh_279() => Sse2.UnpackHigh(GetV128(), GetV128()); + public Vector128 Sse2_UnpackLow_280() => Sse2.UnpackLow(GetV128(), GetV128()); + public Vector128 Sse2_UnpackLow_281() => Sse2.UnpackLow(GetV128(), GetV128()); + public Vector128 Sse2_UnpackLow_282() => Sse2.UnpackLow(GetV128(), GetV128()); + public Vector128 Sse2_UnpackLow_283() => Sse2.UnpackLow(GetV128(), GetV128()); + public Vector128 Sse2_UnpackLow_284() => Sse2.UnpackLow(GetV128(), GetV128()); + public Vector128 Sse2_UnpackLow_285() => Sse2.UnpackLow(GetV128(), GetV128()); + public Vector128 Sse2_UnpackLow_286() => Sse2.UnpackLow(GetV128(), GetV128()); + public Vector128 Sse2_UnpackLow_287() => Sse2.UnpackLow(GetV128(), GetV128()); + public Vector128 Sse2_UnpackLow_288() => Sse2.UnpackLow(GetV128(), GetV128()); + public Vector128 Sse2_Xor_289() => Sse2.Xor(GetV128(), GetV128()); + public Vector128 Sse2_Xor_290() => Sse2.Xor(GetV128(), GetV128()); + public Vector128 Sse2_Xor_291() => Sse2.Xor(GetV128(), GetV128()); + public Vector128 Sse2_Xor_292() => Sse2.Xor(GetV128(), GetV128()); + public Vector128 Sse2_Xor_293() => Sse2.Xor(GetV128(), GetV128()); + public Vector128 Sse2_Xor_294() => Sse2.Xor(GetV128(), GetV128()); + public Vector128 Sse2_Xor_295() => Sse2.Xor(GetV128(), GetV128()); + public Vector128 Sse2_Xor_296() => Sse2.Xor(GetV128(), GetV128()); + public Vector128 Sse2_Xor_297() => Sse2.Xor(GetV128(), GetV128()); + public Vector128 Sse3_AddSubtract_0() => Sse3.AddSubtract(GetV128(), GetV128()); + public Vector128 Sse3_AddSubtract_1() => Sse3.AddSubtract(GetV128(), GetV128()); + public Vector128 Sse3_HorizontalAdd_3() => Sse3.HorizontalAdd(GetV128(), GetV128()); + public Vector128 Sse3_HorizontalAdd_4() => Sse3.HorizontalAdd(GetV128(), GetV128()); + public Vector128 Sse3_HorizontalSubtract_5() => Sse3.HorizontalSubtract(GetV128(), GetV128()); + public Vector128 Sse3_HorizontalSubtract_6() => Sse3.HorizontalSubtract(GetV128(), GetV128()); + public Vector128 Sse3_LoadAndDuplicateToVector128_7() => Sse3.LoadAndDuplicateToVector128(pArray1Double); + public Vector128 Sse3_LoadDquVector128_8() => Sse3.LoadDquVector128((sbyte*)pArray1); + public Vector128 Sse3_LoadDquVector128_9() => Sse3.LoadDquVector128((byte*)pArray1); + public Vector128 Sse3_LoadDquVector128_10() => Sse3.LoadDquVector128((short*)pArray1); + public Vector128 Sse3_LoadDquVector128_11() => Sse3.LoadDquVector128((ushort*)pArray1); + public Vector128 Sse3_LoadDquVector128_12() => Sse3.LoadDquVector128((int*)pArray1); + public Vector128 Sse3_LoadDquVector128_13() => Sse3.LoadDquVector128((uint*)pArray1); + public Vector128 Sse3_LoadDquVector128_14() => Sse3.LoadDquVector128((long*)pArray1); + public Vector128 Sse3_LoadDquVector128_15() => Sse3.LoadDquVector128((ulong*)pArray1); + public Vector128 Sse3_MoveAndDuplicate_16() => Sse3.MoveAndDuplicate(GetV128()); + public Vector128 Sse3_MoveHighAndDuplicate_17() => Sse3.MoveHighAndDuplicate(GetV128()); + public Vector128 Sse3_MoveLowAndDuplicate_18() => Sse3.MoveLowAndDuplicate(GetV128()); + public Vector128 Ssse3_Abs_0() => Ssse3.Abs(GetV128()); + public Vector128 Ssse3_Abs_1() => Ssse3.Abs(GetV128()); + public Vector128 Ssse3_Abs_2() => Ssse3.Abs(GetV128()); + public Vector128 Ssse3_AlignRight_3() => Ssse3.AlignRight(GetV128(), GetV128(), Get()); + public Vector128 Ssse3_AlignRight_4() => Ssse3.AlignRight(GetV128(), GetV128(), Get()); + public Vector128 Ssse3_AlignRight_5() => Ssse3.AlignRight(GetV128(), GetV128(), Get()); + public Vector128 Ssse3_AlignRight_6() => Ssse3.AlignRight(GetV128(), GetV128(), Get()); + public Vector128 Ssse3_AlignRight_7() => Ssse3.AlignRight(GetV128(), GetV128(), Get()); + public Vector128 Ssse3_AlignRight_8() => Ssse3.AlignRight(GetV128(), GetV128(), Get()); + public Vector128 Ssse3_AlignRight_9() => Ssse3.AlignRight(GetV128(), GetV128(), Get()); + public Vector128 Ssse3_AlignRight_10() => Ssse3.AlignRight(GetV128(), GetV128(), Get()); + public Vector128 Ssse3_HorizontalAdd_12() => Ssse3.HorizontalAdd(GetV128(), GetV128()); + public Vector128 Ssse3_HorizontalAdd_13() => Ssse3.HorizontalAdd(GetV128(), GetV128()); + public Vector128 Ssse3_HorizontalAddSaturate_14() => Ssse3.HorizontalAddSaturate(GetV128(), GetV128()); + public Vector128 Ssse3_HorizontalSubtract_15() => Ssse3.HorizontalSubtract(GetV128(), GetV128()); + public Vector128 Ssse3_HorizontalSubtract_16() => Ssse3.HorizontalSubtract(GetV128(), GetV128()); + public Vector128 Ssse3_HorizontalSubtractSaturate_17() => Ssse3.HorizontalSubtractSaturate(GetV128(), GetV128()); + public Vector128 Ssse3_MultiplyAddAdjacent_18() => Ssse3.MultiplyAddAdjacent(GetV128(), GetV128()); + public Vector128 Ssse3_MultiplyHighRoundScale_19() => Ssse3.MultiplyHighRoundScale(GetV128(), GetV128()); + public Vector128 Ssse3_Shuffle_20() => Ssse3.Shuffle(GetV128(), GetV128()); + public Vector128 Ssse3_Shuffle_21() => Ssse3.Shuffle(GetV128(), GetV128()); + public Vector128 Ssse3_Sign_22() => Ssse3.Sign(GetV128(), GetV128()); + public Vector128 Ssse3_Sign_23() => Ssse3.Sign(GetV128(), GetV128()); + public Vector128 Ssse3_Sign_24() => Ssse3.Sign(GetV128(), GetV128()); + public Vector128 Sse41_Blend_0() => Sse41.Blend(GetV128(), GetV128(), Get()); + public Vector128 Sse41_Blend_1() => Sse41.Blend(GetV128(), GetV128(), Get()); + public Vector128 Sse41_Blend_2() => Sse41.Blend(GetV128(), GetV128(), Get()); + public Vector128 Sse41_Blend_3() => Sse41.Blend(GetV128(), GetV128(), Get()); + public Vector128 Sse41_BlendVariable_4() => Sse41.BlendVariable(GetV128(), GetV128(), GetV128()); + public Vector128 Sse41_BlendVariable_5() => Sse41.BlendVariable(GetV128(), GetV128(), GetV128()); + public Vector128 Sse41_BlendVariable_6() => Sse41.BlendVariable(GetV128(), GetV128(), GetV128()); + public Vector128 Sse41_BlendVariable_7() => Sse41.BlendVariable(GetV128(), GetV128(), GetV128()); + public Vector128 Sse41_BlendVariable_8() => Sse41.BlendVariable(GetV128(), GetV128(), GetV128()); + public Vector128 Sse41_BlendVariable_9() => Sse41.BlendVariable(GetV128(), GetV128(), GetV128()); + public Vector128 Sse41_BlendVariable_10() => Sse41.BlendVariable(GetV128(), GetV128(), GetV128()); + public Vector128 Sse41_BlendVariable_11() => Sse41.BlendVariable(GetV128(), GetV128(), GetV128()); + public Vector128 Sse41_BlendVariable_12() => Sse41.BlendVariable(GetV128(), GetV128(), GetV128()); + public Vector128 Sse41_BlendVariable_13() => Sse41.BlendVariable(GetV128(), GetV128(), GetV128()); + public Vector128 Sse41_Ceiling_14() => Sse41.Ceiling(GetV128()); + public Vector128 Sse41_Ceiling_15() => Sse41.Ceiling(GetV128()); + public Vector128 Sse41_CeilingScalar_16() => Sse41.CeilingScalar(GetV128()); + public Vector128 Sse41_CeilingScalar_17() => Sse41.CeilingScalar(GetV128()); + public Vector128 Sse41_CeilingScalar_18() => Sse41.CeilingScalar(GetV128(), GetV128()); + public Vector128 Sse41_CeilingScalar_19() => Sse41.CeilingScalar(GetV128(), GetV128()); + public Vector128 Sse41_CompareEqual_20() => Sse41.CompareEqual(GetV128(), GetV128()); + public Vector128 Sse41_CompareEqual_21() => Sse41.CompareEqual(GetV128(), GetV128()); + public Vector128 Sse41_ConvertToVector128Int16_22() => Sse41.ConvertToVector128Int16(GetV128()); + public Vector128 Sse41_ConvertToVector128Int16_23() => Sse41.ConvertToVector128Int16(GetV128()); + public Vector128 Sse41_ConvertToVector128Int16_24() => Sse41.ConvertToVector128Int16((sbyte*)pArray1); + public Vector128 Sse41_ConvertToVector128Int16_25() => Sse41.ConvertToVector128Int16((byte*)pArray1); + public Vector128 Sse41_ConvertToVector128Int32_26() => Sse41.ConvertToVector128Int32(GetV128()); + public Vector128 Sse41_ConvertToVector128Int32_27() => Sse41.ConvertToVector128Int32(GetV128()); + public Vector128 Sse41_ConvertToVector128Int32_28() => Sse41.ConvertToVector128Int32(GetV128()); + public Vector128 Sse41_ConvertToVector128Int32_29() => Sse41.ConvertToVector128Int32(GetV128()); + public Vector128 Sse41_ConvertToVector128Int32_30() => Sse41.ConvertToVector128Int32((sbyte*)pArray1); + public Vector128 Sse41_ConvertToVector128Int32_31() => Sse41.ConvertToVector128Int32((byte*)pArray1); + public Vector128 Sse41_ConvertToVector128Int32_32() => Sse41.ConvertToVector128Int32((short*)pArray1); + public Vector128 Sse41_ConvertToVector128Int32_33() => Sse41.ConvertToVector128Int32((ushort*)pArray1); + public Vector128 Sse41_ConvertToVector128Int64_34() => Sse41.ConvertToVector128Int64(GetV128()); + public Vector128 Sse41_ConvertToVector128Int64_35() => Sse41.ConvertToVector128Int64(GetV128()); + public Vector128 Sse41_ConvertToVector128Int64_36() => Sse41.ConvertToVector128Int64(GetV128()); + public Vector128 Sse41_ConvertToVector128Int64_37() => Sse41.ConvertToVector128Int64(GetV128()); + public Vector128 Sse41_ConvertToVector128Int64_38() => Sse41.ConvertToVector128Int64(GetV128()); + public Vector128 Sse41_ConvertToVector128Int64_39() => Sse41.ConvertToVector128Int64(GetV128()); + public Vector128 Sse41_ConvertToVector128Int64_40() => Sse41.ConvertToVector128Int64((sbyte*)pArray1); + public Vector128 Sse41_ConvertToVector128Int64_41() => Sse41.ConvertToVector128Int64((byte*)pArray1); + public Vector128 Sse41_ConvertToVector128Int64_42() => Sse41.ConvertToVector128Int64((short*)pArray1); + public Vector128 Sse41_ConvertToVector128Int64_43() => Sse41.ConvertToVector128Int64((ushort*)pArray1); + public Vector128 Sse41_ConvertToVector128Int64_44() => Sse41.ConvertToVector128Int64((int*)pArray1); + public Vector128 Sse41_ConvertToVector128Int64_45() => Sse41.ConvertToVector128Int64((uint*)pArray1); + public Vector128 Sse41_DotProduct_46() => Sse41.DotProduct(GetV128(), GetV128(), Get()); + public Vector128 Sse41_DotProduct_47() => Sse41.DotProduct(GetV128(), GetV128(), Get()); + public Byte Sse41_Extract_48() => Sse41.Extract(GetV128(), Get()); + public Int32 Sse41_Extract_49() => Sse41.Extract(GetV128(), Get()); + public UInt32 Sse41_Extract_50() => Sse41.Extract(GetV128(), Get()); + public Single Sse41_Extract_51() => Sse41.Extract(GetV128(), Get()); + public Vector128 Sse41_Floor_52() => Sse41.Floor(GetV128()); + public Vector128 Sse41_Floor_53() => Sse41.Floor(GetV128()); + public Vector128 Sse41_FloorScalar_54() => Sse41.FloorScalar(GetV128()); + public Vector128 Sse41_FloorScalar_55() => Sse41.FloorScalar(GetV128()); + public Vector128 Sse41_FloorScalar_56() => Sse41.FloorScalar(GetV128(), GetV128()); + public Vector128 Sse41_FloorScalar_57() => Sse41.FloorScalar(GetV128(), GetV128()); + public Vector128 Sse41_Insert_59() => Sse41.Insert(GetV128(), Get(), 4); + public Vector128 Sse41_Insert_60() => Sse41.Insert(GetV128(), Get(), 3); + public Vector128 Sse41_Insert_61() => Sse41.Insert(GetV128(), Get(), 2); + public Vector128 Sse41_Insert_62() => Sse41.Insert(GetV128(), Get(), 1); + public Vector128 Sse41_Insert_63() => Sse41.Insert(GetV128(), GetV128(), 0x10); + public Vector128 Sse41_LoadAlignedVector128NonTemporal_64() => Sse41.LoadAlignedVector128NonTemporal(((sbyte*)pArray1)); + public Vector128 Sse41_LoadAlignedVector128NonTemporal_65() => Sse41.LoadAlignedVector128NonTemporal(((byte*)pArray1)); + public Vector128 Sse41_LoadAlignedVector128NonTemporal_66() => Sse41.LoadAlignedVector128NonTemporal(((short*)pArray1)); + public Vector128 Sse41_LoadAlignedVector128NonTemporal_67() => Sse41.LoadAlignedVector128NonTemporal(((ushort*)pArray1)); + public Vector128 Sse41_LoadAlignedVector128NonTemporal_68() => Sse41.LoadAlignedVector128NonTemporal(((int*)pArray1)); + public Vector128 Sse41_LoadAlignedVector128NonTemporal_69() => Sse41.LoadAlignedVector128NonTemporal(((uint*)pArray1)); + public Vector128 Sse41_LoadAlignedVector128NonTemporal_70() => Sse41.LoadAlignedVector128NonTemporal(((long*)pArray1)); + public Vector128 Sse41_LoadAlignedVector128NonTemporal_71() => Sse41.LoadAlignedVector128NonTemporal(((ulong*)pArray1)); + public Vector128 Sse41_Max_72() => Sse41.Max(GetV128(), GetV128()); + public Vector128 Sse41_Max_73() => Sse41.Max(GetV128(), GetV128()); + public Vector128 Sse41_Max_74() => Sse41.Max(GetV128(), GetV128()); + public Vector128 Sse41_Max_75() => Sse41.Max(GetV128(), GetV128()); + public Vector128 Sse41_Min_76() => Sse41.Min(GetV128(), GetV128()); + public Vector128 Sse41_Min_77() => Sse41.Min(GetV128(), GetV128()); + public Vector128 Sse41_Min_78() => Sse41.Min(GetV128(), GetV128()); + public Vector128 Sse41_Min_79() => Sse41.Min(GetV128(), GetV128()); + public Vector128 Sse41_MinHorizontal_80() => Sse41.MinHorizontal(GetV128()); + public Vector128 Sse41_MultipleSumAbsoluteDifferences_81() => Sse41.MultipleSumAbsoluteDifferences(GetV128(), GetV128(), Get()); + public Vector128 Sse41_Multiply_82() => Sse41.Multiply(GetV128(), GetV128()); + public Vector128 Sse41_MultiplyLow_83() => Sse41.MultiplyLow(GetV128(), GetV128()); + public Vector128 Sse41_MultiplyLow_84() => Sse41.MultiplyLow(GetV128(), GetV128()); + public Vector128 Sse41_PackUnsignedSaturate_85() => Sse41.PackUnsignedSaturate(GetV128(), GetV128()); + public Vector128 Sse41_RoundCurrentDirection_86() => Sse41.RoundCurrentDirection(GetV128()); + public Vector128 Sse41_RoundCurrentDirection_87() => Sse41.RoundCurrentDirection(GetV128()); + public Vector128 Sse41_RoundCurrentDirectionScalar_88() => Sse41.RoundCurrentDirectionScalar(GetV128()); + public Vector128 Sse41_RoundCurrentDirectionScalar_89() => Sse41.RoundCurrentDirectionScalar(GetV128(), GetV128()); + public Vector128 Sse41_RoundCurrentDirectionScalar_90() => Sse41.RoundCurrentDirectionScalar(GetV128()); + public Vector128 Sse41_RoundCurrentDirectionScalar_91() => Sse41.RoundCurrentDirectionScalar(GetV128(), GetV128()); + public Vector128 Sse41_RoundToNearestInteger_92() => Sse41.RoundToNearestInteger(GetV128()); + public Vector128 Sse41_RoundToNearestInteger_93() => Sse41.RoundToNearestInteger(GetV128()); + public Vector128 Sse41_RoundToNearestIntegerScalar_94() => Sse41.RoundToNearestIntegerScalar(GetV128()); + public Vector128 Sse41_RoundToNearestIntegerScalar_95() => Sse41.RoundToNearestIntegerScalar(GetV128(), GetV128()); + public Vector128 Sse41_RoundToNearestIntegerScalar_96() => Sse41.RoundToNearestIntegerScalar(GetV128()); + public Vector128 Sse41_RoundToNearestIntegerScalar_97() => Sse41.RoundToNearestIntegerScalar(GetV128(), GetV128()); + public Vector128 Sse41_RoundToNegativeInfinity_98() => Sse41.RoundToNegativeInfinity(GetV128()); + public Vector128 Sse41_RoundToNegativeInfinity_99() => Sse41.RoundToNegativeInfinity(GetV128()); + public Vector128 Sse41_RoundToNegativeInfinityScalar_100() => Sse41.RoundToNegativeInfinityScalar(GetV128()); + public Vector128 Sse41_RoundToNegativeInfinityScalar_101() => Sse41.RoundToNegativeInfinityScalar(GetV128(), GetV128()); + public Vector128 Sse41_RoundToNegativeInfinityScalar_102() => Sse41.RoundToNegativeInfinityScalar(GetV128()); + public Vector128 Sse41_RoundToNegativeInfinityScalar_103() => Sse41.RoundToNegativeInfinityScalar(GetV128(), GetV128()); + public Vector128 Sse41_RoundToPositiveInfinity_104() => Sse41.RoundToPositiveInfinity(GetV128()); + public Vector128 Sse41_RoundToPositiveInfinity_105() => Sse41.RoundToPositiveInfinity(GetV128()); + public Vector128 Sse41_RoundToPositiveInfinityScalar_106() => Sse41.RoundToPositiveInfinityScalar(GetV128()); + public Vector128 Sse41_RoundToPositiveInfinityScalar_107() => Sse41.RoundToPositiveInfinityScalar(GetV128(), GetV128()); + public Vector128 Sse41_RoundToPositiveInfinityScalar_108() => Sse41.RoundToPositiveInfinityScalar(GetV128()); + public Vector128 Sse41_RoundToPositiveInfinityScalar_109() => Sse41.RoundToPositiveInfinityScalar(GetV128(), GetV128()); + public Vector128 Sse41_RoundToZero_110() => Sse41.RoundToZero(GetV128()); + public Vector128 Sse41_RoundToZero_111() => Sse41.RoundToZero(GetV128()); + public Vector128 Sse41_RoundToZeroScalar_112() => Sse41.RoundToZeroScalar(GetV128()); + public Vector128 Sse41_RoundToZeroScalar_113() => Sse41.RoundToZeroScalar(GetV128(), GetV128()); + public Vector128 Sse41_RoundToZeroScalar_114() => Sse41.RoundToZeroScalar(GetV128()); + public Vector128 Sse41_RoundToZeroScalar_115() => Sse41.RoundToZeroScalar(GetV128(), GetV128()); + public Boolean Sse41_TestC_116() => Sse41.TestC(GetV128(), GetV128()); + public Boolean Sse41_TestC_117() => Sse41.TestC(GetV128(), GetV128()); + public Boolean Sse41_TestC_118() => Sse41.TestC(GetV128(), GetV128()); + public Boolean Sse41_TestC_119() => Sse41.TestC(GetV128(), GetV128()); + public Boolean Sse41_TestC_120() => Sse41.TestC(GetV128(), GetV128()); + public Boolean Sse41_TestC_121() => Sse41.TestC(GetV128(), GetV128()); + public Boolean Sse41_TestC_122() => Sse41.TestC(GetV128(), GetV128()); + public Boolean Sse41_TestC_123() => Sse41.TestC(GetV128(), GetV128()); + public Boolean Sse41_TestNotZAndNotC_124() => Sse41.TestNotZAndNotC(GetV128(), GetV128()); + public Boolean Sse41_TestNotZAndNotC_125() => Sse41.TestNotZAndNotC(GetV128(), GetV128()); + public Boolean Sse41_TestNotZAndNotC_126() => Sse41.TestNotZAndNotC(GetV128(), GetV128()); + public Boolean Sse41_TestNotZAndNotC_127() => Sse41.TestNotZAndNotC(GetV128(), GetV128()); + public Boolean Sse41_TestNotZAndNotC_128() => Sse41.TestNotZAndNotC(GetV128(), GetV128()); + public Boolean Sse41_TestNotZAndNotC_129() => Sse41.TestNotZAndNotC(GetV128(), GetV128()); + public Boolean Sse41_TestNotZAndNotC_130() => Sse41.TestNotZAndNotC(GetV128(), GetV128()); + public Boolean Sse41_TestNotZAndNotC_131() => Sse41.TestNotZAndNotC(GetV128(), GetV128()); + public Boolean Sse41_TestZ_132() => Sse41.TestZ(GetV128(), GetV128()); + public Boolean Sse41_TestZ_133() => Sse41.TestZ(GetV128(), GetV128()); + public Boolean Sse41_TestZ_134() => Sse41.TestZ(GetV128(), GetV128()); + public Boolean Sse41_TestZ_135() => Sse41.TestZ(GetV128(), GetV128()); + public Boolean Sse41_TestZ_136() => Sse41.TestZ(GetV128(), GetV128()); + public Boolean Sse41_TestZ_137() => Sse41.TestZ(GetV128(), GetV128()); + public Boolean Sse41_TestZ_138() => Sse41.TestZ(GetV128(), GetV128()); + public Boolean Sse41_TestZ_139() => Sse41.TestZ(GetV128(), GetV128()); + public Vector128 Sse42_CompareGreaterThan_0() => Sse42.CompareGreaterThan(GetV128(), GetV128()); + public UInt32 Sse42_Crc32_1() => Sse42.Crc32(Get(), Get()); + public UInt32 Sse42_Crc32_2() => Sse42.Crc32(Get(), Get()); + public UInt32 Sse42_Crc32_3() => Sse42.Crc32(Get(), Get()); + + public Vector128 Vector128_Create_1() => Vector128.Create(Get()); + public Vector128 Vector128_Create_2() => Vector128.Create(Get()); + public Vector128 Vector128_Create_3() => Vector128.Create(Get()); + public Vector128 Vector128_Create_4() => Vector128.Create(Get()); + public Vector128 Vector128_Create_5() => Vector128.Create(Get()); + public Vector128 Vector128_Create_6() => Vector128.Create(Get()); + public Vector128 Vector128_Create_7() => Vector128.Create(Get()); + public Vector128 Vector128_Create_8() => Vector128.Create(Get()); + public Vector128 Vector128_Create_9() => Vector128.Create(Get()); + public Vector128 Vector128_Create_10() => Vector128.Create(Get()); + public Vector128 Vector128_Create_11() => Vector128.Create(Get(), Get()); + public Vector128 Vector128_Create_12() => Vector128.Create(Get(), Get()); + public Vector128 Vector128_Create_13() => Vector128.Create(Get(), Get()); + public Vector128 Vector128_Create_14() => Vector128.Create(Get(), Get(), Get(), Get()); + public Vector128 Vector128_Create_15() => Vector128.Create(Get(), Get(), Get(), Get()); + public Vector128 Vector128_Create_16() => Vector128.Create(Get(), Get(), Get(), Get()); + public Vector128 Vector128_Create_17() => Vector128.Create(Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get()); + public Vector128 Vector128_Create_18() => Vector128.Create(Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get()); + public Vector128 Vector128_Create_20() => Vector128.Create(Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get(), Get()); + + 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 Vector128_int_to_byte() => Vector128_Create_15().AsByte(); + public Vector128 Vector128_int_to_ulong() => Vector128_Create_15().AsUInt64(); + public Vector128 Vector128_byte_to_int() => Vector128_Create_20().AsInt32(); +} \ No newline at end of file diff --git a/src/mono/netcore/tests/HwIntrinsics/SRI-reference-data.txt b/src/mono/netcore/tests/HwIntrinsics/SRI-reference-data.txt new file mode 100644 index 0000000..f28524f --- /dev/null +++ b/src/mono/netcore/tests/HwIntrinsics/SRI-reference-data.txt @@ -0,0 +1,595 @@ +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: . 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: . array2: () +Sse_CompareScalarEqual_15: <0, 165247660, 501148420, 424096580>. array2: () +Sse_CompareScalarGreaterThan_16: <0, -510012770, -65459412, -256915410>. array2: () +Sse_CompareScalarGreaterThanOrEqual_17: . array2: () +Sse_CompareScalarLessThan_18: <0, 286352260, 67081924, 391137340>. array2: () +Sse_CompareScalarLessThanOrEqual_19: . array2: () +Sse_CompareScalarNotEqual_20: . array2: () +Sse_CompareScalarNotGreaterThan_21: <0, 675093900, 250508290, 382580160>. array2: () +Sse_CompareScalarNotGreaterThanOrEqual_22: . array2: () +Sse_CompareScalarNotLessThan_23: <0, -669115970, -28078068, -23915620>. array2: () +Sse_CompareScalarNotLessThanOrEqual_24: <0, -263062030, -243626220, -327881220>. array2: () +Sse_CompareScalarOrdered_25: . 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: . 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: . array2: () +Sse_ReciprocalSqrtScalar_71: . array2: () +Sse_Shuffle_72: <103318530, 633020600, 519279620, 446014980>. array2: () +Sse_Sqrt_73: <32375.541, 18467.787, 10546.897, 13361.126>. array2: () +Sse_SqrtScalar_74: . 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: . array2: () +Sse2_CompareNotEqual_51: . array2: () +Sse2_CompareNotGreaterThan_52: . array2: () +Sse2_CompareNotGreaterThanOrEqual_53: <0, 0>. array2: () +Sse2_CompareNotLessThan_54: <0, 0>. array2: () +Sse2_CompareNotLessThanOrEqual_55: . array2: () +Sse2_CompareOrdered_56: . array2: () +Sse2_CompareScalarEqual_57: <0, 2083712820>. array2: () +Sse2_CompareScalarGreaterThan_58: <0, 1650780952>. array2: () +Sse2_CompareScalarGreaterThanOrEqual_59: . array2: () +Sse2_CompareScalarLessThan_60: <0, 1627148431>. array2: () +Sse2_CompareScalarLessThanOrEqual_61: <0, 1720855119>. array2: () +Sse2_CompareScalarNotEqual_62: . array2: () +Sse2_CompareScalarNotGreaterThan_63: <0, 743511762>. array2: () +Sse2_CompareScalarNotGreaterThanOrEqual_64: <0, 2122767112>. array2: () +Sse2_CompareScalarNotLessThan_65: <0, -495948320>. array2: () +Sse2_CompareScalarNotLessThanOrEqual_66: . array2: () +Sse2_CompareScalarOrdered_67: . 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: . array2: () +Sse2_SqrtScalar_221: . 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: ()