|
|
@@ -0,0 +1,1024 @@
|
|
|
+#ifdef NDEBUG
|
|
|
+#undef NDEBUG
|
|
|
+#endif
|
|
|
+
|
|
|
+#include <cassert>
|
|
|
+#include <iomanip>
|
|
|
+#include "utility.hpp"
|
|
|
+#include "../bytecode_machine.hpp"
|
|
|
+#include "../dataset.hpp"
|
|
|
+#include "../blake2/endian.h"
|
|
|
+#include "../blake2/blake2.h"
|
|
|
+#include "../blake2_generator.hpp"
|
|
|
+#include "../superscalar.hpp"
|
|
|
+#include "../reciprocal.h"
|
|
|
+#include "../intrin_portable.h"
|
|
|
+#include "../jit_compiler.hpp"
|
|
|
+
|
|
|
+struct CacheKey {
|
|
|
+ void* key;
|
|
|
+ size_t size = 0;
|
|
|
+};
|
|
|
+
|
|
|
+randomx_cache* cache;
|
|
|
+randomx_vm* vm = nullptr;
|
|
|
+CacheKey currentKey;
|
|
|
+
|
|
|
+template<size_t N>
|
|
|
+void initCache(const char (&key)[N]) {
|
|
|
+ assert(cache != nullptr);
|
|
|
+ if (N - 1 == currentKey.size && memcmp(currentKey.key, key, N - 1) == 0)
|
|
|
+ return;
|
|
|
+ //std::cout << "randomx_init_cache with key ";
|
|
|
+ //outputHex(std::cout, key, N - 1);
|
|
|
+ //std::cout << std::endl;
|
|
|
+ randomx_init_cache(cache, key, N - 1);
|
|
|
+ currentKey.key = (void*)key;
|
|
|
+ currentKey.size = N - 1;
|
|
|
+ if (vm != nullptr)
|
|
|
+ randomx_vm_set_cache(vm, cache);
|
|
|
+}
|
|
|
+
|
|
|
+template<size_t K, size_t H>
|
|
|
+void calcStringHash(const char(&key)[K], const char(&input)[H], void* output) {
|
|
|
+ initCache(key);
|
|
|
+ assert(vm != nullptr);
|
|
|
+ randomx_calculate_hash(vm, input, H - 1, output);
|
|
|
+}
|
|
|
+
|
|
|
+template<size_t K, size_t H>
|
|
|
+void calcHexHash(const char(&key)[K], const char(&hex)[H], void* output) {
|
|
|
+ initCache(key);
|
|
|
+ assert(vm != nullptr);
|
|
|
+ char input[H / 2];
|
|
|
+ hex2bin((char*)hex, H - 1, input);
|
|
|
+ randomx_calculate_hash(vm, input, sizeof(input), output);
|
|
|
+}
|
|
|
+
|
|
|
+int testNo = 0;
|
|
|
+int skipped = 0;
|
|
|
+
|
|
|
+template<typename FUNC>
|
|
|
+void runTest(const char* name, bool condition, FUNC f) {
|
|
|
+ std::cout << "[";
|
|
|
+ std::cout.width(2);
|
|
|
+ std::cout << std::right << ++testNo << "] ";
|
|
|
+ std::cout.width(40);
|
|
|
+ std::cout << std::left << name << " ... ";
|
|
|
+ std::cout.flush();
|
|
|
+ if (condition) {
|
|
|
+ f();
|
|
|
+ std::cout << "PASSED" << std::endl;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ std::cout << "SKIPPED" << std::endl;
|
|
|
+ skipped++;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+int main() {
|
|
|
+ char testHash[32];
|
|
|
+
|
|
|
+ //std::cout << "Allocating randomx_cache..." << std::endl;
|
|
|
+ cache = randomx_alloc_cache(RANDOMX_FLAG_DEFAULT);
|
|
|
+
|
|
|
+ runTest("Cache initialization", RANDOMX_ARGON_ITERATIONS == 3 && RANDOMX_ARGON_LANES == 1 && RANDOMX_ARGON_MEMORY == 262144 && stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), []() {
|
|
|
+ initCache("test key 000");
|
|
|
+ uint64_t* cacheMemory = (uint64_t*)cache->memory;
|
|
|
+ assert(cacheMemory[0] == 0x191e0e1d23c02186);
|
|
|
+ assert(cacheMemory[1568413] == 0xf1b62fe6210bf8b1);
|
|
|
+ assert(cacheMemory[33554431] == 0x1f47f056d05cd99b);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("SuperscalarHash generator", RANDOMX_SUPERSCALAR_LATENCY == 170, []() {
|
|
|
+ char sprogHash[32];
|
|
|
+ randomx::SuperscalarProgram sprog;
|
|
|
+ const char key[] = "test key 000";
|
|
|
+ constexpr size_t keySize = sizeof(key) - 1;
|
|
|
+ randomx::Blake2Generator gen(key, keySize);
|
|
|
+
|
|
|
+ const char superscalarReferences[10][65] = {
|
|
|
+ "d3a4a6623738756f77e6104469102f082eff2a3e60be7ad696285ef7dfc72a61",
|
|
|
+ "f5e7e0bbc7e93c609003d6359208688070afb4a77165a552ff7be63b38dfbc86",
|
|
|
+ "85ed8b11734de5b3e9836641413a8f36e99e89694f419c8cd25c3f3f16c40c5a",
|
|
|
+ "5dd956292cf5d5704ad99e362d70098b2777b2a1730520be52f772ca48cd3bc0",
|
|
|
+ "6f14018ca7d519e9b48d91af094c0f2d7e12e93af0228782671a8640092af9e5",
|
|
|
+ "134be097c92e2c45a92f23208cacd89e4ce51f1009a0b900dbe83b38de11d791",
|
|
|
+ "268f9392c20c6e31371a5131f82bd7713d3910075f2f0468baafaa1abd2f3187",
|
|
|
+ "c668a05fd909714ed4a91e8d96d67b17e44329e88bc71e0672b529a3fc16be47",
|
|
|
+ "99739351315840963011e4c5d8e90ad0bfed3facdcb713fe8f7138fbf01c4c94",
|
|
|
+ "14ab53d61880471f66e80183968d97effd5492b406876060e595fcf9682f9295",
|
|
|
+ };
|
|
|
+
|
|
|
+ for (int i = 0; i < 10; ++i) {
|
|
|
+ randomx::generateSuperscalar(sprog, gen);
|
|
|
+ blake2b(sprogHash, sizeof(sprogHash), &sprog.programBuffer, sizeof(randomx::Instruction) * sprog.getSize(), nullptr, 0);
|
|
|
+ assert(equalsHex(sprogHash, superscalarReferences[i]));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("Dataset initialization (interpreter)", stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), []() {
|
|
|
+ initCache("test key 000");
|
|
|
+ uint64_t datasetItem[8];
|
|
|
+ randomx::initDatasetItem(cache, (uint8_t*)&datasetItem, 0);
|
|
|
+ assert(datasetItem[0] == 0x680588a85ae222db);
|
|
|
+ randomx::initDatasetItem(cache, (uint8_t*)&datasetItem, 10000000);
|
|
|
+ assert(datasetItem[0] == 0x7943a1f6186ffb72);
|
|
|
+ randomx::initDatasetItem(cache, (uint8_t*)&datasetItem, 20000000);
|
|
|
+ assert(datasetItem[0] == 0x9035244d718095e1);
|
|
|
+ randomx::initDatasetItem(cache, (uint8_t*)&datasetItem, 30000000);
|
|
|
+ assert(datasetItem[0] == 0x145a5091f7853099);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("Dataset initialization (compiler)", RANDOMX_HAVE_COMPILER && stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), []() {
|
|
|
+ initCache("test key 000");
|
|
|
+ randomx::JitCompiler jit;
|
|
|
+ jit.generateSuperscalarHash(cache->programs, cache->reciprocalCache);
|
|
|
+ jit.generateDatasetInitCode();
|
|
|
+ uint64_t datasetItem[8];
|
|
|
+ jit.getDatasetInitFunc()(cache, (uint8_t*)&datasetItem, 0, 1);
|
|
|
+ assert(datasetItem[0] == 0x680588a85ae222db);
|
|
|
+ jit.getDatasetInitFunc()(cache, (uint8_t*)&datasetItem, 10000000, 10000001);
|
|
|
+ assert(datasetItem[0] == 0x7943a1f6186ffb72);
|
|
|
+ jit.getDatasetInitFunc()(cache, (uint8_t*)&datasetItem, 20000000, 20000001);
|
|
|
+ assert(datasetItem[0] == 0x9035244d718095e1);
|
|
|
+ jit.getDatasetInitFunc()(cache, (uint8_t*)&datasetItem, 30000000, 30000001);
|
|
|
+ assert(datasetItem[0] == 0x145a5091f7853099);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("randomx_reciprocal", true, []() {
|
|
|
+ assert(randomx_reciprocal(3) == 12297829382473034410U);
|
|
|
+ assert(randomx_reciprocal(13) == 11351842506898185609U);
|
|
|
+ assert(randomx_reciprocal(33) == 17887751829051686415U);
|
|
|
+ assert(randomx_reciprocal(65537) == 18446462603027742720U);
|
|
|
+ assert(randomx_reciprocal(15000001) == 10316166306300415204U);
|
|
|
+ assert(randomx_reciprocal(3845182035) == 10302264209224146340U);
|
|
|
+ assert(randomx_reciprocal(0xffffffff) == 9223372039002259456U);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("randomx_reciprocal_fast", RANDOMX_HAVE_FAST_RECIPROCAL, []() {
|
|
|
+ assert(randomx_reciprocal_fast(3) == 12297829382473034410U);
|
|
|
+ assert(randomx_reciprocal_fast(13) == 11351842506898185609U);
|
|
|
+ assert(randomx_reciprocal_fast(33) == 17887751829051686415U);
|
|
|
+ assert(randomx_reciprocal_fast(65537) == 18446462603027742720U);
|
|
|
+ assert(randomx_reciprocal_fast(15000001) == 10316166306300415204U);
|
|
|
+ assert(randomx_reciprocal_fast(3845182035) == 10302264209224146340U);
|
|
|
+ assert(randomx_reciprocal_fast(0xffffffff) == 9223372039002259456U);
|
|
|
+ });
|
|
|
+
|
|
|
+ randomx::NativeRegisterFile reg;
|
|
|
+ randomx::BytecodeMachine decoder;
|
|
|
+ randomx::InstructionByteCode ibc;
|
|
|
+ alignas(16) randomx::ProgramConfiguration config;
|
|
|
+ constexpr int registerHigh = 192;
|
|
|
+ constexpr int registerDst = 0;
|
|
|
+ constexpr int registerSrc = 1;
|
|
|
+ int pc = 0;
|
|
|
+ constexpr uint32_t imm32 = 3234567890;
|
|
|
+ constexpr uint64_t imm64 = signExtend2sCompl(imm32);
|
|
|
+
|
|
|
+ decoder.beginCompilation(reg);
|
|
|
+
|
|
|
+ runTest("IADD_RS (decode)", RANDOMX_FREQ_IADD_RS > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IADD_RS - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.mod = UINT8_MAX;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IADD_RS);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.shift == 3);
|
|
|
+ assert(ibc.imm == 0);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IADD_RS (execute)", RANDOMX_FREQ_IADD_RS > 0, [&] {
|
|
|
+ reg.r[registerDst] = 0x8000000000000000;
|
|
|
+ reg.r[registerSrc] = 0x1000000000000000;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == 0);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IADD_RS with immediate (decode)", RANDOMX_FREQ_IADD_RS > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IADD_RS - 1;
|
|
|
+ instr.mod = 8;
|
|
|
+ instr.dst = registerHigh | randomx::RegisterNeedsDisplacement;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IADD_RS);
|
|
|
+ assert(ibc.idst == ®.r[randomx::RegisterNeedsDisplacement]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.shift == 2);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IADD_RS with immediate (decode)", RANDOMX_FREQ_IADD_RS > 0, [&] {
|
|
|
+ reg.r[randomx::RegisterNeedsDisplacement] = 0x8000000000000000;
|
|
|
+ reg.r[registerSrc] = 0x2000000000000000;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[randomx::RegisterNeedsDisplacement] == imm64);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IADD_M (decode)", RANDOMX_FREQ_IADD_M > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IADD_M - 1;
|
|
|
+ instr.mod = 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IADD_M);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL1Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISUB_R (decode)", RANDOMX_FREQ_ISUB_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_ISUB_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::ISUB_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISUB_R (execute)", RANDOMX_FREQ_ISUB_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 1;
|
|
|
+ reg.r[registerSrc] = 0xFFFFFFFF;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == 0xFFFFFFFF00000002);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISUB_R with immediate (decode)", RANDOMX_FREQ_ISUB_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_ISUB_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::ISUB_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == &ibc.imm);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISUB_R with immediate (decode)", RANDOMX_FREQ_ISUB_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 0;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == (~imm64 + 1));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISUB_M (decode)", RANDOMX_FREQ_ISUB_M > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_ISUB_M - 1;
|
|
|
+ instr.mod = 0;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::ISUB_M);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL2Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMUL_R (decode)", RANDOMX_FREQ_IMUL_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IMUL_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IMUL_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMUL_R (execute)", RANDOMX_FREQ_IMUL_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 0xBC550E96BA88A72B;
|
|
|
+ reg.r[registerSrc] = 0xF5391FA9F18D6273;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == 0x28723424A9108E51);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMUL_R with immediate (decode)", RANDOMX_FREQ_IMUL_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IMUL_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IMUL_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == &ibc.imm);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMUL_R with immediate (execute)", RANDOMX_FREQ_IMUL_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 1;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == imm64);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMUL_M (decode)", RANDOMX_FREQ_IMUL_M > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IMUL_M - 1;
|
|
|
+ instr.mod = 0;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IMUL_M);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(*ibc.isrc == 0);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL3Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMULH_R (decode)", RANDOMX_FREQ_IMULH_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IMULH_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IMULH_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMULH_R (execute)", RANDOMX_FREQ_IMULH_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 0xBC550E96BA88A72B;
|
|
|
+ reg.r[registerSrc] = 0xF5391FA9F18D6273;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == 0xB4676D31D2B34883);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMULH_R squared (decode)", RANDOMX_FREQ_IMULH_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IMULH_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IMULH_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerDst]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMULH_M (decode)", RANDOMX_FREQ_IMULH_M > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IMULH_M - 1;
|
|
|
+ instr.mod = 0;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IMULH_M);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL2Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISMULH_R (decode)", RANDOMX_FREQ_ISMULH_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_ISMULH_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::ISMULH_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISMULH_R (execute)", RANDOMX_FREQ_ISMULH_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 0xBC550E96BA88A72B;
|
|
|
+ reg.r[registerSrc] = 0xF5391FA9F18D6273;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == 0x02D93EF1269D3EE5);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISMULH_R squared (decode)", RANDOMX_FREQ_ISMULH_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_ISMULH_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::ISMULH_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerDst]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISMULH_M (decode)", RANDOMX_FREQ_ISMULH_M > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_ISMULH_M - 1;
|
|
|
+ instr.mod = 3;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::ISMULH_M);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL1Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMUL_RCP (decode)", RANDOMX_FREQ_IMUL_RCP > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IMUL_RCP - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IMUL_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == &ibc.imm);
|
|
|
+ assert(ibc.imm == randomx_reciprocal(imm32));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IMUL_RCP zero imm32 (decode)", RANDOMX_FREQ_IMUL_RCP > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IMUL_RCP - 1;
|
|
|
+ instr.setImm32(0);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::NOP);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("INEG_R (decode)", RANDOMX_FREQ_INEG_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_INEG_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::INEG_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("INEG_R (execute)", RANDOMX_FREQ_INEG_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 0xFFFFFFFFFFFFFFFF;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == 1);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IXOR_R (decode)", RANDOMX_FREQ_IXOR_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IXOR_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IXOR_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IXOR_R (execute)", RANDOMX_FREQ_IMUL_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 0x8888888888888888;
|
|
|
+ reg.r[registerSrc] = 0xAAAAAAAAAAAAAAAA;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == 0x2222222222222222);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IXOR_R with immediate (decode)", RANDOMX_FREQ_IXOR_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IXOR_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IXOR_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == &ibc.imm);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IXOR_R with immediate (execute)", RANDOMX_FREQ_IXOR_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 0xFFFFFFFFFFFFFFFF;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == ~imm64);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IXOR_M (decode)", RANDOMX_FREQ_IXOR_M > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IXOR_M - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IXOR_M);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(*ibc.isrc == 0);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL3Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IROR_R (decode)", RANDOMX_FREQ_IROR_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IROR_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IROR_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IROR_R (execute)", RANDOMX_FREQ_IROR_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 953360005391419562;
|
|
|
+ reg.r[registerSrc] = 4569451684712230561;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == 0xD835C455069D81EF);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IROL_R (decode)", RANDOMX_FREQ_IROL_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_IROL_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::IROL_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("IROL_R (execute)", RANDOMX_FREQ_IROL_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 953360005391419562;
|
|
|
+ reg.r[registerSrc] = 4569451684712230561;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == 6978065200552740799);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISWAP_R (decode)", RANDOMX_FREQ_ISWAP_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_ISWAP_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::ISWAP_R);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISWAP_R (execute)", RANDOMX_FREQ_ISWAP_R > 0, [&] {
|
|
|
+ reg.r[registerDst] = 953360005391419562;
|
|
|
+ reg.r[registerSrc] = 4569451684712230561;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(reg.r[registerDst] == 4569451684712230561);
|
|
|
+ assert(reg.r[registerSrc] == 953360005391419562);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FSWAP_R (decode)", RANDOMX_FREQ_FSWAP_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_FSWAP_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::FSWAP_R);
|
|
|
+ assert(ibc.fdst == ®.f[registerDst]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FSWAP_R (execute)", RANDOMX_FREQ_FSWAP_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.f[registerDst] = rx_set_vec_f128(953360005391419562, 4569451684712230561);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.f[registerDst]);
|
|
|
+ assert(equalsHex((const char*)&vec, "aa886bb0df033b0da12e95e518f4693f"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FADD_R (decode)", RANDOMX_FREQ_FADD_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_FADD_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::FADD_R);
|
|
|
+ assert(ibc.fdst == ®.f[registerDst]);
|
|
|
+ assert(ibc.fsrc == ®.a[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FADD_R RoundToNearest (execute)", RANDOMX_FREQ_FADD_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.f[registerDst] = rx_set_vec_f128(0x3ffd2c97cc4ef015, 0xc1ce30b3c4223576);
|
|
|
+ reg.a[registerSrc] = rx_set_vec_f128(0x402a26a86a60c8fb, 0x40b8f684057a59e1);
|
|
|
+ rx_set_rounding_mode(RoundToNearest);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.f[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "b932e048a730cec1fea6ea633bcc2d40"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FADD_R RoundDown (execute)", RANDOMX_FREQ_FADD_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.f[registerDst] = rx_set_vec_f128(0x3ffd2c97cc4ef015, 0xc1ce30b3c4223576);
|
|
|
+ reg.a[registerSrc] = rx_set_vec_f128(0x402a26a86a60c8fb, 0x40b8f684057a59e1);
|
|
|
+ rx_set_rounding_mode(RoundDown);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.f[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "b932e048a730cec1fda6ea633bcc2d40"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FADD_R RoundUp (execute)", RANDOMX_FREQ_FADD_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.f[registerDst] = rx_set_vec_f128(0x3ffd2c97cc4ef015, 0xc1ce30b3c4223576);
|
|
|
+ reg.a[registerSrc] = rx_set_vec_f128(0x402a26a86a60c8fb, 0x40b8f684057a59e1);
|
|
|
+ rx_set_rounding_mode(RoundUp);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.f[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "b832e048a730cec1fea6ea633bcc2d40"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FADD_R RoundToZero (execute)", RANDOMX_FREQ_FADD_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.f[registerDst] = rx_set_vec_f128(0x3ffd2c97cc4ef015, 0xc1ce30b3c4223576);
|
|
|
+ reg.a[registerSrc] = rx_set_vec_f128(0x402a26a86a60c8fb, 0x40b8f684057a59e1);
|
|
|
+ rx_set_rounding_mode(RoundToZero);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.f[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "b832e048a730cec1fda6ea633bcc2d40"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FADD_M (decode)", RANDOMX_FREQ_FADD_M > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_FADD_M - 1;
|
|
|
+ instr.mod = 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::FADD_M);
|
|
|
+ assert(ibc.fdst == ®.f[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL1Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FADD_M (execute)", RANDOMX_FREQ_FADD_R > 0, [&] {
|
|
|
+ uint64_t mockScratchpad;
|
|
|
+ store64(&mockScratchpad, 0x1234567890abcdef);
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.f[registerDst] = rx_set_vec_f128(0, 0);
|
|
|
+ reg.r[registerSrc] = 0xFFFFFFFFFFFFE930;
|
|
|
+ rx_set_rounding_mode(RoundToNearest);
|
|
|
+ decoder.executeInstruction(ibc, pc, (uint8_t*)&mockScratchpad, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.f[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "000040840cd5dbc1000000785634b241"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FSUB_R (decode)", RANDOMX_FREQ_FSUB_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_FSUB_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::FSUB_R);
|
|
|
+ assert(ibc.fdst == ®.f[registerDst]);
|
|
|
+ assert(ibc.fsrc == ®.a[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FSUB_M (decode)", RANDOMX_FREQ_FSUB_M > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_FSUB_M - 1;
|
|
|
+ instr.mod = 2;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::FSUB_M);
|
|
|
+ assert(ibc.fdst == ®.f[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL1Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FSCAL_R (decode)", RANDOMX_FREQ_FSCAL_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_FSCAL_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::FSCAL_R);
|
|
|
+ assert(ibc.fdst == ®.f[registerDst]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FSCAL_R (execute)", RANDOMX_FREQ_FSCAL_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.f[registerDst] = rx_set_vec_f128(0x41dbc35cef248783, 0x40fdfdabb6173d07);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.f[registerDst]);
|
|
|
+ assert(equalsHex((const char*)&vec, "073d17b6abfd0dc0838724ef5cc32bc1"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FMUL_R (decode)", RANDOMX_FREQ_FMUL_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_FMUL_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::FMUL_R);
|
|
|
+ assert(ibc.fdst == ®.e[registerDst]);
|
|
|
+ assert(ibc.fsrc == ®.a[registerSrc]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FMUL_R RoundToNearest (execute)", RANDOMX_FREQ_FMUL_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.e[registerDst] = rx_set_vec_f128(0x41dbc35cef248783, 0x40fdfdabb6173d07);
|
|
|
+ reg.a[registerSrc] = rx_set_vec_f128(0x40eba861aa31c7c0, 0x41c4561212ae2d50);
|
|
|
+ rx_set_rounding_mode(RoundToNearest);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.e[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "69697aff350fd3422f1589cdecfed742"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FMUL_R RoundDown/RoundToZero (execute)", RANDOMX_FREQ_FMUL_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.e[registerDst] = rx_set_vec_f128(0x41dbc35cef248783, 0x40fdfdabb6173d07);
|
|
|
+ reg.a[registerSrc] = rx_set_vec_f128(0x40eba861aa31c7c0, 0x41c4561212ae2d50);
|
|
|
+ rx_set_rounding_mode(RoundDown);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.e[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "69697aff350fd3422e1589cdecfed742"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FMUL_R RoundUp (execute)", RANDOMX_FREQ_FMUL_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.e[registerDst] = rx_set_vec_f128(0x41dbc35cef248783, 0x40fdfdabb6173d07);
|
|
|
+ reg.a[registerSrc] = rx_set_vec_f128(0x40eba861aa31c7c0, 0x41c4561212ae2d50);
|
|
|
+ rx_set_rounding_mode(RoundUp);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.e[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "6a697aff350fd3422f1589cdecfed742"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FDIV_M (decode)", RANDOMX_FREQ_FDIV_M > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_FDIV_M - 1;
|
|
|
+ instr.mod = 3;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::FDIV_M);
|
|
|
+ assert(ibc.fdst == ®.e[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL1Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FDIV_M RoundToNearest (execute)", RANDOMX_FREQ_FDIV_M > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ alignas(16) uint32_t mockScratchpad[2];
|
|
|
+ store32(&mockScratchpad[0], 0xd350a1b6);
|
|
|
+ store32(&mockScratchpad[1], 0x8b2460d9);
|
|
|
+ store64(&config.eMask[0], 0x3a0000000005d11a);
|
|
|
+ store64(&config.eMask[1], 0x39000000001ba31e);
|
|
|
+ reg.e[registerDst] = rx_set_vec_f128(0x41937f76fede16ee, 0x411b414296ce93b6);
|
|
|
+ reg.r[registerSrc] = 0xFFFFFFFFFFFFE930;
|
|
|
+ rx_set_rounding_mode(RoundToNearest);
|
|
|
+ decoder.executeInstruction(ibc, pc, (uint8_t*)&mockScratchpad, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.e[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "e7b269639484434632474a66635ba547"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FDIV_M RoundDown/RoundToZero (execute)", RANDOMX_FREQ_FDIV_M > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ alignas(16) uint32_t mockScratchpad[2];
|
|
|
+ store32(&mockScratchpad[0], 0xd350a1b6);
|
|
|
+ store32(&mockScratchpad[1], 0x8b2460d9);
|
|
|
+ store64(&config.eMask[0], 0x3a0000000005d11a);
|
|
|
+ store64(&config.eMask[1], 0x39000000001ba31e);
|
|
|
+ reg.e[registerDst] = rx_set_vec_f128(0x41937f76fede16ee, 0x411b414296ce93b6);
|
|
|
+ reg.r[registerSrc] = 0xFFFFFFFFFFFFE930;
|
|
|
+ rx_set_rounding_mode(RoundDown);
|
|
|
+ decoder.executeInstruction(ibc, pc, (uint8_t*)&mockScratchpad, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.e[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "e6b269639484434632474a66635ba547"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FDIV_M RoundUp (execute)", RANDOMX_FREQ_FDIV_M > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ alignas(16) uint32_t mockScratchpad[2];
|
|
|
+ store32(&mockScratchpad[0], 0xd350a1b6);
|
|
|
+ store32(&mockScratchpad[1], 0x8b2460d9);
|
|
|
+ store64(&config.eMask[0], 0x3a0000000005d11a);
|
|
|
+ store64(&config.eMask[1], 0x39000000001ba31e);
|
|
|
+ reg.e[registerDst] = rx_set_vec_f128(0x41937f76fede16ee, 0x411b414296ce93b6);
|
|
|
+ reg.r[registerSrc] = 0xFFFFFFFFFFFFE930;
|
|
|
+ rx_set_rounding_mode(RoundUp);
|
|
|
+ decoder.executeInstruction(ibc, pc, (uint8_t*)&mockScratchpad, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.e[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "e7b269639484434633474a66635ba547"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FSQRT_R (decode)", RANDOMX_FREQ_FSQRT_R > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_FSQRT_R - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::FSQRT_R);
|
|
|
+ assert(ibc.fdst == ®.e[registerDst]);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FSQRT_R RoundToNearest (execute)", RANDOMX_FREQ_FSQRT_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.e[registerDst] = rx_set_vec_f128(0x41b6b21c11affea7, 0x40526a7e778d9824);
|
|
|
+ rx_set_rounding_mode(RoundToNearest);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.e[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "e81f300b612a21408dbaa33f570ed340"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FSQRT_R RoundDown/RoundToZero (execute)", RANDOMX_FREQ_FSQRT_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.e[registerDst] = rx_set_vec_f128(0x41b6b21c11affea7, 0x40526a7e778d9824);
|
|
|
+ rx_set_rounding_mode(RoundDown);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.e[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "e81f300b612a21408cbaa33f570ed340"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("FSQRT_R RoundUp (execute)", RANDOMX_FREQ_FSQRT_R > 0, [&] {
|
|
|
+ alignas(16) uint64_t vec[2];
|
|
|
+ reg.e[registerDst] = rx_set_vec_f128(0x41b6b21c11affea7, 0x40526a7e778d9824);
|
|
|
+ rx_set_rounding_mode(RoundUp);
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ rx_store_vec_f128((double*)&vec, reg.e[registerDst]);
|
|
|
+ assert(equalsHex(&vec, "e91f300b612a21408dbaa33f570ed340"));
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("CBRANCH (decode) 100", RANDOMX_FREQ_CBRANCH > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_CBRANCH - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ instr.mod = 48;
|
|
|
+ decoder.compileInstruction(instr, 100, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::CBRANCH);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.imm == 0xFFFFFFFFC0CB9AD2);
|
|
|
+ assert(ibc.memMask == 0x7F800);
|
|
|
+ assert(ibc.target == pc);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("CBRANCH (decode) 200", RANDOMX_FREQ_CBRANCH > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_CBRANCH - 1;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ instr.mod = 48;
|
|
|
+ decoder.compileInstruction(instr, pc = 200, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::CBRANCH);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.imm == 0xFFFFFFFFC0CB9AD2);
|
|
|
+ assert(ibc.memMask == 0x7F800);
|
|
|
+ assert(ibc.target == 100);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("CBRANCH not taken (execute)", RANDOMX_FREQ_CBRANCH > 0, [&] {
|
|
|
+ reg.r[registerDst] = 0;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(pc == 200);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("CBRANCH taken (execute)", RANDOMX_FREQ_CBRANCH > 0, [&] {
|
|
|
+ reg.r[registerDst] = 0xFFFFFFFFFFFC6800;
|
|
|
+ decoder.executeInstruction(ibc, pc, nullptr, config);
|
|
|
+ assert(pc == ibc.target);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("CFROUND (decode)", RANDOMX_FREQ_CFROUND > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_CFROUND - 1;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ decoder.compileInstruction(instr, 100, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::CFROUND);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == 18);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISTORE L1 (decode)", RANDOMX_FREQ_ISTORE > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_ISTORE - 1;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ instr.mod = 1;
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::ISTORE);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL1Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISTORE L2 (decode)", RANDOMX_FREQ_ISTORE > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_ISTORE - 1;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ instr.mod = 0;
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::ISTORE);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL2Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ runTest("ISTORE L3 (decode)", RANDOMX_FREQ_ISTORE > 0, [&] {
|
|
|
+ randomx::Instruction instr;
|
|
|
+ instr.opcode = randomx::ceil_ISTORE - 1;
|
|
|
+ instr.src = registerHigh | registerSrc;
|
|
|
+ instr.dst = registerHigh | registerDst;
|
|
|
+ instr.setImm32(imm32);
|
|
|
+ instr.mod = 224;
|
|
|
+ decoder.compileInstruction(instr, pc, ibc);
|
|
|
+ assert(ibc.type == randomx::InstructionType::ISTORE);
|
|
|
+ assert(ibc.idst == ®.r[registerDst]);
|
|
|
+ assert(ibc.isrc == ®.r[registerSrc]);
|
|
|
+ assert(ibc.imm == imm64);
|
|
|
+ assert(ibc.memMask == randomx::ScratchpadL3Mask);
|
|
|
+ });
|
|
|
+
|
|
|
+ vm = randomx_create_vm(RANDOMX_FLAG_DEFAULT, cache, nullptr);
|
|
|
+
|
|
|
+ auto test_a = [&] {
|
|
|
+ char hash[RANDOMX_HASH_SIZE];
|
|
|
+ calcStringHash("test key 000", "This is a test", &hash);
|
|
|
+ assert(equalsHex(hash, "207d7cedf2a16590bd33d758e413ad129ce9888e05417984f46296252a7ba3d0"));
|
|
|
+ };
|
|
|
+
|
|
|
+ auto test_b = [&] {
|
|
|
+ char hash[RANDOMX_HASH_SIZE];
|
|
|
+ calcStringHash("test key 000", "Lorem ipsum dolor sit amet", &hash);
|
|
|
+ assert(equalsHex(hash, "76dd2da840d56d38153e0beaca33e7f862c5ead91a052380d99f3a62bf84579b"));
|
|
|
+ };
|
|
|
+
|
|
|
+ auto test_c = [&] {
|
|
|
+ char hash[RANDOMX_HASH_SIZE];
|
|
|
+ calcStringHash("test key 000", "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua", &hash);
|
|
|
+ assert(equalsHex(hash, "109f6a405efe09d302336dce4389127e33aa62d4c782aca7797a628e87839a61"));
|
|
|
+ };
|
|
|
+
|
|
|
+ auto test_d = [&] {
|
|
|
+ char hash[RANDOMX_HASH_SIZE];
|
|
|
+ calcStringHash("test key 001", "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua", &hash);
|
|
|
+ assert(equalsHex(hash, "3cbb82edf9541ab80233cdc47384cea719c8567a8bbaca8f3ff038488ce9c16c"));
|
|
|
+ };
|
|
|
+
|
|
|
+ auto test_e = [&] {
|
|
|
+ char hash[RANDOMX_HASH_SIZE];
|
|
|
+ calcHexHash("test key 001", "0b0b98bea7e805e0010a2126d287a2a0cc833d312cb786385a7c2f9de69d25537f584a9bc9977b00000000666fd8753bf61a8631f12984e3fd44f4014eca629276817b56f32e9b68bd82f416", &hash);
|
|
|
+
|
|
|
+ //outputHex(std::cout, (const char*)hash, sizeof(hash));
|
|
|
+ //std::cout << std::endl;
|
|
|
+
|
|
|
+ assert(equalsHex(hash, "e003ef128b1f96d99d4a0490e03253ef11186002a8ec018cbd4e07b8ec8c82e8"));
|
|
|
+ };
|
|
|
+
|
|
|
+ runTest("Hash test 1a (interpreter)", stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), test_a);
|
|
|
+
|
|
|
+ runTest("Hash test 1b (interpreter)", stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), test_b);
|
|
|
+
|
|
|
+ runTest("Hash test 1c (interpreter)", stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), test_c);
|
|
|
+
|
|
|
+ runTest("Hash test 1d (interpreter)", stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), test_d);
|
|
|
+
|
|
|
+ runTest("Hash test 1e (interpreter)", stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), test_e);
|
|
|
+
|
|
|
+ randomx_release_cache(cache);
|
|
|
+ cache = randomx_alloc_cache(RANDOMX_FLAG_JIT);
|
|
|
+ currentKey.size = 0;
|
|
|
+ randomx_destroy_vm(vm);
|
|
|
+ vm = randomx_create_vm(RANDOMX_FLAG_JIT, cache, nullptr);
|
|
|
+
|
|
|
+ runTest("Hash test 2a (compiler)", RANDOMX_HAVE_COMPILER && stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), test_a);
|
|
|
+
|
|
|
+ runTest("Hash test 2b (compiler)", RANDOMX_HAVE_COMPILER && stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), test_b);
|
|
|
+
|
|
|
+ runTest("Hash test 2c (compiler)", RANDOMX_HAVE_COMPILER && stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), test_c);
|
|
|
+
|
|
|
+ runTest("Hash test 2d (compiler)", RANDOMX_HAVE_COMPILER && stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), test_d);
|
|
|
+
|
|
|
+ runTest("Hash test 2e (compiler)", RANDOMX_HAVE_COMPILER && stringsEqual(RANDOMX_ARGON_SALT, "RandomX\x03"), test_e);
|
|
|
+
|
|
|
+ std::cout << std::endl << "All tests PASSED" << std::endl;
|
|
|
+
|
|
|
+ if (skipped) {
|
|
|
+ std::cout << skipped << " tests were SKIPPED due to incompatible configuration (see above)" << std::endl;
|
|
|
+ }
|
|
|
+}
|
tevador