a64.cpp
1 /* This file is part of the dynarmic project. 2 * Copyright (c) 2018 MerryMage 3 * SPDX-License-Identifier: 0BSD 4 */ 5 6 #include <catch2/catch_test_macros.hpp> 7 #include <oaknut/oaknut.hpp> 8 9 #include "./testenv.h" 10 #include "dynarmic/common/fp/fpsr.h" 11 #include "dynarmic/interface/exclusive_monitor.h" 12 13 using namespace Dynarmic; 14 using namespace oaknut::util; 15 16 TEST_CASE("A64: ADD", "[a64]") { 17 A64TestEnv env; 18 A64::Jit jit{A64::UserConfig{&env}}; 19 20 env.code_mem.emplace_back(0x8b020020); // ADD X0, X1, X2 21 env.code_mem.emplace_back(0x14000000); // B . 22 23 jit.SetRegister(0, 0); 24 jit.SetRegister(1, 1); 25 jit.SetRegister(2, 2); 26 jit.SetPC(0); 27 28 env.ticks_left = 2; 29 jit.Run(); 30 31 REQUIRE(jit.GetRegister(0) == 3); 32 REQUIRE(jit.GetRegister(1) == 1); 33 REQUIRE(jit.GetRegister(2) == 2); 34 REQUIRE(jit.GetPC() == 4); 35 } 36 37 TEST_CASE("A64: ADD{V,P}", "[a64]") { 38 A64TestEnv env; 39 A64::Jit jit{A64::UserConfig{&env}}; 40 41 env.code_mem.emplace_back(0x0E31B801); // ADDV b1, v0.8b 42 env.code_mem.emplace_back(0x4E31B802); // ADDV b2, v0.16b 43 env.code_mem.emplace_back(0x0E71B803); // ADDV h3, v0.4h 44 env.code_mem.emplace_back(0x4E71B804); // ADDV h4, v0.8h 45 env.code_mem.emplace_back(0x0EA0BC05); // ADDP v5.2s, v0.2s, v0.2s 46 env.code_mem.emplace_back(0x4EB1B806); // ADDV s6, v0.4s 47 env.code_mem.emplace_back(0x14000000); // B . 48 49 jit.SetVector(0, {0x0101010101010101, 0x0101010101010101}); 50 jit.SetPC(0); 51 52 env.ticks_left = 7; 53 jit.Run(); 54 55 REQUIRE(jit.GetVector(1) == Vector{0x0000000000000008, 0x0000000000000000}); 56 REQUIRE(jit.GetVector(2) == Vector{0x0000000000000010, 0x0000000000000000}); 57 REQUIRE(jit.GetVector(3) == Vector{0x0000000000000404, 0x0000000000000000}); 58 REQUIRE(jit.GetVector(4) == Vector{0x0000000000000808, 0x0000000000000000}); 59 REQUIRE(jit.GetVector(5) == Vector{0x0202020202020202, 0x0000000000000000}); 60 REQUIRE(jit.GetVector(6) == Vector{0x0000000004040404, 0x0000000000000000}); 61 } 62 63 TEST_CASE("A64: CLZ", "[a64]") { 64 A64TestEnv env; 65 A64::Jit jit{A64::UserConfig{&env}}; 66 67 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 68 code.CLZ(V3.B16(), V0.B16()); 69 code.CLZ(V4.H8(), V1.H8()); 70 code.CLZ(V5.S4(), V2.S4()); 71 72 jit.SetPC(0); 73 jit.SetVector(0, {0xeff0fafbfcfdfeff, 0xff7f3f1f0f070301}); 74 jit.SetVector(1, {0xfffcfffdfffeffff, 0x000F000700030001}); 75 jit.SetVector(2, {0xfffffffdfffffffe, 0x0000000300000001}); 76 77 env.ticks_left = env.code_mem.size(); 78 jit.Run(); 79 80 REQUIRE(jit.GetVector(3) == Vector{0x0, 0x0001020304050607}); 81 REQUIRE(jit.GetVector(4) == Vector{0x0, 0x000c000d000e000f}); 82 REQUIRE(jit.GetVector(5) == Vector{0x0, 0x0000001e0000001f}); 83 } 84 85 TEST_CASE("A64: UADDL{V,P}", "[a64]") { 86 A64TestEnv env; 87 A64::Jit jit{A64::UserConfig{&env}}; 88 89 env.code_mem.emplace_back(0x2E303801); // UADDLV h1, v0.8b 90 env.code_mem.emplace_back(0x6E303802); // UADDLV h2, v0.16b 91 env.code_mem.emplace_back(0x2E703803); // UADDLV s3, v0.4h 92 env.code_mem.emplace_back(0x6E703804); // UADDLV s4, v0.8h 93 env.code_mem.emplace_back(0x2EA02805); // UADDLP v5.1d, v0.2s 94 env.code_mem.emplace_back(0x6EB03806); // UADDLV d6, v0.4s 95 env.code_mem.emplace_back(0x14000000); // B . 96 97 jit.SetVector(0, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); 98 jit.SetPC(0); 99 100 env.ticks_left = 7; 101 jit.Run(); 102 103 REQUIRE(jit.GetVector(1) == Vector{0x00000000000007f8, 0x0000000000000000}); 104 REQUIRE(jit.GetVector(2) == Vector{0x0000000000000ff0, 0x0000000000000000}); 105 REQUIRE(jit.GetVector(3) == Vector{0x000000000003fffc, 0x0000000000000000}); 106 REQUIRE(jit.GetVector(4) == Vector{0x000000000007fff8, 0x0000000000000000}); 107 REQUIRE(jit.GetVector(5) == Vector{0x00000001fffffffe, 0x0000000000000000}); 108 REQUIRE(jit.GetVector(6) == Vector{0x00000003fffffffc, 0x0000000000000000}); 109 } 110 111 TEST_CASE("A64: SADDL{V,P}", "[a64]") { 112 A64TestEnv env; 113 A64::Jit jit{A64::UserConfig{&env}}; 114 115 env.code_mem.emplace_back(0x0E303801); // SADDLV h1, v0.8b 116 env.code_mem.emplace_back(0x4E303802); // SADDLV h2, v0.16b 117 env.code_mem.emplace_back(0x0E703803); // SADDLV s3, v0.4h 118 env.code_mem.emplace_back(0x4E703804); // SADDLV s4, v0.8h 119 env.code_mem.emplace_back(0x0EA02805); // SADDLP v5.1d, v0.2s 120 env.code_mem.emplace_back(0x4EB03806); // SADDLV d6, v0.4s 121 env.code_mem.emplace_back(0x14000000); // B . 122 123 jit.SetVector(0, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); 124 jit.SetPC(0); 125 126 env.ticks_left = 7; 127 jit.Run(); 128 129 REQUIRE(jit.GetVector(1) == Vector{0x000000000000fff8, 0x0000000000000000}); 130 REQUIRE(jit.GetVector(2) == Vector{0x000000000000fff0, 0x0000000000000000}); 131 REQUIRE(jit.GetVector(3) == Vector{0x00000000fffffffc, 0x0000000000000000}); 132 REQUIRE(jit.GetVector(4) == Vector{0x00000000fffffff8, 0x0000000000000000}); 133 REQUIRE(jit.GetVector(5) == Vector{0xfffffffffffffffe, 0x0000000000000000}); 134 REQUIRE(jit.GetVector(6) == Vector{0xfffffffffffffffc, 0x0000000000000000}); 135 } 136 137 TEST_CASE("A64: VQADD", "[a64]") { 138 A64TestEnv env; 139 A64::Jit jit{A64::UserConfig{&env}}; 140 141 env.code_mem.emplace_back(0x6e210c02); // UQADD v2.16b, v0.16b, v1.16b 142 env.code_mem.emplace_back(0x4e210c03); // SQADD v3.16b, v0.16b, v1.16b 143 env.code_mem.emplace_back(0x6e610c04); // UQADD v4.8h, v0.8h, v1.8h 144 env.code_mem.emplace_back(0x4e610c05); // SQADD v5.8h, v0.8h, v1.8h 145 env.code_mem.emplace_back(0x6ea10c06); // UQADD v6.4s, v0.4s, v1.4s 146 env.code_mem.emplace_back(0x4ea10c07); // SQADD v7.4s, v0.4s, v1.4s 147 env.code_mem.emplace_back(0x6ee10c08); // UQADD v8.2d, v0.2d, v1.2d 148 env.code_mem.emplace_back(0x4ee10c09); // SQADD v9.2d, v0.2d, v1.2d 149 env.code_mem.emplace_back(0x14000000); // B . 150 151 jit.SetVector(0, {0x7F7F7F7F7F7F7F7F, 0x7FFFFFFF7FFF7FFF}); 152 jit.SetVector(1, {0x8010FF00807F0000, 0x8000000080008000}); 153 jit.SetPC(0); 154 155 env.ticks_left = 9; 156 jit.Run(); 157 158 REQUIRE(jit.GetVector(2) == Vector{0xff8fff7ffffe7f7f, 0xffffffffffffffff}); 159 REQUIRE(jit.GetVector(3) == Vector{0xff7f7e7fff7f7f7f, 0xffffffffffffffff}); 160 REQUIRE(jit.GetVector(4) == Vector{0xff8ffffffffe7f7f, 0xffffffffffffffff}); 161 REQUIRE(jit.GetVector(5) == Vector{0xff8f7e7ffffe7f7f, 0xffffffffffffffff}); 162 REQUIRE(jit.GetVector(6) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff}); 163 REQUIRE(jit.GetVector(7) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff}); 164 REQUIRE(jit.GetVector(8) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff}); 165 REQUIRE(jit.GetVector(9) == Vector{0xff907e7ffffe7f7f, 0xffffffffffffffff}); 166 } 167 168 TEST_CASE("A64: VQSUB", "[a64]") { 169 A64TestEnv env; 170 A64::Jit jit{A64::UserConfig{&env}}; 171 172 env.code_mem.emplace_back(0x6e212c02); // UQSUB v2.16b, v0.16b, v1.16b 173 env.code_mem.emplace_back(0x4e212c03); // SQSUB v3.16b, v0.16b, v1.16b 174 env.code_mem.emplace_back(0x6e612c04); // UQSUB v4.8h, v0.8h, v1.8h 175 env.code_mem.emplace_back(0x4e612c05); // SQSUB v5.8h, v0.8h, v1.8h 176 env.code_mem.emplace_back(0x6ea12c06); // UQSUB v6.4s, v0.4s, v1.4s 177 env.code_mem.emplace_back(0x4ea12c07); // SQSUB v7.4s, v0.4s, v1.4s 178 env.code_mem.emplace_back(0x6ee12c08); // UQSUB v8.2d, v0.2d, v1.2d 179 env.code_mem.emplace_back(0x4ee12c09); // SQSUB v9.2d, v0.2d, v1.2d 180 env.code_mem.emplace_back(0x14000000); // B . 181 182 jit.SetVector(0, {0x8010FF00807F0000, 0x8000000080008000}); 183 jit.SetVector(1, {0x7F7F7F7F7F7F7F7F, 0x7FFFFFFF7FFF7FFF}); 184 jit.SetPC(0); 185 186 env.ticks_left = 9; 187 jit.Run(); 188 189 REQUIRE(jit.GetVector(2) == Vector{0x0100800001000000, 0x0100000001000100}); 190 REQUIRE(jit.GetVector(3) == Vector{0x8091808180008181, 0x8001010180018001}); 191 REQUIRE(jit.GetVector(4) == Vector{0x00917f8101000000, 0x0001000000010001}); 192 REQUIRE(jit.GetVector(5) == Vector{0x8000800080008081, 0x8000000180008000}); 193 REQUIRE(jit.GetVector(6) == Vector{0x00917f8100ff8081, 0x0000000100010001}); 194 REQUIRE(jit.GetVector(7) == Vector{0x8000000080000000, 0x8000000080000000}); 195 REQUIRE(jit.GetVector(8) == Vector{0x00917f8100ff8081, 0x0000000100010001}); 196 REQUIRE(jit.GetVector(9) == Vector{0x8000000000000000, 0x8000000000000000}); 197 } 198 199 TEST_CASE("A64: REV", "[a64]") { 200 A64TestEnv env; 201 A64::Jit jit{A64::UserConfig{&env}}; 202 203 env.code_mem.emplace_back(0xdac00c00); // REV X0, X0 204 env.code_mem.emplace_back(0x5ac00821); // REV W1, W1 205 env.code_mem.emplace_back(0x14000000); // B . 206 207 jit.SetRegister(0, 0xaabbccddeeff1100); 208 jit.SetRegister(1, 0xaabbccdd); 209 jit.SetPC(0); 210 211 env.ticks_left = 3; 212 jit.Run(); 213 214 REQUIRE(jit.GetRegister(0) == 0x11ffeeddccbbaa); 215 REQUIRE(jit.GetRegister(1) == 0xddccbbaa); 216 REQUIRE(jit.GetPC() == 8); 217 } 218 219 TEST_CASE("A64: REV32", "[a64]") { 220 A64TestEnv env; 221 A64::Jit jit{A64::UserConfig{&env}}; 222 223 env.code_mem.emplace_back(0xdac00800); // REV32 X0, X0 224 env.code_mem.emplace_back(0x14000000); // B . 225 226 jit.SetRegister(0, 0xaabbccddeeff1100); 227 jit.SetPC(0); 228 229 env.ticks_left = 2; 230 jit.Run(); 231 REQUIRE(jit.GetRegister(0) == 0xddccbbaa0011ffee); 232 REQUIRE(jit.GetPC() == 4); 233 } 234 235 TEST_CASE("A64: REV16", "[a64]") { 236 A64TestEnv env; 237 A64::Jit jit{A64::UserConfig{&env}}; 238 239 env.code_mem.emplace_back(0xdac00400); // REV16 X0, X0 240 env.code_mem.emplace_back(0x5ac00421); // REV16 W1, W1 241 env.code_mem.emplace_back(0x14000000); // B . 242 243 jit.SetRegister(0, 0xaabbccddeeff1100); 244 jit.SetRegister(1, 0xaabbccdd); 245 246 jit.SetPC(0); 247 248 env.ticks_left = 3; 249 jit.Run(); 250 REQUIRE(jit.GetRegister(0) == 0xbbaaddccffee0011); 251 REQUIRE(jit.GetRegister(1) == 0xbbaaddcc); 252 REQUIRE(jit.GetPC() == 8); 253 } 254 255 TEST_CASE("A64: SSHL", "[a64]") { 256 A64TestEnv env; 257 A64::Jit jit{A64::UserConfig{&env}}; 258 259 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 260 code.SSHL(V4.B16(), V4.B16(), V0.B16()); 261 code.SSHL(V5.H8(), V5.H8(), V1.H8()); 262 code.SSHL(V6.S4(), V6.S4(), V2.S4()); 263 code.SSHL(V7.D2(), V7.D2(), V3.D2()); 264 code.SSHL(V17.D2(), V17.D2(), V13.D2()); 265 266 jit.SetPC(0); 267 jit.SetVector(0, {0xEFF0FAFBFCFDFEFF, 0x0807050403020100}); 268 jit.SetVector(1, {0x00FCFFFDFFFEFFFF, 0xFF04000300020001}); 269 jit.SetVector(2, {0x000000FDFFFFFFFE, 0xFFFFFF0200000001}); 270 jit.SetVector(3, {0xFFFFFFFFFFFFFFFF, 0x0000000000000001}); 271 jit.SetVector(13, {0x00000000000000FF, 0xFFFFFFFFFFFFFF01}); 272 273 jit.SetVector(4, {0x8080808080808080, 0xFFFFFFFFFFFFFFFF}); 274 jit.SetVector(5, {0x8000800080008000, 0xFFFFFFFFFFFFFFFF}); 275 jit.SetVector(6, {0x8000000080000000, 0xFFFFFFFFFFFFFFFF}); 276 jit.SetVector(7, {0x8000000000000000, 0xFFFFFFFFFFFFFFFF}); 277 jit.SetVector(17, {0x8000000000000000, 0xFFFFFFFFFFFFFFFF}); 278 279 env.ticks_left = env.code_mem.size(); 280 jit.Run(); 281 282 CHECK(jit.GetVector(4) == Vector{0xfffffefcf8f0e0c0, 0x0080e0f0f8fcfeff}); 283 CHECK(jit.GetVector(5) == Vector{0xf800f000e000c000, 0xfff0fff8fffcfffe}); 284 CHECK(jit.GetVector(6) == Vector{0xf0000000e0000000, 0xfffffffcfffffffe}); 285 CHECK(jit.GetVector(7) == Vector{0xc000000000000000, 0xfffffffffffffffe}); 286 CHECK(jit.GetVector(17) == Vector{0xc000000000000000, 0xfffffffffffffffe}); 287 } 288 289 TEST_CASE("A64: USHL", "[a64]") { 290 A64TestEnv env; 291 A64::Jit jit{A64::UserConfig{&env}}; 292 293 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 294 code.USHL(V4.B16(), V4.B16(), V0.B16()); 295 code.USHL(V14.B8(), V14.B8(), V10.B8()); 296 code.USHL(V5.H8(), V5.H8(), V1.H8()); 297 code.USHL(V15.H4(), V15.H4(), V11.H4()); 298 code.USHL(V6.S4(), V6.S4(), V2.S4()); 299 code.USHL(V16.S2(), V16.S2(), V12.S2()); 300 code.USHL(V7.D2(), V7.D2(), V3.D2()); 301 code.USHL(V17.D2(), V17.D2(), V13.D2()); 302 303 jit.SetPC(0); 304 jit.SetVector(0, {0x10FE0E0D0C0B0A09, 0x0807050403020100}); 305 jit.SetVector(10, {0xF6F7F8F9FAFBFCFD}); 306 jit.SetVector(1, {0xFFFE000700060005, 0x0004000300020001}); 307 jit.SetVector(11, {0x00F1FF0F00F08010}); 308 jit.SetVector(2, {0xFFFFFFFE00000003, 0x0000000200000001}); 309 jit.SetVector(12, {0x000000E18000001F}); 310 jit.SetVector(3, {0xFFFFFFFFFFFFFFFE, 0x0000000000000001}); 311 jit.SetVector(13, {0x00000000000000C1, 0xFF0000000000003F}); 312 313 jit.SetVector(4, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); 314 jit.SetVector(14, {0x8080808080808080}); 315 jit.SetVector(5, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); 316 jit.SetVector(15, {0x80000001FFFFFFFF}); 317 jit.SetVector(6, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); 318 jit.SetVector(16, {0x8000000000000001}); 319 jit.SetVector(7, {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}); 320 jit.SetVector(17, {0x8000000000000000, 0x0000000000000001}); 321 322 env.ticks_left = env.code_mem.size(); 323 jit.Run(); 324 325 CHECK(jit.GetVector(4) == Vector{0x003f000000000000, 0x0080e0f0f8fcfeff}); 326 CHECK(jit.GetVector(14) == Vector{0x0000000102040810}); 327 CHECK(jit.GetVector(5) == Vector{0x3fffff80ffc0ffe0, 0xfff0fff8fffcfffe}); 328 CHECK(jit.GetVector(15) == Vector{0x0001800000000000}); 329 CHECK(jit.GetVector(6) == Vector{0x3ffffffffffffff8, 0xfffffffcfffffffe}); 330 CHECK(jit.GetVector(16) == Vector{0x0000000180000000}); 331 CHECK(jit.GetVector(7) == Vector{0x3fffffffffffffff, 0xfffffffffffffffe}); 332 CHECK(jit.GetVector(17) == Vector{0x0000000000000001, 0x8000000000000000}); 333 } 334 335 TEST_CASE("A64: URSHL", "[a64]") { 336 A64TestEnv env; 337 A64::Jit jit{A64::UserConfig{&env}}; 338 339 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 340 code.URSHL(V0.S4(), V1.S4(), V2.S4()); 341 code.URSHL(V3.S4(), V4.S4(), V5.S4()); 342 343 code.URSHL(V6.D2(), V7.D2(), V8.D2()); 344 code.URSHL(V9.D2(), V10.D2(), V11.D2()); 345 346 jit.SetVector(1, Vector{0xffffffff'18ba6a6a, 0x7fffffff'943b954f}); 347 jit.SetVector(2, Vector{0xffffffe0'80000013, 0x00aabbe1'abcdef21}); 348 jit.SetVector(4, Vector{0x0000000b'0000000f, 0xffffffff'ffffffff}); 349 jit.SetVector(5, Vector{0x000000fd'fedcbafd, 0x000000ff'00000001}); 350 351 jit.SetVector(7, Vector{0x824817df73adca9f, 0x35e511704656e7a4}); 352 jit.SetVector(8, Vector{0x000000000000002a, 0xffffffffffffffc9}); 353 jit.SetVector(10, Vector{0xffffffffffffffff, 0x96dc5c140705cd04}); 354 jit.SetVector(11, Vector{0xffffffffffffffc1, 0x00555555555555f5}); 355 356 env.ticks_left = env.code_mem.size(); 357 jit.Run(); 358 359 CHECK(jit.GetVector(0) == Vector{0x00000001'53500000, 0x00000001'00000000}); 360 CHECK(jit.GetVector(3) == Vector{0x00000001'00000002, 0x80000000'fffffffe}); 361 362 CHECK(jit.GetVector(6) == Vector{0xb72a7c0000000000, 0x0000000000006c}); 363 CHECK(jit.GetVector(9) == Vector{0x0000000000000002, 0x12db8b8280e0ba}); 364 } 365 366 TEST_CASE("A64: XTN", "[a64]") { 367 A64TestEnv env; 368 A64::Jit jit{A64::UserConfig{&env}}; 369 370 env.code_mem.emplace_back(0x0e212803); // XTN v3.8b, v0.8h 371 env.code_mem.emplace_back(0x0e612824); // XTN v4.4h, v1.4s 372 env.code_mem.emplace_back(0x0ea12845); // XTN v5.2s, v2.2d 373 env.code_mem.emplace_back(0x14000000); // B . 374 375 jit.SetPC(0); 376 jit.SetVector(0, {0x3333222211110000, 0x7777666655554444}); 377 jit.SetVector(1, {0x1111111100000000, 0x3333333322222222}); 378 jit.SetVector(2, {0x0000000000000000, 0x1111111111111111}); 379 380 env.ticks_left = 4; 381 jit.Run(); 382 383 REQUIRE(jit.GetVector(3) == Vector{0x7766554433221100, 0x0000000000000000}); 384 REQUIRE(jit.GetVector(4) == Vector{0x3333222211110000, 0x0000000000000000}); 385 REQUIRE(jit.GetVector(5) == Vector{0x1111111100000000, 0x0000000000000000}); 386 } 387 388 TEST_CASE("A64: TBL", "[a64]") { 389 A64TestEnv env; 390 A64::Jit jit{A64::UserConfig{&env}}; 391 392 env.code_mem.emplace_back(0x0e000100); // TBL v0.8b, { v8.16b }, v0.8b 393 env.code_mem.emplace_back(0x4e010101); // TBL v1.16b, { v8.16b }, v1.16b 394 env.code_mem.emplace_back(0x0e022102); // TBL v2.8b, { v8.16b, v9.16b }, v2.8b 395 env.code_mem.emplace_back(0x4e032103); // TBL v3.16b, { v8.16b, v9.16b }, v3.16b 396 env.code_mem.emplace_back(0x0e044104); // TBL v4.8b, { v8.16b, v9.16b, v10.16b }, v4.8b 397 env.code_mem.emplace_back(0x4e054105); // TBL v5.16b, { v8.16b, v9.16b, v10.16b }, v5.16b 398 env.code_mem.emplace_back(0x0e066106); // TBL v6.8b, { v8.16b, v9.16b, v10.16b, v11.16b }, v6.8b 399 env.code_mem.emplace_back(0x4e076107); // TBL v7.16b, { v8.16b, v9.16b, v10.16b, v11.16b }, v7.16b 400 env.code_mem.emplace_back(0x14000000); // B . 401 402 // Indices 403 // 'FF' intended to test out-of-index 404 jit.SetVector(0, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f}); 405 jit.SetVector(1, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f}); 406 jit.SetVector(2, {0x100011011202'FF'03, 0x1404150516061707}); 407 jit.SetVector(3, {0x100011011202'FF'03, 0x1404150516061707}); 408 jit.SetVector(4, {0x201000211101'FF'12, 0x0233231303241404}); 409 jit.SetVector(5, {0x201000211101'FF'12, 0x0233231303241404}); 410 jit.SetVector(6, {0x403010004131'FF'01, 0x4232120243332303}); 411 jit.SetVector(7, {0x403010004131'FF'01, 0x4232120243332303}); 412 413 // Table 414 jit.SetVector(8, {0x7766554433221100, 0xffeeddccbbaa9988}); 415 jit.SetVector(9, {0xffffffffffffffff, 0xffffffffffffffff}); 416 jit.SetVector(10, {0xeeeeeeeeeeeeeeee, 0xeeeeeeeeeeeeeeee}); 417 jit.SetVector(11, {0xdddddddddddddddd, 0xdddddddddddddddd}); 418 419 jit.SetPC(0); 420 421 env.ticks_left = 9; 422 jit.Run(); 423 424 REQUIRE(jit.GetVector(0) == Vector{0x001122334455'00'77, 0x0000000000000000}); 425 REQUIRE(jit.GetVector(1) == Vector{0x001122334455'00'77, 0x8899aabbccddeeff}); 426 REQUIRE(jit.GetVector(2) == Vector{0xff00ff11ff22'00'33, 0x0000000000000000}); 427 REQUIRE(jit.GetVector(3) == Vector{0xff00ff11ff22'00'33, 0xff44ff55ff66ff77}); 428 REQUIRE(jit.GetVector(4) == Vector{0xeeff00eeff11'00'ff, 0x0000000000000000}); 429 REQUIRE(jit.GetVector(5) == Vector{0xeeff00eeff11'00'ff, 0x2200eeff33eeff44}); 430 REQUIRE(jit.GetVector(6) == Vector{0x00ddff0000dd'00'11, 0x0000000000000000}); 431 REQUIRE(jit.GetVector(7) == Vector{0x00ddff0000dd'00'11, 0x00ddff2200ddee33}); 432 } 433 434 TEST_CASE("A64: TBX", "[a64]") { 435 A64TestEnv env; 436 A64::Jit jit{A64::UserConfig{&env}}; 437 438 env.code_mem.emplace_back(0x0e001100); // TBX v0.8b, { v8.16b }, v0.8b 439 env.code_mem.emplace_back(0x4e011101); // TBX v1.16b, { v8.16b }, v1.16b 440 env.code_mem.emplace_back(0x0e023102); // TBX v2.8b, { v8.16b, v9.16b }, v2.8b 441 env.code_mem.emplace_back(0x4e033103); // TBX v3.16b, { v8.16b, v9.16b }, v3.16b 442 env.code_mem.emplace_back(0x0e045104); // TBX v4.8b, { v8.16b, v9.16b, v10.16b }, v4.8b 443 env.code_mem.emplace_back(0x4e055105); // TBX v5.16b, { v8.16b, v9.16b, v10.16b }, v5.16b 444 env.code_mem.emplace_back(0x0e067106); // TBX v6.8b, { v8.16b, v9.16b, v10.16b, v11.16b }, v6.8b 445 env.code_mem.emplace_back(0x4e077107); // TBX v7.16b, { v8.16b, v9.16b, v10.16b, v11.16b }, v7.16b 446 env.code_mem.emplace_back(0x14000000); // B . 447 448 // Indices 449 // 'FF' intended to test out-of-index 450 jit.SetVector(0, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f}); 451 jit.SetVector(1, {0x000102030405'FF'07, 0x08090a0b0c0d0e0f}); 452 jit.SetVector(2, {0x100011011202'FF'03, 0x1404150516061707}); 453 jit.SetVector(3, {0x100011011202'FF'03, 0x1404150516061707}); 454 jit.SetVector(4, {0x201000211101'FF'12, 0x0233231303241404}); 455 jit.SetVector(5, {0x201000211101'FF'12, 0x0233231303241404}); 456 jit.SetVector(6, {0x403010004131'FF'01, 0x4232120243332303}); 457 jit.SetVector(7, {0x403010004131'FF'01, 0x4232120243332303}); 458 459 // Table 460 jit.SetVector(8, {0x7766554433221100, 0xffeeddccbbaa9988}); 461 jit.SetVector(9, {0xffffffffffffffff, 0xffffffffffffffff}); 462 jit.SetVector(10, {0xeeeeeeeeeeeeeeee, 0xeeeeeeeeeeeeeeee}); 463 jit.SetVector(11, {0xdddddddddddddddd, 0xdddddddddddddddd}); 464 465 jit.SetPC(0); 466 467 env.ticks_left = 9; 468 jit.Run(); 469 470 REQUIRE(jit.GetVector(0) == Vector{0x001122334455'FF'77, 0x0000000000000000}); 471 REQUIRE(jit.GetVector(1) == Vector{0x001122334455'FF'77, 0x8899aabbccddeeff}); 472 REQUIRE(jit.GetVector(2) == Vector{0xff00ff11ff22'FF'33, 0x0000000000000000}); 473 REQUIRE(jit.GetVector(3) == Vector{0xff00ff11ff22'FF'33, 0xff44ff55ff66ff77}); 474 REQUIRE(jit.GetVector(4) == Vector{0xeeff00eeff11'FF'ff, 0x0000000000000000}); 475 REQUIRE(jit.GetVector(5) == Vector{0xeeff00eeff11'FF'ff, 0x2233eeff33eeff44}); 476 REQUIRE(jit.GetVector(6) == Vector{0x40ddff0041dd'FF'11, 0x0000000000000000}); 477 REQUIRE(jit.GetVector(7) == Vector{0x40ddff0041dd'FF'11, 0x42ddff2243ddee33}); 478 } 479 480 TEST_CASE("A64: AND", "[a64]") { 481 A64TestEnv env; 482 A64::Jit jit{A64::UserConfig{&env}}; 483 484 env.code_mem.emplace_back(0x8a020020); // AND X0, X1, X2 485 env.code_mem.emplace_back(0x14000000); // B . 486 487 jit.SetRegister(0, 0); 488 jit.SetRegister(1, 1); 489 jit.SetRegister(2, 3); 490 jit.SetPC(0); 491 492 env.ticks_left = 2; 493 jit.Run(); 494 495 REQUIRE(jit.GetRegister(0) == 1); 496 REQUIRE(jit.GetRegister(1) == 1); 497 REQUIRE(jit.GetRegister(2) == 3); 498 REQUIRE(jit.GetPC() == 4); 499 } 500 501 TEST_CASE("A64: Bitmasks", "[a64]") { 502 A64TestEnv env; 503 A64::Jit jit{A64::UserConfig{&env}}; 504 505 env.code_mem.emplace_back(0x3200c3e0); // ORR W0, WZR, #0x01010101 506 env.code_mem.emplace_back(0x320c8fe1); // ORR W1, WZR, #0x00F000F0 507 env.code_mem.emplace_back(0x320003e2); // ORR W2, WZR, #1 508 env.code_mem.emplace_back(0x14000000); // B . 509 510 jit.SetPC(0); 511 512 env.ticks_left = 4; 513 jit.Run(); 514 515 REQUIRE(jit.GetRegister(0) == 0x01010101); 516 REQUIRE(jit.GetRegister(1) == 0x00F000F0); 517 REQUIRE(jit.GetRegister(2) == 1); 518 REQUIRE(jit.GetPC() == 12); 519 } 520 521 TEST_CASE("A64: ANDS NZCV", "[a64]") { 522 A64TestEnv env; 523 A64::Jit jit{A64::UserConfig{&env}}; 524 525 env.code_mem.emplace_back(0x6a020020); // ANDS W0, W1, W2 526 env.code_mem.emplace_back(0x14000000); // B . 527 528 SECTION("N=1, Z=0") { 529 jit.SetRegister(0, 0); 530 jit.SetRegister(1, 0xFFFFFFFF); 531 jit.SetRegister(2, 0xFFFFFFFF); 532 jit.SetPC(0); 533 534 env.ticks_left = 2; 535 jit.Run(); 536 537 REQUIRE(jit.GetRegister(0) == 0xFFFFFFFF); 538 REQUIRE(jit.GetRegister(1) == 0xFFFFFFFF); 539 REQUIRE(jit.GetRegister(2) == 0xFFFFFFFF); 540 REQUIRE(jit.GetPC() == 4); 541 REQUIRE((jit.GetPstate() & 0xF0000000) == 0x80000000); 542 } 543 544 SECTION("N=0, Z=1") { 545 jit.SetRegister(0, 0); 546 jit.SetRegister(1, 0xFFFFFFFF); 547 jit.SetRegister(2, 0x00000000); 548 jit.SetPC(0); 549 550 env.ticks_left = 2; 551 jit.Run(); 552 553 REQUIRE(jit.GetRegister(0) == 0x00000000); 554 REQUIRE(jit.GetRegister(1) == 0xFFFFFFFF); 555 REQUIRE(jit.GetRegister(2) == 0x00000000); 556 REQUIRE(jit.GetPC() == 4); 557 REQUIRE((jit.GetPstate() & 0xF0000000) == 0x40000000); 558 } 559 SECTION("N=0, Z=0") { 560 jit.SetRegister(0, 0); 561 jit.SetRegister(1, 0x12345678); 562 jit.SetRegister(2, 0x7324a993); 563 jit.SetPC(0); 564 565 env.ticks_left = 2; 566 jit.Run(); 567 568 REQUIRE(jit.GetRegister(0) == 0x12240010); 569 REQUIRE(jit.GetRegister(1) == 0x12345678); 570 REQUIRE(jit.GetRegister(2) == 0x7324a993); 571 REQUIRE(jit.GetPC() == 4); 572 REQUIRE((jit.GetPstate() & 0xF0000000) == 0x00000000); 573 } 574 } 575 576 TEST_CASE("A64: CBZ", "[a64]") { 577 A64TestEnv env; 578 A64::Jit jit{A64::UserConfig{&env}}; 579 580 env.code_mem.emplace_back(0x34000060); // 0x00 : CBZ X0, label 581 env.code_mem.emplace_back(0x320003e2); // 0x04 : MOV X2, 1 582 env.code_mem.emplace_back(0x14000000); // 0x08 : B. 583 env.code_mem.emplace_back(0x321f03e2); // 0x0C : label: MOV X2, 2 584 env.code_mem.emplace_back(0x14000000); // 0x10 : B . 585 586 SECTION("no branch") { 587 jit.SetPC(0); 588 jit.SetRegister(0, 1); 589 590 env.ticks_left = 4; 591 jit.Run(); 592 593 REQUIRE(jit.GetRegister(2) == 1); 594 REQUIRE(jit.GetPC() == 8); 595 } 596 597 SECTION("branch") { 598 jit.SetPC(0); 599 jit.SetRegister(0, 0); 600 601 env.ticks_left = 4; 602 jit.Run(); 603 604 REQUIRE(jit.GetRegister(2) == 2); 605 REQUIRE(jit.GetPC() == 16); 606 } 607 } 608 609 TEST_CASE("A64: TBZ", "[a64]") { 610 A64TestEnv env; 611 A64::Jit jit{A64::UserConfig{&env}}; 612 613 env.code_mem.emplace_back(0x36180060); // 0x00 : TBZ X0, 3, label 614 env.code_mem.emplace_back(0x320003e2); // 0x04 : MOV X2, 1 615 env.code_mem.emplace_back(0x14000000); // 0x08 : B . 616 env.code_mem.emplace_back(0x321f03e2); // 0x0C : label: MOV X2, 2 617 env.code_mem.emplace_back(0x14000000); // 0x10 : B . 618 619 SECTION("no branch") { 620 jit.SetPC(0); 621 jit.SetRegister(0, 0xFF); 622 623 env.ticks_left = 4; 624 jit.Run(); 625 626 REQUIRE(jit.GetRegister(2) == 1); 627 REQUIRE(jit.GetPC() == 8); 628 } 629 630 SECTION("branch with zero") { 631 jit.SetPC(0); 632 jit.SetRegister(0, 0); 633 634 env.ticks_left = 4; 635 jit.Run(); 636 637 REQUIRE(jit.GetRegister(2) == 2); 638 REQUIRE(jit.GetPC() == 16); 639 } 640 641 SECTION("branch with non-zero") { 642 jit.SetPC(0); 643 jit.SetRegister(0, 1); 644 645 env.ticks_left = 4; 646 jit.Run(); 647 648 REQUIRE(jit.GetRegister(2) == 2); 649 REQUIRE(jit.GetPC() == 16); 650 } 651 } 652 653 TEST_CASE("A64: FABD", "[a64]") { 654 A64TestEnv env; 655 A64::Jit jit{A64::UserConfig{&env}}; 656 657 env.code_mem.emplace_back(0x6eb5d556); // FABD.4S V22, V10, V21 658 env.code_mem.emplace_back(0x14000000); // B . 659 660 jit.SetPC(0); 661 jit.SetVector(10, {0xb4858ac77ff39a87, 0x9fce5e14c4873176}); 662 jit.SetVector(21, {0x56d3f085ff890e2b, 0x6e4b0a41801a2d00}); 663 664 env.ticks_left = 2; 665 jit.Run(); 666 667 REQUIRE(jit.GetVector(22) == Vector{0x56d3f0857fc90e2b, 0x6e4b0a4144873176}); 668 } 669 670 TEST_CASE("A64: FABS", "[a64]") { 671 A64TestEnv env; 672 A64::Jit jit{A64::UserConfig{&env}}; 673 674 env.code_mem.emplace_back(0x4ef8f804); // FABS v4.8h, v0.8h 675 env.code_mem.emplace_back(0x4ea0f825); // FABS v5.4s, v1.4s 676 env.code_mem.emplace_back(0x4ee0f846); // FABS v6.2d, v2.2d 677 env.code_mem.emplace_back(0x14000000); // B . 678 679 jit.SetPC(0); 680 jit.SetVector(0, {0xffffffffffffffff, 0xffffffffffff8000}); 681 jit.SetVector(1, {0xffbfffffffc00000, 0xff80000080000000}); 682 jit.SetVector(2, {0xffffffffffffffff, 0x8000000000000000}); 683 684 env.ticks_left = 4; 685 jit.Run(); 686 687 REQUIRE(jit.GetVector(4) == Vector{0x7fff7fff7fff7fff, 0x7fff7fff7fff0000}); 688 REQUIRE(jit.GetVector(5) == Vector{0x7fbfffff7fc00000, 0x7f80000000000000}); 689 REQUIRE(jit.GetVector(6) == Vector{0x7fffffffffffffff, 0x0000000000000000}); 690 } 691 692 TEST_CASE("A64: FMIN (example)", "[a64]") { 693 A64TestEnv env; 694 A64::Jit jit{A64::UserConfig{&env}}; 695 696 env.code_mem.emplace_back(0x4ea1f400); // FMIN.4S V0, V0, V1 697 env.code_mem.emplace_back(0x4ee3f442); // FMIN.2D V2, V2, V3 698 env.code_mem.emplace_back(0x14000000); // B . 699 700 jit.SetPC(0); 701 jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37}); 702 jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff}); 703 704 jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000}); 705 jit.SetVector(3, {0xbff0000000000000, 0x6e4b0a41ffffffff}); 706 707 env.ticks_left = 2; 708 jit.Run(); 709 710 REQUIRE(jit.GetVector(0) == Vector{0x7fc00000'00000001, 0x00000000'7fd84a37}); 711 REQUIRE(jit.GetVector(2) == Vector{0xbff0000000000000, 0x3ff0000000000000}); 712 } 713 714 TEST_CASE("A64: FMAX (example)", "[a64]") { 715 A64TestEnv env; 716 A64::Jit jit{A64::UserConfig{&env}}; 717 718 env.code_mem.emplace_back(0x4e21f400); // FMAX.4S V0, V0, V1 719 env.code_mem.emplace_back(0x4e63f442); // FMAX.2D V2, V2, V3 720 env.code_mem.emplace_back(0x14000000); // B . 721 722 jit.SetPC(0); 723 jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37}); 724 jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff}); 725 726 jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000}); 727 jit.SetVector(3, {0xbff0000000000000, 0x6e4b0a41ffffffff}); 728 729 env.ticks_left = 2; 730 jit.Run(); 731 732 REQUIRE(jit.GetVector(0) == Vector{0x7fc00000'09503366, 0x6e4b0a41'7fd84a37}); 733 REQUIRE(jit.GetVector(2) == Vector{0x7fc0000009503366, 0x6e4b0a41ffffffff}); 734 } 735 736 TEST_CASE("A64: FMINNM (example)", "[a64]") { 737 A64TestEnv env; 738 A64::Jit jit{A64::UserConfig{&env}}; 739 740 env.code_mem.emplace_back(0x4ea1c400); // FMINNM.4S V0, V0, V1 741 env.code_mem.emplace_back(0x4ee3c442); // FMINNM.2D V2, V2, V3 742 env.code_mem.emplace_back(0x14000000); // B . 743 744 jit.SetPC(0); 745 jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37}); 746 jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff}); 747 748 jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000}); 749 jit.SetVector(3, {0xfff0000000000000, 0xffffffffffffffff}); 750 751 env.ticks_left = 2; 752 jit.Run(); 753 754 REQUIRE(jit.GetVector(0) == Vector{0xc1200000'00000001, 0x00000000'7fd84a37}); 755 REQUIRE(jit.GetVector(2) == Vector{0xfff0000000000000, 0x3ff0000000000000}); 756 } 757 758 TEST_CASE("A64: FMAXNM (example)", "[a64]") { 759 A64TestEnv env; 760 A64::Jit jit{A64::UserConfig{&env}}; 761 762 env.code_mem.emplace_back(0x4e21c400); // FMAXNM.4S V0, V0, V1 763 env.code_mem.emplace_back(0x4e63c442); // FMAXNM.2D V2, V2, V3 764 env.code_mem.emplace_back(0x14000000); // B . 765 766 jit.SetPC(0); 767 jit.SetVector(0, {0x7fc00000'09503366, 0x00000000'7f984a37}); 768 jit.SetVector(1, {0xc1200000'00000001, 0x6e4b0a41'ffffffff}); 769 770 jit.SetVector(2, {0x7fc0000009503366, 0x3ff0000000000000}); 771 jit.SetVector(3, {0xfff0000000000000, 0xffffffffffffffff}); 772 773 env.ticks_left = 2; 774 jit.Run(); 775 776 REQUIRE(jit.GetVector(0) == Vector{0xc1200000'09503366, 0x6e4b0a41'7fd84a37}); 777 REQUIRE(jit.GetVector(2) == Vector{0x7fc0000009503366, 0x3ff0000000000000}); 778 } 779 780 TEST_CASE("A64: FMAXNM (example 2)", "[a64]") { 781 A64TestEnv env; 782 A64::Jit jit{A64::UserConfig{&env}}; 783 784 env.code_mem.emplace_back(0x4e3bc6fd); // FMAXNM.4S V29, V23, V27 785 env.code_mem.emplace_back(0x14000000); // B . 786 787 jit.SetPC(0); 788 jit.SetFpcr(0x01400000); 789 jit.SetVector(23, {0xb485877c'42280000, 0x317285d3'b5c8e5d3}); 790 jit.SetVector(27, {0xbc48d091'c79b271e, 0xff800001'3304c3ef}); 791 792 env.ticks_left = 2; 793 jit.Run(); 794 795 REQUIRE(jit.GetVector(29) == Vector{0xb485877c'42280000, 0xffc00001'3304c3ef}); 796 } 797 798 TEST_CASE("A64: 128-bit exclusive read/write", "[a64]") { 799 A64TestEnv env; 800 ExclusiveMonitor monitor{1}; 801 802 A64::UserConfig conf; 803 conf.callbacks = &env; 804 conf.processor_id = 0; 805 806 SECTION("Global Monitor") { 807 conf.global_monitor = &monitor; 808 } 809 810 A64::Jit jit{conf}; 811 812 env.code_mem.emplace_back(0xc87f0861); // LDXP X1, X2, [X3] 813 env.code_mem.emplace_back(0xc8241865); // STXP W4, X5, X6, [X3] 814 env.code_mem.emplace_back(0x14000000); // B . 815 816 jit.SetPC(0); 817 jit.SetRegister(3, 0x1234567812345678); 818 jit.SetRegister(4, 0xbaadbaadbaadbaad); 819 jit.SetRegister(5, 0xaf00d1e5badcafe0); 820 jit.SetRegister(6, 0xd0d0cacad0d0caca); 821 822 env.ticks_left = 3; 823 jit.Run(); 824 825 REQUIRE(jit.GetRegister(1) == 0x7f7e7d7c7b7a7978); 826 REQUIRE(jit.GetRegister(2) == 0x8786858483828180); 827 REQUIRE(jit.GetRegister(4) == 0); 828 REQUIRE(env.MemoryRead64(0x1234567812345678) == 0xaf00d1e5badcafe0); 829 REQUIRE(env.MemoryRead64(0x1234567812345680) == 0xd0d0cacad0d0caca); 830 } 831 832 TEST_CASE("A64: CNTPCT_EL0", "[a64]") { 833 A64TestEnv env; 834 A64::Jit jit{A64::UserConfig{&env}}; 835 836 env.code_mem.emplace_back(0xd53be021); // MRS X1, CNTPCT_EL0 837 env.code_mem.emplace_back(0xd503201f); // NOP 838 env.code_mem.emplace_back(0xd503201f); // NOP 839 env.code_mem.emplace_back(0xd503201f); // NOP 840 env.code_mem.emplace_back(0xd503201f); // NOP 841 env.code_mem.emplace_back(0xd503201f); // NOP 842 env.code_mem.emplace_back(0xd503201f); // NOP 843 env.code_mem.emplace_back(0xd53be022); // MRS X2, CNTPCT_EL0 844 env.code_mem.emplace_back(0xcb010043); // SUB X3, X2, X1 845 env.code_mem.emplace_back(0x14000000); // B . 846 847 env.ticks_left = 10; 848 jit.Run(); 849 850 REQUIRE(jit.GetRegister(3) == 7); 851 } 852 853 TEST_CASE("A64: FNMSUB 1", "[a64]") { 854 A64TestEnv env; 855 A64::Jit jit{A64::UserConfig{&env}}; 856 857 env.code_mem.emplace_back(0x1f618a9c); // FNMSUB D28, D20, D1, D2 858 env.code_mem.emplace_back(0x14000000); // B . 859 860 jit.SetPC(0); 861 jit.SetVector(20, {0xe73a51346164bd6c, 0x8080000000002b94}); 862 jit.SetVector(1, {0xbf8000007fffffff, 0xffffffff00002b94}); 863 jit.SetVector(2, {0x0000000000000000, 0xc79b271e3f000000}); 864 865 env.ticks_left = 2; 866 jit.Run(); 867 868 REQUIRE(jit.GetVector(28) == Vector{0x66ca513533ee6076, 0x0000000000000000}); 869 } 870 871 TEST_CASE("A64: FNMSUB 2", "[a64]") { 872 A64TestEnv env; 873 A64::Jit jit{A64::UserConfig{&env}}; 874 875 env.code_mem.emplace_back(0x1f2ab88e); // FNMSUB S14, S4, S10, S14 876 env.code_mem.emplace_back(0x14000000); // B . 877 878 jit.SetPC(0); 879 jit.SetVector(4, {0x3c9623b101398437, 0x7ff0abcd0ba98d27}); 880 jit.SetVector(10, {0xffbfffff3eaaaaab, 0x3f0000003f8147ae}); 881 jit.SetVector(14, {0x80000000007fffff, 0xe73a513400000000}); 882 jit.SetFpcr(0x00400000); 883 884 env.ticks_left = 2; 885 jit.Run(); 886 887 REQUIRE(jit.GetVector(14) == Vector{0x0000000080045284, 0x0000000000000000}); 888 } 889 890 TEST_CASE("A64: FMADD", "[a64]") { 891 A64TestEnv env; 892 A64::Jit jit{A64::UserConfig{&env}}; 893 894 env.code_mem.emplace_back(0x1f5e0e4a); // FMADD D10, D18, D30, D3 895 env.code_mem.emplace_back(0x14000000); // B . 896 897 jit.SetPC(0); 898 jit.SetVector(18, {0x8000007600800000, 0x7ff812347f800000}); 899 jit.SetVector(30, {0xff984a3700000000, 0xe73a513480800000}); 900 jit.SetVector(3, {0x3f000000ff7fffff, 0x8139843780000000}); 901 jit.SetFpcr(0x00400000); 902 903 env.ticks_left = 2; 904 jit.Run(); 905 906 REQUIRE(jit.GetVector(10) == Vector{0x3f059921bf0dbfff, 0x0000000000000000}); 907 } 908 909 TEST_CASE("A64: FMLA.4S(lane)", "[a64]") { 910 A64TestEnv env; 911 A64::Jit jit{A64::UserConfig{&env}}; 912 913 env.code_mem.emplace_back(0x4f8f11c0); // FMLA.4S V0, V14, V15[0] 914 env.code_mem.emplace_back(0x4faf11c1); // FMLA.4S V1, V14, V15[1] 915 env.code_mem.emplace_back(0x4f8f19c2); // FMLA.4S V2, V14, V15[2] 916 env.code_mem.emplace_back(0x4faf19c3); // FMLA.4S V3, V14, V15[3] 917 env.code_mem.emplace_back(0x14000000); // B . 918 919 jit.SetPC(0); 920 jit.SetVector(0, {0x3ff00000'3ff00000, 0x00000000'00000000}); 921 jit.SetVector(1, {0x3ff00000'3ff00000, 0x00000000'00000000}); 922 jit.SetVector(2, {0x3ff00000'3ff00000, 0x00000000'00000000}); 923 jit.SetVector(3, {0x3ff00000'3ff00000, 0x00000000'00000000}); 924 925 jit.SetVector(14, {0x3ff00000'3ff00000, 0x3ff00000'3ff00000}); 926 jit.SetVector(15, {0x3ff00000'40000000, 0x40400000'40800000}); 927 928 env.ticks_left = 5; 929 jit.Run(); 930 931 REQUIRE(jit.GetVector(0) == Vector{0x40b4000040b40000, 0x4070000040700000}); 932 REQUIRE(jit.GetVector(1) == Vector{0x40ac800040ac8000, 0x4061000040610000}); 933 REQUIRE(jit.GetVector(2) == Vector{0x4116000041160000, 0x40f0000040f00000}); 934 REQUIRE(jit.GetVector(3) == Vector{0x40f0000040f00000, 0x40b4000040b40000}); 935 } 936 937 TEST_CASE("A64: FMUL.4S(lane)", "[a64]") { 938 A64TestEnv env; 939 A64::Jit jit{A64::UserConfig{&env}}; 940 941 env.code_mem.emplace_back(0x4f8f91c0); // FMUL.4S V0, V14, V15[0] 942 env.code_mem.emplace_back(0x4faf91c1); // FMUL.4S V1, V14, V15[1] 943 env.code_mem.emplace_back(0x4f8f99c2); // FMUL.4S V2, V14, V15[2] 944 env.code_mem.emplace_back(0x4faf99c3); // FMUL.4S V3, V14, V15[3] 945 env.code_mem.emplace_back(0x14000000); // B . 946 947 jit.SetPC(0); 948 jit.SetVector(14, {0x3ff00000'3ff00000, 0x3ff00000'3ff00000}); 949 jit.SetVector(15, {0x3ff00000'40000000, 0x40400000'40800000}); 950 951 env.ticks_left = 5; 952 jit.Run(); 953 954 REQUIRE(jit.GetVector(0) == Vector{0x4070000040700000, 0x4070000040700000}); 955 REQUIRE(jit.GetVector(1) == Vector{0x4061000040610000, 0x4061000040610000}); 956 REQUIRE(jit.GetVector(2) == Vector{0x40f0000040f00000, 0x40f0000040f00000}); 957 REQUIRE(jit.GetVector(3) == Vector{0x40b4000040b40000, 0x40b4000040b40000}); 958 } 959 960 TEST_CASE("A64: FMLA.4S (denormal)", "[a64]") { 961 A64TestEnv env; 962 A64::Jit jit{A64::UserConfig{&env}}; 963 964 env.code_mem.emplace_back(0x4e2fcccc); // FMLA.4S V12, V6, V15 965 env.code_mem.emplace_back(0x14000000); // B . 966 967 jit.SetPC(0); 968 jit.SetVector(12, {0x3c9623b17ff80000, 0xbff0000080000076}); 969 jit.SetVector(6, {0x7ff80000ff800000, 0x09503366c1200000}); 970 jit.SetVector(15, {0x3ff0000080636d24, 0xbf800000e73a5134}); 971 jit.SetFpcr(0x01000000); 972 973 env.ticks_left = 2; 974 jit.Run(); 975 976 REQUIRE(jit.GetVector(12) == Vector{0x7ff800007fc00000, 0xbff0000068e8e581}); 977 } 978 979 TEST_CASE("A64: FMLA.4S (0x80800000)", "[a64]") { 980 A64TestEnv env; 981 A64::Jit jit{A64::UserConfig{&env}}; 982 983 env.code_mem.emplace_back(0x4e38cc2b); // FMLA.4S V11, V1, V24 984 env.code_mem.emplace_back(0x14000000); // B . 985 986 jit.SetPC(0); 987 jit.SetVector(11, {0xc79b271efff05678, 0xffc0000080800000}); 988 jit.SetVector(1, {0x00636d2400800000, 0x0966320bb26bddee}); 989 jit.SetVector(24, {0x460e8c84fff00000, 0x8ba98d2780800002}); 990 jit.SetFpcr(0x03000000); 991 992 env.ticks_left = 2; 993 jit.Run(); 994 995 REQUIRE(jit.GetVector(11) == Vector{0xc79b271e7fc00000, 0x7fc0000080000000}); 996 } 997 998 // x64 has different rounding behaviour to AArch64. 999 // AArch64 performs rounding after flushing-to-zero. 1000 // x64 performs rounding before flushing-to-zero. 1001 TEST_CASE("A64: FMADD (0x80800000)", "[a64]") { 1002 A64TestEnv env; 1003 A64::Jit jit{A64::UserConfig{&env}}; 1004 1005 env.code_mem.emplace_back(0x1f0f7319); // FMADD S25, S24, S15, S28 1006 env.code_mem.emplace_back(0x14000000); // B . 1007 1008 jit.SetPC(0); 1009 jit.SetVector(24, {0x00800000, 0}); 1010 jit.SetVector(15, {0x0ba98d27, 0}); 1011 jit.SetVector(28, {0x80800000, 0}); 1012 jit.SetFpcr(0x01000000); 1013 1014 env.ticks_left = 2; 1015 jit.Run(); 1016 1017 REQUIRE(jit.GetVector(25) == Vector{0x80000000, 0}); 1018 } 1019 1020 TEST_CASE("A64: FNEG failed to zero upper", "[a64]") { 1021 A64TestEnv env; 1022 A64::Jit jit{A64::UserConfig{&env}}; 1023 1024 env.code_mem.emplace_back(0x2ea0fb50); // FNEG.2S V16, V26 1025 env.code_mem.emplace_back(0x2e207a1c); // SQNEG.8B V28, V16 1026 env.code_mem.emplace_back(0x14000000); // B . 1027 1028 jit.SetPC(0); 1029 jit.SetVector(26, {0x071286fde8f34a90, 0x837cffa8be382f60}); 1030 jit.SetFpcr(0x01000000); 1031 1032 env.ticks_left = 6; 1033 jit.Run(); 1034 1035 REQUIRE(jit.GetVector(28) == Vector{0x79ee7a03980db670, 0}); 1036 REQUIRE(FP::FPSR{jit.GetFpsr()}.QC() == false); 1037 } 1038 1039 TEST_CASE("A64: FRSQRTS", "[a64]") { 1040 A64TestEnv env; 1041 A64::Jit jit{A64::UserConfig{&env}}; 1042 1043 env.code_mem.emplace_back(0x5eb8fcad); // FRSQRTS S13, S5, S24 1044 env.code_mem.emplace_back(0x14000000); // B . 1045 1046 // These particular values result in an intermediate value during 1047 // the calculation that is close to infinity. We want to verify 1048 // that this special case is handled appropriately. 1049 1050 jit.SetPC(0); 1051 jit.SetVector(5, {0xfc6a0206, 0}); 1052 jit.SetVector(24, {0xfc6a0206, 0}); 1053 jit.SetFpcr(0x00400000); 1054 1055 env.ticks_left = 2; 1056 jit.Run(); 1057 1058 REQUIRE(jit.GetVector(13) == Vector{0xff7fffff, 0}); 1059 } 1060 1061 TEST_CASE("A64: SQDMULH.8H (saturate)", "[a64]") { 1062 A64TestEnv env; 1063 A64::Jit jit{A64::UserConfig{&env}}; 1064 1065 env.code_mem.emplace_back(0x4e62b420); // SQDMULH.8H V0, V1, V2 1066 env.code_mem.emplace_back(0x14000000); // B . 1067 1068 // Make sure that saturating values are tested 1069 1070 jit.SetPC(0); 1071 jit.SetVector(1, {0x7fff80007ffe8001, 0x7fff80007ffe8001}); 1072 jit.SetVector(2, {0x7fff80007ffe8001, 0x80007fff80017ffe}); 1073 jit.SetFpsr(0); 1074 1075 env.ticks_left = 2; 1076 jit.Run(); 1077 1078 REQUIRE(jit.GetVector(0) == Vector{0x7ffe7fff7ffc7ffe, 0x8001800180028002}); 1079 REQUIRE(FP::FPSR{jit.GetFpsr()}.QC() == true); 1080 } 1081 1082 TEST_CASE("A64: SQDMULH.4S (saturate)", "[a64]") { 1083 A64TestEnv env; 1084 A64::Jit jit{A64::UserConfig{&env}}; 1085 1086 env.code_mem.emplace_back(0x4ea2b420); // SQDMULH.4S V0, V1, V2 1087 env.code_mem.emplace_back(0x14000000); // B . 1088 1089 // Make sure that saturating values are tested 1090 1091 jit.SetPC(0); 1092 jit.SetVector(1, {0x7fffffff80000000, 0x7fffffff80000000}); 1093 jit.SetVector(2, {0x7fffffff80000000, 0x800000007fffffff}); 1094 jit.SetFpsr(0); 1095 1096 env.ticks_left = 2; 1097 jit.Run(); 1098 1099 REQUIRE(jit.GetVector(0) == Vector{0x7ffffffe7fffffff, 0x8000000180000001}); 1100 REQUIRE(FP::FPSR{jit.GetFpsr()}.QC() == true); 1101 } 1102 1103 TEST_CASE("A64: This is an infinite loop if fast dispatch is enabled", "[a64]") { 1104 A64TestEnv env; 1105 A64::UserConfig conf{&env}; 1106 conf.optimizations &= ~OptimizationFlag::FastDispatch; 1107 A64::Jit jit{conf}; 1108 1109 env.code_mem.emplace_back(0x2ef998fa); 1110 env.code_mem.emplace_back(0x2ef41c11); 1111 env.code_mem.emplace_back(0x0f07fdd8); 1112 env.code_mem.emplace_back(0x9ac90d09); 1113 env.code_mem.emplace_back(0xd63f0120); // BLR X9 1114 env.code_mem.emplace_back(0x14000000); // B . 1115 1116 env.ticks_left = 6; 1117 jit.Run(); 1118 } 1119 1120 TEST_CASE("A64: EXTR", "[a64]") { 1121 A64TestEnv env; 1122 A64::Jit jit{A64::UserConfig{&env}}; 1123 1124 env.code_mem.emplace_back(0x93d8fef7); // EXTR X23, X23, X24, #63 1125 env.code_mem.emplace_back(0x14000000); // B . 1126 1127 jit.SetPC(0); 1128 jit.SetRegister(23, 0); 1129 jit.SetRegister(24, 1); 1130 1131 env.ticks_left = 2; 1132 jit.Run(); 1133 1134 REQUIRE(jit.GetRegister(23) == 0); 1135 } 1136 1137 TEST_CASE("A64: Isolated GetNZCVFromOp", "[a64]") { 1138 A64TestEnv env; 1139 A64::Jit jit{A64::UserConfig{&env}}; 1140 1141 env.code_mem.emplace_back(0xaa1f03f5); // MOV X21, XZR 1142 env.code_mem.emplace_back(0x912a02da); // ADD X26, X22, #0xa80 1143 env.code_mem.emplace_back(0x913662dc); // ADD X28, X22, #0xd98 1144 env.code_mem.emplace_back(0x320003e8); // MOV W8, #1 1145 env.code_mem.emplace_back(0xa9006bfc); // STP X28, X26, [SP] 1146 env.code_mem.emplace_back(0x7200011f); // TST W8, #1 1147 env.code_mem.emplace_back(0xf94007e8); // LDR X8, [SP, #8] 1148 env.code_mem.emplace_back(0x321e03e3); // MOV W3, #4 1149 env.code_mem.emplace_back(0xaa1303e2); // MOV X2, X19 1150 env.code_mem.emplace_back(0x9a881357); // CSEL X23, X26, X8, NE 1151 env.code_mem.emplace_back(0xf94003e8); // LDR X8, [SP] 1152 env.code_mem.emplace_back(0xaa1703e0); // MOV X0, X23 1153 env.code_mem.emplace_back(0x9a881396); // CSEL X22, X28, X8, NE 1154 env.code_mem.emplace_back(0x92407ea8); // AND X8, X21, #0xffffffff 1155 env.code_mem.emplace_back(0x1ac8269b); // LSR W27, W20, W8 1156 env.code_mem.emplace_back(0x0b1b0768); // ADD W8, W27, W27, LSL #1 1157 env.code_mem.emplace_back(0x937f7d01); // SBFIZ X1, X8, #1, #32 1158 env.code_mem.emplace_back(0x2a1f03e4); // MOV W4, WZR 1159 env.code_mem.emplace_back(0x531e7779); // LSL W25, W27, #2 1160 env.code_mem.emplace_back(0x14000000); // B . 1161 1162 jit.SetPC(0); 1163 1164 env.ticks_left = 20; 1165 jit.Run(); 1166 } 1167 1168 TEST_CASE("A64: Optimization failure when folding ADD", "[a64]") { 1169 A64TestEnv env; 1170 A64::Jit jit{A64::UserConfig{&env}}; 1171 1172 env.code_mem.emplace_back(0xbc4f84be); // LDR S30, [X5], #248 1173 env.code_mem.emplace_back(0x9a0c00ea); // ADC X10, X7, X12 1174 env.code_mem.emplace_back(0x5a1a0079); // SBC W25, W3, W26 1175 env.code_mem.emplace_back(0x9b0e2be9); // MADD X9, XZR, X14, X10 1176 env.code_mem.emplace_back(0xfa5fe8a9); // CCMP X5, #31, #9, AL 1177 env.code_mem.emplace_back(0x14000000); // B . 1178 1179 jit.SetPC(0); 1180 jit.SetRegister(0, 0x46e15845dba57924); 1181 jit.SetRegister(1, 0x6f60d04350581fea); 1182 jit.SetRegister(2, 0x85cface50edcfc03); 1183 jit.SetRegister(3, 0x47e1e8906e10ec5a); 1184 jit.SetRegister(4, 0x70717c9450b6b707); 1185 jit.SetRegister(5, 0x300d83205baeaff4); 1186 jit.SetRegister(6, 0xb7890de7c6fee082); 1187 jit.SetRegister(7, 0xa89fb6d6f1b42f4a); 1188 jit.SetRegister(8, 0x04e36b8aada91d4f); 1189 jit.SetRegister(9, 0xa03bf6bde71c6ac5); 1190 jit.SetRegister(10, 0x319374d14baa83b0); 1191 jit.SetRegister(11, 0x5a78fc0fffca7c5f); 1192 jit.SetRegister(12, 0xc012b5063f43b8ad); 1193 jit.SetRegister(13, 0x821ade159d39fea1); 1194 jit.SetRegister(14, 0x41f97b2f5525c25e); 1195 jit.SetRegister(15, 0xab0cd3653cb93738); 1196 jit.SetRegister(16, 0x50dfcb55a4ebd554); 1197 jit.SetRegister(17, 0x30dd7d18ae52df03); 1198 jit.SetRegister(18, 0x4e53b20d252bf085); 1199 jit.SetRegister(19, 0x013582d71f5fd42a); 1200 jit.SetRegister(20, 0x97a151539dad44e7); 1201 jit.SetRegister(21, 0xa6fcc6bb220a2ad3); 1202 jit.SetRegister(22, 0x4c84d3c84a6c5c5c); 1203 jit.SetRegister(23, 0x1a7596a5ef930dff); 1204 jit.SetRegister(24, 0x06248d96a02ff210); 1205 jit.SetRegister(25, 0xfcb8772aec4b1dfd); 1206 jit.SetRegister(26, 0x63619787b6a17665); 1207 jit.SetRegister(27, 0xbd50c3352d001e40); 1208 jit.SetRegister(28, 0x4e186aae63c81553); 1209 jit.SetRegister(29, 0x57462b7163bd6508); 1210 jit.SetRegister(30, 0xa977c850d16d562c); 1211 jit.SetSP(0x000000da9b761d8c); 1212 jit.SetFpsr(0x03480000); 1213 jit.SetPstate(0x30000000); 1214 1215 env.ticks_left = 6; 1216 jit.Run(); 1217 1218 REQUIRE(jit.GetRegister(0) == 0x46e15845dba57924); 1219 REQUIRE(jit.GetRegister(1) == 0x6f60d04350581fea); 1220 REQUIRE(jit.GetRegister(2) == 0x85cface50edcfc03); 1221 REQUIRE(jit.GetRegister(3) == 0x47e1e8906e10ec5a); 1222 REQUIRE(jit.GetRegister(4) == 0x70717c9450b6b707); 1223 REQUIRE(jit.GetRegister(5) == 0x300d83205baeb0ec); 1224 REQUIRE(jit.GetRegister(6) == 0xb7890de7c6fee082); 1225 REQUIRE(jit.GetRegister(7) == 0xa89fb6d6f1b42f4a); 1226 REQUIRE(jit.GetRegister(8) == 0x04e36b8aada91d4f); 1227 REQUIRE(jit.GetRegister(9) == 0x68b26bdd30f7e7f8); 1228 REQUIRE(jit.GetRegister(10) == 0x68b26bdd30f7e7f8); 1229 REQUIRE(jit.GetRegister(11) == 0x5a78fc0fffca7c5f); 1230 REQUIRE(jit.GetRegister(12) == 0xc012b5063f43b8ad); 1231 REQUIRE(jit.GetRegister(13) == 0x821ade159d39fea1); 1232 REQUIRE(jit.GetRegister(14) == 0x41f97b2f5525c25e); 1233 REQUIRE(jit.GetRegister(15) == 0xab0cd3653cb93738); 1234 REQUIRE(jit.GetRegister(16) == 0x50dfcb55a4ebd554); 1235 REQUIRE(jit.GetRegister(17) == 0x30dd7d18ae52df03); 1236 REQUIRE(jit.GetRegister(18) == 0x4e53b20d252bf085); 1237 REQUIRE(jit.GetRegister(19) == 0x013582d71f5fd42a); 1238 REQUIRE(jit.GetRegister(20) == 0x97a151539dad44e7); 1239 REQUIRE(jit.GetRegister(21) == 0xa6fcc6bb220a2ad3); 1240 REQUIRE(jit.GetRegister(22) == 0x4c84d3c84a6c5c5c); 1241 REQUIRE(jit.GetRegister(23) == 0x1a7596a5ef930dff); 1242 REQUIRE(jit.GetRegister(24) == 0x06248d96a02ff210); 1243 REQUIRE(jit.GetRegister(25) == 0x00000000b76f75f5); 1244 REQUIRE(jit.GetRegister(26) == 0x63619787b6a17665); 1245 REQUIRE(jit.GetRegister(27) == 0xbd50c3352d001e40); 1246 REQUIRE(jit.GetRegister(28) == 0x4e186aae63c81553); 1247 REQUIRE(jit.GetRegister(29) == 0x57462b7163bd6508); 1248 REQUIRE(jit.GetRegister(30) == 0xa977c850d16d562c); 1249 REQUIRE(jit.GetPstate() == 0x20000000); 1250 REQUIRE(jit.GetVector(30) == Vector{0xf7f6f5f4, 0}); 1251 } 1252 1253 TEST_CASE("A64: Cache Maintenance Instructions", "[a64]") { 1254 class CacheMaintenanceTestEnv final : public A64TestEnv { 1255 void InstructionCacheOperationRaised(A64::InstructionCacheOperation op, VAddr value) override { 1256 REQUIRE(op == A64::InstructionCacheOperation::InvalidateByVAToPoU); 1257 REQUIRE(value == 0xcafed00d); 1258 } 1259 void DataCacheOperationRaised(A64::DataCacheOperation op, VAddr value) override { 1260 REQUIRE(op == A64::DataCacheOperation::InvalidateByVAToPoC); 1261 REQUIRE(value == 0xcafebabe); 1262 } 1263 }; 1264 1265 CacheMaintenanceTestEnv env; 1266 A64::UserConfig conf{&env}; 1267 conf.hook_data_cache_operations = true; 1268 A64::Jit jit{conf}; 1269 1270 jit.SetRegister(0, 0xcafed00d); 1271 jit.SetRegister(1, 0xcafebabe); 1272 1273 env.code_mem.emplace_back(0xd50b7520); // ic ivau, x0 1274 env.code_mem.emplace_back(0xd5087621); // dc ivac, x1 1275 env.code_mem.emplace_back(0x14000000); // B . 1276 1277 env.ticks_left = 3; 1278 jit.Run(); 1279 } 1280 1281 TEST_CASE("A64: Memory access (fastmem)", "[a64]") { 1282 constexpr size_t address_width = 12; 1283 constexpr size_t memory_size = 1ull << address_width; // 4K 1284 constexpr size_t page_size = 4 * 1024; 1285 constexpr size_t buffer_size = 2 * page_size; 1286 char buffer[buffer_size]; 1287 1288 void* buffer_ptr = reinterpret_cast<void*>(buffer); 1289 size_t buffer_size_nconst = buffer_size; 1290 char* backing_memory = reinterpret_cast<char*>(std::align(page_size, memory_size, buffer_ptr, buffer_size_nconst)); 1291 1292 A64FastmemTestEnv env{backing_memory}; 1293 Dynarmic::A64::UserConfig config{&env}; 1294 config.fastmem_pointer = reinterpret_cast<uintptr_t>(backing_memory); 1295 config.fastmem_address_space_bits = address_width; 1296 config.recompile_on_fastmem_failure = false; 1297 config.silently_mirror_fastmem = true; 1298 config.processor_id = 0; 1299 1300 Dynarmic::A64::Jit jit{config}; 1301 memset(backing_memory, 0, memory_size); 1302 memcpy(backing_memory + 0x100, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 57); 1303 1304 env.MemoryWrite32(0, 0xA9401404); // LDP X4, X5, [X0] 1305 env.MemoryWrite32(4, 0xF9400046); // LDR X6, [X2] 1306 env.MemoryWrite32(8, 0xA9001424); // STP X4, X5, [X1] 1307 env.MemoryWrite32(12, 0xF9000066); // STR X6, [X3] 1308 env.MemoryWrite32(16, 0x14000000); // B . 1309 jit.SetRegister(0, 0x100); 1310 jit.SetRegister(1, 0x1F0); 1311 jit.SetRegister(2, 0x10F); 1312 jit.SetRegister(3, 0x1FF); 1313 1314 jit.SetPC(0); 1315 jit.SetSP(memory_size - 1); 1316 jit.SetFpsr(0x03480000); 1317 jit.SetPstate(0x30000000); 1318 env.ticks_left = 5; 1319 1320 jit.Run(); 1321 REQUIRE(strncmp(backing_memory + 0x100, backing_memory + 0x1F0, 23) == 0); 1322 } 1323 1324 TEST_CASE("A64: SQRDMULH QC flag when output invalidated", "[a64]") { 1325 A64TestEnv env; 1326 A64::Jit jit{A64::UserConfig{&env}}; 1327 1328 env.code_mem.emplace_back(0x0fbcd38b); // SQRDMULH.2S V11, V28, V28[1] 1329 env.code_mem.emplace_back(0x7ef0f8eb); // FMINP.2D D11, V7 1330 env.code_mem.emplace_back(0x14000000); // B . 1331 1332 jit.SetPC(0); 1333 jit.SetVector(7, {0xb1b5'd0b1'4e54'e281, 0xb4cb'4fec'8563'1032}); 1334 jit.SetVector(28, {0x8000'0000'0000'0000, 0x0000'0000'0000'0000}); 1335 jit.SetFpcr(0x05400000); 1336 1337 env.ticks_left = 3; 1338 jit.Run(); 1339 1340 REQUIRE(jit.GetFpsr() == 0x08000000); 1341 REQUIRE(jit.GetVector(11) == Vector{0xb4cb'4fec'8563'1032, 0x0000'0000'0000'0000}); 1342 } 1343 1344 TEST_CASE("A64: SDIV maximally", "[a64]") { 1345 A64TestEnv env; 1346 A64::Jit jit{A64::UserConfig{&env}}; 1347 1348 env.code_mem.emplace_back(0x9ac00c22); // SDIV X2, X1, X0 1349 env.code_mem.emplace_back(0x14000000); // B . 1350 1351 jit.SetRegister(0, 0xffffffffffffffff); 1352 jit.SetRegister(1, 0x8000000000000000); 1353 jit.SetRegister(2, 0xffffffffffffffff); 1354 jit.SetPC(0); 1355 1356 env.ticks_left = 2; 1357 jit.Run(); 1358 1359 REQUIRE(jit.GetRegister(0) == 0xffffffffffffffff); 1360 REQUIRE(jit.GetRegister(1) == 0x8000000000000000); 1361 REQUIRE(jit.GetRegister(2) == 0x8000000000000000); 1362 REQUIRE(jit.GetPC() == 4); 1363 } 1364 1365 // Restricted register set required to trigger: 1366 // const HostLocList any_gpr = { HostLoc::RAX, HostLoc::RBX, HostLoc::RCX, HostLoc::R13, HostLoc::R14 }; 1367 // const HostLocList any_xmm = { HostLoc::XMM1, HostLoc::XMM2, HostLoc::XMM3, HostLoc::XMM4, HostLoc::XMM5, HostLoc::XMM6 }; 1368 TEST_CASE("A64: rand1", "[a64]") { 1369 A64TestEnv env; 1370 A64::Jit jit{A64::UserConfig{&env}}; 1371 1372 env.code_mem = {0x2ea2e69a, 0x6f7168e7, 0x7eb0f816, 0x6ebd369d, 0x1e65c302, 0x1e63011c, 0x1e67c349, 0x0f861bd6, 0x9e59cbbc, 0x5e61cb8b, 0x6e218b01, 0x4eb2409f, 0x7f7c2452, 0x7e207a8d, 0xd503369f}; 1373 env.code_mem.emplace_back(0x14000000); // B . 1374 1375 jit.SetRegister(0, 0x67e1d59cc30a788c); 1376 jit.SetRegister(1, 0x0e771a2a79dfb060); 1377 jit.SetRegister(2, 0x35cc7e7831247f7c); 1378 jit.SetRegister(3, 0x63a22cce1f9cde66); 1379 jit.SetRegister(4, 0xb6a022d8406543a3); 1380 jit.SetRegister(5, 0x6712e272c4ad27a0); 1381 jit.SetRegister(6, 0x9d2a01c3bc374837); 1382 jit.SetRegister(7, 0x83bc2f62feb76043); 1383 jit.SetRegister(8, 0x9ba9e8c3d543f1bf); 1384 jit.SetRegister(9, 0xe4aee4636277b787); 1385 jit.SetRegister(10, 0x9cd9e201dacc233b); 1386 jit.SetRegister(11, 0x39e0a5c3bb44efc9); 1387 jit.SetRegister(12, 0xca229296c29f8742); 1388 jit.SetRegister(13, 0x4cdf038f1323ff2d); 1389 jit.SetRegister(14, 0x377ad499a81b1f5a); 1390 jit.SetRegister(15, 0x8217307060f11c6d); 1391 jit.SetRegister(16, 0xd1af2e75ea62dba7); 1392 jit.SetRegister(17, 0x77661148c760e9d6); 1393 jit.SetRegister(18, 0xf05a251f9cf60f9e); 1394 jit.SetRegister(19, 0xf54301927e8fa020); 1395 jit.SetRegister(20, 0x534c76f6f6d6805c); 1396 jit.SetRegister(21, 0x60240c3e727aae2d); 1397 jit.SetRegister(22, 0x52b82c212af254d6); 1398 jit.SetRegister(23, 0xb0ad501210d12c07); 1399 jit.SetRegister(24, 0x596a9119514f3460); 1400 jit.SetRegister(25, 0xa933e19b69b2c6f7); 1401 jit.SetRegister(26, 0x6f3693ec0f5e7708); 1402 jit.SetRegister(27, 0xc6a3908a03fb9737); 1403 jit.SetRegister(28, 0x113ba38d50953b60); 1404 jit.SetRegister(29, 0xbe5395907134511e); 1405 jit.SetRegister(30, 0x9a5d96aa066e5c39); 1406 jit.SetPC(0); 1407 jit.SetSP(0x000000c6bec5a48c); 1408 1409 jit.SetVector(0, {0x0faa90e6561b1ffb, 0xb8c1c925ee613293}); 1410 jit.SetVector(1, {0x3fa365cf7a4f3eaa, 0xbd0fabf98eb5c061}); 1411 jit.SetVector(2, {0x3d7722d0e4444b00, 0xf30ba88476b79615}); 1412 jit.SetVector(3, {0xf794f4953fb4a413, 0xedd6426638cf0242}); 1413 jit.SetVector(4, {0x1ddfdd8985c58693, 0xc344d565e68ab18b}); 1414 jit.SetVector(5, {0x600fcef72b18ae5f, 0x3af9964747ff06b9}); 1415 jit.SetVector(6, {0x276b755d4452ec74, 0xf5579ddb0f2146b4}); 1416 jit.SetVector(7, {0xd1823739c80439e5, 0xd8c4bc8cf08fce6e}); 1417 jit.SetVector(8, {0x0e4c8796dca46ad0, 0x53293d124cd38d6e}); 1418 jit.SetVector(9, {0x860e30c54fcbe0b8, 0x09c57c6b723e45f5}); 1419 jit.SetVector(10, {0xe3652801c3d11ddb, 0x4ef5f76fa85d28b9}); 1420 jit.SetVector(11, {0xa6c22b4e20d5a3a2, 0x5b98938307afb538}); 1421 jit.SetVector(12, {0x915960a26d2d8c02, 0x0ecdf8bc35c8a184}); 1422 jit.SetVector(13, {0xa79a1f506ed066b4, 0x23de2152171ce4c6}); 1423 jit.SetVector(14, {0xd4b85ed863708645, 0x3cf7b2693ac76d3f}); 1424 jit.SetVector(15, {0x8900b9888729557b, 0x2eeeef32083bf9b9}); 1425 jit.SetVector(16, {0x0b40331c7fc30b54, 0xcb5fb7d6ca96ccca}); 1426 jit.SetVector(17, {0x0040b87ea24910c7, 0x97f925750c5da4c5}); 1427 jit.SetVector(18, {0xf19de744c8c88b3d, 0xa1406fae21f53d8c}); 1428 jit.SetVector(19, {0x02b6e985e99a6a3d, 0xe470d5328c9b2af5}); 1429 jit.SetVector(20, {0x6bfb919ed9752198, 0xcaab56c2adc2c486}); 1430 jit.SetVector(21, {0x4c1dd31e9fb91bae, 0xe1d4a4b936d1dfab}); 1431 jit.SetVector(22, {0x5d8c08ee0dbe758a, 0xb1b25da077a0ba26}); 1432 jit.SetVector(23, {0xf1f3377346a6e4db, 0x4995274fe7e17908}); 1433 jit.SetVector(24, {0xa1c4d7cca6fe8a95, 0xb267a94646819606}); 1434 jit.SetVector(25, {0x8bbe1a250a008e73, 0xc729df1ac7eeb7d3}); 1435 jit.SetVector(26, {0x48c23bc8ce6857d5, 0x35bb31ef278268d7}); 1436 jit.SetVector(27, {0x0473d63f3f0c5075, 0xf4bb5d79938901f4}); 1437 jit.SetVector(28, {0x01e2930f7313493e, 0xdc6ef4adadcc8e37}); 1438 jit.SetVector(29, {0x2c500da43b460d13, 0x7bb4520d5580a648}); 1439 jit.SetVector(30, {0xdf4e3d139b825da0, 0x19fea0310522fda2}); 1440 jit.SetVector(31, {0xf8b440b8d5e25111, 0x73758151a32b6b13}); 1441 1442 jit.SetPstate(0x60000000); 1443 jit.SetFpcr(0x01080000); 1444 1445 env.ticks_left = 16; 1446 jit.Run(); 1447 1448 REQUIRE(jit.GetRegister(0) == 0x67e1d59cc30a788c); 1449 REQUIRE(jit.GetRegister(1) == 0x0e771a2a79dfb060); 1450 REQUIRE(jit.GetRegister(2) == 0x35cc7e7831247f7c); 1451 REQUIRE(jit.GetRegister(3) == 0x63a22cce1f9cde66); 1452 REQUIRE(jit.GetRegister(4) == 0xb6a022d8406543a3); 1453 REQUIRE(jit.GetRegister(5) == 0x6712e272c4ad27a0); 1454 REQUIRE(jit.GetRegister(6) == 0x9d2a01c3bc374837); 1455 REQUIRE(jit.GetRegister(7) == 0x83bc2f62feb76043); 1456 REQUIRE(jit.GetRegister(8) == 0x9ba9e8c3d543f1bf); 1457 REQUIRE(jit.GetRegister(9) == 0xe4aee4636277b787); 1458 REQUIRE(jit.GetRegister(10) == 0x9cd9e201dacc233b); 1459 REQUIRE(jit.GetRegister(11) == 0x39e0a5c3bb44efc9); 1460 REQUIRE(jit.GetRegister(12) == 0xca229296c29f8742); 1461 REQUIRE(jit.GetRegister(13) == 0x4cdf038f1323ff2d); 1462 REQUIRE(jit.GetRegister(14) == 0x377ad499a81b1f5a); 1463 REQUIRE(jit.GetRegister(15) == 0x8217307060f11c6d); 1464 REQUIRE(jit.GetRegister(16) == 0xd1af2e75ea62dba7); 1465 REQUIRE(jit.GetRegister(17) == 0x77661148c760e9d6); 1466 REQUIRE(jit.GetRegister(18) == 0xf05a251f9cf60f9e); 1467 REQUIRE(jit.GetRegister(19) == 0xf54301927e8fa020); 1468 REQUIRE(jit.GetRegister(20) == 0x534c76f6f6d6805c); 1469 REQUIRE(jit.GetRegister(21) == 0x60240c3e727aae2d); 1470 REQUIRE(jit.GetRegister(22) == 0x52b82c212af254d6); 1471 REQUIRE(jit.GetRegister(23) == 0xb0ad501210d12c07); 1472 REQUIRE(jit.GetRegister(24) == 0x596a9119514f3460); 1473 REQUIRE(jit.GetRegister(25) == 0xa933e19b69b2c6f7); 1474 REQUIRE(jit.GetRegister(26) == 0x6f3693ec0f5e7708); 1475 REQUIRE(jit.GetRegister(27) == 0xc6a3908a03fb9737); 1476 REQUIRE(jit.GetRegister(28) == 0x0000000000000000); 1477 REQUIRE(jit.GetRegister(29) == 0xbe5395907134511e); 1478 REQUIRE(jit.GetRegister(30) == 0x9a5d96aa066e5c39); 1479 } 1480 1481 TEST_CASE("A64: rand2", "[a64][.]") { 1482 A64TestEnv env; 1483 A64::Jit jit{A64::UserConfig{.callbacks = &env, .fastmem_pointer = 0xffffffff00000000}}; 1484 1485 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, 0x4e3244e2, 0x6e1b1ceb, 0x0dee5aac, 0x4e2f9dc4, 0x5ea1b8c3, 0x1e59f863, 0xd500403f, 0x4e3ae7d0, 0x4ef5c6ea, 0x08dffe3b, 0x6e36f4f6, 0x2e764f29, 0x0e726f23, 0x5f42375b, 0x7f71fc40, 0x6e618aad, 0x93403e5b, 0x0e205976, 0x0e7250c4, 0x6eb0abc9, 0x2e2049f0, 0x5f14754d, 0x7f6ce468, 0x6f950bbe, 0x6e31aa47, 0x4eb83396, 0x0dccc952, 0x2ea1ca90, 0xce69c701, 0xb0bed69e, 0x7c5dec39, 0x4e2868a2, 0x0e591b08, 0x5f34e6dd, 0x3a449184, 0x5e3ce6de, 0x4ea149b7, 0x4e7ad29b, 0xba198503, 0x1f683e8f, 0xfa52f2a7, 0x6e30dffc, 0x4e6c3d17, 0x2eae3248, 0xd503349f, 0x1e60002c, 0x0f180680, 0x9e240049, 0x6f75774e, 0xa90d8678, 0x9ad924c4, 0x7eb0f85b, 0x0e205aaf, 0x7ee08899, 0x5f4bffd8, 0x1b0ff5f3, 0x4ee11dcd, 0x2e218948, 0x0dcb2733, 0x4eac107c, 0x4ea04a53, 0x4e287b44, 0x0e60b82a, 0x5ee0ebbc, 0xce454ff1, 0x5e1761e7, 0x5e09202f, 0x0e0c0754, 0x1e72e6b9, 0x7e21da70, 0x0fbdb20c, 0x5efb8c84, 0xd500401f, 0x3a47526e, 0x1e680acf, 0x7f7375fc, 0xf80522da, 0x4ee60c02, 0x4d40c2e7, 0x6f89096b, 0x7ee1bb6e, 0x5e280b4a, 0x1e3120c8, 0x7eb2ef96, 0x4fd012dd, 0x0f3027ef, 0x4e2078a8, 0xd503201f, 0x2e2312d9, 0x6ebf1c6e, 0x5ee1f8df, 0x4e607a46, 0x6e30c877, 0x6c09d2d1, 0x4e61abd8, 0x0e35267e, 0x6ac17728, 0x0e861aa0, 0x6f63fe26, 0x6f157628, 0x6f30a5f9, 0x4d60cc0c, 0x4e21cb59, 0x2e68a3fb, 0x7efae601, 0x6ea0f82c, 0x9b25ec12, 0x1a1a0305, 0x0e043fe1, 0x6e73c0ed, 0x6ea1b8c0, 0x7e20380b, 0x0f0534e8, 0x1f56bc7d, 0xba0c0128, 0x1e672160, 0x6e7b259b, 0x7ee07b5d, 0x9a820443, 0x4e040581, 0x2f1d87e8, 0x1acd2f5b, 0x6e20794f, 0x2e6a3c93, 0xc8dffe13, 0xce5ab1c6, 0x6eea55f6, 0x4ea039b3, 0x0d602fec, 0x2e246e2f, 0x7857be39, 0xb80608fb, 0x1e67c017, 0x9bcf7f63, 0x0f92d857, 0x5e0812f7, 0x1e210172, 0x7e6128e9, 0x7ea94d41, 0x981179e1, 0x1effb018, 0x2e600828, 0x0eb9c6b2, 0x6ee1baae, 0x4ea0db28, 0x2ea1487b, 0x4ea6c7f0, 0x2e2374c7, 0x7e30d8dd, 0xb9991fa7, 0x4e791e3e, 0x889f7c4b, 0x0e6c753c, 0x1e740ad1, 0x1e244324, 0x1ef33010, 0x5ac01102, 0x9bd97fba, 0x6e290143, 0x1e2220d8, 0x4d8d5aee, 0x6f28570b, 0xfa4ab0c1, 0xdac00b14, 0x7ea1a90e, 0x2e3027d8, 0x6f25a733, 0x4e61a96e, 0x4e1a2fcb, 0x0e22fe0a, 0xc8df7cd0, 0x5e280a55, 0x4e012b20, 0x7e70dbf4, 0x520c5a4e, 0x6ea6c57f, 0x0e861af8, 0xd503233f, 0x889ffe3c, 0x5e274ea9, 0x4e21a89a, 0x0e170c02, 0x6efd4c0b, 0xd5033ebf, 0x6e61a92c, 0x2e205b72, 0x789fb828, 0x0e626e94, 0x2ea6724c, 0x9a10028b, 0x2c6c51fc, 0x5a9de6b9, 0x6e6881f3, 0x5ee0ea6b, 0x0faec36e, 0x0e955bca, 0x1acf206d, 0x7f6f571b, 0x4e286930, 0x12b41ceb, 0x1e770b7a, 0x0ea18ac2, 0x5e282aaf, 0xf2b7fa1e, 0x1ac34311, 0x13167d11, 0x4ea63412, 0x6e758038, 0x2f1d85d6, 0x0f275480, 0x0ead6c71, 0x6e204b69, 0x1e6303f4, 0x5e0031ef, 0x13001e40, 0x7a16006f, 0x6e6ae4c0, 0x0f0f242f, 0x6e674f50, 0x4e606b7a, 0x7e6ee684, 0x1e6b5957, 0x7ea1bbab, 0x7ea0b6cb, 0xce4da241, 0x0ea1b953, 0x0eb2af4b, 0x9ac309d0, 0x6e61d8bd, 0x5ea0d890, 0x5f47d1e7, 0xfa5981ca, 0x1e7f7959, 0x6ef24dd8, 0x0e0a41d1, 0x5ee0e898, 0x4e6038e2, 0x13097d65, 0x6f839088, 0x9e290265, 0x0e208824, 0x2e65af79, 0x6f36a561, 0x9ad3204b, 0x0e21482e, 0x1e24431d, 0xd50330bf, 0x0df641aa, 0x6e602a83, 0xce30505f, 0x5e025238, 0xd503201f, 0x4e608880, 0x4de9c38d, 0x5e0f5348, 0x6eb48ca9, 0x50fda31b, 0x2e251eec, 0x7842ba50, 0xd8a1cd86, 0x2ea09862, 0x0ea09983, 0x2ea333b0, 0x0ea6032c, 0x4f94801b, 0x7e3ee57d, 0x38135e4f, 0xd8fdd9dd, 0x5ee0fcde, 0x9e64033d, 0x6e37f547, 0x6e3dd7ef, 0x13003f3d, 0x0e602f9f, 0x4e7ad014, 0x9b3b6857, 0x5ea0cb67, 0x0eb31c9f, 0x4e7c5372, 0x5e61b8c0, 0x0ea19b23, 0x0ee6e1df, 0x6e63a626, 0x2f139405, 0x7eb0f96d, 0x9e588c63, 0x2e714c3a, 0x6e8c941e, 0x0f61b331, 0x6f01f625, 0x4e78d4ea, 0x6f403709, 0x1a0300da, 0xda0102c8, 0x7e61d9fd, 0xb89469bb, 0x0c838780, 0x2e60a590, 0x4dfd29e1, 0x4e150f2e, 0xce2810bc, 0x5f541591, 0x9ee60259, 0x2eb40e56, 0x5e014027, 0x2ef71faf, 0x4e2d452f, 0x5ee0a813, 0x4eb03301, 0x38443acf, 0x6eabd502, 0x0e2ee71e, 0x5a960364, 0xce7ec596, 0x7efbed09, 0x4ef42ea2, 0x0eb30ea5, 0x5ee0d9f8, 0x6f513552, 0xf89eb3fa, 0x7ea2eca6, 0x9b00cc19, 0xf897409e, 0x1e73485f, 0x381afa77, 0x0f169f3b, 0x5ee1aa70, 0x5e1803ee, 0x0dbf5a4c, 0xce78c7a6, 0x9b0b260c, 0x2ef8fa19, 0x6e70aa4b, 0xce45b805, 0x2ea08e86, 0x4ee0bafd, 0x2ea09a1f, 0x4e218900, 0x6e744f13, 0xce518653, 0xf81b7a68, 0xce45ac5e, 0x7e62e416, 0x1a1b02b6, 0x7e21db48, 0x381daaaf, 0x6b2c0987, 0x0e2ec651, 0x4eae8502, 0x9bde7ca0, 0x6f47201f, 0x7e61a8a3, 0x6e60d5db, 0x4e2879de, 0xf81d194e, 0x4f1b8d05, 0x4d0048b2, 0x6e203be9, 0x4e3e7eb1, 0x0e260ef8, 0x2e688518, 0x7e3fec46, 0xdac00843, 0xf85c8917, 0x2e212a0f, 0x0e8196da, 0xd503359f, 0xce4c81f2, 0x6ee19992, 0x6e21ca79, 0x4d40c1d2, 0x4f5816ef, 0x4e34c3ea, 0x4df7c283, 0x7ef7eeb6, 0x18e276ce, 0xab0d21c0, 0xd5032f7f, 0x4ea00dbf, 0x5ac01251, 0xd0121955, 0x7f1495e4, 0x7ef0fa11, 0x5e24dd9c, 0x9add25b5, 0x0eb2bdef, 0x9e1977c7, 0x6f4b26bd, 0x0e200a9c, 0x9b4f7c00, 0x0ea0392e, 0x7e212a2c, 0x0b248b90, 0x1acc27a1, 0x2e701c90, 0x5ee1b870, 0x5e280aba, 0x5ea0780e, 0x1e264246, 0x4e052d04, 0x0e731dc4, 0xce461997, 0x9a9e9413, 0x3d462048, 0x5ea1fac5, 0x2ea0c8c4, 0x9a030280, 0x2ebda4b8, 0x5eef8614, 0x6eadc4e0, 0xbd035a8f, 0x4e606b84, 0x4eb1aba1, 0x4e286928, 0x4e2858cc, 0x9add0ce9, 0x4e070d65, 0x5fd399d5, 0x0f03fde7, 0x6ee90c74, 0x4ef8e31e, 0x381d986a, 0x5ea0ebf4, 0x5ea0d87e, 0x2e76ac9e, 0x6eb36cd4, 0x2e6e1c4c, 0x2e2feebc, 0x1ace4b03, 0x5ee0db12, 0x5ea0e9b1, 0x2e1c32d5, 0x5fa49a09, 0x0e258737, 0x7e21ca8e, 0xce4f9988, 0x5f7f56a6, 0x0e739766, 0x4e28586c, 0x6e619908, 0xd500401f, 0xf88b9252, 0x6e251c8e, 0x9e20015b, 0x7f1486b9, 0x717c339b, 0x1f31ff70, 0x4ea0eb62, 0x9acb0926, 0x489f7d85, 0x4e209b54, 0x2e84cf03, 0x2e65946c, 0x0e7d80cd, 0xc8dffecc, 0xce668bd8, 0x6e2188af, 0xeb4ada34, 0x2b25ec33, 0x0d40e6e7, 0x4eb2c757, 0x4ec82ad0, 0x7e21cb0a, 0x0e21a847, 0x4e0b1ec0, 0x381e6ac0, 0x6e61c8f5, 0x0f10071c, 0x2ee21daa, 0x5e61ab31, 0x6e218892, 0x2e7e7cb5, 0x6f2826aa, 0x7f6b54df, 0x4eaa2620, 0xdac00034, 0x4f6477be, 0x7e6148ea, 0x4eef1f57, 0x78459aeb, 0x2ebc3f10, 0x2e35f4eb, 0x4fbf19ce, 0xd8d0e58e, 0x2e21bbc7, 0x6ee0cab6, 0x9bc57e3f, 0x2f854037, 0x4e92181c, 0x6e6d1f89, 0x0f305545, 0x4ee19a57, 0x0e887bdf, 0x5e1a4185, 0x7ef0c821, 0x2eb6607c, 0x2ea0d9b8, 0x9e0380f4, 0x2ebf1c83, 0x1e62597d, 0x7f6e2548, 0x5ac00205, 0x4e616adb, 0xce638b8c, 0x5e1653cf, 0x2e6069be, 0x0e2ac641, 0x1e33c76f, 0xce44956d, 0x9bb90d31, 0x1e24c20a, 0x7ee038c1, 0x93407e5e, 0x4e280127, 0xc8df7f7d, 0xba42f263, 0x1e6f199c, 0x6e212889, 0x6e92f60e, 0x6ebdc499, 0x8b9acbf8, 0x4d40c581, 0x3a020250, 0x6e6a6716, 0x9248403b, 0x9081ffea, 0x4e603856, 0x9ad1242b, 0x6f270579, 0x1a070349, 0xcec08133, 0xd503305f, 0x5a1a00ca, 0x2e60b8a2, 0x0e5f28fd, 0x0e31a3da, 0x7e61cbc1, 0xd503399f, 0x5f5e54aa, 0x0eb8bdea, 0x4eba8f10, 0x4e2a2e60, 0x2f3da7d6, 0x1e58e297, 0x6e71aa3e, 0x6b86701a, 0xce4fa5e6, 0x4ee7c463, 0x8a79307f, 0x0ebea541, 0x2e218af4, 0x4e774f8a, 0xb9b95dc5, 0x6e61abd5, 0x4dd1e814, 0x4da72098, 0x98307582, 0x3a512101, 0x7ef95497, 0x1ace5535, 0x5a0c0349, 0x4e28581b, 0x6ebf1c02, 0x5ea1da23, 0x1e274314, 0x5e25dd29, 0x6e75f594, 0x6eaf6ed5, 0x4e214abe, 0x4e064172, 0x2e21c8f4, 0xf84c5b08, 0x1e244312, 0x14000000}; 1486 env.code_mem.emplace_back(0x14000000); // B . 1487 1488 jit.SetRegister(0, 0x866524401a1d4e47); 1489 jit.SetRegister(1, 0x02ca8cec51301b60); 1490 jit.SetRegister(2, 0x0d2e0921242a853d); 1491 jit.SetRegister(3, 0x5ce3dda7d19ec198); 1492 jit.SetRegister(4, 0x8a608e22fb3f50d9); 1493 jit.SetRegister(5, 0x97eab1c959f550bb); 1494 jit.SetRegister(6, 0xdb6d004e7503e72a); 1495 jit.SetRegister(7, 0xbc585cf4f01fee85); 1496 jit.SetRegister(8, 0xd7873927978802ca); 1497 jit.SetRegister(9, 0xf64d146839cc0275); 1498 jit.SetRegister(10, 0xada655f0c8013f78); 1499 jit.SetRegister(11, 0x9c06b18d34ad718a); 1500 jit.SetRegister(12, 0xaa46ab9693a7549f); 1501 jit.SetRegister(13, 0xdc0392ca7ded1f12); 1502 jit.SetRegister(14, 0xb86b5a280b452d1e); 1503 jit.SetRegister(15, 0x4cafeaf58ccf472e); 1504 jit.SetRegister(16, 0x21fcba85c1ed26ba); 1505 jit.SetRegister(17, 0xca8075f2eb56e277); 1506 jit.SetRegister(18, 0x3f06bc758608d762); 1507 jit.SetRegister(19, 0xbbc5a0aecff698e5); 1508 jit.SetRegister(20, 0x02170439baa29e14); 1509 jit.SetRegister(21, 0x0e7a29e1ab81b89b); 1510 jit.SetRegister(22, 0xe8af1b958d645884); 1511 jit.SetRegister(23, 0x86691d7e0500e2e9); 1512 jit.SetRegister(24, 0x4983e6e57f0602c1); 1513 jit.SetRegister(25, 0x4077d562a05048c5); 1514 jit.SetRegister(26, 0x7019154cfcba3e12); 1515 jit.SetRegister(27, 0xfb17997ce5f6a4ce); 1516 jit.SetRegister(28, 0x6eb7a6b778e3dbca); 1517 jit.SetRegister(29, 0x2ca051e70a4743be); 1518 jit.SetRegister(30, 0x91fcc5fdd8a78378); 1519 jit.SetPC(100); 1520 jit.SetSP(0x000000cdfadeaff0); 1521 1522 env.code_mem_start_address = 100; 1523 1524 jit.SetVector(0, {0x4d5a180ac0ffdac8, 0xfc6eb113cd5ff2a8}); 1525 jit.SetVector(1, {0x39f8cecc9de9cefd, 0x3a6b35d333d89a6b}); 1526 jit.SetVector(2, {0x791fd8290bbdd2f4, 0xdc0e5e7aee311411}); 1527 jit.SetVector(3, {0xd97db4cbd67fe7de, 0x50042a5e0b94f71c}); 1528 jit.SetVector(4, {0xe2b93543509f65a7, 0xaa1b6433c337c5b9}); 1529 jit.SetVector(5, {0xd93ee9fc22c5edf7, 0xe9042e8f2a2279d3}); 1530 jit.SetVector(6, {0x988cf27e5c9928ad, 0xc1a39aa7429018af}); 1531 jit.SetVector(7, {0x8f24fd7c96752d5e, 0x211ed066df4bf60d}); 1532 jit.SetVector(8, {0xec12260921aa0e5d, 0xcb98d7c3aa39bb54}); 1533 jit.SetVector(9, {0x8ae0d63bef16836b, 0x54b582f6c7c563d5}); 1534 jit.SetVector(10, {0xd36cb5833320a802, 0x94afbd35a90c0d01}); 1535 jit.SetVector(11, {0xf80d24f3de920bb5, 0x8505fd820fdca5ac}); 1536 jit.SetVector(12, {0xc4d5ee040479c10a, 0xb9a65305f855b401}); 1537 jit.SetVector(13, {0xe258117dea0e2e1d, 0x50b6e47f2cbbf98f}); 1538 jit.SetVector(14, {0x8c46631befe40367, 0x76ef634acc1d252e}); 1539 jit.SetVector(15, {0x31ba2e4997445a39, 0xeea2b7e296ed9a10}); 1540 jit.SetVector(16, {0xb1b6ad7f6888ad82, 0x22d61f3a89e351f2}); 1541 jit.SetVector(17, {0x38556d902cb1e166, 0xd94cd8ece8871a9b}); 1542 jit.SetVector(18, {0x8022388e51111894, 0x8319843c0f97c296}); 1543 jit.SetVector(19, {0x80950f4f1988738e, 0x2b51d501a2ac843e}); 1544 jit.SetVector(20, {0xd959d91895a0e304, 0xd86a18f9fbca97cd}); 1545 jit.SetVector(21, {0x9b06de585c91b8f6, 0x6a27b488c3137c9c}); 1546 jit.SetVector(22, {0x95970398b8941fde, 0x85f81fbbf5989d74}); 1547 jit.SetVector(23, {0x33926666f9db44d7, 0xf36ed3933d067e0f}); 1548 jit.SetVector(24, {0x1aefb2ab9a149525, 0xbff5abf69badf81f}); 1549 jit.SetVector(25, {0x88492c5b044f4d83, 0x3fc4029fe302c62c}); 1550 jit.SetVector(26, {0x0cfcc374a4866662, 0xcec449f82b95bc0f}); 1551 jit.SetVector(27, {0x54506ca290052cf6, 0x22f41aa29a475adb}); 1552 jit.SetVector(28, {0x7baf46a55161f432, 0xe7426c082b417919}); 1553 jit.SetVector(29, {0x03a801b9d543654e, 0xb78f7f602ad245ee}); 1554 jit.SetVector(30, {0x656014c093d5ef4a, 0x180caaef9d32e7ab}); 1555 jit.SetVector(31, {0xb6f6e9d497f143b9, 0x1c52381350356431}); 1556 1557 jit.SetPstate(0xb0000000); 1558 jit.SetFpcr(0x01000000); 1559 1560 env.ticks_left = 110; 1561 jit.Run(); 1562 1563 REQUIRE(jit.GetVector(0) == Vector{0x0101010211914707, 0x090000007fd9991a}); 1564 REQUIRE(jit.GetVector(1) == Vector{0x00000000fffffffe, 0x0000000000000000}); 1565 REQUIRE(jit.GetVector(2) == Vector{0x05004503877a2f45, 0x0000000000000000}); 1566 REQUIRE(jit.GetVector(3) == Vector{0x000000007f800000, 0x0000000000000000}); 1567 REQUIRE(jit.GetVector(4) == Vector{0xffffffff00000000, 0x0000000000000000}); 1568 REQUIRE(jit.GetVector(5) == Vector{0xda00894d7886d0bb, 0x5cc5a3b2ca6afb26}); 1569 REQUIRE(jit.GetVector(6) == Vector{0x0000000000000000, 0xfffffffd00000000}); 1570 REQUIRE(jit.GetVector(7) == Vector{0x0000000000000000, 0x0000000000000000}); 1571 REQUIRE(jit.GetVector(8) == Vector{0x0000000000000000, 0x0000000000000000}); 1572 REQUIRE(jit.GetVector(9) == Vector{0x00000000ff800000, 0x0000000000000000}); 1573 REQUIRE(jit.GetVector(10) == Vector{0xc000000000000000, 0x0000000000000000}); 1574 REQUIRE(jit.GetVector(11) == Vector{0xffff000000000000, 0x0000000000000000}); 1575 REQUIRE(jit.GetVector(12) == Vector{0x0c0bd08451d5d9b3, 0x0000000000000000}); 1576 REQUIRE(jit.GetVector(13) == Vector{0x0000000000000000, 0xdc1e34ac00000000}); 1577 REQUIRE(jit.GetVector(14) == Vector{0x00000000ffffffff, 0x0000000000000000}); 1578 REQUIRE(jit.GetVector(15) == Vector{0xfbdfff7cf38fba7d, 0xfffffffffffffffe}); 1579 REQUIRE(jit.GetVector(16) == Vector{0x0000000000000000, 0x0000000000000000}); 1580 REQUIRE(jit.GetVector(17) == Vector{0x0000000000000000, 0x0000000000000000}); 1581 REQUIRE(jit.GetVector(18) == Vector{0x00000000ffffffff, 0x0000000000000000}); 1582 REQUIRE(jit.GetVector(19) == Vector{0x0000000000000000, 0x090000007fd9991a}); 1583 REQUIRE(jit.GetVector(20) == Vector{0x0000000000000000, 0x0000000000000000}); 1584 REQUIRE(jit.GetVector(21) == Vector{0xdbdad9d8dbdad9d8, 0xdbdad9d8dbdad9d8}); 1585 REQUIRE(jit.GetVector(22) == Vector{0xdbdad9d8dbdad9d8, 0xdbdad9d8dbdad9d8}); 1586 REQUIRE(jit.GetVector(23) == Vector{0xffffffff00000000, 0x0000000000000000}); 1587 REQUIRE(jit.GetVector(24) == Vector{0xffffffffffffffff, 0x0000000000000000}); 1588 REQUIRE(jit.GetVector(25) == Vector{0x0000007f00000000, 0x0000000000000000}); 1589 REQUIRE(jit.GetVector(26) == Vector{0x0000000000000000, 0x0000000000000000}); 1590 REQUIRE(jit.GetVector(27) == Vector{0x3a7d96116b237d60, 0x0c6bd37dd698d82a}); 1591 REQUIRE(jit.GetVector(28) == Vector{0x8000000000000000, 0x0000000000000000}); 1592 REQUIRE(jit.GetVector(29) == Vector{0xb3b2000000000000, 0x0000000000000000}); 1593 REQUIRE(jit.GetVector(30) == Vector{0x0000000000000000, 0x8080808080808080}); 1594 REQUIRE(jit.GetVector(31) == Vector{0xb3b2b3b200000000, 0x0000000000000000}); 1595 } 1596 1597 TEST_CASE("A64: SABD", "[a64]") { 1598 A64TestEnv env; 1599 A64::Jit jit{A64::UserConfig{&env}}; 1600 1601 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 1602 code.SABD(V0.B16(), V3.B16(), V4.B16()); 1603 code.SABD(V1.H8(), V5.H8(), V6.H8()); 1604 code.SABD(V2.S4(), V7.S4(), V8.S4()); 1605 1606 constexpr std::array<Vector, 9> vectors = { 1607 // expected output vectors (int8, int16, int32) 1608 Vector{0xa8'4a'cd'0f'7b'2b'78'49, 0x00'ff'88'01'29'34'10'1d}, 1609 Vector{0x1b8c'83cc'4640'37e5, 0x1696'ab90'3d96'2155}, 1610 Vector{0x1c656335'733d91c4, 0x1a488da4'b025dc65}, 1611 // int8 input vectors [3-4] 1612 Vector{0x81'60'7e'60'c4'd6'20'34, 0x12'7f'f7'00'3f'db'0b'a0}, 1613 Vector{0x29'16'b1'6f'3f'ab'a8'7d, 0x12'80'7f'ff'16'0f'fb'83}, 1614 // int16 input vectors [5-6] 1615 Vector{0x8bbd'c450'2dd9'7179, 0xf171'966c'33f2'423b}, 1616 Vector{0xa749'481c'e799'3994, 0xdadb'41fc'f65c'20e6}, 1617 // int32 input vectors [7-8] 1618 Vector{0x57816e27'df8b9293, 0xe1808186'495e497a}, 1619 Vector{0x73e6d15c'52c92457, 0xfbc90f2a'99386d15}, 1620 }; 1621 1622 jit.SetPC(0); 1623 jit.SetVector(3, vectors[3]); 1624 jit.SetVector(4, vectors[4]); 1625 jit.SetVector(5, vectors[5]); 1626 jit.SetVector(6, vectors[6]); 1627 jit.SetVector(7, vectors[7]); 1628 jit.SetVector(8, vectors[8]); 1629 1630 env.ticks_left = env.code_mem.size(); 1631 jit.Run(); 1632 1633 CHECK(jit.GetVector(0) == vectors[0]); 1634 CHECK(jit.GetVector(1) == vectors[1]); 1635 CHECK(jit.GetVector(2) == vectors[2]); 1636 1637 // ensure the correct results are not being produced randomly 1638 jit.SetPC(0); 1639 jit.SetVectors(std::array<Vector, 32>{}); 1640 jit.SetVector(3, vectors[4]); 1641 jit.SetVector(4, vectors[3]); 1642 jit.SetVector(5, vectors[6]); 1643 jit.SetVector(6, vectors[5]); 1644 jit.SetVector(7, vectors[8]); 1645 jit.SetVector(8, vectors[7]); 1646 1647 env.ticks_left = 4; 1648 jit.Run(); 1649 1650 CHECK(jit.GetVector(0) == vectors[0]); 1651 CHECK(jit.GetVector(1) == vectors[1]); 1652 CHECK(jit.GetVector(2) == vectors[2]); 1653 } 1654 1655 TEST_CASE("A64: UZP{1,2}.2D", "[a64]") { 1656 A64TestEnv env; 1657 A64::Jit jit{A64::UserConfig{&env}}; 1658 1659 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 1660 code.UZP1(V2.D2(), V0.D2(), V1.D2()); 1661 code.UZP2(V3.D2(), V0.D2(), V1.D2()); 1662 1663 jit.SetPC(0); 1664 jit.SetVector(0, {0xF0F1F2F3F4F5F6F7, 0xE0E1E2E3E4E5E6E7}); 1665 jit.SetVector(1, {0xA0A1A2A3A4A5A6A7, 0xB0B1B2B3B4B5B6B7}); 1666 1667 env.ticks_left = env.code_mem.size(); 1668 jit.Run(); 1669 1670 REQUIRE(jit.GetVector(2) == Vector{0xF0F1F2F3F4F5F6F7, 0xA0A1A2A3A4A5A6A7}); 1671 REQUIRE(jit.GetVector(3) == Vector{0xE0E1E2E3E4E5E6E7, 0xB0B1B2B3B4B5B6B7}); 1672 } 1673 1674 TEST_CASE("A64: UZP{1,2}.S", "[a64]") { 1675 A64TestEnv env; 1676 A64::Jit jit{A64::UserConfig{&env}}; 1677 1678 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 1679 code.UZP1(V2.S2(), V0.S2(), V1.S2()); 1680 code.UZP2(V3.S2(), V0.S2(), V1.S2()); 1681 code.UZP1(V4.S4(), V0.S4(), V1.S4()); 1682 code.UZP2(V5.S4(), V0.S4(), V1.S4()); 1683 1684 jit.SetPC(0); 1685 jit.SetVector(0, {0xF4F5F6F7'F0F1F2F3, 0xE4E5E6E7'E0E1E2E3}); 1686 jit.SetVector(1, {0xA4A5A6A7'A0A1A2A3, 0xB4B5B6B7'B0B1B2B3}); 1687 1688 env.ticks_left = env.code_mem.size(); 1689 jit.Run(); 1690 1691 REQUIRE(jit.GetVector(2) == Vector{0xA0A1A2A3'F0F1F2F3, 0}); 1692 REQUIRE(jit.GetVector(3) == Vector{0xA4A5A6A7'F4F5F6F7, 0}); 1693 REQUIRE(jit.GetVector(4) == Vector{0xE0E1E2E3'F0F1F2F3, 0xB0B1B2B3'A0A1A2A3}); 1694 REQUIRE(jit.GetVector(5) == Vector{0xE4E5E6E7'F4F5F6F7, 0xB4B5B6B7'A4A5A6A7}); 1695 } 1696 1697 TEST_CASE("A64: UZP{1,2}.H", "[a64]") { 1698 A64TestEnv env; 1699 A64::Jit jit{A64::UserConfig{&env}}; 1700 1701 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 1702 code.UZP1(V2.H4(), V0.H4(), V1.H4()); 1703 code.UZP2(V3.H4(), V0.H4(), V1.H4()); 1704 code.UZP1(V4.H8(), V0.H8(), V1.H8()); 1705 code.UZP2(V5.H8(), V0.H8(), V1.H8()); 1706 1707 jit.SetPC(0); 1708 jit.SetVector(0, {0xF6F7'F4F5'F2F3'F0F1, 0xE6E7'E4E5'E2E3'E0E1}); 1709 jit.SetVector(1, {0xA6A7'A4A5'A2A3'A0A1, 0xB6B7'B4B5'B2B3'B0B1}); 1710 1711 env.ticks_left = env.code_mem.size(); 1712 jit.Run(); 1713 1714 REQUIRE(jit.GetVector(2) == Vector{0xA4A5'A0A1'F4F5'F0F1, 0}); 1715 REQUIRE(jit.GetVector(3) == Vector{0xA6A7'A2A3'F6F7'F2F3, 0}); 1716 REQUIRE(jit.GetVector(4) == Vector{0xE4E5'E0E1'F4F5'F0F1, 0xB4B5'B0B1'A4A5'A0A1}); 1717 REQUIRE(jit.GetVector(5) == Vector{0xE6E7'E2E3'F6F7'F2F3, 0xB6B7'B2B3'A6A7'A2A3}); 1718 } 1719 1720 TEST_CASE("A64: UZP{1,2}.B", "[a64]") { 1721 A64TestEnv env; 1722 A64::Jit jit{A64::UserConfig{&env}}; 1723 1724 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 1725 code.UZP1(V2.B8(), V0.B8(), V1.B8()); 1726 code.UZP2(V3.B8(), V0.B8(), V1.B8()); 1727 code.UZP1(V4.B16(), V0.B16(), V1.B16()); 1728 code.UZP2(V5.B16(), V0.B16(), V1.B16()); 1729 1730 jit.SetPC(0); 1731 jit.SetVector(0, {0xF7'F6'F5'F4'F3'F2'F1'F0, 0xE7'E6'E5'E4'E3'E2'E1'E0}); 1732 jit.SetVector(1, {0xA7'A6'A5'A4'A3'A2'A1'A0, 0xB7'B6'B5'B4'B3'B2'B1'B0}); 1733 1734 env.ticks_left = env.code_mem.size(); 1735 jit.Run(); 1736 1737 REQUIRE(jit.GetVector(2) == Vector{0xA6'A4'A2'A0'F6'F4'F2'F0, 0}); 1738 REQUIRE(jit.GetVector(3) == Vector{0xA7'A5'A3'A1'F7'F5'F3'F1, 0}); 1739 REQUIRE(jit.GetVector(4) == Vector{0xE6'E4'E2'E0'F6'F4'F2'F0, 0xB6'B4'B2'B0'A6'A4'A2'A0}); 1740 REQUIRE(jit.GetVector(5) == Vector{0xE7'E5'E3'E1'F7'F5'F3'F1, 0xB7'B5'B3'B1'A7'A5'A3'A1}); 1741 } 1742 1743 TEST_CASE("A64: {S,U}MIN.S, {S,U}MAX.S", "[a64]") { 1744 A64TestEnv env; 1745 A64::Jit jit{A64::UserConfig{&env}}; 1746 1747 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 1748 code.SMIN(V2.S4(), V0.S4(), V1.S4()); 1749 code.UMIN(V3.S4(), V0.S4(), V1.S4()); 1750 code.SMAX(V4.S4(), V0.S4(), V1.S4()); 1751 code.UMAX(V5.S4(), V0.S4(), V1.S4()); 1752 1753 code.SMIN(V12.S4(), V1.S4(), V0.S4()); 1754 code.UMIN(V13.S4(), V1.S4(), V0.S4()); 1755 code.SMAX(V14.S4(), V1.S4(), V0.S4()); 1756 code.UMAX(V15.S4(), V1.S4(), V0.S4()); 1757 1758 constexpr std::array<Vector, 6> vectors = { 1759 // initial input vectors [0-1] 1760 Vector{0x7FFFFFFF'00000002, 0x76543209'01234567}, 1761 Vector{0x80000000'00000003, 0x76543210'F1234567}, 1762 // expected output vectors [2-5] 1763 Vector{0x80000000'00000002, 0x76543209'F1234567}, 1764 Vector{0x7FFFFFFF'00000002, 0x76543209'01234567}, 1765 Vector{0x7FFFFFFF'00000003, 0x76543210'01234567}, 1766 Vector{0x80000000'00000003, 0x76543210'F1234567}, 1767 }; 1768 1769 jit.SetPC(0); 1770 jit.SetVector(0, vectors[0]); 1771 jit.SetVector(1, vectors[1]); 1772 1773 env.ticks_left = env.code_mem.size(); 1774 jit.Run(); 1775 1776 CHECK(jit.GetVector(2) == vectors[2]); 1777 CHECK(jit.GetVector(3) == vectors[3]); 1778 CHECK(jit.GetVector(4) == vectors[4]); 1779 CHECK(jit.GetVector(5) == vectors[5]); 1780 1781 CHECK(jit.GetVector(12) == vectors[2]); 1782 CHECK(jit.GetVector(13) == vectors[3]); 1783 CHECK(jit.GetVector(14) == vectors[4]); 1784 CHECK(jit.GetVector(15) == vectors[5]); 1785 } 1786 1787 TEST_CASE("A64: {S,U}MIN.H, {S,U}MAX.H", "[a64]") { 1788 A64TestEnv env; 1789 A64::Jit jit{A64::UserConfig{&env}}; 1790 1791 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 1792 code.SMIN(V2.H8(), V0.H8(), V1.H8()); 1793 code.UMIN(V3.H8(), V0.H8(), V1.H8()); 1794 code.SMAX(V4.H8(), V0.H8(), V1.H8()); 1795 code.UMAX(V5.H8(), V0.H8(), V1.H8()); 1796 1797 code.SMIN(V12.H8(), V1.H8(), V0.H8()); 1798 code.UMIN(V13.H8(), V1.H8(), V0.H8()); 1799 code.SMAX(V14.H8(), V1.H8(), V0.H8()); 1800 code.UMAX(V15.H8(), V1.H8(), V0.H8()); 1801 1802 constexpr std::array<Vector, 6> vectors = { 1803 // initial input vectors [0-1] 1804 Vector{0x0123'0000'0002'7FFE, 0x8764'0123'7FFF'FFFE}, 1805 Vector{0xF123'FFFF'0003'7FFF, 0x8765'0124'8000'FFFF}, 1806 // expected output vectors [2-5] 1807 Vector{0xF123'FFFF'0002'7FFE, 0x8764'0123'8000'FFFE}, 1808 Vector{0x0123'0000'0002'7FFE, 0x8764'0123'7FFF'FFFE}, 1809 Vector{0x0123'0000'0003'7FFF, 0x8765'0124'7FFF'FFFF}, 1810 Vector{0xF123'FFFF'0003'7FFF, 0x8765'0124'8000'FFFF}, 1811 }; 1812 1813 jit.SetPC(0); 1814 jit.SetVector(0, vectors[0]); 1815 jit.SetVector(1, vectors[1]); 1816 1817 env.ticks_left = env.code_mem.size(); 1818 jit.Run(); 1819 1820 CHECK(jit.GetVector(2) == vectors[2]); 1821 CHECK(jit.GetVector(3) == vectors[3]); 1822 CHECK(jit.GetVector(4) == vectors[4]); 1823 CHECK(jit.GetVector(5) == vectors[5]); 1824 1825 CHECK(jit.GetVector(12) == vectors[2]); 1826 CHECK(jit.GetVector(13) == vectors[3]); 1827 CHECK(jit.GetVector(14) == vectors[4]); 1828 CHECK(jit.GetVector(15) == vectors[5]); 1829 } 1830 1831 TEST_CASE("A64: {S,U}MIN.B, {S,U}MAX.B", "[a64]") { 1832 A64TestEnv env; 1833 A64::Jit jit{A64::UserConfig{&env}}; 1834 1835 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 1836 code.SMIN(V2.B16(), V0.B16(), V1.B16()); 1837 code.UMIN(V3.B16(), V0.B16(), V1.B16()); 1838 code.SMAX(V4.B16(), V0.B16(), V1.B16()); 1839 code.UMAX(V5.B16(), V0.B16(), V1.B16()); 1840 1841 code.SMIN(V12.B16(), V1.B16(), V0.B16()); 1842 code.UMIN(V13.B16(), V1.B16(), V0.B16()); 1843 code.SMAX(V14.B16(), V1.B16(), V0.B16()); 1844 code.UMAX(V15.B16(), V1.B16(), V0.B16()); 1845 1846 constexpr std::array<Vector, 6> vectors = { 1847 // initial input vectors [0-1] 1848 Vector{0x40'70'F0'A0'02'7E'7F'FE, 0xC2'B0'7E'7F'00'18'9A'12}, 1849 Vector{0x41'71'F1'A1'03'7F'80'FF, 0xC3'B1'82'81'FF'81'99'34}, 1850 // expected output vectors [2-5] 1851 Vector{0x40'70'F0'A0'02'7E'80'FE, 0xC2'B0'82'81'FF'81'99'12}, 1852 Vector{0x40'70'F0'A0'02'7E'7F'FE, 0xC2'B0'7E'7F'00'18'99'12}, 1853 Vector{0x41'71'F1'A1'03'7F'7F'FF, 0xC3'B1'7E'7F'00'18'9A'34}, 1854 Vector{0x41'71'F1'A1'03'7F'80'FF, 0xC3'B1'82'81'FF'81'9A'34}, 1855 }; 1856 1857 jit.SetPC(0); 1858 jit.SetVector(0, vectors[0]); 1859 jit.SetVector(1, vectors[1]); 1860 1861 env.ticks_left = env.code_mem.size(); 1862 jit.Run(); 1863 1864 CHECK(jit.GetVector(2) == vectors[2]); 1865 CHECK(jit.GetVector(3) == vectors[3]); 1866 CHECK(jit.GetVector(4) == vectors[4]); 1867 CHECK(jit.GetVector(5) == vectors[5]); 1868 1869 CHECK(jit.GetVector(12) == vectors[2]); 1870 CHECK(jit.GetVector(13) == vectors[3]); 1871 CHECK(jit.GetVector(14) == vectors[4]); 1872 CHECK(jit.GetVector(15) == vectors[5]); 1873 } 1874 1875 TEST_CASE("A64: {S,U}MINP.S, {S,U}MAXP.S", "[a64]") { 1876 A64TestEnv env; 1877 A64::Jit jit{A64::UserConfig{&env}}; 1878 1879 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 1880 code.SMINP(V2.S2(), V0.S2(), V1.S2()); 1881 code.UMINP(V3.S2(), V0.S2(), V1.S2()); 1882 code.SMINP(V4.S4(), V0.S4(), V1.S4()); 1883 code.UMINP(V5.S4(), V0.S4(), V1.S4()); 1884 code.SMAXP(V6.S2(), V0.S2(), V1.S2()); 1885 code.UMAXP(V7.S2(), V0.S2(), V1.S2()); 1886 code.SMAXP(V8.S4(), V0.S4(), V1.S4()); 1887 code.UMAXP(V9.S4(), V0.S4(), V1.S4()); 1888 1889 constexpr std::array<Vector, 12> vectors = { 1890 // initial input vectors [0-1] 1891 Vector{0x00000003'00000002, 0xF1234567'01234567}, 1892 Vector{0x80000000'7FFFFFFF, 0x76543210'76543209}, 1893 // expected output vectors [2-9] 1894 Vector{0x80000000'00000002, 0}, 1895 Vector{0x7FFFFFFF'00000002, 0}, 1896 Vector{0xF1234567'00000002, 0x76543209'80000000}, 1897 Vector{0x01234567'00000002, 0x76543209'7FFFFFFF}, 1898 Vector{0x7FFFFFFF'00000003, 0}, 1899 Vector{0x80000000'00000003, 0}, 1900 Vector{0x01234567'00000003, 0x76543210'7FFFFFFF}, 1901 Vector{0xF1234567'00000003, 0x76543210'80000000}, 1902 // input vectors with elements swapped pairwise [10-11] 1903 Vector{0x00000002'00000003, 0x01234567'F1234567}, 1904 Vector{0x7FFFFFFF'80000000, 0x76543209'76543210}, 1905 }; 1906 1907 jit.SetPC(0); 1908 jit.SetVector(0, vectors[0]); 1909 jit.SetVector(1, vectors[1]); 1910 1911 env.ticks_left = env.code_mem.size(); 1912 jit.Run(); 1913 1914 CHECK(jit.GetVector(2) == vectors[2]); 1915 CHECK(jit.GetVector(3) == vectors[3]); 1916 CHECK(jit.GetVector(4) == vectors[4]); 1917 CHECK(jit.GetVector(5) == vectors[5]); 1918 CHECK(jit.GetVector(6) == vectors[6]); 1919 CHECK(jit.GetVector(7) == vectors[7]); 1920 CHECK(jit.GetVector(8) == vectors[8]); 1921 CHECK(jit.GetVector(9) == vectors[9]); 1922 1923 // run the same tests again but with the input vectors swapped pairwise, 1924 // to ensure we aren't randomly producing the correct values 1925 jit.SetPC(0); 1926 jit.SetVectors(std::array<Vector, 32>{}); 1927 jit.SetVector(0, vectors[10]); 1928 jit.SetVector(1, vectors[11]); 1929 1930 env.ticks_left = env.code_mem.size(); 1931 jit.Run(); 1932 1933 CHECK(jit.GetVector(2) == vectors[2]); 1934 CHECK(jit.GetVector(3) == vectors[3]); 1935 CHECK(jit.GetVector(4) == vectors[4]); 1936 CHECK(jit.GetVector(5) == vectors[5]); 1937 CHECK(jit.GetVector(6) == vectors[6]); 1938 CHECK(jit.GetVector(7) == vectors[7]); 1939 CHECK(jit.GetVector(8) == vectors[8]); 1940 CHECK(jit.GetVector(9) == vectors[9]); 1941 } 1942 1943 TEST_CASE("A64: {S,U}MINP.H, {S,U}MAXP.H", "[a64]") { 1944 A64TestEnv env; 1945 A64::Jit jit{A64::UserConfig{&env}}; 1946 1947 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 1948 code.SMINP(V2.H4(), V0.H4(), V1.H4()); 1949 code.UMINP(V3.H4(), V0.H4(), V1.H4()); 1950 code.SMINP(V4.H8(), V0.H8(), V1.H8()); 1951 code.UMINP(V5.H8(), V0.H8(), V1.H8()); 1952 code.SMAXP(V6.H4(), V0.H4(), V1.H4()); 1953 code.UMAXP(V7.H4(), V0.H4(), V1.H4()); 1954 code.SMAXP(V8.H8(), V0.H8(), V1.H8()); 1955 code.UMAXP(V9.H8(), V0.H8(), V1.H8()); 1956 1957 constexpr std::array<Vector, 12> vectors = { 1958 // initial input vectors [0-1] 1959 Vector{0x0003'0002'7FFF'7FFE, 0xF123'0123'FFFF'0000}, 1960 Vector{0x8000'7FFF'FFFF'FFFE, 0x8765'8764'0123'0124}, 1961 // expected output vectors [2-9] 1962 Vector{0x8000'FFFE'0002'7FFE, 0}, 1963 Vector{0x7FFF'FFFE'0002'7FFE, 0}, 1964 Vector{0xF123'FFFF'0002'7FFE, 0x8764'0123'8000'FFFE}, 1965 Vector{0x0123'0000'0002'7FFE, 0x8764'0123'7FFF'FFFE}, 1966 Vector{0x7FFF'FFFF'0003'7FFF, 0}, 1967 Vector{0x8000'FFFF'0003'7FFF, 0}, 1968 Vector{0x0123'0000'0003'7FFF, 0x8765'0124'7FFF'FFFF}, 1969 Vector{0xF123'FFFF'0003'7FFF, 0x8765'0124'8000'FFFF}, 1970 // input vectors with elements swapped pairwise [10-11] 1971 Vector{0x0002'0003'7FFE'7FFF, 0x0123'F123'0000'FFFF}, 1972 Vector{0x7FFF'8000'FFFE'FFFF, 0x8764'8765'0124'0123}, 1973 }; 1974 1975 jit.SetPC(0); 1976 jit.SetVector(0, vectors[0]); 1977 jit.SetVector(1, vectors[1]); 1978 1979 env.ticks_left = env.code_mem.size(); 1980 jit.Run(); 1981 1982 CHECK(jit.GetVector(2) == vectors[2]); 1983 CHECK(jit.GetVector(3) == vectors[3]); 1984 CHECK(jit.GetVector(4) == vectors[4]); 1985 CHECK(jit.GetVector(5) == vectors[5]); 1986 CHECK(jit.GetVector(6) == vectors[6]); 1987 CHECK(jit.GetVector(7) == vectors[7]); 1988 CHECK(jit.GetVector(8) == vectors[8]); 1989 CHECK(jit.GetVector(9) == vectors[9]); 1990 1991 // run the same tests again but with the input vectors swapped pairwise, 1992 // to ensure we aren't randomly producing the correct values 1993 jit.SetPC(0); 1994 jit.SetVectors(std::array<Vector, 32>{}); 1995 jit.SetVector(0, vectors[10]); 1996 jit.SetVector(1, vectors[11]); 1997 1998 env.ticks_left = env.code_mem.size(); 1999 jit.Run(); 2000 2001 CHECK(jit.GetVector(2) == vectors[2]); 2002 CHECK(jit.GetVector(3) == vectors[3]); 2003 CHECK(jit.GetVector(4) == vectors[4]); 2004 CHECK(jit.GetVector(5) == vectors[5]); 2005 CHECK(jit.GetVector(6) == vectors[6]); 2006 CHECK(jit.GetVector(7) == vectors[7]); 2007 CHECK(jit.GetVector(8) == vectors[8]); 2008 CHECK(jit.GetVector(9) == vectors[9]); 2009 } 2010 2011 TEST_CASE("A64: {S,U}MINP.B, {S,U}MAXP.B", "[a64]") { 2012 A64TestEnv env; 2013 A64::Jit jit{A64::UserConfig{&env}}; 2014 2015 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 2016 code.SMINP(V2.B8(), V0.B8(), V1.B8()); 2017 code.UMINP(V3.B8(), V0.B8(), V1.B8()); 2018 code.SMINP(V4.B16(), V0.B16(), V1.B16()); 2019 code.UMINP(V5.B16(), V0.B16(), V1.B16()); 2020 code.SMAXP(V6.B8(), V0.B8(), V1.B8()); 2021 code.UMAXP(V7.B8(), V0.B8(), V1.B8()); 2022 code.SMAXP(V8.B16(), V0.B16(), V1.B16()); 2023 code.UMAXP(V9.B16(), V0.B16(), V1.B16()); 2024 2025 constexpr std::array<Vector, 12> vectors = { 2026 // initial input vectors [0-1] 2027 Vector{0x02'03'7F'7E'80'7F'FF'FE, 0x40'41'70'71'F0'F1'A0'A1}, 2028 Vector{0xFF'00'81'18'99'9A'12'34, 0xC3'C2'B1'B0'82'7E'81'7F}, 2029 // expected output vectors [2-9] 2030 Vector{0xFF'81'99'12'02'7E'80'FE, 0}, 2031 Vector{0x00'18'99'12'02'7E'7F'FE, 0}, 2032 Vector{0x40'70'F0'A0'02'7E'80'FE, 0xC2'B0'82'81'FF'81'99'12}, 2033 Vector{0x40'70'F0'A0'02'7E'7F'FE, 0xC2'B0'7E'7F'00'18'99'12}, 2034 Vector{0x00'18'9A'34'03'7F'7F'FF, 0}, 2035 Vector{0xFF'81'9A'34'03'7F'80'FF, 0}, 2036 Vector{0x41'71'F1'A1'03'7F'7F'FF, 0xC3'B1'7E'7F'00'18'9A'34}, 2037 Vector{0x41'71'F1'A1'03'7F'80'FF, 0xC3'B1'82'81'FF'81'9A'34}, 2038 // input vectors with elements swapped pairwise [10-11] 2039 Vector{0x03'02'7E'7F'7F'80'FE'FF, 0x41'40'71'70'F1'F0'A1'A0}, 2040 Vector{0x00'FF'18'81'9A'99'34'12, 0xC2'C3'B0'B1'7E'82'7F'81}, 2041 }; 2042 2043 jit.SetPC(0); 2044 jit.SetVector(0, vectors[0]); 2045 jit.SetVector(1, vectors[1]); 2046 2047 env.ticks_left = env.code_mem.size(); 2048 jit.Run(); 2049 2050 CHECK(jit.GetVector(2) == vectors[2]); 2051 CHECK(jit.GetVector(3) == vectors[3]); 2052 2053 CHECK(jit.GetVector(4) == vectors[4]); 2054 CHECK(jit.GetVector(5) == vectors[5]); 2055 2056 CHECK(jit.GetVector(6) == vectors[6]); 2057 CHECK(jit.GetVector(7) == vectors[7]); 2058 2059 CHECK(jit.GetVector(8) == vectors[8]); 2060 CHECK(jit.GetVector(9) == vectors[9]); 2061 2062 // run the same tests again but with the input vectors swapped pairwise, 2063 // to ensure we aren't randomly producing the correct values 2064 jit.SetPC(0); 2065 jit.SetVectors(std::array<Vector, 32>{}); 2066 jit.SetVector(0, vectors[10]); 2067 jit.SetVector(1, vectors[11]); 2068 2069 env.ticks_left = env.code_mem.size(); 2070 jit.Run(); 2071 2072 CHECK(jit.GetVector(2) == vectors[2]); 2073 CHECK(jit.GetVector(3) == vectors[3]); 2074 2075 CHECK(jit.GetVector(4) == vectors[4]); 2076 CHECK(jit.GetVector(5) == vectors[5]); 2077 2078 CHECK(jit.GetVector(6) == vectors[6]); 2079 CHECK(jit.GetVector(7) == vectors[7]); 2080 2081 CHECK(jit.GetVector(8) == vectors[8]); 2082 CHECK(jit.GetVector(9) == vectors[9]); 2083 } 2084 2085 TEST_CASE("A64: SQABS", "[a64]") { 2086 A64TestEnv env; 2087 A64::Jit jit{A64::UserConfig{&env}}; 2088 2089 oaknut::VectorCodeGenerator code{env.code_mem, nullptr}; 2090 // should set QC flag 2091 code.SQABS(V0.B16(), V0.B16()); 2092 code.MRS(X0, oaknut::SystemReg::FPSR); 2093 code.MSR(oaknut::SystemReg::FPSR, XZR); 2094 2095 code.SQABS(V1.H8(), V1.H8()); 2096 code.MRS(X1, oaknut::SystemReg::FPSR); 2097 code.MSR(oaknut::SystemReg::FPSR, XZR); 2098 2099 code.SQABS(V2.S4(), V2.S4()); 2100 code.MRS(X2, oaknut::SystemReg::FPSR); 2101 code.MSR(oaknut::SystemReg::FPSR, XZR); 2102 2103 code.SQABS(V3.D2(), V3.D2()); 2104 code.MRS(X3, oaknut::SystemReg::FPSR); 2105 code.MSR(oaknut::SystemReg::FPSR, XZR); 2106 2107 // should not set QC flag 2108 code.SQABS(V10.B16(), V10.B16()); 2109 code.MRS(X10, oaknut::SystemReg::FPSR); 2110 code.MSR(oaknut::SystemReg::FPSR, XZR); 2111 2112 code.SQABS(V11.H8(), V11.H8()); 2113 code.MRS(X11, oaknut::SystemReg::FPSR); 2114 code.MSR(oaknut::SystemReg::FPSR, XZR); 2115 2116 code.SQABS(V12.S4(), V12.S4()); 2117 code.MRS(X12, oaknut::SystemReg::FPSR); 2118 code.MSR(oaknut::SystemReg::FPSR, XZR); 2119 2120 code.SQABS(V13.D2(), V13.D2()); 2121 code.MRS(X13, oaknut::SystemReg::FPSR); 2122 2123 jit.SetPC(0); 2124 jit.SetFpsr(0); 2125 // contains one value that will be saturated 2126 jit.SetVector(0, Vector{0x2B'7F'EC'D6'77'CE'80'10, 0x9D'EA'82'45'81'CD'42'FC}); 2127 jit.SetVector(1, Vector{0x3D74'9114'8000'B0BE, 0x3F0F'E281'CE50'0616}); 2128 jit.SetVector(2, Vector{0x218630B5'BEC18D71, 0x9042167E'80000000}); 2129 jit.SetVector(3, Vector{0x89C1B48FBC43F53B, 0x8000000000000000}); 2130 // contains no values that will be saturated 2131 jit.SetVector(10, Vector{0x2B'7F'EC'D6'77'CE'00'10, 0x9D'EA'82'45'81'CD'42'FC}); 2132 jit.SetVector(11, Vector{0x3D74'9114'0000'B0BE, 0x3F0F'E281'CE50'0616}); 2133 jit.SetVector(12, Vector{0x218630B5'BEC18D71, 0x9042167E'00000000}); 2134 jit.SetVector(13, Vector{0x89C1B48FBC43F53B, 0x5FDD5D671D399E2}); 2135 2136 env.ticks_left = env.code_mem.size(); 2137 jit.Run(); 2138 2139 CHECK(jit.GetVector(0) == Vector{0x2B'7F'14'2A'77'32'7F'10, 0x63'16'7E'45'7F'33'42'04}); 2140 CHECK(FP::FPSR{(uint32_t)jit.GetRegister(0)}.QC() == 1); 2141 CHECK(jit.GetVector(1) == Vector{0x3D74'6EEC'7FFF'4F42, 0x3F0F'1D7F'31B0'0616}); 2142 CHECK(FP::FPSR{(uint32_t)jit.GetRegister(1)}.QC() == 1); 2143 CHECK(jit.GetVector(2) == Vector{0x218630B5'413E728F, 0x6FBDE982'7FFFFFFF}); 2144 CHECK(FP::FPSR{(uint32_t)jit.GetRegister(2)}.QC() == 1); 2145 CHECK(jit.GetVector(3) == Vector{0x763E4B7043BC0AC5, 0x7FFFFFFFFFFFFFFF}); 2146 CHECK(FP::FPSR{(uint32_t)jit.GetRegister(3)}.QC() == 1); 2147 2148 CHECK(jit.GetVector(10) == Vector{0x2B'7F'14'2A'77'32'00'10, 0x63'16'7E'45'7F'33'42'04}); 2149 CHECK(FP::FPSR{(uint32_t)jit.GetRegister(10)}.QC() == 0); 2150 CHECK(jit.GetVector(11) == Vector{0x3D74'6EEC'0000'4F42, 0x3F0F'1D7F'31B0'0616}); 2151 CHECK(FP::FPSR{(uint32_t)jit.GetRegister(11)}.QC() == 0); 2152 CHECK(jit.GetVector(12) == Vector{0x218630B5'413E728F, 0x6FBDE982'00000000}); 2153 CHECK(FP::FPSR{(uint32_t)jit.GetRegister(12)}.QC() == 0); 2154 CHECK(jit.GetVector(13) == Vector{0x763E4B7043BC0AC5, 0x5FDD5D671D399E2}); 2155 CHECK(FP::FPSR{(uint32_t)jit.GetRegister(13)}.QC() == 0); 2156 }