mirrors/Ryujinx
1
0
Fork 0
mirror of https://github.com/Ryubing/Ryujinx.git synced 2025-03-15 02:44:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

misc: chore: Use collection expressions everywhere else (except VP9)

Browse source
This commit is contained in:
Evan Husted 2025-01-26 15:59:11 -06:00
parent 0f857400b6
commit ac838aa81d
59 changed files with 3246 additions and 2452 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/Ryujinx.Graphics.GAL/Multithreading/BufferMap.cs
View file

@ -16,7 +16,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading
private ulong _bufferHandle = 0;
private readonly Dictionary<BufferHandle, BufferHandle> _bufferMap = new();
private readonly HashSet<BufferHandle> _inFlight = new();
private readonly HashSet<BufferHandle> _inFlight = [];
private readonly AutoResetEvent _inFlightChanged = new(false);
internal BufferHandle CreateBufferHandle()

2
src/Ryujinx.Graphics.GAL/Multithreading/Resources/ProgramQueue.cs
View file

@ -22,7 +22,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
_renderer = renderer;
_toCompile = new Queue<IProgramRequest>();
_inProgress = new List<ThreadedProgram>();
_inProgress = [];
}
public void Add(IProgramRequest request)

2
src/Ryujinx.Graphics.GAL/Multithreading/SyncMap.cs
View file

@ -6,7 +6,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading
{
class SyncMap : IDisposable
{
private readonly HashSet<ulong> _inFlight = new();
private readonly HashSet<ulong> _inFlight = [];
private readonly AutoResetEvent _inFlightChanged = new(false);
internal void CreateSyncHandle(ulong id)

2
src/Ryujinx.Graphics.Host1x/SyncptIncrManager.cs
View file

@ -23,7 +23,7 @@ namespace Ryujinx.Graphics.Host1x
}
}
private readonly List<SyncptIncr> _incrs = new();
private readonly List<SyncptIncr> _incrs = [];
private uint _currentId;

6
src/Ryujinx.Graphics.Metal/CacheByRange.cs
View file

@ -149,7 +149,7 @@ namespace Ryujinx.Graphics.Metal
{
if (entry.DependencyList == null)
{
entry.DependencyList = new List<Dependency>();
entry.DependencyList = [];
entries[i] = entry;
}
@ -240,7 +240,7 @@ namespace Ryujinx.Graphics.Metal
DestroyEntry(entry);
}
(toRemove ??= new List<ulong>()).Add(range.Key);
(toRemove ??= []).Add(range.Key);
}
}
@ -262,7 +262,7 @@ namespace Ryujinx.Graphics.Metal
if (!_ranges.TryGetValue(key, out List<Entry> value))
{
value = new List<Entry>();
value = [];
_ranges.Add(key, value);
}

4
src/Ryujinx.Graphics.Metal/CommandBufferPool.cs
View file

@ -50,8 +50,8 @@ namespace Ryujinx.Graphics.Metal
public void Initialize()
{
Dependants = new List<IAuto>();
Waitables = new List<MultiFenceHolder>();
Dependants = [];
Waitables = [];
Encoders = new CommandBufferEncoder();
}
}

10
src/Ryujinx.Graphics.Metal/EncoderResources.cs
View file

@ -5,9 +5,9 @@ namespace Ryujinx.Graphics.Metal
{
public struct RenderEncoderBindings
{
public List<Resource> Resources = new();
public List<BufferResource> VertexBuffers = new();
public List<BufferResource> FragmentBuffers = new();
public List<Resource> Resources = [];
public List<BufferResource> VertexBuffers = [];
public List<BufferResource> FragmentBuffers = [];
public RenderEncoderBindings() { }
@ -21,8 +21,8 @@ namespace Ryujinx.Graphics.Metal
public struct ComputeEncoderBindings
{
public List<Resource> Resources = new();
public List<BufferResource> Buffers = new();
public List<Resource> Resources = [];
public List<BufferResource> Buffers = [];
public ComputeEncoderBindings() { }

8
src/Ryujinx.Graphics.Metal/HashTableSlim.cs
View file

@ -89,10 +89,10 @@ namespace Ryujinx.Graphics.Metal
}
else
{
bucket.Entries = new[]
{
entry,
};
bucket.Entries =
[
entry
];
}
bucket.Length++;

6
src/Ryujinx.Graphics.Metal/HelperShader.cs
View file

@ -27,9 +27,9 @@ namespace Ryujinx.Graphics.Metal
private readonly IProgram _programColorBlitMsF;
private readonly IProgram _programColorBlitMsI;
private readonly IProgram _programColorBlitMsU;
private readonly List<IProgram> _programsColorClearF = new();
private readonly List<IProgram> _programsColorClearI = new();
private readonly List<IProgram> _programsColorClearU = new();
private readonly List<IProgram> _programsColorClearF = [];
private readonly List<IProgram> _programsColorClearI = [];
private readonly List<IProgram> _programsColorClearU = [];
private readonly IProgram _programDepthStencilClear;
private readonly IProgram _programStrideChange;
private readonly IProgram _programConvertD32S8ToD24S8;

2
src/Ryujinx.Graphics.Metal/IdList.cs
View file

@ -10,7 +10,7 @@ namespace Ryujinx.Graphics.Metal
public IdList()
{
_list = new List<T>();
_list = [];
_freeMin = 0;
}

4
src/Ryujinx.Graphics.Metal/MetalRenderer.cs
View file

@ -45,8 +45,8 @@ namespace Ryujinx.Graphics.Metal
public MetalRenderer(Func<CAMetalLayer> metalLayer)
{
_device = MTLDevice.CreateSystemDefaultDevice();
Programs = new HashSet<Program>();
Samplers = new HashSet<SamplerHolder>();
Programs = [];
Samplers = [];
if (_device.ArgumentBuffersSupport != MTLArgumentBuffersTier.Tier2)
{

2
src/Ryujinx.Graphics.Metal/Program.cs
View file

@ -118,7 +118,7 @@ namespace Ryujinx.Graphics.Metal
for (int setIndex = 0; setIndex < setUsages.Count; setIndex++)
{
List<ResourceBindingSegment> currentSegments = new();
List<ResourceBindingSegment> currentSegments = [];
ResourceUsage currentUsage = default;
int currentCount = 0;

4
src/Ryujinx.Graphics.Metal/ResourceLayoutBuilder.cs
View file

@ -20,8 +20,8 @@ namespace Ryujinx.Graphics.Metal
for (int index = 0; index < TotalSets; index++)
{
_resourceDescriptors[index] = new();
_resourceUsages[index] = new();
_resourceDescriptors[index] = [];
_resourceUsages[index] = [];
}
}

2
src/Ryujinx.Graphics.Metal/SyncManager.cs
View file

@ -32,7 +32,7 @@ namespace Ryujinx.Graphics.Metal
public SyncManager(MetalRenderer renderer)
{
_renderer = renderer;
_handles = new List<SyncHandle>();
_handles = [];
}
public void RegisterFlush()

16
src/Ryujinx.Graphics.Nvdec.FFmpeg/H264/SpsAndPpsReconstruction.cs
View file

@ -118,8 +118,8 @@ namespace Ryujinx.Graphics.Nvdec.FFmpeg.H264
}
// ZigZag LUTs from libavcodec.
private static ReadOnlySpan<byte> ZigZagDirect => new byte[]
{
private static ReadOnlySpan<byte> ZigZagDirect =>
[
0, 1, 8, 16, 9, 2, 3, 10,
17, 24, 32, 25, 18, 11, 4, 5,
12, 19, 26, 33, 40, 48, 41, 34,
@ -127,16 +127,16 @@ namespace Ryujinx.Graphics.Nvdec.FFmpeg.H264
35, 42, 49, 56, 57, 50, 43, 36,
29, 22, 15, 23, 30, 37, 44, 51,
58, 59, 52, 45, 38, 31, 39, 46,
53, 60, 61, 54, 47, 55, 62, 63,
};
53, 60, 61, 54, 47, 55, 62, 63
];
private static ReadOnlySpan<byte> ZigZagScan => new byte[]
{
private static ReadOnlySpan<byte> ZigZagScan =>
[
0 + 0 * 4, 1 + 0 * 4, 0 + 1 * 4, 0 + 2 * 4,
1 + 1 * 4, 2 + 0 * 4, 3 + 0 * 4, 2 + 1 * 4,
1 + 2 * 4, 0 + 3 * 4, 1 + 3 * 4, 2 + 2 * 4,
3 + 1 * 4, 3 + 2 * 4, 2 + 3 * 4, 3 + 3 * 4,
};
3 + 1 * 4, 3 + 2 * 4, 2 + 3 * 4, 3 + 3 * 4
];
private static void WriteScalingList(ref H264BitStreamWriter writer, IArray<byte> list)
{

4
src/Ryujinx.Graphics.Texture/Astc/AstcDecoder.cs
View file

@ -1693,12 +1693,12 @@ namespace Ryujinx.Graphics.Texture.Astc
if (h)
{
ReadOnlySpan<byte> maxWeights = new byte[] { 9, 11, 15, 19, 23, 31 };
ReadOnlySpan<byte> maxWeights = [9, 11, 15, 19, 23, 31];
texelParams.MaxWeight = maxWeights[r - 2];
}
else
{
ReadOnlySpan<byte> maxWeights = new byte[] { 1, 2, 3, 4, 5, 7 };
ReadOnlySpan<byte> maxWeights = [1, 2, 3, 4, 5, 7];
texelParams.MaxWeight = maxWeights[r - 2];
}

18
src/Ryujinx.Graphics.Texture/Astc/IntegerEncoded.cs
View file

@ -129,7 +129,7 @@ namespace Ryujinx.Graphics.Texture.Astc
ref IntegerSequence listIntegerEncoded,
int numberBitsPerValue)
{
ReadOnlySpan<byte> interleavedBits = new byte[] { 3, 2, 2 };
ReadOnlySpan<byte> interleavedBits = [3, 2, 2];
// Implement the algorithm in section C.2.12
Span<int> m = stackalloc int[3];
@ -213,8 +213,8 @@ namespace Ryujinx.Graphics.Texture.Astc
return QuintEncodings.Slice(index * 3, 3);
}
private static ReadOnlySpan<byte> TritEncodings => new byte[]
{
private static ReadOnlySpan<byte> TritEncodings =>
[
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0,
2, 1, 0, 0, 0, 1, 0, 2, 0, 0, 0, 2, 0, 0, 0,
@ -300,11 +300,11 @@ namespace Ryujinx.Graphics.Texture.Astc
2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 0, 2, 1, 1, 2,
1, 2, 1, 1, 2, 2, 2, 1, 1, 2, 2, 1, 2, 1, 2,
0, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 1, 2, 2, 2,
};
2, 1, 2, 2, 2
];
private static ReadOnlySpan<byte> QuintEncodings => new byte[]
{
private static ReadOnlySpan<byte> QuintEncodings =>
[
0, 0, 0, 1, 0, 0, 2, 0, 0, 3, 0, 0, 4, 0, 0,
0, 4, 0, 4, 4, 0, 4, 4, 4, 0, 1, 0, 1, 1, 0,
2, 1, 0, 3, 1, 0, 4, 1, 0, 1, 4, 0, 4, 4, 1,
@ -330,7 +330,7 @@ namespace Ryujinx.Graphics.Texture.Astc
0, 1, 4, 1, 1, 4, 0, 2, 3, 1, 2, 3, 2, 2, 3,
3, 2, 3, 4, 2, 3, 2, 4, 3, 0, 2, 4, 1, 2, 4,
0, 3, 3, 1, 3, 3, 2, 3, 3, 3, 3, 3, 4, 3, 3,
3, 4, 3, 0, 3, 4, 1, 3, 4,
};
3, 4, 3, 0, 3, 4, 1, 3, 4
];
}
}

62
src/Ryujinx.Graphics.Texture/ETC2Decoder.cs
View file

@ -14,41 +14,41 @@ namespace Ryujinx.Graphics.Texture
private const int BlockHeight = 4;
private static readonly int[][] _etc1Lut =
{
new int[] { 2, 8, -2, -8 },
new int[] { 5, 17, -5, -17 },
new int[] { 9, 29, -9, -29 },
new int[] { 13, 42, -13, -42 },
new int[] { 18, 60, -18, -60 },
new int[] { 24, 80, -24, -80 },
new int[] { 33, 106, -33, -106 },
new int[] { 47, 183, -47, -183 },
};
[
[2, 8, -2, -8],
[5, 17, -5, -17],
[9, 29, -9, -29],
[13, 42, -13, -42],
[18, 60, -18, -60],
[24, 80, -24, -80],
[33, 106, -33, -106],
[47, 183, -47, -183]
];
private static readonly int[] _etc2Lut =
{
3, 6, 11, 16, 23, 32, 41, 64,
};
[
3, 6, 11, 16, 23, 32, 41, 64
];
private static readonly int[][] _etc2AlphaLut =
{
new int[] { -3, -6, -9, -15, 2, 5, 8, 14 },
new int[] { -3, -7, -10, -13, 2, 6, 9, 12 },
new int[] { -2, -5, -8, -13, 1, 4, 7, 12 },
new int[] { -2, -4, -6, -13, 1, 3, 5, 12 },
new int[] { -3, -6, -8, -12, 2, 5, 7, 11 },
new int[] { -3, -7, -9, -11, 2, 6, 8, 10 },
new int[] { -4, -7, -8, -11, 3, 6, 7, 10 },
new int[] { -3, -5, -8, -11, 2, 4, 7, 10 },
new int[] { -2, -6, -8, -10, 1, 5, 7, 9 },
new int[] { -2, -5, -8, -10, 1, 4, 7, 9 },
new int[] { -2, -4, -8, -10, 1, 3, 7, 9 },
new int[] { -2, -5, -7, -10, 1, 4, 6, 9 },
new int[] { -3, -4, -7, -10, 2, 3, 6, 9 },
new int[] { -1, -2, -3, -10, 0, 1, 2, 9 },
new int[] { -4, -6, -8, -9, 3, 5, 7, 8 },
new int[] { -3, -5, -7, -9, 2, 4, 6, 8 },
};
[
[-3, -6, -9, -15, 2, 5, 8, 14],
[-3, -7, -10, -13, 2, 6, 9, 12],
[-2, -5, -8, -13, 1, 4, 7, 12],
[-2, -4, -6, -13, 1, 3, 5, 12],
[-3, -6, -8, -12, 2, 5, 7, 11],
[-3, -7, -9, -11, 2, 6, 8, 10],
[-4, -7, -8, -11, 3, 6, 7, 10],
[-3, -5, -8, -11, 2, 4, 7, 10],
[-2, -6, -8, -10, 1, 5, 7, 9],
[-2, -5, -8, -10, 1, 4, 7, 9],
[-2, -4, -8, -10, 1, 3, 7, 9],
[-2, -5, -7, -10, 1, 4, 6, 9],
[-3, -4, -7, -10, 2, 3, 6, 9],
[-1, -2, -3, -10, 0, 1, 2, 9],
[-4, -6, -8, -9, 3, 5, 7, 8],
[-3, -5, -7, -9, 2, 4, 6, 8]
];
public static MemoryOwner<byte> DecodeRgb(ReadOnlySpan<byte> data, int width, int height, int depth, int levels, int layers)
{

8
src/Ryujinx.Graphics.Texture/Encoders/BC7Encoder.cs
View file

@ -57,10 +57,10 @@ namespace Ryujinx.Graphics.Texture.Encoders
}
}
private static readonly int[] _mostFrequentPartitions = new int[]
{
0, 13, 2, 1, 15, 14, 10, 23,
};
private static readonly int[] _mostFrequentPartitions =
[
0, 13, 2, 1, 15, 14, 10, 23
];
private static Block CompressBlock(ReadOnlySpan<byte> data, int x, int y, int width, int height, bool fastMode)
{

8
src/Ryujinx.Graphics.Texture/SizeInfo.cs
View file

@ -19,10 +19,10 @@ namespace Ryujinx.Graphics.Texture
public SizeInfo(int size)
{
_mipOffsets = new int[] { 0 };
AllOffsets = new int[] { 0 };
SliceSizes = new int[] { size };
LevelSizes = new int[] { size };
_mipOffsets = [0];
AllOffsets = [0];
SliceSizes = [size];
LevelSizes = [size];
_depth = 1;
_levels = 1;
LayerSize = size;

484
src/Ryujinx.Graphics.Texture/Utils/BC67Tables.cs
View file

@ -2,8 +2,8 @@ namespace Ryujinx.Graphics.Texture.Utils
{
static class BC67Tables
{
public static readonly BC7ModeInfo[] BC7ModeInfos = new BC7ModeInfo[]
{
public static readonly BC7ModeInfo[] BC7ModeInfos =
[
new(3, 4, 6, 0, 0, 3, 0, 4, 0),
new(2, 6, 2, 0, 0, 3, 0, 6, 0),
new(3, 6, 0, 0, 0, 2, 0, 5, 0),
@ -11,81 +11,57 @@ namespace Ryujinx.Graphics.Texture.Utils
new(1, 0, 0, 2, 1, 2, 3, 5, 6),
new(1, 0, 0, 2, 0, 2, 2, 7, 8),
new(1, 0, 2, 0, 0, 4, 0, 7, 7),
new(2, 6, 4, 0, 0, 2, 0, 5, 5),
};
new(2, 6, 4, 0, 0, 2, 0, 5, 5)
];
public static readonly byte[][] Weights =
{
new byte[] { 0, 21, 43, 64 },
new byte[] { 0, 9, 18, 27, 37, 46, 55, 64 },
new byte[] { 0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64 },
};
[
[0, 21, 43, 64],
[0, 9, 18, 27, 37, 46, 55, 64],
[0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64]
];
public static readonly byte[][] InverseWeights =
{
new byte[] { 64, 43, 21, 0 },
new byte[] { 64, 55, 46, 37, 27, 18, 9, 0 },
new byte[] { 64, 60, 55, 51, 47, 43, 38, 34, 30, 26, 21, 17, 13, 9, 4, 0 },
};
[
[64, 43, 21, 0],
[64, 55, 46, 37, 27, 18, 9, 0],
[64, 60, 55, 51, 47, 43, 38, 34, 30, 26, 21, 17, 13, 9, 4, 0]
];
public static readonly byte[][][] FixUpIndices = new byte[3][][]
{
new byte[64][]
{
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 }, new byte[] { 0, 0, 0 },
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
},
new byte[64][]
{
new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 },
new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 },
new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 },
new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 },
new byte[] { 0, 15, 0 }, new byte[] { 0, 2, 0 }, new byte[] { 0, 8, 0 }, new byte[] { 0, 2, 0 },
new byte[] { 0, 2, 0 }, new byte[] { 0, 8, 0 }, new byte[] { 0, 8, 0 }, new byte[] { 0, 15, 0 },
new byte[] { 0, 2, 0 }, new byte[] { 0, 8, 0 }, new byte[] { 0, 2, 0 }, new byte[] { 0, 2, 0 },
new byte[] { 0, 8, 0 }, new byte[] { 0, 8, 0 }, new byte[] { 0, 2, 0 }, new byte[] { 0, 2, 0 },
new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 6, 0 }, new byte[] { 0, 8, 0 },
new byte[] { 0, 2, 0 }, new byte[] { 0, 8, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 },
new byte[] { 0, 2, 0 }, new byte[] { 0, 8, 0 }, new byte[] { 0, 2, 0 }, new byte[] { 0, 2, 0 },
new byte[] { 0, 2, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 6, 0 },
new byte[] { 0, 6, 0 }, new byte[] { 0, 2, 0 }, new byte[] { 0, 6, 0 }, new byte[] { 0, 8, 0 },
new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 2, 0 }, new byte[] { 0, 2, 0 },
new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 }, new byte[] { 0, 15, 0 },
new byte[] { 0, 15, 0 }, new byte[] { 0, 2, 0 }, new byte[] { 0, 2, 0 }, new byte[] { 0, 15, 0 },
[0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0],
[0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0],
[0, 15, 0], [0, 2, 0], [0, 8, 0], [0, 2, 0], [0, 2, 0], [0, 8, 0], [0, 8, 0], [0, 15, 0],
[0, 2, 0], [0, 8, 0], [0, 2, 0], [0, 2, 0], [0, 8, 0], [0, 8, 0], [0, 2, 0], [0, 2, 0],
[0, 15, 0], [0, 15, 0], [0, 6, 0], [0, 8, 0], [0, 2, 0], [0, 8, 0], [0, 15, 0], [0, 15, 0],
[0, 2, 0], [0, 8, 0], [0, 2, 0], [0, 2, 0], [0, 2, 0], [0, 15, 0], [0, 15, 0], [0, 6, 0],
[0, 6, 0], [0, 2, 0], [0, 6, 0], [0, 8, 0], [0, 15, 0], [0, 15, 0], [0, 2, 0], [0, 2, 0],
[0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 15, 0], [0, 2, 0], [0, 2, 0], [0, 15, 0],
},
new byte[64][]
{
new byte[] { 0, 3, 15 }, new byte[] { 0, 3, 8 }, new byte[] { 0, 15, 8 }, new byte[] { 0, 15, 3 },
new byte[] { 0, 8, 15 }, new byte[] { 0, 3, 15 }, new byte[] { 0, 15, 3 }, new byte[] { 0, 15, 8 },
new byte[] { 0, 8, 15 }, new byte[] { 0, 8, 15 }, new byte[] { 0, 6, 15 }, new byte[] { 0, 6, 15 },
new byte[] { 0, 6, 15 }, new byte[] { 0, 5, 15 }, new byte[] { 0, 3, 15 }, new byte[] { 0, 3, 8 },
new byte[] { 0, 3, 15 }, new byte[] { 0, 3, 8 }, new byte[] { 0, 8, 15 }, new byte[] { 0, 15, 3 },
new byte[] { 0, 3, 15 }, new byte[] { 0, 3, 8 }, new byte[] { 0, 6, 15 }, new byte[] { 0, 10, 8 },
new byte[] { 0, 5, 3 }, new byte[] { 0, 8, 15 }, new byte[] { 0, 8, 6 }, new byte[] { 0, 6, 10 },
new byte[] { 0, 8, 15 }, new byte[] { 0, 5, 15 }, new byte[] { 0, 15, 10 }, new byte[] { 0, 15, 8 },
new byte[] { 0, 8, 15 }, new byte[] { 0, 15, 3 }, new byte[] { 0, 3, 15 }, new byte[] { 0, 5, 10 },
new byte[] { 0, 6, 10 }, new byte[] { 0, 10, 8 }, new byte[] { 0, 8, 9 }, new byte[] { 0, 15, 10 },
new byte[] { 0, 15, 6 }, new byte[] { 0, 3, 15 }, new byte[] { 0, 15, 8 }, new byte[] { 0, 5, 15 },
new byte[] { 0, 15, 3 }, new byte[] { 0, 15, 6 }, new byte[] { 0, 15, 6 }, new byte[] { 0, 15, 8 },
new byte[] { 0, 3, 15 }, new byte[] { 0, 15, 3 }, new byte[] { 0, 5, 15 }, new byte[] { 0, 5, 15 },
new byte[] { 0, 5, 15 }, new byte[] { 0, 8, 15 }, new byte[] { 0, 5, 15 }, new byte[] { 0, 10, 15 },
new byte[] { 0, 5, 15 }, new byte[] { 0, 10, 15 }, new byte[] { 0, 8, 15 }, new byte[] { 0, 13, 15 },
new byte[] { 0, 15, 3 }, new byte[] { 0, 12, 15 }, new byte[] { 0, 3, 15 }, new byte[] { 0, 3, 8 },
[0, 3, 15], [0, 3, 8], [0, 15, 8], [0, 15, 3], [0, 8, 15], [0, 3, 15], [0, 15, 3], [0, 15, 8],
[0, 8, 15], [0, 8, 15], [0, 6, 15], [0, 6, 15], [0, 6, 15], [0, 5, 15], [0, 3, 15], [0, 3, 8],
[0, 3, 15], [0, 3, 8], [0, 8, 15], [0, 15, 3], [0, 3, 15], [0, 3, 8], [0, 6, 15], [0, 10, 8],
[0, 5, 3], [0, 8, 15], [0, 8, 6], [0, 6, 10], [0, 8, 15], [0, 5, 15], [0, 15, 10], [0, 15, 8],
[0, 8, 15], [0, 15, 3], [0, 3, 15], [0, 5, 10], [0, 6, 10], [0, 10, 8], [0, 8, 9], [0, 15, 10],
[0, 15, 6], [0, 3, 15], [0, 15, 8], [0, 5, 15], [0, 15, 3], [0, 15, 6], [0, 15, 6], [0, 15, 8],
[0, 3, 15], [0, 15, 3], [0, 5, 15], [0, 5, 15], [0, 5, 15], [0, 8, 15], [0, 5, 15], [0, 10, 15],
[0, 5, 15], [0, 10, 15], [0, 8, 15], [0, 13, 15], [0, 15, 3], [0, 12, 15], [0, 3, 15], [0, 3, 8],
},
};
@ -93,204 +69,204 @@ namespace Ryujinx.Graphics.Texture.Utils
{
new byte[64][]
{
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 0
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 1
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 2
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 3
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 4
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 5
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 6
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 7
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 8
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 9
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 10
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 11
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 12
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 13
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 14
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 15
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 16
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 17
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 18
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 19
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 20
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 21
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 22
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 23
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 24
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 25
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 26
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 27
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 28
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 29
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 30
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 31
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 32
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 33
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 34
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 35
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 36
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 37
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 38
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 39
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 40
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 41
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 42
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 43
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 44
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 45
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 46
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 47
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 48
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 49
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 50
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 51
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 52
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 53
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 54
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 55
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 56
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 57
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 58
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 59
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 60
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 61
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 62
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 63
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 0
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 1
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 2
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 3
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 4
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 5
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 6
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 7
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 8
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 9
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 11
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 12
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 13
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 14
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 15
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 16
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 17
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 18
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 19
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 20
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 21
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 22
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 23
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 24
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 25
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 26
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 27
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 28
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 29
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 30
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 31
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 32
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 33
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 34
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 35
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 36
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 37
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 38
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 39
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 40
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 41
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 42
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 43
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 44
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 45
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 46
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 47
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 48
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 49
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 50
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 51
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 52
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 53
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 54
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 55
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 56
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 57
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 58
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 59
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 60
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 61
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 62
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // 63
},
new byte[64][]
{
new byte[16] { 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 }, // 0
new byte[16] { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1 }, // 1
new byte[16] { 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 }, // 2
new byte[16] { 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1 }, // 3
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1 }, // 4
new byte[16] { 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 }, // 5
new byte[16] { 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 }, // 6
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1 }, // 7
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1 }, // 8
new byte[16] { 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 9
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1 }, // 10
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1 }, // 11
new byte[16] { 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 12
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1 }, // 13
new byte[16] { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 14
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1 }, // 15
new byte[16] { 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1 }, // 16
new byte[16] { 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, // 17
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0 }, // 18
new byte[16] { 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0 }, // 19
new byte[16] { 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, // 20
new byte[16] { 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0 }, // 21
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0 }, // 22
new byte[16] { 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1 }, // 23
new byte[16] { 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 }, // 24
new byte[16] { 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0 }, // 25
new byte[16] { 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0 }, // 26
new byte[16] { 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0 }, // 27
new byte[16] { 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0 }, // 28
new byte[16] { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 }, // 29
new byte[16] { 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0 }, // 30
new byte[16] { 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0 }, // 31
new byte[16] { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 }, // 32
new byte[16] { 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1 }, // 33
new byte[16] { 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0 }, // 34
new byte[16] { 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0 }, // 35
new byte[16] { 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0 }, // 36
new byte[16] { 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0 }, // 37
new byte[16] { 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1 }, // 38
new byte[16] { 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 }, // 39
new byte[16] { 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0 }, // 40
new byte[16] { 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0 }, // 41
new byte[16] { 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0 }, // 42
new byte[16] { 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0 }, // 43
new byte[16] { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 }, // 44
new byte[16] { 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1 }, // 45
new byte[16] { 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1 }, // 46
new byte[16] { 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0 }, // 47
new byte[16] { 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0 }, // 48
new byte[16] { 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 }, // 49
new byte[16] { 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0 }, // 50
new byte[16] { 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0 }, // 51
new byte[16] { 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1 }, // 52
new byte[16] { 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1 }, // 53
new byte[16] { 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0 }, // 54
new byte[16] { 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0 }, // 55
new byte[16] { 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1 }, // 56
new byte[16] { 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1 }, // 57
new byte[16] { 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1 }, // 58
new byte[16] { 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1 }, // 59
new byte[16] { 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 }, // 60
new byte[16] { 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 }, // 61
new byte[16] { 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0 }, // 62
new byte[16] { 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1 }, // 63
[0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1], // 0
[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1], // 1
[0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1], // 2
[0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1], // 3
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1], // 4
[0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1], // 5
[0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1], // 6
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1], // 7
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1], // 8
[0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], // 9
[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1], // 10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1], // 11
[0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], // 12
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1], // 13
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], // 14
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1], // 15
[0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1], // 16
[0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], // 17
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0], // 18
[0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0], // 19
[0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], // 20
[0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0], // 21
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0], // 22
[0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1], // 23
[0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0], // 24
[0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0], // 25
[0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0], // 26
[0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0], // 27
[0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0], // 28
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0], // 29
[0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0], // 30
[0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0], // 31
[0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], // 32
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1], // 33
[0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0], // 34
[0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0], // 35
[0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0], // 36
[0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0], // 37
[0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1], // 38
[0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1], // 39
[0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0], // 40
[0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0], // 41
[0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0], // 42
[0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0], // 43
[0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0], // 44
[0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1], // 45
[0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1], // 46
[0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0], // 47
[0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0], // 48
[0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0], // 49
[0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0], // 50
[0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0], // 51
[0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1], // 52
[0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1], // 53
[0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0], // 54
[0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0], // 55
[0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1], // 56
[0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1], // 57
[0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1], // 58
[0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1], // 59
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1], // 60
[0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0], // 61
[0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0], // 62
[0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1], // 63
},
new byte[64][]
{
new byte[16] { 0, 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 1, 2, 2, 2, 2 }, // 0
new byte[16] { 0, 0, 0, 1, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1 }, // 1
new byte[16] { 0, 0, 0, 0, 2, 0, 0, 1, 2, 2, 1, 1, 2, 2, 1, 1 }, // 2
new byte[16] { 0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 1, 1, 0, 1, 1, 1 }, // 3
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2 }, // 4
new byte[16] { 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 2, 2 }, // 5
new byte[16] { 0, 0, 2, 2, 0, 0, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1 }, // 6
new byte[16] { 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1 }, // 7
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2 }, // 8
new byte[16] { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2 }, // 9
new byte[16] { 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2 }, // 10
new byte[16] { 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2 }, // 11
new byte[16] { 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2 }, // 12
new byte[16] { 0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2 }, // 13
new byte[16] { 0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 2 }, // 14
new byte[16] { 0, 0, 1, 1, 2, 0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 0 }, // 15
new byte[16] { 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 2, 2 }, // 16
new byte[16] { 0, 1, 1, 1, 0, 0, 1, 1, 2, 0, 0, 1, 2, 2, 0, 0 }, // 17
new byte[16] { 0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2 }, // 18
new byte[16] { 0, 0, 2, 2, 0, 0, 2, 2, 0, 0, 2, 2, 1, 1, 1, 1 }, // 19
new byte[16] { 0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2, 0, 2, 2, 2 }, // 20
new byte[16] { 0, 0, 0, 1, 0, 0, 0, 1, 2, 2, 2, 1, 2, 2, 2, 1 }, // 21
new byte[16] { 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 0, 1, 2, 2 }, // 22
new byte[16] { 0, 0, 0, 0, 1, 1, 0, 0, 2, 2, 1, 0, 2, 2, 1, 0 }, // 23
new byte[16] { 0, 1, 2, 2, 0, 1, 2, 2, 0, 0, 1, 1, 0, 0, 0, 0 }, // 24
new byte[16] { 0, 0, 1, 2, 0, 0, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2 }, // 25
new byte[16] { 0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1, 0, 1, 1, 0 }, // 26
new byte[16] { 0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1 }, // 27
new byte[16] { 0, 0, 2, 2, 1, 1, 0, 2, 1, 1, 0, 2, 0, 0, 2, 2 }, // 28
new byte[16] { 0, 1, 1, 0, 0, 1, 1, 0, 2, 0, 0, 2, 2, 2, 2, 2 }, // 29
new byte[16] { 0, 0, 1, 1, 0, 1, 2, 2, 0, 1, 2, 2, 0, 0, 1, 1 }, // 30
new byte[16] { 0, 0, 0, 0, 2, 0, 0, 0, 2, 2, 1, 1, 2, 2, 2, 1 }, // 31
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 2, 2, 2 }, // 32
new byte[16] { 0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 1, 2, 0, 0, 1, 1 }, // 33
new byte[16] { 0, 0, 1, 1, 0, 0, 1, 2, 0, 0, 2, 2, 0, 2, 2, 2 }, // 34
new byte[16] { 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0 }, // 35
new byte[16] { 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0 }, // 36
new byte[16] { 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0 }, // 37
new byte[16] { 0, 1, 2, 0, 2, 0, 1, 2, 1, 2, 0, 1, 0, 1, 2, 0 }, // 38
new byte[16] { 0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2, 0, 0, 1, 1 }, // 39
new byte[16] { 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0, 1, 1 }, // 40
new byte[16] { 0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2 }, // 41
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 2, 1, 2, 1, 2, 1 }, // 42
new byte[16] { 0, 0, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2, 1, 1, 2, 2 }, // 43
new byte[16] { 0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 1, 1 }, // 44
new byte[16] { 0, 2, 2, 0, 1, 2, 2, 1, 0, 2, 2, 0, 1, 2, 2, 1 }, // 45
new byte[16] { 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 0, 1 }, // 46
new byte[16] { 0, 0, 0, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1 }, // 47
new byte[16] { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2 }, // 48
new byte[16] { 0, 2, 2, 2, 0, 1, 1, 1, 0, 2, 2, 2, 0, 1, 1, 1 }, // 49
new byte[16] { 0, 0, 0, 2, 1, 1, 1, 2, 0, 0, 0, 2, 1, 1, 1, 2 }, // 50
new byte[16] { 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2 }, // 51
new byte[16] { 0, 2, 2, 2, 0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2 }, // 52
new byte[16] { 0, 0, 0, 2, 1, 1, 1, 2, 1, 1, 1, 2, 0, 0, 0, 2 }, // 53
new byte[16] { 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 2, 2 }, // 54
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 1, 2 }, // 55
new byte[16] { 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2 }, // 56
new byte[16] { 0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2 }, // 57
new byte[16] { 0, 0, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2 }, // 58
new byte[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2 }, // 59
new byte[16] { 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1 }, // 60
new byte[16] { 0, 2, 2, 2, 1, 2, 2, 2, 0, 2, 2, 2, 1, 2, 2, 2 }, // 61
new byte[16] { 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }, // 62
new byte[16] { 0, 1, 1, 1, 2, 0, 1, 1, 2, 2, 0, 1, 2, 2, 2, 0 }, // 63
[0, 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 1, 2, 2, 2, 2], // 0
[0, 0, 0, 1, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1], // 1
[0, 0, 0, 0, 2, 0, 0, 1, 2, 2, 1, 1, 2, 2, 1, 1], // 2
[0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 1, 1, 0, 1, 1, 1], // 3
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2], // 4
[0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 2, 2], // 5
[0, 0, 2, 2, 0, 0, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1], // 6
[0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1], // 7
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], // 8
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2], // 9
[0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2], // 10
[0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2], // 11
[0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2], // 12
[0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2], // 13
[0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 2], // 14
[0, 0, 1, 1, 2, 0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 0], // 15
[0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 2, 2], // 16
[0, 1, 1, 1, 0, 0, 1, 1, 2, 0, 0, 1, 2, 2, 0, 0], // 17
[0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2], // 18
[0, 0, 2, 2, 0, 0, 2, 2, 0, 0, 2, 2, 1, 1, 1, 1], // 19
[0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2, 0, 2, 2, 2], // 20
[0, 0, 0, 1, 0, 0, 0, 1, 2, 2, 2, 1, 2, 2, 2, 1], // 21
[0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 0, 1, 2, 2], // 22
[0, 0, 0, 0, 1, 1, 0, 0, 2, 2, 1, 0, 2, 2, 1, 0], // 23
[0, 1, 2, 2, 0, 1, 2, 2, 0, 0, 1, 1, 0, 0, 0, 0], // 24
[0, 0, 1, 2, 0, 0, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2], // 25
[0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1, 0, 1, 1, 0], // 26
[0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1], // 27
[0, 0, 2, 2, 1, 1, 0, 2, 1, 1, 0, 2, 0, 0, 2, 2], // 28
[0, 1, 1, 0, 0, 1, 1, 0, 2, 0, 0, 2, 2, 2, 2, 2], // 29
[0, 0, 1, 1, 0, 1, 2, 2, 0, 1, 2, 2, 0, 0, 1, 1], // 30
[0, 0, 0, 0, 2, 0, 0, 0, 2, 2, 1, 1, 2, 2, 2, 1], // 31
[0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 2, 2, 2], // 32
[0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 1, 2, 0, 0, 1, 1], // 33
[0, 0, 1, 1, 0, 0, 1, 2, 0, 0, 2, 2, 0, 2, 2, 2], // 34
[0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0], // 35
[0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0], // 36
[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0], // 37
[0, 1, 2, 0, 2, 0, 1, 2, 1, 2, 0, 1, 0, 1, 2, 0], // 38
[0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2, 0, 0, 1, 1], // 39
[0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0, 1, 1], // 40
[0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2], // 41
[0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 2, 1, 2, 1, 2, 1], // 42
[0, 0, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2, 1, 1, 2, 2], // 43
[0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 1, 1], // 44
[0, 2, 2, 0, 1, 2, 2, 1, 0, 2, 2, 0, 1, 2, 2, 1], // 45
[0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 0, 1], // 46
[0, 0, 0, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1], // 47
[0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2], // 48
[0, 2, 2, 2, 0, 1, 1, 1, 0, 2, 2, 2, 0, 1, 1, 1], // 49
[0, 0, 0, 2, 1, 1, 1, 2, 0, 0, 0, 2, 1, 1, 1, 2], // 50
[0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2], // 51
[0, 2, 2, 2, 0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2], // 52
[0, 0, 0, 2, 1, 1, 1, 2, 1, 1, 1, 2, 0, 0, 0, 2], // 53
[0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 2, 2], // 54
[0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 1, 2], // 55
[0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2], // 56
[0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2], // 57
[0, 0, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2], // 58
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2], // 59
[0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1], // 60
[0, 2, 2, 2, 1, 2, 2, 2, 0, 2, 2, 2, 1, 2, 2, 2], // 61
[0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], // 62
[0, 1, 1, 1, 2, 0, 1, 1, 2, 2, 0, 1, 2, 2, 2, 0], // 63
},
};
}

2
src/Ryujinx.HLE.Generators/ServiceSyntaxReceiver.cs
View file

@ -6,7 +6,7 @@ namespace Ryujinx.HLE.Generators
{
internal class ServiceSyntaxReceiver : ISyntaxReceiver
{
public HashSet<ClassDeclarationSyntax> Types = new();
public HashSet<ClassDeclarationSyntax> Types = [];
public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
{

18
src/Ryujinx.Tests.Memory/MultiRegionTrackingTests.cs
View file

@ -208,7 +208,7 @@ namespace Ryujinx.Tests.Memory
// Query some large regions to prep the subdivision of the tracking region.
int[] regionSizes = new int[] { 6, 4, 3, 2, 6, 1 };
int[] regionSizes = [6, 4, 3, 2, 6, 1];
ulong address = 0;
for (int i = 0; i < regionSizes.Length; i++)
@ -333,24 +333,24 @@ namespace Ryujinx.Tests.Memory
// Finally, create a granular handle that inherits all these handles.
IEnumerable<IRegionHandle>[] handleGroups = new IEnumerable<IRegionHandle>[]
{
IEnumerable<IRegionHandle>[] handleGroups =
[
granular.GetHandles(),
singlePages,
doublePages,
};
doublePages
];
MultiRegionHandle combined = _tracking.BeginGranularTracking(0, PageSize * 18, handleGroups.SelectMany((handles) => handles), PageSize, 0);
bool[] expectedDirty = new bool[]
{
bool[] expectedDirty =
[
true, true, true, // Gap.
false, true, false, // Multi-region.
true, true, // Gap.
false, true, false, // Individual handles.
false, false, true, true, false, false, // Double size handles.
true, // Gap.
};
true // Gap.
];
for (int i = 0; i < 18; i++)
{

2
src/Ryujinx.Tests.Memory/TrackingTests.cs
View file

@ -214,7 +214,7 @@ namespace Ryujinx.Tests.Memory
handles[i].Reprotect();
}
List<Thread> testThreads = new();
List<Thread> testThreads = [];
// Dirty flag consumer threads
int dirtyFlagReprotects = 0;

14
src/Ryujinx.Tests.Unicorn/UnicornAArch32.cs
View file

@ -122,7 +122,7 @@ namespace Ryujinx.Tests.Unicorn
}
private static readonly int[] _xRegisters =
{
[
Arm.UC_ARM_REG_R0,
Arm.UC_ARM_REG_R1,
Arm.UC_ARM_REG_R2,
@ -138,12 +138,12 @@ namespace Ryujinx.Tests.Unicorn
Arm.UC_ARM_REG_R12,
Arm.UC_ARM_REG_R13,
Arm.UC_ARM_REG_R14,
Arm.UC_ARM_REG_R15,
};
Arm.UC_ARM_REG_R15
];
#pragma warning disable IDE0051, IDE0052 // Remove unused private member
private static readonly int[] _qRegisters =
{
[
Arm.UC_ARM_REG_Q0,
Arm.UC_ARM_REG_Q1,
Arm.UC_ARM_REG_Q2,
@ -159,8 +159,8 @@ namespace Ryujinx.Tests.Unicorn
Arm.UC_ARM_REG_Q12,
Arm.UC_ARM_REG_Q13,
Arm.UC_ARM_REG_Q14,
Arm.UC_ARM_REG_Q15,
};
Arm.UC_ARM_REG_Q15
];
#pragma warning restore IDE0051, IDE0052
public uint GetX(int index)
@ -259,7 +259,7 @@ namespace Ryujinx.Tests.Unicorn
Uc.MemWrite((long)address, value);
}
public void MemoryWrite8(ulong address, byte value) => MemoryWrite(address, new[] { value });
public void MemoryWrite8(ulong address, byte value) => MemoryWrite(address, [value]);
public void MemoryWrite16(ulong address, short value) => MemoryWrite(address, BitConverter.GetBytes(value));
public void MemoryWrite16(ulong address, ushort value) => MemoryWrite(address, BitConverter.GetBytes(value));
public void MemoryWrite32(ulong address, int value) => MemoryWrite(address, BitConverter.GetBytes(value));

14
src/Ryujinx.Tests.Unicorn/UnicornAArch64.cs
View file

@ -111,7 +111,7 @@ namespace Ryujinx.Tests.Unicorn
}
private static readonly int[] _xRegisters =
{
[
Arm64.UC_ARM64_REG_X0,
Arm64.UC_ARM64_REG_X1,
Arm64.UC_ARM64_REG_X2,
@ -142,11 +142,11 @@ namespace Ryujinx.Tests.Unicorn
Arm64.UC_ARM64_REG_X27,
Arm64.UC_ARM64_REG_X28,
Arm64.UC_ARM64_REG_X29,
Arm64.UC_ARM64_REG_X30,
};
Arm64.UC_ARM64_REG_X30
];
private static readonly int[] _qRegisters =
{
[
Arm64.UC_ARM64_REG_Q0,
Arm64.UC_ARM64_REG_Q1,
Arm64.UC_ARM64_REG_Q2,
@ -178,8 +178,8 @@ namespace Ryujinx.Tests.Unicorn
Arm64.UC_ARM64_REG_Q28,
Arm64.UC_ARM64_REG_Q29,
Arm64.UC_ARM64_REG_Q30,
Arm64.UC_ARM64_REG_Q31,
};
Arm64.UC_ARM64_REG_Q31
];
public ulong GetX(int index)
{
@ -272,7 +272,7 @@ namespace Ryujinx.Tests.Unicorn
Uc.MemWrite((long)address, value);
}
public void MemoryWrite8(ulong address, byte value) => MemoryWrite(address, new[] { value });
public void MemoryWrite8(ulong address, byte value) => MemoryWrite(address, [value]);
public void MemoryWrite16(ulong address, short value) => MemoryWrite(address, BitConverter.GetBytes(value));
public void MemoryWrite16(ulong address, ushort value) => MemoryWrite(address, BitConverter.GetBytes(value));
public void MemoryWrite32(ulong address, int value) => MemoryWrite(address, BitConverter.GetBytes(value));

6
src/Ryujinx.Tests/Cpu/Arm64CodeGenCommonTests.cs
View file

@ -15,7 +15,7 @@ namespace Ryujinx.Tests.Cpu
}
public static readonly TestCase[] TestCases =
{
[
new() { Value = 0, Valid = false, ImmN = 0, ImmS = 0, ImmR = 0 },
new() { Value = 0x970977f35f848714, Valid = false, ImmN = 0, ImmS = 0, ImmR = 0 },
new() { Value = 0xffffffffffffffff, Valid = false, ImmN = 0, ImmS = 0, ImmR = 0 },
@ -29,8 +29,8 @@ namespace Ryujinx.Tests.Cpu
new() { Value = 0xc001c001c001c001, Valid = true, ImmN = 0, ImmS = 0x22, ImmR = 2 },
new() { Value = 0x0000038000000380, Valid = true, ImmN = 0, ImmS = 0x02, ImmR = 25 },
new() { Value = 0xffff8fffffff8fff, Valid = true, ImmN = 0, ImmS = 0x1c, ImmR = 17 },
new() { Value = 0x000000000ffff800, Valid = true, ImmN = 1, ImmS = 0x10, ImmR = 53 },
};
new() { Value = 0x000000000ffff800, Valid = true, ImmN = 1, ImmS = 0x10, ImmR = 53 }
];
[Test]
public void BitImmTests([ValueSource(nameof(TestCases))] TestCase test)

48
src/Ryujinx.Tests/Cpu/CpuTestAlu32.cs
View file

@ -12,8 +12,8 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] SuHAddSub8()
{
return new[]
{
return
[
0xe6100f90u, // SADD8 R0, R0, R0
0xe6100ff0u, // SSUB8 R0, R0, R0
0xe6300f90u, // SHADD8 R0, R0, R0
@ -21,58 +21,58 @@ namespace Ryujinx.Tests.Cpu
0xe6500f90u, // UADD8 R0, R0, R0
0xe6500ff0u, // USUB8 R0, R0, R0
0xe6700f90u, // UHADD8 R0, R0, R0
0xe6700ff0u, // UHSUB8 R0, R0, R0
};
0xe6700ff0u // UHSUB8 R0, R0, R0
];
}
private static uint[] UQAddSub16()
{
return new[]
{
return
[
0xe6200f10u, // QADD16 R0, R0, R0
0xe6600f10u, // UQADD16 R0, R0, R0
0xe6600f70u, // UQSUB16 R0, R0, R0
};
0xe6600f70u // UQSUB16 R0, R0, R0
];
}
private static uint[] UQAddSub8()
{
return new[]
{
return
[
0xe6600f90u, // UQADD8 R0, R0, R0
0xe6600ff0u, // UQSUB8 R0, R0, R0
};
0xe6600ff0u // UQSUB8 R0, R0, R0
];
}
private static uint[] SsatUsat()
{
return new[]
{
return
[
0xe6a00010u, // SSAT R0, #1, R0, LSL #0
0xe6a00050u, // SSAT R0, #1, R0, ASR #32
0xe6e00010u, // USAT R0, #0, R0, LSL #0
0xe6e00050u, // USAT R0, #0, R0, ASR #32
};
0xe6e00050u // USAT R0, #0, R0, ASR #32
];
}
private static uint[] Ssat16Usat16()
{
return new[]
{
return
[
0xe6a00f30u, // SSAT16 R0, #1, R0
0xe6e00f30u, // USAT16 R0, #0, R0
};
0xe6e00f30u // USAT16 R0, #0, R0
];
}
private static uint[] LsrLslAsrRor()
{
return new[]
{
return
[
0xe1b00030u, // LSRS R0, R0, R0
0xe1b00010u, // LSLS R0, R0, R0
0xe1b00050u, // ASRS R0, R0, R0
0xe1b00070u, // RORS R0, R0, R0
};
0xe1b00070u // RORS R0, R0, R0
];
}
#endregion

8
src/Ryujinx.Tests/Cpu/CpuTestAluBinary.cs
View file

@ -36,8 +36,8 @@ namespace Ryujinx.Tests.Cpu
// - xor 0
// Only includes non-C variant, as the other can be tested with unicorn.
return new[]
{
return
[
new CrcTest(0x00000000u, 0x00_00_00_00_00_00_00_00u, false, 0x00000000, 0x00000000, 0x00000000, 0x00000000),
new CrcTest(0x00000000u, 0x7f_ff_ff_ff_ff_ff_ff_ffu, false, 0x2d02ef8d, 0xbe2612ff, 0xdebb20e3, 0xa9de8355),
new CrcTest(0x00000000u, 0x80_00_00_00_00_00_00_00u, false, 0x00000000, 0x00000000, 0x00000000, 0xedb88320),
@ -48,8 +48,8 @@ namespace Ryujinx.Tests.Cpu
new CrcTest(0xffffffffu, 0x7f_ff_ff_ff_ff_ff_ff_ffu, false, 0x00ffffff, 0x0000ffff, 0x00000000, 0x3303a3c3),
new CrcTest(0xffffffffu, 0x80_00_00_00_00_00_00_00u, false, 0x2dfd1072, 0xbe26ed00, 0xdebb20e3, 0x7765a3b6),
new CrcTest(0xffffffffu, 0xff_ff_ff_ff_ff_ff_ff_ffu, false, 0x00ffffff, 0x0000ffff, 0x00000000, 0xdebb20e3),
new CrcTest(0xffffffffu, 0xa0_02_f1_ca_52_78_8c_1cu, false, 0x39fc4c3d, 0xbc5f7f56, 0x4ed8e906, 0x12cb419c),
};
new CrcTest(0xffffffffu, 0xa0_02_f1_ca_52_78_8c_1cu, false, 0x39fc4c3d, 0xbc5f7f56, 0x4ed8e906, 0x12cb419c)
];
}
#endregion

8
src/Ryujinx.Tests/Cpu/CpuTestAluBinary32.cs
View file

@ -36,8 +36,8 @@ namespace Ryujinx.Tests.Cpu
// - bytes in order of increasing significance
// - xor 0
return new[]
{
return
[
new CrcTest32(0x00000000u, 0x00_00_00_00u, false, 0x00000000, 0x00000000, 0x00000000),
new CrcTest32(0x00000000u, 0x7f_ff_ff_ffu, false, 0x2d02ef8d, 0xbe2612ff, 0x3303a3c3),
new CrcTest32(0x00000000u, 0x80_00_00_00u, false, 0x00000000, 0x00000000, 0xedb88320),
@ -60,8 +60,8 @@ namespace Ryujinx.Tests.Cpu
new CrcTest32(0xffffffffu, 0x7f_ff_ff_ffu, true, 0x00ffffff, 0x0000ffff, 0x82f63b78),
new CrcTest32(0xffffffffu, 0x80_00_00_00u, true, 0xad82acae, 0x0e9e882d, 0x356e8f40),
new CrcTest32(0xffffffffu, 0xff_ff_ff_ffu, true, 0x00ffffff, 0x0000ffff, 0x00000000),
new CrcTest32(0xffffffffu, 0x9d_cb_12_f0u, true, 0x5eecc3db, 0xbb6111cb, 0xcfb54fc9),
};
new CrcTest32(0xffffffffu, 0x9d_cb_12_f0u, true, 0x5eecc3db, 0xbb6111cb, 0xcfb54fc9)
];
}
#endregion

8
src/Ryujinx.Tests/Cpu/CpuTestAluImm32.cs
View file

@ -12,8 +12,8 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] Opcodes()
{
return new[]
{
return
[
0xe2a00000u, // ADC R0, R0, #0
0xe2b00000u, // ADCS R0, R0, #0
0xe2800000u, // ADD R0, R0, #0
@ -27,8 +27,8 @@ namespace Ryujinx.Tests.Cpu
0xe2c00000u, // SBC R0, R0, #0
0xe2d00000u, // SBCS R0, R0, #0
0xe2400000u, // SUB R0, R0, #0
0xe2500000u, // SUBS R0, R0, #0
};
0xe2500000u // SUBS R0, R0, #0
];
}
#endregion

16
src/Ryujinx.Tests/Cpu/CpuTestAluRs32.cs
View file

@ -12,26 +12,26 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _Add_Adds_Rsb_Rsbs_()
{
return new[]
{
return
[
0xe0800000u, // ADD R0, R0, R0, LSL #0
0xe0900000u, // ADDS R0, R0, R0, LSL #0
0xe0600000u, // RSB R0, R0, R0, LSL #0
0xe0700000u, // RSBS R0, R0, R0, LSL #0
};
0xe0700000u // RSBS R0, R0, R0, LSL #0
];
}
private static uint[] _Adc_Adcs_Rsc_Rscs_Sbc_Sbcs_()
{
return new[]
{
return
[
0xe0a00000u, // ADC R0, R0, R0
0xe0b00000u, // ADCS R0, R0, R0
0xe0e00000u, // RSC R0, R0, R0
0xe0f00000u, // RSCS R0, R0, R0
0xe0c00000u, // SBC R0, R0, R0
0xe0d00000u, // SBCS R0, R0, R0
};
0xe0d00000u // SBCS R0, R0, R0
];
}
#endregion

32
src/Ryujinx.Tests/Cpu/CpuTestMul32.cs
View file

@ -12,42 +12,42 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _Smlabb_Smlabt_Smlatb_Smlatt_()
{
return new[]
{
return
[
0xe1000080u, // SMLABB R0, R0, R0, R0
0xe10000C0u, // SMLABT R0, R0, R0, R0
0xe10000A0u, // SMLATB R0, R0, R0, R0
0xe10000E0u, // SMLATT R0, R0, R0, R0
};
0xe10000E0u // SMLATT R0, R0, R0, R0
];
}
private static uint[] _Smlawb_Smlawt_()
{
return new[]
{
return
[
0xe1200080u, // SMLAWB R0, R0, R0, R0
0xe12000C0u, // SMLAWT R0, R0, R0, R0
};
0xe12000C0u // SMLAWT R0, R0, R0, R0
];
}
private static uint[] _Smulbb_Smulbt_Smultb_Smultt_()
{
return new[]
{
return
[
0xe1600080u, // SMULBB R0, R0, R0
0xe16000C0u, // SMULBT R0, R0, R0
0xe16000A0u, // SMULTB R0, R0, R0
0xe16000E0u, // SMULTT R0, R0, R0
};
0xe16000E0u // SMULTT R0, R0, R0
];
}
private static uint[] _Smulwb_Smulwt_()
{
return new[]
{
return
[
0xe12000a0u, // SMULWB R0, R0, R0
0xe12000e0u, // SMULWT R0, R0, R0
};
0xe12000e0u // SMULWT R0, R0, R0
];
}
#endregion

547
src/Ryujinx.Tests/Cpu/CpuTestSimd.cs
View file

@ -101,122 +101,135 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Types)"
private static ulong[] _1B1H1S1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x000000000000007Ful,
0x0000000000000080ul, 0x00000000000000FFul,
0x0000000000007FFFul, 0x0000000000008000ul,
0x000000000000FFFFul, 0x000000007FFFFFFFul,
0x0000000080000000ul, 0x00000000FFFFFFFFul,
0x7FFFFFFFFFFFFFFFul, 0x8000000000000000ul,
0xFFFFFFFFFFFFFFFFul,
};
0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _1H1S1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x0000000000007FFFul,
0x0000000000008000ul, 0x000000000000FFFFul,
0x000000007FFFFFFFul, 0x0000000080000000ul,
0x00000000FFFFFFFFul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _1S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x000000007FFFFFFFul,
0x0000000080000000ul, 0x00000000FFFFFFFFul,
};
0x0000000080000000ul, 0x00000000FFFFFFFFul
];
}
private static ulong[] _2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _4H_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _4H2S1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B4H_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B4H2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B4H2S1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static uint[] _W_()
{
return new[] {
return
[
0x00000000u, 0x7FFFFFFFu,
0x80000000u, 0xFFFFFFFFu,
};
0x80000000u, 0xFFFFFFFFu
];
}
private static ulong[] _X_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static IEnumerable<ulong> _1H_F_()
@ -694,558 +707,558 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _SU_Add_Max_Min_V_V_8BB_4HH_()
{
return new[]
{
return
[
0x0E31B800u, // ADDV B0, V0.8B
0x0E30A800u, // SMAXV B0, V0.8B
0x0E31A800u, // SMINV B0, V0.8B
0x2E30A800u, // UMAXV B0, V0.8B
0x2E31A800u, // UMINV B0, V0.8B
};
0x2E31A800u // UMINV B0, V0.8B
];
}
private static uint[] _SU_Add_Max_Min_V_V_16BB_8HH_4SS_()
{
return new[]
{
return
[
0x4E31B800u, // ADDV B0, V0.16B
0x4E30A800u, // SMAXV B0, V0.16B
0x4E31A800u, // SMINV B0, V0.16B
0x6E30A800u, // UMAXV B0, V0.16B
0x6E31A800u, // UMINV B0, V0.16B
};
0x6E31A800u // UMINV B0, V0.16B
];
}
private static uint[] _F_Abs_Neg_Recpx_Sqrt_S_S_()
{
return new[]
{
return
[
0x1E20C020u, // FABS S0, S1
0x1E214020u, // FNEG S0, S1
0x5EA1F820u, // FRECPX S0, S1
0x1E21C020u, // FSQRT S0, S1
};
0x1E21C020u // FSQRT S0, S1
];
}
private static uint[] _F_Abs_Neg_Recpx_Sqrt_S_D_()
{
return new[]
{
return
[
0x1E60C020u, // FABS D0, D1
0x1E614020u, // FNEG D0, D1
0x5EE1F820u, // FRECPX D0, D1
0x1E61C020u, // FSQRT D0, D1
};
0x1E61C020u // FSQRT D0, D1
];
}
private static uint[] _F_Abs_Neg_Sqrt_V_2S_4S_()
{
return new[]
{
return
[
0x0EA0F800u, // FABS V0.2S, V0.2S
0x2EA0F800u, // FNEG V0.2S, V0.2S
0x2EA1F800u, // FSQRT V0.2S, V0.2S
};
0x2EA1F800u // FSQRT V0.2S, V0.2S
];
}
private static uint[] _F_Abs_Neg_Sqrt_V_2D_()
{
return new[]
{
return
[
0x4EE0F800u, // FABS V0.2D, V0.2D
0x6EE0F800u, // FNEG V0.2D, V0.2D
0x6EE1F800u, // FSQRT V0.2D, V0.2D
};
0x6EE1F800u // FSQRT V0.2D, V0.2D
];
}
private static uint[] _F_Add_Max_Min_Nm_P_S_2SS_()
{
return new[]
{
return
[
0x7E30D820u, // FADDP S0, V1.2S
0x7E30C820u, // FMAXNMP S0, V1.2S
0x7E30F820u, // FMAXP S0, V1.2S
0x7EB0C820u, // FMINNMP S0, V1.2S
0x7EB0F820u, // FMINP S0, V1.2S
};
0x7EB0F820u // FMINP S0, V1.2S
];
}
private static uint[] _F_Add_Max_Min_Nm_P_S_2DD_()
{
return new[]
{
return
[
0x7E70D820u, // FADDP D0, V1.2D
0x7E70C820u, // FMAXNMP D0, V1.2D
0x7E70F820u, // FMAXP D0, V1.2D
0x7EF0C820u, // FMINNMP D0, V1.2D
0x7EF0F820u, // FMINP D0, V1.2D
};
0x7EF0F820u // FMINP D0, V1.2D
];
}
private static uint[] _F_Cm_EqGeGtLeLt_S_S_()
{
return new[]
{
return
[
0x5EA0D820u, // FCMEQ S0, S1, #0.0
0x7EA0C820u, // FCMGE S0, S1, #0.0
0x5EA0C820u, // FCMGT S0, S1, #0.0
0x7EA0D820u, // FCMLE S0, S1, #0.0
0x5EA0E820u, // FCMLT S0, S1, #0.0
};
0x5EA0E820u // FCMLT S0, S1, #0.0
];
}
private static uint[] _F_Cm_EqGeGtLeLt_S_D_()
{
return new[]
{
return
[
0x5EE0D820u, // FCMEQ D0, D1, #0.0
0x7EE0C820u, // FCMGE D0, D1, #0.0
0x5EE0C820u, // FCMGT D0, D1, #0.0
0x7EE0D820u, // FCMLE D0, D1, #0.0
0x5EE0E820u, // FCMLT D0, D1, #0.0
};
0x5EE0E820u // FCMLT D0, D1, #0.0
];
}
private static uint[] _F_Cm_EqGeGtLeLt_V_2S_4S_()
{
return new[]
{
return
[
0x0EA0D800u, // FCMEQ V0.2S, V0.2S, #0.0
0x2EA0C800u, // FCMGE V0.2S, V0.2S, #0.0
0x0EA0C800u, // FCMGT V0.2S, V0.2S, #0.0
0x2EA0D800u, // FCMLE V0.2S, V0.2S, #0.0
0x0EA0E800u, // FCMLT V0.2S, V0.2S, #0.0
};
0x0EA0E800u // FCMLT V0.2S, V0.2S, #0.0
];
}
private static uint[] _F_Cm_EqGeGtLeLt_V_2D_()
{
return new[]
{
return
[
0x4EE0D800u, // FCMEQ V0.2D, V0.2D, #0.0
0x6EE0C800u, // FCMGE V0.2D, V0.2D, #0.0
0x4EE0C800u, // FCMGT V0.2D, V0.2D, #0.0
0x6EE0D800u, // FCMLE V0.2D, V0.2D, #0.0
0x4EE0E800u, // FCMLT V0.2D, V0.2D, #0.0
};
0x4EE0E800u // FCMLT V0.2D, V0.2D, #0.0
];
}
private static uint[] _F_Cmp_Cmpe_S_S_()
{
return new[]
{
return
[
0x1E202028u, // FCMP S1, #0.0
0x1E202038u, // FCMPE S1, #0.0
};
0x1E202038u // FCMPE S1, #0.0
];
}
private static uint[] _F_Cmp_Cmpe_S_D_()
{
return new[]
{
return
[
0x1E602028u, // FCMP D1, #0.0
0x1E602038u, // FCMPE D1, #0.0
};
0x1E602038u // FCMPE D1, #0.0
];
}
private static uint[] _F_Cvt_S_SD_()
{
return new[]
{
0x1E22C020u, // FCVT D0, S1
};
return
[
0x1E22C020u // FCVT D0, S1
];
}
private static uint[] _F_Cvt_S_DS_()
{
return new[]
{
0x1E624020u, // FCVT S0, D1
};
return
[
0x1E624020u // FCVT S0, D1
];
}
private static uint[] _F_Cvt_S_SH_()
{
return new[]
{
0x1E23C020u, // FCVT H0, S1
};
return
[
0x1E23C020u // FCVT H0, S1
];
}
private static uint[] _F_Cvt_S_DH_()
{
return new[]
{
0x1E63C020u, // FCVT H0, D1
};
return
[
0x1E63C020u // FCVT H0, D1
];
}
private static uint[] _F_Cvt_S_HS_()
{
return new[]
{
0x1EE24020u, // FCVT S0, H1
};
return
[
0x1EE24020u // FCVT S0, H1
];
}
private static uint[] _F_Cvt_S_HD_()
{
return new[]
{
0x1EE2C020u, // FCVT D0, H1
};
return
[
0x1EE2C020u // FCVT D0, H1
];
}
private static uint[] _F_Cvt_ANZ_SU_S_S_()
{
return new[]
{
return
[
0x5E21C820u, // FCVTAS S0, S1
0x7E21C820u, // FCVTAU S0, S1
0x5E21A820u, // FCVTNS S0, S1
0x7E21A820u, // FCVTNU S0, S1
0x5EA1B820u, // FCVTZS S0, S1
0x7EA1B820u, // FCVTZU S0, S1
};
0x7EA1B820u // FCVTZU S0, S1
];
}
private static uint[] _F_Cvt_ANZ_SU_S_D_()
{
return new[]
{
return
[
0x5E61C820u, // FCVTAS D0, D1
0x7E61C820u, // FCVTAU D0, D1
0x5E61A820u, // FCVTNS D0, D1
0x7E61A820u, // FCVTNU D0, D1
0x5EE1B820u, // FCVTZS D0, D1
0x7EE1B820u, // FCVTZU D0, D1
};
0x7EE1B820u // FCVTZU D0, D1
];
}
private static uint[] _F_Cvt_ANZ_SU_V_2S_4S_()
{
return new[]
{
return
[
0x0E21C800u, // FCVTAS V0.2S, V0.2S
0x2E21C800u, // FCVTAU V0.2S, V0.2S
0x0E21B800u, // FCVTMS V0.2S, V0.2S
0x0E21A800u, // FCVTNS V0.2S, V0.2S
0x2E21A800u, // FCVTNU V0.2S, V0.2S
0x0EA1B800u, // FCVTZS V0.2S, V0.2S
0x2EA1B800u, // FCVTZU V0.2S, V0.2S
};
0x2EA1B800u // FCVTZU V0.2S, V0.2S
];
}
private static uint[] _F_Cvt_ANZ_SU_V_2D_()
{
return new[]
{
return
[
0x4E61C800u, // FCVTAS V0.2D, V0.2D
0x6E61C800u, // FCVTAU V0.2D, V0.2D
0x4E61B800u, // FCVTMS V0.2D, V0.2D
0x4E61A800u, // FCVTNS V0.2D, V0.2D
0x6E61A800u, // FCVTNU V0.2D, V0.2D
0x4EE1B800u, // FCVTZS V0.2D, V0.2D
0x6EE1B800u, // FCVTZU V0.2D, V0.2D
};
0x6EE1B800u // FCVTZU V0.2D, V0.2D
];
}
private static uint[] _F_Cvtl_V_4H4S_8H4S_()
{
return new[]
{
0x0E217800u, // FCVTL V0.4S, V0.4H
};
return
[
0x0E217800u // FCVTL V0.4S, V0.4H
];
}
private static uint[] _F_Cvtl_V_2S2D_4S2D_()
{
return new[]
{
0x0E617800u, // FCVTL V0.2D, V0.2S
};
return
[
0x0E617800u // FCVTL V0.2D, V0.2S
];
}
private static uint[] _F_Cvtn_V_4S4H_4S8H_()
{
return new[]
{
0x0E216800u, // FCVTN V0.4H, V0.4S
};
return
[
0x0E216800u // FCVTN V0.4H, V0.4S
];
}
private static uint[] _F_Cvtn_V_2D2S_2D4S_()
{
return new[]
{
0x0E616800u, // FCVTN V0.2S, V0.2D
};
return
[
0x0E616800u // FCVTN V0.2S, V0.2D
];
}
private static uint[] _F_Max_Min_Nm_V_V_4SS_()
{
return new[]
{
return
[
0x6E30C800u, // FMAXNMV S0, V0.4S
0x6E30F800u, // FMAXV S0, V0.4S
0x6EB0C800u, // FMINNMV S0, V0.4S
0x6EB0F800u, // FMINV S0, V0.4S
};
0x6EB0F800u // FMINV S0, V0.4S
];
}
private static uint[] _F_Mov_Ftoi_SW_()
{
return new[]
{
0x1E260000u, // FMOV W0, S0
};
return
[
0x1E260000u // FMOV W0, S0
];
}
private static uint[] _F_Mov_Ftoi_DX_()
{
return new[]
{
0x9E660000u, // FMOV X0, D0
};
return
[
0x9E660000u // FMOV X0, D0
];
}
private static uint[] _F_Mov_Ftoi1_DX_()
{
return new[]
{
0x9EAE0000u, // FMOV X0, V0.D[1]
};
return
[
0x9EAE0000u // FMOV X0, V0.D[1]
];
}
private static uint[] _F_Mov_Itof_WS_()
{
return new[]
{
0x1E270000u, // FMOV S0, W0
};
return
[
0x1E270000u // FMOV S0, W0
];
}
private static uint[] _F_Mov_Itof_XD_()
{
return new[]
{
0x9E670000u, // FMOV D0, X0
};
return
[
0x9E670000u // FMOV D0, X0
];
}
private static uint[] _F_Mov_Itof1_XD_()
{
return new[]
{
0x9EAF0000u, // FMOV V0.D[1], X0
};
return
[
0x9EAF0000u // FMOV V0.D[1], X0
];
}
private static uint[] _F_Mov_S_S_()
{
return new[]
{
0x1E204020u, // FMOV S0, S1
};
return
[
0x1E204020u // FMOV S0, S1
];
}
private static uint[] _F_Mov_S_D_()
{
return new[]
{
0x1E604020u, // FMOV D0, D1
};
return
[
0x1E604020u // FMOV D0, D1
];
}
private static uint[] _F_Recpe_Rsqrte_S_S_()
{
return new[]
{
return
[
0x5EA1D820u, // FRECPE S0, S1
0x7EA1D820u, // FRSQRTE S0, S1
};
0x7EA1D820u // FRSQRTE S0, S1
];
}
private static uint[] _F_Recpe_Rsqrte_S_D_()
{
return new[]
{
return
[
0x5EE1D820u, // FRECPE D0, D1
0x7EE1D820u, // FRSQRTE D0, D1
};
0x7EE1D820u // FRSQRTE D0, D1
];
}
private static uint[] _F_Recpe_Rsqrte_V_2S_4S_()
{
return new[]
{
return
[
0x0EA1D800u, // FRECPE V0.2S, V0.2S
0x2EA1D800u, // FRSQRTE V0.2S, V0.2S
};
0x2EA1D800u // FRSQRTE V0.2S, V0.2S
];
}
private static uint[] _F_Recpe_Rsqrte_V_2D_()
{
return new[]
{
return
[
0x4EE1D800u, // FRECPE V0.2D, V0.2D
0x6EE1D800u, // FRSQRTE V0.2D, V0.2D
};
0x6EE1D800u // FRSQRTE V0.2D, V0.2D
];
}
private static uint[] _F_Rint_AMNPZ_S_S_()
{
return new[]
{
return
[
0x1E264020u, // FRINTA S0, S1
0x1E254020u, // FRINTM S0, S1
0x1E244020u, // FRINTN S0, S1
0x1E24C020u, // FRINTP S0, S1
0x1E25C020u, // FRINTZ S0, S1
};
0x1E25C020u // FRINTZ S0, S1
];
}
private static uint[] _F_Rint_AMNPZ_S_D_()
{
return new[]
{
return
[
0x1E664020u, // FRINTA D0, D1
0x1E654020u, // FRINTM D0, D1
0x1E644020u, // FRINTN D0, D1
0x1E64C020u, // FRINTP D0, D1
0x1E65C020u, // FRINTZ D0, D1
};
0x1E65C020u // FRINTZ D0, D1
];
}
private static uint[] _F_Rint_AMNPZ_V_2S_4S_()
{
return new[]
{
return
[
0x2E218800u, // FRINTA V0.2S, V0.2S
0x0E219800u, // FRINTM V0.2S, V0.2S
0x0E218800u, // FRINTN V0.2S, V0.2S
0x0EA18800u, // FRINTP V0.2S, V0.2S
0x0EA19800u, // FRINTZ V0.2S, V0.2S
};
0x0EA19800u // FRINTZ V0.2S, V0.2S
];
}
private static uint[] _F_Rint_AMNPZ_V_2D_()
{
return new[]
{
return
[
0x6E618800u, // FRINTA V0.2D, V0.2D
0x4E619800u, // FRINTM V0.2D, V0.2D
0x4E618800u, // FRINTN V0.2D, V0.2D
0x4EE18800u, // FRINTP V0.2D, V0.2D
0x4EE19800u, // FRINTZ V0.2D, V0.2D
};
0x4EE19800u // FRINTZ V0.2D, V0.2D
];
}
private static uint[] _F_Rint_IX_S_S_()
{
return new[]
{
return
[
0x1E27C020u, // FRINTI S0, S1
0x1E274020u, // FRINTX S0, S1
};
0x1E274020u // FRINTX S0, S1
];
}
private static uint[] _F_Rint_IX_S_D_()
{
return new[]
{
return
[
0x1E67C020u, // FRINTI D0, D1
0x1E674020u, // FRINTX D0, D1
};
0x1E674020u // FRINTX D0, D1
];
}
private static uint[] _F_Rint_IX_V_2S_4S_()
{
return new[]
{
return
[
0x2EA19800u, // FRINTI V0.2S, V0.2S
0x2E219800u, // FRINTX V0.2S, V0.2S
};
0x2E219800u // FRINTX V0.2S, V0.2S
];
}
private static uint[] _F_Rint_IX_V_2D_()
{
return new[]
{
return
[
0x6EE19800u, // FRINTI V0.2D, V0.2D
0x6E619800u, // FRINTX V0.2D, V0.2D
};
0x6E619800u // FRINTX V0.2D, V0.2D
];
}
private static uint[] _SU_Addl_V_V_8BH_4HS_()
{
return new[]
{
return
[
0x0E303800u, // SADDLV H0, V0.8B
0x2E303800u, // UADDLV H0, V0.8B
};
0x2E303800u // UADDLV H0, V0.8B
];
}
private static uint[] _SU_Addl_V_V_16BH_8HS_4SD_()
{
return new[]
{
return
[
0x4E303800u, // SADDLV H0, V0.16B
0x6E303800u, // UADDLV H0, V0.16B
};
0x6E303800u // UADDLV H0, V0.16B
];
}
private static uint[] _SU_Cvt_F_S_S_()
{
return new[]
{
return
[
0x5E21D820u, // SCVTF S0, S1
0x7E21D820u, // UCVTF S0, S1
};
0x7E21D820u // UCVTF S0, S1
];
}
private static uint[] _SU_Cvt_F_S_D_()
{
return new[]
{
return
[
0x5E61D820u, // SCVTF D0, D1
0x7E61D820u, // UCVTF D0, D1
};
0x7E61D820u // UCVTF D0, D1
];
}
private static uint[] _SU_Cvt_F_V_2S_4S_()
{
return new[]
{
return
[
0x0E21D800u, // SCVTF V0.2S, V0.2S
0x2E21D800u, // UCVTF V0.2S, V0.2S
};
0x2E21D800u // UCVTF V0.2S, V0.2S
];
}
private static uint[] _SU_Cvt_F_V_2D_()
{
return new[]
{
return
[
0x4E61D800u, // SCVTF V0.2D, V0.2D
0x6E61D800u, // UCVTF V0.2D, V0.2D
};
0x6E61D800u // UCVTF V0.2D, V0.2D
];
}
private static uint[] _Sha1h_Sha1su1_V_()
{
return new[]
{
return
[
0x5E280800u, // SHA1H S0, S0
0x5E281800u, // SHA1SU1 V0.4S, V0.4S
};
0x5E281800u // SHA1SU1 V0.4S, V0.4S
];
}
private static uint[] _Sha256su0_V_()
{
return new[]
{
0x5E282800u, // SHA256SU0 V0.4S, V0.4S
};
return
[
0x5E282800u // SHA256SU0 V0.4S, V0.4S
];
}
#endregion

23
src/Ryujinx.Tests/Cpu/CpuTestSimd32.cs
View file

@ -14,33 +14,34 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _Vabs_Vneg_Vpaddl_I_()
{
return new[]
{
return
[
0xf3b10300u, // VABS.S8 D0, D0
0xf3b10380u, // VNEG.S8 D0, D0
0xf3b00200u, // VPADDL.S8 D0, D0
};
0xf3b00200u // VPADDL.S8 D0, D0
];
}
private static uint[] _Vabs_Vneg_F_()
{
return new[]
{
return
[
0xf3b90700u, // VABS.F32 D0, D0
0xf3b90780u, // VNEG.F32 D0, D0
};
0xf3b90780u // VNEG.F32 D0, D0
];
}
#endregion
#region "ValueSource (Types)"
private static ulong[] _8B4H2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static IEnumerable<ulong> _1S_F_()

142
src/Ryujinx.Tests/Cpu/CpuTestSimdCvt.cs
View file

@ -15,18 +15,20 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Types)"
private static uint[] _W_()
{
return new[] {
return
[
0x00000000u, 0x7FFFFFFFu,
0x80000000u, 0xFFFFFFFFu,
};
0x80000000u, 0xFFFFFFFFu
];
}
private static ulong[] _X_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static IEnumerable<ulong> _1S_F_WX_()
@ -197,8 +199,8 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _F_Cvt_AMPZ_SU_Gp_SW_()
{
return new[]
{
return
[
0x1E240000u, // FCVTAS W0, S0
0x1E250000u, // FCVTAU W0, S0
0x1E300000u, // FCVTMS W0, S0
@ -207,14 +209,14 @@ namespace Ryujinx.Tests.Cpu
0x1E280000u, // FCVTPS W0, S0
0x1E290000u, // FCVTPU W0, S0
0x1E380000u, // FCVTZS W0, S0
0x1E390000u, // FCVTZU W0, S0
};
0x1E390000u // FCVTZU W0, S0
];
}
private static uint[] _F_Cvt_AMPZ_SU_Gp_SX_()
{
return new[]
{
return
[
0x9E240000u, // FCVTAS X0, S0
0x9E250000u, // FCVTAU X0, S0
0x9E300000u, // FCVTMS X0, S0
@ -223,14 +225,14 @@ namespace Ryujinx.Tests.Cpu
0x9E280000u, // FCVTPS X0, S0
0x9E290000u, // FCVTPU X0, S0
0x9E380000u, // FCVTZS X0, S0
0x9E390000u, // FCVTZU X0, S0
};
0x9E390000u // FCVTZU X0, S0
];
}
private static uint[] _F_Cvt_AMPZ_SU_Gp_DW_()
{
return new[]
{
return
[
0x1E640000u, // FCVTAS W0, D0
0x1E650000u, // FCVTAU W0, D0
0x1E700000u, // FCVTMS W0, D0
@ -239,14 +241,14 @@ namespace Ryujinx.Tests.Cpu
0x1E680000u, // FCVTPS W0, D0
0x1E690000u, // FCVTPU W0, D0
0x1E780000u, // FCVTZS W0, D0
0x1E790000u, // FCVTZU W0, D0
};
0x1E790000u // FCVTZU W0, D0
];
}
private static uint[] _F_Cvt_AMPZ_SU_Gp_DX_()
{
return new[]
{
return
[
0x9E640000u, // FCVTAS X0, D0
0x9E650000u, // FCVTAU X0, D0
0x9E700000u, // FCVTMS X0, D0
@ -255,116 +257,116 @@ namespace Ryujinx.Tests.Cpu
0x9E680000u, // FCVTPS X0, D0
0x9E690000u, // FCVTPU X0, D0
0x9E780000u, // FCVTZS X0, D0
0x9E790000u, // FCVTZU X0, D0
};
0x9E790000u // FCVTZU X0, D0
];
}
private static uint[] _F_Cvt_Z_SU_Gp_Fixed_SW_()
{
return new[]
{
return
[
0x1E188000u, // FCVTZS W0, S0, #32
0x1E198000u, // FCVTZU W0, S0, #32
};
0x1E198000u // FCVTZU W0, S0, #32
];
}
private static uint[] _F_Cvt_Z_SU_Gp_Fixed_SX_()
{
return new[]
{
return
[
0x9E180000u, // FCVTZS X0, S0, #64
0x9E190000u, // FCVTZU X0, S0, #64
};
0x9E190000u // FCVTZU X0, S0, #64
];
}
private static uint[] _F_Cvt_Z_SU_Gp_Fixed_DW_()
{
return new[]
{
return
[
0x1E588000u, // FCVTZS W0, D0, #32
0x1E598000u, // FCVTZU W0, D0, #32
};
0x1E598000u // FCVTZU W0, D0, #32
];
}
private static uint[] _F_Cvt_Z_SU_Gp_Fixed_DX_()
{
return new[]
{
return
[
0x9E580000u, // FCVTZS X0, D0, #64
0x9E590000u, // FCVTZU X0, D0, #64
};
0x9E590000u // FCVTZU X0, D0, #64
];
}
private static uint[] _SU_Cvt_F_Gp_WS_()
{
return new[]
{
return
[
0x1E220000u, // SCVTF S0, W0
0x1E230000u, // UCVTF S0, W0
};
0x1E230000u // UCVTF S0, W0
];
}
private static uint[] _SU_Cvt_F_Gp_WD_()
{
return new[]
{
return
[
0x1E620000u, // SCVTF D0, W0
0x1E630000u, // UCVTF D0, W0
};
0x1E630000u // UCVTF D0, W0
];
}
private static uint[] _SU_Cvt_F_Gp_XS_()
{
return new[]
{
return
[
0x9E220000u, // SCVTF S0, X0
0x9E230000u, // UCVTF S0, X0
};
0x9E230000u // UCVTF S0, X0
];
}
private static uint[] _SU_Cvt_F_Gp_XD_()
{
return new[]
{
return
[
0x9E620000u, // SCVTF D0, X0
0x9E630000u, // UCVTF D0, X0
};
0x9E630000u // UCVTF D0, X0
];
}
private static uint[] _SU_Cvt_F_Gp_Fixed_WS_()
{
return new[]
{
return
[
0x1E028000u, // SCVTF S0, W0, #32
0x1E038000u, // UCVTF S0, W0, #32
};
0x1E038000u // UCVTF S0, W0, #32
];
}
private static uint[] _SU_Cvt_F_Gp_Fixed_WD_()
{
return new[]
{
return
[
0x1E428000u, // SCVTF D0, W0, #32
0x1E438000u, // UCVTF D0, W0, #32
};
0x1E438000u // UCVTF D0, W0, #32
];
}
private static uint[] _SU_Cvt_F_Gp_Fixed_XS_()
{
return new[]
{
return
[
0x9E020000u, // SCVTF S0, X0, #64
0x9E030000u, // UCVTF S0, X0, #64
};
0x9E030000u // UCVTF S0, X0, #64
];
}
private static uint[] _SU_Cvt_F_Gp_Fixed_XD_()
{
return new[]
{
return
[
0x9E420000u, // SCVTF D0, X0, #64
0x9E430000u, // UCVTF D0, X0, #64
};
0x9E430000u // UCVTF D0, X0, #64
];
}
#endregion

15
src/Ryujinx.Tests/Cpu/CpuTestSimdCvt32.cs
View file

@ -15,23 +15,24 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _Vrint_AMNP_V_F32_()
{
return new[]
{
return
[
0xf3ba0500u, // VRINTA.F32 Q0, Q0
0xf3ba0680u, // VRINTM.F32 Q0, Q0
0xf3ba0400u, // VRINTN.F32 Q0, Q0
0xf3ba0780u, // VRINTP.F32 Q0, Q0
};
0xf3ba0780u // VRINTP.F32 Q0, Q0
];
}
#endregion
#region "ValueSource (Types)"
private static uint[] _1S_()
{
return new[] {
return
[
0x00000000u, 0x7FFFFFFFu,
0x80000000u, 0xFFFFFFFFu,
};
0x80000000u, 0xFFFFFFFFu
];
}
private static IEnumerable<ulong> _1S_F_()

7
src/Ryujinx.Tests/Cpu/CpuTestSimdExt.cs
View file

@ -13,10 +13,11 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource"
private static ulong[] _8B_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul
];
}
#endregion

32
src/Ryujinx.Tests/Cpu/CpuTestSimdFcond.cs
View file

@ -99,36 +99,36 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _F_Ccmp_Ccmpe_S_S_()
{
return new[]
{
return
[
0x1E220420u, // FCCMP S1, S2, #0, EQ
0x1E220430u, // FCCMPE S1, S2, #0, EQ
};
0x1E220430u // FCCMPE S1, S2, #0, EQ
];
}
private static uint[] _F_Ccmp_Ccmpe_S_D_()
{
return new[]
{
return
[
0x1E620420u, // FCCMP D1, D2, #0, EQ
0x1E620430u, // FCCMPE D1, D2, #0, EQ
};
0x1E620430u // FCCMPE D1, D2, #0, EQ
];
}
private static uint[] _F_Csel_S_S_()
{
return new[]
{
0x1E220C20u, // FCSEL S0, S1, S2, EQ
};
return
[
0x1E220C20u // FCSEL S0, S1, S2, EQ
];
}
private static uint[] _F_Csel_S_D_()
{
return new[]
{
0x1E620C20u, // FCSEL D0, D1, D2, EQ
};
return
[
0x1E620C20u // FCSEL D0, D1, D2, EQ
];
}
#endregion

16
src/Ryujinx.Tests/Cpu/CpuTestSimdFmov.cs
View file

@ -13,18 +13,18 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource"
private static uint[] _F_Mov_Si_S_()
{
return new[]
{
0x1E201000u, // FMOV S0, #2.0
};
return
[
0x1E201000u // FMOV S0, #2.0
];
}
private static uint[] _F_Mov_Si_D_()
{
return new[]
{
0x1E601000u, // FMOV D0, #2.0
};
return
[
0x1E601000u // FMOV D0, #2.0
];
}
#endregion

102
src/Ryujinx.Tests/Cpu/CpuTestSimdImm.cs
View file

@ -48,18 +48,20 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Types)"
private static ulong[] _2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _4H_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static IEnumerable<byte> _8BIT_IMM_()
@ -96,95 +98,95 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _Bic_Orr_Vi_16bit_()
{
return new[]
{
return
[
0x2F009400u, // BIC V0.4H, #0
0x0F009400u, // ORR V0.4H, #0
};
0x0F009400u // ORR V0.4H, #0
];
}
private static uint[] _Bic_Orr_Vi_32bit_()
{
return new[]
{
return
[
0x2F001400u, // BIC V0.2S, #0
0x0F001400u, // ORR V0.2S, #0
};
0x0F001400u // ORR V0.2S, #0
];
}
private static uint[] _F_Mov_Vi_2S_()
{
return new[]
{
0x0F00F400u, // FMOV V0.2S, #2.0
};
return
[
0x0F00F400u // FMOV V0.2S, #2.0
];
}
private static uint[] _F_Mov_Vi_4S_()
{
return new[]
{
0x4F00F400u, // FMOV V0.4S, #2.0
};
return
[
0x4F00F400u // FMOV V0.4S, #2.0
];
}
private static uint[] _F_Mov_Vi_2D_()
{
return new[]
{
0x6F00F400u, // FMOV V0.2D, #2.0
};
return
[
0x6F00F400u // FMOV V0.2D, #2.0
];
}
private static uint[] _Movi_V_8bit_()
{
return new[]
{
0x0F00E400u, // MOVI V0.8B, #0
};
return
[
0x0F00E400u // MOVI V0.8B, #0
];
}
private static uint[] _Movi_Mvni_V_16bit_shifted_imm_()
{
return new[]
{
return
[
0x0F008400u, // MOVI V0.4H, #0
0x2F008400u, // MVNI V0.4H, #0
};
0x2F008400u // MVNI V0.4H, #0
];
}
private static uint[] _Movi_Mvni_V_32bit_shifted_imm_()
{
return new[]
{
return
[
0x0F000400u, // MOVI V0.2S, #0
0x2F000400u, // MVNI V0.2S, #0
};
0x2F000400u // MVNI V0.2S, #0
];
}
private static uint[] _Movi_Mvni_V_32bit_shifting_ones_()
{
return new[]
{
return
[
0x0F00C400u, // MOVI V0.2S, #0, MSL #8
0x2F00C400u, // MVNI V0.2S, #0, MSL #8
};
0x2F00C400u // MVNI V0.2S, #0, MSL #8
];
}
private static uint[] _Movi_V_64bit_scalar_()
{
return new[]
{
0x2F00E400u, // MOVI D0, #0
};
return
[
0x2F00E400u // MOVI D0, #0
];
}
private static uint[] _Movi_V_64bit_vector_()
{
return new[]
{
0x6F00E400u, // MOVI V0.2D, #0
};
return
[
0x6F00E400u // MOVI V0.2D, #0
];
}
#endregion

56
src/Ryujinx.Tests/Cpu/CpuTestSimdIns.cs
View file

@ -13,72 +13,80 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource"
private static ulong[] _1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _4H_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B4H_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B4H2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static uint[] _W_()
{
return new[] {
return
[
0x00000000u, 0x0000007Fu,
0x00000080u, 0x000000FFu,
0x00007FFFu, 0x00008000u,
0x0000FFFFu, 0x7FFFFFFFu,
0x80000000u, 0xFFFFFFFFu,
};
0x80000000u, 0xFFFFFFFFu
];
}
private static ulong[] _X_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
#endregion

23
src/Ryujinx.Tests/Cpu/CpuTestSimdLogical32.cs
View file

@ -13,20 +13,21 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Types)"
private static ulong[] _8B4H2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
#endregion
#region "ValueSource (Opcodes)"
private static uint[] _Vbic_Vbif_Vbit_Vbsl_Vand_Vorn_Vorr_Veor_I_()
{
return new[]
{
return
[
0xf2100110u, // VBIC D0, D0, D0
0xf3300110u, // VBIF D0, D0, D0
0xf3200110u, // VBIT D0, D0, D0
@ -34,19 +35,19 @@ namespace Ryujinx.Tests.Cpu
0xf2000110u, // VAND D0, D0, D0
0xf2300110u, // VORN D0, D0, D0
0xf2200110u, // VORR D0, D0, D0
0xf3000110u, // VEOR D0, D0, D0
};
0xf3000110u // VEOR D0, D0, D0
];
}
private static uint[] _Vbic_Vorr_II_()
{
return new[]
{
return
[
0xf2800130u, // VBIC.I32 D0, #0 (A1)
0xf2800930u, // VBIC.I16 D0, #0 (A2)
0xf2800110u, // VORR.I32 D0, #0 (A1)
0xf2800910u, // VORR.I16 D0, #0 (A2)
};
0xf2800910u // VORR.I16 D0, #0 (A2)
];
}
#endregion

12
src/Ryujinx.Tests/Cpu/CpuTestSimdMemory32.cs
View file

@ -14,7 +14,7 @@ namespace Ryujinx.Tests.Cpu
#if SimdMemory32
private readonly uint[] _ldStModes =
{
[
// LD1
0b0111,
0b1010,
@ -32,8 +32,8 @@ namespace Ryujinx.Tests.Cpu
// LD4
0b0000,
0b0001,
};
0b0001
];
[Test, Pairwise, Description("VLDn.<size> <list>, [<Rn> {:<align>}]{ /!/, <Rm>} (single n element structure)")]
public void Vldn_Single([Values(0u, 1u, 2u)] uint size,
@ -200,12 +200,12 @@ namespace Ryujinx.Tests.Cpu
uint opcode = 0xec100a00u; // VST4.8 {D0, D1, D2, D3}, [R0], R0
uint[] vldmModes =
{
[
// Note: 3rd 0 leaves a space for "D".
0b0100, // Increment after.
0b0101, // Increment after. (!)
0b1001, // Decrement before. (!)
};
0b1001 // Decrement before. (!)
];
opcode |= ((vldmModes[mode] & 15) << 21);
opcode |= ((rn & 15) << 16);

12
src/Ryujinx.Tests/Cpu/CpuTestSimdMov32.cs
View file

@ -19,7 +19,7 @@ namespace Ryujinx.Tests.Cpu
[Values] bool q)
{
uint[] variants =
{
[
// I32
0b0000_0,
0b0010_0,
@ -36,8 +36,8 @@ namespace Ryujinx.Tests.Cpu
0b1110_0,
0b1111_0,
0b1110_1,
};
0b1110_1
];
uint opcode = 0xf2800010u; // VMOV.I32 D0, #0
@ -300,7 +300,7 @@ namespace Ryujinx.Tests.Cpu
[Values] bool q)
{
uint[] variants =
{
[
// I32
0b0000,
0b0010,
@ -313,8 +313,8 @@ namespace Ryujinx.Tests.Cpu
// I32
0b1100,
0b1101,
};
0b1101
];
uint opcode = 0xf2800030u; // VMVN.I32 D0, #0

319
src/Ryujinx.Tests/Cpu/CpuTestSimdReg.cs
View file

@ -14,90 +14,99 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Types)"
private static ulong[] _1B1H1S1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x000000000000007Ful,
0x0000000000000080ul, 0x00000000000000FFul,
0x0000000000007FFFul, 0x0000000000008000ul,
0x000000000000FFFFul, 0x000000007FFFFFFFul,
0x0000000080000000ul, 0x00000000FFFFFFFFul,
0x7FFFFFFFFFFFFFFFul, 0x8000000000000000ul,
0xFFFFFFFFFFFFFFFFul,
};
0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _1H1S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x0000000000007FFFul,
0x0000000000008000ul, 0x000000000000FFFFul,
0x000000007FFFFFFFul, 0x0000000080000000ul,
0x00000000FFFFFFFFul,
};
0x00000000FFFFFFFFul
];
}
private static ulong[] _4H2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _4H2S1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B4H2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B4H2S1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static IEnumerable<ulong> _1S_F_()
@ -228,174 +237,174 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _F_Abd_Add_Div_Mul_Mulx_Nmul_Sub_S_S_()
{
return new[]
{
return
[
0x7EA2D420u, // FABD S0, S1, S2
0x1E222820u, // FADD S0, S1, S2
0x1E221820u, // FDIV S0, S1, S2
0x1E220820u, // FMUL S0, S1, S2
0x5E22DC20u, // FMULX S0, S1, S2
0x1E228820u, // FNMUL S0, S1, S2
0x1E223820u, // FSUB S0, S1, S2
};
0x1E223820u // FSUB S0, S1, S2
];
}
private static uint[] _F_Abd_Add_Div_Mul_Mulx_Nmul_Sub_S_D_()
{
return new[]
{
return
[
0x7EE2D420u, // FABD D0, D1, D2
0x1E622820u, // FADD D0, D1, D2
0x1E621820u, // FDIV D0, D1, D2
0x1E620820u, // FMUL D0, D1, D2
0x5E62DC20u, // FMULX D0, D1, D2
0x1E628820u, // FNMUL D0, D1, D2
0x1E623820u, // FSUB D0, D1, D2
};
0x1E623820u // FSUB D0, D1, D2
];
}
private static uint[] _F_Abd_Add_Div_Mul_Mulx_Sub_P_V_2S_4S_()
{
return new[]
{
return
[
0x2EA0D400u, // FABD V0.2S, V0.2S, V0.2S
0x0E20D400u, // FADD V0.2S, V0.2S, V0.2S
0x2E20D400u, // FADDP V0.2S, V0.2S, V0.2S
0x2E20FC00u, // FDIV V0.2S, V0.2S, V0.2S
0x2E20DC00u, // FMUL V0.2S, V0.2S, V0.2S
0x0E20DC00u, // FMULX V0.2S, V0.2S, V0.2S
0x0EA0D400u, // FSUB V0.2S, V0.2S, V0.2S
};
0x0EA0D400u // FSUB V0.2S, V0.2S, V0.2S
];
}
private static uint[] _F_Abd_Add_Div_Mul_Mulx_Sub_P_V_2D_()
{
return new[]
{
return
[
0x6EE0D400u, // FABD V0.2D, V0.2D, V0.2D
0x4E60D400u, // FADD V0.2D, V0.2D, V0.2D
0x6E60D400u, // FADDP V0.2D, V0.2D, V0.2D
0x6E60FC00u, // FDIV V0.2D, V0.2D, V0.2D
0x6E60DC00u, // FMUL V0.2D, V0.2D, V0.2D
0x4E60DC00u, // FMULX V0.2D, V0.2D, V0.2D
0x4EE0D400u, // FSUB V0.2D, V0.2D, V0.2D
};
0x4EE0D400u // FSUB V0.2D, V0.2D, V0.2D
];
}
private static uint[] _F_AcCm_EqGeGt_S_S_()
{
return new[]
{
return
[
0x7E22EC20u, // FACGE S0, S1, S2
0x7EA2EC20u, // FACGT S0, S1, S2
0x5E22E420u, // FCMEQ S0, S1, S2
0x7E22E420u, // FCMGE S0, S1, S2
0x7EA2E420u, // FCMGT S0, S1, S2
};
0x7EA2E420u // FCMGT S0, S1, S2
];
}
private static uint[] _F_AcCm_EqGeGt_S_D_()
{
return new[]
{
return
[
0x7E62EC20u, // FACGE D0, D1, D2
0x7EE2EC20u, // FACGT D0, D1, D2
0x5E62E420u, // FCMEQ D0, D1, D2
0x7E62E420u, // FCMGE D0, D1, D2
0x7EE2E420u, // FCMGT D0, D1, D2
};
0x7EE2E420u // FCMGT D0, D1, D2
];
}
private static uint[] _F_AcCm_EqGeGt_V_2S_4S_()
{
return new[]
{
return
[
0x2E20EC00u, // FACGE V0.2S, V0.2S, V0.2S
0x2EA0EC00u, // FACGT V0.2S, V0.2S, V0.2S
0x0E20E400u, // FCMEQ V0.2S, V0.2S, V0.2S
0x2E20E400u, // FCMGE V0.2S, V0.2S, V0.2S
0x2EA0E400u, // FCMGT V0.2S, V0.2S, V0.2S
};
0x2EA0E400u // FCMGT V0.2S, V0.2S, V0.2S
];
}
private static uint[] _F_AcCm_EqGeGt_V_2D_()
{
return new[]
{
return
[
0x6E60EC00u, // FACGE V0.2D, V0.2D, V0.2D
0x6EE0EC00u, // FACGT V0.2D, V0.2D, V0.2D
0x4E60E400u, // FCMEQ V0.2D, V0.2D, V0.2D
0x6E60E400u, // FCMGE V0.2D, V0.2D, V0.2D
0x6EE0E400u, // FCMGT V0.2D, V0.2D, V0.2D
};
0x6EE0E400u // FCMGT V0.2D, V0.2D, V0.2D
];
}
private static uint[] _F_Cmp_Cmpe_S_S_()
{
return new[]
{
return
[
0x1E222020u, // FCMP S1, S2
0x1E222030u, // FCMPE S1, S2
};
0x1E222030u // FCMPE S1, S2
];
}
private static uint[] _F_Cmp_Cmpe_S_D_()
{
return new[]
{
return
[
0x1E622020u, // FCMP D1, D2
0x1E622030u, // FCMPE D1, D2
};
0x1E622030u // FCMPE D1, D2
];
}
private static uint[] _F_Madd_Msub_Nmadd_Nmsub_S_S_()
{
return new[]
{
return
[
0x1F020C20u, // FMADD S0, S1, S2, S3
0x1F028C20u, // FMSUB S0, S1, S2, S3
0x1F220C20u, // FNMADD S0, S1, S2, S3
0x1F228C20u, // FNMSUB S0, S1, S2, S3
};
0x1F228C20u // FNMSUB S0, S1, S2, S3
];
}
private static uint[] _F_Madd_Msub_Nmadd_Nmsub_S_D_()
{
return new[]
{
return
[
0x1F420C20u, // FMADD D0, D1, D2, D3
0x1F428C20u, // FMSUB D0, D1, D2, D3
0x1F620C20u, // FNMADD D0, D1, D2, D3
0x1F628C20u, // FNMSUB D0, D1, D2, D3
};
0x1F628C20u // FNMSUB D0, D1, D2, D3
];
}
private static uint[] _F_Max_Min_Nm_S_S_()
{
return new[]
{
return
[
0x1E224820u, // FMAX S0, S1, S2
0x1E226820u, // FMAXNM S0, S1, S2
0x1E225820u, // FMIN S0, S1, S2
0x1E227820u, // FMINNM S0, S1, S2
};
0x1E227820u // FMINNM S0, S1, S2
];
}
private static uint[] _F_Max_Min_Nm_S_D_()
{
return new[]
{
return
[
0x1E624820u, // FMAX D0, D1, D2
0x1E626820u, // FMAXNM D0, D1, D2
0x1E625820u, // FMIN D0, D1, D2
0x1E627820u, // FMINNM D0, D1, D2
};
0x1E627820u // FMINNM D0, D1, D2
];
}
private static uint[] _F_Max_Min_Nm_P_V_2S_4S_()
{
return new[]
{
return
[
0x0E20F400u, // FMAX V0.2S, V0.2S, V0.2S
0x0E20C400u, // FMAXNM V0.2S, V0.2S, V0.2S
0x2E20C400u, // FMAXNMP V0.2S, V0.2S, V0.2S
@ -403,14 +412,14 @@ namespace Ryujinx.Tests.Cpu
0x0EA0F400u, // FMIN V0.2S, V0.2S, V0.2S
0x0EA0C400u, // FMINNM V0.2S, V0.2S, V0.2S
0x2EA0C400u, // FMINNMP V0.2S, V0.2S, V0.2S
0x2EA0F400u, // FMINP V0.2S, V0.2S, V0.2S
};
0x2EA0F400u // FMINP V0.2S, V0.2S, V0.2S
];
}
private static uint[] _F_Max_Min_Nm_P_V_2D_()
{
return new[]
{
return
[
0x4E60F400u, // FMAX V0.2D, V0.2D, V0.2D
0x4E60C400u, // FMAXNM V0.2D, V0.2D, V0.2D
0x6E60C400u, // FMAXNMP V0.2D, V0.2D, V0.2D
@ -418,109 +427,109 @@ namespace Ryujinx.Tests.Cpu
0x4EE0F400u, // FMIN V0.2D, V0.2D, V0.2D
0x4EE0C400u, // FMINNM V0.2D, V0.2D, V0.2D
0x6EE0C400u, // FMINNMP V0.2D, V0.2D, V0.2D
0x6EE0F400u, // FMINP V0.2D, V0.2D, V0.2D
};
0x6EE0F400u // FMINP V0.2D, V0.2D, V0.2D
];
}
private static uint[] _F_Mla_Mls_V_2S_4S_()
{
return new[]
{
return
[
0x0E20CC00u, // FMLA V0.2S, V0.2S, V0.2S
0x0EA0CC00u, // FMLS V0.2S, V0.2S, V0.2S
};
0x0EA0CC00u // FMLS V0.2S, V0.2S, V0.2S
];
}
private static uint[] _F_Mla_Mls_V_2D_()
{
return new[]
{
return
[
0x4E60CC00u, // FMLA V0.2D, V0.2D, V0.2D
0x4EE0CC00u, // FMLS V0.2D, V0.2D, V0.2D
};
0x4EE0CC00u // FMLS V0.2D, V0.2D, V0.2D
];
}
private static uint[] _F_Recps_Rsqrts_S_S_()
{
return new[]
{
return
[
0x5E22FC20u, // FRECPS S0, S1, S2
0x5EA2FC20u, // FRSQRTS S0, S1, S2
};
0x5EA2FC20u // FRSQRTS S0, S1, S2
];
}
private static uint[] _F_Recps_Rsqrts_S_D_()
{
return new[]
{
return
[
0x5E62FC20u, // FRECPS D0, D1, D2
0x5EE2FC20u, // FRSQRTS D0, D1, D2
};
0x5EE2FC20u // FRSQRTS D0, D1, D2
];
}
private static uint[] _F_Recps_Rsqrts_V_2S_4S_()
{
return new[]
{
return
[
0x0E20FC00u, // FRECPS V0.2S, V0.2S, V0.2S
0x0EA0FC00u, // FRSQRTS V0.2S, V0.2S, V0.2S
};
0x0EA0FC00u // FRSQRTS V0.2S, V0.2S, V0.2S
];
}
private static uint[] _F_Recps_Rsqrts_V_2D_()
{
return new[]
{
return
[
0x4E60FC00u, // FRECPS V0.2D, V0.2D, V0.2D
0x4EE0FC00u, // FRSQRTS V0.2D, V0.2D, V0.2D
};
0x4EE0FC00u // FRSQRTS V0.2D, V0.2D, V0.2D
];
}
private static uint[] _Mla_Mls_Mul_V_8B_4H_2S_()
{
return new[]
{
return
[
0x0E209400u, // MLA V0.8B, V0.8B, V0.8B
0x2E209400u, // MLS V0.8B, V0.8B, V0.8B
0x0E209C00u, // MUL V0.8B, V0.8B, V0.8B
};
0x0E209C00u // MUL V0.8B, V0.8B, V0.8B
];
}
private static uint[] _Mla_Mls_Mul_V_16B_8H_4S_()
{
return new[]
{
return
[
0x4E209400u, // MLA V0.16B, V0.16B, V0.16B
0x6E209400u, // MLS V0.16B, V0.16B, V0.16B
0x4E209C00u, // MUL V0.16B, V0.16B, V0.16B
};
0x4E209C00u // MUL V0.16B, V0.16B, V0.16B
];
}
private static uint[] _Sha1c_Sha1m_Sha1p_Sha1su0_V_()
{
return new[]
{
return
[
0x5E000000u, // SHA1C Q0, S0, V0.4S
0x5E002000u, // SHA1M Q0, S0, V0.4S
0x5E001000u, // SHA1P Q0, S0, V0.4S
0x5E003000u, // SHA1SU0 V0.4S, V0.4S, V0.4S
};
0x5E003000u // SHA1SU0 V0.4S, V0.4S, V0.4S
];
}
private static uint[] _Sha256h_Sha256h2_Sha256su1_V_()
{
return new[]
{
return
[
0x5E004000u, // SHA256H Q0, Q0, V0.4S
0x5E005000u, // SHA256H2 Q0, Q0, V0.4S
0x5E006000u, // SHA256SU1 V0.4S, V0.4S, V0.4S
};
0x5E006000u // SHA256SU1 V0.4S, V0.4S, V0.4S
];
}
private static uint[] _SU_Max_Min_P_V_()
{
return new[]
{
return
[
0x0E206400u, // SMAX V0.8B, V0.8B, V0.8B
0x0E20A400u, // SMAXP V0.8B, V0.8B, V0.8B
0x0E206C00u, // SMIN V0.8B, V0.8B, V0.8B
@ -528,49 +537,49 @@ namespace Ryujinx.Tests.Cpu
0x2E206400u, // UMAX V0.8B, V0.8B, V0.8B
0x2E20A400u, // UMAXP V0.8B, V0.8B, V0.8B
0x2E206C00u, // UMIN V0.8B, V0.8B, V0.8B
0x2E20AC00u, // UMINP V0.8B, V0.8B, V0.8B
};
0x2E20AC00u // UMINP V0.8B, V0.8B, V0.8B
];
}
private static uint[] _SU_Mlal_Mlsl_Mull_V_8B8H_4H4S_2S2D_()
{
return new[]
{
return
[
0x0E208000u, // SMLAL V0.8H, V0.8B, V0.8B
0x0E20A000u, // SMLSL V0.8H, V0.8B, V0.8B
0x0E20C000u, // SMULL V0.8H, V0.8B, V0.8B
0x2E208000u, // UMLAL V0.8H, V0.8B, V0.8B
0x2E20A000u, // UMLSL V0.8H, V0.8B, V0.8B
0x2E20C000u, // UMULL V0.8H, V0.8B, V0.8B
};
0x2E20C000u // UMULL V0.8H, V0.8B, V0.8B
];
}
private static uint[] _SU_Mlal_Mlsl_Mull_V_16B8H_8H4S_4S2D_()
{
return new[]
{
return
[
0x4E208000u, // SMLAL2 V0.8H, V0.16B, V0.16B
0x4E20A000u, // SMLSL2 V0.8H, V0.16B, V0.16B
0x4E20C000u, // SMULL2 V0.8H, V0.16B, V0.16B
0x6E208000u, // UMLAL2 V0.8H, V0.16B, V0.16B
0x6E20A000u, // UMLSL2 V0.8H, V0.16B, V0.16B
0x6E20C000u, // UMULL2 V0.8H, V0.16B, V0.16B
};
0x6E20C000u // UMULL2 V0.8H, V0.16B, V0.16B
];
}
private static uint[] _ShlReg_S_D_()
{
return new[]
{
return
[
0x5EE04400u, // SSHL D0, D0, D0
0x7EE04400u, // USHL D0, D0, D0
};
0x7EE04400u // USHL D0, D0, D0
];
}
private static uint[] _ShlReg_V_8B_4H_2S_()
{
return new[]
{
return
[
0x0E205C00u, // SQRSHL V0.8B, V0.8B, V0.8B
0x0E204C00u, // SQSHL V0.8B, V0.8B, V0.8B
0x0E205400u, // SRSHL V0.8B, V0.8B, V0.8B
@ -578,14 +587,14 @@ namespace Ryujinx.Tests.Cpu
0x2E205C00u, // UQRSHL V0.8B, V0.8B, V0.8B
0x2E204C00u, // UQSHL V0.8B, V0.8B, V0.8B
0x2E205400u, // URSHL V0.8B, V0.8B, V0.8B
0x2E204400u, // USHL V0.8B, V0.8B, V0.8B
};
0x2E204400u // USHL V0.8B, V0.8B, V0.8B
];
}
private static uint[] _ShlReg_V_16B_8H_4S_2D_()
{
return new[]
{
return
[
0x4E205C00u, // SQRSHL V0.16B, V0.16B, V0.16B
0x4E204C00u, // SQSHL V0.16B, V0.16B, V0.16B
0x4E205400u, // SRSHL V0.16B, V0.16B, V0.16B
@ -593,8 +602,8 @@ namespace Ryujinx.Tests.Cpu
0x6E205C00u, // UQRSHL V0.16B, V0.16B, V0.16B
0x6E204C00u, // UQSHL V0.16B, V0.16B, V0.16B
0x6E205400u, // URSHL V0.16B, V0.16B, V0.16B
0x6E204400u, // USHL V0.16B, V0.16B, V0.16B
};
0x6E204400u // USHL V0.16B, V0.16B, V0.16B
];
}
#endregion

102
src/Ryujinx.Tests/Cpu/CpuTestSimdReg32.cs
View file

@ -15,134 +15,136 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _V_Add_Sub_Long_Wide_I_()
{
return new[]
{
return
[
0xf2800000u, // VADDL.S8 Q0, D0, D0
0xf2800100u, // VADDW.S8 Q0, Q0, D0
0xf2800200u, // VSUBL.S8 Q0, D0, D0
0xf2800300u, // VSUBW.S8 Q0, Q0, D0
};
0xf2800300u // VSUBW.S8 Q0, Q0, D0
];
}
private static uint[] _Vfma_Vfms_Vfnma_Vfnms_S_F32_()
{
return new[]
{
return
[
0xEEA00A00u, // VFMA. F32 S0, S0, S0
0xEEA00A40u, // VFMS. F32 S0, S0, S0
0xEE900A40u, // VFNMA.F32 S0, S0, S0
0xEE900A00u, // VFNMS.F32 S0, S0, S0
};
0xEE900A00u // VFNMS.F32 S0, S0, S0
];
}
private static uint[] _Vfma_Vfms_Vfnma_Vfnms_S_F64_()
{
return new[]
{
return
[
0xEEA00B00u, // VFMA. F64 D0, D0, D0
0xEEA00B40u, // VFMS. F64 D0, D0, D0
0xEE900B40u, // VFNMA.F64 D0, D0, D0
0xEE900B00u, // VFNMS.F64 D0, D0, D0
};
0xEE900B00u // VFNMS.F64 D0, D0, D0
];
}
private static uint[] _Vfma_Vfms_V_F32_()
{
return new[]
{
return
[
0xF2000C10u, // VFMA.F32 D0, D0, D0
0xF2200C10u, // VFMS.F32 D0, D0, D0
};
0xF2200C10u // VFMS.F32 D0, D0, D0
];
}
private static uint[] _Vmla_Vmls_Vnmla_Vnmls_S_F32_()
{
return new[]
{
return
[
0xEE000A00u, // VMLA. F32 S0, S0, S0
0xEE000A40u, // VMLS. F32 S0, S0, S0
0xEE100A40u, // VNMLA.F32 S0, S0, S0
0xEE100A00u, // VNMLS.F32 S0, S0, S0
};
0xEE100A00u // VNMLS.F32 S0, S0, S0
];
}
private static uint[] _Vmla_Vmls_Vnmla_Vnmls_S_F64_()
{
return new[]
{
return
[
0xEE000B00u, // VMLA. F64 D0, D0, D0
0xEE000B40u, // VMLS. F64 D0, D0, D0
0xEE100B40u, // VNMLA.F64 D0, D0, D0
0xEE100B00u, // VNMLS.F64 D0, D0, D0
};
0xEE100B00u // VNMLS.F64 D0, D0, D0
];
}
private static uint[] _Vmlal_Vmlsl_V_I_()
{
return new[]
{
return
[
0xf2800800u, // VMLAL.S8 Q0, D0, D0
0xf2800a00u, // VMLSL.S8 Q0, D0, D0
};
0xf2800a00u // VMLSL.S8 Q0, D0, D0
];
}
private static uint[] _Vp_Add_Max_Min_F_()
{
return new[]
{
return
[
0xf3000d00u, // VPADD.F32 D0, D0, D0
0xf3000f00u, // VPMAX.F32 D0, D0, D0
0xf3200f00u, // VPMIN.F32 D0, D0, D0
};
0xf3200f00u // VPMIN.F32 D0, D0, D0
];
}
private static uint[] _Vp_Add_I_()
{
return new[]
{
0xf2000b10u, // VPADD.I8 D0, D0, D0
};
return
[
0xf2000b10u // VPADD.I8 D0, D0, D0
];
}
private static uint[] _V_Pmax_Pmin_Rhadd_I_()
{
return new[]
{
return
[
0xf2000a00u, // VPMAX .S8 D0, D0, D0
0xf2000a10u, // VPMIN .S8 D0, D0, D0
0xf2000100u, // VRHADD.S8 D0, D0, D0
};
0xf2000100u // VRHADD.S8 D0, D0, D0
];
}
private static uint[] _Vq_Add_Sub_I_()
{
return new[]
{
return
[
0xf2000050u, // VQADD.S8 Q0, Q0, Q0
0xf2000250u, // VQSUB.S8 Q0, Q0, Q0
};
0xf2000250u // VQSUB.S8 Q0, Q0, Q0
];
}
#endregion
#region "ValueSource (Types)"
private static ulong[] _8B1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B4H2S1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static IEnumerable<ulong> _1S_F_()

46
src/Ryujinx.Tests/Cpu/CpuTestSimdRegElem.cs
View file

@ -13,70 +13,72 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Types)"
private static ulong[] _2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _4H_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul
];
}
#endregion
#region "ValueSource (Opcodes)"
private static uint[] _Mla_Mls_Mul_Sqdmulh_Sqrdmulh_Ve_4H_8H_()
{
return new[]
{
return
[
0x2F400000u, // MLA V0.4H, V0.4H, V0.H[0]
0x2F404000u, // MLS V0.4H, V0.4H, V0.H[0]
0x0F408000u, // MUL V0.4H, V0.4H, V0.H[0]
0x0F40C000u, // SQDMULH V0.4H, V0.4H, V0.H[0]
0x0F40D000u, // SQRDMULH V0.4H, V0.4H, V0.H[0]
};
0x0F40D000u // SQRDMULH V0.4H, V0.4H, V0.H[0]
];
}
private static uint[] _Mla_Mls_Mul_Sqdmulh_Sqrdmulh_Ve_2S_4S_()
{
return new[]
{
return
[
0x2F800000u, // MLA V0.2S, V0.2S, V0.S[0]
0x2F804000u, // MLS V0.2S, V0.2S, V0.S[0]
0x0F808000u, // MUL V0.2S, V0.2S, V0.S[0]
0x0F80C000u, // SQDMULH V0.2S, V0.2S, V0.S[0]
0x0F80D000u, // SQRDMULH V0.2S, V0.2S, V0.S[0]
};
0x0F80D000u // SQRDMULH V0.2S, V0.2S, V0.S[0]
];
}
private static uint[] _SU_Mlal_Mlsl_Mull_Ve_4H4S_8H4S_()
{
return new[]
{
return
[
0x0F402000u, // SMLAL V0.4S, V0.4H, V0.H[0]
0x0F406000u, // SMLSL V0.4S, V0.4H, V0.H[0]
0x0F40A000u, // SMULL V0.4S, V0.4H, V0.H[0]
0x2F402000u, // UMLAL V0.4S, V0.4H, V0.H[0]
0x2F406000u, // UMLSL V0.4S, V0.4H, V0.H[0]
0x2F40A000u, // UMULL V0.4S, V0.4H, V0.H[0]
};
0x2F40A000u // UMULL V0.4S, V0.4H, V0.H[0]
];
}
private static uint[] _SU_Mlal_Mlsl_Mull_Ve_2S2D_4S2D_()
{
return new[]
{
return
[
0x0F802000u, // SMLAL V0.2D, V0.2S, V0.S[0]
0x0F806000u, // SMLSL V0.2D, V0.2S, V0.S[0]
0x0F80A000u, // SMULL V0.2D, V0.2S, V0.S[0]
0x2F802000u, // UMLAL V0.2D, V0.2S, V0.S[0]
0x2F806000u, // UMLSL V0.2D, V0.2S, V0.S[0]
0x2F80A000u, // UMULL V0.2D, V0.2S, V0.S[0]
};
0x2F80A000u // UMULL V0.2D, V0.2S, V0.S[0]
];
}
#endregion

64
src/Ryujinx.Tests/Cpu/CpuTestSimdRegElemF.cs
View file

@ -140,74 +140,74 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _F_Mla_Mls_Se_S_()
{
return new[]
{
return
[
0x5F821020u, // FMLA S0, S1, V2.S[0]
0x5F825020u, // FMLS S0, S1, V2.S[0]
};
0x5F825020u // FMLS S0, S1, V2.S[0]
];
}
private static uint[] _F_Mla_Mls_Se_D_()
{
return new[]
{
return
[
0x5FC21020u, // FMLA D0, D1, V2.D[0]
0x5FC25020u, // FMLS D0, D1, V2.D[0]
};
0x5FC25020u // FMLS D0, D1, V2.D[0]
];
}
private static uint[] _F_Mla_Mls_Ve_2S_4S_()
{
return new[]
{
return
[
0x0F801000u, // FMLA V0.2S, V0.2S, V0.S[0]
0x0F805000u, // FMLS V0.2S, V0.2S, V0.S[0]
};
0x0F805000u // FMLS V0.2S, V0.2S, V0.S[0]
];
}
private static uint[] _F_Mla_Mls_Ve_2D_()
{
return new[]
{
return
[
0x4FC01000u, // FMLA V0.2D, V0.2D, V0.D[0]
0x4FC05000u, // FMLS V0.2D, V0.2D, V0.D[0]
};
0x4FC05000u // FMLS V0.2D, V0.2D, V0.D[0]
];
}
private static uint[] _F_Mul_Mulx_Se_S_()
{
return new[]
{
return
[
0x5F829020u, // FMUL S0, S1, V2.S[0]
0x7F829020u, // FMULX S0, S1, V2.S[0]
};
0x7F829020u // FMULX S0, S1, V2.S[0]
];
}
private static uint[] _F_Mul_Mulx_Se_D_()
{
return new[]
{
return
[
0x5FC29020u, // FMUL D0, D1, V2.D[0]
0x7FC29020u, // FMULX D0, D1, V2.D[0]
};
0x7FC29020u // FMULX D0, D1, V2.D[0]
];
}
private static uint[] _F_Mul_Mulx_Ve_2S_4S_()
{
return new[]
{
return
[
0x0F809000u, // FMUL V0.2S, V0.2S, V0.S[0]
0x2F809000u, // FMULX V0.2S, V0.2S, V0.S[0]
};
0x2F809000u // FMULX V0.2S, V0.2S, V0.S[0]
];
}
private static uint[] _F_Mul_Mulx_Ve_2D_()
{
return new[]
{
return
[
0x4FC09000u, // FMUL V0.2D, V0.2D, V0.D[0]
0x6FC09000u, // FMULX V0.2D, V0.2D, V0.D[0]
};
0x6FC09000u // FMULX V0.2D, V0.2D, V0.D[0]
];
}
#endregion

306
src/Ryujinx.Tests/Cpu/CpuTestSimdShImm.cs
View file

@ -15,50 +15,56 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Types)"
private static ulong[] _1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _1H_()
{
return new[] {
return
[
0x0000000000000000ul, 0x0000000000007FFFul,
0x0000000000008000ul, 0x000000000000FFFFul,
};
0x0000000000008000ul, 0x000000000000FFFFul
];
}
private static ulong[] _1S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x000000007FFFFFFFul,
0x0000000080000000ul, 0x00000000FFFFFFFFul,
};
0x0000000080000000ul, 0x00000000FFFFFFFFul
];
}
private static ulong[] _2S_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFF7FFFFFFFul,
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _4H_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul,
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static IEnumerable<ulong> _2S_F_W_()
@ -187,174 +193,174 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _F_Cvt_Z_SU_V_Fixed_2S_4S_()
{
return new[]
{
return
[
0x0F20FC00u, // FCVTZS V0.2S, V0.2S, #32
0x2F20FC00u, // FCVTZU V0.2S, V0.2S, #32
};
0x2F20FC00u // FCVTZU V0.2S, V0.2S, #32
];
}
private static uint[] _F_Cvt_Z_SU_V_Fixed_2D_()
{
return new[]
{
return
[
0x4F40FC00u, // FCVTZS V0.2D, V0.2D, #64
0x6F40FC00u, // FCVTZU V0.2D, V0.2D, #64
};
0x6F40FC00u // FCVTZU V0.2D, V0.2D, #64
];
}
private static uint[] _SU_Cvt_F_S_Fixed_S_()
{
return new[]
{
return
[
0x5F20E420u, // SCVTF S0, S1, #32
0x7F20E420u, // UCVTF S0, S1, #32
};
0x7F20E420u // UCVTF S0, S1, #32
];
}
private static uint[] _SU_Cvt_F_S_Fixed_D_()
{
return new[]
{
return
[
0x5F40E420u, // SCVTF D0, D1, #64
0x7F40E420u, // UCVTF D0, D1, #64
};
0x7F40E420u // UCVTF D0, D1, #64
];
}
private static uint[] _SU_Cvt_F_V_Fixed_2S_4S_()
{
return new[]
{
return
[
0x0F20E400u, // SCVTF V0.2S, V0.2S, #32
0x2F20E400u, // UCVTF V0.2S, V0.2S, #32
};
0x2F20E400u // UCVTF V0.2S, V0.2S, #32
];
}
private static uint[] _SU_Cvt_F_V_Fixed_2D_()
{
return new[]
{
return
[
0x4F40E400u, // SCVTF V0.2D, V0.2D, #64
0x6F40E400u, // UCVTF V0.2D, V0.2D, #64
};
0x6F40E400u // UCVTF V0.2D, V0.2D, #64
];
}
private static uint[] _Shl_Sli_S_D_()
{
return new[]
{
return
[
0x5F405400u, // SHL D0, D0, #0
0x7F405400u, // SLI D0, D0, #0
};
0x7F405400u // SLI D0, D0, #0
];
}
private static uint[] _Shl_Sli_V_8B_16B_()
{
return new[]
{
return
[
0x0F085400u, // SHL V0.8B, V0.8B, #0
0x2F085400u, // SLI V0.8B, V0.8B, #0
};
0x2F085400u // SLI V0.8B, V0.8B, #0
];
}
private static uint[] _Shl_Sli_V_4H_8H_()
{
return new[]
{
return
[
0x0F105400u, // SHL V0.4H, V0.4H, #0
0x2F105400u, // SLI V0.4H, V0.4H, #0
};
0x2F105400u // SLI V0.4H, V0.4H, #0
];
}
private static uint[] _Shl_Sli_V_2S_4S_()
{
return new[]
{
return
[
0x0F205400u, // SHL V0.2S, V0.2S, #0
0x2F205400u, // SLI V0.2S, V0.2S, #0
};
0x2F205400u // SLI V0.2S, V0.2S, #0
];
}
private static uint[] _Shl_Sli_V_2D_()
{
return new[]
{
return
[
0x4F405400u, // SHL V0.2D, V0.2D, #0
0x6F405400u, // SLI V0.2D, V0.2D, #0
};
0x6F405400u // SLI V0.2D, V0.2D, #0
];
}
private static uint[] _SU_Shll_V_8B8H_16B8H_()
{
return new[]
{
return
[
0x0F08A400u, // SSHLL V0.8H, V0.8B, #0
0x2F08A400u, // USHLL V0.8H, V0.8B, #0
};
0x2F08A400u // USHLL V0.8H, V0.8B, #0
];
}
private static uint[] _SU_Shll_V_4H4S_8H4S_()
{
return new[]
{
return
[
0x0F10A400u, // SSHLL V0.4S, V0.4H, #0
0x2F10A400u, // USHLL V0.4S, V0.4H, #0
};
0x2F10A400u // USHLL V0.4S, V0.4H, #0
];
}
private static uint[] _SU_Shll_V_2S2D_4S2D_()
{
return new[]
{
return
[
0x0F20A400u, // SSHLL V0.2D, V0.2S, #0
0x2F20A400u, // USHLL V0.2D, V0.2S, #0
};
0x2F20A400u // USHLL V0.2D, V0.2S, #0
];
}
private static uint[] _ShlImm_S_D_()
{
return new[]
{
0x5F407400u, // SQSHL D0, D0, #0
};
return
[
0x5F407400u // SQSHL D0, D0, #0
];
}
private static uint[] _ShlImm_V_8B_16B_()
{
return new[]
{
0x0F087400u, // SQSHL V0.8B, V0.8B, #0
};
return
[
0x0F087400u // SQSHL V0.8B, V0.8B, #0
];
}
private static uint[] _ShlImm_V_4H_8H_()
{
return new[]
{
0x0F107400u, // SQSHL V0.4H, V0.4H, #0
};
return
[
0x0F107400u // SQSHL V0.4H, V0.4H, #0
];
}
private static uint[] _ShlImm_V_2S_4S_()
{
return new[]
{
0x0F207400u, // SQSHL V0.2S, V0.2S, #0
};
return
[
0x0F207400u // SQSHL V0.2S, V0.2S, #0
];
}
private static uint[] _ShlImm_V_2D_()
{
return new[]
{
0x4F407400u, // SQSHL V0.2D, V0.2D, #0
};
return
[
0x4F407400u // SQSHL V0.2D, V0.2D, #0
];
}
private static uint[] _ShrImm_Sri_S_D_()
{
return new[]
{
return
[
0x7F404400u, // SRI D0, D0, #64
0x5F402400u, // SRSHR D0, D0, #64
0x5F403400u, // SRSRA D0, D0, #64
@ -363,14 +369,14 @@ namespace Ryujinx.Tests.Cpu
0x7F402400u, // URSHR D0, D0, #64
0x7F403400u, // URSRA D0, D0, #64
0x7F400400u, // USHR D0, D0, #64
0x7F401400u, // USRA D0, D0, #64
};
0x7F401400u // USRA D0, D0, #64
];
}
private static uint[] _ShrImm_Sri_V_8B_16B_()
{
return new[]
{
return
[
0x2F084400u, // SRI V0.8B, V0.8B, #8
0x0F082400u, // SRSHR V0.8B, V0.8B, #8
0x0F083400u, // SRSRA V0.8B, V0.8B, #8
@ -379,14 +385,14 @@ namespace Ryujinx.Tests.Cpu
0x2F082400u, // URSHR V0.8B, V0.8B, #8
0x2F083400u, // URSRA V0.8B, V0.8B, #8
0x2F080400u, // USHR V0.8B, V0.8B, #8
0x2F081400u, // USRA V0.8B, V0.8B, #8
};
0x2F081400u // USRA V0.8B, V0.8B, #8
];
}
private static uint[] _ShrImm_Sri_V_4H_8H_()
{
return new[]
{
return
[
0x2F104400u, // SRI V0.4H, V0.4H, #16
0x0F102400u, // SRSHR V0.4H, V0.4H, #16
0x0F103400u, // SRSRA V0.4H, V0.4H, #16
@ -395,14 +401,14 @@ namespace Ryujinx.Tests.Cpu
0x2F102400u, // URSHR V0.4H, V0.4H, #16
0x2F103400u, // URSRA V0.4H, V0.4H, #16
0x2F100400u, // USHR V0.4H, V0.4H, #16
0x2F101400u, // USRA V0.4H, V0.4H, #16
};
0x2F101400u // USRA V0.4H, V0.4H, #16
];
}
private static uint[] _ShrImm_Sri_V_2S_4S_()
{
return new[]
{
return
[
0x2F204400u, // SRI V0.2S, V0.2S, #32
0x0F202400u, // SRSHR V0.2S, V0.2S, #32
0x0F203400u, // SRSRA V0.2S, V0.2S, #32
@ -411,14 +417,14 @@ namespace Ryujinx.Tests.Cpu
0x2F202400u, // URSHR V0.2S, V0.2S, #32
0x2F203400u, // URSRA V0.2S, V0.2S, #32
0x2F200400u, // USHR V0.2S, V0.2S, #32
0x2F201400u, // USRA V0.2S, V0.2S, #32
};
0x2F201400u // USRA V0.2S, V0.2S, #32
];
}
private static uint[] _ShrImm_Sri_V_2D_()
{
return new[]
{
return
[
0x6F404400u, // SRI V0.2D, V0.2D, #64
0x4F402400u, // SRSHR V0.2D, V0.2D, #64
0x4F403400u, // SRSRA V0.2D, V0.2D, #64
@ -427,113 +433,113 @@ namespace Ryujinx.Tests.Cpu
0x6F402400u, // URSHR V0.2D, V0.2D, #64
0x6F403400u, // URSRA V0.2D, V0.2D, #64
0x6F400400u, // USHR V0.2D, V0.2D, #64
0x6F401400u, // USRA V0.2D, V0.2D, #64
};
0x6F401400u // USRA V0.2D, V0.2D, #64
];
}
private static uint[] _ShrImmNarrow_V_8H8B_8H16B_()
{
return new[]
{
return
[
0x0F088C00u, // RSHRN V0.8B, V0.8H, #8
0x0F088400u, // SHRN V0.8B, V0.8H, #8
};
0x0F088400u // SHRN V0.8B, V0.8H, #8
];
}
private static uint[] _ShrImmNarrow_V_4S4H_4S8H_()
{
return new[]
{
return
[
0x0F108C00u, // RSHRN V0.4H, V0.4S, #16
0x0F108400u, // SHRN V0.4H, V0.4S, #16
};
0x0F108400u // SHRN V0.4H, V0.4S, #16
];
}
private static uint[] _ShrImmNarrow_V_2D2S_2D4S_()
{
return new[]
{
return
[
0x0F208C00u, // RSHRN V0.2S, V0.2D, #32
0x0F208400u, // SHRN V0.2S, V0.2D, #32
};
0x0F208400u // SHRN V0.2S, V0.2D, #32
];
}
private static uint[] _ShrImmSaturatingNarrow_S_HB_()
{
return new[]
{
return
[
0x5F089C00u, // SQRSHRN B0, H0, #8
0x7F089C00u, // UQRSHRN B0, H0, #8
0x7F088C00u, // SQRSHRUN B0, H0, #8
0x5F089400u, // SQSHRN B0, H0, #8
0x7F089400u, // UQSHRN B0, H0, #8
0x7F088400u, // SQSHRUN B0, H0, #8
};
0x7F088400u // SQSHRUN B0, H0, #8
];
}
private static uint[] _ShrImmSaturatingNarrow_S_SH_()
{
return new[]
{
return
[
0x5F109C00u, // SQRSHRN H0, S0, #16
0x7F109C00u, // UQRSHRN H0, S0, #16
0x7F108C00u, // SQRSHRUN H0, S0, #16
0x5F109400u, // SQSHRN H0, S0, #16
0x7F109400u, // UQSHRN H0, S0, #16
0x7F108400u, // SQSHRUN H0, S0, #16
};
0x7F108400u // SQSHRUN H0, S0, #16
];
}
private static uint[] _ShrImmSaturatingNarrow_S_DS_()
{
return new[]
{
return
[
0x5F209C00u, // SQRSHRN S0, D0, #32
0x7F209C00u, // UQRSHRN S0, D0, #32
0x7F208C00u, // SQRSHRUN S0, D0, #32
0x5F209400u, // SQSHRN S0, D0, #32
0x7F209400u, // UQSHRN S0, D0, #32
0x7F208400u, // SQSHRUN S0, D0, #32
};
0x7F208400u // SQSHRUN S0, D0, #32
];
}
private static uint[] _ShrImmSaturatingNarrow_V_8H8B_8H16B_()
{
return new[]
{
return
[
0x0F089C00u, // SQRSHRN V0.8B, V0.8H, #8
0x2F089C00u, // UQRSHRN V0.8B, V0.8H, #8
0x2F088C00u, // SQRSHRUN V0.8B, V0.8H, #8
0x0F089400u, // SQSHRN V0.8B, V0.8H, #8
0x2F089400u, // UQSHRN V0.8B, V0.8H, #8
0x2F088400u, // SQSHRUN V0.8B, V0.8H, #8
};
0x2F088400u // SQSHRUN V0.8B, V0.8H, #8
];
}
private static uint[] _ShrImmSaturatingNarrow_V_4S4H_4S8H_()
{
return new[]
{
return
[
0x0F109C00u, // SQRSHRN V0.4H, V0.4S, #16
0x2F109C00u, // UQRSHRN V0.4H, V0.4S, #16
0x2F108C00u, // SQRSHRUN V0.4H, V0.4S, #16
0x0F109400u, // SQSHRN V0.4H, V0.4S, #16
0x2F109400u, // UQSHRN V0.4H, V0.4S, #16
0x2F108400u, // SQSHRUN V0.4H, V0.4S, #16
};
0x2F108400u // SQSHRUN V0.4H, V0.4S, #16
];
}
private static uint[] _ShrImmSaturatingNarrow_V_2D2S_2D4S_()
{
return new[]
{
return
[
0x0F209C00u, // SQRSHRN V0.2S, V0.2D, #32
0x2F209C00u, // UQRSHRN V0.2S, V0.2D, #32
0x2F208C00u, // SQRSHRUN V0.2S, V0.2D, #32
0x0F209400u, // SQSHRN V0.2S, V0.2D, #32
0x2F209400u, // UQSHRN V0.2S, V0.2D, #32
0x2F208400u, // SQSHRUN V0.2S, V0.2D, #32
};
0x2F208400u // SQSHRUN V0.2S, V0.2D, #32
];
}
#endregion

79
src/Ryujinx.Tests/Cpu/CpuTestSimdShImm32.cs
View file

@ -13,98 +13,99 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Types)"
private static ulong[] _1D_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul,
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _2S_()
{
return new[]
{
0x0000000000000000ul, 0x7FFFFFFF7FFFFFFFul, 0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul,
};
return
[
0x0000000000000000ul, 0x7FFFFFFF7FFFFFFFul, 0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _4H_()
{
return new[]
{
0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul, 0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul,
};
return
[
0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul, 0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static ulong[] _8B_()
{
return new[]
{
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful, 0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul,
};
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful, 0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul
];
}
#endregion
#region "ValueSource (Opcodes)"
private static uint[] _Vshr_Imm_SU8_()
{
return new[]
{
return
[
0xf2880010u, // VSHR.S8 D0, D0, #8
0xf2880110u, // VSRA.S8 D0, D0, #8
0xf2880210u, // VRSHR.S8 D0, D0, #8
0xf2880310u, // VRSRA.S8 D0, D0, #8
};
0xf2880310u // VRSRA.S8 D0, D0, #8
];
}
private static uint[] _Vshr_Imm_SU16_()
{
return new[]
{
return
[
0xf2900010u, // VSHR.S16 D0, D0, #16
0xf2900110u, // VSRA.S16 D0, D0, #16
0xf2900210u, // VRSHR.S16 D0, D0, #16
0xf2900310u, // VRSRA.S16 D0, D0, #16
};
0xf2900310u // VRSRA.S16 D0, D0, #16
];
}
private static uint[] _Vshr_Imm_SU32_()
{
return new[]
{
return
[
0xf2a00010u, // VSHR.S32 D0, D0, #32
0xf2a00110u, // VSRA.S32 D0, D0, #32
0xf2a00210u, // VRSHR.S32 D0, D0, #32
0xf2a00310u, // VRSRA.S32 D0, D0, #32
};
0xf2a00310u // VRSRA.S32 D0, D0, #32
];
}
private static uint[] _Vshr_Imm_SU64_()
{
return new[]
{
return
[
0xf2800190u, // VSRA.S64 D0, D0, #64
0xf2800290u, // VRSHR.S64 D0, D0, #64
0xf2800090u, // VSHR.S64 D0, D0, #64
};
0xf2800090u // VSHR.S64 D0, D0, #64
];
}
private static uint[] _Vqshrn_Vqrshrn_Vrshrn_Imm_()
{
return new[]
{
return
[
0xf2800910u, // VORR.I16 D0, #0 (immediate value changes it into QSHRN)
0xf2800950u, // VORR.I16 Q0, #0 (immediate value changes it into QRSHRN)
0xf2800850u, // VMOV.I16 Q0, #0 (immediate value changes it into RSHRN)
};
0xf2800850u // VMOV.I16 Q0, #0 (immediate value changes it into RSHRN)
];
}
private static uint[] _Vqshrun_Vqrshrun_Imm_()
{
return new[]
{
return
[
0xf3800810u, // VMOV.I16 D0, #0x80 (immediate value changes it into QSHRUN)
0xf3800850u, // VMOV.I16 Q0, #0x80 (immediate value changes it into QRSHRUN)
};
0xf3800850u // VMOV.I16 Q0, #0x80 (immediate value changes it into QRSHRUN)
];
}
#endregion

39
src/Ryujinx.Tests/Cpu/CpuTestSimdTbl.cs
View file

@ -38,10 +38,11 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Types)"
private static ulong[] _8B_()
{
return new[] {
return
[
0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul,
};
0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul
];
}
private static IEnumerable<ulong> _GenIdxsForTbl1_()
@ -100,38 +101,38 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _SingleRegisterTable_V_8B_16B_()
{
return new[]
{
return
[
0x0E000000u, // TBL V0.8B, { V0.16B }, V0.8B
0x0E001000u, // TBX V0.8B, { V0.16B }, V0.8B
};
0x0E001000u // TBX V0.8B, { V0.16B }, V0.8B
];
}
private static uint[] _TwoRegisterTable_V_8B_16B_()
{
return new[]
{
return
[
0x0E002000u, // TBL V0.8B, { V0.16B, V1.16B }, V0.8B
0x0E003000u, // TBX V0.8B, { V0.16B, V1.16B }, V0.8B
};
0x0E003000u // TBX V0.8B, { V0.16B, V1.16B }, V0.8B
];
}
private static uint[] _ThreeRegisterTable_V_8B_16B_()
{
return new[]
{
return
[
0x0E004000u, // TBL V0.8B, { V0.16B, V1.16B, V2.16B }, V0.8B
0x0E005000u, // TBX V0.8B, { V0.16B, V1.16B, V2.16B }, V0.8B
};
0x0E005000u // TBX V0.8B, { V0.16B, V1.16B, V2.16B }, V0.8B
];
}
private static uint[] _FourRegisterTable_V_8B_16B_()
{
return new[]
{
return
[
0x0E006000u, // TBL V0.8B, { V0.16B, V1.16B, V2.16B, V3.16B }, V0.8B
0x0E006000u, // TBX V0.8B, { V0.16B, V1.16B, V2.16B, V3.16B }, V0.8B
};
0x0E006000u // TBX V0.8B, { V0.16B, V1.16B, V2.16B, V3.16B }, V0.8B
];
}
#endregion

8
src/Ryujinx.Tests/Cpu/CpuTestSystem.cs
View file

@ -38,11 +38,11 @@ namespace Ryujinx.Tests.Cpu
#region "ValueSource (Opcodes)"
private static uint[] _MrsMsr_Nzcv_()
{
return new[]
{
return
[
0xD53B4200u, // MRS X0, NZCV
0xD51B4200u, // MSR NZCV, X0
};
0xD51B4200u // MSR NZCV, X0
];
}
#endregion

1284
src/Ryujinx.Tests/Cpu/CpuTestT32Alu.cs
View file

File diff suppressed because it is too large Load diff

714
src/Ryujinx.Tests/Cpu/CpuTestT32Mem.cs
View file

@ -13,509 +13,657 @@ namespace Ryujinx.Tests.Cpu
}
public static readonly PrecomputedMemoryThumbTestCase[] ImmTestCases =
{
[
// STRB (imm8)
new()
{
Instructions = new ushort[] { 0xf80c, 0x1b2f, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000023bd, 0x000027bb, 0x00002715, 0x000028f5, 0x0000233f, 0x0000213b, 0x00002eea, 0x0000282b, 0x000021e1, 0x0000264c, 0x000029e0, 0x00002ae7, 0x000021ff, 0x000026e3, 0x00000001, 0x800001f0 },
FinalRegs = new uint[] { 0x000023bd, 0x000027bb, 0x00002715, 0x000028f5, 0x0000233f, 0x0000213b, 0x00002eea, 0x0000282b, 0x000021e1, 0x0000264c, 0x000029e0, 0x00002ae7, 0x0000222e, 0x000026e3, 0x00000001, 0x800001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x21fe, Value: 0xbbfe) },
Instructions = [0xf80c, 0x1b2f, 0x4770, 0xe7fe],
StartRegs = [0x000023bd, 0x000027bb, 0x00002715, 0x000028f5, 0x0000233f, 0x0000213b, 0x00002eea, 0x0000282b, 0x000021e1, 0x0000264c, 0x000029e0, 0x00002ae7, 0x000021ff, 0x000026e3, 0x00000001, 0x800001f0
],
FinalRegs = [0x000023bd, 0x000027bb, 0x00002715, 0x000028f5, 0x0000233f, 0x0000213b, 0x00002eea, 0x0000282b, 0x000021e1, 0x0000264c, 0x000029e0, 0x00002ae7, 0x0000222e, 0x000026e3, 0x00000001, 0x800001f0
],
MemoryDelta = [(Address: 0x21fe, Value: 0xbbfe)],
},
new()
{
Instructions = new ushort[] { 0xf80a, 0x2f81, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x0000223c, 0x00002db9, 0x00002900, 0x0000247c, 0x00002b0a, 0x0000266b, 0x000026df, 0x00002447, 0x000024bb, 0x00002687, 0x0000266f, 0x00002a80, 0x000025ff, 0x00002881, 0x00000001, 0xa00001f0 },
FinalRegs = new uint[] { 0x0000223c, 0x00002db9, 0x00002900, 0x0000247c, 0x00002b0a, 0x0000266b, 0x000026df, 0x00002447, 0x000024bb, 0x00002687, 0x000026f0, 0x00002a80, 0x000025ff, 0x00002881, 0x00000001, 0xa00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x26f0, Value: 0x2600) },
Instructions = [0xf80a, 0x2f81, 0x4770, 0xe7fe],
StartRegs = [0x0000223c, 0x00002db9, 0x00002900, 0x0000247c, 0x00002b0a, 0x0000266b, 0x000026df, 0x00002447, 0x000024bb, 0x00002687, 0x0000266f, 0x00002a80, 0x000025ff, 0x00002881, 0x00000001, 0xa00001f0
],
FinalRegs = [0x0000223c, 0x00002db9, 0x00002900, 0x0000247c, 0x00002b0a, 0x0000266b, 0x000026df, 0x00002447, 0x000024bb, 0x00002687, 0x000026f0, 0x00002a80, 0x000025ff, 0x00002881, 0x00000001, 0xa00001f0
],
MemoryDelta = [(Address: 0x26f0, Value: 0x2600)],
},
new()
{
Instructions = new ushort[] { 0xf803, 0x6968, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000026ed, 0x00002685, 0x00002cd1, 0x00002dac, 0x00002a23, 0x00002626, 0x00002ec9, 0x0000245c, 0x000024ef, 0x00002319, 0x000026ce, 0x0000214d, 0x00002401, 0x000028b4, 0x00000001, 0x300001f0 },
FinalRegs = new uint[] { 0x000026ed, 0x00002685, 0x00002cd1, 0x00002d44, 0x00002a23, 0x00002626, 0x00002ec9, 0x0000245c, 0x000024ef, 0x00002319, 0x000026ce, 0x0000214d, 0x00002401, 0x000028b4, 0x00000001, 0x300001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2dac, Value: 0x2dc9) },
Instructions = [0xf803, 0x6968, 0x4770, 0xe7fe],
StartRegs = [0x000026ed, 0x00002685, 0x00002cd1, 0x00002dac, 0x00002a23, 0x00002626, 0x00002ec9, 0x0000245c, 0x000024ef, 0x00002319, 0x000026ce, 0x0000214d, 0x00002401, 0x000028b4, 0x00000001, 0x300001f0
],
FinalRegs = [0x000026ed, 0x00002685, 0x00002cd1, 0x00002d44, 0x00002a23, 0x00002626, 0x00002ec9, 0x0000245c, 0x000024ef, 0x00002319, 0x000026ce, 0x0000214d, 0x00002401, 0x000028b4, 0x00000001, 0x300001f0
],
MemoryDelta = [(Address: 0x2dac, Value: 0x2dc9)],
},
new()
{
Instructions = new ushort[] { 0xf804, 0x89ad, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x0000265d, 0x00002b9c, 0x00002360, 0x000029ec, 0x00002413, 0x00002d8e, 0x00002aad, 0x00002d29, 0x00002bca, 0x00002a44, 0x00002980, 0x00002710, 0x000022fa, 0x0000222e, 0x00000001, 0xc00001f0 },
FinalRegs = new uint[] { 0x0000265d, 0x00002b9c, 0x00002360, 0x000029ec, 0x00002366, 0x00002d8e, 0x00002aad, 0x00002d29, 0x00002bca, 0x00002a44, 0x00002980, 0x00002710, 0x000022fa, 0x0000222e, 0x00000001, 0xc00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2412, Value: 0xca12) },
Instructions = [0xf804, 0x89ad, 0x4770, 0xe7fe],
StartRegs = [0x0000265d, 0x00002b9c, 0x00002360, 0x000029ec, 0x00002413, 0x00002d8e, 0x00002aad, 0x00002d29, 0x00002bca, 0x00002a44, 0x00002980, 0x00002710, 0x000022fa, 0x0000222e, 0x00000001, 0xc00001f0
],
FinalRegs = [0x0000265d, 0x00002b9c, 0x00002360, 0x000029ec, 0x00002366, 0x00002d8e, 0x00002aad, 0x00002d29, 0x00002bca, 0x00002a44, 0x00002980, 0x00002710, 0x000022fa, 0x0000222e, 0x00000001, 0xc00001f0
],
MemoryDelta = [(Address: 0x2412, Value: 0xca12)],
},
new()
{
Instructions = new ushort[] { 0xf80d, 0xa9fe, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x0000298d, 0x00002e6c, 0x00002986, 0x00002ebb, 0x0000213e, 0x00002e39, 0x0000246f, 0x00002b6c, 0x00002ee2, 0x0000259e, 0x0000250a, 0x000029f6, 0x000021e7, 0x00002d9d, 0x00000001, 0x900001f0 },
FinalRegs = new uint[] { 0x0000298d, 0x00002e6c, 0x00002986, 0x00002ebb, 0x0000213e, 0x00002e39, 0x0000246f, 0x00002b6c, 0x00002ee2, 0x0000259e, 0x0000250a, 0x000029f6, 0x000021e7, 0x00002c9f, 0x00000001, 0x900001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2d9c, Value: 0x0a9c) },
Instructions = [0xf80d, 0xa9fe, 0x4770, 0xe7fe],
StartRegs = [0x0000298d, 0x00002e6c, 0x00002986, 0x00002ebb, 0x0000213e, 0x00002e39, 0x0000246f, 0x00002b6c, 0x00002ee2, 0x0000259e, 0x0000250a, 0x000029f6, 0x000021e7, 0x00002d9d, 0x00000001, 0x900001f0
],
FinalRegs = [0x0000298d, 0x00002e6c, 0x00002986, 0x00002ebb, 0x0000213e, 0x00002e39, 0x0000246f, 0x00002b6c, 0x00002ee2, 0x0000259e, 0x0000250a, 0x000029f6, 0x000021e7, 0x00002c9f, 0x00000001, 0x900001f0
],
MemoryDelta = [(Address: 0x2d9c, Value: 0x0a9c)],
},
new()
{
Instructions = new ushort[] { 0xf80d, 0x3c46, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002c6f, 0x000028cc, 0x000025f0, 0x000022cc, 0x00002de3, 0x0000243c, 0x000025fb, 0x00002e88, 0x00002985, 0x000023ee, 0x00002120, 0x00002d50, 0x0000270a, 0x00002bbd, 0x00000001, 0xa00001f0 },
FinalRegs = new uint[] { 0x00002c6f, 0x000028cc, 0x000025f0, 0x000022cc, 0x00002de3, 0x0000243c, 0x000025fb, 0x00002e88, 0x00002985, 0x000023ee, 0x00002120, 0x00002d50, 0x0000270a, 0x00002bbd, 0x00000001, 0xa00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2b76, Value: 0xcc76) },
Instructions = [0xf80d, 0x3c46, 0x4770, 0xe7fe],
StartRegs = [0x00002c6f, 0x000028cc, 0x000025f0, 0x000022cc, 0x00002de3, 0x0000243c, 0x000025fb, 0x00002e88, 0x00002985, 0x000023ee, 0x00002120, 0x00002d50, 0x0000270a, 0x00002bbd, 0x00000001, 0xa00001f0
],
FinalRegs = [0x00002c6f, 0x000028cc, 0x000025f0, 0x000022cc, 0x00002de3, 0x0000243c, 0x000025fb, 0x00002e88, 0x00002985, 0x000023ee, 0x00002120, 0x00002d50, 0x0000270a, 0x00002bbd, 0x00000001, 0xa00001f0
],
MemoryDelta = [(Address: 0x2b76, Value: 0xcc76)],
},
new()
{
Instructions = new ushort[] { 0xf801, 0x6c56, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002d6e, 0x00002530, 0x00002e6d, 0x00002942, 0x00002985, 0x00002d64, 0x00002a73, 0x00002ac6, 0x00002955, 0x00002881, 0x0000221d, 0x00002cb0, 0x0000225f, 0x00002534, 0x00000001, 0x100001f0 },
FinalRegs = new uint[] { 0x00002d6e, 0x00002530, 0x00002e6d, 0x00002942, 0x00002985, 0x00002d64, 0x00002a73, 0x00002ac6, 0x00002955, 0x00002881, 0x0000221d, 0x00002cb0, 0x0000225f, 0x00002534, 0x00000001, 0x100001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x24da, Value: 0x2473) },
Instructions = [0xf801, 0x6c56, 0x4770, 0xe7fe],
StartRegs = [0x00002d6e, 0x00002530, 0x00002e6d, 0x00002942, 0x00002985, 0x00002d64, 0x00002a73, 0x00002ac6, 0x00002955, 0x00002881, 0x0000221d, 0x00002cb0, 0x0000225f, 0x00002534, 0x00000001, 0x100001f0
],
FinalRegs = [0x00002d6e, 0x00002530, 0x00002e6d, 0x00002942, 0x00002985, 0x00002d64, 0x00002a73, 0x00002ac6, 0x00002955, 0x00002881, 0x0000221d, 0x00002cb0, 0x0000225f, 0x00002534, 0x00000001, 0x100001f0
],
MemoryDelta = [(Address: 0x24da, Value: 0x2473)],
},
new()
{
Instructions = new ushort[] { 0xf809, 0xcc76, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002d50, 0x000025f2, 0x0000250a, 0x0000214c, 0x000023d1, 0x00002115, 0x00002c27, 0x00002540, 0x0000222b, 0x00002d03, 0x00002679, 0x00002b52, 0x00002eee, 0x00002b2a, 0x00000001, 0xd00001f0 },
FinalRegs = new uint[] { 0x00002d50, 0x000025f2, 0x0000250a, 0x0000214c, 0x000023d1, 0x00002115, 0x00002c27, 0x00002540, 0x0000222b, 0x00002d03, 0x00002679, 0x00002b52, 0x00002eee, 0x00002b2a, 0x00000001, 0xd00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2c8c, Value: 0xee8c) },
Instructions = [0xf809, 0xcc76, 0x4770, 0xe7fe],
StartRegs = [0x00002d50, 0x000025f2, 0x0000250a, 0x0000214c, 0x000023d1, 0x00002115, 0x00002c27, 0x00002540, 0x0000222b, 0x00002d03, 0x00002679, 0x00002b52, 0x00002eee, 0x00002b2a, 0x00000001, 0xd00001f0
],
FinalRegs = [0x00002d50, 0x000025f2, 0x0000250a, 0x0000214c, 0x000023d1, 0x00002115, 0x00002c27, 0x00002540, 0x0000222b, 0x00002d03, 0x00002679, 0x00002b52, 0x00002eee, 0x00002b2a, 0x00000001, 0xd00001f0
],
MemoryDelta = [(Address: 0x2c8c, Value: 0xee8c)],
},
new()
{
Instructions = new ushort[] { 0xf808, 0x1c8d, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002844, 0x00002b78, 0x000028b0, 0x000026ff, 0x0000280b, 0x00002e0b, 0x00002de4, 0x00002b53, 0x00002ecd, 0x000021b5, 0x000026bc, 0x00002e9d, 0x00002d33, 0x000027f0, 0x00000001, 0x800001f0 },
FinalRegs = new uint[] { 0x00002844, 0x00002b78, 0x000028b0, 0x000026ff, 0x0000280b, 0x00002e0b, 0x00002de4, 0x00002b53, 0x00002ecd, 0x000021b5, 0x000026bc, 0x00002e9d, 0x00002d33, 0x000027f0, 0x00000001, 0x800001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2e40, Value: 0x2e78) },
Instructions = [0xf808, 0x1c8d, 0x4770, 0xe7fe],
StartRegs = [0x00002844, 0x00002b78, 0x000028b0, 0x000026ff, 0x0000280b, 0x00002e0b, 0x00002de4, 0x00002b53, 0x00002ecd, 0x000021b5, 0x000026bc, 0x00002e9d, 0x00002d33, 0x000027f0, 0x00000001, 0x800001f0
],
FinalRegs = [0x00002844, 0x00002b78, 0x000028b0, 0x000026ff, 0x0000280b, 0x00002e0b, 0x00002de4, 0x00002b53, 0x00002ecd, 0x000021b5, 0x000026bc, 0x00002e9d, 0x00002d33, 0x000027f0, 0x00000001, 0x800001f0
],
MemoryDelta = [(Address: 0x2e40, Value: 0x2e78)],
},
new()
{
Instructions = new ushort[] { 0xf80b, 0xbc26, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002244, 0x000025ad, 0x00002434, 0x00002b06, 0x00002ebd, 0x0000292b, 0x00002431, 0x00002e12, 0x0000289b, 0x0000265a, 0x00002747, 0x00002bac, 0x00002dae, 0x00002582, 0x00000001, 0xf00001f0 },
FinalRegs = new uint[] { 0x00002244, 0x000025ad, 0x00002434, 0x00002b06, 0x00002ebd, 0x0000292b, 0x00002431, 0x00002e12, 0x0000289b, 0x0000265a, 0x00002747, 0x00002bac, 0x00002dae, 0x00002582, 0x00000001, 0xf00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2b86, Value: 0x2bac) },
Instructions = [0xf80b, 0xbc26, 0x4770, 0xe7fe],
StartRegs = [0x00002244, 0x000025ad, 0x00002434, 0x00002b06, 0x00002ebd, 0x0000292b, 0x00002431, 0x00002e12, 0x0000289b, 0x0000265a, 0x00002747, 0x00002bac, 0x00002dae, 0x00002582, 0x00000001, 0xf00001f0
],
FinalRegs = [0x00002244, 0x000025ad, 0x00002434, 0x00002b06, 0x00002ebd, 0x0000292b, 0x00002431, 0x00002e12, 0x0000289b, 0x0000265a, 0x00002747, 0x00002bac, 0x00002dae, 0x00002582, 0x00000001, 0xf00001f0
],
MemoryDelta = [(Address: 0x2b86, Value: 0x2bac)],
},
// STRB (imm12)
new()
{
Instructions = new ushort[] { 0xf887, 0x67c2, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x700001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x700001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x27c2, Value: 0x2700) },
Instructions = [0xf887, 0x67c2, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x700001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x700001f0
],
MemoryDelta = [(Address: 0x27c2, Value: 0x2700)],
},
new()
{
Instructions = new ushort[] { 0xf883, 0x9fda, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xc00001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xc00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2fda, Value: 0x2f00) },
Instructions = [0xf883, 0x9fda, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xc00001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xc00001f0
],
MemoryDelta = [(Address: 0x2fda, Value: 0x2f00)],
},
new()
{
Instructions = new ushort[] { 0xf889, 0xd200, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x400001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x400001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf889, 0xd200, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x400001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x400001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf88c, 0x1c5b, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2c5a, Value: 0x005a) },
Instructions = [0xf88c, 0x1c5b, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0
],
MemoryDelta = [(Address: 0x2c5a, Value: 0x005a)],
},
new()
{
Instructions = new ushort[] { 0xf887, 0x9fe2, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2fe2, Value: 0x2f00) },
Instructions = [0xf887, 0x9fe2, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0
],
MemoryDelta = [(Address: 0x2fe2, Value: 0x2f00)],
},
// STRH (imm8)
new()
{
Instructions = new ushort[] { 0xf826, 0x0b0a, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000025a2, 0x000024d5, 0x00002ca1, 0x0000238a, 0x0000279c, 0x0000244c, 0x00002620, 0x00002c0e, 0x0000233e, 0x0000285f, 0x000021ab, 0x00002bd0, 0x0000281f, 0x00002be7, 0x00000001, 0x600001f0 },
FinalRegs = new uint[] { 0x000025a2, 0x000024d5, 0x00002ca1, 0x0000238a, 0x0000279c, 0x0000244c, 0x0000262a, 0x00002c0e, 0x0000233e, 0x0000285f, 0x000021ab, 0x00002bd0, 0x0000281f, 0x00002be7, 0x00000001, 0x600001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2620, Value: 0x25a2) },
Instructions = [0xf826, 0x0b0a, 0x4770, 0xe7fe],
StartRegs = [0x000025a2, 0x000024d5, 0x00002ca1, 0x0000238a, 0x0000279c, 0x0000244c, 0x00002620, 0x00002c0e, 0x0000233e, 0x0000285f, 0x000021ab, 0x00002bd0, 0x0000281f, 0x00002be7, 0x00000001, 0x600001f0
],
FinalRegs = [0x000025a2, 0x000024d5, 0x00002ca1, 0x0000238a, 0x0000279c, 0x0000244c, 0x0000262a, 0x00002c0e, 0x0000233e, 0x0000285f, 0x000021ab, 0x00002bd0, 0x0000281f, 0x00002be7, 0x00000001, 0x600001f0
],
MemoryDelta = [(Address: 0x2620, Value: 0x25a2)],
},
new()
{
Instructions = new ushort[] { 0xf827, 0xcf61, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002555, 0x0000238f, 0x00002829, 0x000028c8, 0x00002399, 0x00002aab, 0x00002d6f, 0x000029eb, 0x000029e0, 0x00002d33, 0x0000292a, 0x00002b33, 0x00002e29, 0x00002ca4, 0x00000001, 0x100001f0 },
FinalRegs = new uint[] { 0x00002555, 0x0000238f, 0x00002829, 0x000028c8, 0x00002399, 0x00002aab, 0x00002d6f, 0x00002a4c, 0x000029e0, 0x00002d33, 0x0000292a, 0x00002b33, 0x00002e29, 0x00002ca4, 0x00000001, 0x100001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2a4c, Value: 0x2e29) },
Instructions = [0xf827, 0xcf61, 0x4770, 0xe7fe],
StartRegs = [0x00002555, 0x0000238f, 0x00002829, 0x000028c8, 0x00002399, 0x00002aab, 0x00002d6f, 0x000029eb, 0x000029e0, 0x00002d33, 0x0000292a, 0x00002b33, 0x00002e29, 0x00002ca4, 0x00000001, 0x100001f0
],
FinalRegs = [0x00002555, 0x0000238f, 0x00002829, 0x000028c8, 0x00002399, 0x00002aab, 0x00002d6f, 0x00002a4c, 0x000029e0, 0x00002d33, 0x0000292a, 0x00002b33, 0x00002e29, 0x00002ca4, 0x00000001, 0x100001f0
],
MemoryDelta = [(Address: 0x2a4c, Value: 0x2e29)],
},
new()
{
Instructions = new ushort[] { 0xf821, 0x9b00, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000027ba, 0x00002514, 0x00002b07, 0x00002daf, 0x00002790, 0x0000274b, 0x00002379, 0x00002a98, 0x000024c8, 0x00002398, 0x000021ba, 0x00002959, 0x00002821, 0x00002d09, 0x00000001, 0x500001f0 },
FinalRegs = new uint[] { 0x000027ba, 0x00002514, 0x00002b07, 0x00002daf, 0x00002790, 0x0000274b, 0x00002379, 0x00002a98, 0x000024c8, 0x00002398, 0x000021ba, 0x00002959, 0x00002821, 0x00002d09, 0x00000001, 0x500001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2514, Value: 0x2398) },
Instructions = [0xf821, 0x9b00, 0x4770, 0xe7fe],
StartRegs = [0x000027ba, 0x00002514, 0x00002b07, 0x00002daf, 0x00002790, 0x0000274b, 0x00002379, 0x00002a98, 0x000024c8, 0x00002398, 0x000021ba, 0x00002959, 0x00002821, 0x00002d09, 0x00000001, 0x500001f0
],
FinalRegs = [0x000027ba, 0x00002514, 0x00002b07, 0x00002daf, 0x00002790, 0x0000274b, 0x00002379, 0x00002a98, 0x000024c8, 0x00002398, 0x000021ba, 0x00002959, 0x00002821, 0x00002d09, 0x00000001, 0x500001f0
],
MemoryDelta = [(Address: 0x2514, Value: 0x2398)],
},
new()
{
Instructions = new ushort[] { 0xf82c, 0xa927, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x0000226a, 0x00002792, 0x00002870, 0x00002918, 0x00002757, 0x00002679, 0x00002546, 0x000027f5, 0x00002edc, 0x00002cd3, 0x0000274a, 0x00002562, 0x000029a1, 0x00002976, 0x00000001, 0x100001f0 },
FinalRegs = new uint[] { 0x0000226a, 0x00002792, 0x00002870, 0x00002918, 0x00002757, 0x00002679, 0x00002546, 0x000027f5, 0x00002edc, 0x00002cd3, 0x0000274a, 0x00002562, 0x0000297a, 0x00002976, 0x00000001, 0x100001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x29a0, Value: 0x4aa0), (Address: 0x29a2, Value: 0x2927) },
Instructions = [0xf82c, 0xa927, 0x4770, 0xe7fe],
StartRegs = [0x0000226a, 0x00002792, 0x00002870, 0x00002918, 0x00002757, 0x00002679, 0x00002546, 0x000027f5, 0x00002edc, 0x00002cd3, 0x0000274a, 0x00002562, 0x000029a1, 0x00002976, 0x00000001, 0x100001f0
],
FinalRegs = [0x0000226a, 0x00002792, 0x00002870, 0x00002918, 0x00002757, 0x00002679, 0x00002546, 0x000027f5, 0x00002edc, 0x00002cd3, 0x0000274a, 0x00002562, 0x0000297a, 0x00002976, 0x00000001, 0x100001f0
],
MemoryDelta = [(Address: 0x29a0, Value: 0x4aa0), (Address: 0x29a2, Value: 0x2927)],
},
new()
{
Instructions = new ushort[] { 0xf824, 0xcfe4, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x0000238b, 0x00002d22, 0x00002476, 0x000028ae, 0x00002442, 0x0000212b, 0x000026de, 0x00002a1a, 0x00002a02, 0x00002e47, 0x00002b2d, 0x00002427, 0x00002d1c, 0x000026d4, 0x00000001, 0xd00001f0 },
FinalRegs = new uint[] { 0x0000238b, 0x00002d22, 0x00002476, 0x000028ae, 0x00002526, 0x0000212b, 0x000026de, 0x00002a1a, 0x00002a02, 0x00002e47, 0x00002b2d, 0x00002427, 0x00002d1c, 0x000026d4, 0x00000001, 0xd00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2526, Value: 0x2d1c) },
Instructions = [0xf824, 0xcfe4, 0x4770, 0xe7fe],
StartRegs = [0x0000238b, 0x00002d22, 0x00002476, 0x000028ae, 0x00002442, 0x0000212b, 0x000026de, 0x00002a1a, 0x00002a02, 0x00002e47, 0x00002b2d, 0x00002427, 0x00002d1c, 0x000026d4, 0x00000001, 0xd00001f0
],
FinalRegs = [0x0000238b, 0x00002d22, 0x00002476, 0x000028ae, 0x00002526, 0x0000212b, 0x000026de, 0x00002a1a, 0x00002a02, 0x00002e47, 0x00002b2d, 0x00002427, 0x00002d1c, 0x000026d4, 0x00000001, 0xd00001f0
],
MemoryDelta = [(Address: 0x2526, Value: 0x2d1c)],
},
new()
{
Instructions = new ushort[] { 0xf820, 0x1c3d, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002227, 0x00002b29, 0x0000232a, 0x0000214e, 0x000029ef, 0x00002522, 0x000029d3, 0x0000286c, 0x000029b2, 0x00002147, 0x00002c65, 0x00002891, 0x000029c2, 0x000028a5, 0x00000001, 0x800001f0 },
FinalRegs = new uint[] { 0x00002227, 0x00002b29, 0x0000232a, 0x0000214e, 0x000029ef, 0x00002522, 0x000029d3, 0x0000286c, 0x000029b2, 0x00002147, 0x00002c65, 0x00002891, 0x000029c2, 0x000028a5, 0x00000001, 0x800001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x21ea, Value: 0x2b29) },
Instructions = [0xf820, 0x1c3d, 0x4770, 0xe7fe],
StartRegs = [0x00002227, 0x00002b29, 0x0000232a, 0x0000214e, 0x000029ef, 0x00002522, 0x000029d3, 0x0000286c, 0x000029b2, 0x00002147, 0x00002c65, 0x00002891, 0x000029c2, 0x000028a5, 0x00000001, 0x800001f0
],
FinalRegs = [0x00002227, 0x00002b29, 0x0000232a, 0x0000214e, 0x000029ef, 0x00002522, 0x000029d3, 0x0000286c, 0x000029b2, 0x00002147, 0x00002c65, 0x00002891, 0x000029c2, 0x000028a5, 0x00000001, 0x800001f0
],
MemoryDelta = [(Address: 0x21ea, Value: 0x2b29)],
},
new()
{
Instructions = new ushort[] { 0xf826, 0x1cdf, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002232, 0x000029a1, 0x00002938, 0x00002ae7, 0x000029a4, 0x00002366, 0x0000273a, 0x000023f6, 0x00002601, 0x00002919, 0x000028e3, 0x00002907, 0x000023c1, 0x00002138, 0x00000001, 0x100001f0 },
FinalRegs = new uint[] { 0x00002232, 0x000029a1, 0x00002938, 0x00002ae7, 0x000029a4, 0x00002366, 0x0000273a, 0x000023f6, 0x00002601, 0x00002919, 0x000028e3, 0x00002907, 0x000023c1, 0x00002138, 0x00000001, 0x100001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x265a, Value: 0xa15a), (Address: 0x265c, Value: 0x2629) },
Instructions = [0xf826, 0x1cdf, 0x4770, 0xe7fe],
StartRegs = [0x00002232, 0x000029a1, 0x00002938, 0x00002ae7, 0x000029a4, 0x00002366, 0x0000273a, 0x000023f6, 0x00002601, 0x00002919, 0x000028e3, 0x00002907, 0x000023c1, 0x00002138, 0x00000001, 0x100001f0
],
FinalRegs = [0x00002232, 0x000029a1, 0x00002938, 0x00002ae7, 0x000029a4, 0x00002366, 0x0000273a, 0x000023f6, 0x00002601, 0x00002919, 0x000028e3, 0x00002907, 0x000023c1, 0x00002138, 0x00000001, 0x100001f0
],
MemoryDelta = [(Address: 0x265a, Value: 0xa15a), (Address: 0x265c, Value: 0x2629)],
},
new()
{
Instructions = new ushort[] { 0xf82b, 0x3c66, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002974, 0x00002372, 0x0000276c, 0x000021df, 0x00002272, 0x00002928, 0x00002c50, 0x0000290e, 0x00002319, 0x000021d1, 0x00002a82, 0x000027ff, 0x00002730, 0x000027b2, 0x00000001, 0x700001f0 },
FinalRegs = new uint[] { 0x00002974, 0x00002372, 0x0000276c, 0x000021df, 0x00002272, 0x00002928, 0x00002c50, 0x0000290e, 0x00002319, 0x000021d1, 0x00002a82, 0x000027ff, 0x00002730, 0x000027b2, 0x00000001, 0x700001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2798, Value: 0xdf98), (Address: 0x279a, Value: 0x2721) },
Instructions = [0xf82b, 0x3c66, 0x4770, 0xe7fe],
StartRegs = [0x00002974, 0x00002372, 0x0000276c, 0x000021df, 0x00002272, 0x00002928, 0x00002c50, 0x0000290e, 0x00002319, 0x000021d1, 0x00002a82, 0x000027ff, 0x00002730, 0x000027b2, 0x00000001, 0x700001f0
],
FinalRegs = [0x00002974, 0x00002372, 0x0000276c, 0x000021df, 0x00002272, 0x00002928, 0x00002c50, 0x0000290e, 0x00002319, 0x000021d1, 0x00002a82, 0x000027ff, 0x00002730, 0x000027b2, 0x00000001, 0x700001f0
],
MemoryDelta = [(Address: 0x2798, Value: 0xdf98), (Address: 0x279a, Value: 0x2721)],
},
new()
{
Instructions = new ushort[] { 0xf822, 0x3c06, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000021b8, 0x00002357, 0x00002b00, 0x00002207, 0x00002648, 0x0000219c, 0x000021d2, 0x000023b0, 0x00002368, 0x00002a41, 0x000026ac, 0x00002a86, 0x00002879, 0x00002c1d, 0x00000001, 0x700001f0 },
FinalRegs = new uint[] { 0x000021b8, 0x00002357, 0x00002b00, 0x00002207, 0x00002648, 0x0000219c, 0x000021d2, 0x000023b0, 0x00002368, 0x00002a41, 0x000026ac, 0x00002a86, 0x00002879, 0x00002c1d, 0x00000001, 0x700001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2afa, Value: 0x2207) },
Instructions = [0xf822, 0x3c06, 0x4770, 0xe7fe],
StartRegs = [0x000021b8, 0x00002357, 0x00002b00, 0x00002207, 0x00002648, 0x0000219c, 0x000021d2, 0x000023b0, 0x00002368, 0x00002a41, 0x000026ac, 0x00002a86, 0x00002879, 0x00002c1d, 0x00000001, 0x700001f0
],
FinalRegs = [0x000021b8, 0x00002357, 0x00002b00, 0x00002207, 0x00002648, 0x0000219c, 0x000021d2, 0x000023b0, 0x00002368, 0x00002a41, 0x000026ac, 0x00002a86, 0x00002879, 0x00002c1d, 0x00000001, 0x700001f0
],
MemoryDelta = [(Address: 0x2afa, Value: 0x2207)],
},
new()
{
Instructions = new ushort[] { 0xf824, 0xac84, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002796, 0x000027c8, 0x0000241b, 0x0000214d, 0x0000220b, 0x00002587, 0x00002130, 0x00002910, 0x00002ac2, 0x00002e74, 0x000028f8, 0x000024bf, 0x0000263a, 0x00002625, 0x00000001, 0x600001f0 },
FinalRegs = new uint[] { 0x00002796, 0x000027c8, 0x0000241b, 0x0000214d, 0x0000220b, 0x00002587, 0x00002130, 0x00002910, 0x00002ac2, 0x00002e74, 0x000028f8, 0x000024bf, 0x0000263a, 0x00002625, 0x00000001, 0x600001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2186, Value: 0xf886), (Address: 0x2188, Value: 0x2128) },
Instructions = [0xf824, 0xac84, 0x4770, 0xe7fe],
StartRegs = [0x00002796, 0x000027c8, 0x0000241b, 0x0000214d, 0x0000220b, 0x00002587, 0x00002130, 0x00002910, 0x00002ac2, 0x00002e74, 0x000028f8, 0x000024bf, 0x0000263a, 0x00002625, 0x00000001, 0x600001f0
],
FinalRegs = [0x00002796, 0x000027c8, 0x0000241b, 0x0000214d, 0x0000220b, 0x00002587, 0x00002130, 0x00002910, 0x00002ac2, 0x00002e74, 0x000028f8, 0x000024bf, 0x0000263a, 0x00002625, 0x00000001, 0x600001f0
],
MemoryDelta = [(Address: 0x2186, Value: 0xf886), (Address: 0x2188, Value: 0x2128)],
},
// STRH (imm12)
new()
{
Instructions = new ushort[] { 0xf8a5, 0x59d4, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x000001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x000001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x29d4, Value: 0x2000) },
Instructions = [0xf8a5, 0x59d4, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x000001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x000001f0
],
MemoryDelta = [(Address: 0x29d4, Value: 0x2000)],
},
new()
{
Instructions = new ushort[] { 0xf8ac, 0xc533, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2532, Value: 0x0032), (Address: 0x2534, Value: 0x2520) },
Instructions = [0xf8ac, 0xc533, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0
],
MemoryDelta = [(Address: 0x2532, Value: 0x0032), (Address: 0x2534, Value: 0x2520)],
},
new()
{
Instructions = new ushort[] { 0xf8a3, 0xb559, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x000001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x000001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2558, Value: 0x0058), (Address: 0x255a, Value: 0x2520) },
Instructions = [0xf8a3, 0xb559, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x000001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x000001f0
],
MemoryDelta = [(Address: 0x2558, Value: 0x0058), (Address: 0x255a, Value: 0x2520)],
},
new()
{
Instructions = new ushort[] { 0xf8a5, 0xdb3a, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xb00001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xb00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2b3a, Value: 0x2000) },
Instructions = [0xf8a5, 0xdb3a, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xb00001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xb00001f0
],
MemoryDelta = [(Address: 0x2b3a, Value: 0x2000)],
},
new()
{
Instructions = new ushort[] { 0xf8a9, 0x02cc, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xc00001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xc00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x22cc, Value: 0x2000) },
Instructions = [0xf8a9, 0x02cc, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xc00001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xc00001f0
],
MemoryDelta = [(Address: 0x22cc, Value: 0x2000)],
},
// STR (imm8)
new()
{
Instructions = new ushort[] { 0xf846, 0x1fb4, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002b17, 0x0000272f, 0x00002483, 0x0000284c, 0x0000287f, 0x0000238f, 0x0000222d, 0x00002259, 0x0000249d, 0x00002e3f, 0x00002323, 0x00002729, 0x000025c1, 0x00002866, 0x00000001, 0x900001f0 },
FinalRegs = new uint[] { 0x00002b17, 0x0000272f, 0x00002483, 0x0000284c, 0x0000287f, 0x0000238f, 0x000022e1, 0x00002259, 0x0000249d, 0x00002e3f, 0x00002323, 0x00002729, 0x000025c1, 0x00002866, 0x00000001, 0x900001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x22e0, Value: 0x2fe0), (Address: 0x22e2, Value: 0x0027), (Address: 0x22e4, Value: 0x2200) },
Instructions = [0xf846, 0x1fb4, 0x4770, 0xe7fe],
StartRegs = [0x00002b17, 0x0000272f, 0x00002483, 0x0000284c, 0x0000287f, 0x0000238f, 0x0000222d, 0x00002259, 0x0000249d, 0x00002e3f, 0x00002323, 0x00002729, 0x000025c1, 0x00002866, 0x00000001, 0x900001f0
],
FinalRegs = [0x00002b17, 0x0000272f, 0x00002483, 0x0000284c, 0x0000287f, 0x0000238f, 0x000022e1, 0x00002259, 0x0000249d, 0x00002e3f, 0x00002323, 0x00002729, 0x000025c1, 0x00002866, 0x00000001, 0x900001f0
],
MemoryDelta = [(Address: 0x22e0, Value: 0x2fe0), (Address: 0x22e2, Value: 0x0027), (Address: 0x22e4, Value: 0x2200)
],
},
new()
{
Instructions = new ushort[] { 0xf844, 0x3f11, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000028e1, 0x00002d48, 0x000027d6, 0x000023ac, 0x000027bb, 0x000026cf, 0x000023c1, 0x00002633, 0x0000214b, 0x00002434, 0x0000239a, 0x000025c6, 0x00002148, 0x00002d1f, 0x00000001, 0x300001f0 },
FinalRegs = new uint[] { 0x000028e1, 0x00002d48, 0x000027d6, 0x000023ac, 0x000027cc, 0x000026cf, 0x000023c1, 0x00002633, 0x0000214b, 0x00002434, 0x0000239a, 0x000025c6, 0x00002148, 0x00002d1f, 0x00000001, 0x300001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x27cc, Value: 0x23ac), (Address: 0x27ce, Value: 0x0000) },
Instructions = [0xf844, 0x3f11, 0x4770, 0xe7fe],
StartRegs = [0x000028e1, 0x00002d48, 0x000027d6, 0x000023ac, 0x000027bb, 0x000026cf, 0x000023c1, 0x00002633, 0x0000214b, 0x00002434, 0x0000239a, 0x000025c6, 0x00002148, 0x00002d1f, 0x00000001, 0x300001f0
],
FinalRegs = [0x000028e1, 0x00002d48, 0x000027d6, 0x000023ac, 0x000027cc, 0x000026cf, 0x000023c1, 0x00002633, 0x0000214b, 0x00002434, 0x0000239a, 0x000025c6, 0x00002148, 0x00002d1f, 0x00000001, 0x300001f0
],
MemoryDelta = [(Address: 0x27cc, Value: 0x23ac), (Address: 0x27ce, Value: 0x0000)],
},
new()
{
Instructions = new ushort[] { 0xf847, 0x09c2, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x0000248b, 0x00002396, 0x000023c5, 0x00002be0, 0x0000237d, 0x00002191, 0x00002da0, 0x0000211c, 0x00002d24, 0x000021e6, 0x000024ff, 0x00002268, 0x00002968, 0x0000244d, 0x00000001, 0x800001f0 },
FinalRegs = new uint[] { 0x0000248b, 0x00002396, 0x000023c5, 0x00002be0, 0x0000237d, 0x00002191, 0x00002da0, 0x0000205a, 0x00002d24, 0x000021e6, 0x000024ff, 0x00002268, 0x00002968, 0x0000244d, 0x00000001, 0x800001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x211c, Value: 0x248b), (Address: 0x211e, Value: 0x0000) },
Instructions = [0xf847, 0x09c2, 0x4770, 0xe7fe],
StartRegs = [0x0000248b, 0x00002396, 0x000023c5, 0x00002be0, 0x0000237d, 0x00002191, 0x00002da0, 0x0000211c, 0x00002d24, 0x000021e6, 0x000024ff, 0x00002268, 0x00002968, 0x0000244d, 0x00000001, 0x800001f0
],
FinalRegs = [0x0000248b, 0x00002396, 0x000023c5, 0x00002be0, 0x0000237d, 0x00002191, 0x00002da0, 0x0000205a, 0x00002d24, 0x000021e6, 0x000024ff, 0x00002268, 0x00002968, 0x0000244d, 0x00000001, 0x800001f0
],
MemoryDelta = [(Address: 0x211c, Value: 0x248b), (Address: 0x211e, Value: 0x0000)],
},
new()
{
Instructions = new ushort[] { 0xf84d, 0x7f23, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000025b0, 0x0000260e, 0x00002343, 0x00002e36, 0x000024c5, 0x000029bc, 0x0000278e, 0x00002b63, 0x00002ce7, 0x000029af, 0x000023bf, 0x00002475, 0x00002197, 0x00002c33, 0x00000001, 0x200001f0 },
FinalRegs = new uint[] { 0x000025b0, 0x0000260e, 0x00002343, 0x00002e36, 0x000024c5, 0x000029bc, 0x0000278e, 0x00002b63, 0x00002ce7, 0x000029af, 0x000023bf, 0x00002475, 0x00002197, 0x00002c56, 0x00000001, 0x200001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2c56, Value: 0x2b63), (Address: 0x2c58, Value: 0x0000) },
Instructions = [0xf84d, 0x7f23, 0x4770, 0xe7fe],
StartRegs = [0x000025b0, 0x0000260e, 0x00002343, 0x00002e36, 0x000024c5, 0x000029bc, 0x0000278e, 0x00002b63, 0x00002ce7, 0x000029af, 0x000023bf, 0x00002475, 0x00002197, 0x00002c33, 0x00000001, 0x200001f0
],
FinalRegs = [0x000025b0, 0x0000260e, 0x00002343, 0x00002e36, 0x000024c5, 0x000029bc, 0x0000278e, 0x00002b63, 0x00002ce7, 0x000029af, 0x000023bf, 0x00002475, 0x00002197, 0x00002c56, 0x00000001, 0x200001f0
],
MemoryDelta = [(Address: 0x2c56, Value: 0x2b63), (Address: 0x2c58, Value: 0x0000)],
},
new()
{
Instructions = new ushort[] { 0xf843, 0x9d24, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002ce4, 0x00002e0e, 0x000026d5, 0x000025fb, 0x00002b78, 0x0000215a, 0x00002af7, 0x0000259c, 0x00002645, 0x000027dc, 0x00002163, 0x000028f5, 0x000029df, 0x0000230b, 0x00000001, 0x500001f0 },
FinalRegs = new uint[] { 0x00002ce4, 0x00002e0e, 0x000026d5, 0x000025d7, 0x00002b78, 0x0000215a, 0x00002af7, 0x0000259c, 0x00002645, 0x000027dc, 0x00002163, 0x000028f5, 0x000029df, 0x0000230b, 0x00000001, 0x500001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x25d6, Value: 0xdcd6), (Address: 0x25d8, Value: 0x0027), (Address: 0x25da, Value: 0x2500) },
Instructions = [0xf843, 0x9d24, 0x4770, 0xe7fe],
StartRegs = [0x00002ce4, 0x00002e0e, 0x000026d5, 0x000025fb, 0x00002b78, 0x0000215a, 0x00002af7, 0x0000259c, 0x00002645, 0x000027dc, 0x00002163, 0x000028f5, 0x000029df, 0x0000230b, 0x00000001, 0x500001f0
],
FinalRegs = [0x00002ce4, 0x00002e0e, 0x000026d5, 0x000025d7, 0x00002b78, 0x0000215a, 0x00002af7, 0x0000259c, 0x00002645, 0x000027dc, 0x00002163, 0x000028f5, 0x000029df, 0x0000230b, 0x00000001, 0x500001f0
],
MemoryDelta = [(Address: 0x25d6, Value: 0xdcd6), (Address: 0x25d8, Value: 0x0027), (Address: 0x25da, Value: 0x2500)
],
},
new()
{
Instructions = new ushort[] { 0xf849, 0xdc1a, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002d98, 0x0000254a, 0x00002540, 0x00002324, 0x0000264e, 0x00002523, 0x0000271f, 0x00002875, 0x000023b3, 0x00002680, 0x00002223, 0x000022bf, 0x000025f4, 0x00002d81, 0x00000001, 0x700001f0 },
FinalRegs = new uint[] { 0x00002d98, 0x0000254a, 0x00002540, 0x00002324, 0x0000264e, 0x00002523, 0x0000271f, 0x00002875, 0x000023b3, 0x00002680, 0x00002223, 0x000022bf, 0x000025f4, 0x00002d81, 0x00000001, 0x700001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2666, Value: 0x2d81), (Address: 0x2668, Value: 0x0000) },
Instructions = [0xf849, 0xdc1a, 0x4770, 0xe7fe],
StartRegs = [0x00002d98, 0x0000254a, 0x00002540, 0x00002324, 0x0000264e, 0x00002523, 0x0000271f, 0x00002875, 0x000023b3, 0x00002680, 0x00002223, 0x000022bf, 0x000025f4, 0x00002d81, 0x00000001, 0x700001f0
],
FinalRegs = [0x00002d98, 0x0000254a, 0x00002540, 0x00002324, 0x0000264e, 0x00002523, 0x0000271f, 0x00002875, 0x000023b3, 0x00002680, 0x00002223, 0x000022bf, 0x000025f4, 0x00002d81, 0x00000001, 0x700001f0
],
MemoryDelta = [(Address: 0x2666, Value: 0x2d81), (Address: 0x2668, Value: 0x0000)],
},
new()
{
Instructions = new ushort[] { 0xf849, 0x0cd1, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x0000255a, 0x00002655, 0x00002276, 0x000022e4, 0x00002eef, 0x00002e99, 0x00002b55, 0x00002a40, 0x00002661, 0x00002dbd, 0x00002687, 0x000024e1, 0x000023ea, 0x00002b88, 0x00000001, 0xc00001f0 },
FinalRegs = new uint[] { 0x0000255a, 0x00002655, 0x00002276, 0x000022e4, 0x00002eef, 0x00002e99, 0x00002b55, 0x00002a40, 0x00002661, 0x00002dbd, 0x00002687, 0x000024e1, 0x000023ea, 0x00002b88, 0x00000001, 0xc00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2cec, Value: 0x255a), (Address: 0x2cee, Value: 0x0000) },
Instructions = [0xf849, 0x0cd1, 0x4770, 0xe7fe],
StartRegs = [0x0000255a, 0x00002655, 0x00002276, 0x000022e4, 0x00002eef, 0x00002e99, 0x00002b55, 0x00002a40, 0x00002661, 0x00002dbd, 0x00002687, 0x000024e1, 0x000023ea, 0x00002b88, 0x00000001, 0xc00001f0
],
FinalRegs = [0x0000255a, 0x00002655, 0x00002276, 0x000022e4, 0x00002eef, 0x00002e99, 0x00002b55, 0x00002a40, 0x00002661, 0x00002dbd, 0x00002687, 0x000024e1, 0x000023ea, 0x00002b88, 0x00000001, 0xc00001f0
],
MemoryDelta = [(Address: 0x2cec, Value: 0x255a), (Address: 0x2cee, Value: 0x0000)],
},
new()
{
Instructions = new ushort[] { 0xf847, 0x7c96, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000027f6, 0x0000222a, 0x000024e1, 0x00002a2d, 0x00002ee8, 0x000023f2, 0x000029de, 0x00002a53, 0x000029da, 0x00002d2c, 0x00002d6f, 0x000026b8, 0x00002777, 0x00002e3a, 0x00000001, 0xf00001f0 },
FinalRegs = new uint[] { 0x000027f6, 0x0000222a, 0x000024e1, 0x00002a2d, 0x00002ee8, 0x000023f2, 0x000029de, 0x00002a53, 0x000029da, 0x00002d2c, 0x00002d6f, 0x000026b8, 0x00002777, 0x00002e3a, 0x00000001, 0xf00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x29bc, Value: 0x53bc), (Address: 0x29be, Value: 0x002a), (Address: 0x29c0, Value: 0x2900) },
Instructions = [0xf847, 0x7c96, 0x4770, 0xe7fe],
StartRegs = [0x000027f6, 0x0000222a, 0x000024e1, 0x00002a2d, 0x00002ee8, 0x000023f2, 0x000029de, 0x00002a53, 0x000029da, 0x00002d2c, 0x00002d6f, 0x000026b8, 0x00002777, 0x00002e3a, 0x00000001, 0xf00001f0
],
FinalRegs = [0x000027f6, 0x0000222a, 0x000024e1, 0x00002a2d, 0x00002ee8, 0x000023f2, 0x000029de, 0x00002a53, 0x000029da, 0x00002d2c, 0x00002d6f, 0x000026b8, 0x00002777, 0x00002e3a, 0x00000001, 0xf00001f0
],
MemoryDelta = [(Address: 0x29bc, Value: 0x53bc), (Address: 0x29be, Value: 0x002a), (Address: 0x29c0, Value: 0x2900)
],
},
new()
{
Instructions = new ushort[] { 0xf84d, 0x8cbd, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002a58, 0x00002a59, 0x00002dfd, 0x00002ba8, 0x00002929, 0x00002146, 0x00002706, 0x000025f3, 0x000023d7, 0x0000221f, 0x000027ae, 0x00002a6e, 0x00002824, 0x00002357, 0x00000001, 0x600001f0 },
FinalRegs = new uint[] { 0x00002a58, 0x00002a59, 0x00002dfd, 0x00002ba8, 0x00002929, 0x00002146, 0x00002706, 0x000025f3, 0x000023d7, 0x0000221f, 0x000027ae, 0x00002a6e, 0x00002824, 0x00002357, 0x00000001, 0x600001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x229a, Value: 0x23d7), (Address: 0x229c, Value: 0x0000) },
Instructions = [0xf84d, 0x8cbd, 0x4770, 0xe7fe],
StartRegs = [0x00002a58, 0x00002a59, 0x00002dfd, 0x00002ba8, 0x00002929, 0x00002146, 0x00002706, 0x000025f3, 0x000023d7, 0x0000221f, 0x000027ae, 0x00002a6e, 0x00002824, 0x00002357, 0x00000001, 0x600001f0
],
FinalRegs = [0x00002a58, 0x00002a59, 0x00002dfd, 0x00002ba8, 0x00002929, 0x00002146, 0x00002706, 0x000025f3, 0x000023d7, 0x0000221f, 0x000027ae, 0x00002a6e, 0x00002824, 0x00002357, 0x00000001, 0x600001f0
],
MemoryDelta = [(Address: 0x229a, Value: 0x23d7), (Address: 0x229c, Value: 0x0000)],
},
new()
{
Instructions = new ushort[] { 0xf846, 0xacaf, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x0000284f, 0x00002def, 0x0000292f, 0x000021e8, 0x0000274e, 0x00002518, 0x00002538, 0x00002375, 0x00002d28, 0x0000229a, 0x0000255f, 0x00002eca, 0x00002e15, 0x000021aa, 0x00000001, 0x100001f0 },
FinalRegs = new uint[] { 0x0000284f, 0x00002def, 0x0000292f, 0x000021e8, 0x0000274e, 0x00002518, 0x00002538, 0x00002375, 0x00002d28, 0x0000229a, 0x0000255f, 0x00002eca, 0x00002e15, 0x000021aa, 0x00000001, 0x100001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2488, Value: 0x5f88), (Address: 0x248a, Value: 0x0025), (Address: 0x248c, Value: 0x2400) },
Instructions = [0xf846, 0xacaf, 0x4770, 0xe7fe],
StartRegs = [0x0000284f, 0x00002def, 0x0000292f, 0x000021e8, 0x0000274e, 0x00002518, 0x00002538, 0x00002375, 0x00002d28, 0x0000229a, 0x0000255f, 0x00002eca, 0x00002e15, 0x000021aa, 0x00000001, 0x100001f0
],
FinalRegs = [0x0000284f, 0x00002def, 0x0000292f, 0x000021e8, 0x0000274e, 0x00002518, 0x00002538, 0x00002375, 0x00002d28, 0x0000229a, 0x0000255f, 0x00002eca, 0x00002e15, 0x000021aa, 0x00000001, 0x100001f0
],
MemoryDelta = [(Address: 0x2488, Value: 0x5f88), (Address: 0x248a, Value: 0x0025), (Address: 0x248c, Value: 0x2400)
],
},
// STR (imm12)
new()
{
Instructions = new ushort[] { 0xf8cc, 0x1a6e, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2a6e, Value: 0x2000), (Address: 0x2a70, Value: 0x0000) },
Instructions = [0xf8cc, 0x1a6e, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0
],
MemoryDelta = [(Address: 0x2a6e, Value: 0x2000), (Address: 0x2a70, Value: 0x0000)],
},
new()
{
Instructions = new ushort[] { 0xf8c9, 0xcfc1, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x2fc0, Value: 0x00c0), (Address: 0x2fc2, Value: 0x0020), (Address: 0x2fc4, Value: 0x2f00) },
Instructions = [0xf8c9, 0xcfc1, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0
],
MemoryDelta = [(Address: 0x2fc0, Value: 0x00c0), (Address: 0x2fc2, Value: 0x0020), (Address: 0x2fc4, Value: 0x2f00)
],
},
new()
{
Instructions = new ushort[] { 0xf8c3, 0xb5dd, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x600001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x600001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x25dc, Value: 0x00dc), (Address: 0x25de, Value: 0x0020), (Address: 0x25e0, Value: 0x2500) },
Instructions = [0xf8c3, 0xb5dd, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x600001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x600001f0
],
MemoryDelta = [(Address: 0x25dc, Value: 0x00dc), (Address: 0x25de, Value: 0x0020), (Address: 0x25e0, Value: 0x2500)
],
},
new()
{
Instructions = new ushort[] { 0xf8c0, 0x69e9, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x29e8, Value: 0x00e8), (Address: 0x29ea, Value: 0x0020), (Address: 0x29ec, Value: 0x2900) },
Instructions = [0xf8c0, 0x69e9, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xe00001f0
],
MemoryDelta = [(Address: 0x29e8, Value: 0x00e8), (Address: 0x29ea, Value: 0x0020), (Address: 0x29ec, Value: 0x2900)
],
},
new()
{
Instructions = new ushort[] { 0xf8cd, 0x028f, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x600001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x600001f0 },
MemoryDelta = new (ulong Address, ushort Value)[] { (Address: 0x228e, Value: 0x008e), (Address: 0x2290, Value: 0x0020), (Address: 0x2292, Value: 0x2200) },
Instructions = [0xf8cd, 0x028f, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x600001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x600001f0
],
MemoryDelta = [(Address: 0x228e, Value: 0x008e), (Address: 0x2290, Value: 0x0020), (Address: 0x2292, Value: 0x2200)
],
},
// LDRB (imm8)
new()
{
Instructions = new ushort[] { 0xf816, 0x1c48, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002cb8, 0x00002345, 0x00002ebc, 0x00002db8, 0x000021d4, 0x000026e4, 0x00002458, 0x000029e3, 0x000028d2, 0x000027f4, 0x000023d6, 0x00002def, 0x0000285c, 0x00002d06, 0x00000001, 0x600001f0 },
FinalRegs = new uint[] { 0x00002cb8, 0x00000010, 0x00002ebc, 0x00002db8, 0x000021d4, 0x000026e4, 0x00002458, 0x000029e3, 0x000028d2, 0x000027f4, 0x000023d6, 0x00002def, 0x0000285c, 0x00002d06, 0x00000001, 0x600001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf816, 0x1c48, 0x4770, 0xe7fe],
StartRegs = [0x00002cb8, 0x00002345, 0x00002ebc, 0x00002db8, 0x000021d4, 0x000026e4, 0x00002458, 0x000029e3, 0x000028d2, 0x000027f4, 0x000023d6, 0x00002def, 0x0000285c, 0x00002d06, 0x00000001, 0x600001f0
],
FinalRegs = [0x00002cb8, 0x00000010, 0x00002ebc, 0x00002db8, 0x000021d4, 0x000026e4, 0x00002458, 0x000029e3, 0x000028d2, 0x000027f4, 0x000023d6, 0x00002def, 0x0000285c, 0x00002d06, 0x00000001, 0x600001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf815, 0x2d6e, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000021e4, 0x00002425, 0x00002e42, 0x00002a58, 0x00002708, 0x00002965, 0x00002a1d, 0x00002ed5, 0x00002cc4, 0x000026e1, 0x00002b4b, 0x00002ade, 0x00002824, 0x00002975, 0x00000001, 0x100001f0 },
FinalRegs = new uint[] { 0x000021e4, 0x00002425, 0x00000028, 0x00002a58, 0x00002708, 0x000028f7, 0x00002a1d, 0x00002ed5, 0x00002cc4, 0x000026e1, 0x00002b4b, 0x00002ade, 0x00002824, 0x00002975, 0x00000001, 0x100001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf815, 0x2d6e, 0x4770, 0xe7fe],
StartRegs = [0x000021e4, 0x00002425, 0x00002e42, 0x00002a58, 0x00002708, 0x00002965, 0x00002a1d, 0x00002ed5, 0x00002cc4, 0x000026e1, 0x00002b4b, 0x00002ade, 0x00002824, 0x00002975, 0x00000001, 0x100001f0
],
FinalRegs = [0x000021e4, 0x00002425, 0x00000028, 0x00002a58, 0x00002708, 0x000028f7, 0x00002a1d, 0x00002ed5, 0x00002cc4, 0x000026e1, 0x00002b4b, 0x00002ade, 0x00002824, 0x00002975, 0x00000001, 0x100001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf818, 0x0d33, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002492, 0x0000214d, 0x00002827, 0x000021af, 0x0000215e, 0x000028d6, 0x000024ec, 0x00002984, 0x0000297b, 0x000024b5, 0x000024ca, 0x0000298f, 0x00002339, 0x00002b7e, 0x00000001, 0xd00001f0 },
FinalRegs = new uint[] { 0x00000048, 0x0000214d, 0x00002827, 0x000021af, 0x0000215e, 0x000028d6, 0x000024ec, 0x00002984, 0x00002948, 0x000024b5, 0x000024ca, 0x0000298f, 0x00002339, 0x00002b7e, 0x00000001, 0xd00001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf818, 0x0d33, 0x4770, 0xe7fe],
StartRegs = [0x00002492, 0x0000214d, 0x00002827, 0x000021af, 0x0000215e, 0x000028d6, 0x000024ec, 0x00002984, 0x0000297b, 0x000024b5, 0x000024ca, 0x0000298f, 0x00002339, 0x00002b7e, 0x00000001, 0xd00001f0
],
FinalRegs = [0x00000048, 0x0000214d, 0x00002827, 0x000021af, 0x0000215e, 0x000028d6, 0x000024ec, 0x00002984, 0x00002948, 0x000024b5, 0x000024ca, 0x0000298f, 0x00002339, 0x00002b7e, 0x00000001, 0xd00001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf810, 0xbff3, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002ea6, 0x000024fa, 0x00002346, 0x00002748, 0x0000283f, 0x00002770, 0x000023e3, 0x000021aa, 0x0000214a, 0x00002d58, 0x00002159, 0x000022e7, 0x00002242, 0x00002728, 0x00000001, 0x600001f0 },
FinalRegs = new uint[] { 0x00002f99, 0x000024fa, 0x00002346, 0x00002748, 0x0000283f, 0x00002770, 0x000023e3, 0x000021aa, 0x0000214a, 0x00002d58, 0x00002159, 0x0000002f, 0x00002242, 0x00002728, 0x00000001, 0x600001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf810, 0xbff3, 0x4770, 0xe7fe],
StartRegs = [0x00002ea6, 0x000024fa, 0x00002346, 0x00002748, 0x0000283f, 0x00002770, 0x000023e3, 0x000021aa, 0x0000214a, 0x00002d58, 0x00002159, 0x000022e7, 0x00002242, 0x00002728, 0x00000001, 0x600001f0
],
FinalRegs = [0x00002f99, 0x000024fa, 0x00002346, 0x00002748, 0x0000283f, 0x00002770, 0x000023e3, 0x000021aa, 0x0000214a, 0x00002d58, 0x00002159, 0x0000002f, 0x00002242, 0x00002728, 0x00000001, 0x600001f0
],
MemoryDelta = [],
},
// LDRB (imm12)
new()
{
Instructions = new ushort[] { 0xf892, 0xcc8f, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x100001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x0000002c, 0x00002000, 0x00000001, 0x100001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf892, 0xcc8f, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x100001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x0000002c, 0x00002000, 0x00000001, 0x100001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf89a, 0x7fdc, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x200001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x000000dc, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x200001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf89a, 0x7fdc, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x200001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x000000dc, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x200001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf890, 0x5f9f, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x800001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x0000002f, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x800001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf890, 0x5f9f, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x800001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x0000002f, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x800001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf894, 0xdda1, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x900001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x0000002d, 0x00000001, 0x900001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf894, 0xdda1, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x900001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x0000002d, 0x00000001, 0x900001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf890, 0xc281, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x100001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000022, 0x00002000, 0x00000001, 0x100001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf890, 0xc281, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x100001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000022, 0x00002000, 0x00000001, 0x100001f0
],
MemoryDelta = [],
},
// LDRH (imm8)
new()
{
Instructions = new ushort[] { 0xf834, 0x89d8, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002a9e, 0x00002d84, 0x00002e9b, 0x00002e7f, 0x000024a2, 0x00002b7b, 0x00002e3b, 0x0000299a, 0x00002dff, 0x00002a9e, 0x000027b2, 0x00002a90, 0x00002883, 0x0000288d, 0x00000001, 0x500001f0 },
FinalRegs = new uint[] { 0x00002a9e, 0x00002d84, 0x00002e9b, 0x00002e7f, 0x000023ca, 0x00002b7b, 0x00002e3b, 0x0000299a, 0x000024a2, 0x00002a9e, 0x000027b2, 0x00002a90, 0x00002883, 0x0000288d, 0x00000001, 0x500001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf834, 0x89d8, 0x4770, 0xe7fe],
StartRegs = [0x00002a9e, 0x00002d84, 0x00002e9b, 0x00002e7f, 0x000024a2, 0x00002b7b, 0x00002e3b, 0x0000299a, 0x00002dff, 0x00002a9e, 0x000027b2, 0x00002a90, 0x00002883, 0x0000288d, 0x00000001, 0x500001f0
],
FinalRegs = [0x00002a9e, 0x00002d84, 0x00002e9b, 0x00002e7f, 0x000023ca, 0x00002b7b, 0x00002e3b, 0x0000299a, 0x000024a2, 0x00002a9e, 0x000027b2, 0x00002a90, 0x00002883, 0x0000288d, 0x00000001, 0x500001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf833, 0x6be4, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000028bd, 0x00002b0e, 0x00002bc1, 0x00002a83, 0x00002293, 0x00002c7c, 0x00002bfe, 0x00002eb7, 0x0000299b, 0x000026e6, 0x0000219c, 0x00002d5e, 0x00002cd4, 0x000026cf, 0x00000001, 0xd00001f0 },
FinalRegs = new uint[] { 0x000028bd, 0x00002b0e, 0x00002bc1, 0x00002b67, 0x00002293, 0x00002c7c, 0x0000842a, 0x00002eb7, 0x0000299b, 0x000026e6, 0x0000219c, 0x00002d5e, 0x00002cd4, 0x000026cf, 0x00000001, 0xd00001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf833, 0x6be4, 0x4770, 0xe7fe],
StartRegs = [0x000028bd, 0x00002b0e, 0x00002bc1, 0x00002a83, 0x00002293, 0x00002c7c, 0x00002bfe, 0x00002eb7, 0x0000299b, 0x000026e6, 0x0000219c, 0x00002d5e, 0x00002cd4, 0x000026cf, 0x00000001, 0xd00001f0
],
FinalRegs = [0x000028bd, 0x00002b0e, 0x00002bc1, 0x00002b67, 0x00002293, 0x00002c7c, 0x0000842a, 0x00002eb7, 0x0000299b, 0x000026e6, 0x0000219c, 0x00002d5e, 0x00002cd4, 0x000026cf, 0x00000001, 0xd00001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf83d, 0x1bca, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x0000250e, 0x00002776, 0x000029e5, 0x0000276e, 0x00002c6b, 0x00002712, 0x00002a85, 0x00002d56, 0x000024c0, 0x00002d86, 0x0000254a, 0x00002549, 0x00002795, 0x00002e97, 0x00000001, 0x200001f0 },
FinalRegs = new uint[] { 0x0000250e, 0x0000982e, 0x000029e5, 0x0000276e, 0x00002c6b, 0x00002712, 0x00002a85, 0x00002d56, 0x000024c0, 0x00002d86, 0x0000254a, 0x00002549, 0x00002795, 0x00002f61, 0x00000001, 0x200001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf83d, 0x1bca, 0x4770, 0xe7fe],
StartRegs = [0x0000250e, 0x00002776, 0x000029e5, 0x0000276e, 0x00002c6b, 0x00002712, 0x00002a85, 0x00002d56, 0x000024c0, 0x00002d86, 0x0000254a, 0x00002549, 0x00002795, 0x00002e97, 0x00000001, 0x200001f0
],
FinalRegs = [0x0000250e, 0x0000982e, 0x000029e5, 0x0000276e, 0x00002c6b, 0x00002712, 0x00002a85, 0x00002d56, 0x000024c0, 0x00002d86, 0x0000254a, 0x00002549, 0x00002795, 0x00002f61, 0x00000001, 0x200001f0
],
MemoryDelta = [],
},
// LDRH (imm12)
new()
{
Instructions = new ushort[] { 0xf8b7, 0x92fc, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xa00001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x000022fc, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xa00001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf8b7, 0x92fc, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xa00001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x000022fc, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xa00001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf8ba, 0xadd9, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xa00001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x0000da2d, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xa00001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf8ba, 0xadd9, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xa00001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x0000da2d, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xa00001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf8bb, 0x0bb0, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xd00001f0 },
FinalRegs = new uint[] { 0x00002bb0, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xd00001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf8bb, 0x0bb0, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xd00001f0
],
FinalRegs = [0x00002bb0, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0xd00001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf8b8, 0xc3f8, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x600001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x000023f8, 0x00002000, 0x00000001, 0x600001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf8b8, 0xc3f8, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x600001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x000023f8, 0x00002000, 0x00000001, 0x600001f0
],
MemoryDelta = [],
},
// LDR (imm8)
new()
{
Instructions = new ushort[] { 0xf85b, 0x3fd1, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002a19, 0x00002e5b, 0x0000231b, 0x000021fa, 0x00002e95, 0x00002bd5, 0x00002e9c, 0x00002dfa, 0x000021d8, 0x00002ce1, 0x00002318, 0x00002735, 0x0000247d, 0x00002436, 0x00000001, 0xf00001f0 },
FinalRegs = new uint[] { 0x00002a19, 0x00002e5b, 0x0000231b, 0x28082806, 0x00002e95, 0x00002bd5, 0x00002e9c, 0x00002dfa, 0x000021d8, 0x00002ce1, 0x00002318, 0x00002806, 0x0000247d, 0x00002436, 0x00000001, 0xf00001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf85b, 0x3fd1, 0x4770, 0xe7fe],
StartRegs = [0x00002a19, 0x00002e5b, 0x0000231b, 0x000021fa, 0x00002e95, 0x00002bd5, 0x00002e9c, 0x00002dfa, 0x000021d8, 0x00002ce1, 0x00002318, 0x00002735, 0x0000247d, 0x00002436, 0x00000001, 0xf00001f0
],
FinalRegs = [0x00002a19, 0x00002e5b, 0x0000231b, 0x28082806, 0x00002e95, 0x00002bd5, 0x00002e9c, 0x00002dfa, 0x000021d8, 0x00002ce1, 0x00002318, 0x00002806, 0x0000247d, 0x00002436, 0x00000001, 0xf00001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf854, 0xab9e, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x0000214f, 0x00002578, 0x00002a98, 0x000021b0, 0x00002ebb, 0x0000284a, 0x00002319, 0x00002581, 0x00002179, 0x00002594, 0x00002373, 0x000028f4, 0x00002ec5, 0x00002e0a, 0x00000001, 0xb00001f0 },
FinalRegs = new uint[] { 0x0000214f, 0x00002578, 0x00002a98, 0x000021b0, 0x00002f59, 0x0000284a, 0x00002319, 0x00002581, 0x00002179, 0x00002594, 0xbe2ebc2e, 0x000028f4, 0x00002ec5, 0x00002e0a, 0x00000001, 0xb00001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf854, 0xab9e, 0x4770, 0xe7fe],
StartRegs = [0x0000214f, 0x00002578, 0x00002a98, 0x000021b0, 0x00002ebb, 0x0000284a, 0x00002319, 0x00002581, 0x00002179, 0x00002594, 0x00002373, 0x000028f4, 0x00002ec5, 0x00002e0a, 0x00000001, 0xb00001f0
],
FinalRegs = [0x0000214f, 0x00002578, 0x00002a98, 0x000021b0, 0x00002f59, 0x0000284a, 0x00002319, 0x00002581, 0x00002179, 0x00002594, 0xbe2ebc2e, 0x000028f4, 0x00002ec5, 0x00002e0a, 0x00000001, 0xb00001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf852, 0x6d2d, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002e27, 0x00002676, 0x00002bde, 0x000022d9, 0x00002362, 0x00002d4b, 0x00002dab, 0x000022b6, 0x0000229c, 0x00002507, 0x00002848, 0x0000225f, 0x00002ac2, 0x000023c3, 0x00000001, 0xf00001f0 },
FinalRegs = new uint[] { 0x00002e27, 0x00002676, 0x00002bb1, 0x000022d9, 0x00002362, 0x00002d4b, 0xb42bb22b, 0x000022b6, 0x0000229c, 0x00002507, 0x00002848, 0x0000225f, 0x00002ac2, 0x000023c3, 0x00000001, 0xf00001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf852, 0x6d2d, 0x4770, 0xe7fe],
StartRegs = [0x00002e27, 0x00002676, 0x00002bde, 0x000022d9, 0x00002362, 0x00002d4b, 0x00002dab, 0x000022b6, 0x0000229c, 0x00002507, 0x00002848, 0x0000225f, 0x00002ac2, 0x000023c3, 0x00000001, 0xf00001f0
],
FinalRegs = [0x00002e27, 0x00002676, 0x00002bb1, 0x000022d9, 0x00002362, 0x00002d4b, 0xb42bb22b, 0x000022b6, 0x0000229c, 0x00002507, 0x00002848, 0x0000225f, 0x00002ac2, 0x000023c3, 0x00000001, 0xf00001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf850, 0x8da5, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002559, 0x0000285e, 0x000021de, 0x00002223, 0x000023ff, 0x00002e05, 0x00002bf3, 0x000024a5, 0x00002124, 0x00002768, 0x00002a14, 0x0000219e, 0x00002739, 0x00002e3c, 0x00000001, 0xd00001f0 },
FinalRegs = new uint[] { 0x000024b4, 0x0000285e, 0x000021de, 0x00002223, 0x000023ff, 0x00002e05, 0x00002bf3, 0x000024a5, 0x24b624b4, 0x00002768, 0x00002a14, 0x0000219e, 0x00002739, 0x00002e3c, 0x00000001, 0xd00001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf850, 0x8da5, 0x4770, 0xe7fe],
StartRegs = [0x00002559, 0x0000285e, 0x000021de, 0x00002223, 0x000023ff, 0x00002e05, 0x00002bf3, 0x000024a5, 0x00002124, 0x00002768, 0x00002a14, 0x0000219e, 0x00002739, 0x00002e3c, 0x00000001, 0xd00001f0
],
FinalRegs = [0x000024b4, 0x0000285e, 0x000021de, 0x00002223, 0x000023ff, 0x00002e05, 0x00002bf3, 0x000024a5, 0x24b624b4, 0x00002768, 0x00002a14, 0x0000219e, 0x00002739, 0x00002e3c, 0x00000001, 0xd00001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf857, 0x19f6, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x000027f5, 0x0000285e, 0x000025f6, 0x00002e22, 0x00002224, 0x00002870, 0x00002ecc, 0x000024cf, 0x00002711, 0x0000241b, 0x00002ddf, 0x00002545, 0x000028ca, 0x000023c5, 0x00000001, 0x400001f0 },
FinalRegs = new uint[] { 0x000027f5, 0xd224d024, 0x000025f6, 0x00002e22, 0x00002224, 0x00002870, 0x00002ecc, 0x000023d9, 0x00002711, 0x0000241b, 0x00002ddf, 0x00002545, 0x000028ca, 0x000023c5, 0x00000001, 0x400001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf857, 0x19f6, 0x4770, 0xe7fe],
StartRegs = [0x000027f5, 0x0000285e, 0x000025f6, 0x00002e22, 0x00002224, 0x00002870, 0x00002ecc, 0x000024cf, 0x00002711, 0x0000241b, 0x00002ddf, 0x00002545, 0x000028ca, 0x000023c5, 0x00000001, 0x400001f0
],
FinalRegs = [0x000027f5, 0xd224d024, 0x000025f6, 0x00002e22, 0x00002224, 0x00002870, 0x00002ecc, 0x000023d9, 0x00002711, 0x0000241b, 0x00002ddf, 0x00002545, 0x000028ca, 0x000023c5, 0x00000001, 0x400001f0
],
MemoryDelta = [],
},
// LDR (imm12)
new()
{
Instructions = new ushort[] { 0xf8d1, 0xc65e, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x000001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x2660265e, 0x00002000, 0x00000001, 0x000001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf8d1, 0xc65e, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x000001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x2660265e, 0x00002000, 0x00000001, 0x000001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf8db, 0xd09b, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x800001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x9e209c20, 0x00000001, 0x800001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf8db, 0xd09b, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x800001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x9e209c20, 0x00000001, 0x800001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf8d2, 0x6fde, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x900001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x2fe02fde, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x900001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
Instructions = [0xf8d2, 0x6fde, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x900001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x2fe02fde, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x900001f0
],
MemoryDelta = [],
},
new()
{
Instructions = new ushort[] { 0xf8dc, 0x3de5, 0x4770, 0xe7fe },
StartRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0 },
FinalRegs = new uint[] { 0x00002000, 0x00002000, 0x00002000, 0xe82de62d, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0 },
MemoryDelta = Array.Empty<(ulong Address, ushort Value)>(),
},
};
Instructions = [0xf8dc, 0x3de5, 0x4770, 0xe7fe],
StartRegs = [0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0
],
FinalRegs = [0x00002000, 0x00002000, 0x00002000, 0xe82de62d, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00002000, 0x00000001, 0x500001f0
],
MemoryDelta = [],
}
];
}
}

906
src/Ryujinx.Tests/Cpu/CpuTestThumb.cs
View file

File diff suppressed because one or more lines are too long

7
src/Ryujinx.Tests/HLE/SoftwareKeyboardTests.cs
View file

@ -21,7 +21,8 @@ namespace Ryujinx.Tests.HLE
[Test]
public void StripUnicodeControlCodes_Passthrough()
{
string[] prompts = {
string[] prompts =
[
"Please name him.",
"Name her, too.",
"Name your friend.",
@ -29,8 +30,8 @@ namespace Ryujinx.Tests.HLE
"Name your pet.",
"Favorite homemade food?",
"What’s your favorite thing?",
"Are you sure?",
};
"Are you sure?"
];
foreach (string prompt in prompts)
{

2
src/Ryujinx.Tests/Memory/PartialUnmaps.cs
View file

@ -377,7 +377,7 @@ namespace Ryujinx.Tests.Memory
public void NativeReaderWriterLock()
{
NativeReaderWriterLock rwLock = new();
List<Thread> threads = new();
List<Thread> threads = [];
int value = 0;

3
src/Ryujinx/Updater.cs
View file

@ -434,7 +434,8 @@ namespace Ryujinx.Ava
// On macOS, ensure that we remove the quarantine bit to prevent Gatekeeper from blocking execution.
if (OperatingSystem.IsMacOS())
{
using Process xattrProcess = Process.Start("xattr", new List<string> { "-d", "com.apple.quarantine", updateFile });
using Process xattrProcess = Process.Start("xattr",
[ "-d", "com.apple.quarantine", updateFile ]);
xattrProcess.WaitForExit();
}