Plexi09/eden-miror
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden synced 2026-05-31 23:07:06 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

[dynarmic] nuke mcl dependency (#3777)
Some checks are pending
tx-src / sources (push) Waiting to run
Details
Check Strings / check-strings (push) Waiting to run
Details

Browse source 
crueter will love this one

mcl nuked off externals, i did however copy some important headers (notably intrusive list and bit.hpp); because grand part of dynarmic still uses them
but i made the appropriate adjustments anyways

solves mcl for #3373

depends on #3718

Signed-off-by: lizzie <lizzie@eden-emu.dev>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3777
Reviewed-by: Maufeat <sahyno1996@gmail.com>
Reviewed-by: MaranBr <maranbr@eden-emu.dev>
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>
Co-authored-by: lizzie <lizzie@eden-emu.dev>
Co-committed-by: lizzie <lizzie@eden-emu.dev>
This commit is contained in:
lizzie 2026-03-27 01:11:49 +01:00 • committed by crueter
parent 813a35abca
commit 47c6a73971
No known key found for this signature in database
GPG key ID: 425ACD2D4830EBC6
120 changed files with 1284 additions and 539 deletions
Download patch file Download diff file Expand all files Collapse all files

116
src/dynarmic/tests/A32/fuzz_arm.cpp
View file

@ -15,9 +15,7 @@
#include <vector>
#include <catch2/catch_test_macros.hpp>
#include <mcl/bit/bit_count.hpp>
#include <mcl/bit/swap.hpp>
#include <mcl/scope_exit.hpp>
#include "dynarmic/mcl/bit.hpp"
#include "dynarmic/common/common_types.h"
#include "dynarmic/tests/fuzz_util.h"
@ -356,67 +354,67 @@ static void RunTestInstance(Dynarmic::A32::Jit& jit,
uni_env.ticks_left = instructions.size(); // Unicorn counts thumb instructions weirdly.
uni.Run();
SCOPE_FAIL {
fmt::print("Instruction Listing:\n");
fmt::print("{}\n", Common::DisassembleAArch32(std::is_same_v<TestEnv, ThumbTestEnv>, initial_pc, (const u8*)instructions.data(), instructions.size() * sizeof(instructions[0])));
// SCOPE_FAIL {
// fmt::print("Instruction Listing:\n");
// fmt::print("{}\n", Common::DisassembleAArch32(std::is_same_v<TestEnv, ThumbTestEnv>, initial_pc, (const u8*)instructions.data(), instructions.size() * sizeof(instructions[0])));
fmt::print("Initial register listing:\n");
for (size_t i = 0; i < regs.size(); ++i) {
fmt::print("{:3s}: {:08x}\n", static_cast<A32::Reg>(i), regs[i]);
}
for (size_t i = 0; i < vecs.size(); ++i) {
fmt::print("{:3s}: {:08x}\n", static_cast<A32::ExtReg>(i), vecs[i]);
}
fmt::print("cpsr {:08x}\n", cpsr);
fmt::print("fpcr {:08x}\n", fpscr);
fmt::print("fpcr.AHP {}\n", FP::FPCR{fpscr}.AHP());
fmt::print("fpcr.DN {}\n", FP::FPCR{fpscr}.DN());
fmt::print("fpcr.FZ {}\n", FP::FPCR{fpscr}.FZ());
fmt::print("fpcr.RMode {}\n", static_cast<size_t>(FP::FPCR{fpscr}.RMode()));
fmt::print("fpcr.FZ16 {}\n", FP::FPCR{fpscr}.FZ16());
fmt::print("\n");
// fmt::print("Initial register listing:\n");
// for (size_t i = 0; i < regs.size(); ++i) {
// fmt::print("{:3s}: {:08x}\n", static_cast<A32::Reg>(i), regs[i]);
// }
// for (size_t i = 0; i < vecs.size(); ++i) {
// fmt::print("{:3s}: {:08x}\n", static_cast<A32::ExtReg>(i), vecs[i]);
// }
// fmt::print("cpsr {:08x}\n", cpsr);
// fmt::print("fpcr {:08x}\n", fpscr);
// fmt::print("fpcr.AHP {}\n", FP::FPCR{fpscr}.AHP());
// fmt::print("fpcr.DN {}\n", FP::FPCR{fpscr}.DN());
// fmt::print("fpcr.FZ {}\n", FP::FPCR{fpscr}.FZ());
// fmt::print("fpcr.RMode {}\n", static_cast<size_t>(FP::FPCR{fpscr}.RMode()));
// fmt::print("fpcr.FZ16 {}\n", FP::FPCR{fpscr}.FZ16());
// fmt::print("\n");
fmt::print("Final register listing:\n");
fmt::print(" unicorn dynarmic\n");
const auto uni_regs = uni.GetRegisters();
for (size_t i = 0; i < regs.size(); ++i) {
fmt::print("{:3s}: {:08x} {:08x} {}\n", static_cast<A32::Reg>(i), uni_regs[i], jit.Regs()[i], uni_regs[i] != jit.Regs()[i] ? "*" : "");
}
const auto uni_ext_regs = uni.GetExtRegs();
for (size_t i = 0; i < vecs.size(); ++i) {
fmt::print("s{:2d}: {:08x} {:08x} {}\n", static_cast<size_t>(i), uni_ext_regs[i], jit.ExtRegs()[i], uni_ext_regs[i] != jit.ExtRegs()[i] ? "*" : "");
}
fmt::print("cpsr {:08x} {:08x} {}\n", uni.GetCpsr(), jit.Cpsr(), uni.GetCpsr() != jit.Cpsr() ? "*" : "");
fmt::print("fpsr {:08x} {:08x} {}\n", uni.GetFpscr(), jit.Fpscr(), (uni.GetFpscr() & 0xF0000000) != (jit.Fpscr() & 0xF0000000) ? "*" : "");
fmt::print("\n");
// fmt::print("Final register listing:\n");
// fmt::print(" unicorn dynarmic\n");
// const auto uni_regs = uni.GetRegisters();
// for (size_t i = 0; i < regs.size(); ++i) {
// fmt::print("{:3s}: {:08x} {:08x} {}\n", static_cast<A32::Reg>(i), uni_regs[i], jit.Regs()[i], uni_regs[i] != jit.Regs()[i] ? "*" : "");
// }
// const auto uni_ext_regs = uni.GetExtRegs();
// for (size_t i = 0; i < vecs.size(); ++i) {
// fmt::print("s{:2d}: {:08x} {:08x} {}\n", static_cast<size_t>(i), uni_ext_regs[i], jit.ExtRegs()[i], uni_ext_regs[i] != jit.ExtRegs()[i] ? "*" : "");
// }
// fmt::print("cpsr {:08x} {:08x} {}\n", uni.GetCpsr(), jit.Cpsr(), uni.GetCpsr() != jit.Cpsr() ? "*" : "");
// fmt::print("fpsr {:08x} {:08x} {}\n", uni.GetFpscr(), jit.Fpscr(), (uni.GetFpscr() & 0xF0000000) != (jit.Fpscr() & 0xF0000000) ? "*" : "");
// fmt::print("\n");
fmt::print("Modified memory:\n");
fmt::print(" uni dyn\n");
auto uni_iter = uni_env.modified_memory.begin();
auto jit_iter = jit_env.modified_memory.begin();
while (uni_iter != uni_env.modified_memory.end() || jit_iter != jit_env.modified_memory.end()) {
if (uni_iter == uni_env.modified_memory.end() || (jit_iter != jit_env.modified_memory.end() && uni_iter->first > jit_iter->first)) {
fmt::print("{:08x}: {:02x} *\n", jit_iter->first, jit_iter->second);
jit_iter++;
} else if (jit_iter == jit_env.modified_memory.end() || jit_iter->first > uni_iter->first) {
fmt::print("{:08x}: {:02x} *\n", uni_iter->first, uni_iter->second);
uni_iter++;
} else if (uni_iter->first == jit_iter->first) {
fmt::print("{:08x}: {:02x} {:02x} {}\n", uni_iter->first, uni_iter->second, jit_iter->second, uni_iter->second != jit_iter->second ? "*" : "");
uni_iter++;
jit_iter++;
}
}
fmt::print("\n");
// fmt::print("Modified memory:\n");
// fmt::print(" uni dyn\n");
// auto uni_iter = uni_env.modified_memory.begin();
// auto jit_iter = jit_env.modified_memory.begin();
// while (uni_iter != uni_env.modified_memory.end() || jit_iter != jit_env.modified_memory.end()) {
// if (uni_iter == uni_env.modified_memory.end() || (jit_iter != jit_env.modified_memory.end() && uni_iter->first > jit_iter->first)) {
// fmt::print("{:08x}: {:02x} *\n", jit_iter->first, jit_iter->second);
// jit_iter++;
// } else if (jit_iter == jit_env.modified_memory.end() || jit_iter->first > uni_iter->first) {
// fmt::print("{:08x}: {:02x} *\n", uni_iter->first, uni_iter->second);
// uni_iter++;
// } else if (uni_iter->first == jit_iter->first) {
// fmt::print("{:08x}: {:02x} {:02x} {}\n", uni_iter->first, uni_iter->second, jit_iter->second, uni_iter->second != jit_iter->second ? "*" : "");
// uni_iter++;
// jit_iter++;
// }
// }
// fmt::print("\n");
fmt::print("x86_64:\n");
fmt::print("{}", jit.Disassemble());
// fmt::print("x86_64:\n");
// fmt::print("{}", jit.Disassemble());
fmt::print("Interrupts:\n");
for (const auto& i : uni_env.interrupts) {
std::puts(i.c_str());
}
};
// fmt::print("Interrupts:\n");
// for (const auto& i : uni_env.interrupts) {
// std::puts(i.c_str());
// }
// };
REQUIRE(uni_env.code_mem_modified_by_guest == jit_env.code_mem_modified_by_guest);
if (uni_env.code_mem_modified_by_guest) {

2
src/dynarmic/tests/A32/fuzz_thumb.cpp
View file

@ -16,7 +16,7 @@
#include <tuple>
#include <catch2/catch_test_macros.hpp>
#include <mcl/bit/bit_field.hpp>
#include "dynarmic/mcl/bit.hpp"
#include "dynarmic/common/common_types.h"
#include "dynarmic/tests/rand_int.h"

145
src/dynarmic/tests/A64/fuzz_with_unicorn.cpp
View file

@ -12,7 +12,6 @@
#include <vector>
#include <catch2/catch_test_macros.hpp>
#include <mcl/scope_exit.hpp>
#include "dynarmic/common/common_types.h"
#include "dynarmic/tests/fuzz_util.h"
@ -205,82 +204,82 @@ static void RunTestInstance(Dynarmic::A64::Jit& jit, A64Unicorn& uni, A64TestEnv
uni_env.ticks_left = instructions.size() * 4;
uni.Run();
SCOPE_FAIL {
fmt::print("Instruction Listing:\n");
for (u32 instruction : instructions) {
fmt::print("{:08x} {}\n", instruction, Common::DisassembleAArch64(instruction));
}
fmt::print("\n");
// SCOPE_FAIL {
// fmt::print("Instruction Listing:\n");
// for (u32 instruction : instructions) {
// fmt::print("{:08x} {}\n", instruction, Common::DisassembleAArch64(instruction));
// }
// fmt::print("\n");
fmt::print("Initial register listing:\n");
for (size_t i = 0; i < regs.size(); ++i) {
fmt::print("{:3s}: {:016x}\n", A64::RegToString(static_cast<A64::Reg>(i)), regs[i]);
}
for (size_t i = 0; i < vecs.size(); ++i) {
fmt::print("{:3s}: {:016x}{:016x}\n", A64::VecToString(static_cast<A64::Vec>(i)), vecs[i][1], vecs[i][0]);
}
fmt::print("sp : {:016x}\n", initial_sp);
fmt::print("pc : {:016x}\n", instructions_start);
fmt::print("p : {:08x}\n", pstate);
fmt::print("fpcr {:08x}\n", fpcr);
fmt::print("fpcr.AHP {}\n", FP::FPCR{fpcr}.AHP());
fmt::print("fpcr.DN {}\n", FP::FPCR{fpcr}.DN());
fmt::print("fpcr.FZ {}\n", FP::FPCR{fpcr}.FZ());
fmt::print("fpcr.RMode {}\n", static_cast<size_t>(FP::FPCR{fpcr}.RMode()));
fmt::print("fpcr.FZ16 {}\n", FP::FPCR{fpcr}.FZ16());
fmt::print("\n");
// fmt::print("Initial register listing:\n");
// for (size_t i = 0; i < regs.size(); ++i) {
// fmt::print("{:3s}: {:016x}\n", A64::RegToString(static_cast<A64::Reg>(i)), regs[i]);
// }
// for (size_t i = 0; i < vecs.size(); ++i) {
// fmt::print("{:3s}: {:016x}{:016x}\n", A64::VecToString(static_cast<A64::Vec>(i)), vecs[i][1], vecs[i][0]);
// }
// fmt::print("sp : {:016x}\n", initial_sp);
// fmt::print("pc : {:016x}\n", instructions_start);
// fmt::print("p : {:08x}\n", pstate);
// fmt::print("fpcr {:08x}\n", fpcr);
// fmt::print("fpcr.AHP {}\n", FP::FPCR{fpcr}.AHP());
// fmt::print("fpcr.DN {}\n", FP::FPCR{fpcr}.DN());
// fmt::print("fpcr.FZ {}\n", FP::FPCR{fpcr}.FZ());
// fmt::print("fpcr.RMode {}\n", static_cast<size_t>(FP::FPCR{fpcr}.RMode()));
// fmt::print("fpcr.FZ16 {}\n", FP::FPCR{fpcr}.FZ16());
// fmt::print("\n");
fmt::print("Final register listing:\n");
fmt::print(" unicorn dynarmic\n");
const auto uni_regs = uni.GetRegisters();
for (size_t i = 0; i < regs.size(); ++i) {
fmt::print("{:3s}: {:016x} {:016x} {}\n", A64::RegToString(static_cast<A64::Reg>(i)), uni_regs[i], jit.GetRegisters()[i], uni_regs[i] != jit.GetRegisters()[i] ? "*" : "");
}
const auto uni_vecs = uni.GetVectors();
for (size_t i = 0; i < vecs.size(); ++i) {
fmt::print("{:3s}: {:016x}{:016x} {:016x}{:016x} {}\n", A64::VecToString(static_cast<A64::Vec>(i)),
uni_vecs[i][1], uni_vecs[i][0],
jit.GetVectors()[i][1], jit.GetVectors()[i][0],
uni_vecs[i] != jit.GetVectors()[i] ? "*" : "");
}
fmt::print("sp : {:016x} {:016x} {}\n", uni.GetSP(), jit.GetSP(), uni.GetSP() != jit.GetSP() ? "*" : "");
fmt::print("pc : {:016x} {:016x} {}\n", uni.GetPC(), jit.GetPC(), uni.GetPC() != jit.GetPC() ? "*" : "");
fmt::print("p : {:08x} {:08x} {}\n", uni.GetPstate(), jit.GetPstate(), (uni.GetPstate() & 0xF0000000) != (jit.GetPstate() & 0xF0000000) ? "*" : "");
fmt::print("qc : {:08x} {:08x} {}\n", uni.GetFpsr(), jit.GetFpsr(), FP::FPSR{uni.GetFpsr()}.QC() != FP::FPSR{jit.GetFpsr()}.QC() ? "*" : "");
fmt::print("\n");
// fmt::print("Final register listing:\n");
// fmt::print(" unicorn dynarmic\n");
// const auto uni_regs = uni.GetRegisters();
// for (size_t i = 0; i < regs.size(); ++i) {
// fmt::print("{:3s}: {:016x} {:016x} {}\n", A64::RegToString(static_cast<A64::Reg>(i)), uni_regs[i], jit.GetRegisters()[i], uni_regs[i] != jit.GetRegisters()[i] ? "*" : "");
// }
// const auto uni_vecs = uni.GetVectors();
// for (size_t i = 0; i < vecs.size(); ++i) {
// fmt::print("{:3s}: {:016x}{:016x} {:016x}{:016x} {}\n", A64::VecToString(static_cast<A64::Vec>(i)),
// uni_vecs[i][1], uni_vecs[i][0],
// jit.GetVectors()[i][1], jit.GetVectors()[i][0],
// uni_vecs[i] != jit.GetVectors()[i] ? "*" : "");
// }
// fmt::print("sp : {:016x} {:016x} {}\n", uni.GetSP(), jit.GetSP(), uni.GetSP() != jit.GetSP() ? "*" : "");
// fmt::print("pc : {:016x} {:016x} {}\n", uni.GetPC(), jit.GetPC(), uni.GetPC() != jit.GetPC() ? "*" : "");
// fmt::print("p : {:08x} {:08x} {}\n", uni.GetPstate(), jit.GetPstate(), (uni.GetPstate() & 0xF0000000) != (jit.GetPstate() & 0xF0000000) ? "*" : "");
// fmt::print("qc : {:08x} {:08x} {}\n", uni.GetFpsr(), jit.GetFpsr(), FP::FPSR{uni.GetFpsr()}.QC() != FP::FPSR{jit.GetFpsr()}.QC() ? "*" : "");
// fmt::print("\n");
fmt::print("Modified memory:\n");
fmt::print(" uni dyn\n");
auto uni_iter = uni_env.modified_memory.begin();
auto jit_iter = jit_env.modified_memory.begin();
while (uni_iter != uni_env.modified_memory.end() || jit_iter != jit_env.modified_memory.end()) {
if (uni_iter == uni_env.modified_memory.end() || (jit_iter != jit_env.modified_memory.end() && uni_iter->first > jit_iter->first)) {
fmt::print("{:016x}: {:02x} *\n", jit_iter->first, jit_iter->second);
jit_iter++;
} else if (jit_iter == jit_env.modified_memory.end() || jit_iter->first > uni_iter->first) {
fmt::print("{:016x}: {:02x} *\n", uni_iter->first, uni_iter->second);
uni_iter++;
} else if (uni_iter->first == jit_iter->first) {
fmt::print("{:016x}: {:02x} {:02x} {}\n", uni_iter->first, uni_iter->second, jit_iter->second, uni_iter->second != jit_iter->second ? "*" : "");
uni_iter++;
jit_iter++;
}
}
fmt::print("\n");
// fmt::print("Modified memory:\n");
// fmt::print(" uni dyn\n");
// auto uni_iter = uni_env.modified_memory.begin();
// auto jit_iter = jit_env.modified_memory.begin();
// while (uni_iter != uni_env.modified_memory.end() || jit_iter != jit_env.modified_memory.end()) {
// if (uni_iter == uni_env.modified_memory.end() || (jit_iter != jit_env.modified_memory.end() && uni_iter->first > jit_iter->first)) {
// fmt::print("{:016x}: {:02x} *\n", jit_iter->first, jit_iter->second);
// jit_iter++;
// } else if (jit_iter == jit_env.modified_memory.end() || jit_iter->first > uni_iter->first) {
// fmt::print("{:016x}: {:02x} *\n", uni_iter->first, uni_iter->second);
// uni_iter++;
// } else if (uni_iter->first == jit_iter->first) {
// fmt::print("{:016x}: {:02x} {:02x} {}\n", uni_iter->first, uni_iter->second, jit_iter->second, uni_iter->second != jit_iter->second ? "*" : "");
// uni_iter++;
// jit_iter++;
// }
// }
// fmt::print("\n");
const auto get_code = [&jit_env](u64 vaddr) { return jit_env.MemoryReadCode(vaddr); };
const A64::LocationDescriptor location{instructions_start, FP::FPCR{fpcr}};
IR::Block ir_block{location};
A64::Translate(ir_block, location, get_code, {});
fmt::print("IR:\n{}\n", IR::DumpBlock(ir_block));
Optimization::Optimize(ir_block, conf, {});
fmt::print("Optimized IR:\n{}\n", IR::DumpBlock(ir_block));
fmt::print("x86_64:\n{}", jit.Disassemble());
fmt::print("Interrupts:\n");
for (auto& i : uni_env.interrupts) {
puts(i.c_str());
}
};
// const auto get_code = [&jit_env](u64 vaddr) { return jit_env.MemoryReadCode(vaddr); };
// const A64::LocationDescriptor location{instructions_start, FP::FPCR{fpcr}};
// IR::Block ir_block{location};
// A64::Translate(ir_block, location, get_code, {});
// fmt::print("IR:\n{}\n", IR::DumpBlock(ir_block));
// Optimization::Optimize(ir_block, conf, {});
// fmt::print("Optimized IR:\n{}\n", IR::DumpBlock(ir_block));
// fmt::print("x86_64:\n{}", jit.Disassemble());
// fmt::print("Interrupts:\n");
// for (auto& i : uni_env.interrupts) {
// puts(i.c_str());
// }
// };
REQUIRE(uni_env.code_mem_modified_by_guest == jit_env.code_mem_modified_by_guest);
if (uni_env.code_mem_modified_by_guest) {

8
src/dynarmic/tests/CMakeLists.txt
View file

@ -72,7 +72,7 @@ add_executable(dynarmic_print_info
print_info.cpp
)
create_target_directory_groups(dynarmic_print_info)
target_link_libraries(dynarmic_print_info PRIVATE dynarmic fmt::fmt merry::mcl unordered_dense::unordered_dense)
target_link_libraries(dynarmic_print_info PRIVATE dynarmic fmt::fmt unordered_dense::unordered_dense)
if (BOOST_NO_HEADERS)
target_link_libraries(dynarmic_print_info PRIVATE Boost::variant Boost::icl Boost::pool)
else()
@ -93,7 +93,7 @@ add_executable(dynarmic_test_generator
create_target_directory_groups(dynarmic_test_generator)
target_link_libraries(dynarmic_test_generator PRIVATE dynarmic fmt::fmt merry::mcl unordered_dense::unordered_dense)
target_link_libraries(dynarmic_test_generator PRIVATE dynarmic fmt::fmt unordered_dense::unordered_dense)
if (BOOST_NO_HEADERS)
target_link_libraries(dynarmic_test_generator PRIVATE Boost::variant Boost::icl Boost::pool)
else()
@ -110,7 +110,7 @@ add_executable(dynarmic_test_reader
test_reader.cpp
)
create_target_directory_groups(dynarmic_test_reader)
target_link_libraries(dynarmic_test_reader PRIVATE dynarmic fmt::fmt merry::mcl unordered_dense::unordered_dense)
target_link_libraries(dynarmic_test_reader PRIVATE dynarmic fmt::fmt unordered_dense::unordered_dense)
if (BOOST_NO_HEADERS)
target_link_libraries(dynarmic_test_reader PRIVATE Boost::variant Boost::icl Boost::pool)
else()
@ -123,7 +123,7 @@ target_compile_definitions(dynarmic_test_reader PRIVATE FMT_USE_USER_DEFINED_LIT
#
create_target_directory_groups(dynarmic_tests)
target_link_libraries(dynarmic_tests PRIVATE dynarmic Catch2::Catch2WithMain fmt::fmt merry::mcl unordered_dense::unordered_dense)
target_link_libraries(dynarmic_tests PRIVATE dynarmic Catch2::Catch2WithMain fmt::fmt unordered_dense::unordered_dense)
if (BOOST_NO_HEADERS)
target_link_libraries(dynarmic_tests PRIVATE Boost::variant Boost::icl Boost::pool)
else()

2
src/dynarmic/tests/print_info.cpp
View file

@ -18,7 +18,7 @@
#include <fmt/format.h>
#include <fmt/ostream.h>
#include <fmt/ranges.h>
#include <mcl/bit/swap.hpp>
#include "dynarmic/mcl/bit.hpp"
#include "dynarmic/common/common_types.h"
#include "dynarmic/common/llvm_disassemble.h"

3
src/dynarmic/tests/test_generator.cpp
View file

@ -16,8 +16,7 @@
#include <tuple>
#include <vector>
#include <mcl/bit/swap.hpp>
#include <mcl/macro/architecture.hpp>
#include "dynarmic/mcl/bit.hpp"
#include "dynarmic/common/common_types.h"
#include "./A32/testenv.h"

2
src/dynarmic/tests/unicorn_emu/a32_unicorn.cpp
View file

@ -8,7 +8,7 @@
#include <type_traits>
#include <fmt/format.h>
#include <mcl/bit/bit_field.hpp>
#include "dynarmic/mcl/bit.hpp"
#include "dynarmic/tests/unicorn_emu/a32_unicorn.h"
#include "dynarmic/common/assert.h"
#include "dynarmic/tests/A32/testenv.h"