VERY experimental Nintendo Switch 2 emulator
C++
[dynarmic] remove bloated LUT usage that makes giant functions for no good reason (#2801)
lizzie71241b7560ea
diff --git a/src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_vector_floating_point.cpp b/src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_vector_floating_point.cppindex e0a53bf9e4..81cfc0b2db 100644--- a/src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_vector_floating_point.cpp+++ b/src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_vector_floating_point.cpp@@ -1,3 +1,6 @@+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later+/* This file is part of the dynarmic project.* Copyright (c) 2022 MerryMage* SPDX-License-Identifier: 0BSD@@ -566,37 +569,49 @@ void EmitIR<IR::Opcode::FPVectorRecipStepFused64>(oaknut::CodeGenerator& code, EEmitThreeOpArranged<64>(code, ctx, inst, [&](auto Vresult, auto Va, auto Vb) { code.FRECPS(Vresult, Va, Vb); });}+/// @brief Assembly thunk "parameters" are in template parameters+/// TODO: we have space for a 5th parameter? :)+template<typename FPT, FP::RoundingMode rounding_mode, bool exact>+static void EmitIRVectorRoundInt16Thunk(VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {+ for (size_t i = 0; i < output.size(); ++i)+ output[i] = FPT(FP::FPRoundInt<FPT>(input[i], fpcr, rounding_mode, exact, fpsr));+}+template<>void EmitIR<IR::Opcode::FPVectorRoundInt16>(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Inst* inst) {- const auto rounding = static_cast<FP::RoundingMode>(inst->GetArg(1).GetU8());+ const auto rounding = FP::RoundingMode(inst->GetArg(1).GetU8());const bool exact = inst->GetArg(2).GetU1();-- using rounding_list = mp::list<- mp::lift_value<FP::RoundingMode::ToNearest_TieEven>,- mp::lift_value<FP::RoundingMode::TowardsPlusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsMinusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsZero>,- mp::lift_value<FP::RoundingMode::ToNearest_TieAwayFromZero>>;- using exact_list = mp::list<std::true_type, std::false_type>;-- static const auto lut = Common::GenerateLookupTableFromList(- []<typename I>(I) {- using FPT = u16;- return std::pair{- mp::lower_to_tuple_v<I>,- Common::FptrCast(- [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {- constexpr FP::RoundingMode rounding_mode = mp::get<0, I>::value;- constexpr bool exact = mp::get<1, I>::value;-- for (size_t i = 0; i < output.size(); ++i) {- output[i] = static_cast<FPT>(FP::FPRoundInt<FPT>(input[i], fpcr, rounding_mode, exact, fpsr));- }- })};- },- mp::cartesian_product<rounding_list, exact_list>{});-- EmitTwoOpFallback<3>(code, ctx, inst, lut.at(std::make_tuple(rounding, exact)));+ // Don't even think about making this a LUT -- it's bad+ using FPT = u16; // Yes it's u16, no fsize madness+ switch (rounding) {+ case FP::RoundingMode::ToNearest_TieEven:+ exact+ ? EmitTwoOpFallback<3>(code, ctx, inst, EmitIRVectorRoundInt16Thunk<FPT, FP::RoundingMode::ToNearest_TieEven, true>)+ : EmitTwoOpFallback<3>(code, ctx, inst, EmitIRVectorRoundInt16Thunk<FPT, FP::RoundingMode::ToNearest_TieEven, false>);+ break;+ case FP::RoundingMode::TowardsPlusInfinity:+ exact+ ? EmitTwoOpFallback<3>(code, ctx, inst, EmitIRVectorRoundInt16Thunk<FPT, FP::RoundingMode::TowardsPlusInfinity, true>)+ : EmitTwoOpFallback<3>(code, ctx, inst, EmitIRVectorRoundInt16Thunk<FPT, FP::RoundingMode::TowardsPlusInfinity, false>);+ break;+ case FP::RoundingMode::TowardsMinusInfinity:+ exact+ ? EmitTwoOpFallback<3>(code, ctx, inst, EmitIRVectorRoundInt16Thunk<FPT, FP::RoundingMode::TowardsMinusInfinity, true>)+ : EmitTwoOpFallback<3>(code, ctx, inst, EmitIRVectorRoundInt16Thunk<FPT, FP::RoundingMode::TowardsMinusInfinity, false>);+ break;+ case FP::RoundingMode::TowardsZero:+ exact+ ? EmitTwoOpFallback<3>(code, ctx, inst, EmitIRVectorRoundInt16Thunk<FPT, FP::RoundingMode::TowardsZero, true>)+ : EmitTwoOpFallback<3>(code, ctx, inst, EmitIRVectorRoundInt16Thunk<FPT, FP::RoundingMode::TowardsZero, false>);+ break;+ case FP::RoundingMode::ToNearest_TieAwayFromZero:+ exact+ ? EmitTwoOpFallback<3>(code, ctx, inst, EmitIRVectorRoundInt16Thunk<FPT, FP::RoundingMode::ToNearest_TieAwayFromZero, true>)+ : EmitTwoOpFallback<3>(code, ctx, inst, EmitIRVectorRoundInt16Thunk<FPT, FP::RoundingMode::ToNearest_TieAwayFromZero, false>);+ break;+ default:+ UNREACHABLE();+ }}template<>diff --git a/src/dynarmic/src/dynarmic/backend/x64/emit_x64_floating_point.cpp b/src/dynarmic/src/dynarmic/backend/x64/emit_x64_floating_point.cppindex 47e51acb03..a2fe4001a9 100644--- a/src/dynarmic/src/dynarmic/backend/x64/emit_x64_floating_point.cpp+++ b/src/dynarmic/src/dynarmic/backend/x64/emit_x64_floating_point.cpp@@ -1071,57 +1071,42 @@ void EmitX64::EmitFPRecipStepFused64(EmitContext& ctx, IR::Inst* inst) {EmitFPRecipStepFused<64>(code, ctx, inst);}-static void EmitFPRound(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst, size_t fsize) {- const auto rounding_mode = static_cast<FP::RoundingMode>(inst->GetArg(1).GetU8());- const bool exact = inst->GetArg(2).GetU1();- const auto round_imm = ConvertRoundingModeToX64Immediate(rounding_mode);+/// @brief An assembly thunk for the general rounding of FP+/// Conciously making this be a template, because the cost of comparing "fsize" for every+/// round is not worth it. Remember we are making only 3 copies (u16,u32,u64)+/// Extra args layout:+/// 0-7 rounding_mode+/// 8-15 exact (!= 0)+template<typename FPT>+static u64 EmitFPRoundThunk(u64 input, FP::FPSR& fpsr, FP::FPCR fpcr, u32 extra_args) {+ auto const exact = ((extra_args >> 16) & 0xff) != 0;+ auto const rounding_mode = FP::RoundingMode((extra_args >> 8) & 0xff);+ return FP::FPRoundInt<FPT>(FPT(input), fpcr, rounding_mode, exact, fpsr);+}+static void EmitFPRound(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst, size_t fsize) {+ auto const rounding_mode = FP::RoundingMode(inst->GetArg(1).GetU8());+ bool const exact = inst->GetArg(2).GetU1();+ auto const round_imm = ConvertRoundingModeToX64Immediate(rounding_mode);if (fsize != 16 && code.HasHostFeature(HostFeature::SSE41) && round_imm && !exact) {- if (fsize == 64) {- FPTwoOp<64>(code, ctx, inst, [&](Xbyak::Xmm result) {- code.roundsd(result, result, *round_imm);- });- } else {- FPTwoOp<32>(code, ctx, inst, [&](Xbyak::Xmm result) {- code.roundss(result, result, *round_imm);- });+ fsize == 64+ ? FPTwoOp<64>(code, ctx, inst, [&](Xbyak::Xmm result) { code.roundsd(result, result, *round_imm); })+ : FPTwoOp<32>(code, ctx, inst, [&](Xbyak::Xmm result) { code.roundss(result, result, *round_imm); });+ } else {+ auto args = ctx.reg_alloc.GetArgumentInfo(inst);+ // See EmitFPRoundThunk+ auto const extra_args = u32(rounding_mode) | (u32(exact) << 8);+ ctx.reg_alloc.HostCall(inst, args[0]);+ code.lea(code.ABI_PARAM2, code.ptr[code.ABI_JIT_PTR + code.GetJitStateInfo().offsetof_fpsr_exc]);+ code.mov(code.ABI_PARAM3.cvt32(), ctx.FPCR().Value());+ code.mov(code.ABI_PARAM4.cvt32(), extra_args);+ switch (fsize) {+ case 64: code.CallFunction(EmitFPRoundThunk<u64>); break;+ case 32: code.CallFunction(EmitFPRoundThunk<u32>); break;+ case 16: code.CallFunction(EmitFPRoundThunk<u16>); break;+ default: UNREACHABLE();}-- return;}-- using fsize_list = mp::list<mp::lift_value<size_t(16)>,- mp::lift_value<size_t(32)>,- mp::lift_value<size_t(64)>>;- using rounding_list = mp::list<- mp::lift_value<FP::RoundingMode::ToNearest_TieEven>,- mp::lift_value<FP::RoundingMode::TowardsPlusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsMinusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsZero>,- mp::lift_value<FP::RoundingMode::ToNearest_TieAwayFromZero>>;- using exact_list = mp::list<std::true_type, std::false_type>;-- static const auto lut = Common::GenerateLookupTableFromList(- []<typename I>(I) {- return std::pair{- mp::lower_to_tuple_v<I>,- Common::FptrCast(- [](u64 input, FP::FPSR& fpsr, FP::FPCR fpcr) {- constexpr size_t fsize = mp::get<0, I>::value;- constexpr FP::RoundingMode rounding_mode = mp::get<1, I>::value;- constexpr bool exact = mp::get<2, I>::value;- using InputSize = mcl::unsigned_integer_of_size<fsize>;-- return FP::FPRoundInt<InputSize>(static_cast<InputSize>(input), fpcr, rounding_mode, exact, fpsr);- })};- },- mp::cartesian_product<fsize_list, rounding_list, exact_list>{});-- auto args = ctx.reg_alloc.GetArgumentInfo(inst);- ctx.reg_alloc.HostCall(inst, args[0]);- code.lea(code.ABI_PARAM2, code.ptr[code.ABI_JIT_PTR + code.GetJitStateInfo().offsetof_fpsr_exc]);- code.mov(code.ABI_PARAM3.cvt32(), ctx.FPCR().Value());- code.CallFunction(lut.at(std::make_tuple(fsize, rounding_mode, exact)));}void EmitX64::EmitFPRoundInt16(EmitContext& ctx, IR::Inst* inst) {@@ -1621,12 +1606,29 @@ void EmitX64::EmitFPDoubleToSingle(EmitContext& ctx, IR::Inst* inst) {}}+/// @brief Thunk used in assembly+/// The extra args is conformed as follows:+/// 0-7 fbits+/// 8-15 rounding+/// 16-23 isize+/// 24-31 unsigned_ (!= 0)+/// Better than spamming thousands of templates aye?+template<size_t fsize>+static u64 EmitFPToFixedThunk(u64 input, FP::FPSR& fpsr, FP::FPCR fpcr, u32 extra_args) {+ using FPT = mcl::unsigned_integer_of_size<fsize>;+ auto const unsigned_ = ((extra_args >> 24) & 0xff) != 0;+ auto const isize = ((extra_args >> 16) & 0xff);+ auto const rounding = FP::RoundingMode((extra_args >> 8) & 0xff);+ auto const fbits = ((extra_args >> 0) & 0xff);+ return FP::FPToFixed<FPT>(isize, FPT(input), fbits, unsigned_, fpcr, rounding, fpsr);+}+template<size_t fsize, bool unsigned_, size_t isize>static void EmitFPToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {auto args = ctx.reg_alloc.GetArgumentInfo(inst);const size_t fbits = args[1].GetImmediateU8();- const auto rounding_mode = static_cast<FP::RoundingMode>(args[2].GetImmediateU8());+ const auto rounding_mode = FP::RoundingMode(args[2].GetImmediateU8());if constexpr (fsize != 16) {const auto round_imm = ConvertRoundingModeToX64Immediate(rounding_mode);@@ -1732,34 +1734,14 @@ static void EmitFPToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {return;}}-- using fbits_list = mp::lift_sequence<std::make_index_sequence<isize + 1>>;- using rounding_list = mp::list<- mp::lift_value<FP::RoundingMode::ToNearest_TieEven>,- mp::lift_value<FP::RoundingMode::TowardsPlusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsMinusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsZero>,- mp::lift_value<FP::RoundingMode::ToNearest_TieAwayFromZero>>;-- static const auto lut = Common::GenerateLookupTableFromList(- []<typename I>(I) {- return std::pair{- mp::lower_to_tuple_v<I>,- Common::FptrCast(- [](u64 input, FP::FPSR& fpsr, FP::FPCR fpcr) {- constexpr size_t fbits = mp::get<0, I>::value;- constexpr FP::RoundingMode rounding_mode = mp::get<1, I>::value;- using FPT = mcl::unsigned_integer_of_size<fsize>;-- return FP::FPToFixed<FPT>(isize, static_cast<FPT>(input), fbits, unsigned_, fpcr, rounding_mode, fpsr);- })};- },- mp::cartesian_product<fbits_list, rounding_list>{});-+ // See EmitFPToFixedThunk+ auto const extra_args = (u32(unsigned_) << 24) | (u32(isize) << 16)+ | (u32(rounding_mode) << 8) | (u32(fbits));ctx.reg_alloc.HostCall(inst, args[0]);code.lea(code.ABI_PARAM2, code.ptr[code.ABI_JIT_PTR + code.GetJitStateInfo().offsetof_fpsr_exc]);code.mov(code.ABI_PARAM3.cvt32(), ctx.FPCR().Value());- code.CallFunction(lut.at(std::make_tuple(fbits, rounding_mode)));+ code.mov(code.ABI_PARAM4.cvt32(), extra_args);+ code.CallFunction(EmitFPToFixedThunk<fsize>);}void EmitX64::EmitFPDoubleToFixedS16(EmitContext& ctx, IR::Inst* inst) {diff --git a/src/dynarmic/src/dynarmic/backend/x64/emit_x64_vector_floating_point.cpp b/src/dynarmic/src/dynarmic/backend/x64/emit_x64_vector_floating_point.cppindex a368e6703f..66a179a481 100644--- a/src/dynarmic/src/dynarmic/backend/x64/emit_x64_vector_floating_point.cpp+++ b/src/dynarmic/src/dynarmic/backend/x64/emit_x64_vector_floating_point.cpp@@ -439,9 +439,9 @@ void EmitThreeOpVectorOperation(BlockOfCode& code, EmitContext& ctx, IR::Inst* ictx.reg_alloc.DefineValue(inst, result);}-template<typename Lambda>-void EmitTwoOpFallbackWithoutRegAlloc(BlockOfCode& code, EmitContext& ctx, Xbyak::Xmm result, Xbyak::Xmm arg1, Lambda lambda, bool fpcr_controlled) {- const auto fn = static_cast<mcl::equivalent_function_type<Lambda>*>(lambda);+template<typename F>+void EmitTwoOpFallbackWithoutRegAlloc(BlockOfCode& code, EmitContext& ctx, Xbyak::Xmm result, Xbyak::Xmm arg1, F lambda, bool fpcr_controlled) {+ const auto fn = static_cast<mcl::equivalent_function_type<F>*>(lambda);const u32 fpcr = ctx.FPCR(fpcr_controlled).Value();@@ -459,8 +459,8 @@ void EmitTwoOpFallbackWithoutRegAlloc(BlockOfCode& code, EmitContext& ctx, Xbyakcode.add(rsp, stack_space + ABI_SHADOW_SPACE);}-template<size_t fpcr_controlled_arg_index = 1, typename Lambda>-void EmitTwoOpFallback(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst, Lambda lambda) {+template<size_t fpcr_controlled_arg_index = 1, typename F>+void EmitTwoOpFallback(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst, F lambda) {auto args = ctx.reg_alloc.GetArgumentInfo(inst);const Xbyak::Xmm arg1 = ctx.reg_alloc.UseXmm(args[0]);const Xbyak::Xmm result = ctx.reg_alloc.ScratchXmm();@@ -665,8 +665,14 @@ void EmitX64::EmitFPVectorEqual64(EmitContext& ctx, IR::Inst* inst) {ctx.reg_alloc.DefineValue(inst, a);}+template<FP::RoundingMode rounding_mode>+static void EmitFPVectorFromHalf32Thunk(VectorArray<u32>& output, const VectorArray<u16>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {+ for (size_t i = 0; i < output.size(); ++i)+ output[i] = FP::FPConvert<u32, u16>(input[i], fpcr, rounding_mode, fpsr);+}+void EmitX64::EmitFPVectorFromHalf32(EmitContext& ctx, IR::Inst* inst) {- const auto rounding_mode = static_cast<FP::RoundingMode>(inst->GetArg(1).GetU8());+ const auto rounding_mode = FP::RoundingMode(inst->GetArg(1).GetU8());const bool fpcr_controlled = inst->GetArg(2).GetU1();if (code.HasHostFeature(HostFeature::F16C) && !ctx.FPCR().AHP() && !ctx.FPCR().FZ16()) {@@ -679,32 +685,27 @@ void EmitX64::EmitFPVectorFromHalf32(EmitContext& ctx, IR::Inst* inst) {ForceToDefaultNaN<32>(code, ctx.FPCR(fpcr_controlled), result);ctx.reg_alloc.DefineValue(inst, result);- return;+ } else {+ switch (rounding_mode) {+ case FP::RoundingMode::ToNearest_TieEven:+ EmitTwoOpFallback<2>(code, ctx, inst, EmitFPVectorFromHalf32Thunk<FP::RoundingMode::ToNearest_TieEven>);+ break;+ case FP::RoundingMode::TowardsPlusInfinity:+ EmitTwoOpFallback<2>(code, ctx, inst, EmitFPVectorFromHalf32Thunk<FP::RoundingMode::TowardsPlusInfinity>);+ break;+ case FP::RoundingMode::TowardsMinusInfinity:+ EmitTwoOpFallback<2>(code, ctx, inst, EmitFPVectorFromHalf32Thunk<FP::RoundingMode::TowardsMinusInfinity>);+ break;+ case FP::RoundingMode::TowardsZero:+ EmitTwoOpFallback<2>(code, ctx, inst, EmitFPVectorFromHalf32Thunk<FP::RoundingMode::TowardsZero>);+ break;+ case FP::RoundingMode::ToNearest_TieAwayFromZero:+ EmitTwoOpFallback<2>(code, ctx, inst, EmitFPVectorFromHalf32Thunk<FP::RoundingMode::ToNearest_TieAwayFromZero>);+ break;+ default:+ UNREACHABLE();+ }}-- using rounding_list = mp::list<- mp::lift_value<FP::RoundingMode::ToNearest_TieEven>,- mp::lift_value<FP::RoundingMode::TowardsPlusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsMinusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsZero>,- mp::lift_value<FP::RoundingMode::ToNearest_TieAwayFromZero>>;-- static const auto lut = Common::GenerateLookupTableFromList(- []<typename I>(I) {- return std::pair{- mp::lower_to_tuple_v<I>,- Common::FptrCast(- [](VectorArray<u32>& output, const VectorArray<u16>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {- constexpr FP::RoundingMode rounding_mode = mp::get<0, I>::value;-- for (size_t i = 0; i < output.size(); ++i) {- output[i] = FP::FPConvert<u32, u16>(input[i], fpcr, rounding_mode, fpsr);- }- })};- },- mp::cartesian_product<rounding_list>{});-- EmitTwoOpFallback<2>(code, ctx, inst, lut.at(std::make_tuple(rounding_mode)));}void EmitX64::EmitFPVectorFromSignedFixed32(EmitContext& ctx, IR::Inst* inst) {@@ -1681,25 +1682,26 @@ void EmitX64::EmitFPVectorRecipStepFused64(EmitContext& ctx, IR::Inst* inst) {EmitRecipStepFused<64>(code, ctx, inst);}+template<typename FPT, FP::RoundingMode rounding_mode, bool exact>+static void EmitFPVectorRoundIntThunk(VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {+ for (size_t i = 0; i < output.size(); ++i)+ output[i] = FPT(FP::FPRoundInt<FPT>(input[i], fpcr, rounding_mode, exact, fpsr));+}+template<size_t fsize>void EmitFPVectorRoundInt(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {- const auto rounding = static_cast<FP::RoundingMode>(inst->GetArg(1).GetU8());+ const auto rounding = FP::RoundingMode(inst->GetArg(1).GetU8());const bool exact = inst->GetArg(2).GetU1();if constexpr (fsize != 16) {if (code.HasHostFeature(HostFeature::SSE41) && rounding != FP::RoundingMode::ToNearest_TieAwayFromZero && !exact) {const u8 round_imm = [&]() -> u8 {switch (rounding) {- case FP::RoundingMode::ToNearest_TieEven:- return 0b00;- case FP::RoundingMode::TowardsPlusInfinity:- return 0b10;- case FP::RoundingMode::TowardsMinusInfinity:- return 0b01;- case FP::RoundingMode::TowardsZero:- return 0b11;- default:- UNREACHABLE();+ case FP::RoundingMode::ToNearest_TieEven: return 0b00;+ case FP::RoundingMode::TowardsPlusInfinity: return 0b10;+ case FP::RoundingMode::TowardsMinusInfinity: return 0b01;+ case FP::RoundingMode::TowardsZero: return 0b11;+ default: UNREACHABLE();}}();@@ -1711,32 +1713,37 @@ void EmitFPVectorRoundInt(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {}}- using rounding_list = mp::list<- mp::lift_value<FP::RoundingMode::ToNearest_TieEven>,- mp::lift_value<FP::RoundingMode::TowardsPlusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsMinusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsZero>,- mp::lift_value<FP::RoundingMode::ToNearest_TieAwayFromZero>>;- using exact_list = mp::list<std::true_type, std::false_type>;-- static const auto lut = Common::GenerateLookupTableFromList(- []<typename I>(I) {- using FPT = mcl::unsigned_integer_of_size<fsize>; // WORKAROUND: For issue 678 on MSVC- return std::pair{- mp::lower_to_tuple_v<I>,- Common::FptrCast(- [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {- constexpr FP::RoundingMode rounding_mode = mp::get<0, I>::value;- constexpr bool exact = mp::get<1, I>::value;-- for (size_t i = 0; i < output.size(); ++i) {- output[i] = static_cast<FPT>(FP::FPRoundInt<FPT>(input[i], fpcr, rounding_mode, exact, fpsr));- }- })};- },- mp::cartesian_product<rounding_list, exact_list>{});-- EmitTwoOpFallback<3>(code, ctx, inst, lut.at(std::make_tuple(rounding, exact)));+ // Do not make a LUT out of this, let the compiler do it's thing+ using FPT = mcl::unsigned_integer_of_size<fsize>;+ switch (rounding) {+ case FP::RoundingMode::ToNearest_TieEven:+ exact+ ? EmitTwoOpFallback<3>(code, ctx, inst, EmitFPVectorRoundIntThunk<FPT, FP::RoundingMode::ToNearest_TieEven, true>)+ : EmitTwoOpFallback<3>(code, ctx, inst, EmitFPVectorRoundIntThunk<FPT, FP::RoundingMode::ToNearest_TieEven, false>);+ break;+ case FP::RoundingMode::TowardsPlusInfinity:+ exact+ ? EmitTwoOpFallback<3>(code, ctx, inst, EmitFPVectorRoundIntThunk<FPT, FP::RoundingMode::TowardsPlusInfinity, true>)+ : EmitTwoOpFallback<3>(code, ctx, inst, EmitFPVectorRoundIntThunk<FPT, FP::RoundingMode::TowardsPlusInfinity, false>);+ break;+ case FP::RoundingMode::TowardsMinusInfinity:+ exact+ ? EmitTwoOpFallback<3>(code, ctx, inst, EmitFPVectorRoundIntThunk<FPT, FP::RoundingMode::TowardsMinusInfinity, true>)+ : EmitTwoOpFallback<3>(code, ctx, inst, EmitFPVectorRoundIntThunk<FPT, FP::RoundingMode::TowardsMinusInfinity, false>);+ break;+ case FP::RoundingMode::TowardsZero:+ exact+ ? EmitTwoOpFallback<3>(code, ctx, inst, EmitFPVectorRoundIntThunk<FPT, FP::RoundingMode::TowardsZero, true>)+ : EmitTwoOpFallback<3>(code, ctx, inst, EmitFPVectorRoundIntThunk<FPT, FP::RoundingMode::TowardsZero, false>);+ break;+ case FP::RoundingMode::ToNearest_TieAwayFromZero:+ exact+ ? EmitTwoOpFallback<3>(code, ctx, inst, EmitFPVectorRoundIntThunk<FPT, FP::RoundingMode::ToNearest_TieAwayFromZero, true>)+ : EmitTwoOpFallback<3>(code, ctx, inst, EmitFPVectorRoundIntThunk<FPT, FP::RoundingMode::ToNearest_TieAwayFromZero, false>);+ break;+ default:+ UNREACHABLE();+ }}void EmitX64::EmitFPVectorRoundInt16(EmitContext& ctx, IR::Inst* inst) {@@ -1965,8 +1972,14 @@ void EmitX64::EmitFPVectorSub64(EmitContext& ctx, IR::Inst* inst) {EmitThreeOpVectorOperation<64, DefaultIndexer>(code, ctx, inst, &Xbyak::CodeGenerator::subpd);}+template<FP::RoundingMode rounding_mode>+static void EmitFPVectorToHalf32Thunk(VectorArray<u16>& output, const VectorArray<u32>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {+ for (size_t i = 0; i < output.size(); ++i)+ output[i] = i < input.size() ? FP::FPConvert<u16, u32>(input[i], fpcr, rounding_mode, fpsr) : 0;+}+void EmitX64::EmitFPVectorToHalf32(EmitContext& ctx, IR::Inst* inst) {- const auto rounding_mode = static_cast<FP::RoundingMode>(inst->GetArg(1).GetU8());+ const auto rounding_mode = FP::RoundingMode(inst->GetArg(1).GetU8());const bool fpcr_controlled = inst->GetArg(2).GetU1();if (code.HasHostFeature(HostFeature::F16C) && !ctx.FPCR().AHP() && !ctx.FPCR().FZ16()) {@@ -1976,41 +1989,39 @@ void EmitX64::EmitFPVectorToHalf32(EmitContext& ctx, IR::Inst* inst) {const Xbyak::Xmm result = ctx.reg_alloc.UseScratchXmm(args[0]);ForceToDefaultNaN<32>(code, ctx.FPCR(fpcr_controlled), result);- code.vcvtps2ph(result, result, static_cast<u8>(*round_imm));+ code.vcvtps2ph(result, result, u8(*round_imm));ctx.reg_alloc.DefineValue(inst, result);- return;+ } else {+ switch (rounding_mode) {+ case FP::RoundingMode::ToNearest_TieEven:+ EmitTwoOpFallback<2>(code, ctx, inst, EmitFPVectorToHalf32Thunk<FP::RoundingMode::ToNearest_TieEven>);+ break;+ case FP::RoundingMode::TowardsPlusInfinity:+ EmitTwoOpFallback<2>(code, ctx, inst, EmitFPVectorToHalf32Thunk<FP::RoundingMode::TowardsPlusInfinity>);+ break;+ case FP::RoundingMode::TowardsMinusInfinity:+ EmitTwoOpFallback<2>(code, ctx, inst, EmitFPVectorToHalf32Thunk<FP::RoundingMode::TowardsMinusInfinity>);+ break;+ case FP::RoundingMode::TowardsZero:+ EmitTwoOpFallback<2>(code, ctx, inst, EmitFPVectorToHalf32Thunk<FP::RoundingMode::TowardsZero>);+ break;+ case FP::RoundingMode::ToNearest_TieAwayFromZero:+ EmitTwoOpFallback<2>(code, ctx, inst, EmitFPVectorToHalf32Thunk<FP::RoundingMode::ToNearest_TieAwayFromZero>);+ break;+ default:+ UNREACHABLE();+ }}-- using rounding_list = mp::list<- mp::lift_value<FP::RoundingMode::ToNearest_TieEven>,- mp::lift_value<FP::RoundingMode::TowardsPlusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsMinusInfinity>,- mp::lift_value<FP::RoundingMode::TowardsZero>,- mp::lift_value<FP::RoundingMode::ToNearest_TieAwayFromZero>>;-- static const auto lut = Common::GenerateLookupTableFromList(- []<typename I>(I) {- return std::pair{- mp::lower_to_tuple_v<I>,- Common::FptrCast(- [](VectorArray<u16>& output, const VectorArray<u32>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {- constexpr FP::RoundingMode rounding_mode = mp::get<0, I>::value;-- for (size_t i = 0; i < output.size(); ++i) {- if (i < input.size()) {- output[i] = FP::FPConvert<u16, u32>(input[i], fpcr, rounding_mode, fpsr);- } else {- output[i] = 0;- }- }- })};- },- mp::cartesian_product<rounding_list>{});-- EmitTwoOpFallback<2>(code, ctx, inst, lut.at(std::make_tuple(rounding_mode)));}+// Assembly thunk; just remember not to specialise too much otherwise i-cache death!+// template<typename FPT, size_t fbits, FP::RoundingMode rounding_mode>+// static void EmitFPVectorToFixedThunk(VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {+// for (size_t i = 0; i < output.size(); ++i)+// output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fbits, unsigned_, fpcr, rounding_mode, fpsr));+// }+template<size_t fsize, bool unsigned_>void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {const size_t fbits = inst->GetArg(1).GetU8();@@ -2108,7 +2119,7 @@ void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {FCODE(andp)(tmp, xmm0);FCODE(subp)(src, tmp);perform_conversion(src);- ICODE(psll)(xmm0, static_cast<u8>(fsize - 1));+ ICODE(psll)(xmm0, u8(fsize - 1));FCODE(orp)(src, xmm0);// Saturate to max@@ -2116,7 +2127,7 @@ void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {}} else {using FPT = mcl::unsigned_integer_of_size<fsize>; // WORKAROUND: For issue 678 on MSVC- constexpr u64 integer_max = static_cast<FPT>((std::numeric_limits<std::conditional_t<unsigned_, FPT, std::make_signed_t<FPT>>>::max)());+ constexpr u64 integer_max = FPT((std::numeric_limits<std::conditional_t<unsigned_, FPT, std::make_signed_t<FPT>>>::max)());code.movaps(xmm0, GetVectorOf<fsize, float_upper_limit_signed>(code));FCODE(cmplep)(xmm0, src);@@ -2138,22 +2149,18 @@ void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {mp::lift_value<FP::RoundingMode::TowardsZero>,mp::lift_value<FP::RoundingMode::ToNearest_TieAwayFromZero>>;- static const auto lut = Common::GenerateLookupTableFromList(- []<typename I>(I) {- using FPT = mcl::unsigned_integer_of_size<fsize>; // WORKAROUND: For issue 678 on MSVC- return std::pair{- mp::lower_to_tuple_v<I>,- Common::FptrCast(- [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {- constexpr size_t fbits = mp::get<0, I>::value;- constexpr FP::RoundingMode rounding_mode = mp::get<1, I>::value;-- for (size_t i = 0; i < output.size(); ++i) {- output[i] = static_cast<FPT>(FP::FPToFixed<FPT>(fsize, input[i], fbits, unsigned_, fpcr, rounding_mode, fpsr));- }- })};- },- mp::cartesian_product<fbits_list, rounding_list>{});+ static const auto lut = Common::GenerateLookupTableFromList([]<typename I>(I) {+ using FPT = mcl::unsigned_integer_of_size<fsize>; // WORKAROUND: For issue 678 on MSVC+ return std::pair{+ mp::lower_to_tuple_v<I>,+ Common::FptrCast([](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {+ constexpr size_t fbits = mp::get<0, I>::value;+ constexpr FP::RoundingMode rounding_mode = mp::get<1, I>::value;+ for (size_t i = 0; i < output.size(); ++i)+ output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fbits, unsigned_, fpcr, rounding_mode, fpsr));+ })+ };+ }, mp::cartesian_product<fbits_list, rounding_list>{});EmitTwoOpFallback<3>(code, ctx, inst, lut.at(std::make_tuple(fbits, rounding)));}diff --git a/src/dynarmic/src/dynarmic/common/fp/rounding_mode.h b/src/dynarmic/src/dynarmic/common/fp/rounding_mode.hindex fcf36f6100..6643a8b512 100644--- a/src/dynarmic/src/dynarmic/common/fp/rounding_mode.h+++ b/src/dynarmic/src/dynarmic/common/fp/rounding_mode.h@@ -1,3 +1,6 @@+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later+/* This file is part of the dynarmic project.* Copyright (c) 2018 MerryMage* SPDX-License-Identifier: 0BSDdiff --git a/src/dynarmic/src/dynarmic/common/lut_from_list.h b/src/dynarmic/src/dynarmic/common/lut_from_list.hindex c904e2c041..633b62aeda 100644--- a/src/dynarmic/src/dynarmic/common/lut_from_list.h+++ b/src/dynarmic/src/dynarmic/common/lut_from_list.h@@ -40,9 +40,7 @@ inline auto GenerateLookupTableFromList(Function f, mcl::mp::list<Values...>) {using PairT = std::common_type_t<std::invoke_result_t<Function, Values>...>;#endifusing MapT = mcl::mp::apply<std::map, PairT>;-static_assert(mcl::is_instance_of_template_v<std::pair, PairT>);-const std::initializer_list<PairT> pair_array{f(Values{})...};return MapT(pair_array.begin(), pair_array.end());}