Plexi09/eden-miror
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden synced 2026-04-10 03:18:55 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

[dynarmic] fix bayonetta 3 regression due to LUT in #3718 (#3822)
Some checks failed
tx-src / sources (push) Has been cancelled
Details
Check Strings / check-strings (push) Has been cancelled
Details

Browse source 
minor oversight

Signed-off-by: lizzie <lizzie@eden-emu.dev>

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3822
Reviewed-by: MaranBr <maranbr@eden-emu.dev>
Co-authored-by: lizzie <lizzie@eden-emu.dev>
Co-committed-by: lizzie <lizzie@eden-emu.dev>
This commit is contained in:
lizzie 2026-04-03 17:33:44 +02:00 • committed by crueter
parent d1b7824443
commit ac99ea96da
No known key found for this signature in database
GPG key ID: 425ACD2D4830EBC6
1 changed files with 87 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

122
src/dynarmic/src/dynarmic/backend/x64/emit_x64_vector_floating_point.cpp
View file

@ -1985,6 +1985,13 @@ void EmitX64::EmitFPVectorToHalf32(EmitContext& ctx, IR::Inst* inst) {
// output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fbits, unsigned_, fpcr, rounding_mode, fpsr)); // output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fbits, unsigned_, fpcr, rounding_mode, fpsr));
// } // }
template<size_t fsize, bool unsigned_, FP::RoundingMode rounding_mode, size_t fbits>
static void EmitFPVectorToFixedThunk(VectorArray<mcl::unsigned_integer_of_size<fsize>>& output, const VectorArray<mcl::unsigned_integer_of_size<fsize>>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {
using FPT = mcl::unsigned_integer_of_size<fsize>;
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_> template<size_t fsize, bool unsigned_>
void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) { void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {
const size_t fbits = inst->GetArg(1).GetU8(); const size_t fbits = inst->GetArg(1).GetU8();
@ -2106,43 +2113,88 @@ void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {
ctx.reg_alloc.DefineValue(code, inst, src); ctx.reg_alloc.DefineValue(code, inst, src);
return; return;
} }
auto const fpt_fn = [fbits, rounding]() -> void (*)(VectorArray<mcl::unsigned_integer_of_size<fsize>>& output, const VectorArray<mcl::unsigned_integer_of_size<fsize>>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {
#define ROUNDING_MODE_CASE(CASE, N) \
if (rounding == FP::RoundingMode::CASE && fsize >= (N) && fbits == (N)) return &EmitFPVectorToFixedThunk<fsize, unsigned_, FP::RoundingMode::CASE, N>;
#define ROUNDING_MODE_SWITCH(CASE) \
ROUNDING_MODE_CASE(CASE, 0x00) \
ROUNDING_MODE_CASE(CASE, 0x01) \
ROUNDING_MODE_CASE(CASE, 0x02) \
ROUNDING_MODE_CASE(CASE, 0x03) \
ROUNDING_MODE_CASE(CASE, 0x04) \
ROUNDING_MODE_CASE(CASE, 0x05) \
ROUNDING_MODE_CASE(CASE, 0x06) \
ROUNDING_MODE_CASE(CASE, 0x07) \
ROUNDING_MODE_CASE(CASE, 0x08) \
ROUNDING_MODE_CASE(CASE, 0x09) \
ROUNDING_MODE_CASE(CASE, 0x0a) \
ROUNDING_MODE_CASE(CASE, 0x0b) \
ROUNDING_MODE_CASE(CASE, 0x0c) \
ROUNDING_MODE_CASE(CASE, 0x0d) \
ROUNDING_MODE_CASE(CASE, 0x0e) \
ROUNDING_MODE_CASE(CASE, 0x0f) \
ROUNDING_MODE_CASE(CASE, 0x10) \
ROUNDING_MODE_CASE(CASE, 0x11) \
ROUNDING_MODE_CASE(CASE, 0x12) \
ROUNDING_MODE_CASE(CASE, 0x13) \
ROUNDING_MODE_CASE(CASE, 0x14) \
ROUNDING_MODE_CASE(CASE, 0x15) \
ROUNDING_MODE_CASE(CASE, 0x16) \
ROUNDING_MODE_CASE(CASE, 0x17) \
ROUNDING_MODE_CASE(CASE, 0x18) \
ROUNDING_MODE_CASE(CASE, 0x19) \
ROUNDING_MODE_CASE(CASE, 0x1a) \
ROUNDING_MODE_CASE(CASE, 0x1b) \
ROUNDING_MODE_CASE(CASE, 0x1c) \
ROUNDING_MODE_CASE(CASE, 0x1d) \
ROUNDING_MODE_CASE(CASE, 0x1e) \
ROUNDING_MODE_CASE(CASE, 0x1f) \
ROUNDING_MODE_CASE(CASE, 0x20) \
ROUNDING_MODE_CASE(CASE, 0x21) \
ROUNDING_MODE_CASE(CASE, 0x22) \
ROUNDING_MODE_CASE(CASE, 0x23) \
ROUNDING_MODE_CASE(CASE, 0x24) \
ROUNDING_MODE_CASE(CASE, 0x25) \
ROUNDING_MODE_CASE(CASE, 0x26) \
ROUNDING_MODE_CASE(CASE, 0x27) \
ROUNDING_MODE_CASE(CASE, 0x28) \
ROUNDING_MODE_CASE(CASE, 0x29) \
ROUNDING_MODE_CASE(CASE, 0x2a) \
ROUNDING_MODE_CASE(CASE, 0x2b) \
ROUNDING_MODE_CASE(CASE, 0x2c) \
ROUNDING_MODE_CASE(CASE, 0x2d) \
ROUNDING_MODE_CASE(CASE, 0x2e) \
ROUNDING_MODE_CASE(CASE, 0x2f) \
ROUNDING_MODE_CASE(CASE, 0x30) \
ROUNDING_MODE_CASE(CASE, 0x31) \
ROUNDING_MODE_CASE(CASE, 0x32) \
ROUNDING_MODE_CASE(CASE, 0x33) \
ROUNDING_MODE_CASE(CASE, 0x34) \
ROUNDING_MODE_CASE(CASE, 0x35) \
ROUNDING_MODE_CASE(CASE, 0x36) \
ROUNDING_MODE_CASE(CASE, 0x37) \
ROUNDING_MODE_CASE(CASE, 0x38) \
ROUNDING_MODE_CASE(CASE, 0x39) \
ROUNDING_MODE_CASE(CASE, 0x3a) \
ROUNDING_MODE_CASE(CASE, 0x3b) \
ROUNDING_MODE_CASE(CASE, 0x3c) \
ROUNDING_MODE_CASE(CASE, 0x3d) \
ROUNDING_MODE_CASE(CASE, 0x3e) \
ROUNDING_MODE_CASE(CASE, 0x3f)
using FPT = mcl::unsigned_integer_of_size<fsize>; // WORKAROUND: For issue 678 on MSVC // FUCK YOU MSVC, FUCKING DEPTH CANT EVEN HANDLE 8+16+32+64 DEPTH OF A ELSE STATMENT YOU FUCKING STUPID
auto const func = [rounding]() -> void(*)(VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) { // BURN MSVC BURN IT STUPID COMPILER CAN'T EVEN COMPILE THE MOST BASIC C++
switch (rounding) { ROUNDING_MODE_SWITCH(ToNearest_TieEven)
case FP::RoundingMode::ToNearest_TieEven: ROUNDING_MODE_SWITCH(TowardsPlusInfinity)
return [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) { ROUNDING_MODE_SWITCH(TowardsMinusInfinity)
for (size_t i = 0; i < output.size(); ++i) ROUNDING_MODE_SWITCH(TowardsZero)
output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fsize, unsigned_, fpcr, FP::RoundingMode::ToNearest_TieEven, fpsr)); ROUNDING_MODE_SWITCH(ToNearest_TieAwayFromZero)
}; #undef ROUNDING_MODE_SWITCH
case FP::RoundingMode::TowardsPlusInfinity: #undef ROUNDING_MODE_CASE
return [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) { return nullptr;
for (size_t i = 0; i < output.size(); ++i)
output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fsize, unsigned_, fpcr, FP::RoundingMode::TowardsPlusInfinity, fpsr));
};
case FP::RoundingMode::TowardsMinusInfinity:
return [](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], fsize, unsigned_, fpcr, FP::RoundingMode::TowardsMinusInfinity, fpsr));
};
case FP::RoundingMode::TowardsZero:
return [](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], fsize, unsigned_, fpcr, FP::RoundingMode::TowardsZero, fpsr));
};
case FP::RoundingMode::ToNearest_TieAwayFromZero:
return [](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], fsize, unsigned_, fpcr, FP::RoundingMode::ToNearest_TieAwayFromZero, fpsr));
};
case FP::RoundingMode::ToOdd:
return [](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], fsize, unsigned_, fpcr, FP::RoundingMode::ToOdd, fpsr));
};
}
}(); }();
EmitTwoOpFallback<3>(code, ctx, inst, func);
EmitTwoOpFallback<3>(code, ctx, inst, fpt_fn);
} }
void EmitX64::EmitFPVectorToSignedFixed16(EmitContext& ctx, IR::Inst* inst) { void EmitX64::EmitFPVectorToSignedFixed16(EmitContext& ctx, IR::Inst* inst) {