Souichirou/Singularity
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Singularity/Library/PackageCache/com.unity.burst@1.8.4/Runtime/Intrinsics/x86/Avx2.cs

3055 lines
125 KiB
C#
Raw Normal View History

first commit
2024-05-06 14:45:45 -04:00
using System;
using System.Diagnostics;
namespace Unity.Burst.Intrinsics
{
public unsafe static partial class X86
{
/// <summary>
/// AVX2 intrinsics
/// </summary>
public static class Avx2
{
/// <summary>
/// Evaluates to true at compile time if AVX2 intrinsics are supported.
/// </summary>
public static bool IsAvx2Supported { get { return false; } }
/// <summary>
/// Create mask from the most significant bit of each 8-bit element in a, and store the result in dst.
/// </summary>
/// <remarks>
/// **** vpmovmskb r32, ymm
/// </remarks>
/// <param name="a">Vector a</param>
/// <returns>Integer</returns>
[DebuggerStepThrough]
public static int mm256_movemask_epi8(v256 a)
{
uint result = 0;
byte* ptr = &a.Byte0;
uint bit = 1;
for (int i = 0; i < 32; ++i, bit <<= 1)
{
result |= (((uint)ptr[i]) >> 7) * bit;
}
return (int)result;
}
/// <summary>
/// Extract an 8-bit integer from a, selected with index (which must be constant), and store the result in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="index">Index in the vector</param>
/// <returns>Integer</returns>
[DebuggerStepThrough]
public static int mm256_extract_epi8(v256 a, int index)
{
return (&a.Byte0)[index & 31];
}
/// <summary>
/// Extract a 16-bit integer from a, selected with index (which must be constant), and store the result in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="index">Index in the vector</param>
/// <returns>Integer</returns>
[DebuggerStepThrough]
public static int mm256_extract_epi16(v256 a, int index)
{
return (&a.UShort0)[index & 15];
}
/// <summary>
/// Copy the lower double-precision (64-bit) floating-point element of a to dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Double</returns>
[DebuggerStepThrough]
public static double mm256_cvtsd_f64(v256 a)
{
// Burst IR is fine here.
return a.Double0;
}
/// <summary>
/// Copy the lower 32-bit integer in a to dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Integer</returns>
[DebuggerStepThrough]
public static int mm256_cvtsi256_si32(v256 a)
{
// Burst IR is fine here.
return a.SInt0;
}
/// <summary>
/// Copy the lower 64-bit integer in a to dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>64-bit integer</returns>
[DebuggerStepThrough]
public static long mm256_cvtsi256_si64(v256 a)
{
// Burst IR is fine here.
return a.SLong0;
}
/// <summary>
/// Compare packed 8-bit integers in a and b for equality, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cmpeq_epi8(v256 a, v256 b)
{
return new v256(Sse2.cmpeq_epi8(a.Lo128, b.Lo128), Sse2.cmpeq_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 16-bit integers in a and b for equality, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cmpeq_epi16(v256 a, v256 b)
{
return new v256(Sse2.cmpeq_epi16(a.Lo128, b.Lo128), Sse2.cmpeq_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 32-bit integers in a and b for equality, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cmpeq_epi32(v256 a, v256 b)
{
return new v256(Sse2.cmpeq_epi32(a.Lo128, b.Lo128), Sse2.cmpeq_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 64-bit integers in a and b for equality, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cmpeq_epi64(v256 a, v256 b)
{
return new v256(Sse4_1.cmpeq_epi64(a.Lo128, b.Lo128), Sse4_1.cmpeq_epi64(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 8-bit integers in a and b for greater-than, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cmpgt_epi8(v256 a, v256 b)
{
return new v256(Sse2.cmpgt_epi8(a.Lo128, b.Lo128), Sse2.cmpgt_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 16-bit integers in a and b for greater-than, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cmpgt_epi16(v256 a, v256 b)
{
return new v256(Sse2.cmpgt_epi16(a.Lo128, b.Lo128), Sse2.cmpgt_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 32-bit integers in a and b for greater-than, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cmpgt_epi32(v256 a, v256 b)
{
return new v256(Sse2.cmpgt_epi32(a.Lo128, b.Lo128), Sse2.cmpgt_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 64-bit integers in a and b for equality, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cmpgt_epi64(v256 a, v256 b)
{
return new v256(Sse4_2.cmpgt_epi64(a.Lo128, b.Lo128), Sse4_2.cmpgt_epi64(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 8-bit integers in a and b, and store packed maximum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_max_epi8(v256 a, v256 b)
{
return new v256(Sse4_1.max_epi8(a.Lo128, b.Lo128), Sse4_1.max_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 16-bit integers in a and b, and store packed maximum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_max_epi16(v256 a, v256 b)
{
return new v256(Sse2.max_epi16(a.Lo128, b.Lo128), Sse2.max_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 32-bit integers in a and b, and store packed maximum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_max_epi32(v256 a, v256 b)
{
return new v256(Sse4_1.max_epi32(a.Lo128, b.Lo128), Sse4_1.max_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed unsigned 8-bit integers in a and b, and store packed maximum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_max_epu8(v256 a, v256 b)
{
return new v256(Sse2.max_epu8(a.Lo128, b.Lo128), Sse2.max_epu8(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed unsigned 16-bit integers in a and b, and store packed maximum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_max_epu16(v256 a, v256 b)
{
return new v256(Sse4_1.max_epu16(a.Lo128, b.Lo128), Sse4_1.max_epu16(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed unsigned 32-bit integers in a and b, and store packed maximum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_max_epu32(v256 a, v256 b)
{
return new v256(Sse4_1.max_epu32(a.Lo128, b.Lo128), Sse4_1.max_epu32(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 8-bit integers in a and b, and store packed minimum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_min_epi8(v256 a, v256 b)
{
return new v256(Sse4_1.min_epi8(a.Lo128, b.Lo128), Sse4_1.min_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 16-bit integers in a and b, and store packed minimum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_min_epi16(v256 a, v256 b)
{
return new v256(Sse2.min_epi16(a.Lo128, b.Lo128), Sse2.min_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed 32-bit integers in a and b, and store packed minimum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_min_epi32(v256 a, v256 b)
{
return new v256(Sse4_1.min_epi32(a.Lo128, b.Lo128), Sse4_1.min_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed unsigned 8-bit integers in a and b, and store packed minimum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_min_epu8(v256 a, v256 b)
{
return new v256(Sse2.min_epu8(a.Lo128, b.Lo128), Sse2.min_epu8(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed unsigned 16-bit integers in a and b, and store packed minimum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_min_epu16(v256 a, v256 b)
{
return new v256(Sse4_1.min_epu16(a.Lo128, b.Lo128), Sse4_1.min_epu16(a.Hi128, b.Hi128));
}
/// <summary>
/// Compare packed unsigned 32-bit integers in a and b, and store packed minimum values in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_min_epu32(v256 a, v256 b)
{
return new v256(Sse4_1.min_epu32(a.Lo128, b.Lo128), Sse4_1.min_epu32(a.Hi128, b.Hi128));
}
/// <summary>
/// Compute the bitwise AND of 256 bits (representing integer data) in a and b, and store the result in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_and_si256(v256 a, v256 b)
{
return new v256(Sse2.and_si128(a.Lo128, b.Lo128), Sse2.and_si128(a.Hi128, b.Hi128));
}
/// <summary>
/// Compute the bitwise NOT of 256 bits (representing integer data) in a and then AND with b, and store the result in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_andnot_si256(v256 a, v256 b)
{
return new v256(Sse2.andnot_si128(a.Lo128, b.Lo128), Sse2.andnot_si128(a.Hi128, b.Hi128));
}
/// <summary>
/// Compute the bitwise OR of 256 bits (representing integer data) in a and b, and store the result in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_or_si256(v256 a, v256 b)
{
return new v256(Sse2.or_si128(a.Lo128, b.Lo128), Sse2.or_si128(a.Hi128, b.Hi128));
}
/// <summary>
/// Compute the bitwise XOR of 256 bits (representing integer data) in a and b, and store the result in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_xor_si256(v256 a, v256 b)
{
return new v256(Sse2.xor_si128(a.Lo128, b.Lo128), Sse2.xor_si128(a.Hi128, b.Hi128));
}
/// <summary>
/// Compute the absolute value of packed 8-bit integers in a, and store the unsigned results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_abs_epi8(v256 a)
{
return new v256(Ssse3.abs_epi8(a.Lo128), Ssse3.abs_epi8(a.Hi128));
}
/// <summary>
/// Compute the absolute value of packed 16-bit integers in a, and store the unsigned results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_abs_epi16(v256 a)
{
return new v256(Ssse3.abs_epi16(a.Lo128), Ssse3.abs_epi16(a.Hi128));
}
/// <summary>
/// Compute the absolute value of packed 32-bit integers in a, and store the unsigned results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_abs_epi32(v256 a)
{
return new v256(Ssse3.abs_epi32(a.Lo128), Ssse3.abs_epi32(a.Hi128));
}
/// <summary>
/// Add packed 8-bit integers in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_add_epi8(v256 a, v256 b)
{
return new v256(Sse2.add_epi8(a.Lo128, b.Lo128), Sse2.add_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Add packed 16-bit integers in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_add_epi16(v256 a, v256 b)
{
return new v256(Sse2.add_epi16(a.Lo128, b.Lo128), Sse2.add_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Add packed 32-bit integers in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_add_epi32(v256 a, v256 b)
{
return new v256(Sse2.add_epi32(a.Lo128, b.Lo128), Sse2.add_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Add packed 64-bit integers in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_add_epi64(v256 a, v256 b)
{
return new v256(Sse2.add_epi64(a.Lo128, b.Lo128), Sse2.add_epi64(a.Hi128, b.Hi128));
}
/// <summary>
/// Add packed 8-bit integers in a and b using saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_adds_epi8(v256 a, v256 b)
{
return new v256(Sse2.adds_epi8(a.Lo128, b.Lo128), Sse2.adds_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Add packed 16-bit integers in a and b using saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_adds_epi16(v256 a, v256 b)
{
return new v256(Sse2.adds_epi16(a.Lo128, b.Lo128), Sse2.adds_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Add packed unsigned 8-bit integers in a and b using saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_adds_epu8(v256 a, v256 b)
{
return new v256(Sse2.adds_epu8(a.Lo128, b.Lo128), Sse2.adds_epu8(a.Hi128, b.Hi128));
}
/// <summary>
/// Add packed unsigned 16-bit integers in a and b using saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_adds_epu16(v256 a, v256 b)
{
return new v256(Sse2.adds_epu16(a.Lo128, b.Lo128), Sse2.adds_epu16(a.Hi128, b.Hi128));
}
/// <summary>
/// Subtract packed 8-bit integers in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sub_epi8(v256 a, v256 b)
{
return new v256(Sse2.sub_epi8(a.Lo128, b.Lo128), Sse2.sub_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Subtract packed 16-bit integers in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sub_epi16(v256 a, v256 b)
{
return new v256(Sse2.sub_epi16(a.Lo128, b.Lo128), Sse2.sub_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Subtract packed 32-bit integers in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sub_epi32(v256 a, v256 b)
{
return new v256(Sse2.sub_epi32(a.Lo128, b.Lo128), Sse2.sub_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Subtract packed 64-bit integers in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sub_epi64(v256 a, v256 b)
{
return new v256(Sse2.sub_epi64(a.Lo128, b.Lo128), Sse2.sub_epi64(a.Hi128, b.Hi128));
}
/// <summary>
/// Subtract packed 8-bit integers in a and b using saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_subs_epi8(v256 a, v256 b)
{
return new v256(Sse2.subs_epi8(a.Lo128, b.Lo128), Sse2.subs_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Subtract packed 16-bit integers in a and b using saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_subs_epi16(v256 a, v256 b)
{
return new v256(Sse2.subs_epi16(a.Lo128, b.Lo128), Sse2.subs_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Subtract packed unsigned 8-bit integers in a and b using saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_subs_epu8(v256 a, v256 b)
{
return new v256(Sse2.subs_epu8(a.Lo128, b.Lo128), Sse2.subs_epu8(a.Hi128, b.Hi128));
}
/// <summary>
/// Subtract packed unsigned 16-bit integers in a and b using saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_subs_epu16(v256 a, v256 b)
{
return new v256(Sse2.subs_epu16(a.Lo128, b.Lo128), Sse2.subs_epu16(a.Hi128, b.Hi128));
}
/// <summary>
/// Average packed unsigned 8-bit integers in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_avg_epu8(v256 a, v256 b)
{
return new v256(Sse2.avg_epu8(a.Lo128, b.Lo128), Sse2.avg_epu8(a.Hi128, b.Hi128));
}
/// <summary>
/// Average packed unsigned 16-bit integers in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_avg_epu16(v256 a, v256 b)
{
return new v256(Sse2.avg_epu16(a.Lo128, b.Lo128), Sse2.avg_epu16(a.Hi128, b.Hi128));
}
/// <summary>
/// Horizontally add adjacent pairs of 16-bit integers in a and b, and pack the signed 16-bit results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_hadd_epi16(v256 a, v256 b)
{
return new v256(Ssse3.hadd_epi16(a.Lo128, b.Lo128), Ssse3.hadd_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Horizontally add adjacent pairs of 32-bit integers in a and b, and pack the signed 16-bit results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_hadd_epi32(v256 a, v256 b)
{
return new v256(Ssse3.hadd_epi32(a.Lo128, b.Lo128), Ssse3.hadd_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Horizontally add adjacent pairs of 16-bit integers in a and b using saturation, and pack the signed 16-bit results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_hadds_epi16(v256 a, v256 b)
{
return new v256(Ssse3.hadds_epi16(a.Lo128, b.Lo128), Ssse3.hadds_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Horizontally subtract adjacent pairs of 16-bit integers in a and b, and pack the signed 16-bit results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_hsub_epi16(v256 a, v256 b)
{
return new v256(Ssse3.hsub_epi16(a.Lo128, b.Lo128), Ssse3.hsub_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Horizontally subtract adjacent pairs of 32-bit integers in a and b, and pack the signed 16-bit results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_hsub_epi32(v256 a, v256 b)
{
return new v256(Ssse3.hsub_epi32(a.Lo128, b.Lo128), Ssse3.hsub_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Horizontally subtract adjacent pairs of 16-bit integers in a and b using saturation, and pack the signed 16-bit results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_hsubs_epi16(v256 a, v256 b)
{
return new v256(Ssse3.hsubs_epi16(a.Lo128, b.Lo128), Ssse3.hsubs_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Multiply packed signed 16-bit integers in a and b, producing
/// intermediate signed 32-bit integers. Horizontally add adjacent
/// pairs of intermediate 32-bit integers, and pack the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_madd_epi16(v256 a, v256 b)
{
return new v256(Sse2.madd_epi16(a.Lo128, b.Lo128), Sse2.madd_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Vertically multiply each unsigned 8-bit integer from a with the
/// corresponding signed 8-bit integer from b, producing
/// intermediate signed 16-bit integers. Horizontally add adjacent
/// pairs of intermediate signed 16-bit integers, and pack the
/// saturated results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_maddubs_epi16(v256 a, v256 b)
{
return new v256(Ssse3.maddubs_epi16(a.Lo128, b.Lo128), Ssse3.maddubs_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Multiply the packed 16-bit integers in a and b, producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mulhi_epi16(v256 a, v256 b)
{
return new v256(Sse2.mulhi_epi16(a.Lo128, b.Lo128), Sse2.mulhi_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Multiply the packed unsigned 16-bit integers in a and b,
/// producing intermediate 32-bit integers, and store the high 16
/// bits of the intermediate integers in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mulhi_epu16(v256 a, v256 b)
{
return new v256(Sse2.mulhi_epu16(a.Lo128, b.Lo128), Sse2.mulhi_epu16(a.Hi128, b.Hi128));
}
/// <summary>
/// Multiply the packed 16-bit integers in a and b, producing
/// intermediate 32-bit integers, and store the low 16 bits of the
/// intermediate integers in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mullo_epi16(v256 a, v256 b)
{
return new v256(Sse2.mullo_epi16(a.Lo128, b.Lo128), Sse2.mullo_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Multiply the packed 32-bit integers in a and b, producing
/// intermediate 64-bit integers, and store the low 32 bits of the
/// intermediate integers in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mullo_epi32(v256 a, v256 b)
{
return new v256(Sse4_1.mullo_epi32(a.Lo128, b.Lo128), Sse4_1.mullo_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Multiply the low unsigned 32-bit integers from each packed 64-bit element in a and b, and store the unsigned 64-bit results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mul_epu32(v256 a, v256 b)
{
return new v256(Sse2.mul_epu32(a.Lo128, b.Lo128), Sse2.mul_epu32(a.Hi128, b.Hi128));
}
/// <summary>
/// Multiply the low 32-bit integers from each packed 64-bit element in a and b, and store the signed 64-bit results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mul_epi32(v256 a, v256 b)
{
return new v256(Sse4_1.mul_epi32(a.Lo128, b.Lo128), Sse4_1.mul_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Negate packed 8-bit integers in a when the corresponding signed
/// 8-bit integer in b is negative, and store the results in dst.
/// Element in dst are zeroed out when the corresponding element in
/// b is zero.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sign_epi8(v256 a, v256 b)
{
return new v256(Ssse3.sign_epi8(a.Lo128, b.Lo128), Ssse3.sign_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Negate packed 16-bit integers in a when the corresponding signed
/// 16-bit integer in b is negative, and store the results in dst.
/// Element in dst are zeroed out when the corresponding element in
/// b is zero.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sign_epi16(v256 a, v256 b)
{
return new v256(Ssse3.sign_epi16(a.Lo128, b.Lo128), Ssse3.sign_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Negate packed 32-bit integers in a when the corresponding signed
/// 32-bit integer in b is negative, and store the results in dst.
/// Element in dst are zeroed out when the corresponding element in
/// b is zero.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sign_epi32(v256 a, v256 b)
{
return new v256(Ssse3.sign_epi32(a.Lo128, b.Lo128), Ssse3.sign_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Multiply packed 16-bit integers in a and b, producing
/// intermediate signed 32-bit integers. Truncate each intermediate
/// integer to the 18 most significant bits, round by adding 1, and
/// store bits [16:1] to dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mulhrs_epi16(v256 a, v256 b)
{
return new v256(Ssse3.mulhrs_epi16(a.Lo128, b.Lo128), Ssse3.mulhrs_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Compute the absolute differences of packed unsigned 8-bit
/// integers in a and b, then horizontally sum each consecutive 8
/// differences to produce four unsigned 16-bit integers, and pack
/// these unsigned 16-bit integers in the low 16 bits of 64-bit
/// elements in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sad_epu8(v256 a, v256 b)
{
return new v256(Sse2.sad_epu8(a.Lo128, b.Lo128), Sse2.sad_epu8(a.Hi128, b.Hi128));
}
/// <summary>
/// Compute the sum of absolute differences (SADs) of quadruplets of
/// unsigned 8-bit integers in a compared to those in b, and store
/// the 16-bit results in dst. Eight SADs are performed for each
/// 128-bit lane using one quadruplet from b and eight quadruplets
/// from a. One quadruplet is selected from b starting at on the
/// offset specified in imm8. Eight quadruplets are formed from
/// sequential 8-bit integers selected from a starting at the offset
/// specified in imm8.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mpsadbw_epu8(v256 a, v256 b, int imm8)
{
return new v256(Sse4_1.mpsadbw_epu8(a.Lo128, b.Lo128, imm8 & 7), Sse4_1.mpsadbw_epu8(a.Hi128, b.Hi128, (imm8 >> 3) & 7));
}
/// <summary>
/// Shift 128-bit lanes in a left by imm8 bytes while shifting in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_slli_si256(v256 a, int imm8)
{
return new v256(Sse2.slli_si128(a.Lo128, imm8), Sse2.slli_si128(a.Hi128, imm8));
}
// This is just a #define alias
/// <summary>
/// Shift 128-bit lanes in a left by imm8 bytes while shifting in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_bslli_epi128(v256 a, int imm8)
{
return mm256_slli_si256(a, imm8);
}
/// <summary>
/// Shift 128-bit lanes in a right by imm8 bytes while shifting in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srli_si256(v256 a, int imm8)
{
return new v256(Sse2.srli_si128(a.Lo128, imm8), Sse2.srli_si128(a.Hi128, imm8));
}
// This is just a #define alias
/// <summary>
/// Shift 128-bit lanes in a right by imm8 bytes while shifting in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_bsrli_epi128(v256 a, int imm8)
{
return mm256_srli_si256(a, imm8);
}
/// <summary>
/// Shift packed 16-bit integers in a left by count while shifting
/// in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Shift amount</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sll_epi16(v256 a, v128 count)
{
return new v256(Sse2.sll_epi16(a.Lo128, count), Sse2.sll_epi16(a.Hi128, count));
}
/// <summary>
/// Shift packed 32-bit integers in a left by count while shifting
/// in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sll_epi32(v256 a, v128 count)
{
return new v256(Sse2.sll_epi32(a.Lo128, count), Sse2.sll_epi32(a.Hi128, count));
}
/// <summary>
/// Shift packed 64-bit integers in a left by count while shifting
/// in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sll_epi64(v256 a, v128 count)
{
return new v256(Sse2.sll_epi64(a.Lo128, count), Sse2.sll_epi64(a.Hi128, count));
}
/// <summary>
/// Shift packed 16-bit integers in a left by imm8 while shifting in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_slli_epi16(v256 a, int imm8)
{
return new v256(Sse2.slli_epi16(a.Lo128, imm8), Sse2.slli_epi16(a.Hi128, imm8));
}
/// <summary>
/// Shift packed 32-bit integers in a left by imm8 while shifting in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_slli_epi32(v256 a, int imm8)
{
return new v256(Sse2.slli_epi32(a.Lo128, imm8), Sse2.slli_epi32(a.Hi128, imm8));
}
/// <summary>
/// Shift packed 64-bit integers in a left by imm8 while shifting in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_slli_epi64(v256 a, int imm8)
{
return new v256(Sse2.slli_epi64(a.Lo128, imm8), Sse2.slli_epi64(a.Hi128, imm8));
}
/// <summary>
/// Shift packed 32-bit integers in a left by the amount specified
/// by the corresponding element in count while shifting in zeros,
/// and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Corresponding element</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sllv_epi32(v256 a, v256 count)
{
return new v256(sllv_epi32(a.Lo128, count.Lo128), sllv_epi32(a.Hi128, count.Hi128));
}
/// <summary>
/// Shift packed 64-bit integers in a left by the amount specified
/// by the corresponding element in count while shifting in zeros,
/// and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Corresponding element</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sllv_epi64(v256 a, v256 count)
{
return new v256(sllv_epi64(a.Lo128, count.Lo128), sllv_epi64(a.Hi128, count.Hi128));
}
/// <summary>
/// Shift packed 32-bit integers in a left by the amount specified
/// by the corresponding element in count while shifting in zeros,
/// and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Corresponding element</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 sllv_epi32(v128 a, v128 count)
{
v128 dst = default;
uint* aptr = &a.UInt0;
uint* dptr = &dst.UInt0;
int* sptr = &count.SInt0;
for (int i = 0; i < 4; ++i)
{
int shift = sptr[i];
if (shift >= 0 && shift <= 31)
{
dptr[i] = aptr[i] << shift;
}
else
{
dptr[i] = 0;
}
}
return dst;
}
/// <summary>
/// Shift packed 64-bit integers in a left by the amount specified
/// by the corresponding element in count while shifting in zeros,
/// and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Corresponding element</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 sllv_epi64(v128 a, v128 count)
{
v128 dst = default;
ulong* aptr = &a.ULong0;
ulong* dptr = &dst.ULong0;
long* sptr = &count.SLong0;
for (int i = 0; i < 2; ++i)
{
int shift = (int)sptr[i];
if (shift >= 0 && shift <= 63)
{
dptr[i] = aptr[i] << shift;
}
else
{
dptr[i] = 0;
}
}
return dst;
}
/// <summary>
/// Shift packed 16-bit integers in a right by count while shifting in sign bits, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sra_epi16(v256 a, v128 count)
{
return new v256(Sse2.sra_epi16(a.Lo128, count), Sse2.sra_epi16(a.Hi128, count));
}
/// <summary>
/// Shift packed 32-bit integers in a right by count while shifting in sign bits, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_sra_epi32(v256 a, v128 count)
{
return new v256(Sse2.sra_epi32(a.Lo128, count), Sse2.sra_epi32(a.Hi128, count));
}
/// <summary>
/// Shift packed 16-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srai_epi16(v256 a, int imm8)
{
return new v256(Sse2.srai_epi16(a.Lo128, imm8), Sse2.srai_epi16(a.Hi128, imm8));
}
/// <summary>
/// Shift packed 32-bit integers in a right by imm8 while shifting in sign bits, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srai_epi32(v256 a, int imm8)
{
return new v256(Sse2.srai_epi32(a.Lo128, imm8), Sse2.srai_epi32(a.Hi128, imm8));
}
/// <summary>
/// Shift packed 32-bit integers in a right by the amount specified
/// by the corresponding element in count while shifting in sign
/// bits, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Corresponding element</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srav_epi32(v256 a, v256 count)
{
return new v256(srav_epi32(a.Lo128, count.Lo128), srav_epi32(a.Hi128, count.Hi128));
}
/// <summary>
/// Shift packed 32-bit integers in a right by the amount specified
/// by the corresponding element in count while shifting in sign
/// bits, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Corresponding element</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 srav_epi32(v128 a, v128 count)
{
v128 dst = default;
int* aptr = &a.SInt0;
int* dptr = &dst.SInt0;
int* sptr = &count.SInt0;
for (int i = 0; i < 4; ++i)
{
// Work around modulo 32 shifts on the general register file
int shift1 = Math.Min(sptr[i] & 0xff, 32);
int shift2 = 0;
if (shift1 >= 16)
{
shift1 -= 16;
shift2 += 16;
}
dptr[i] = (aptr[i] >> shift1) >> shift2;
}
return dst;
}
/// <summary>
/// Shift packed 16-bit integers in a right by count while shifting
/// in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srl_epi16(v256 a, v128 count)
{
return new v256(Sse2.srl_epi16(a.Lo128, count), Sse2.srl_epi16(a.Hi128, count));
}
/// <summary>
/// Shift packed 32-bit integers in a right by count while shifting
/// in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srl_epi32(v256 a, v128 count)
{
return new v256(Sse2.srl_epi32(a.Lo128, count), Sse2.srl_epi32(a.Hi128, count));
}
/// <summary>
/// Shift packed 64-bit integers in a right by count while shifting
/// in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srl_epi64(v256 a, v128 count)
{
return new v256(Sse2.srl_epi64(a.Lo128, count), Sse2.srl_epi64(a.Hi128, count));
}
/// <summary>
/// Shift packed 16-bit integers in a right by imm8 while shifting in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srli_epi16(v256 a, int imm8)
{
return new v256(Sse2.srli_epi16(a.Lo128, imm8), Sse2.srli_epi16(a.Hi128, imm8));
}
/// <summary>
/// Shift packed 32-bit integers in a right by imm8 while shifting in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srli_epi32(v256 a, int imm8)
{
return new v256(Sse2.srli_epi32(a.Lo128, imm8), Sse2.srli_epi32(a.Hi128, imm8));
}
/// <summary>
/// Shift packed 64-bit integers in a right by imm8 while shifting in zeros, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srli_epi64(v256 a, int imm8)
{
return new v256(Sse2.srli_epi64(a.Lo128, imm8), Sse2.srli_epi64(a.Hi128, imm8));
}
/// <summary>
/// Shift packed 32-bit integers in a right by the amount specified
/// by the corresponding element in count while shifting in zeros,
/// and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Corresponding element</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srlv_epi32(v256 a, v256 count)
{
return new v256(srlv_epi32(a.Lo128, count.Lo128), srlv_epi32(a.Hi128, count.Hi128));
}
/// <summary>
/// Shift packed 64-bit integers in a right by the amount specified
/// by the corresponding element in count while shifting in zeros,
/// and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Corresponding element</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_srlv_epi64(v256 a, v256 count)
{
return new v256(srlv_epi64(a.Lo128, count.Lo128), srlv_epi64(a.Hi128, count.Hi128));
}
/// <summary>
/// Shift packed 32-bit integers in a right by the amount specified
/// by the corresponding element in count while shifting in zeros,
/// and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Corresponding element</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 srlv_epi32(v128 a, v128 count)
{
v128 dst = default;
uint* aptr = &a.UInt0;
uint* dptr = &dst.UInt0;
int* sptr = &count.SInt0;
for (int i = 0; i < 4; ++i)
{
int shift = sptr[i];
if (shift >= 0 && shift <= 31)
{
dptr[i] = aptr[i] >> shift;
}
else
{
dptr[i] = 0;
}
}
return dst;
}
/// <summary>
/// Shift packed 64-bit integers in a right by the amount specified
/// by the corresponding element in count while shifting in zeros,
/// and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="count">Corresponding element</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 srlv_epi64(v128 a, v128 count)
{
v128 dst = default;
ulong* aptr = &a.ULong0;
ulong* dptr = &dst.ULong0;
long* sptr = &count.SLong0;
for (int i = 0; i < 2; ++i)
{
int shift = (int)sptr[i];
if (shift >= 0 && shift <= 63)
{
dptr[i] = aptr[i] >> shift;
}
else
{
dptr[i] = 0;
}
}
return dst;
}
/// <summary>
/// Blend packed 32-bit integers from a and b using control mask imm8, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <param name="imm8">Control mask</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 blend_epi32(v128 a, v128 b, int imm8)
{
return Sse4_1.blend_ps(a, b, imm8);
}
/// <summary>
/// Blend packed 32-bit integers from a and b using control mask imm8, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <param name="imm8">Control mask</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_blend_epi32(v256 a, v256 b, int imm8)
{
return Avx.mm256_blend_ps(a, b, imm8);
}
/// <summary>
/// Concatenate pairs of 16-byte blocks in a and b into a 32-byte temporary result, shift the result right by imm8 bytes, and store the low 16 bytes in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <param name="imm8">Offset</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_alignr_epi8(v256 a, v256 b, int imm8)
{
return new v256(Ssse3.alignr_epi8(a.Lo128, b.Lo128, imm8), Ssse3.alignr_epi8(a.Hi128, b.Hi128, imm8));
}
/// <summary>
/// Blend packed 8-bit integers from a and b using mask, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <param name="mask">Mask</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_blendv_epi8(v256 a, v256 b, v256 mask)
{
return new v256(Sse4_1.blendv_epi8(a.Lo128, b.Lo128, mask.Lo128), Sse4_1.blendv_epi8(a.Hi128, b.Hi128, mask.Hi128));
}
/// <summary>
/// Blend packed 16-bit integers from a and b within 128-bit lanes using control mask imm8, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <param name="imm8">Control mask</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_blend_epi16(v256 a, v256 b, int imm8)
{
return new v256(Sse4_1.blend_epi16(a.Lo128, b.Lo128, imm8), Sse4_1.blend_epi16(a.Hi128, b.Hi128, imm8));
}
/// <summary>
/// Convert packed 16-bit integers from a and b to packed 8-bit integers using signed saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_packs_epi16(v256 a, v256 b)
{
return new v256(Sse2.packs_epi16(a.Lo128, b.Lo128), Sse2.packs_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Convert packed 32-bit integers from a and b to packed 16-bit integers using signed saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_packs_epi32(v256 a, v256 b)
{
return new v256(Sse2.packs_epi32(a.Lo128, b.Lo128), Sse2.packs_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Convert packed 16-bit integers from a and b to packed 8-bit integers using unsigned saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_packus_epi16(v256 a, v256 b)
{
return new v256(Sse2.packus_epi16(a.Lo128, b.Lo128), Sse2.packus_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Convert packed 32-bit integers from a and b to packed 16-bit integers using unsigned saturation, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_packus_epi32(v256 a, v256 b)
{
return new v256(Sse4_1.packus_epi32(a.Lo128, b.Lo128), Sse4_1.packus_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Unpack and interleave 8-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_unpackhi_epi8(v256 a, v256 b)
{
return new v256(Sse2.unpackhi_epi8(a.Lo128, b.Lo128), Sse2.unpackhi_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Unpack and interleave 16-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_unpackhi_epi16(v256 a, v256 b)
{
return new v256(Sse2.unpackhi_epi16(a.Lo128, b.Lo128), Sse2.unpackhi_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Unpack and interleave 32-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_unpackhi_epi32(v256 a, v256 b)
{
return new v256(Sse2.unpackhi_epi32(a.Lo128, b.Lo128), Sse2.unpackhi_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Unpack and interleave 64-bit integers from the high half of each 128-bit lane in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_unpackhi_epi64(v256 a, v256 b)
{
return new v256(Sse2.unpackhi_epi64(a.Lo128, b.Lo128), Sse2.unpackhi_epi64(a.Hi128, b.Hi128));
}
/// <summary>
/// Unpack and interleave 8-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_unpacklo_epi8(v256 a, v256 b)
{
return new v256(Sse2.unpacklo_epi8(a.Lo128, b.Lo128), Sse2.unpacklo_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Unpack and interleave 16-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_unpacklo_epi16(v256 a, v256 b)
{
return new v256(Sse2.unpacklo_epi16(a.Lo128, b.Lo128), Sse2.unpacklo_epi16(a.Hi128, b.Hi128));
}
/// <summary>
/// Unpack and interleave 32-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_unpacklo_epi32(v256 a, v256 b)
{
return new v256(Sse2.unpacklo_epi32(a.Lo128, b.Lo128), Sse2.unpacklo_epi32(a.Hi128, b.Hi128));
}
/// <summary>
/// Unpack and interleave 64-bit integers from the low half of each 128-bit lane in a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_unpacklo_epi64(v256 a, v256 b)
{
return new v256(Sse2.unpacklo_epi64(a.Lo128, b.Lo128), Sse2.unpacklo_epi64(a.Hi128, b.Hi128));
}
/// <summary>
/// Shuffle 8-bit integers in a within 128-bit lanes according to
/// shuffle control mask in the corresponding 8-bit element of b,
/// and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_shuffle_epi8(v256 a, v256 b)
{
return new v256(Ssse3.shuffle_epi8(a.Lo128, b.Lo128), Ssse3.shuffle_epi8(a.Hi128, b.Hi128));
}
/// <summary>
/// Shuffle 32-bit integers in a within 128-bit lanes using the control in imm8, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Control</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_shuffle_epi32(v256 a, int imm8)
{
return new v256(Sse2.shuffle_epi32(a.Lo128, imm8), Sse2.shuffle_epi32(a.Hi128, imm8));
}
/// <summary>
/// Shuffle 16-bit integers in the high 64 bits of 128-bit lanes of
/// a using the control in imm8. Store the results in the high 64
/// bits of 128-bit lanes of dst, with the low 64 bits of 128-bit
/// lanes being copied from from a to dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Control</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_shufflehi_epi16(v256 a, int imm8)
{
return new v256(Sse2.shufflehi_epi16(a.Lo128, imm8), Sse2.shufflehi_epi16(a.Hi128, imm8));
}
/// <summary>
/// Shuffle 16-bit integers in the low 64 bits of 128-bit lanes of
/// a using the control in imm8. Store the results in the low 64
/// bits of 128-bit lanes of dst, with the high 64 bits of 128-bit
/// lanes being copied from from a to dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Control</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_shufflelo_epi16(v256 a, int imm8)
{
return new v256(Sse2.shufflelo_epi16(a.Lo128, imm8), Sse2.shufflelo_epi16(a.Hi128, imm8));
}
/// <summary>
/// Extract 128 bits (composed of integer data) from a, selected with imm8, and store the result in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Selection</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mm256_extracti128_si256(v256 a, int imm8)
{
// Burst IR is fine.
return Avx.mm256_extractf128_si256(a, imm8);
}
/// <summary>
/// Copy a to dst, then insert 128 bits (composed of integer data) from b into dst at the location specified by imm8.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <param name="imm8">Location</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_inserti128_si256(v256 a, v128 b, int imm8)
{
// Burst IR is fine.
return Avx.mm256_insertf128_ps(a, b, imm8);
}
/// <summary>
/// Broadcast the low single-precision (32-bit) floating-point element from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 broadcastss_ps(v128 a)
{
return new v128(a.Float0);
}
/// <summary>
/// Broadcast the low single-precision (32-bit) floating-point element from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_broadcastss_ps(v128 a)
{
return new v256(a.Float0);
}
/// <summary>
/// Broadcast the low double-precision (64-bit) floating-point element from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 broadcastsd_pd(v128 a)
{
return new v128(a.Double0);
}
/// <summary>
/// Broadcast the low double-precision (64-bit) floating-point element from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_broadcastsd_pd(v128 a)
{
return new v256(a.Double0);
}
/// <summary>
/// Broadcast the low packed 8-bit integer from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 broadcastb_epi8(v128 a)
{
return new v128(a.Byte0);
}
/// <summary>
/// Broadcast the low packed 16-bit integer from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 broadcastw_epi16(v128 a)
{
return new v128(a.SShort0);
}
/// <summary>
/// Broadcast the low packed 32-bit integer from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 broadcastd_epi32(v128 a)
{
return new v128(a.SInt0);
}
/// <summary>
/// Broadcast the low packed 64-bit integer from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 broadcastq_epi64(v128 a)
{
return new v128(a.SLong0);
}
/// <summary>
/// Broadcast the low packed 8-bit integer from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_broadcastb_epi8(v128 a)
{
return new v256(a.Byte0);
}
/// <summary>
/// Broadcast the low packed 16-bit integer from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_broadcastw_epi16(v128 a)
{
return new v256(a.SShort0);
}
/// <summary>
/// Broadcast the low packed 32-bit integer from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_broadcastd_epi32(v128 a)
{
return new v256(a.SInt0);
}
/// <summary>
/// Broadcast the low packed 64-bit integer from a to all elements of dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_broadcastq_epi64(v128 a)
{
return new v256(a.SLong0);
}
/// <summary>
/// Broadcast 128 bits of integer data from a to all 128-bit lanes in dst
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_broadcastsi128_si256(v128 a)
{
// Burst IR is fine
return new v256(a, a);
}
/// <summary>
/// Sign extend packed 8-bit integers in a to packed 16-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepi8_epi16(v128 a)
{
v256 dst = default;
short* dptr = &dst.SShort0;
sbyte* aptr = &a.SByte0;
for (int j = 0; j <= 15; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed 8-bit integers in a to packed 32-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepi8_epi32(v128 a)
{
v256 dst = default;
int* dptr = &dst.SInt0;
sbyte* aptr = &a.SByte0;
for (int j = 0; j <= 7; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed 8-bit integers in a to packed 64-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepi8_epi64(v128 a)
{
v256 dst = default;
long* dptr = &dst.SLong0;
sbyte* aptr = &a.SByte0;
for (int j = 0; j <= 3; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed 16-bit integers in a to packed 32-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepi16_epi32(v128 a)
{
v256 dst = default;
int* dptr = &dst.SInt0;
short* aptr = &a.SShort0;
for (int j = 0; j <= 7; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed 16-bit integers in a to packed 64-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepi16_epi64(v128 a)
{
v256 dst = default;
long* dptr = &dst.SLong0;
short* aptr = &a.SShort0;
for (int j = 0; j <= 3; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed 32-bit integers in a to packed 64-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepi32_epi64(v128 a)
{
v256 dst = default;
long* dptr = &dst.SLong0;
int* aptr = &a.SInt0;
for (int j = 0; j <= 3; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed unsigned 8-bit integers in a to packed 16-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepu8_epi16(v128 a)
{
v256 dst = default;
short* dptr = &dst.SShort0;
byte* aptr = &a.Byte0;
for (int j = 0; j <= 15; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed unsigned 8-bit integers in a to packed 32-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepu8_epi32(v128 a)
{
v256 dst = default;
int* dptr = &dst.SInt0;
byte* aptr = &a.Byte0;
for (int j = 0; j <= 7; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed unsigned 8-bit integers in a to packed 64-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepu8_epi64(v128 a)
{
v256 dst = default;
long* dptr = &dst.SLong0;
byte* aptr = &a.Byte0;
for (int j = 0; j <= 3; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed unsigned 16-bit integers in a to packed 32-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepu16_epi32(v128 a)
{
v256 dst = default;
int* dptr = &dst.SInt0;
ushort* aptr = &a.UShort0;
for (int j = 0; j <= 7; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed unsigned 16-bit integers in a to packed 64-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepu16_epi64(v128 a)
{
v256 dst = default;
long* dptr = &dst.SLong0;
ushort* aptr = &a.UShort0;
for (int j = 0; j <= 3; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Sign extend packed unsigned 32-bit integers in a to packed 64-bit integers, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_cvtepu32_epi64(v128 a)
{
v256 dst = default;
long* dptr = &dst.SLong0;
uint* aptr = &a.UInt0;
for (int j = 0; j <= 3; j++)
{
dptr[j] = aptr[j];
}
return dst;
}
/// <summary>
/// Load packed 32-bit integers from memory into dst using mask
/// (elements are zeroed out when the highest bit is not set in the
/// corresponding element).
/// </summary>
/// <param name="mem_addr">Memory address</param>
/// <param name="mask">Mask</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 maskload_epi32(void* mem_addr, v128 mask)
{
v128 dst = default;
int* sptr = (int*)mem_addr;
int* mptr = &mask.SInt0;
int* dptr = &dst.SInt0;
for (int i = 0; i < 4; ++i)
{
if (mptr[i] < 0)
{
dptr[i] = sptr[i];
}
}
return dst;
}
/// <summary>
/// Load packed 64-bit integers from memory into dst using mask
/// (elements are zeroed out when the highest bit is not set in the
/// corresponding element).
/// </summary>
/// <param name="mem_addr">Memory address</param>
/// <param name="mask">Mask</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 maskload_epi64(void* mem_addr, v128 mask)
{
v128 dst = default;
long* sptr = (long*)mem_addr;
long* mptr = &mask.SLong0;
long* dptr = &dst.SLong0;
for (int i = 0; i < 2; ++i)
{
if (mptr[i] < 0)
{
dptr[i] = sptr[i];
}
}
return dst;
}
/// <summary>
/// Store packed 32-bit integers from a into memory using mask
/// (elements are not stored when the highest bit is not set in the
/// corresponding element).
/// </summary>
/// <param name="mem_addr">Memory address</param>
/// <param name="mask">Mask</param>
/// <param name="a">Vector a</param>
[DebuggerStepThrough]
public static void maskstore_epi32(void* mem_addr, v128 mask, v128 a)
{
int* dptr = (int*)mem_addr;
int* mptr = &mask.SInt0;
int* sptr = &a.SInt0;
for (int i = 0; i < 4; ++i)
{
if (mptr[i] < 0)
{
dptr[i] = sptr[i];
}
}
}
/// <summary>
/// Store packed 64-bit integers from a into memory using mask
/// (elements are not stored when the highest bit is not set in the
/// corresponding element).
/// </summary>
/// <param name="mem_addr">Memory address</param>
/// <param name="mask">Mask</param>
/// <param name="a">Vector a</param>
[DebuggerStepThrough]
public static void maskstore_epi64(void* mem_addr, v128 mask, v128 a)
{
long* dptr = (long*)mem_addr;
long* mptr = &mask.SLong0;
long* sptr = &a.SLong0;
for (int i = 0; i < 2; ++i)
{
if (mptr[i] < 0)
{
dptr[i] = sptr[i];
}
}
}
/// <summary>
/// Load packed 32-bit integers from memory into dst using mask
/// (elements are zeroed out when the highest bit is not set in the
/// corresponding element).
/// </summary>
/// <param name="mem_addr">Memory address</param>
/// <param name="mask">Mask</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_maskload_epi32(void* mem_addr, v256 mask)
{
v256 dst = default;
int* sptr = (int*)mem_addr;
int* mptr = &mask.SInt0;
int* dptr = &dst.SInt0;
for (int i = 0; i < 8; ++i)
{
if (mptr[i] < 0)
{
dptr[i] = sptr[i];
}
}
return dst;
}
/// <summary>
/// Load packed 64-bit integers from memory into dst using mask
/// (elements are zeroed out when the highest bit is not set in the
/// corresponding element).
/// </summary>
/// <param name="mem_addr">Memory address</param>
/// <param name="mask">Mask</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_maskload_epi64(void* mem_addr, v256 mask)
{
v256 dst = default;
long* sptr = (long*)mem_addr;
long* mptr = &mask.SLong0;
long* dptr = &dst.SLong0;
for (int i = 0; i < 4; ++i)
{
if (mptr[i] < 0)
{
dptr[i] = sptr[i];
}
}
return dst;
}
/// <summary>
/// Store packed 32-bit integers from a into memory using mask
/// (elements are not stored when the highest bit is not set in the
/// corresponding element).
/// </summary>
/// <param name="mem_addr">Memory address</param>
/// <param name="mask">Mask</param>
/// <param name="a">Vector a</param>
[DebuggerStepThrough]
public static void mm256_maskstore_epi32(void* mem_addr, v256 mask, v256 a)
{
int* dptr = (int*)mem_addr;
int* mptr = &mask.SInt0;
int* sptr = &a.SInt0;
for (int i = 0; i < 8; ++i)
{
if (mptr[i] < 0)
{
dptr[i] = sptr[i];
}
}
}
/// <summary>
/// Store packed 64-bit integers from a into memory using mask
/// (elements are not stored when the highest bit is not set in the
/// corresponding element).
/// </summary>
/// <param name="mem_addr">Memory address</param>
/// <param name="mask">Mask</param>
/// <param name="a">Vector a</param>
[DebuggerStepThrough]
public static void mm256_maskstore_epi64(void* mem_addr, v256 mask, v256 a)
{
long* dptr = (long*)mem_addr;
long* mptr = &mask.SLong0;
long* sptr = &a.SLong0;
for (int i = 0; i < 4; ++i)
{
if (mptr[i] < 0)
{
dptr[i] = sptr[i];
}
}
}
/// <summary>
/// Shuffle 32-bit integers in a across lanes using the corresponding index in idx, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="idx">idx</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_permutevar8x32_epi32(v256 a, v256 idx)
{
v256 dst = default;
int* iptr = &idx.SInt0;
int* aptr = &a.SInt0;
int* dptr = &dst.SInt0;
for (int i = 0; i < 8; ++i)
{
int index = iptr[i] & 7;
dptr[i] = aptr[index];
}
return dst;
}
/// <summary>
/// Shuffle single-precision (32-bit) floating-point elements in a across lanes using the corresponding index in idx.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="idx">idx</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_permutevar8x32_ps(v256 a, v256 idx)
{
return mm256_permutevar8x32_epi32(a, idx);
}
/// <summary>
/// Shuffle 64-bit integers in a across lanes using the control in imm8, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Control</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_permute4x64_epi64(v256 a, int imm8)
{
v256 dst = default;
long* aptr = &a.SLong0;
long* dptr = &dst.SLong0;
for (int i = 0; i < 4; ++i, imm8 >>= 2)
{
dptr[i] = aptr[imm8 & 3];
}
return dst;
}
/// <summary>
/// Shuffle double-precision (64-bit) floating-point elements in a across lanes using the control in imm8, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="imm8">Control</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_permute4x64_pd(v256 a, int imm8)
{
return mm256_permute4x64_epi64(a, imm8);
}
/// <summary>
/// Shuffle 128-bits (composed of integer data) selected by imm8 from a and b, and store the results in dst.
/// </summary>
/// <param name="a">Vector a</param>
/// <param name="b">Vector b</param>
/// <param name="imm8">Selection</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_permute2x128_si256(v256 a, v256 b, int imm8)
{
return Avx.mm256_permute2f128_si256(a, b, imm8);
}
/// <summary>
/// Load 256-bits of integer data from memory into dst using a
/// non-temporal memory hint. mem_addr must be aligned on a 32-byte
/// boundary or a general-protection exception may be generated.
/// </summary>
/// <param name="mem_addr">Memory address</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_stream_load_si256(void* mem_addr)
{
return *(v256*)mem_addr;
}
private static void EmulatedGather<T, U>(T* dptr, void* base_addr, long* indexPtr, int scale, int n, U* mask) where T : unmanaged where U : unmanaged, IComparable<U>
{
U maskZero = default;
for (int i = 0; i < n; ++i)
{
long baseIndex = indexPtr[i];
long offset = baseIndex * scale;
T* mem_addr = (T*)((byte*)base_addr + offset);
if (mask == null || mask[i].CompareTo(maskZero) < 0)
{
dptr[i] = *mem_addr;
}
}
}
private static void EmulatedGather<T, U>(T* dptr, void* base_addr, int* indexPtr, int scale, int n, U* mask) where T : unmanaged where U : unmanaged, IComparable<U>
{
U maskZero = default;
for (int i = 0; i < n; ++i)
{
long baseIndex = indexPtr[i];
long offset = baseIndex * scale;
T* mem_addr = (T*)((byte*)base_addr + offset);
if (mask == null || mask[i].CompareTo(maskZero) < 0)
{
dptr[i] = *mem_addr;
}
}
}
/// <summary>
/// Gather 32-bit integers from memory using 32-bit indices. 32-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 32-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst.
/// scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_i32gather_epi32(void* base_addr, v256 vindex, int scale)
{
v256 dst = default;
EmulatedGather<int, int>(&dst.SInt0, base_addr, &vindex.SInt0, scale, sizeof(v256) / sizeof(int), (int*)null);
return dst;
}
/// <summary>
/// Gather double-precision (64-bit) floating-point elements from
/// memory using 32-bit indices. 64-bit elements are loaded from
/// addresses starting at base_addr and offset by each 32-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst. scale should be
/// 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_i32gather_pd(void* base_addr, v128 vindex, int scale)
{
v256 dst = default;
EmulatedGather<double, long>(&dst.Double0, base_addr, &vindex.SInt0, scale, 4, null);
return dst;
}
/// <summary>
/// Gather single-precision (32-bit) floating-point elements from
/// memory using 32-bit indices. 32-bit elements are loaded from
/// addresses starting at base_addr and offset by each 32-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst using mask
/// (elements are copied from src when the highest bit is not set
/// in the corresponding element). scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_i32gather_ps(void* base_addr, v256 vindex, int scale)
{
v256 dst = default;
EmulatedGather<float, int>(&dst.Float0, base_addr, &vindex.SInt0, scale, 8, null);
return dst;
}
/// <summary>
/// Gather double-precision (64-bit) floating-point elements from
/// memory using 64-bit indices. 64-bit elements are loaded from
/// addresses starting at base_addr and offset by each 64-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst. scale should be
/// 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_i64gather_pd(void* base_addr, v256 vindex, int scale)
{
v256 dst = default;
EmulatedGather<double, long>(&dst.Double0, base_addr, &vindex.SLong0, scale, 4, null);
return dst;
}
/// <summary>
/// Gather single-precision (32-bit) floating-point elements from
/// memory using 64-bit indices. 32-bit elements are loaded from
/// addresses starting at base_addr and offset by each 64-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst. scale should be
/// 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mm256_i64gather_ps(void* base_addr, v256 vindex, int scale)
{
v128 dst = default;
EmulatedGather<float, int>(&dst.Float0, base_addr, &vindex.SLong0, scale, 4, null);
return dst;
}
/// <summary>
/// Gather double-precision (64-bit) floating-point elements from
/// memory using 32-bit indices. 64-bit elements are loaded from
/// addresses starting at base_addr and offset by each 32-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst. scale should be
/// 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 i32gather_pd(void* base_addr, v128 vindex, int scale)
{
v128 dst = default;
EmulatedGather<double, long>(&dst.Double0, base_addr, &vindex.SInt0, scale, 2, null);
return dst;
}
/// <summary>
/// Gather single-precision (32-bit) floating-point elements from
/// memory using 32-bit indices. 32-bit elements are loaded from
/// addresses starting at base_addr and offset by each 32-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst. scale should be
/// 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 i32gather_ps(void* base_addr, v128 vindex, int scale)
{
v128 dst = default;
EmulatedGather<float, int>(&dst.Float0, base_addr, &vindex.SInt0, scale, 4, null);
return dst;
}
/// <summary>
/// Gather double-precision (64-bit) floating-point elements from
/// memory using 64-bit indices. 64-bit elements are loaded from
/// addresses starting at base_addr and offset by each 64-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst. scale should be
/// 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 i64gather_pd(void* base_addr, v128 vindex, int scale)
{
v128 dst = default;
EmulatedGather<double, long>(&dst.Double0, base_addr, &vindex.SLong0, scale, 2, null);
return dst;
}
/// <summary>
/// Gather single-precision (32-bit) floating-point elements from
/// memory using 64-bit indices. 32-bit elements are loaded from
/// addresses starting at base_addr and offset by each 64-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst. scale should be
/// 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 i64gather_ps(void* base_addr, v128 vindex, int scale)
{
v128 dst = default;
EmulatedGather<float, int>(&dst.Float0, base_addr, &vindex.SLong0, scale, 2, null);
return dst;
}
/// <summary>
/// Gather 64-bit integers from memory using 32-bit indices. 64-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 32-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst.
/// scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_i32gather_epi64(void* base_addr, v128 vindex, int scale)
{
v256 dst = default;
EmulatedGather<long, long>(&dst.SLong0, base_addr, &vindex.SInt0, scale, 4, null);
return dst;
}
/// <summary>
/// Gather 32-bit integers from memory using 64-bit indices. 32-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 64-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst.
/// scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mm256_i64gather_epi32(void* base_addr, v256 vindex, int scale)
{
v128 dst = default;
EmulatedGather<int, int>(&dst.SInt0, base_addr, &vindex.SLong0, scale, 4, null);
return dst;
}
/// <summary>
/// Gather 64-bit integers from memory using 64-bit indices. 64-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 64-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst.
/// scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_i64gather_epi64(void* base_addr, v256 vindex, int scale)
{
v256 dst = default;
EmulatedGather<long, long>(&dst.SLong0, base_addr, &vindex.SLong0, scale, 4, null);
return dst;
}
/// <summary>
/// Gather 32-bit integers from memory using 32-bit indices. 32-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 32-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst.
/// scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 i32gather_epi32(void* base_addr, v128 vindex, int scale)
{
v128 dst = default;
EmulatedGather<int, int>(&dst.SInt0, base_addr, &vindex.SInt0, scale, 4, null);
return dst;
}
/// <summary>
/// Gather 64-bit integers from memory using 32-bit indices. 64-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 32-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst.
/// scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 i32gather_epi64(void* base_addr, v128 vindex, int scale)
{
v128 dst = default;
EmulatedGather<long, long>(&dst.SLong0, base_addr, &vindex.SInt0, scale, 2, null);
return dst;
}
/// <summary>
/// Gather 32-bit integers from memory using 64-bit indices. 32-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 64-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst.
/// scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 i64gather_epi32(void* base_addr, v128 vindex, int scale)
{
v128 dst = default;
EmulatedGather<int, int>(&dst.SInt0, base_addr, &vindex.SLong0, scale, 2, null);
return dst;
}
/// <summary>
/// Gather 64-bit integers from memory using 64-bit indices. 64-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 64-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst.
/// scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 i64gather_epi64(void* base_addr, v128 vindex, int scale)
{
v128 dst = default;
EmulatedGather<long, long>(&dst.SLong0, base_addr, &vindex.SLong0, scale, 2, null);
return dst;
}
/// <summary>
/// Gather double-precision (64-bit) floating-point elements from
/// memory using 32-bit indices. 64-bit elements are loaded from
/// addresses starting at base_addr and offset by each 32-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst using mask
/// (elements are copied from src when the highest bit is not set
/// in the corresponding element). scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mask_i32gather_pd(v256 src, void* base_addr, v128 vindex, v256 mask, int scale)
{
v256 dst = src;
EmulatedGather<double, long>(&dst.Double0, base_addr, &vindex.SInt0, scale, 4, &mask.SLong0);
return dst;
}
/// <summary>
/// Gather single-precision (32-bit) floating-point elements from
/// memory using 32-bit indices. 32-bit elements are loaded from
/// addresses starting at base_addr and offset by each 32-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst using mask
/// (elements are copied from src when the highest bit is not set
/// in the corresponding element). scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mask_i32gather_ps(v256 src, void* base_addr, v256 vindex, v256 mask, int scale)
{
v256 dst = src;
EmulatedGather<float, int>(&dst.Float0, base_addr, &vindex.SInt0, scale, 8, &mask.SInt0);
return dst;
}
/// <summary>
/// Gather double-precision (64-bit) floating-point elements from
/// memory using 64-bit indices. 64-bit elements are loaded from
/// addresses starting at base_addr and offset by each 64-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst using mask
/// (elements are copied from src when the highest bit is not set
/// in the corresponding element). scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mask_i64gather_pd(v256 src, void* base_addr, v256 vindex, v256 mask, int scale)
{
v256 dst = src;
EmulatedGather<double, long>(&dst.Double0, base_addr, &vindex.SLong0, scale, 4, &mask.SLong0);
return dst;
}
/// <summary>
/// Gather single-precision (32-bit) floating-point elements from
/// memory using 64-bit indices. 32-bit elements are loaded from
/// addresses starting at base_addr and offset by each 64-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst using mask
/// (elements are copied from src when the highest bit is not set
/// in the corresponding element). scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mm256_mask_i64gather_ps(v128 src, void* base_addr, v256 vindex, v128 mask, int scale)
{
v128 dst = src;
EmulatedGather<float, int>(&dst.Float0, base_addr, &vindex.SLong0, scale, 4, &mask.SInt0);
return dst;
}
/// <summary>
/// Gather 32-bit integers from memory using 32-bit indices. 32-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 32-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst
/// using mask (elements are copied from src when the highest bit
/// is not set in the corresponding element). scale should be 1, 2,
/// 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mask_i32gather_epi32(v256 src, void* base_addr, v256 vindex, v256 mask, int scale)
{
v256 dst = src;
EmulatedGather<int, int>(&dst.SInt0, base_addr, &vindex.SInt0, scale, 8, &mask.SInt0);
return dst;
}
/// <summary>
/// Gather 64-bit integers from memory using 32-bit indices. 64-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 32-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst
/// using mask (elements are copied from src when the highest bit
/// is not set in the corresponding element). scale should be 1, 2,
/// 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mask_i32gather_epi64(v256 src, void* base_addr, v128 vindex, v256 mask, int scale)
{
v256 dst = src;
EmulatedGather<long, long>(&dst.SLong0, base_addr, &vindex.SInt0, scale, 4, &mask.SLong0);
return dst;
}
/// <summary>
/// Gather 64-bit integers from memory using 64-bit indices. 64-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 64-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst
/// using mask (elements are copied from src when the highest bit
/// is not set in the corresponding element). scale should be 1, 2,
/// 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v256 mm256_mask_i64gather_epi64(v256 src, void* base_addr, v256 vindex, v256 mask, int scale)
{
v256 dst = src;
EmulatedGather<long, long>(&dst.SLong0, base_addr, &vindex.SLong0, scale, 4, &mask.SLong0);
return dst;
}
/// <summary>
/// Gather 32-bit integers from memory using 64-bit indices. 32-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 64-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst
/// using mask (elements are copied from src when the highest bit
/// is not set in the corresponding element). scale should be 1, 2,
/// 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mm256_mask_i64gather_epi32(v128 src, void* base_addr, v256 vindex, v128 mask, int scale)
{
v128 dst = src;
EmulatedGather<int, int>(&dst.SInt0, base_addr, &vindex.SLong0, scale, 4, &mask.SInt0);
return dst;
}
/// <summary>
/// Gather double-precision (64-bit) floating-point elements from
/// memory using 32-bit indices. 64-bit elements are loaded from
/// addresses starting at base_addr and offset by each 32-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst using mask
/// (elements are copied from src when the highest bit is not set
/// in the corresponding element). scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mask_i32gather_pd(v128 src, void* base_addr, v128 vindex, v128 mask, int scale)
{
v128 dst = src;
EmulatedGather<double, long>(&dst.Double0, base_addr, &vindex.SInt0, scale, 2, &mask.SLong0);
return dst;
}
/// <summary>
/// Gather single-precision (32-bit) floating-point elements from
/// memory using 32-bit indices. 32-bit elements are loaded from
/// addresses starting at base_addr and offset by each 32-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst using mask
/// (elements are copied from src when the highest bit is not set
/// in the corresponding element). scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mask_i32gather_ps(v128 src, void* base_addr, v128 vindex, v128 mask, int scale)
{
v128 dst = src;
EmulatedGather<float, int>(&dst.Float0, base_addr, &vindex.SInt0, scale, 4, &mask.SInt0);
return dst;
}
/// <summary>
/// Gather double-precision (64-bit) floating-point elements from
/// memory using 64-bit indices. 64-bit elements are loaded from
/// addresses starting at base_addr and offset by each 64-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst using mask
/// (elements are copied from src when the highest bit is not set
/// in the corresponding element). scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mask_i64gather_pd(v128 src, void* base_addr, v128 vindex, v128 mask, int scale)
{
v128 dst = src;
EmulatedGather<double, long>(&dst.Double0, base_addr, &vindex.SLong0, scale, 2, &mask.SLong0);
return dst;
}
/// <summary>
/// Gather single-precision (32-bit) floating-point elements from
/// memory using 64-bit indices. 32-bit elements are loaded from
/// addresses starting at base_addr and offset by each 64-bit
/// element in vindex (each index is scaled by the factor in
/// scale). Gathered elements are merged into dst using mask
/// (elements are copied from src when the highest bit is not set
/// in the corresponding element). scale should be 1, 2, 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mask_i64gather_ps(v128 src, void* base_addr, v128 vindex, v128 mask, int scale)
{
v128 dst = src;
dst.UInt2 = dst.UInt3 = 0;
EmulatedGather<float, int>(&dst.Float0, base_addr, &vindex.SLong0, scale, 2, &mask.SInt0);
return dst;
}
/// <summary>
/// Gather 32-bit integers from memory using 32-bit indices. 32-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 32-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst
/// using mask (elements are copied from src when the highest bit
/// is not set in the corresponding element). scale should be 1, 2,
/// 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mask_i32gather_epi32(v128 src, void* base_addr, v128 vindex, v128 mask, int scale)
{
v128 dst = src;
EmulatedGather<int, int>(&dst.SInt0, base_addr, &vindex.SInt0, scale, 4, &mask.SInt0);
return dst;
}
/// <summary>
/// Gather 64-bit integers from memory using 32-bit indices. 64-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 32-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst
/// using mask (elements are copied from src when the highest bit
/// is not set in the corresponding element). scale should be 1, 2,
/// 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mask_i32gather_epi64(v128 src, void* base_addr, v128 vindex, v128 mask, int scale)
{
v128 dst = src;
EmulatedGather<long, long>(&dst.SLong0, base_addr, &vindex.SInt0, scale, 2, &mask.SLong0);
return dst;
}
/// <summary>
/// Gather 32-bit integers from memory using 64-bit indices. 32-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 64-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst
/// using mask (elements are copied from src when the highest bit
/// is not set in the corresponding element). scale should be 1, 2,
/// 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mask_i64gather_epi32(v128 src, void* base_addr, v128 vindex, v128 mask, int scale)
{
v128 dst = src;
dst.UInt2 = dst.UInt3 = 0;
EmulatedGather<int, int>(&dst.SInt0, base_addr, &vindex.SLong0, scale, 2, &mask.SInt0);
return dst;
}
/// <summary>
/// Gather 64-bit integers from memory using 64-bit indices. 64-bit
/// elements are loaded from addresses starting at base_addr and
/// offset by each 64-bit element in vindex (each index is scaled
/// by the factor in scale). Gathered elements are merged into dst
/// using mask (elements are copied from src when the highest bit
/// is not set in the corresponding element). scale should be 1, 2,
/// 4 or 8.
/// </summary>
/// <param name="src">Source</param>
/// <param name="base_addr">Base address</param>
/// <param name="vindex">Offset</param>
/// <param name="mask">Mask</param>
/// <param name="scale">Index scale</param>
/// <returns>Vector</returns>
[DebuggerStepThrough]
public static v128 mask_i64gather_epi64(v128 src, void* base_addr, v128 vindex, v128 mask, int scale)
{
v128 dst = src;
EmulatedGather<long, long>(&dst.SLong0, base_addr, &vindex.SLong0, scale, 2, &mask.SLong0);
return dst;
}
}
}
}