Skip to content
This repository was archived by the owner on Jan 23, 2023. It is now read-only.

Arm64: Add S.P.CoreLib instrinsics UnzipEven and UnzipOdd #27731

Merged
merged 4 commits into from
Nov 8, 2019
Merged

Arm64: Add S.P.CoreLib instrinsics UnzipEven and UnzipOdd #27731

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
cf82dce
Arm64: Update S.P.CoreLib for UnzipEven and UnzipOdd
TamarChristinaArm Nov 7, 2019
5c6e7df
Merge branch 'master' into implement-arm64-unzip
echesakov Nov 8, 2019
34192b3
Fix error during rebasing
echesakov Nov 8, 2019
4318b2e
Fix error during rebase
echesakov Nov 8, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
204 changes: 204 additions & 0 deletions ...stem.Private.CoreLib/shared/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -136,6 +136,210 @@ internal Arm64() { }
/// </summary>
public static Vector128<sbyte> ReverseElementBits(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint8x8_t vuzp1_u8(uint8x8_t a, uint8x8_t b)
/// A64: UZP1 Vd.8B, Vn.8B, Vm.8B
/// </summary>
public static Vector64<byte> UnzipEven(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int16x4_t vuzp1_s16(int16x4_t a, int16x4_t b)
/// A64: UZP1 Vd.4H, Vn.4H, Vm.4H
/// </summary>
public static Vector64<short> UnzipEven(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int32x2_t vuzp1_s32(int32x2_t a, int32x2_t b)
/// A64: UZP1 Vd.2S, Vn.2S, Vm.2S
/// </summary>
public static Vector64<int> UnzipEven(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int8x8_t vuzp1_s8(int8x8_t a, int8x8_t b)
/// A64: UZP1 Vd.8B, Vn.8B, Vm.8B
/// </summary>
public static Vector64<sbyte> UnzipEven(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// float32x2_t vuzp1_f32(float32x2_t a, float32x2_t b)
/// A64: UZP1 Vd.2S, Vn.2S, Vm.2S
/// </summary>
public static Vector64<float> UnzipEven(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint16x4_t vuzp1_u16(uint16x4_t a, uint16x4_t b)
/// A64: UZP1 Vd.4H, Vn.4H, Vm.4H
/// </summary>
public static Vector64<ushort> UnzipEven(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint32x2_t vuzp1_u32(uint32x2_t a, uint32x2_t b)
/// A64: UZP1 Vd.2S, Vn.2S, Vm.2S
/// </summary>
public static Vector64<uint> UnzipEven(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint8x16_t vuzp1q_u8(uint8x16_t a, uint8x16_t b)
/// A64: UZP1 Vd.16B, Vn.16B, Vm.16B
/// </summary>
public static Vector128<byte> UnzipEven(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// float64x2_t vuzp1q_f64(float64x2_t a, float64x2_t b)
/// A64: UZP1 Vd.2D, Vn.2D, Vm.2D
/// </summary>
public static Vector128<double> UnzipEven(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int16x8_t vuzp1q_s16(int16x8_t a, int16x8_t b)
/// A64: UZP1 Vd.8H, Vn.8H, Vm.8H
/// </summary>
public static Vector128<short> UnzipEven(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int32x4_t vuzp1q_s32(int32x4_t a, int32x4_t b)
/// A64: UZP1 Vd.4S, Vn.4S, Vm.4S
/// </summary>
public static Vector128<int> UnzipEven(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int64x2_t vuzp1q_s64(int64x2_t a, int64x2_t b)
/// A64: UZP1 Vd.2D, Vn.2D, Vm.2D
/// </summary>
public static Vector128<long> UnzipEven(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int8x16_t vuzp1q_u8(int8x16_t a, int8x16_t b)
/// A64: UZP1 Vd.16B, Vn.16B, Vm.16B
/// </summary>
public static Vector128<sbyte> UnzipEven(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// float32x4_t vuzp1q_f32(float32x4_t a, float32x4_t b)
/// A64: UZP1 Vd.4S, Vn.4S, Vm.4S
/// </summary>
public static Vector128<float> UnzipEven(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint16x8_t vuzp1q_u16(uint16x8_t a, uint16x8_t b)
/// A64: UZP1 Vd.8H, Vn.8H, Vm.8H
/// </summary>
public static Vector128<ushort> UnzipEven(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint32x4_t vuzp1q_u32(uint32x4_t a, uint32x4_t b)
/// A64: UZP1 Vd.4S, Vn.4S, Vm.4S
/// </summary>
public static Vector128<uint> UnzipEven(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint64x2_t vuzp1q_u64(uint64x2_t a, uint64x2_t b)
/// A64: UZP1 Vd.2D, Vn.2D, Vm.2D
/// </summary>
public static Vector128<ulong> UnzipEven(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint8x8_t vuzp2_u8(uint8x8_t a, uint8x8_t b)
/// A64: UZP2 Vd.8B, Vn.8B, Vm.8B
/// </summary>
public static Vector64<byte> UnzipOdd(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int16x4_t vuzp2_s16(int16x4_t a, int16x4_t b)
/// A64: UZP2 Vd.4H, Vn.4H, Vm.4H
/// </summary>
public static Vector64<short> UnzipOdd(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int32x2_t vuzp2_s32(int32x2_t a, int32x2_t b)
/// A64: UZP2 Vd.2S, Vn.2S, Vm.2S
/// </summary>
public static Vector64<int> UnzipOdd(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int8x8_t vuzp2_s8(int8x8_t a, int8x8_t b)
/// A64: UZP2 Vd.8B, Vn.8B, Vm.8B
/// </summary>
public static Vector64<sbyte> UnzipOdd(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// float32x2_t vuzp2_f32(float32x2_t a, float32x2_t b)
/// A64: UZP2 Vd.2S, Vn.2S, Vm.2S
/// </summary>
public static Vector64<float> UnzipOdd(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint16x4_t vuzp2_u16(uint16x4_t a, uint16x4_t b)
/// A64: UZP2 Vd.4H, Vn.4H, Vm.4H
/// </summary>
public static Vector64<ushort> UnzipOdd(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint32x2_t vuzp2_u32(uint32x2_t a, uint32x2_t b)
/// A64: UZP2 Vd.2S, Vn.2S, Vm.2S
/// </summary>
public static Vector64<uint> UnzipOdd(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint8x16_t vuzp2q_u8(uint8x16_t a, uint8x16_t b)
/// A64: UZP2 Vd.16B, Vn.16B, Vm.16B
/// </summary>
public static Vector128<byte> UnzipOdd(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// float64x2_t vuzp2q_f64(float64x2_t a, float64x2_t b)
/// A64: UZP2 Vd.2D, Vn.2D, Vm.2D
/// </summary>
public static Vector128<double> UnzipOdd(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int16x8_t vuzp2q_s16(int16x8_t a, int16x8_t b)
/// A64: UZP2 Vd.8H, Vn.8H, Vm.8H
/// </summary>
public static Vector128<short> UnzipOdd(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int32x4_t vuzp2q_s32(int32x4_t a, int32x4_t b)
/// A64: UZP2 Vd.4S, Vn.4S, Vm.4S
/// </summary>
public static Vector128<int> UnzipOdd(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int64x2_t vuzp2q_s64(int64x2_t a, int64x2_t b)
/// A64: UZP2 Vd.2D, Vn.2D, Vm.2D
/// </summary>
public static Vector128<long> UnzipOdd(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// int8x16_t vuzp2q_u8(int8x16_t a, int8x16_t b)
/// A64: UZP2 Vd.16B, Vn.16B, Vm.16B
/// </summary>
public static Vector128<sbyte> UnzipOdd(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// float32x4_t vuzp2_f32(float32x4_t a, float32x4_t b)
/// A64: UZP2 Vd.4S, Vn.4S, Vm.4S
/// </summary>
public static Vector128<float> UnzipOdd(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint16x8_t vuzp2q_u16(uint16x8_t a, uint16x8_t b)
/// A64: UZP2 Vd.8H, Vn.8H, Vm.8H
/// </summary>
public static Vector128<ushort> UnzipOdd(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint32x4_t vuzp2q_u32(uint32x4_t a, uint32x4_t b)
/// A64: UZP2 Vd.4S, Vn.4S, Vm.4S
/// </summary>
public static Vector128<uint> UnzipOdd(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint64x2_t vuzp2q_u64(uint64x2_t a, uint64x2_t b)
/// A64: UZP2 Vd.2D, Vn.2D, Vm.2D
/// </summary>
public static Vector128<ulong> UnzipOdd(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }

/// <summary>
/// uint8x8_t vzip2_u8(uint8x8_t a, uint8x8_t b)
/// A64: ZIP2 Vd.8B, Vn.8B, Vm.8B
Expand Down
Loading