mirrors/Ryujinx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Removed sse checks that were no longer needed

Browse source
This commit is contained in:
Andy Adshead 2019-01-22 02:45:13 +00:00
parent 2d39139e00
commit 14f44e47af
1 changed files with 27 additions and 217 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

244
ChocolArm64/Instructions/VectorHelper.cs
View file

@ -500,268 +500,78 @@ namespace ChocolArm64.Instructions
return Sse41.Insert(vector, Vector128.CreateScalarUnsafe(value), 0b1110);
}
// Zero helpers
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<sbyte> VectorSByteZero()
{
if (Sse2.IsSupported)
{
return Vector128<sbyte>.Zero;
}
throw new PlatformNotSupportedException();
}
public static Vector128<sbyte> VectorSByteZero() => Vector128<sbyte>.Zero;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<short> VectorInt16Zero()
{
if (Sse2.IsSupported)
{
return Vector128<short>.Zero;
}
throw new PlatformNotSupportedException();
}
public static Vector128<short> VectorInt16Zero() => Vector128<short>.Zero;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<int> VectorInt32Zero()
{
if (Sse2.IsSupported)
{
return Vector128<int>.Zero;
}
throw new PlatformNotSupportedException();
}
public static Vector128<int> VectorInt32Zero() => Vector128<int>.Zero;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<long> VectorInt64Zero()
{
if (Sse2.IsSupported)
{
return Vector128<long>.Zero;
}
throw new PlatformNotSupportedException();
}
public static Vector128<long> VectorInt64Zero() => Vector128<long>.Zero;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<float> VectorSingleZero()
{
if (Sse.IsSupported)
{
return Vector128<float>.Zero;
}
throw new PlatformNotSupportedException();
}
public static Vector128<float> VectorSingleZero() => Vector128<float>.Zero;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<double> VectorDoubleZero()
{
if (Sse2.IsSupported)
{
return Vector128<double>.Zero;
}
public static Vector128<double> VectorDoubleZero() => Vector128<double>.Zero;
throw new PlatformNotSupportedException();
}
// Cast helpers
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<sbyte> VectorSingleToSByte(Vector128<float> vector) => vector.As<sbyte>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<sbyte> VectorSingleToSByte(Vector128<float> vector)
{
if (Sse.IsSupported)
{
return vector.As<sbyte>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<short> VectorSingleToInt16(Vector128<float> vector) => vector.As<short>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<short> VectorSingleToInt16(Vector128<float> vector)
{
if (Sse.IsSupported)
{
return vector.As<short>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<int> VectorSingleToInt32(Vector128<float> vector) => vector.As<int>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<int> VectorSingleToInt32(Vector128<float> vector)
{
if (Sse.IsSupported)
{
return vector.As<int>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<long> VectorSingleToInt64(Vector128<float> vector) => vector.As<long>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<long> VectorSingleToInt64(Vector128<float> vector)
{
if (Sse.IsSupported)
{
return vector.As<long>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<byte> VectorSingleToByte(Vector128<float> vector) => vector.As<byte>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<byte> VectorSingleToByte(Vector128<float> vector)
{
if (Sse.IsSupported)
{
return vector.As<byte>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<ushort> VectorSingleToUInt16(Vector128<float> vector) => vector.As<ushort>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<ushort> VectorSingleToUInt16(Vector128<float> vector)
{
if (Sse.IsSupported)
{
return vector.As<ushort>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<uint> VectorSingleToUInt32(Vector128<float> vector) => vector.As<uint>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<uint> VectorSingleToUInt32(Vector128<float> vector)
{
if (Sse.IsSupported)
{
return vector.As<uint>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<ulong> VectorSingleToUInt64(Vector128<float> vector) => vector.As<ulong>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<ulong> VectorSingleToUInt64(Vector128<float> vector)
{
if (Sse.IsSupported)
{
return vector.As<ulong>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<double> VectorSingleToDouble(Vector128<float> vector) => vector.As<double>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<double> VectorSingleToDouble(Vector128<float> vector)
{
if (Sse.IsSupported)
{
return vector.As<double>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<float> VectorSByteToSingle(Vector128<sbyte> vector) => vector.As<float>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<float> VectorSByteToSingle(Vector128<sbyte> vector)
{
if (Sse.IsSupported)
{
return vector.As<float>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<float> VectorInt16ToSingle(Vector128<short> vector) => vector.As<float>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<float> VectorInt16ToSingle(Vector128<short> vector)
{
if (Sse.IsSupported)
{
return vector.As<float>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<float> VectorInt32ToSingle(Vector128<int> vector) => vector.As<float>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<float> VectorInt32ToSingle(Vector128<int> vector)
{
if (Sse.IsSupported)
{
return vector.As<float>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<float> VectorInt64ToSingle(Vector128<long> vector) => vector.As<float>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<float> VectorInt64ToSingle(Vector128<long> vector)
{
if (Sse.IsSupported)
{
return vector.As<float>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<float> VectorByteToSingle(Vector128<byte> vector) => vector.As<float>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<float> VectorByteToSingle(Vector128<byte> vector)
{
if (Sse.IsSupported)
{
return vector.As<float>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<float> VectorUInt16ToSingle(Vector128<ushort> vector) => vector.As<float>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<float> VectorUInt16ToSingle(Vector128<ushort> vector)
{
if (Sse.IsSupported)
{
return vector.As<float>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<float> VectorUInt32ToSingle(Vector128<uint> vector) => vector.As<float>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<float> VectorUInt32ToSingle(Vector128<uint> vector)
{
if (Sse.IsSupported)
{
return vector.As<float>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<float> VectorUInt64ToSingle(Vector128<ulong> vector) => vector.As<float>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<float> VectorUInt64ToSingle(Vector128<ulong> vector)
{
if (Sse.IsSupported)
{
return vector.As<float>();
}
throw new PlatformNotSupportedException();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector128<float> VectorDoubleToSingle(Vector128<double> vector)
{
if (Sse.IsSupported)
{
return vector.As<float>();
}
throw new PlatformNotSupportedException();
}
public static Vector128<float> VectorDoubleToSingle(Vector128<double> vector) => vector.As<float>();
}
}