suyu/dynarmic
26
1
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity
dynarmic/tests/A64/a64.cpp

1676 lines
75 KiB
C++
Raw Normal View History

A64: Backend framework
2018-01-06 22:15:25 +01:00
/* This file is part of the dynarmic project.
A64: Implement ADD_shifted
2018-01-07 01:11:57 +01:00
* Copyright (c) 2018 MerryMage
Relicense to 0BSD
2020-04-23 16:25:11 +02:00
* SPDX-License-Identifier: 0BSD
A64: Backend framework
2018-01-06 22:15:25 +01:00
*/
tests: Update to Catch2 v3
2022-12-31 17:26:55 +01:00
#include <catch2/catch_test_macros.hpp>
A64: Backend framework
2018-01-06 22:15:25 +01:00
Consolidate all source files into src/ directory
2021-05-19 18:28:35 +02:00
#include "./testenv.h"
#include "dynarmic/common/fp/fpsr.h"
#include "dynarmic/interface/exclusive_monitor.h"
A64: Backend framework
2018-01-06 22:15:25 +01:00
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
using namespace Dynarmic;
simd_two_register_misc: FNEG (vector) with Q == 0 had dirty upper
2018-09-09 20:55:37 +02:00
A64: Implement ADD_shifted
2018-01-07 01:11:57 +01:00
TEST_CASE("A64: ADD", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
A64: Implement ADD_shifted
2018-01-07 01:11:57 +01:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x8b020020); // ADD X0, X1, X2
env.code_mem.emplace_back(0x14000000); // B .
A64: Implement ADD_shifted
2018-01-07 01:11:57 +01:00
jit.SetRegister(0, 0);
jit.SetRegister(1, 1);
jit.SetRegister(2, 2);
jit.SetPC(0);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetRegister(0) == 3);
REQUIRE(jit.GetRegister(1) == 1);
REQUIRE(jit.GetRegister(2) == 2);
REQUIRE(jit.GetPC() == 4);
}
A64: Implement logical
2018-01-07 13:52:12 +01:00
tests: Add {S,V}ADD{V,P} tests These are the instructions emitted for each variant of the `vaddv{q}_{s}{8,16,32,64}` intrinsic.
2021-09-09 22:40:06 +02:00
TEST_CASE("A64: ADD{V,P}", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x0E31B801); // ADDV b1, v0.8b
env.code_mem.emplace_back(0x4E31B802); // ADDV b2, v0.16b
env.code_mem.emplace_back(0x0E71B803); // ADDV h3, v0.4h
env.code_mem.emplace_back(0x4E71B804); // ADDV h4, v0.8h
env.code_mem.emplace_back(0x0EA0BC05); // ADDP v5.2s, v0.2s, v0.2s
env.code_mem.emplace_back(0x4EB1B806); // ADDV s6, v0.4s
env.code_mem.emplace_back(0x14000000); // B .
jit.SetVector(0, {0x0101010101010101, 0x0101010101010101});
jit.SetPC(0);
env.ticks_left = 7;
jit.Run();
REQUIRE(jit.GetVector(1) == Vector{0x0000000000000008, 0x0000000000000000});
REQUIRE(jit.GetVector(2) == Vector{0x0000000000000010, 0x0000000000000000});
REQUIRE(jit.GetVector(3) == Vector{0x0000000000000404, 0x0000000000000000});
REQUIRE(jit.GetVector(4) == Vector{0x0000000000000808, 0x0000000000000000});
REQUIRE(jit.GetVector(5) == Vector{0x0202020202020202, 0x0000000000000000});
REQUIRE(jit.GetVector(6) == Vector{0x0000000004040404, 0x0000000000000000});
}
TEST_CASE("A64: UADDL{V,P}", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x2E303801); // UADDLV h1, v0.8b
env.code_mem.emplace_back(0x6E303802); // UADDLV h2, v0.16b
env.code_mem.emplace_back(0x2E703803); // UADDLV s3, v0.4h
env.code_mem.emplace_back(0x6E703804); // UADDLV s4, v0.8h
env.code_mem.emplace_back(0x2EA02805); // UADDLP v5.1d, v0.2s
env.code_mem.emplace_back(0x6EB03806); // UADDLV d6, v0.4s
env.code_mem.emplace_back(0x14000000); // B .
jit.SetVector(0, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF});
jit.SetPC(0);
env.ticks_left = 7;
jit.Run();
REQUIRE(jit.GetVector(1) == Vector{0x00000000000007f8, 0x0000000000000000});
REQUIRE(jit.GetVector(2) == Vector{0x0000000000000ff0, 0x0000000000000000});
REQUIRE(jit.GetVector(3) == Vector{0x000000000003fffc, 0x0000000000000000});
REQUIRE(jit.GetVector(4) == Vector{0x000000000007fff8, 0x0000000000000000});
REQUIRE(jit.GetVector(5) == Vector{0x00000001fffffffe, 0x0000000000000000});
REQUIRE(jit.GetVector(6) == Vector{0x00000003fffffffc, 0x0000000000000000});
}
TEST_CASE("A64: SADDL{V,P}", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x0E303801); // SADDLV h1, v0.8b
env.code_mem.emplace_back(0x4E303802); // SADDLV h2, v0.16b
env.code_mem.emplace_back(0x0E703803); // SADDLV s3, v0.4h
env.code_mem.emplace_back(0x4E703804); // SADDLV s4, v0.8h
env.code_mem.emplace_back(0x0EA02805); // SADDLP v5.1d, v0.2s
env.code_mem.emplace_back(0x4EB03806); // SADDLV d6, v0.4s
env.code_mem.emplace_back(0x14000000); // B .
jit.SetVector(0, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF});
jit.SetPC(0);
env.ticks_left = 7;
jit.Run();
REQUIRE(jit.GetVector(1) == Vector{0x000000000000fff8, 0x0000000000000000});
REQUIRE(jit.GetVector(2) == Vector{0x000000000000fff0, 0x0000000000000000});
REQUIRE(jit.GetVector(3) == Vector{0x00000000fffffffc, 0x0000000000000000});
REQUIRE(jit.GetVector(4) == Vector{0x00000000fffffff8, 0x0000000000000000});
REQUIRE(jit.GetVector(5) == Vector{0xfffffffffffffffe, 0x0000000000000000});
REQUIRE(jit.GetVector(6) == Vector{0xfffffffffffffffc, 0x0000000000000000});
}
tests/A64: Add VQADD/VQSUB unit tests
2021-05-21 23:45:22 +02:00
TEST_CASE("A64: VQADD", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
tests: Format to clang-format mandated style
2021-05-31 13:54:27 +02:00
env.code_mem.emplace_back(0x6e210c02); // UQADD v2.16b, v0.16b, v1.16b
env.code_mem.emplace_back(0x4e210c03); // SQADD v3.16b, v0.16b, v1.16b
env.code_mem.emplace_back(0x6e610c04); // UQADD v4.8h, v0.8h, v1.8h
env.code_mem.emplace_back(0x4e610c05); // SQADD v5.8h, v0.8h, v1.8h
env.code_mem.emplace_back(0x6ea10c06); // UQADD v6.4s, v0.4s, v1.4s
env.code_mem.emplace_back(0x4ea10c07); // SQADD v7.4s, v0.4s, v1.4s
env.code_mem.emplace_back(0x6ee10c08); // UQADD v8.2d, v0.2d, v1.2d
env.code_mem.emplace_back(0x4ee10c09); // SQADD v9.2d, v0.2d, v1.2d
env.code_mem.emplace_back(0x14000000); // B .
tests/A64: Add VQADD/VQSUB unit tests
2021-05-21 23:45:22 +02:00
jit.SetVector(0, {0x7F7F7F7F7F7F7F7F, 0x7FFFFFFF7FFF7FFF});
jit.SetVector(1, {0x8010FF00807F0000, 0x8000000080008000});
jit.SetPC(0);
env.ticks_left = 9;
jit.Run();
REQUIRE(jit.GetVector(2) == Vector{0xff8fff7ffffe7f7f, 0xffffffffffffffff});
REQUIRE(jit.GetVector(3) == Vector{0xff7f7e7fff7f7f7f, 0xffffffffffffffff});
REQUIRE(jit.GetVector(4) == Vector{0xff8ffffffffe7f7f, 0xffffffffffffffff});
REQUIRE(jit.GetVector(5) == Vector{0xff8f7e7ffffe7f7f, 0xffffffffffffffff});
REQUIRE(jit.GetVector(6) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff});
REQUIRE(jit.GetVector(7) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff});
REQUIRE(jit.GetVector(8) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff});
REQUIRE(jit.GetVector(9) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff});
}
TEST_CASE("A64: VQSUB", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
tests: Format to clang-format mandated style
2021-05-31 13:54:27 +02:00
env.code_mem.emplace_back(0x6e212c02); // UQSUB v2.16b, v0.16b, v1.16b
env.code_mem.emplace_back(0x4e212c03); // SQSUB v3.16b, v0.16b, v1.16b
env.code_mem.emplace_back(0x6e612c04); // UQSUB v4.8h, v0.8h, v1.8h
env.code_mem.emplace_back(0x4e612c05); // SQSUB v5.8h, v0.8h, v1.8h
env.code_mem.emplace_back(0x6ea12c06); // UQSUB v6.4s, v0.4s, v1.4s
env.code_mem.emplace_back(0x4ea12c07); // SQSUB v7.4s, v0.4s, v1.4s
env.code_mem.emplace_back(0x6ee12c08); // UQSUB v8.2d, v0.2d, v1.2d
env.code_mem.emplace_back(0x4ee12c09); // SQSUB v9.2d, v0.2d, v1.2d
env.code_mem.emplace_back(0x14000000); // B .
tests/A64: Add VQADD/VQSUB unit tests
2021-05-21 23:45:22 +02:00
jit.SetVector(0, {0x8010FF00807F0000, 0x8000000080008000});
jit.SetVector(1, {0x7F7F7F7F7F7F7F7F, 0x7FFFFFFF7FFF7FFF});
jit.SetPC(0);
env.ticks_left = 9;
jit.Run();
REQUIRE(jit.GetVector(2) == Vector{0x0100800001000000, 0x0100000001000100});
REQUIRE(jit.GetVector(3) == Vector{0x8091808180008181, 0x8001010180018001});
REQUIRE(jit.GetVector(4) == Vector{0x00917f8101000000, 0x0001000000010001});
REQUIRE(jit.GetVector(5) == Vector{0x8000800080008081, 0x8000000180008000});
REQUIRE(jit.GetVector(6) == Vector{0x00917f8100ff8081, 0x0000000100010001});
REQUIRE(jit.GetVector(7) == Vector{0x8000000080000000, 0x8000000080000000});
REQUIRE(jit.GetVector(8) == Vector{0x00917f8100ff8081, 0x0000000100010001});
REQUIRE(jit.GetVector(9) == Vector{0x8000000000000000, 0x8000000000000000});
}
A64: Implement REV, REV32, and REV16 (#126)
2018-01-21 13:17:47 +01:00
TEST_CASE("A64: REV", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
A64: Implement REV, REV32, and REV16 (#126)
2018-01-21 13:17:47 +01:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0xdac00c00); // REV X0, X0
env.code_mem.emplace_back(0x5ac00821); // REV W1, W1
env.code_mem.emplace_back(0x14000000); // B .
A64: Implement REV, REV32, and REV16 (#126)
2018-01-21 13:17:47 +01:00
jit.SetRegister(0, 0xaabbccddeeff1100);
jit.SetRegister(1, 0xaabbccdd);
jit.SetPC(0);
env.ticks_left = 3;
jit.Run();
REQUIRE(jit.GetRegister(0) == 0x11ffeeddccbbaa);
REQUIRE(jit.GetRegister(1) == 0xddccbbaa);
REQUIRE(jit.GetPC() == 8);
}
TEST_CASE("A64: REV32", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
A64: Implement REV, REV32, and REV16 (#126)
2018-01-21 13:17:47 +01:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0xdac00800); // REV32 X0, X0
env.code_mem.emplace_back(0x14000000); // B .
A64: Implement REV, REV32, and REV16 (#126)
2018-01-21 13:17:47 +01:00
jit.SetRegister(0, 0xaabbccddeeff1100);
jit.SetPC(0);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetRegister(0) == 0xddccbbaa0011ffee);
REQUIRE(jit.GetPC() == 4);
}
TEST_CASE("A64: REV16", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
A64: Implement REV, REV32, and REV16 (#126)
2018-01-21 13:17:47 +01:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0xdac00400); // REV16 X0, X0
env.code_mem.emplace_back(0x5ac00421); // REV16 W1, W1
env.code_mem.emplace_back(0x14000000); // B .
A64: Implement REV, REV32, and REV16 (#126)
2018-01-21 13:17:47 +01:00
jit.SetRegister(0, 0xaabbccddeeff1100);
jit.SetRegister(1, 0xaabbccdd);
jit.SetPC(0);
env.ticks_left = 3;
jit.Run();
REQUIRE(jit.GetRegister(0) == 0xbbaaddccffee0011);
REQUIRE(jit.GetRegister(1) == 0xbbaaddcc);
REQUIRE(jit.GetPC() == 8);
}
tests/A64: Add {S,U}SHL instruction unit tests
2022-03-27 23:15:44 +02:00
TEST_CASE("A64: SSHL", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x4e204484); // SSHL v4.16b, v4.16b, v0.16b
env.code_mem.emplace_back(0x4e6144a5); // SSHL v5.8h, v5.8h, v1.8h
env.code_mem.emplace_back(0x4ea244c6); // SSHL v6.4s, v6.4s, v2.4s
env.code_mem.emplace_back(0x4ee344e7); // SSHL v7.2d, v7.2d, v3.2d
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0xEFF0FAFBFCFDFEFF, 0x0807050403020100});
jit.SetVector(1, {0xFFFCFFFDFFFEFFFF, 0x0004000300020001});
jit.SetVector(2, {0xFFFFFFFDFFFFFFFE, 0x0000000200000001});
jit.SetVector(3, {0xFFFFFFFFFFFFFFFF, 0x0000000000000001});
jit.SetVector(4, {0x8080808080808080, 0xFFFFFFFFFFFFFFFF});
jit.SetVector(5, {0x8000800080008000, 0xFFFFFFFFFFFFFFFF});
jit.SetVector(6, {0x8000000080000000, 0xFFFFFFFFFFFFFFFF});
jit.SetVector(7, {0x8000000000000000, 0xFFFFFFFFFFFFFFFF});
env.ticks_left = 4;
jit.Run();
REQUIRE(jit.GetVector(4) == Vector{0xfffffefcf8f0e0c0, 0x0080e0f0f8fcfeff});
REQUIRE(jit.GetVector(5) == Vector{0xf800f000e000c000, 0xfff0fff8fffcfffe});
REQUIRE(jit.GetVector(6) == Vector{0xf0000000e0000000, 0xfffffffcfffffffe});
REQUIRE(jit.GetVector(7) == Vector{0xc000000000000000, 0xfffffffffffffffe});
}
TEST_CASE("A64: USHL", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x6e204484); // USHL v4.16b, v4.16b, v0.16b
env.code_mem.emplace_back(0x6e6144a5); // USHL v5.8h, v5.8h, v1.8h
env.code_mem.emplace_back(0x6ea244c6); // USHL v6.4s, v6.4s, v2.4s
env.code_mem.emplace_back(0x6ee344e7); // USHL v7.2d, v7.2d, v3.2d
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0x100F0E0D0C0B0A09, 0x0807050403020100});
jit.SetVector(1, {0x0008000700060005, 0x0004000300020001});
jit.SetVector(2, {0x0000000400000003, 0x0000000200000001});
jit.SetVector(3, {0x0000000000000002, 0x0000000000000001});
jit.SetVector(4, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF});
jit.SetVector(5, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF});
jit.SetVector(6, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF});
jit.SetVector(7, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF});
env.ticks_left = 4;
jit.Run();
REQUIRE(jit.GetVector(4) == Vector{0x0000000000000000, 0x0080e0f0f8fcfeff});
REQUIRE(jit.GetVector(5) == Vector{0xff00ff80ffc0ffe0, 0xfff0fff8fffcfffe});
REQUIRE(jit.GetVector(6) == Vector{0xfffffff0fffffff8, 0xfffffffcfffffffe});
REQUIRE(jit.GetVector(7) == Vector{0xfffffffffffffffc, 0xfffffffffffffffe});
}
emit_x64_vector: AVX512 Implementation of EmitVectorNarrow{32,64} Includes a new test case with the XTN instruction to verify the implementation
2021-05-14 07:30:29 +02:00
TEST_CASE("A64: XTN", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x0e212803); // XTN v3.8b, v0.8h
env.code_mem.emplace_back(0x0e612824); // XTN v4.4h, v1.4s
env.code_mem.emplace_back(0x0ea12845); // XTN v5.2s, v2.2d
env.code_mem.emplace_back(0x14000000); // B .
emit_x64_vector: AVX512 Implementation of EmitVectorNarrow{32,64} Includes a new test case with the XTN instruction to verify the implementation
2021-05-14 07:30:29 +02:00
jit.SetPC(0);
jit.SetVector(0, {0x3333222211110000, 0x7777666655554444});
jit.SetVector(1, {0x1111111100000000, 0x3333333322222222});
jit.SetVector(2, {0x0000000000000000, 0x1111111111111111});
env.ticks_left = 4;
jit.Run();
REQUIRE(jit.GetVector(3) == Vector{0x7766554433221100, 0x0000000000000000});
REQUIRE(jit.GetVector(4) == Vector{0x3333222211110000, 0x0000000000000000});
REQUIRE(jit.GetVector(5) == Vector{0x1111111100000000, 0x0000000000000000});
}
tests/A64: Add TBL/TBX instruction unit tests Tests the TBL instruction with implementation with {1-4} register lookups and the handling of out-of-bound indices. Intended to target the implementation of VectorTableLookup128
2021-05-15 06:24:00 +02:00
TEST_CASE("A64: TBL", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
emit_x64_vector: AVX512VBMI implementation of EmitVectorTableLookup128 Also adds AVX512VBMI detection to host_feature
2021-05-16 06:54:33 +02:00
env.code_mem.emplace_back(0x0e000100); // TBL v0.8b, { v8.16b }, v0.8b
env.code_mem.emplace_back(0x4e010101); // TBL v1.16b, { v8.16b }, v1.16b
env.code_mem.emplace_back(0x0e022102); // TBL v2.8b, { v8.16b, v9.16b }, v2.8b
env.code_mem.emplace_back(0x4e032103); // TBL v3.16b, { v8.16b, v9.16b }, v3.16b
env.code_mem.emplace_back(0x0e044104); // TBL v4.8b, { v8.16b, v9.16b, v10.16b }, v4.8b
env.code_mem.emplace_back(0x4e054105); // TBL v5.16b, { v8.16b, v9.16b, v10.16b }, v5.16b
env.code_mem.emplace_back(0x0e066106); // TBL v6.8b, { v8.16b, v9.16b, v10.16b, v11.16b }, v6.8b
env.code_mem.emplace_back(0x4e076107); // TBL v7.16b, { v8.16b, v9.16b, v10.16b, v11.16b }, v7.16b
env.code_mem.emplace_back(0x14000000); // B .
tests/A64: Add TBL/TBX instruction unit tests Tests the TBL instruction with implementation with {1-4} register lookups and the handling of out-of-bound indices. Intended to target the implementation of VectorTableLookup128
2021-05-15 06:24:00 +02:00
// Indices
// 'FF' intended to test out-of-index
emit_x64_vector: AVX512VBMI implementation of EmitVectorTableLookup128 Also adds AVX512VBMI detection to host_feature
2021-05-16 06:54:33 +02:00
jit.SetVector(0, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f});
jit.SetVector(1, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f});
jit.SetVector(2, {0x100011011202'FF'03, 0x1404150516061707});
jit.SetVector(3, {0x100011011202'FF'03, 0x1404150516061707});
jit.SetVector(4, {0x201000211101'FF'12, 0x0233231303241404});
jit.SetVector(5, {0x201000211101'FF'12, 0x0233231303241404});
jit.SetVector(6, {0x403010004131'FF'01, 0x4232120243332303});
jit.SetVector(7, {0x403010004131'FF'01, 0x4232120243332303});
tests/A64: Add TBL/TBX instruction unit tests Tests the TBL instruction with implementation with {1-4} register lookups and the handling of out-of-bound indices. Intended to target the implementation of VectorTableLookup128
2021-05-15 06:24:00 +02:00
// Table
emit_x64_vector: AVX512VBMI implementation of EmitVectorTableLookup128 Also adds AVX512VBMI detection to host_feature
2021-05-16 06:54:33 +02:00
jit.SetVector(8, {0x7766554433221100, 0xffeeddccbbaa9988});
jit.SetVector(9, {0xffffffffffffffff, 0xffffffffffffffff});
tests/A64: Add TBL/TBX instruction unit tests Tests the TBL instruction with implementation with {1-4} register lookups and the handling of out-of-bound indices. Intended to target the implementation of VectorTableLookup128
2021-05-15 06:24:00 +02:00
jit.SetVector(10, {0xeeeeeeeeeeeeeeee, 0xeeeeeeeeeeeeeeee});
jit.SetVector(11, {0xdddddddddddddddd, 0xdddddddddddddddd});
jit.SetPC(0);
env.ticks_left = 9;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0x001122334455'00'77, 0x0000000000000000});
REQUIRE(jit.GetVector(1) == Vector{0x001122334455'00'77, 0x8899aabbccddeeff});
REQUIRE(jit.GetVector(2) == Vector{0xff00ff11ff22'00'33, 0x0000000000000000});
REQUIRE(jit.GetVector(3) == Vector{0xff00ff11ff22'00'33, 0xff44ff55ff66ff77});
REQUIRE(jit.GetVector(4) == Vector{0xeeff00eeff11'00'ff, 0x0000000000000000});
REQUIRE(jit.GetVector(5) == Vector{0xeeff00eeff11'00'ff, 0x2200eeff33eeff44});
REQUIRE(jit.GetVector(6) == Vector{0x00ddff0000dd'00'11, 0x0000000000000000});
REQUIRE(jit.GetVector(7) == Vector{0x00ddff0000dd'00'11, 0x00ddff2200ddee33});
}
TEST_CASE("A64: TBX", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
emit_x64_vector: AVX512VBMI implementation of EmitVectorTableLookup128 Also adds AVX512VBMI detection to host_feature
2021-05-16 06:54:33 +02:00
env.code_mem.emplace_back(0x0e001100); // TBX v0.8b, { v8.16b }, v0.8b
env.code_mem.emplace_back(0x4e011101); // TBX v1.16b, { v8.16b }, v1.16b
env.code_mem.emplace_back(0x0e023102); // TBX v2.8b, { v8.16b, v9.16b }, v2.8b
env.code_mem.emplace_back(0x4e033103); // TBX v3.16b, { v8.16b, v9.16b }, v3.16b
env.code_mem.emplace_back(0x0e045104); // TBX v4.8b, { v8.16b, v9.16b, v10.16b }, v4.8b
env.code_mem.emplace_back(0x4e055105); // TBX v5.16b, { v8.16b, v9.16b, v10.16b }, v5.16b
env.code_mem.emplace_back(0x0e067106); // TBX v6.8b, { v8.16b, v9.16b, v10.16b, v11.16b }, v6.8b
env.code_mem.emplace_back(0x4e077107); // TBX v7.16b, { v8.16b, v9.16b, v10.16b, v11.16b }, v7.16b
env.code_mem.emplace_back(0x14000000); // B .
tests/A64: Add TBL/TBX instruction unit tests Tests the TBL instruction with implementation with {1-4} register lookups and the handling of out-of-bound indices. Intended to target the implementation of VectorTableLookup128
2021-05-15 06:24:00 +02:00
// Indices
// 'FF' intended to test out-of-index
emit_x64_vector: AVX512VBMI implementation of EmitVectorTableLookup128 Also adds AVX512VBMI detection to host_feature
2021-05-16 06:54:33 +02:00
jit.SetVector(0, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f});
jit.SetVector(1, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f});
jit.SetVector(2, {0x100011011202'FF'03, 0x1404150516061707});
jit.SetVector(3, {0x100011011202'FF'03, 0x1404150516061707});
jit.SetVector(4, {0x201000211101'FF'12, 0x0233231303241404});
jit.SetVector(5, {0x201000211101'FF'12, 0x0233231303241404});
jit.SetVector(6, {0x403010004131'FF'01, 0x4232120243332303});
jit.SetVector(7, {0x403010004131'FF'01, 0x4232120243332303});
tests/A64: Add TBL/TBX instruction unit tests Tests the TBL instruction with implementation with {1-4} register lookups and the handling of out-of-bound indices. Intended to target the implementation of VectorTableLookup128
2021-05-15 06:24:00 +02:00
// Table
emit_x64_vector: AVX512VBMI implementation of EmitVectorTableLookup128 Also adds AVX512VBMI detection to host_feature
2021-05-16 06:54:33 +02:00
jit.SetVector(8, {0x7766554433221100, 0xffeeddccbbaa9988});
jit.SetVector(9, {0xffffffffffffffff, 0xffffffffffffffff});
tests/A64: Add TBL/TBX instruction unit tests Tests the TBL instruction with implementation with {1-4} register lookups and the handling of out-of-bound indices. Intended to target the implementation of VectorTableLookup128
2021-05-15 06:24:00 +02:00
jit.SetVector(10, {0xeeeeeeeeeeeeeeee, 0xeeeeeeeeeeeeeeee});
jit.SetVector(11, {0xdddddddddddddddd, 0xdddddddddddddddd});
jit.SetPC(0);
env.ticks_left = 9;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0x001122334455'FF'77, 0x0000000000000000});
REQUIRE(jit.GetVector(1) == Vector{0x001122334455'FF'77, 0x8899aabbccddeeff});
REQUIRE(jit.GetVector(2) == Vector{0xff00ff11ff22'FF'33, 0x0000000000000000});
REQUIRE(jit.GetVector(3) == Vector{0xff00ff11ff22'FF'33, 0xff44ff55ff66ff77});
REQUIRE(jit.GetVector(4) == Vector{0xeeff00eeff11'FF'ff, 0x0000000000000000});
REQUIRE(jit.GetVector(5) == Vector{0xeeff00eeff11'FF'ff, 0x2233eeff33eeff44});
REQUIRE(jit.GetVector(6) == Vector{0x40ddff0041dd'FF'11, 0x0000000000000000});
REQUIRE(jit.GetVector(7) == Vector{0x40ddff0041dd'FF'11, 0x42ddff2243ddee33});
}
A64: Implement logical
2018-01-07 13:52:12 +01:00
TEST_CASE("A64: AND", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
A64: Implement logical
2018-01-07 13:52:12 +01:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x8a020020); // AND X0, X1, X2
env.code_mem.emplace_back(0x14000000); // B .
A64: Implement logical
2018-01-07 13:52:12 +01:00
jit.SetRegister(0, 0);
jit.SetRegister(1, 1);
jit.SetRegister(2, 3);
jit.SetPC(0);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetRegister(0) == 1);
REQUIRE(jit.GetRegister(1) == 1);
REQUIRE(jit.GetRegister(2) == 3);
REQUIRE(jit.GetPC() == 4);
}
TEST_CASE("A64: Bitmasks", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
A64: Implement logical
2018-01-07 13:52:12 +01:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x3200c3e0); // ORR W0, WZR, #0x01010101
env.code_mem.emplace_back(0x320c8fe1); // ORR W1, WZR, #0x00F000F0
env.code_mem.emplace_back(0x320003e2); // ORR W2, WZR, #1
env.code_mem.emplace_back(0x14000000); // B .
A64: Implement logical
2018-01-07 13:52:12 +01:00
jit.SetPC(0);
env.ticks_left = 4;
jit.Run();
REQUIRE(jit.GetRegister(0) == 0x01010101);
REQUIRE(jit.GetRegister(1) == 0x00F000F0);
REQUIRE(jit.GetRegister(2) == 1);
REQUIRE(jit.GetPC() == 12);
}
A64: PSTATE access and tests
2018-01-07 15:46:35 +01:00
TEST_CASE("A64: ANDS NZCV", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
A64: PSTATE access and tests
2018-01-07 15:46:35 +01:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x6a020020); // ANDS W0, W1, W2
env.code_mem.emplace_back(0x14000000); // B .
A64: PSTATE access and tests
2018-01-07 15:46:35 +01:00
SECTION("N=1, Z=0") {
jit.SetRegister(0, 0);
jit.SetRegister(1, 0xFFFFFFFF);
jit.SetRegister(2, 0xFFFFFFFF);
jit.SetPC(0);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetRegister(0) == 0xFFFFFFFF);
REQUIRE(jit.GetRegister(1) == 0xFFFFFFFF);
REQUIRE(jit.GetRegister(2) == 0xFFFFFFFF);
REQUIRE(jit.GetPC() == 4);
REQUIRE((jit.GetPstate() & 0xF0000000) == 0x80000000);
}
SECTION("N=0, Z=1") {
jit.SetRegister(0, 0);
jit.SetRegister(1, 0xFFFFFFFF);
jit.SetRegister(2, 0x00000000);
jit.SetPC(0);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetRegister(0) == 0x00000000);
REQUIRE(jit.GetRegister(1) == 0xFFFFFFFF);
REQUIRE(jit.GetRegister(2) == 0x00000000);
REQUIRE(jit.GetPC() == 4);
REQUIRE((jit.GetPstate() & 0xF0000000) == 0x40000000);
}
SECTION("N=0, Z=0") {
jit.SetRegister(0, 0);
jit.SetRegister(1, 0x12345678);
jit.SetRegister(2, 0x7324a993);
jit.SetPC(0);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetRegister(0) == 0x12240010);
REQUIRE(jit.GetRegister(1) == 0x12345678);
REQUIRE(jit.GetRegister(2) == 0x7324a993);
REQUIRE(jit.GetPC() == 4);
REQUIRE((jit.GetPstate() & 0xF0000000) == 0x00000000);
}
}
A64: Implement compare and branch
2018-01-07 17:33:02 +01:00
TEST_CASE("A64: CBZ", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
A64: Implement compare and branch
2018-01-07 17:33:02 +01:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x34000060); // 0x00 : CBZ X0, label
env.code_mem.emplace_back(0x320003e2); // 0x04 : MOV X2, 1
env.code_mem.emplace_back(0x14000000); // 0x08 : B.
env.code_mem.emplace_back(0x321f03e2); // 0x0C : label: MOV X2, 2
env.code_mem.emplace_back(0x14000000); // 0x10 : B .
A64: Implement compare and branch
2018-01-07 17:33:02 +01:00
SECTION("no branch") {
jit.SetPC(0);
jit.SetRegister(0, 1);
env.ticks_left = 4;
jit.Run();
REQUIRE(jit.GetRegister(2) == 1);
REQUIRE(jit.GetPC() == 8);
}
SECTION("branch") {
jit.SetPC(0);
jit.SetRegister(0, 0);
env.ticks_left = 4;
jit.Run();
REQUIRE(jit.GetRegister(2) == 2);
REQUIRE(jit.GetPC() == 16);
}
}
TEST_CASE("A64: TBZ", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
A64: Implement compare and branch
2018-01-07 17:33:02 +01:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x36180060); // 0x00 : TBZ X0, 3, label
env.code_mem.emplace_back(0x320003e2); // 0x04 : MOV X2, 1
env.code_mem.emplace_back(0x14000000); // 0x08 : B .
env.code_mem.emplace_back(0x321f03e2); // 0x0C : label: MOV X2, 2
env.code_mem.emplace_back(0x14000000); // 0x10 : B .
A64: Implement compare and branch
2018-01-07 17:33:02 +01:00
SECTION("no branch") {
jit.SetPC(0);
jit.SetRegister(0, 0xFF);
env.ticks_left = 4;
jit.Run();
REQUIRE(jit.GetRegister(2) == 1);
REQUIRE(jit.GetPC() == 8);
}
SECTION("branch with zero") {
jit.SetPC(0);
jit.SetRegister(0, 0);
env.ticks_left = 4;
jit.Run();
REQUIRE(jit.GetRegister(2) == 2);
REQUIRE(jit.GetPC() == 16);
}
SECTION("branch with non-zero") {
jit.SetPC(0);
jit.SetRegister(0, 1);
env.ticks_left = 4;
jit.Run();
REQUIRE(jit.GetRegister(2) == 2);
REQUIRE(jit.GetPC() == 16);
}
}
tests: Add FABD test
2018-07-16 17:55:26 +02:00
TEST_CASE("A64: FABD", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
tests: Add FABD test
2018-07-16 17:55:26 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x6eb5d556); // FABD.4S V22, V10, V21
env.code_mem.emplace_back(0x14000000); // B .
tests: Add FABD test
2018-07-16 17:55:26 +02:00
jit.SetPC(0);
jit.SetVector(10, {0xb4858ac77ff39a87, 0x9fce5e14c4873176});
jit.SetVector(21, {0x56d3f085ff890e2b, 0x6e4b0a41801a2d00});
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(22) == Vector{0x56d3f0857fc90e2b, 0x6e4b0a4144873176});
}
a64_emit_x64: Fix stack misalignment on Windows for 128-bit exclusive writes Discovered by @Subv. Includes a test to ensure this codepath is exercised on Windows.
2018-07-22 16:05:53 +02:00
tests: Add FABS tests
2021-06-09 18:54:18 +02:00
TEST_CASE("A64: FABS", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x4ef8f804); // FABS v4.8h, v0.8h
env.code_mem.emplace_back(0x4ea0f825); // FABS v5.4s, v1.4s
env.code_mem.emplace_back(0x4ee0f846); // FABS v6.2d, v2.2d
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0xffffffffffffffff, 0xffffffffffff8000});
jit.SetVector(1, {0xffbfffffffc00000, 0xff80000080000000});
jit.SetVector(2, {0xffffffffffffffff, 0x8000000000000000});
env.ticks_left = 4;
jit.Run();
REQUIRE(jit.GetVector(4) == Vector{0x7fff7fff7fff7fff, 0x7fff7fff7fff0000});
REQUIRE(jit.GetVector(5) == Vector{0x7fbfffff7fc00000, 0x7f80000000000000});
REQUIRE(jit.GetVector(6) == Vector{0x7fffffffffffffff, 0x0000000000000000});
}
tests: Add FMAX/FMIN/FMAXNM/FMINNM tests
2022-12-29 18:01:17 +01:00
TEST_CASE("A64: FMIN (example)", "[a64]") {
tests: Add F{MIN,MAX} tests Very minimal tests that includes some denormals and {Q,S}NANs
2021-06-04 23:55:47 +02:00
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x4ea1f400); // FMIN.4S V0, V0, V1
env.code_mem.emplace_back(0x4ee3f442); // FMIN.2D V2, V2, V3
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37});
jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff});
jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000});
jit.SetVector(3, {0xbff0000000000000, 0x6e4b0a41ffffffff});
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0x7fc00000'00000001, 0x00000000'7fd84a37});
REQUIRE(jit.GetVector(2) == Vector{0xbff0000000000000, 0x3ff0000000000000});
}
tests: Add FMAX/FMIN/FMAXNM/FMINNM tests
2022-12-29 18:01:17 +01:00
TEST_CASE("A64: FMAX (example)", "[a64]") {
tests: Add F{MIN,MAX} tests Very minimal tests that includes some denormals and {Q,S}NANs
2021-06-04 23:55:47 +02:00
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x4e21f400); // FMAX.4S V0, V0, V1
env.code_mem.emplace_back(0x4e63f442); // FMAX.2D V2, V2, V3
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37});
jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff});
jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000});
jit.SetVector(3, {0xbff0000000000000, 0x6e4b0a41ffffffff});
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0x7fc00000'09503366, 0x6e4b0a41'7fd84a37});
REQUIRE(jit.GetVector(2) == Vector{0x7fc0000009503366, 0x6e4b0a41ffffffff});
}
tests: Add FMAX/FMIN/FMAXNM/FMINNM tests
2022-12-29 18:01:17 +01:00
TEST_CASE("A64: FMINNM (example)", "[a64]") {
tests: add F{MIN,MAX}NM tests
2021-06-14 21:43:06 +02:00
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x4ea1c400); // FMINNM.4S V0, V0, V1
env.code_mem.emplace_back(0x4ee3c442); // FMINNM.2D V2, V2, V3
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37});
jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff});
jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000});
jit.SetVector(3, {0xfff0000000000000, 0xffffffffffffffff});
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0xc1200000'00000001, 0x00000000'7fd84a37});
REQUIRE(jit.GetVector(2) == Vector{0xfff0000000000000, 0x3ff0000000000000});
}
tests: Add FMAX/FMIN/FMAXNM/FMINNM tests
2022-12-29 18:01:17 +01:00
TEST_CASE("A64: FMAXNM (example)", "[a64]") {
tests: add F{MIN,MAX}NM tests
2021-06-14 21:43:06 +02:00
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x4e21c400); // FMAXNM.4S V0, V0, V1
env.code_mem.emplace_back(0x4e63c442); // FMAXNM.2D V2, V2, V3
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37});
jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff});
jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000});
jit.SetVector(3, {0xfff0000000000000, 0xffffffffffffffff});
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0xc1200000'09503366, 0x6e4b0a41'7fd84a37});
REQUIRE(jit.GetVector(2) == Vector{0x7fc0000009503366, 0x3ff0000000000000});
}
tests/fp_min_max: Add a few more test cases
2022-12-29 18:16:06 +01:00
TEST_CASE("A64: FMAXNM (example 2)", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x4e3bc6fd); // FMAXNM.4S V29, V23, V27
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetFpcr(0x01400000);
jit.SetVector(23, {0xb485877c'42280000, 0x317285d3'b5c8e5d3});
jit.SetVector(27, {0xbc48d091'c79b271e, 0xff800001'3304c3ef});
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(29) == Vector{0xb485877c'42280000, 0xffc00001'3304c3ef});
}
a64_emit_x64: Fix stack misalignment on Windows for 128-bit exclusive writes Discovered by @Subv. Includes a test to ensure this codepath is exercised on Windows.
2018-07-22 16:05:53 +02:00
TEST_CASE("A64: 128-bit exclusive read/write", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
ExclusiveMonitor monitor{1};
a64_emit_x64: Fix stack misalignment on Windows for 128-bit exclusive writes Discovered by @Subv. Includes a test to ensure this codepath is exercised on Windows.
2018-07-22 16:05:53 +02:00
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::UserConfig conf;
a64_emit_x64: Fix stack misalignment on Windows for 128-bit exclusive writes Discovered by @Subv. Includes a test to ensure this codepath is exercised on Windows.
2018-07-22 16:05:53 +02:00
conf.callbacks = &env;
conf.processor_id = 0;
SECTION("Global Monitor") {
conf.global_monitor = &monitor;
}
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{conf};
a64_emit_x64: Fix stack misalignment on Windows for 128-bit exclusive writes Discovered by @Subv. Includes a test to ensure this codepath is exercised on Windows.
2018-07-22 16:05:53 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0xc87f0861); // LDXP X1, X2, [X3]
env.code_mem.emplace_back(0xc8241865); // STXP W4, X5, X6, [X3]
env.code_mem.emplace_back(0x14000000); // B .
a64_emit_x64: Fix stack misalignment on Windows for 128-bit exclusive writes Discovered by @Subv. Includes a test to ensure this codepath is exercised on Windows.
2018-07-22 16:05:53 +02:00
jit.SetPC(0);
jit.SetRegister(3, 0x1234567812345678);
jit.SetRegister(4, 0xbaadbaadbaadbaad);
jit.SetRegister(5, 0xaf00d1e5badcafe0);
jit.SetRegister(6, 0xd0d0cacad0d0caca);
env.ticks_left = 3;
jit.Run();
REQUIRE(jit.GetRegister(1) == 0x7f7e7d7c7b7a7978);
REQUIRE(jit.GetRegister(2) == 0x8786858483828180);
REQUIRE(jit.GetRegister(4) == 0);
REQUIRE(env.MemoryRead64(0x1234567812345678) == 0xaf00d1e5badcafe0);
REQUIRE(env.MemoryRead64(0x1234567812345680) == 0xd0d0cacad0d0caca);
}
a64_emit_x64: Ensure host has updated ticks in EmitA64GetCNTPCT Discovered by @Subv. Fixes incomplete fix begun in 5a91c94dca47c9702dee20fbd5ae1f4c07eef9df. That fix fails to take into account that LinkBlock doesn't update ticks until there are no remaining ticks to be executed. Test added to confirm fix.
2018-07-22 17:16:26 +02:00
TEST_CASE("A64: CNTPCT_EL0", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
a64_emit_x64: Ensure host has updated ticks in EmitA64GetCNTPCT Discovered by @Subv. Fixes incomplete fix begun in 5a91c94dca47c9702dee20fbd5ae1f4c07eef9df. That fix fails to take into account that LinkBlock doesn't update ticks until there are no remaining ticks to be executed. Test added to confirm fix.
2018-07-22 17:16:26 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0xd53be021); // MRS X1, CNTPCT_EL0
env.code_mem.emplace_back(0xd503201f); // NOP
env.code_mem.emplace_back(0xd503201f); // NOP
env.code_mem.emplace_back(0xd503201f); // NOP
env.code_mem.emplace_back(0xd503201f); // NOP
env.code_mem.emplace_back(0xd503201f); // NOP
env.code_mem.emplace_back(0xd503201f); // NOP
env.code_mem.emplace_back(0xd53be022); // MRS X2, CNTPCT_EL0
env.code_mem.emplace_back(0xcb010043); // SUB X3, X2, X1
env.code_mem.emplace_back(0x14000000); // B .
a64_emit_x64: Ensure host has updated ticks in EmitA64GetCNTPCT Discovered by @Subv. Fixes incomplete fix begun in 5a91c94dca47c9702dee20fbd5ae1f4c07eef9df. That fix fails to take into account that LinkBlock doesn't update ticks until there are no remaining ticks to be executed. Test added to confirm fix.
2018-07-22 17:16:26 +02:00
env.ticks_left = 10;
jit.Run();
REQUIRE(jit.GetRegister(3) == 7);
}
emit_x64_floating_point: Implement accurate fallback for FPMulAdd{32,64}
2018-07-23 17:23:05 +02:00
TEST_CASE("A64: FNMSUB 1", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
emit_x64_floating_point: Implement accurate fallback for FPMulAdd{32,64}
2018-07-23 17:23:05 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x1f618a9c); // FNMSUB D28, D20, D1, D2
env.code_mem.emplace_back(0x14000000); // B .
emit_x64_floating_point: Implement accurate fallback for FPMulAdd{32,64}
2018-07-23 17:23:05 +02:00
jit.SetPC(0);
jit.SetVector(20, {0xe73a51346164bd6c, 0x8080000000002b94});
jit.SetVector(1, {0xbf8000007fffffff, 0xffffffff00002b94});
jit.SetVector(2, {0x0000000000000000, 0xc79b271e3f000000});
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(28) == Vector{0x66ca513533ee6076, 0x0000000000000000});
}
TEST_CASE("A64: FNMSUB 2", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
emit_x64_floating_point: Implement accurate fallback for FPMulAdd{32,64}
2018-07-23 17:23:05 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x1f2ab88e); // FNMSUB S14, S4, S10, S14
env.code_mem.emplace_back(0x14000000); // B .
emit_x64_floating_point: Implement accurate fallback for FPMulAdd{32,64}
2018-07-23 17:23:05 +02:00
jit.SetPC(0);
jit.SetVector(4, {0x3c9623b101398437, 0x7ff0abcd0ba98d27});
jit.SetVector(10, {0xffbfffff3eaaaaab, 0x3f0000003f8147ae});
jit.SetVector(14, {0x80000000007fffff, 0xe73a513400000000});
jit.SetFpcr(0x00400000);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(14) == Vector{0x0000000080045284, 0x0000000000000000});
}
u128: StickyLogicalShiftRight requires special-casing for amount == 64 In this case (128 - amount) == 64, and this invokes undefined behaviour
2018-07-23 21:21:33 +02:00
TEST_CASE("A64: FMADD", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
u128: StickyLogicalShiftRight requires special-casing for amount == 64 In this case (128 - amount) == 64, and this invokes undefined behaviour
2018-07-23 21:21:33 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x1f5e0e4a); // FMADD D10, D18, D30, D3
env.code_mem.emplace_back(0x14000000); // B .
u128: StickyLogicalShiftRight requires special-casing for amount == 64 In this case (128 - amount) == 64, and this invokes undefined behaviour
2018-07-23 21:21:33 +02:00
jit.SetPC(0);
jit.SetVector(18, {0x8000007600800000, 0x7ff812347f800000});
jit.SetVector(30, {0xff984a3700000000, 0xe73a513480800000});
jit.SetVector(3, {0x3f000000ff7fffff, 0x8139843780000000});
jit.SetFpcr(0x00400000);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(10) == Vector{0x3f059921bf0dbfff, 0x0000000000000000});
}
backend_x64: Fix FPVectorMulAdd and FPMulAdd NaN handling with denormals Denormals should be treated as zero in NaN handler
2018-07-31 17:07:46 +02:00
tests: Add FMLA(lane) test Math operations such as Matrix multiplication utilize these particular instructions enough that there should be some unit tests for thesein particular. The lane-splatting form of FMUL and FMLA instructions are of particular interest and I've found them to be very common in retail game binaries such as Pokemon Sword. https://community.arm.com/developer/ip-products/processors/b/processors-ip-blog/posts/coding-for-neon---part-3-matrix-multiplication I'm primarily adding this unit test so that I can ensure compatibility while I tune and optimize them.
2021-07-18 01:43:55 +02:00
TEST_CASE("A64: FMLA.4S(lane)", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x4f8f11c0); // FMLA.4S V0, V14, V15[0]
env.code_mem.emplace_back(0x4faf11c1); // FMLA.4S V1, V14, V15[1]
env.code_mem.emplace_back(0x4f8f19c2); // FMLA.4S V2, V14, V15[2]
env.code_mem.emplace_back(0x4faf19c3); // FMLA.4S V3, V14, V15[3]
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0x3ff00000'3ff00000, 0x00000000'00000000});
jit.SetVector(1, {0x3ff00000'3ff00000, 0x00000000'00000000});
jit.SetVector(2, {0x3ff00000'3ff00000, 0x00000000'00000000});
jit.SetVector(3, {0x3ff00000'3ff00000, 0x00000000'00000000});
jit.SetVector(14, {0x3ff00000'3ff00000, 0x3ff00000'3ff00000});
jit.SetVector(15, {0x3ff00000'40000000, 0x40400000'40800000});
env.ticks_left = 5;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0x40b4000040b40000, 0x4070000040700000});
REQUIRE(jit.GetVector(1) == Vector{0x40ac800040ac8000, 0x4061000040610000});
REQUIRE(jit.GetVector(2) == Vector{0x4116000041160000, 0x40f0000040f00000});
REQUIRE(jit.GetVector(3) == Vector{0x40f0000040f00000, 0x40b4000040b40000});
}
TEST_CASE("A64: FMUL.4S(lane)", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x4f8f91c0); // FMUL.4S V0, V14, V15[0]
env.code_mem.emplace_back(0x4faf91c1); // FMUL.4S V1, V14, V15[1]
env.code_mem.emplace_back(0x4f8f99c2); // FMUL.4S V2, V14, V15[2]
env.code_mem.emplace_back(0x4faf99c3); // FMUL.4S V3, V14, V15[3]
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(14, {0x3ff00000'3ff00000, 0x3ff00000'3ff00000});
jit.SetVector(15, {0x3ff00000'40000000, 0x40400000'40800000});
env.ticks_left = 5;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0x4070000040700000, 0x4070000040700000});
REQUIRE(jit.GetVector(1) == Vector{0x4061000040610000, 0x4061000040610000});
REQUIRE(jit.GetVector(2) == Vector{0x40f0000040f00000, 0x40f0000040f00000});
REQUIRE(jit.GetVector(3) == Vector{0x40b4000040b40000, 0x40b4000040b40000});
}
backend_x64: Fix FPVectorMulAdd and FPMulAdd NaN handling with denormals Denormals should be treated as zero in NaN handler
2018-07-31 17:07:46 +02:00
TEST_CASE("A64: FMLA.4S (denormal)", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
backend_x64: Fix FPVectorMulAdd and FPMulAdd NaN handling with denormals Denormals should be treated as zero in NaN handler
2018-07-31 17:07:46 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x4e2fcccc); // FMLA.4S V12, V6, V15
env.code_mem.emplace_back(0x14000000); // B .
backend_x64: Fix FPVectorMulAdd and FPMulAdd NaN handling with denormals Denormals should be treated as zero in NaN handler
2018-07-31 17:07:46 +02:00
jit.SetPC(0);
jit.SetVector(12, {0x3c9623b17ff80000, 0xbff0000080000076});
jit.SetVector(6, {0x7ff80000ff800000, 0x09503366c1200000});
jit.SetVector(15, {0x3ff0000080636d24, 0xbf800000e73a5134});
jit.SetFpcr(0x01000000);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(12) == Vector{0x7ff800007fc00000, 0xbff0000068e8e581});
}
emit_x64_vector_floating_point: Correct FMA in FTZ mode x64 rounds before flushing to zero AArch64 rounds after flushing to zero This difference of behaviour is noticable if something would round to a smallest normalized number
2018-07-31 19:12:39 +02:00
TEST_CASE("A64: FMLA.4S (0x80800000)", "[a64]") {
tests: Refactor unicorn_emu to allow for A32 unicorn
2018-08-11 12:39:53 +02:00
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
emit_x64_vector_floating_point: Correct FMA in FTZ mode x64 rounds before flushing to zero AArch64 rounds after flushing to zero This difference of behaviour is noticable if something would round to a smallest normalized number
2018-07-31 19:12:39 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x4e38cc2b); // FMLA.4S V11, V1, V24
env.code_mem.emplace_back(0x14000000); // B .
emit_x64_vector_floating_point: Correct FMA in FTZ mode x64 rounds before flushing to zero AArch64 rounds after flushing to zero This difference of behaviour is noticable if something would round to a smallest normalized number
2018-07-31 19:12:39 +02:00
jit.SetPC(0);
jit.SetVector(11, {0xc79b271efff05678, 0xffc0000080800000});
jit.SetVector(1, {0x00636d2400800000, 0x0966320bb26bddee});
jit.SetVector(24, {0x460e8c84fff00000, 0x8ba98d2780800002});
jit.SetFpcr(0x03000000);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(11) == Vector{0xc79b271e7fc00000, 0x7fc0000080000000});
}
emit_x64_floating_point: Fix smallest normal check in EmitFPMulAdd
2018-08-18 14:49:02 +02:00
// x64 has different rounding behaviour to AArch64.
// AArch64 performs rounding after flushing-to-zero.
// x64 performs rounding before flushing-to-zero.
TEST_CASE("A64: FMADD (0x80800000)", "[a64]") {
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
emit_x64_floating_point: Fix smallest normal check in EmitFPMulAdd
2018-08-18 14:49:02 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x1f0f7319); // FMADD S25, S24, S15, S28
env.code_mem.emplace_back(0x14000000); // B .
emit_x64_floating_point: Fix smallest normal check in EmitFPMulAdd
2018-08-18 14:49:02 +02:00
jit.SetPC(0);
jit.SetVector(24, {0x00800000, 0});
jit.SetVector(15, {0x0ba98d27, 0});
jit.SetVector(28, {0x80800000, 0});
jit.SetFpcr(0x01000000);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(25) == Vector{0x80000000, 0});
}
simd_two_register_misc: FNEG (vector) with Q == 0 had dirty upper
2018-09-09 20:55:37 +02:00
TEST_CASE("A64: FNEG failed to zero upper", "[a64]") {
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
simd_two_register_misc: FNEG (vector) with Q == 0 had dirty upper
2018-09-09 20:55:37 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x2ea0fb50); // FNEG.2S V16, V26
env.code_mem.emplace_back(0x2e207a1c); // SQNEG.8B V28, V16
env.code_mem.emplace_back(0x14000000); // B .
simd_two_register_misc: FNEG (vector) with Q == 0 had dirty upper
2018-09-09 20:55:37 +02:00
jit.SetPC(0);
jit.SetVector(26, {0x071286fde8f34a90, 0x837cffa8be382f60});
jit.SetFpcr(0x01000000);
env.ticks_left = 6;
jit.Run();
REQUIRE(jit.GetVector(28) == Vector{0x79ee7a03980db670, 0});
REQUIRE(FP::FPSR{jit.GetFpsr()}.QC() == false);
}
emit_x64_floating_point: Hardware FMA implementation of FPRSqrtStepFused
2018-09-12 17:10:18 +02:00
TEST_CASE("A64: FRSQRTS", "[a64]") {
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
emit_x64_floating_point: Hardware FMA implementation of FPRSqrtStepFused
2018-09-12 17:10:18 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x5eb8fcad); // FRSQRTS S13, S5, S24
env.code_mem.emplace_back(0x14000000); // B .
emit_x64_floating_point: Hardware FMA implementation of FPRSqrtStepFused
2018-09-12 17:10:18 +02:00
// These particular values result in an intermediate value during
// the calculation that is close to infinity. We want to verify
// that this special case is handled appropriately.
jit.SetPC(0);
jit.SetVector(5, {0xfc6a0206, 0});
jit.SetVector(24, {0xfc6a0206, 0});
jit.SetFpcr(0x00400000);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(13) == Vector{0xff7fffff, 0});
}
emit_x64_vector: Changes to VectorSignedSaturatedDoublingMultiply * Return both the upper and lower parts of the multiply if required * SSE2 does not support the pmuldq instruction, do sign correction to an unsigned result instead * Improve port utilisation where possible (punpck instructions were a bottleneck)
2018-09-15 10:04:19 +02:00
TEST_CASE("A64: SQDMULH.8H (saturate)", "[a64]") {
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
emit_x64_vector: Changes to VectorSignedSaturatedDoublingMultiply * Return both the upper and lower parts of the multiply if required * SSE2 does not support the pmuldq instruction, do sign correction to an unsigned result instead * Improve port utilisation where possible (punpck instructions were a bottleneck)
2018-09-15 10:04:19 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x4e62b420); // SQDMULH.8H V0, V1, V2
env.code_mem.emplace_back(0x14000000); // B .
emit_x64_vector: Changes to VectorSignedSaturatedDoublingMultiply * Return both the upper and lower parts of the multiply if required * SSE2 does not support the pmuldq instruction, do sign correction to an unsigned result instead * Improve port utilisation where possible (punpck instructions were a bottleneck)
2018-09-15 10:04:19 +02:00
// Make sure that saturating values are tested
jit.SetPC(0);
jit.SetVector(1, {0x7fff80007ffe8001, 0x7fff80007ffe8001});
jit.SetVector(2, {0x7fff80007ffe8001, 0x80007fff80017ffe});
jit.SetFpsr(0);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0x7ffe7fff7ffc7ffe, 0x8001800180028002});
REQUIRE(FP::FPSR{jit.GetFpsr()}.QC() == true);
}
TEST_CASE("A64: SQDMULH.4S (saturate)", "[a64]") {
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
emit_x64_vector: Changes to VectorSignedSaturatedDoublingMultiply * Return both the upper and lower parts of the multiply if required * SSE2 does not support the pmuldq instruction, do sign correction to an unsigned result instead * Improve port utilisation where possible (punpck instructions were a bottleneck)
2018-09-15 10:04:19 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0x4ea2b420); // SQDMULH.4S V0, V1, V2
env.code_mem.emplace_back(0x14000000); // B .
emit_x64_vector: Changes to VectorSignedSaturatedDoublingMultiply * Return both the upper and lower parts of the multiply if required * SSE2 does not support the pmuldq instruction, do sign correction to an unsigned result instead * Improve port utilisation where possible (punpck instructions were a bottleneck)
2018-09-15 10:04:19 +02:00
// Make sure that saturating values are tested
jit.SetPC(0);
jit.SetVector(1, {0x7fffffff80000000, 0x7fffffff80000000});
jit.SetVector(2, {0x7fffffff80000000, 0x800000007fffffff});
jit.SetFpsr(0);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0x7ffffffe7fffffff, 0x8000000180000001});
REQUIRE(FP::FPSR{jit.GetFpsr()}.QC() == true);
}
tests/a64: Reminder about hidden infinite loops
2020-04-23 19:11:45 +02:00
TEST_CASE("A64: This is an infinite loop if fast dispatch is enabled", "[a64]") {
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::UserConfig conf{&env};
conf.optimizations &= ~OptimizationFlag::FastDispatch;
A64::Jit jit{conf};
tests/a64: Reminder about hidden infinite loops
2020-04-23 19:11:45 +02:00
env.code_mem.emplace_back(0x2ef998fa);
env.code_mem.emplace_back(0x2ef41c11);
env.code_mem.emplace_back(0x0f07fdd8);
env.code_mem.emplace_back(0x9ac90d09);
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0xd63f0120); // BLR X9
env.code_mem.emplace_back(0x14000000); // B .
tests/a64: Reminder about hidden infinite loops
2020-04-23 19:11:45 +02:00
env.ticks_left = 6;
jit.Run();
}
constant_propagation_pass: Don't fold add if we nee flags Results in incorrect flags
2020-04-29 16:33:12 +02:00
Fix EXTR (flipped rgister order)
2022-11-16 22:10:39 +01:00
TEST_CASE("A64: EXTR", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x93d8fef7); // EXTR X23, X23, X24, #63
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetRegister(23, 0);
jit.SetRegister(24, 1);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetRegister(23) == 0);
}
Add test for isolated GetNZCVFromOp
2022-11-16 22:50:33 +01:00
TEST_CASE("A64: Isolated GetNZCVFromOp", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0xaa1f03f5); // MOV X21, XZR
env.code_mem.emplace_back(0x912a02da); // ADD X26, X22, #0xa80
env.code_mem.emplace_back(0x913662dc); // ADD X28, X22, #0xd98
env.code_mem.emplace_back(0x320003e8); // MOV W8, #1
env.code_mem.emplace_back(0xa9006bfc); // STP X28, X26, [SP]
env.code_mem.emplace_back(0x7200011f); // TST W8, #1
env.code_mem.emplace_back(0xf94007e8); // LDR X8, [SP, #8]
env.code_mem.emplace_back(0x321e03e3); // MOV W3, #4
env.code_mem.emplace_back(0xaa1303e2); // MOV X2, X19
env.code_mem.emplace_back(0x9a881357); // CSEL X23, X26, X8, NE
env.code_mem.emplace_back(0xf94003e8); // LDR X8, [SP]
env.code_mem.emplace_back(0xaa1703e0); // MOV X0, X23
env.code_mem.emplace_back(0x9a881396); // CSEL X22, X28, X8, NE
env.code_mem.emplace_back(0x92407ea8); // AND X8, X21, #0xffffffff
env.code_mem.emplace_back(0x1ac8269b); // LSR W27, W20, W8
env.code_mem.emplace_back(0x0b1b0768); // ADD W8, W27, W27, LSL #1
env.code_mem.emplace_back(0x937f7d01); // SBFIZ X1, X8, #1, #32
env.code_mem.emplace_back(0x2a1f03e4); // MOV W4, WZR
env.code_mem.emplace_back(0x531e7779); // LSL W25, W27, #2
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
env.ticks_left = 20;
jit.Run();
}
constant_propagation_pass: Don't fold add if we nee flags Results in incorrect flags
2020-04-29 16:33:12 +02:00
TEST_CASE("A64: Optimization failure when folding ADD", "[a64]") {
A64TestEnv env;
Add optimization flags to disable specific optimizations
2020-06-28 22:39:26 +02:00
A64::Jit jit{A64::UserConfig{&env}};
constant_propagation_pass: Don't fold add if we nee flags Results in incorrect flags
2020-04-29 16:33:12 +02:00
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0xbc4f84be); // LDR S30, [X5], #248
env.code_mem.emplace_back(0x9a0c00ea); // ADC X10, X7, X12
env.code_mem.emplace_back(0x5a1a0079); // SBC W25, W3, W26
env.code_mem.emplace_back(0x9b0e2be9); // MADD X9, XZR, X14, X10
env.code_mem.emplace_back(0xfa5fe8a9); // CCMP X5, #31, #9, AL
env.code_mem.emplace_back(0x14000000); // B .
constant_propagation_pass: Don't fold add if we nee flags Results in incorrect flags
2020-04-29 16:33:12 +02:00
jit.SetPC(0);
jit.SetRegister(0, 0x46e15845dba57924);
jit.SetRegister(1, 0x6f60d04350581fea);
jit.SetRegister(2, 0x85cface50edcfc03);
jit.SetRegister(3, 0x47e1e8906e10ec5a);
jit.SetRegister(4, 0x70717c9450b6b707);
jit.SetRegister(5, 0x300d83205baeaff4);
jit.SetRegister(6, 0xb7890de7c6fee082);
jit.SetRegister(7, 0xa89fb6d6f1b42f4a);
jit.SetRegister(8, 0x04e36b8aada91d4f);
jit.SetRegister(9, 0xa03bf6bde71c6ac5);
jit.SetRegister(10, 0x319374d14baa83b0);
jit.SetRegister(11, 0x5a78fc0fffca7c5f);
jit.SetRegister(12, 0xc012b5063f43b8ad);
jit.SetRegister(13, 0x821ade159d39fea1);
jit.SetRegister(14, 0x41f97b2f5525c25e);
jit.SetRegister(15, 0xab0cd3653cb93738);
jit.SetRegister(16, 0x50dfcb55a4ebd554);
jit.SetRegister(17, 0x30dd7d18ae52df03);
jit.SetRegister(18, 0x4e53b20d252bf085);
jit.SetRegister(19, 0x013582d71f5fd42a);
jit.SetRegister(20, 0x97a151539dad44e7);
jit.SetRegister(21, 0xa6fcc6bb220a2ad3);
jit.SetRegister(22, 0x4c84d3c84a6c5c5c);
jit.SetRegister(23, 0x1a7596a5ef930dff);
jit.SetRegister(24, 0x06248d96a02ff210);
jit.SetRegister(25, 0xfcb8772aec4b1dfd);
jit.SetRegister(26, 0x63619787b6a17665);
jit.SetRegister(27, 0xbd50c3352d001e40);
jit.SetRegister(28, 0x4e186aae63c81553);
jit.SetRegister(29, 0x57462b7163bd6508);
jit.SetRegister(30, 0xa977c850d16d562c);
jit.SetSP(0x000000da9b761d8c);
jit.SetFpsr(0x03480000);
jit.SetPstate(0x30000000);
env.ticks_left = 6;
jit.Run();
REQUIRE(jit.GetRegister(0) == 0x46e15845dba57924);
REQUIRE(jit.GetRegister(1) == 0x6f60d04350581fea);
REQUIRE(jit.GetRegister(2) == 0x85cface50edcfc03);
REQUIRE(jit.GetRegister(3) == 0x47e1e8906e10ec5a);
REQUIRE(jit.GetRegister(4) == 0x70717c9450b6b707);
REQUIRE(jit.GetRegister(5) == 0x300d83205baeb0ec);
REQUIRE(jit.GetRegister(6) == 0xb7890de7c6fee082);
REQUIRE(jit.GetRegister(7) == 0xa89fb6d6f1b42f4a);
REQUIRE(jit.GetRegister(8) == 0x04e36b8aada91d4f);
REQUIRE(jit.GetRegister(9) == 0x68b26bdd30f7e7f8);
REQUIRE(jit.GetRegister(10) == 0x68b26bdd30f7e7f8);
REQUIRE(jit.GetRegister(11) == 0x5a78fc0fffca7c5f);
REQUIRE(jit.GetRegister(12) == 0xc012b5063f43b8ad);
REQUIRE(jit.GetRegister(13) == 0x821ade159d39fea1);
REQUIRE(jit.GetRegister(14) == 0x41f97b2f5525c25e);
REQUIRE(jit.GetRegister(15) == 0xab0cd3653cb93738);
REQUIRE(jit.GetRegister(16) == 0x50dfcb55a4ebd554);
REQUIRE(jit.GetRegister(17) == 0x30dd7d18ae52df03);
REQUIRE(jit.GetRegister(18) == 0x4e53b20d252bf085);
REQUIRE(jit.GetRegister(19) == 0x013582d71f5fd42a);
REQUIRE(jit.GetRegister(20) == 0x97a151539dad44e7);
REQUIRE(jit.GetRegister(21) == 0xa6fcc6bb220a2ad3);
REQUIRE(jit.GetRegister(22) == 0x4c84d3c84a6c5c5c);
REQUIRE(jit.GetRegister(23) == 0x1a7596a5ef930dff);
REQUIRE(jit.GetRegister(24) == 0x06248d96a02ff210);
REQUIRE(jit.GetRegister(25) == 0x00000000b76f75f5);
REQUIRE(jit.GetRegister(26) == 0x63619787b6a17665);
REQUIRE(jit.GetRegister(27) == 0xbd50c3352d001e40);
REQUIRE(jit.GetRegister(28) == 0x4e186aae63c81553);
REQUIRE(jit.GetRegister(29) == 0x57462b7163bd6508);
REQUIRE(jit.GetRegister(30) == 0xa977c850d16d562c);
REQUIRE(jit.GetPstate() == 0x20000000);
REQUIRE(jit.GetVector(30) == Vector{0xf7f6f5f4, 0});
}
fixed data + instruction cache callbacks (w/ tests)
2020-11-12 17:15:33 +01:00
TEST_CASE("A64: Cache Maintenance Instructions", "[a64]") {
class CacheMaintenanceTestEnv final : public A64TestEnv {
void InstructionCacheOperationRaised(A64::InstructionCacheOperation op, VAddr value) override {
REQUIRE(op == A64::InstructionCacheOperation::InvalidateByVAToPoU);
REQUIRE(value == 0xcafed00d);
}
void DataCacheOperationRaised(A64::DataCacheOperation op, VAddr value) override {
REQUIRE(op == A64::DataCacheOperation::InvalidateByVAToPoC);
REQUIRE(value == 0xcafebabe);
}
};
CacheMaintenanceTestEnv env;
A64::UserConfig conf{&env};
conf.hook_data_cache_operations = true;
A64::Jit jit{conf};
jit.SetRegister(0, 0xcafed00d);
jit.SetRegister(1, 0xcafebabe);
Add .clang-format file Using clang-format version 12.0.0
2021-05-22 15:51:20 +02:00
env.code_mem.emplace_back(0xd50b7520); // ic ivau, x0
env.code_mem.emplace_back(0xd5087621); // dc ivac, x1
env.code_mem.emplace_back(0x14000000); // B .
fixed data + instruction cache callbacks (w/ tests)
2020-11-12 17:15:33 +01:00
env.ticks_left = 3;
jit.Run();
}
unit tests & various fixes
2020-06-21 19:29:55 +02:00
TEST_CASE("A64: Memory access (fastmem)", "[a64]") {
constexpr size_t address_width = 12;
tests: Format to clang-format mandated style
2021-05-31 13:54:27 +02:00
constexpr size_t memory_size = 1ull << address_width; // 4K
unit tests & various fixes
2020-06-21 19:29:55 +02:00
constexpr size_t page_size = 4 * 1024;
constexpr size_t buffer_size = 2 * page_size;
char buffer[buffer_size];
void* buffer_ptr = reinterpret_cast<void*>(buffer);
size_t buffer_size_nconst = buffer_size;
char* backing_memory = reinterpret_cast<char*>(std::align(page_size, memory_size, buffer_ptr, buffer_size_nconst));
A64FastmemTestEnv env{backing_memory};
Dynarmic::A64::UserConfig config{&env};
config.fastmem_pointer = backing_memory;
A64/config.h: Split fastmem and page_table options. We might want to allocate different sizes for each of them. e.g. for the unsafe fastmem approach without bounds checking. Or for using the full 48bit adress range (with mirrors) by allocating our real arena as close to 1<<47 as possible.
2021-06-05 12:20:21 +02:00
config.fastmem_address_space_bits = address_width;
unit tests & various fixes
2020-06-21 19:29:55 +02:00
config.recompile_on_fastmem_failure = false;
A64/config.h: Split fastmem and page_table options. We might want to allocate different sizes for each of them. e.g. for the unsafe fastmem approach without bounds checking. Or for using the full 48bit adress range (with mirrors) by allocating our real arena as close to 1<<47 as possible.
2021-06-05 12:20:21 +02:00
config.silently_mirror_fastmem = true;
unit tests & various fixes
2020-06-21 19:29:55 +02:00
config.processor_id = 0;
Dynarmic::A64::Jit jit{config};
memset(backing_memory, 0, memory_size);
memcpy(backing_memory + 0x100, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 57);
tests: Format to clang-format mandated style
2021-05-31 13:54:27 +02:00
env.MemoryWrite32(0, 0xA9401404); // LDP X4, X5, [X0]
env.MemoryWrite32(4, 0xF9400046); // LDR X6, [X2]
env.MemoryWrite32(8, 0xA9001424); // STP X4, X5, [X1]
env.MemoryWrite32(12, 0xF9000066); // STR X6, [X3]
env.MemoryWrite32(16, 0x14000000); // B .
unit tests & various fixes
2020-06-21 19:29:55 +02:00
jit.SetRegister(0, 0x100);
jit.SetRegister(1, 0x1F0);
jit.SetRegister(2, 0x10F);
jit.SetRegister(3, 0x1FF);
jit.SetPC(0);
jit.SetSP(memory_size - 1);
jit.SetFpsr(0x03480000);
jit.SetPstate(0x30000000);
env.ticks_left = 5;
jit.Run();
REQUIRE(strncmp(backing_memory + 0x100, backing_memory + 0x1F0, 23) == 0);
}
emit_x64_vector: Ensure FPSR.QC is set even if output is invalidated
2022-07-20 20:38:41 +02:00
TEST_CASE("A64: SQRDMULH QC flag when output invalidated", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x0fbcd38b); // SQRDMULH.2S V11, V28, V28[1]
env.code_mem.emplace_back(0x7ef0f8eb); // FMINP.2D D11, V7
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(7, {0xb1b5'd0b1'4e54'e281, 0xb4cb'4fec'8563'1032});
jit.SetVector(28, {0x8000'0000'0000'0000, 0x0000'0000'0000'0000});
jit.SetFpcr(0x05400000);
env.ticks_left = 3;
jit.Run();
REQUIRE(jit.GetFpsr() == 0x08000000);
REQUIRE(jit.GetVector(11) == Vector{0xb4cb'4fec'8563'1032, 0x0000'0000'0000'0000});
}
emit_x64_data_processing: Detect overflow on division
2022-11-29 15:15:03 +01:00
TEST_CASE("A64: SDIV maximally", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x9ac00c22); // SDIV X2, X1, X0
env.code_mem.emplace_back(0x14000000); // B .
jit.SetRegister(0, 0xffffffffffffffff);
jit.SetRegister(1, 0x8000000000000000);
jit.SetRegister(2, 0xffffffffffffffff);
jit.SetPC(0);
env.ticks_left = 2;
jit.Run();
REQUIRE(jit.GetRegister(0) == 0xffffffffffffffff);
REQUIRE(jit.GetRegister(1) == 0x8000000000000000);
REQUIRE(jit.GetRegister(2) == 0x8000000000000000);
REQUIRE(jit.GetPC() == 4);
}
emit_x64_floating_point: Fix register allocation bug in FPTwoOp Erroneous use of ScratchXmm in conditional path
2023-01-15 03:29:08 +01:00
// Restricted register set required to trigger:
// const HostLocList any_gpr = { HostLoc::RAX, HostLoc::RBX, HostLoc::RCX, HostLoc::R13, HostLoc::R14 };
// const HostLocList any_xmm = { HostLoc::XMM1, HostLoc::XMM2, HostLoc::XMM3, HostLoc::XMM4, HostLoc::XMM5, HostLoc::XMM6 };
TEST_CASE("A64: rand1", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem = {0x2ea2e69a, 0x6f7168e7, 0x7eb0f816, 0x6ebd369d, 0x1e65c302, 0x1e63011c, 0x1e67c349, 0x0f861bd6, 0x9e59cbbc, 0x5e61cb8b, 0x6e218b01, 0x4eb2409f, 0x7f7c2452, 0x7e207a8d, 0xd503369f};
env.code_mem.emplace_back(0x14000000); // B .
jit.SetRegister(0, 0x67e1d59cc30a788c);
jit.SetRegister(1, 0x0e771a2a79dfb060);
jit.SetRegister(2, 0x35cc7e7831247f7c);
jit.SetRegister(3, 0x63a22cce1f9cde66);
jit.SetRegister(4, 0xb6a022d8406543a3);
jit.SetRegister(5, 0x6712e272c4ad27a0);
jit.SetRegister(6, 0x9d2a01c3bc374837);
jit.SetRegister(7, 0x83bc2f62feb76043);
jit.SetRegister(8, 0x9ba9e8c3d543f1bf);
jit.SetRegister(9, 0xe4aee4636277b787);
jit.SetRegister(10, 0x9cd9e201dacc233b);
jit.SetRegister(11, 0x39e0a5c3bb44efc9);
jit.SetRegister(12, 0xca229296c29f8742);
jit.SetRegister(13, 0x4cdf038f1323ff2d);
jit.SetRegister(14, 0x377ad499a81b1f5a);
jit.SetRegister(15, 0x8217307060f11c6d);
jit.SetRegister(16, 0xd1af2e75ea62dba7);
jit.SetRegister(17, 0x77661148c760e9d6);
jit.SetRegister(18, 0xf05a251f9cf60f9e);
jit.SetRegister(19, 0xf54301927e8fa020);
jit.SetRegister(20, 0x534c76f6f6d6805c);
jit.SetRegister(21, 0x60240c3e727aae2d);
jit.SetRegister(22, 0x52b82c212af254d6);
jit.SetRegister(23, 0xb0ad501210d12c07);
jit.SetRegister(24, 0x596a9119514f3460);
jit.SetRegister(25, 0xa933e19b69b2c6f7);
jit.SetRegister(26, 0x6f3693ec0f5e7708);
jit.SetRegister(27, 0xc6a3908a03fb9737);
jit.SetRegister(28, 0x113ba38d50953b60);
jit.SetRegister(29, 0xbe5395907134511e);
jit.SetRegister(30, 0x9a5d96aa066e5c39);
jit.SetPC(0);
jit.SetSP(0x000000c6bec5a48c);
jit.SetVector(0, {0x0faa90e6561b1ffb, 0xb8c1c925ee613293});
jit.SetVector(1, {0x3fa365cf7a4f3eaa, 0xbd0fabf98eb5c061});
jit.SetVector(2, {0x3d7722d0e4444b00, 0xf30ba88476b79615});
jit.SetVector(3, {0xf794f4953fb4a413, 0xedd6426638cf0242});
jit.SetVector(4, {0x1ddfdd8985c58693, 0xc344d565e68ab18b});
jit.SetVector(5, {0x600fcef72b18ae5f, 0x3af9964747ff06b9});
jit.SetVector(6, {0x276b755d4452ec74, 0xf5579ddb0f2146b4});
jit.SetVector(7, {0xd1823739c80439e5, 0xd8c4bc8cf08fce6e});
jit.SetVector(8, {0x0e4c8796dca46ad0, 0x53293d124cd38d6e});
jit.SetVector(9, {0x860e30c54fcbe0b8, 0x09c57c6b723e45f5});
jit.SetVector(10, {0xe3652801c3d11ddb, 0x4ef5f76fa85d28b9});
jit.SetVector(11, {0xa6c22b4e20d5a3a2, 0x5b98938307afb538});
jit.SetVector(12, {0x915960a26d2d8c02, 0x0ecdf8bc35c8a184});
jit.SetVector(13, {0xa79a1f506ed066b4, 0x23de2152171ce4c6});
jit.SetVector(14, {0xd4b85ed863708645, 0x3cf7b2693ac76d3f});
jit.SetVector(15, {0x8900b9888729557b, 0x2eeeef32083bf9b9});
jit.SetVector(16, {0x0b40331c7fc30b54, 0xcb5fb7d6ca96ccca});
jit.SetVector(17, {0x0040b87ea24910c7, 0x97f925750c5da4c5});
jit.SetVector(18, {0xf19de744c8c88b3d, 0xa1406fae21f53d8c});
jit.SetVector(19, {0x02b6e985e99a6a3d, 0xe470d5328c9b2af5});
jit.SetVector(20, {0x6bfb919ed9752198, 0xcaab56c2adc2c486});
jit.SetVector(21, {0x4c1dd31e9fb91bae, 0xe1d4a4b936d1dfab});
jit.SetVector(22, {0x5d8c08ee0dbe758a, 0xb1b25da077a0ba26});
jit.SetVector(23, {0xf1f3377346a6e4db, 0x4995274fe7e17908});
jit.SetVector(24, {0xa1c4d7cca6fe8a95, 0xb267a94646819606});
jit.SetVector(25, {0x8bbe1a250a008e73, 0xc729df1ac7eeb7d3});
jit.SetVector(26, {0x48c23bc8ce6857d5, 0x35bb31ef278268d7});
jit.SetVector(27, {0x0473d63f3f0c5075, 0xf4bb5d79938901f4});
jit.SetVector(28, {0x01e2930f7313493e, 0xdc6ef4adadcc8e37});
jit.SetVector(29, {0x2c500da43b460d13, 0x7bb4520d5580a648});
jit.SetVector(30, {0xdf4e3d139b825da0, 0x19fea0310522fda2});
jit.SetVector(31, {0xf8b440b8d5e25111, 0x73758151a32b6b13});
jit.SetPstate(0x60000000);
jit.SetFpcr(0x01080000);
env.ticks_left = 16;
jit.Run();
REQUIRE(jit.GetRegister(0) == 0x67e1d59cc30a788c);
REQUIRE(jit.GetRegister(1) == 0x0e771a2a79dfb060);
REQUIRE(jit.GetRegister(2) == 0x35cc7e7831247f7c);
REQUIRE(jit.GetRegister(3) == 0x63a22cce1f9cde66);
REQUIRE(jit.GetRegister(4) == 0xb6a022d8406543a3);
REQUIRE(jit.GetRegister(5) == 0x6712e272c4ad27a0);
REQUIRE(jit.GetRegister(6) == 0x9d2a01c3bc374837);
REQUIRE(jit.GetRegister(7) == 0x83bc2f62feb76043);
REQUIRE(jit.GetRegister(8) == 0x9ba9e8c3d543f1bf);
REQUIRE(jit.GetRegister(9) == 0xe4aee4636277b787);
REQUIRE(jit.GetRegister(10) == 0x9cd9e201dacc233b);
REQUIRE(jit.GetRegister(11) == 0x39e0a5c3bb44efc9);
REQUIRE(jit.GetRegister(12) == 0xca229296c29f8742);
REQUIRE(jit.GetRegister(13) == 0x4cdf038f1323ff2d);
REQUIRE(jit.GetRegister(14) == 0x377ad499a81b1f5a);
REQUIRE(jit.GetRegister(15) == 0x8217307060f11c6d);
REQUIRE(jit.GetRegister(16) == 0xd1af2e75ea62dba7);
REQUIRE(jit.GetRegister(17) == 0x77661148c760e9d6);
REQUIRE(jit.GetRegister(18) == 0xf05a251f9cf60f9e);
REQUIRE(jit.GetRegister(19) == 0xf54301927e8fa020);
REQUIRE(jit.GetRegister(20) == 0x534c76f6f6d6805c);
REQUIRE(jit.GetRegister(21) == 0x60240c3e727aae2d);
REQUIRE(jit.GetRegister(22) == 0x52b82c212af254d6);
REQUIRE(jit.GetRegister(23) == 0xb0ad501210d12c07);
REQUIRE(jit.GetRegister(24) == 0x596a9119514f3460);
REQUIRE(jit.GetRegister(25) == 0xa933e19b69b2c6f7);
REQUIRE(jit.GetRegister(26) == 0x6f3693ec0f5e7708);
REQUIRE(jit.GetRegister(27) == 0xc6a3908a03fb9737);
REQUIRE(jit.GetRegister(28) == 0x0000000000000000);
REQUIRE(jit.GetRegister(29) == 0xbe5395907134511e);
REQUIRE(jit.GetRegister(30) == 0x9a5d96aa066e5c39);
}
tests: Ensure issue #727 resolved
2023-01-15 03:45:05 +01:00
TEST_CASE("A64: rand2", "[a64][.]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{.callbacks = &env, .fastmem_pointer = reinterpret_cast<void*>(0xffffffff00000000)}};
env.code_mem = {0xea80f352, 0x6e65e59d, 0x1e20c343, 0x2e3a7192, 0x2e267249, 0xd500405f, 0x6f01f461, 0x6eb684fc, 0x58028edd, 0x0ea5f5b6, 0x0ea069fb, 0x2e769517, 0x5e066063, 0x1e65c3f5, 0x4f00ff52, 0x93401cf6, 0x1e274248, 0x6f67aaf5, 0x5e0c0782, 0x5ef43f3c, 0x2e6595b7, 0x4e20590f, 0xb35aa451, 0x6ee2c5ed, 0x4e32bf46, 0x2ea1ba8f, 0x2f68a85e, 0x9237d90a, 0x5e23dd10, 0x0e762e32, 0x4e31a8cf, 0xce1f3360, 0x781a4ac0, 0x13834066, 0x5fa8101c, 0x6f7c5594, 0x0e71bb68, 0xbc0b3e8f, 0x785dbbda, 0x6f51e794, 0xce50af75, 0x1ad728ec, 0x6ee0da4c, 0xb84efa14, 0x2eb3f613, 0x4e287ade, 0x4eb8c734, 0x2e83f4e8, 0x0e397c80, 0xd08f93f8, 0xce718e48, 0x0f672a0d, 0x2e9edd40, 0x0e14128b, 0x6f5942e6, 0x8b3a0f03, 0x3c5d16b9, 0x7f7e3743, 0x4f4c54e4, 0x0ea0a9e9, 0x9e59dbe6, 0x6e7ddcd3, 0xcec08377, 0x9ba759f8, 0x2ea5046e, 0x0e24c569, 0xb8979780, 0x4e31b98c, 0x4efe4f46, 0x4ea7c762, 0x7e61c9c6, 0x6e30c880, 0x1ada0c25, 0x4e603a2f, 0xda9d7218, 0x0d40c5d9, 0x5e214b05, 0x9ba9efc5, 0x5e61b81e, 0x6e7bc31c, 0x0e61a163, 0x9e5832d2, 0x4e772248, 0x4e3d17c8, 0x92624f60, 0x7a1a02dc, 0x79891f65, 0x6eb45036, 0x0e321ee8, 0x4e2566f0, 0x4ea02b9b, 0x0f9dcb3d, 0x2e21b9f9, 0x0e21a8c3, 0xda1700bd, 0x6ea0fb38, 0x7e607a0b, 0x72845817, 0x7f61068e, 0x0d60e529, 0x4ea0ca5c, 0x1a94b20f, 0x8b87419d, 0x7ea9ed71, 0x2ea1a86e, 0x4d40c4da, 0x5ea0eada, 0x784ba96e, 0x7eb6ee02, 0x3db1c710, 0x0e217836, 0x7ee0bb96, 0x4e786c08, 0x4e976a08, 0x489ffe86, 0x4e79fc9b, 0x0e21cbce, 0x5ef7fc65, 0x4ea1286d, 0xd29c771e, 0x6f5c2839, 0x0ea00a9d, 0x6ee44c06, 0x5ee1d858, 0x5ef2fda6, 0x7eb0c9fe, 0x7f762791, 0x2e212ae6, 0x4e61c9db, 0x13003c57, 0x5ee1b8f8, 0x0f2396d2, 0x6ea0db1e, 0x0e71ba82, 0xab29c807, 0x6ef8f8b3, 0x1f18d4a1, 0x0e261d15, 0x1e290081, 0x1b0c7d12, 0x4e7771c3, 0xf845f1e4, 0x4d40c9e8, 0xce778452, 0x6eb9879d, 0x6e21c93d, 0xcec0829f, 0x52a0969f, 0x1e772b4f, 0x7ee1da88, 0x5f52fe0a, 0x7f3387b1, 0x5e214850, 0x1e65c025, 0x0e2ca294, 0x2e614829, 0x1e640077, 0x9e240048, 0x4ebe9537, 0x9bb7925e, 0x38b669c5, 0x2840d089, 0x6f43e648, 0x2e662d28, 0x4eabaff3, 0x6e734cc7, 0x0e31baee, 0x7ee0d93c, 0x5e282bde, 0x7e21bba4, 0x4e6c75fa, 0x5ac01217, 0x7f4304af, 0x1e7878ed, 0x1ada2196, 0x7ee1aba3, 0x93407f3c, 0x4f6c34eb, 0x6e3447a9, 0x7e7ae545, 0x5e0802bb, 0x6eeae63a, 0x7ee1da62, 0x5e280bb3, 0xf81d4009, 0x1e603b21, 0x5e281a14, 0x6eb0a99b, 0x1e266a25, 0x0d60cafe, 0x0e0b6194, 0x7a4ed2c5, 0x92b762ec, 0x4e6b5749, 0x3c16a6e5, 0x4ea0a92b, 0x0fa58b6a, 0x5f76148c, 0x6e30c95f, 0x1e6540fd, 0x5e28e40f, 0x0d403fd4, 0x7e30da36, 0x7fda9b51, 0x2ea04bde, 0x1e25c3d2, 0x1ee0434c, 0x5e21d8e7, 0x5ee1ba51, 0x5e61aba9, 0x4e2849fb, 0x5ee098ea, 0x4e60f63d, 0x0f280443, 0x5ee0da27, 0x2e78a6ce, 0x78054afc, 0x4e14286b, 0x4e218bd8, 0x2a3d2551, 0x3a04017a, 0x5f4317cd, 0x0e604a37, 0x9a834614, 0x0e2edf4d, 0x7a51a0a0, 0x5f8e9043, 0x6ea06bb2, 0xaa2857dd, 0x7a1903fc, 0x301ba9ba, 0x9ac929cd, 0x4e061ff0, 0x2e38fcfc, 0x0e2f614a, 0x7ee0d8e4, 0x6e73afda, 0x7f4156f7, 0x0e6078bf, 0x4ee1d9ed, 0x93403fbe, 0xce6f8640, 0x4e3855e3, 0x6f76fe23, 0x112466e8, 0x1e358a90, 0x7f45272c, 0x6ea19a9d, 0x8a696350, 0x1e3900f6, 0x5e61c866, 0x0e3fbfd0, 0x5ee09ad0, 0x0e651d27, 0x4dffc35e, 0x2e20c6ce, 0x0fbe118d, 0x1e656a15, 0xd1357365, 0x0e20a847, 0xce4a835c, 0x4e203905, 0x2e60090d, 0x7f4a27bb, 0x1e64c316, 0xce7d86a4, 0x7ebded2d, 0x6e70a97e, 0x4eb9a42b, 0x0e209bef, 0x6f151730, 0x0e7e30f7, 0x4e724509, 0xd503375f, 0xce58b6ae, 0x5e21a9b8, 0xcb2ca538, 0x5ac01131, 0x6ea19a24, 0xeb40c8b3, 0xc8df7d65, 0x78108341, 0x3218ab9b, 0x0f3da7dd, 0x2e003089, 0x4e21cab5, 0x8aa5c924, 0x1a94950c, 0x123e506f, 0x13117e37, 0x1ee6005b, 0x5ac00647, 0x5eec8cd5, 0x7ef0fb3d, 0x9223272a, 0x5ee0cb02, 0x6e66071d, 0x6ea1dbbf, 0x5e61c903, 0x5ac015ea, 0x93db6206, 0x7e62b5e3, 0x6ea0c87b, 0xdac0090e, 0x48df7d90, 0x6e206ba5, 0x9e2503c2, 0x6e25fc89, 0x4d60e2db, 0x1e3e22a0, 0x2eb81c19, 0x7856ea00, 0x5fbfb22d, 0x1e630244, 0x4e202a83, 0x1f50a722, 0x7f7b55d2, 0x0fae89b9, 0x4e781d73, 0xce738c3a, 0x4f15a591, 0x6e21c7e1, 0x586ff77e, 0x8a5d3592, 0x93401c67, 0x5e61cb86, 0xce6bc2c1, 0x6e393f10, 0x9bb70ec3, 0xdac0098c, 0x4da84b95, 0x7f494476, 0x9ace5c11, 0x7e61ca14, 0x4f7a60ef, 0x1ad32b39, 0x0ea3777f, 0x5e61da7f, 0x4f1404e2, 0x4e324
env.code_mem.emplace_back(0x14000000); // B .
jit.SetRegister(0, 0x866524401a1d4e47);
jit.SetRegister(1, 0x02ca8cec51301b60);
jit.SetRegister(2, 0x0d2e0921242a853d);
jit.SetRegister(3, 0x5ce3dda7d19ec198);
jit.SetRegister(4, 0x8a608e22fb3f50d9);
jit.SetRegister(5, 0x97eab1c959f550bb);
jit.SetRegister(6, 0xdb6d004e7503e72a);
jit.SetRegister(7, 0xbc585cf4f01fee85);
jit.SetRegister(8, 0xd7873927978802ca);
jit.SetRegister(9, 0xf64d146839cc0275);
jit.SetRegister(10, 0xada655f0c8013f78);
jit.SetRegister(11, 0x9c06b18d34ad718a);
jit.SetRegister(12, 0xaa46ab9693a7549f);
jit.SetRegister(13, 0xdc0392ca7ded1f12);
jit.SetRegister(14, 0xb86b5a280b452d1e);
jit.SetRegister(15, 0x4cafeaf58ccf472e);
jit.SetRegister(16, 0x21fcba85c1ed26ba);
jit.SetRegister(17, 0xca8075f2eb56e277);
jit.SetRegister(18, 0x3f06bc758608d762);
jit.SetRegister(19, 0xbbc5a0aecff698e5);
jit.SetRegister(20, 0x02170439baa29e14);
jit.SetRegister(21, 0x0e7a29e1ab81b89b);
jit.SetRegister(22, 0xe8af1b958d645884);
jit.SetRegister(23, 0x86691d7e0500e2e9);
jit.SetRegister(24, 0x4983e6e57f0602c1);
jit.SetRegister(25, 0x4077d562a05048c5);
jit.SetRegister(26, 0x7019154cfcba3e12);
jit.SetRegister(27, 0xfb17997ce5f6a4ce);
jit.SetRegister(28, 0x6eb7a6b778e3dbca);
jit.SetRegister(29, 0x2ca051e70a4743be);
jit.SetRegister(30, 0x91fcc5fdd8a78378);
jit.SetPC(100);
jit.SetSP(0x000000cdfadeaff0);
env.code_mem_start_address = 100;
jit.SetVector(0, {0x4d5a180ac0ffdac8, 0xfc6eb113cd5ff2a8});
jit.SetVector(1, {0x39f8cecc9de9cefd, 0x3a6b35d333d89a6b});
jit.SetVector(2, {0x791fd8290bbdd2f4, 0xdc0e5e7aee311411});
jit.SetVector(3, {0xd97db4cbd67fe7de, 0x50042a5e0b94f71c});
jit.SetVector(4, {0xe2b93543509f65a7, 0xaa1b6433c337c5b9});
jit.SetVector(5, {0xd93ee9fc22c5edf7, 0xe9042e8f2a2279d3});
jit.SetVector(6, {0x988cf27e5c9928ad, 0xc1a39aa7429018af});
jit.SetVector(7, {0x8f24fd7c96752d5e, 0x211ed066df4bf60d});
jit.SetVector(8, {0xec12260921aa0e5d, 0xcb98d7c3aa39bb54});
jit.SetVector(9, {0x8ae0d63bef16836b, 0x54b582f6c7c563d5});
jit.SetVector(10, {0xd36cb5833320a802, 0x94afbd35a90c0d01});
jit.SetVector(11, {0xf80d24f3de920bb5, 0x8505fd820fdca5ac});
jit.SetVector(12, {0xc4d5ee040479c10a, 0xb9a65305f855b401});
jit.SetVector(13, {0xe258117dea0e2e1d, 0x50b6e47f2cbbf98f});
jit.SetVector(14, {0x8c46631befe40367, 0x76ef634acc1d252e});
jit.SetVector(15, {0x31ba2e4997445a39, 0xeea2b7e296ed9a10});
jit.SetVector(16, {0xb1b6ad7f6888ad82, 0x22d61f3a89e351f2});
jit.SetVector(17, {0x38556d902cb1e166, 0xd94cd8ece8871a9b});
jit.SetVector(18, {0x8022388e51111894, 0x8319843c0f97c296});
jit.SetVector(19, {0x80950f4f1988738e, 0x2b51d501a2ac843e});
jit.SetVector(20, {0xd959d91895a0e304, 0xd86a18f9fbca97cd});
jit.SetVector(21, {0x9b06de585c91b8f6, 0x6a27b488c3137c9c});
jit.SetVector(22, {0x95970398b8941fde, 0x85f81fbbf5989d74});
jit.SetVector(23, {0x33926666f9db44d7, 0xf36ed3933d067e0f});
jit.SetVector(24, {0x1aefb2ab9a149525, 0xbff5abf69badf81f});
jit.SetVector(25, {0x88492c5b044f4d83, 0x3fc4029fe302c62c});
jit.SetVector(26, {0x0cfcc374a4866662, 0xcec449f82b95bc0f});
jit.SetVector(27, {0x54506ca290052cf6, 0x22f41aa29a475adb});
jit.SetVector(28, {0x7baf46a55161f432, 0xe7426c082b417919});
jit.SetVector(29, {0x03a801b9d543654e, 0xb78f7f602ad245ee});
jit.SetVector(30, {0x656014c093d5ef4a, 0x180caaef9d32e7ab});
jit.SetVector(31, {0xb6f6e9d497f143b9, 0x1c52381350356431});
jit.SetPstate(0xb0000000);
jit.SetFpcr(0x01000000);
env.ticks_left = 110;
jit.Run();
REQUIRE(jit.GetVector(0) == Vector{0x0101010211914707, 0x090000007fd9991a});
REQUIRE(jit.GetVector(1) == Vector{0x00000000fffffffe, 0x0000000000000000});
REQUIRE(jit.GetVector(2) == Vector{0x05004503877a2f45, 0x0000000000000000});
REQUIRE(jit.GetVector(3) == Vector{0x000000007f800000, 0x0000000000000000});
REQUIRE(jit.GetVector(4) == Vector{0xffffffff00000000, 0x0000000000000000});
REQUIRE(jit.GetVector(5) == Vector{0xda00894d7886d0bb, 0x5cc5a3b2ca6afb26});
REQUIRE(jit.GetVector(6) == Vector{0x0000000000000000, 0xfffffffd00000000});
REQUIRE(jit.GetVector(7) == Vector{0x0000000000000000, 0x0000000000000000});
REQUIRE(jit.GetVector(8) == Vector{0x0000000000000000, 0x0000000000000000});
REQUIRE(jit.GetVector(9) == Vector{0x00000000ff800000, 0x0000000000000000});
REQUIRE(jit.GetVector(10) == Vector{0xc000000000000000, 0x0000000000000000});
REQUIRE(jit.GetVector(11) == Vector{0xffff000000000000, 0x0000000000000000});
REQUIRE(jit.GetVector(12) == Vector{0x0c0bd08451d5d9b3, 0x0000000000000000});
REQUIRE(jit.GetVector(13) == Vector{0x0000000000000000, 0xdc1e34ac00000000});
REQUIRE(jit.GetVector(14) == Vector{0x00000000ffffffff, 0x0000000000000000});
REQUIRE(jit.GetVector(15) == Vector{0xfbdfff7cf38fba7d, 0xfffffffffffffffe});
REQUIRE(jit.GetVector(16) == Vector{0x0000000000000000, 0x0000000000000000});
REQUIRE(jit.GetVector(17) == Vector{0x0000000000000000, 0x0000000000000000});
REQUIRE(jit.GetVector(18) == Vector{0x00000000ffffffff, 0x0000000000000000});
REQUIRE(jit.GetVector(19) == Vector{0x0000000000000000, 0x090000007fd9991a});
REQUIRE(jit.GetVector(20) == Vector{0x0000000000000000, 0x0000000000000000});
REQUIRE(jit.GetVector(21) == Vector{0xdbdad9d8dbdad9d8, 0xdbdad9d8dbdad9d8});
REQUIRE(jit.GetVector(22) == Vector{0xdbdad9d8dbdad9d8, 0xdbdad9d8dbdad9d8});
REQUIRE(jit.GetVector(23) == Vector{0xffffffff00000000, 0x0000000000000000});
REQUIRE(jit.GetVector(24) == Vector{0xffffffffffffffff, 0x0000000000000000});
REQUIRE(jit.GetVector(25) == Vector{0x0000007f00000000, 0x0000000000000000});
REQUIRE(jit.GetVector(26) == Vector{0x0000000000000000, 0x0000000000000000});
REQUIRE(jit.GetVector(27) == Vector{0x3a7d96116b237d60, 0x0c6bd37dd698d82a});
REQUIRE(jit.GetVector(28) == Vector{0x8000000000000000, 0x0000000000000000});
REQUIRE(jit.GetVector(29) == Vector{0xb3b2000000000000, 0x0000000000000000});
REQUIRE(jit.GetVector(30) == Vector{0x0000000000000000, 0x8080808080808080});
REQUIRE(jit.GetVector(31) == Vector{0xb3b2b3b200000000, 0x0000000000000000});
}
tests/A64: Add VUZP{1,2}.S unit tests
2023-12-02 19:35:51 +01:00
tests/A64: Add remaining UZP unit tests. Additionally changed the numeric values of the test vectors in the 32-bit element tests to match the pattern of the other tests - this makes it easier to tell at a glance what elements are out of place if a test fails.
2023-12-15 03:03:39 +01:00
TEST_CASE("A64: UZP{1,2}.2D", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x4ec11802); // UZP1 V2.2D, V0.2D, V1.2D
env.code_mem.emplace_back(0x4ec15803); // UZP2 V3.2D, V0.2D, V1.2D
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0xF0F1F2F3F4F5F6F7, 0xE0E1E2E2E4E5E6E7});
jit.SetVector(1, {0xA0A1A2A3A4A5A6A7, 0xB0B1B2B3B4B5B6B7});
env.ticks_left = 3;
jit.Run();
REQUIRE(jit.GetVector(2) == Vector{0xF0F1F2F3F4F5F6F7, 0xA0A1A2A3A4A5A6A7});
REQUIRE(jit.GetVector(3) == Vector{0xE0E1E2E2E4E5E6E7, 0xB0B1B2B3B4B5B6B7});
}
tests/A64: Add VUZP{1,2}.S unit tests
2023-12-02 19:35:51 +01:00
TEST_CASE("A64: UZP{1,2}.S", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x0e811802); // UZP1 V2.2S, V0.2S, V1.2S
env.code_mem.emplace_back(0x0e815803); // UZP2 V3.2S, V0.2S, V1.2S
env.code_mem.emplace_back(0x4e811804); // UZP1 V4.4S, V0.4S, V1.4S
env.code_mem.emplace_back(0x4e815805); // UZP2 V5.4S, V0.4S, V1.4S
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
tests/A64: Add remaining UZP unit tests. Additionally changed the numeric values of the test vectors in the 32-bit element tests to match the pattern of the other tests - this makes it easier to tell at a glance what elements are out of place if a test fails.
2023-12-15 03:03:39 +01:00
jit.SetVector(0, {0xF4F5F6F7'F0F1F2F3, 0xE4E5E6E7'E0E1E2E3});
jit.SetVector(1, {0xA4A5A6A7'A0A1A2A3, 0xB4B5B6B7'B0B1B2B3});
tests/A64: Add VUZP{1,2}.S unit tests
2023-12-02 19:35:51 +01:00
env.ticks_left = 5;
jit.Run();
tests/A64: Add remaining UZP unit tests. Additionally changed the numeric values of the test vectors in the 32-bit element tests to match the pattern of the other tests - this makes it easier to tell at a glance what elements are out of place if a test fails.
2023-12-15 03:03:39 +01:00
REQUIRE(jit.GetVector(2) == Vector{0xA0A1A2A3'F0F1F2F3, 0});
REQUIRE(jit.GetVector(3) == Vector{0xA4A5A6A7'F4F5F6F7, 0});
REQUIRE(jit.GetVector(4) == Vector{0xE0E1E2E3'F0F1F2F3, 0xB0B1B2B3'A0A1A2A3});
REQUIRE(jit.GetVector(5) == Vector{0xE4E5E6E7'F4F5F6F7, 0xB4B5B6B7'A4A5A6A7});
tests/A64: Add VUZP{1,2}.S unit tests
2023-12-02 19:35:51 +01:00
}
tests/A64: Add VUZP{1,2}.H unit tests
2023-12-10 00:40:27 +01:00
TEST_CASE("A64: UZP{1,2}.H", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x0e411802); // UZP1 V2.4H, V0.4H, V1.4H
env.code_mem.emplace_back(0x0e415803); // UZP2 V3.4H, V0.4H, V1.4H
env.code_mem.emplace_back(0x4e411804); // UZP1 V4.8H, V0.8H, V1.8H
env.code_mem.emplace_back(0x4e415805); // UZP2 V5.8H, V0.8H, V1.8H
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0xF6F7'F4F5'F2F3'F0F1, 0xE6E7'E4E5'E2E3'E0E1});
jit.SetVector(1, {0xA6A7'A4A5'A2A3'A0A1, 0xB6B7'B4B5'B2B3'B0B1});
env.ticks_left = 5;
jit.Run();
REQUIRE(jit.GetVector(2) == Vector{0xA4A5'A0A1'F4F5'F0F1, 0});
REQUIRE(jit.GetVector(3) == Vector{0xA6A7'A2A3'F6F7'F2F3, 0});
REQUIRE(jit.GetVector(4) == Vector{0xE4E5'E0E1'F4F5'F0F1, 0xB4B5'B0B1'A4A5'A0A1});
REQUIRE(jit.GetVector(5) == Vector{0xE6E7'E2E3'F6F7'F2F3, 0xB6B7'B2B3'A6A7'A2A3});
}
tests/A64: Add remaining UZP unit tests. Additionally changed the numeric values of the test vectors in the 32-bit element tests to match the pattern of the other tests - this makes it easier to tell at a glance what elements are out of place if a test fails.
2023-12-15 03:03:39 +01:00
TEST_CASE("A64: UZP{1,2}.B", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x0e011802); // UZP1 V2.8B, V0.8B, V1.8B
env.code_mem.emplace_back(0x0e015803); // UZP2 V3.8B, V0.8B, V1.8B
env.code_mem.emplace_back(0x4e011804); // UZP1 V4.16B, V0.16B, V1.16B
env.code_mem.emplace_back(0x4e015805); // UZP2 V5.16B, V0.16B, V1.16B
env.code_mem.emplace_back(0x14000000); // B .
jit.SetPC(0);
jit.SetVector(0, {0xF7'F6'F5'F4'F3'F2'F1'F0, 0xE7'E6'E5'E4'E3'E2'E1'E0});
jit.SetVector(1, {0xA7'A6'A5'A4'A3'A2'A1'A0, 0xB7'B6'B5'B4'B3'B2'B1'B0});
env.ticks_left = 5;
jit.Run();
REQUIRE(jit.GetVector(2) == Vector{0xA6'A4'A2'A0'F6'F4'F2'F0, 0});
REQUIRE(jit.GetVector(3) == Vector{0xA7'A5'A3'A1'F7'F5'F3'F1, 0});
REQUIRE(jit.GetVector(4) == Vector{0xE6'E4'E2'E0'F6'F4'F2'F0, 0xB6'B4'B2'B0'A6'A4'A2'A0});
REQUIRE(jit.GetVector(5) == Vector{0xE7'E5'E3'E1'F7'F5'F3'F1, 0xB7'B5'B3'B1'A7'A5'A3'A1});
}
tests/A64: Add {U,S}MINP.S, {U,S}MAXP.S tests
2024-01-02 04:16:02 +01:00
TEST_CASE("A64: {S,U}MINP.S, {S,U}MAXP.S", "[a64]") {
A64TestEnv env;
A64::Jit jit{A64::UserConfig{&env}};
env.code_mem.emplace_back(0x0ea1ac02); // SMINP V2.2S, V0.2S, V1.2S
env.code_mem.emplace_back(0x2ea1ac03); // UMINP V3.2S, V0.2S, V1.2S
env.code_mem.emplace_back(0x4ea1ac04); // SMINP V4.4S, V0.4S, V1.4S
env.code_mem.emplace_back(0x6ea1ac05); // UMINP V5.4S, V0.4S, V1.4S
env.code_mem.emplace_back(0x0ea1a406); // SMAXP V6.2S, V0.2S, V1.2S
env.code_mem.emplace_back(0x2ea1a407); // UMAXP V7.2S, V0.2S, V1.2S
env.code_mem.emplace_back(0x4ea1a408); // SMAXP V8.4S, V0.4S, V1.4S
env.code_mem.emplace_back(0x6ea1a409); // UMAXP V9.4S, V0.4S, V1.4S
env.code_mem.emplace_back(0x14000000); // B .
constexpr std::array<Vector, 12> vectors = {
// initial input vectors [0-1]
Vector{0x00000003'00000002, 0xF1234567'01234567},
Vector{0x80000000'7FFFFFFF, 0x76543210'76543209},
// expected output vectors [2-9]
Vector{0x80000000'00000002, 0},
Vector{0x7FFFFFFF'00000002, 0},
Vector{0xF1234567'00000002, 0x76543209'80000000},
Vector{0x01234567'00000002, 0x76543209'7FFFFFFF},
Vector{0x7FFFFFFF'00000003, 0},
Vector{0x80000000'00000003, 0},
Vector{0x01234567'00000003, 0x76543210'7FFFFFFF},
Vector{0xF1234567'00000003, 0x76543210'80000000},
// input vectors with elements swapped pairwise [10-11]
Vector{0x00000002'00000003, 0x01234567'F1234567},
Vector{0x7FFFFFFF'80000000, 0x76543209'76543210},
};
jit.SetPC(0);
jit.SetVector(0, vectors[0]);
jit.SetVector(1, vectors[1]);
env.ticks_left = 9;
jit.Run();
CHECK(jit.GetVector(2) == vectors[2]);
CHECK(jit.GetVector(3) == vectors[3]);
CHECK(jit.GetVector(4) == vectors[4]);
CHECK(jit.GetVector(5) == vectors[5]);
CHECK(jit.GetVector(6) == vectors[6]);
CHECK(jit.GetVector(7) == vectors[7]);
CHECK(jit.GetVector(8) == vectors[8]);
CHECK(jit.GetVector(9) == vectors[9]);
// run the same tests again but with the input vectors swapped pairwise,
// to ensure we aren't randomly producing the correct values
jit.SetPC(0);
jit.SetVectors(std::array<Vector, 32>{});
jit.SetVector(0, vectors[10]);
jit.SetVector(1, vectors[11]);
env.ticks_left = 9;
jit.Run();
CHECK(jit.GetVector(2) == vectors[2]);
CHECK(jit.GetVector(3) == vectors[3]);
CHECK(jit.GetVector(4) == vectors[4]);
CHECK(jit.GetVector(5) == vectors[5]);
CHECK(jit.GetVector(6) == vectors[6]);
CHECK(jit.GetVector(7) == vectors[7]);
CHECK(jit.GetVector(8) == vectors[8]);
CHECK(jit.GetVector(9) == vectors[9]);
}
Reference in a new issue Copy permalink