From 2342b6fb0fd21bb810ace4d4fdc151bf07e9123b Mon Sep 17 00:00:00 2001 From: water111 <48171810+water111@users.noreply.github.com> Date: Thu, 3 Feb 2022 22:45:41 -0500 Subject: [PATCH] [graphics] MERC (#1124) * merc dma generation * wip very early version of merc * small fixes * fix * fix more merc bugs * derp fixed min * oops we did need something weird on max * merc for everything * program optimization 1 * more optimization * windows * windows 2 * clean up * fix test * BLERC --- common/dma/dma.cpp | 5 +- common/dma/dma.h | 42 + decompiler/VuDisasm/VuDisassembler.cpp | 369 ++ decompiler/VuDisasm/VuDisassembler.h | 7 +- decompiler/VuDisasm/VuInstruction.cpp | 4 + decompiler/VuDisasm/VuInstruction.h | 3 + decompiler/analysis/mips2c.cpp | 5 + decompiler/config/all-types.gc | 12 +- .../config/jak1_ntsc_black_label/hacks.jsonc | 11 +- .../jak1_ntsc_black_label/type_casts.jsonc | 23 +- game/CMakeLists.txt | 3 + .../graphics/opengl_renderer/BucketRenderer.h | 9 + .../opengl_renderer/DirectRenderer.cpp | 37 +- game/graphics/opengl_renderer/MercProgram.cpp | 5401 +++++++++++++++++ .../graphics/opengl_renderer/MercRenderer.cpp | 346 ++ game/graphics/opengl_renderer/MercRenderer.h | 539 ++ .../opengl_renderer/OpenGLRenderer.cpp | 142 +- .../opengl_renderer/shaders/direct_basic.vert | 2 +- .../shaders/direct_basic_textured.frag | 2 +- .../opengl_renderer/tfrag/tfrag_common.cpp | 2 +- game/mips2c/functions/bones.cpp | 587 ++ game/mips2c/functions/merc_blend_shape.cpp | 588 ++ game/mips2c/mips2c_private.h | 65 +- game/mips2c/mips2c_table.cpp | 16 +- goal_src/engine/anim/bones.gc | 436 +- goal_src/engine/data/art-h.gc | 2 +- goal_src/engine/dma/dma-h.gc | 18 +- goal_src/engine/draw/drawable.gc | 39 +- goal_src/engine/draw/process-drawable.gc | 8 +- goal_src/engine/game/main.gc | 8 +- goal_src/engine/gfx/merc/merc-blend-shape.gc | 141 +- goal_src/engine/gfx/merc/merc.gc | 3 +- goal_src/engine/gfx/texture.gc | 7 + goal_src/engine/gfx/time-of-day.gc | 6 +- goal_src/engine/target/logic-target.gc | 2 - goal_src/engine/target/sidekick.gc | 6 +- .../reference/engine/draw/drawable_REF.gc | 4 +- .../reference/engine/entity/entity_REF.gc | 2 +- .../reference/engine/game/main-h_REF.gc | 4 +- .../reference/engine/gfx/merc/merc_REF.gc | 2 - test/decompiler/test_VuDisasm.cpp | 14 + 41 files changed, 8811 insertions(+), 111 deletions(-) create mode 100644 game/graphics/opengl_renderer/MercProgram.cpp create mode 100644 game/graphics/opengl_renderer/MercRenderer.cpp create mode 100644 game/graphics/opengl_renderer/MercRenderer.h create mode 100644 game/mips2c/functions/merc_blend_shape.cpp diff --git a/common/dma/dma.cpp b/common/dma/dma.cpp index 48347dc573..71e652be68 100644 --- a/common/dma/dma.cpp +++ b/common/dma/dma.cpp @@ -53,7 +53,7 @@ std::string VifCode::print() { result = "FLUSHA"; break; case Kind::MSCAL: - result = "MSCAL"; + result = fmt::format("MSCAL 0x{:x}", immediate); break; case Kind::MSCNT: result = "MSCNT"; @@ -109,10 +109,9 @@ std::string VifCode::print() { default: fmt::print("Unhandled vif code {}\n", (int)kind); - assert(false); result = "???"; - // assert(false); + assert(false); break; } // TODO: the rest of the VIF code. diff --git a/common/dma/dma.h b/common/dma/dma.h index 667c103470..8d58285cd9 100644 --- a/common/dma/dma.h +++ b/common/dma/dma.h @@ -52,6 +52,48 @@ struct DmaTag { std::string print(); }; +inline void emulate_dma(const void* source_base, void* dest_base, u32 tadr, u32 dadr) { + const u8* src = (const u8*)source_base; + u8* dst = (u8*)dest_base; + + u32 dest_offset = dadr; + while (true) { + u64 tag_data; + memcpy(&tag_data, src + tadr, 8); + DmaTag tag(tag_data); + + switch (tag.kind) { + case DmaTag::Kind::CNT: + memcpy(dst + dest_offset, src + tadr, (1 + tag.qwc) * 16); + dest_offset += (1 + tag.qwc) * 16; + tadr += 16 + tag.qwc * 16; + break; + case DmaTag::Kind::REF: { + // tte + memcpy(dst + dest_offset, src + tadr, 16); + dest_offset += 16; + + memcpy(dst + dest_offset, src + tag.addr, tag.qwc * 16); + dest_offset += tag.qwc * 16; + tadr += 16; + } break; + case DmaTag::Kind::REFE: { + // tte + memcpy(dst + dest_offset, src + tadr, 16); + dest_offset += 16; + + memcpy(dst + dest_offset, src + tag.addr, tag.qwc * 16); + dest_offset += tag.qwc * 16; + tadr += 16; + return; + } break; + default: + printf("bad tag: %d\n", (int)tag.kind); + assert(false); + } + } +} + struct VifCode { enum class Kind : u8 { NOP = 0b0, diff --git a/decompiler/VuDisasm/VuDisassembler.cpp b/decompiler/VuDisasm/VuDisassembler.cpp index 55f849de02..73b969b8d9 100644 --- a/decompiler/VuDisasm/VuDisassembler.cpp +++ b/decompiler/VuDisasm/VuDisassembler.cpp @@ -575,8 +575,286 @@ char bc_to_part(int x) { return '?'; } } + +std::string mask_to_string(u8 val) { + std::string result; + if (val & 8) { + result += 'x'; + } + if (val & 4) { + result += 'y'; + } + if (val & 2) { + result += 'z'; + } + if (val & 1) { + result += 'w'; + } + return result; +} } // namespace +int unk = 0; +std::string VuDisassembler::to_cpp(const VuInstruction& instr) const { + switch (instr.kind) { + case VuInstrK::NOP: + case VuInstrK::LOWER_NOP: + return "/* nop */"; + case VuInstrK::LQ: + if (instr.src.at(1).is_int_reg(0)) { + return fmt::format("lq_buffer(Mask::{}, vu.{}, {});", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names)); + } else if (instr.src.at(0).value() == 0) { + return fmt::format("lq_buffer(Mask::{}, vu.{}, vu.{});", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + } else { + return fmt::format("lq_buffer(Mask::{}, vu.{}, vu.{} + {});", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(1).to_string(m_label_names), + instr.src.at(0).to_string(m_label_names)); + } + goto unknown; + case VuInstrK::LQI: + return fmt::format("lq_buffer(Mask::{}, vu.{}, vu.{}++);", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names)); + case VuInstrK::SQI: + return fmt::format("sq_buffer(Mask::{}, vu.{}, vu.{}++);", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names)); + case VuInstrK::SQ: + if (instr.src.at(1).is_int_reg(0)) { + return fmt::format("sq_buffer(Mask::{}, vu.{}, {});", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names)); + } else if (instr.src.at(0).value() == 0) { + return fmt::format("sq_buffer(Mask::{}, vu.{}, vu.{});", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + } else { + return fmt::format("sq_buffer(Mask::{}, vu.{}, vu.{} + {});", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(1).to_string(m_label_names), + instr.src.at(0).to_string(m_label_names)); + } + goto unknown; + case VuInstrK::IADDI: + if (instr.src.at(0).is_int_reg(0)) { + return fmt::format("vu.{} = {};", instr.dst->to_string(m_label_names), + (s16)instr.src.at(1).value()); + } else { + return fmt::format("vu.{} = vu.{} + {};", instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names), (s16)instr.src.at(1).value()); + } + + case VuInstrK::IADDIU: + if (instr.src.at(0).is_int_reg(0)) { + return fmt::format("vu.{} = 0x{:x}; /* {} */\n", instr.dst->to_string(m_label_names), + (u16)instr.src.at(1).value(), instr.src.at(1).value()); + } else { + return fmt::format("vu.{} = vu.{} + 0x{:x}; /* {} */", instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names), (u16)instr.src.at(1).value(), + instr.src.at(1).value()); + } + + case VuInstrK::ISW: + if (instr.src.at(2).is_int_reg(0)) { + return fmt::format("isw_buffer(Mask::{}, vu.{}, {});", mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + } else { + return fmt::format("isw_buffer(Mask::{}, vu.{}, vu.{} + {});", mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names), + instr.src.at(2).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + } + goto unknown; + + case VuInstrK::ISWR: + return fmt::format("isw_buffer(Mask::{}, vu.{}, vu.{});", mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + + case VuInstrK::ILWR: + return fmt::format("ilw_buffer(Mask::{}, vu.{}, vu.{});", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names)); + + case VuInstrK::ILW: + if (instr.src.at(1).is_int_reg(0)) { + return fmt::format("ilw_buffer(Mask::{}, vu.{}, {});", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names)); + } else { + return fmt::format("ilw_buffer(Mask::{}, vu.{}, vu.{} + {});", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(1).to_string(m_label_names), + instr.src.at(0).to_string(m_label_names)); + } + + case VuInstrK::ISUBIU: + if (instr.src.at(0).is_int_reg(0)) { + return fmt::format("vu.{} = -{};\n", instr.dst->to_string(m_label_names), + instr.src.at(1).value()); + } else { + return fmt::format("vu.{} = vu.{} - 0x{:x}; /* {} */", instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names), (u16)instr.src.at(1).value(), + instr.src.at(1).value()); + } + + case VuInstrK::MTIR: + return fmt::format("vu.{} = vu.{}.{}_as_u16();", instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names), + bc_to_part(*instr.first_src_field)); + + case VuInstrK::MFIR: + return fmt::format("vu.{}.mfir(Mask::{}, vu.{});", instr.dst->to_string(m_label_names), + mask_to_string(*instr.mask), instr.src.at(0).to_string(m_label_names)); + + case VuInstrK::B: + return fmt::format("bc = true;", instr.src.at(0).to_string(m_label_names)); + + case VuInstrK::IBGTZ: + return fmt::format("bc = ((s16)vu.{}) > 0;", instr.src.at(0).to_string(m_label_names)); + + case VuInstrK::IBGEZ: + return fmt::format("bc = ((s16)vu.{}) >= 0;", instr.src.at(0).to_string(m_label_names)); + + case VuInstrK::IBEQ: + if (instr.src.at(0).is_int_reg(0)) { + return fmt::format("bc = (vu.{} == 0);", instr.src.at(1).to_string(m_label_names)); + } else { + return fmt::format("bc = (vu.{} == vu.{});", instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + } + + case VuInstrK::IBNE: + if (instr.src.at(0).is_int_reg(0)) { + return fmt::format("bc = (vu.{} != 0);", instr.src.at(1).to_string(m_label_names)); + } else { + return fmt::format("bc = (vu.{} != vu.{});", instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + } + + case VuInstrK::IADD: + return fmt::format("vu.{} = vu.{} + vu.{};", instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + case VuInstrK::ISUB: + return fmt::format("vu.{} = vu.{} - vu.{};", instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + case VuInstrK::IAND: + return fmt::format("vu.{} = vu.{} & vu.{};", instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + case VuInstrK::IOR: + if (instr.src.at(1).is_int_reg(0)) { + return fmt::format("vu.{} = vu.{};", instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names)); + } else { + goto unknown; + } + + case VuInstrK::MFP: + return fmt::format("vu.{}.mfp(Mask::{}, vu.P);", instr.dst->to_string(m_label_names), + mask_to_string(*instr.mask)); + + case VuInstrK::MULq: + return fmt::format("vu.{}.mul(Mask::{}, vu.{}, vu.Q); /* TODO mulq */", + instr.dst->to_string(m_label_names), mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names)); + case VuInstrK::DIV: + return fmt::format( + "vu.Q = vu.{}.{}() / vu.{}.{}();\n", instr.src.at(0).to_string(m_label_names), + bc_to_part(*instr.first_src_field), instr.src.at(1).to_string(m_label_names), + bc_to_part(*instr.second_src_field)); + + case VuInstrK::ERLENG: + return fmt::format("vu.P = erleng(Mask::{}, vu.{}); /* TODO erleng */", + mask_to_string(*instr.mask), instr.src.at(0).to_string(m_label_names)); + + case VuInstrK::MR32: + case VuInstrK::MOVE: + case VuInstrK::ITOF0: + case VuInstrK::ITOF15: + case VuInstrK::FTOI0: + case VuInstrK::FTOI4: + return fmt::format("vu.{}.{}(Mask::{}, vu.{});", instr.dst->to_string(m_label_names), + info(instr.kind).name, mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names)); + + case VuInstrK::ADDbc: + case VuInstrK::MULbc: + case VuInstrK::MINIbc: + case VuInstrK::MAXbc: + return fmt::format("vu.{}.{}(Mask::{}, vu.{}, vu.{}.{}());", + instr.dst->to_string(m_label_names), info(instr.kind).name, + mask_to_string(*instr.mask), instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names), bc_to_part(*instr.bc)); + + case VuInstrK::FP_CONSTANT: + return fmt::format("vu.I = {};", float_to_string(instr.fp)); + + case VuInstrK::MINIi: + case VuInstrK::MAXi: + return fmt::format("vu.{}.{}(Mask::{}, vu.{}, vu.I);", instr.dst->to_string(m_label_names), + info(instr.kind).name, mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names)); + + case VuInstrK::MUL: + case VuInstrK::ADD: + case VuInstrK::MAX: + case VuInstrK::MINI: + return fmt::format("vu.{}.{}(Mask::{}, vu.{}, vu.{});", instr.dst->to_string(m_label_names), + info(instr.kind).name, mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + + case VuInstrK::ADDAbc: + return fmt::format("vu.acc.adda(Mask::{}, vu.{}, vu.{}.{}());", mask_to_string(*instr.mask), + instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names), bc_to_part(*instr.bc)); + case VuInstrK::MADDA: + return fmt::format("vu.acc.madda(Mask::{}, vu.{}, vu.{});", mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + case VuInstrK::MADDAbc: + return fmt::format("vu.acc.madda(Mask::{}, vu.{}, vu.{}.{}());", mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names), bc_to_part(*instr.bc)); + case VuInstrK::MADDbc: + return fmt::format("vu.acc.madd(Mask::{}, vu.{}, vu.{}, vu.{}.{}());", + mask_to_string(*instr.mask), instr.dst->to_string(m_label_names), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names), bc_to_part(*instr.bc)); + case VuInstrK::MULA: + return fmt::format("vu.acc.mula(Mask::{}, vu.{}, vu.{});", mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names)); + case VuInstrK::MULAbc: + return fmt::format("vu.acc.mula(Mask::{}, vu.{}, vu.{}.{}());", mask_to_string(*instr.mask), + instr.src.at(0).to_string(m_label_names), + instr.src.at(1).to_string(m_label_names), bc_to_part(*instr.bc)); + + case VuInstrK::XGKICK: + return fmt::format("xgkick(vu.{});", instr.src.at(0).to_string(m_label_names)); + + case VuInstrK::XTOP: + return fmt::format("vu.{} = xtop();", instr.src.at(0).to_string(m_label_names)); + default: + unk++; + return "???"; + } + +unknown: + + unk++; + return "???"; +} + std::string VuDisassembler::to_string(const VuInstruction& instr) const { if (instr.kind == VuInstrK::FP_CONSTANT) { return float_to_string(instr.fp); @@ -719,6 +997,11 @@ int VuDisassembler::add_label(int instr) { } } +void VuDisassembler::add_label_with_name(int instr, const std::string& name) { + add_label(instr); + m_user_named_instructions[instr] = name; +} + void VuDisassembler::name_labels() { std::vector instrs_with_labels; for (auto [instr, label_idx] : m_labels) { @@ -732,5 +1015,91 @@ void VuDisassembler::name_labels() { auto label_idx = m_labels.at(instr); m_label_names.at(label_idx) = fmt::format("L{}", idx++); } + + for (auto& kv : m_user_named_instructions) { + m_label_names.at(m_labels.at(kv.first)) = kv.second; + } +} + +bool has_branch_delay(const VuInstructionPair& pair) { + switch (pair.lower.kind) { + case VuInstrK::JALR: + // case VuInstrK::JR: it does, but it's not supported + case VuInstrK::IBGTZ: + case VuInstrK::IBNE: + case VuInstrK::IBEQ: + case VuInstrK::B: + case VuInstrK::BAL: + case VuInstrK::IBLTZ: + case VuInstrK::IBLEZ: + case VuInstrK::IBGEZ: + return true; + default: + return false; + } +} + +std::string get_label_name(const VuInstructionPair& pair, + const std::vector& label_names) { + for (auto& arg : pair.lower.src) { + if (arg.kind() == VuInstructionAtom::Kind::LABEL) { + return arg.to_string(label_names); + } + } + assert(false); +} + +std::string VuDisassembler::to_string_with_cpp(const VuProgram& prog) const { + std::string result; + for (int i = 0; i < (int)prog.instructions().size(); i++) { + auto lab = m_labels.find(i); + if (lab != m_labels.end()) { + result += m_label_names.at(lab->second); + result += ':'; + result += '\n'; + } + auto& pair = prog.instructions().at(i); + if (has_branch_delay(pair)) { + result += "// BRANCH!\n"; + // set bc + result += to_string_with_cpp(prog.instructions().at(i)); + result += "\n"; + result += to_string_with_cpp(prog.instructions().at(i + 1)); + result += "\n"; + result += fmt::format("if (bc) {{ goto {}; }}\n", get_label_name(pair, m_label_names)); + result += "\n\n"; + i++; + } else { + result += to_string_with_cpp(prog.instructions().at(i)); + result += '\n'; + } + } + fmt::print("TOTAL unk: {}\n", unk); + return result; +} + +namespace { +bool is_nop(const VuInstruction& i) { + return i.kind == VuInstrK::NOP || i.kind == VuInstrK::LOWER_NOP; +} +} // namespace +std::string VuDisassembler::to_string_with_cpp(const VuInstructionPair& pair) const { + std::string result; + result += fmt::format(" // {:25s} | {:30s}\n", to_string(pair.lower), to_string(pair.upper)); + + if (!is_nop(pair.lower) && !is_nop(pair.upper) && pair.lower.kind == VuInstrK::FP_CONSTANT) { + result += fmt::format(" {:25s}", to_cpp(pair.upper)); + result += fmt::format(" {:25s}", to_cpp(pair.lower)); + } else { + if (!is_nop(pair.upper)) { + result += fmt::format(" {:25s}", to_cpp(pair.upper)); + } + + if (!is_nop(pair.lower)) { + result += fmt::format(" {:25s}", to_cpp(pair.lower)); + } + } + + return result; } } // namespace decompiler diff --git a/decompiler/VuDisasm/VuDisassembler.h b/decompiler/VuDisasm/VuDisassembler.h index f283a0d36f..6e11a590a7 100644 --- a/decompiler/VuDisasm/VuDisassembler.h +++ b/decompiler/VuDisasm/VuDisassembler.h @@ -57,8 +57,13 @@ class VuDisassembler { VuDisassembler(VuKind kind); VuProgram disassemble(void* data, int size_bytes, bool debug_print = false); std::string to_string(const VuInstruction& instr) const; + std::string to_cpp(const VuInstruction& instr) const; std::string to_string(const VuInstructionPair& pair) const; + std::string to_string_with_cpp(const VuInstructionPair& pair) const; std::string to_string(const VuProgram& prog) const; + std::string to_string_with_cpp(const VuProgram& prog) const; + int add_label(int instr); + void add_label_with_name(int instr, const std::string& name); private: VuKind m_kind; @@ -66,6 +71,7 @@ class VuDisassembler { VuInstrK lower_kind(u32 in); VuInstruction decode(VuInstrK kind, u32 data, int instr_idx); s32 get_instruction_index_mask(); + std::unordered_map m_user_named_instructions; struct VuUpperOp6 { bool goto_11 = false; @@ -225,7 +231,6 @@ class VuDisassembler { std::unordered_map m_labels; std::vector m_label_names; - int add_label(int instr); void name_labels(); OpInfo& add_op(VuInstrK kind, const std::string& name); diff --git a/decompiler/VuDisasm/VuInstruction.cpp b/decompiler/VuDisasm/VuInstruction.cpp index 30e8f34f60..df77afc35b 100644 --- a/decompiler/VuDisasm/VuInstruction.cpp +++ b/decompiler/VuDisasm/VuInstruction.cpp @@ -45,6 +45,10 @@ VuInstructionAtom VuInstructionAtom::make_r() { return {Kind::R}; } +bool VuInstructionAtom::is_int_reg(int idx) const { + return m_kind == Kind::VI && m_value == idx; +} + std::string VuInstructionAtom::to_string(const std::vector& labels) const { switch (m_kind) { case Kind::VF: diff --git a/decompiler/VuDisasm/VuInstruction.h b/decompiler/VuDisasm/VuInstruction.h index 94bc44cccc..365b081db8 100644 --- a/decompiler/VuDisasm/VuInstruction.h +++ b/decompiler/VuDisasm/VuInstruction.h @@ -178,8 +178,11 @@ class VuInstructionAtom { static VuInstructionAtom make_p(); static VuInstructionAtom make_r(); + bool is_int_reg(int idx) const; + std::string to_string(const std::vector& labels) const; Kind kind() const { return m_kind; } + s64 value() const { return m_value; } private: VuInstructionAtom(Kind kind, s64 idx = -1) : m_kind(kind), m_value(idx) {} diff --git a/decompiler/analysis/mips2c.cpp b/decompiler/analysis/mips2c.cpp index ef22330048..57e61b89fd 100644 --- a/decompiler/analysis/mips2c.cpp +++ b/decompiler/analysis/mips2c.cpp @@ -976,6 +976,7 @@ Mips2C_Line handle_normal_instr(Mips2C_Output& output, case InstructionKind::DSRL: case InstructionKind::SRL: case InstructionKind::PSRAW: + case InstructionKind::PSRAH: case InstructionKind::PSRLH: return handle_generic_op2_u16(i0, instr_str); case InstructionKind::SLL: @@ -1002,8 +1003,10 @@ Mips2C_Line handle_normal_instr(Mips2C_Output& output, case InstructionKind::PMINH: case InstructionKind::MOVZ: case InstructionKind::MULT3: + case InstructionKind::MULTU3: case InstructionKind::PMINW: case InstructionKind::PMAXW: + case InstructionKind::PMAXH: case InstructionKind::SUBU: case InstructionKind::DSRAV: return handle_generic_op3(i0, instr_str, {}); @@ -1073,6 +1076,8 @@ Mips2C_Line handle_normal_instr(Mips2C_Output& output, return handle_generic_op2(i0, instr_str, "sqrts"); case InstructionKind::PLZCW: return handle_generic_op2(i0, instr_str, "plzcw"); + case InstructionKind::PCPYH: + return handle_generic_op2(i0, instr_str, "pcpyh"); case InstructionKind::LUI: return handle_lui(i0, instr_str); case InstructionKind::CLTS: diff --git a/decompiler/config/all-types.gc b/decompiler/config/all-types.gc index 8add6a2d94..67ac237219 100644 --- a/decompiler/config/all-types.gc +++ b/decompiler/config/all-types.gc @@ -8040,7 +8040,7 @@ (defenum draw-status :type uint8 :bitfield #t - (drwf00 0) + (needs-clip 0) (drwf01 1) (drwf02 2) (drwf03 3) @@ -8347,7 +8347,9 @@ ) ;;effect-bits: -;; 1 - swap with last effect. +;; 0 - texture scroll +;; 1 - swap with last effect, +;; 2 - ripple (deftype merc-effect (structure) ((frag-geo merc-fragment :offset-assert 0) ;; ? @@ -16423,7 +16425,7 @@ ;; - Functions -(define-extern setup-blerc-chains-for-one-fragment function) +(define-extern setup-blerc-chains-for-one-fragment (function object object object object object object object)) (define-extern setup-blerc-chains (function merc-ctrl (pointer int16) dma-buffer none)) (define-extern blerc-stats-init (function none)) (define-extern blerc-init (function none)) @@ -16448,7 +16450,7 @@ ;; - Functions (define-extern merc-vu1-init-buffer (function bucket-id gs-test int none)) -(define-extern merc-vu1-initialize-chain (function dma-gif-packet none)) +(define-extern merc-vu1-initialize-chain (function dma-gif-packet dma-packet)) (define-extern merc-vu1-add-vu-function (function dma-packet vu-function int dma-gif-packet)) (define-extern get-eye-block (function int int int)) (define-extern merc-stats-display (function merc-ctrl none)) @@ -16619,7 +16621,7 @@ (define-extern draw-bones-generic-merc (function draw-control object object int pointer)) (define-extern draw-bones-merc (function draw-control object object int int pointer)) (define-extern draw-bones-check-longest-edge (function draw-control float none)) -(define-extern draw-bones-check-longest-edge-asm (function draw-control float none)) +(define-extern draw-bones-check-longest-edge-asm (function draw-control float symbol)) (define-extern draw-bones (function draw-control dma-buffer float none)) (define-extern draw-bones-hud (function draw-control dma-buffer none)) diff --git a/decompiler/config/jak1_ntsc_black_label/hacks.jsonc b/decompiler/config/jak1_ntsc_black_label/hacks.jsonc index f4ec297a64..bb16af8c2a 100644 --- a/decompiler/config/jak1_ntsc_black_label/hacks.jsonc +++ b/decompiler/config/jak1_ntsc_black_label/hacks.jsonc @@ -127,8 +127,6 @@ "ripple-execute-init", // bones - "draw-bones-check-longest-edge-asm", - "draw-bones-merc", "bones-mtx-calc", // generic-effect @@ -499,7 +497,8 @@ "(anon-function 21 plant-boss)": [0, 1, 3, 4], "(method 55 ram-boss)": [5], "(method 60 ice-cube)": [8], - "(anon-function 2 snow-ball)": [22] + "(anon-function 2 snow-ball)": [22], + "draw-bones-merc": [1, 3, 5, 7, 8, 10, 11, 12, 13] }, // Sometimes the game might use format strings that are fetched dynamically, @@ -578,7 +577,11 @@ "calc-animation-from-spr", "clear-frame-accumulator", "bones-mtx-calc", - "cspace<-parented-transformq-joint!" + "cspace<-parented-transformq-joint!", + "draw-bones-merc", + "draw-bones-check-longest-edge-asm", + "setup-blerc-chains-for-one-fragment", + "blerc-execute" ], "mips2c_jump_table_functions": { diff --git a/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc b/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc index c60ba39025..2caebe4f2a 100644 --- a/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc +++ b/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc @@ -7083,7 +7083,9 @@ [545, "s2", "int"], [49, "a1", "bone-calculation"], [262, "s2", "(pointer uint32)"], - [89, "at", "terrain-context"] + [89, "at", "terrain-context"], + [[312,334], "v1", "mei-envmap-tint"], + [363, "a0", "(pointer uint8)"] ], "draw-bones-hud": [ @@ -7897,5 +7899,24 @@ [20, "a0", "process-drawable"] ], + "setup-blerc-chains": [ + [43, "v1", "int"], + [80, "s0", "int"], + [83, "a0", "int"], + [[30,40], "s1", "merc-fragment-control"], + [41, "v1", "merc-fragment"], + [46, "v1", "(pointer uint8)"], + [59, "a0", "merc-blend-ctrl"], + [[64,76], "s1", "merc-fragment-control"], + [77, "a1", "merc-blend-ctrl"] + ], + + "blerc-execute": [ + [20, "a0", "(pointer int32)"], + [26, "v1", "(pointer int32)"], + [59, "a2", "(pointer int32)"], + [65, "a1", "(pointer int32)"] + ], + "placeholder-do-not-add-below": [] } diff --git a/game/CMakeLists.txt b/game/CMakeLists.txt index 00309d7302..b7f8dafeba 100644 --- a/game/CMakeLists.txt +++ b/game/CMakeLists.txt @@ -68,6 +68,7 @@ set(RUNTIME_SOURCE mips2c/functions/collide_probe.cpp mips2c/functions/draw_string.cpp mips2c/functions/joint.cpp + mips2c/functions/merc_blend_shape.cpp mips2c/functions/sky_tng.cpp mips2c/functions/sparticle.cpp mips2c/functions/sparticle_launcher.cpp @@ -97,6 +98,8 @@ set(RUNTIME_SOURCE graphics/opengl_renderer/DirectRenderer.cpp graphics/opengl_renderer/dma_helpers.cpp graphics/opengl_renderer/Loader.cpp + graphics/opengl_renderer/MercProgram.cpp + graphics/opengl_renderer/MercRenderer.cpp graphics/opengl_renderer/OpenGLRenderer.cpp graphics/opengl_renderer/Profiler.cpp graphics/opengl_renderer/Shader.cpp diff --git a/game/graphics/opengl_renderer/BucketRenderer.h b/game/graphics/opengl_renderer/BucketRenderer.h index 796c897887..af598ea697 100644 --- a/game/graphics/opengl_renderer/BucketRenderer.h +++ b/game/graphics/opengl_renderer/BucketRenderer.h @@ -18,9 +18,11 @@ enum class BucketId { TFRAG_TEX_LEVEL0 = 5, TFRAG_LEVEL0 = 6, TIE_LEVEL0 = 9, + MERC_TFRAG_TEX_LEVEL0 = 10, TFRAG_TEX_LEVEL1 = 12, TFRAG_LEVEL1 = 13, TIE_LEVEL1 = 16, + MERC_TFRAG_TEX_LEVEL1 = 17, SHRUB_TEX_LEVEL0 = 19, SHRUB_TEX_LEVEL1 = 25, ALPHA_TEX_LEVEL0 = 31, @@ -31,10 +33,16 @@ enum class BucketId { TFRAG_TRANS1_AND_SKY_BLEND_LEVEL1 = 39, TFRAG_DIRT_LEVEL1 = 41, TFRAG_ICE_LEVEL1 = 43, + MERC_AFTER_ALPHA = 45, PRIS_TEX_LEVEL0 = 48, + MERC_PRIS_LEVEL0 = 49, PRIS_TEX_LEVEL1 = 51, + MERC_PRIS_LEVEL1 = 52, + MERC_AFTER_PRIS = 55, WATER_TEX_LEVEL0 = 57, + MERC_WATER_LEVEL0 = 58, WATER_TEX_LEVEL1 = 60, + MERC_WATER_LEVEL1 = 61, // ... PRE_SPRITE_TEX = 65, // maybe it's just common textures? SPRITE = 66, @@ -69,6 +77,7 @@ struct SharedRenderState { bool use_sky_cpu = true; bool use_occlusion_culling = true; + bool render_debug = false; void reset(); bool has_camera_planes = false; diff --git a/game/graphics/opengl_renderer/DirectRenderer.cpp b/game/graphics/opengl_renderer/DirectRenderer.cpp index 374299455e..120898f0c4 100644 --- a/game/graphics/opengl_renderer/DirectRenderer.cpp +++ b/game/graphics/opengl_renderer/DirectRenderer.cpp @@ -244,7 +244,7 @@ void DirectRenderer::update_gl_prim(SharedRenderState* render_state) { // currently gouraud is handled in setup. const auto& state = m_prim_gl_state; if (state.texture_enable) { - float alpha_reject = 0.; + float alpha_reject = 0.0; if (m_test_state.alpha_test_enable) { switch (m_test_state.alpha_test) { case GsTest::AlphaTest::ALWAYS: @@ -310,10 +310,11 @@ void DirectRenderer::update_gl_texture(SharedRenderState* render_state, int unit if (!tex) { // TODO Add back - fmt::print("Failed to find texture at {}, using random\n", state.texture_base_ptr); - tex = render_state->texture_pool->get_random_texture(); - if (tex) { - // fmt::print("Successful texture lookup! {} {}\n", tex->page_name, tex->name); + if (state.texture_base_ptr >= 8160 && state.texture_base_ptr <= 8600) { + tex = render_state->texture_pool->get_random_texture(); + } else { + fmt::print("Failed to find texture at {}, using random\n", state.texture_base_ptr); + tex = render_state->texture_pool->get_random_texture(); } } assert(tex); @@ -367,6 +368,7 @@ void DirectRenderer::update_gl_blend() { // (Cs - 0) * As + Cd // Cs * As + (1) * Cd // s, d + assert(state.fix == 0); glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendEquation(GL_FUNC_ADD); } else if (state.a == GsAlpha::BlendMode::ZERO_OR_FIXED && @@ -377,11 +379,19 @@ void DirectRenderer::update_gl_blend() { // s, d glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendEquation(GL_FUNC_REVERSE_SUBTRACT); + } else if (state.a == GsAlpha::BlendMode::SOURCE && state.b == GsAlpha::BlendMode::DEST && + state.c == GsAlpha::BlendMode::ZERO_OR_FIXED && + state.d == GsAlpha::BlendMode::DEST) { + // (Cs - Cd) * fix + Cd + // Cs * fix + (1 - fx) * Cd + glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA); + glBlendColor(0, 0, 0, state.fix / 127.f); + glBlendEquation(GL_FUNC_ADD); } else { // unsupported blend: a 0 b 2 c 2 d 1 - lg::error("unsupported blend: a {} b {} c {} d {} NOTE THIS DOWN IMMEDIATELY!!", (int)state.a, - (int)state.b, (int)state.c, (int)state.d); - assert(false); + lg::error("unsupported blend: a {} b {} c {} d {}", (int)state.a, (int)state.b, (int)state.c, + (int)state.d); + // assert(false); } } } @@ -408,6 +418,7 @@ void DirectRenderer::update_gl_test() { assert(false); } } else { + // you aren't supposed to turn off z test enable, the GS had some bugs assert(false); } @@ -699,7 +710,6 @@ void DirectRenderer::handle_tex0_1(u64 val, SharedRenderState* render_state, ScopedProfilerNode& prof) { GsTex0 reg(val); - // update tbp if (current_texture_state()->current_register != reg) { if (current_texture_state()->used) { @@ -726,7 +736,8 @@ void DirectRenderer::handle_tex0_1(u64 val, // tw: assume they got it right // th: assume they got it right - assert(reg.tfx() == GsTex0::TextureFunction::MODULATE); + // MERC hack + // assert(reg.tfx() == GsTex0::TextureFunction::MODULATE); // cbp: assume they got it right // cpsm: assume they got it right @@ -832,8 +843,8 @@ void DirectRenderer::handle_clamp1(u64 val, SharedRenderState* render_state, ScopedProfilerNode& prof) { if (!(val == 0b101 || val == 0 || val == 1 || val == 0b100)) { - fmt::print("clamp: 0x{:x}\n", val); - assert(false); + // fmt::print("clamp: 0x{:x}\n", val); + // assert(false); } if (current_texture_state()->m_clamp_state.current_register != val) { @@ -1089,8 +1100,6 @@ void DirectRenderer::BlendState::from_register(GsAlpha reg) { c = reg.c_mode(); d = reg.d_mode(); fix = reg.fix(); - - assert(fix == 0); } void DirectRenderer::PrimGlState::from_register(GsPrim reg) { diff --git a/game/graphics/opengl_renderer/MercProgram.cpp b/game/graphics/opengl_renderer/MercProgram.cpp new file mode 100644 index 0000000000..883547f768 --- /dev/null +++ b/game/graphics/opengl_renderer/MercProgram.cpp @@ -0,0 +1,5401 @@ +#include "game/graphics/opengl_renderer/MercRenderer.h" + +void MercRenderer::mscal(int enter_address, + SharedRenderState* render_state, + ScopedProfilerNode& prof) { + if (render_state->render_debug) { + mscal_impl(enter_address, render_state, prof); + } else { + mscal_impl(enter_address, render_state, prof); + } +} + +static inline REALLY_INLINE float erleng(const Vf& in) { + float len = in.x() * in.x() + in.y() * in.y() + in.z() * in.z(); + return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(len))); +} + +u16 MercRenderer::xitop() { + return m_dbf ? BUFFER_BASE : 0; +} + +u16 MercRenderer::xtop() { + return m_dbf ? 0 : BUFFER_BASE; +} + +void MercRenderer::lq_buffer(Mask mask, Vf& dest, u16 addr) { + assert(addr * 16 < sizeof(m_buffer.data)); + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + memcpy(dest.data + i, m_buffer.data + addr * 16 + i * 4, 4); + } + } +} + +template +REALLY_INLINE void MercRenderer::lq_buffer_xyzw(Vf& dest, u16 addr) { + if constexpr (DEBUG) { + assert(addr * 16 < sizeof(m_buffer.data)); + } + copy_vector(dest.data, m_buffer.data + addr * 16); +} + +template +REALLY_INLINE void MercRenderer::lq_buffer_xyz(Vf& dest, u16 addr) { + if constexpr (DEBUG) { + assert(addr * 16 < sizeof(m_buffer.data)); + } + auto reg = _mm_load_ps(dest.data); + auto mem = _mm_load_ps((const float*)(m_buffer.data + addr * 16)); + _mm_store_ps(dest.data, _mm_blend_ps(mem, reg, 0b1000)); +} + +template +REALLY_INLINE void MercRenderer::sq_buffer_xyzw(const Vf& src, u16 addr) { + if constexpr (DEBUG) { + assert(addr * 16 < sizeof(m_buffer.data)); + } + copy_vector(m_buffer.data + addr * 16, src.data); +} + +void MercRenderer::isw_buffer(Mask mask, u16 val, u16 addr) { + assert(addr * 16 < sizeof(m_buffer.data)); + u32 val32 = val; + int offset; + switch (mask) { + case Mask::x: + offset = 0; + break; + case Mask::y: + offset = 4; + break; + case Mask::z: + offset = 8; + break; + case Mask::w: + offset = 12; + break; + default: + assert(false); + } + memcpy(m_buffer.data + addr * 16 + offset, &val32, 4); +} + +void MercRenderer::ilw_buffer(Mask mask, u16& dest, u16 addr) { + // fmt::print("addr is {}\n", addr); + assert(addr * 16 < sizeof(m_buffer.data)); + int offset; + switch (mask) { + case Mask::x: + offset = 0; + break; + case Mask::y: + offset = 4; + break; + case Mask::z: + offset = 8; + break; + case Mask::w: + offset = 12; + break; + default: + assert(false); + } + memcpy(&dest, m_buffer.data + addr * 16 + offset, 2); +} + +// clang-format off +template +void MercRenderer::mscal_impl(int enter_address, + SharedRenderState* render_state, + ScopedProfilerNode& prof) { + bool bc = false; + // bool bc = false; + switch (enter_address) { + case 0: + goto ENTER_0; + case 17: + goto ENTER_17; + case 20: + goto ENTER_20; + case 32: + goto ENTER_32; + case 35: + goto ENTER_35; + default: + assert(false); + } + ENTER_0: + // lq.xyzw vf01, 7(vi00) | nop + lq_buffer_xyzw(vu.vf01, 7); + // lq.xyzw vf25, 3(vi00) | nop + lq_buffer_xyzw(vu.vf25, 3); + // lq.xyzw vf26, 4(vi00) | nop + lq_buffer_xyzw(vu.vf26, 4); + // lq.xyzw vf27, 5(vi00) | nop + lq_buffer_xyzw(vu.vf27, 5); + // lq.xyzw vf28, 6(vi00) | nop + lq_buffer_xyzw(vu.vf28, 6); + // mr32.xyzw vf01, vf01 | nop + vu.vf01.mr32(Mask::xyzw, vu.vf01); + // move.y vf25, vf26 | nop + vu.vf25.move(Mask::y, vu.vf26); + // move.zw vf25, vf27 | nop + vu.vf25.move(Mask::zw, vu.vf27); + // sq.xyzw vf25, 3(vi00) | nop + sq_buffer_xyzw(vu.vf25, 3); + // 2048.0 | nop :i + vu.I = 2048.0; + // 255.0 | maxi.x vf17, vf00, I :i + vu.vf17.maxi(Mask::x, vu.vf00, vu.I); vu.I = 255.0; + // -65537.0 | maxi.y vf17, vf00, I :i + vu.vf17.maxi(Mask::y, vu.vf00, vu.I); vu.I = -65537.0; + // mr32.xyzw vf02, vf01 | minii.z vf17, vf00, I + vu.vf17.minii(Mask::z, vu.vf00, vu.I); vu.vf02.mr32(Mask::xyzw, vu.vf01); + // lq.xyzw vf22, 2(vi00) | minii.z vf18, vf00, I + vu.vf18.minii(Mask::z, vu.vf00, vu.I); lq_buffer_xyzw(vu.vf22, 2); + // 0.003921569 | minii.z vf19, vf00, I :i + vu.vf19.minii(Mask::z, vu.vf00, vu.I); vu.I = 0.003921569; + // sq.xyzw vf28, 4(vi00) | minii.w vf29, vf00, I :e + vu.vf29.minii(Mask::w, vu.vf00, vu.I); sq_buffer_xyzw(vu.vf28, 4); + // mr32.xyzw vf03, vf02 | nop + vu.vf03.mr32(Mask::xyzw, vu.vf02); + return; + + ENTER_17: + // iaddi vi07, vi00, 0x1 | nop + vu.vi07 = 1; +// BRANCH! + // b L2 | nop + bc = true; + // isw.w vi07, 1(vi00) | nop + isw_buffer(Mask::w, vu.vi07, 1); + if (bc) { goto L2; } + + + ENTER_20: + // iaddi vi07, vi00, 0x0 | nop + vu.vi07 = 0; + L2: + // lq.xyzw vf25, 139(vi00) | nop + lq_buffer_xyzw(vu.vf25, 139); + // lq.xyzw vf26, 3(vi00) | nop + lq_buffer_xyzw(vu.vf26, 3); + // lq.xyz vf01, 132(vi00) | nop + lq_buffer_xyz(vu.vf01, 132); + // lq.xyz vf02, 133(vi00) | nop + lq_buffer_xyz(vu.vf02, 133); + // lq.xyz vf03, 134(vi00) | addy.xy vf19, vf00, vf25 + vu.vf19.add(Mask::xy, vu.vf00, vu.vf25.y()); lq_buffer_xyz(vu.vf03, 134); + // lq.xyzw vf04, 135(vi00) | mulx.xyzw vf26, vf26, vf25 + vu.vf26.mul_xyzw(vu.vf26, vu.vf25.x()); lq_buffer_xyzw(vu.vf04, 135); + // lq.xyzw vf05, 136(vi00) | nop + lq_buffer_xyzw(vu.vf05, 136); + // lq.xyzw vf06, 137(vi00) | nop + lq_buffer_xyzw(vu.vf06, 137); + // lq.xyzw vf07, 138(vi00) | nop + lq_buffer_xyzw(vu.vf07, 138); +// BRANCH! + // b L4 | nop + bc = true; + // sq.xyzw vf26, 5(vi00) | nop + sq_buffer_xyzw(vu.vf26, 5); + if (bc) { goto L4; } + + ENTER_32: + + // iaddi vi07, vi00, 0x1 | nop + vu.vi07 = 1; +// BRANCH! + // b L4 | nop + bc = true; + // isw.w vi07, 1(vi00) | nop + isw_buffer(Mask::w, vu.vi07, 1); + if (bc) { goto L4; } + + + ENTER_35: + // iaddi vi07, vi00, 0x0 | nop + vu.vi07 = 0; + L4: + // lq.xyzw vf28, 139(vi00) | minix.xyzw vf15, vf00, vf00 + vu.vf15.mini_xyzw(vu.vf00, vu.vf00.x()); lq_buffer_xyzw(vu.vf28, 139); + // xtop vi15 | nop + vu.vi15 = xtop(); + // iaddiu vi12, vi15, 0x8c | nop + vu.vi12 = vu.vi15 + 0x8c; /* 140 */ +// BRANCH! + // ibeq vi00, vi15, L5 | nop + bc = (vu.vi15 == 0); + // ilwr.w vi03, vi12 | maxz.xy vf18, vf00, vf28 + vu.vf18.max(Mask::xy, vu.vf00, vu.vf28.z()); ilw_buffer(Mask::w, vu.vi03, vu.vi12); + if (bc) { goto L5; } + + + // nop | maxw.xy vf18, vf00, vf28 + vu.vf18.max(Mask::xy, vu.vf00, vu.vf28.w()); + L5: + // ilw.w vi10, 133(vi00) | nop + ilw_buffer(Mask::w, vu.vi10, 133); + // iaddiu vi15, vi15, 0x173 | nop + vu.vi15 = vu.vi15 + 0x173; /* 371 */ + // ilw.y vi02, 2(vi12) | nop + ilw_buffer(Mask::y, vu.vi02, vu.vi12 + 2); + // lq.xyzw vf14, 0(vi00) | nop + lq_buffer_xyzw(vu.vf14, 0); +// BRANCH! + // ibeq vi00, vi10, L6 | nop + bc = (vu.vi10 == 0); + // iadd vi03, vi03, vi12 | nop + vu.vi03 = vu.vi03 + vu.vi12; + if (bc) { goto L6; } + + + // mr32.xyzw vf27, vf14 | nop + vu.vf27.mr32(Mask::xyzw, vu.vf14); + // ilw.w vi11, 134(vi00) | nop + ilw_buffer(Mask::w, vu.vi11, 134); + // iaddiu vi13, vi00, 0x42 | nop + vu.vi13 = 0x42; /* 66 */ + + // mr32.y vf14, vf27 | nop + vu.vf14.mr32(Mask::y, vu.vf27); + L6: + // ilwr.w vi09, vi03 | nop + ilw_buffer(Mask::w, vu.vi09, vu.vi03); + // lqi.xyzw vf27, vi03 | nop + lq_buffer_xyzw(vu.vf27, vu.vi03++); + // ilw.x vi04, 1(vi12) | nop + ilw_buffer(Mask::x, vu.vi04, vu.vi12 + 1); + // iaddiu vi05, vi00, 0x7f | addw.xyz vf15, vf15, vf00 + vu.vf15.add(Mask::xyz, vu.vf15, vu.vf00.w()); vu.vi05 = 0x7f; /* 127 */ + + // iand vi09, vi09, vi05 | nop + vu.vi09 = vu.vi09 & vu.vi05; + // ilw.y vi06, 1(vi12) | miniz.w vf19, vf00, vf27 + vu.vf19.mini(Mask::w, vu.vf00, vu.vf27.z()); ilw_buffer(Mask::y, vu.vi06, vu.vi12 + 1); +// BRANCH! + // ibeq vi00, vi02, L8 | miniy.w vf18, vf00, vf27 + vu.vf18.mini(Mask::w, vu.vf00, vu.vf27.y()); bc = (vu.vi02 == 0); + // ilwr.z vi01, vi12 | minix.w vf17, vf00, vf27 + vu.vf17.mini(Mask::w, vu.vf00, vu.vf27.x()); ilw_buffer(Mask::z, vu.vi01, vu.vi12); + if (bc) { goto L8; } + + +// BRANCH! + // ibne vi00, vi09, L7 | nop + bc = (vu.vi09 != 0); + // sq.yzw vf14, 0(vi15) | nop + sq_buffer(Mask::yzw, vu.vf14, vu.vi15); + if (bc) { goto L7; } + + + // iaddiu vi02, vi02, 0x4000 | nop + vu.vi02 = vu.vi02 + 0x4000; /* 16384 */ + // iaddiu vi02, vi02, 0x4000 | nop + vu.vi02 = vu.vi02 + 0x4000; /* 16384 */ + // iswr.x vi02, vi15 | nop + isw_buffer(Mask::x, vu.vi02, vu.vi15); +// BRANCH! + // b L11 | nop + bc = true; + // nop | nop + + if (bc) { goto L11; } + + + L7: + // iswr.x vi02, vi15 | nop + isw_buffer(Mask::x, vu.vi02, vu.vi15); + L8: + // lq.xyzw vf13, 1(vi00) | nop + lq_buffer_xyzw(vu.vf13, 1); + L9: + // ilwr.w vi02, vi03 | nop + ilw_buffer(Mask::w, vu.vi02, vu.vi03); + // lqi.xyzw vf08, vi03 | nop + lq_buffer_xyzw(vu.vf08, vu.vi03++); + // lqi.xyzw vf09, vi03 | nop + lq_buffer_xyzw(vu.vf09, vu.vi03++); + // lqi.xyzw vf10, vi03 | nop + lq_buffer_xyzw(vu.vf10, vu.vi03++); + // lqi.xyzw vf11, vi03 | nop + lq_buffer_xyzw(vu.vf11, vu.vi03++); + // lqi.xyzw vf12, vi03 | nop + lq_buffer_xyzw(vu.vf12, vu.vi03++); + // iadd vi02, vi02, vi15 | nop + vu.vi02 = vu.vi02 + vu.vi15; + // mtir vi08, vf09.w | nop + vu.vi08 = vu.vf09.w_as_u16(); + // sqi.xyzw vf13, vi02 | nop + sq_buffer_xyzw(vu.vf13, vu.vi02++); + // sqi.xyzw vf08, vi02 | nop + sq_buffer_xyzw(vu.vf08, vu.vi02++); + // sqi.xyzw vf09, vi02 | nop + sq_buffer_xyzw(vu.vf09, vu.vi02++); + // mfir.x vf14, vi08 | nop + vu.vf14.mfir(Mask::x, vu.vi08); + // sqi.xyzw vf10, vi02 | nop + sq_buffer_xyzw(vu.vf10, vu.vi02++); + // sqi.xyzw vf11, vi02 | nop + sq_buffer_xyzw(vu.vf11, vu.vi02++); +// BRANCH! + // ibeq vi00, vi10, L10 | nop + bc = (vu.vi10 == 0); + // sqi.xyzw vf12, vi02 | nop + sq_buffer_xyzw(vu.vf12, vu.vi02++); + if (bc) { goto L10; } + + + // mtir vi14, vf12.z | nop + vu.vi14 = vu.vf12.z_as_u16(); + // isw.x vi10, -1(vi02) | nop + isw_buffer(Mask::x, vu.vi10, vu.vi02 + -1); +// BRANCH! + // ibeq vi14, vi13, L10 | nop + bc = (vu.vi14 == vu.vi13); + // isw.y vi11, -1(vi02) | nop + isw_buffer(Mask::y, vu.vi11, vu.vi02 + -1); + if (bc) { goto L10; } + + + // ilw.x vi13, -4(vi02) | nop + ilw_buffer(Mask::x, vu.vi13, vu.vi02 + -4); + // isubiu vi14, vi00, 0x1d | nop + vu.vi14 = -29; + + // iand vi13, vi13, vi14 | nop + vu.vi13 = vu.vi13 & vu.vi14; + // iaddi vi13, vi13, 0xc | nop + vu.vi13 = vu.vi13 + 12; + // isw.x vi13, -4(vi02) | nop + isw_buffer(Mask::x, vu.vi13, vu.vi02 + -4); + // iaddiu vi13, vi00, 0x42 | nop + vu.vi13 = 0x42; /* 66 */ + + // isw.z vi13, -1(vi02) | nop + isw_buffer(Mask::z, vu.vi13, vu.vi02 + -1); + L10: +// BRANCH! + // ibgtz vi08, L9 | nop + bc = ((s16)vu.vi08) > 0; + // sq.xyzw vf14, 0(vi02) | nop + sq_buffer_xyzw(vu.vf14, vu.vi02); + if (bc) { goto L9; } + + + L11: + // lq.xyzw vf28, 3(vi00) | nop + lq_buffer_xyzw(vu.vf28, 3); + // ilw.y vi08, 3(vi12) | nop + ilw_buffer(Mask::y, vu.vi08, vu.vi12 + 3); + // lq.xyzw vf16, 5(vi00) | nop + lq_buffer_xyzw(vu.vf16, 5); + // lq.xyzw vf20, 4(vi00) | nop + lq_buffer_xyzw(vu.vf20, 4); + // ilw.z vi09, 3(vi12) | mul.xyzw vf27, vf28, vf15 + vu.vf27.mul_xyzw(vu.vf28, vu.vf15); ilw_buffer(Mask::z, vu.vi09, vu.vi12 + 3); + // ior vi11, vi08, vi00 | mul.xyzw vf28, vf28, vf00 + vu.vf28.mul_xyzw(vu.vf28, vu.vf00); vu.vi11 = vu.vi08; +// BRANCH! + // ibeq vi00, vi08, L13 | mul.xyzw vf15, vf16, vf15 + vu.vf15.mul_xyzw(vu.vf16, vu.vf15); bc = (vu.vi08 == 0); + // iaddi vi13, vi12, 0x3 | mul.xyzw vf16, vf16, vf00 + vu.vf16.mul_xyzw(vu.vf16, vu.vf00); vu.vi13 = vu.vi12 + 3; + if (bc) { goto L13; } + + + L12: + // lq.xyzw vf08, 0(vi08) | addax.xyzw vf20, vf00 + vu.acc.adda(Mask::xyzw, vu.vf20, vu.vf00.x()); lq_buffer_xyzw(vu.vf08, vu.vi08); + // lq.xyzw vf10, 1(vi08) | madda.xyzw ACC, vf27, vf25 + vu.acc.madda_xyzw(vu.vf27, vu.vf25); lq_buffer_xyzw(vu.vf10, vu.vi08 + 1); + // lq.xyzw vf12, 2(vi08) | maddz.xyzw vf26, vf28, vf25 + vu.acc.madd_xyzw(vu.vf26, vu.vf28, vu.vf25.z()); lq_buffer_xyzw(vu.vf12, vu.vi08 + 2); + // lq.xyzw vf25, 3(vi08) | nop + lq_buffer_xyzw(vu.vf25, vu.vi08 + 3); + // sq.xyzw vf09, 0(vi11) | mula.xyzw ACC, vf15, vf08 + vu.acc.mula_xyzw(vu.vf15, vu.vf08); sq_buffer_xyzw(vu.vf09, vu.vi11); + // sq.xyzw vf11, 1(vi11) | maddz.xyzw vf09, vf16, vf08 + vu.acc.madd_xyzw(vu.vf09, vu.vf16, vu.vf08.z()); sq_buffer_xyzw(vu.vf11, vu.vi11 + 1); + // sq.xyzw vf13, 2(vi11) | mula.xyzw ACC, vf15, vf10 + vu.acc.mula_xyzw(vu.vf15, vu.vf10); sq_buffer_xyzw(vu.vf13, vu.vi11 + 2); + // sq.xyzw vf26, 3(vi11) | maddz.xyzw vf11, vf16, vf10 + vu.acc.madd_xyzw(vu.vf11, vu.vf16, vu.vf10.z()); sq_buffer_xyzw(vu.vf26, vu.vi11 + 3); +// BRANCH! + // ibeq vi00, vi08, L13 | mula.xyzw ACC, vf15, vf12 + vu.acc.mula_xyzw(vu.vf15, vu.vf12); bc = (vu.vi08 == 0); + // ilwr.w vi10, vi13 | maddz.xyzw vf13, vf16, vf12 + vu.acc.madd_xyzw(vu.vf13, vu.vf16, vu.vf12.z()); ilw_buffer(Mask::w, vu.vi10, vu.vi13); + if (bc) { goto L13; } + + + // lq.xyzw vf08, 0(vi09) | addax.xyzw vf20, vf00 + vu.acc.adda(Mask::xyzw, vu.vf20, vu.vf00.x()); lq_buffer_xyzw(vu.vf08, vu.vi09); + // lq.xyzw vf10, 1(vi09) | madda.xyzw ACC, vf27, vf25 + vu.acc.madda_xyzw(vu.vf27, vu.vf25); lq_buffer_xyzw(vu.vf10, vu.vi09 + 1); + // lq.xyzw vf12, 2(vi09) | maddz.xyzw vf26, vf28, vf25 + vu.acc.madd_xyzw(vu.vf26, vu.vf28, vu.vf25.z()); lq_buffer_xyzw(vu.vf12, vu.vi09 + 2); + // lq.xyzw vf25, 3(vi09) | nop + lq_buffer_xyzw(vu.vf25, vu.vi09 + 3); + // sq.xyzw vf09, 0(vi08) | mula.xyzw ACC, vf15, vf08 + vu.acc.mula_xyzw(vu.vf15, vu.vf08); sq_buffer_xyzw(vu.vf09, vu.vi08); + // sq.xyzw vf11, 1(vi08) | maddz.xyzw vf09, vf16, vf08 + vu.acc.madd_xyzw(vu.vf09, vu.vf16, vu.vf08.z()); sq_buffer_xyzw(vu.vf11, vu.vi08 + 1); + // sq.xyzw vf13, 2(vi08) | mula.xyzw ACC, vf15, vf10 + vu.acc.mula_xyzw(vu.vf15, vu.vf10); sq_buffer_xyzw(vu.vf13, vu.vi08 + 2); + // sq.xyzw vf26, 3(vi08) | maddz.xyzw vf11, vf16, vf10 + vu.acc.madd_xyzw(vu.vf11, vu.vf16, vu.vf10.z()); sq_buffer_xyzw(vu.vf26, vu.vi08 + 3); +// BRANCH! + // ibeq vi00, vi09, L13 | mula.xyzw ACC, vf15, vf12 + vu.acc.mula_xyzw(vu.vf15, vu.vf12); bc = (vu.vi09 == 0); + // ilw.x vi11, 1(vi13) | maddz.xyzw vf13, vf16, vf12 + vu.acc.madd_xyzw(vu.vf13, vu.vf16, vu.vf12.z()); ilw_buffer(Mask::x, vu.vi11, vu.vi13 + 1); + if (bc) { goto L13; } + + + // lq.xyzw vf08, 0(vi10) | addax.xyzw vf20, vf00 + vu.acc.adda(Mask::xyzw, vu.vf20, vu.vf00.x()); lq_buffer_xyzw(vu.vf08, vu.vi10); + // lq.xyzw vf10, 1(vi10) | madda.xyzw ACC, vf27, vf25 + vu.acc.madda_xyzw(vu.vf27, vu.vf25); lq_buffer_xyzw(vu.vf10, vu.vi10 + 1); + // lq.xyzw vf12, 2(vi10) | maddz.xyzw vf26, vf28, vf25 + vu.acc.madd_xyzw(vu.vf26, vu.vf28, vu.vf25.z()); lq_buffer_xyzw(vu.vf12, vu.vi10 + 2); + // lq.xyzw vf25, 3(vi10) | nop + lq_buffer_xyzw(vu.vf25, vu.vi10 + 3); + // sq.xyzw vf09, 0(vi09) | mula.xyzw ACC, vf15, vf08 + vu.acc.mula_xyzw(vu.vf15, vu.vf08); sq_buffer_xyzw(vu.vf09, vu.vi09); + // sq.xyzw vf11, 1(vi09) | maddz.xyzw vf09, vf16, vf08 + vu.acc.madd_xyzw(vu.vf09, vu.vf16, vu.vf08.z()); sq_buffer_xyzw(vu.vf11, vu.vi09 + 1); + // sq.xyzw vf13, 2(vi09) | mula.xyzw ACC, vf15, vf10 + vu.acc.mula_xyzw(vu.vf15, vu.vf10); sq_buffer_xyzw(vu.vf13, vu.vi09 + 2); + // sq.xyzw vf26, 3(vi09) | maddz.xyzw vf11, vf16, vf10 + vu.acc.madd_xyzw(vu.vf11, vu.vf16, vu.vf10.z()); sq_buffer_xyzw(vu.vf26, vu.vi09 + 3); +// BRANCH! + // ibeq vi00, vi10, L13 | mula.xyzw ACC, vf15, vf12 + vu.acc.mula_xyzw(vu.vf15, vu.vf12); bc = (vu.vi10 == 0); + // ilw.y vi08, 1(vi13) | maddz.xyzw vf13, vf16, vf12 + vu.acc.madd_xyzw(vu.vf13, vu.vf16, vu.vf12.z()); ilw_buffer(Mask::y, vu.vi08, vu.vi13 + 1); + if (bc) { goto L13; } + + + // lq.xyzw vf08, 0(vi11) | addax.xyzw vf20, vf00 + vu.acc.adda(Mask::xyzw, vu.vf20, vu.vf00.x()); lq_buffer_xyzw(vu.vf08, vu.vi11); + // lq.xyzw vf10, 1(vi11) | madda.xyzw ACC, vf27, vf25 + vu.acc.madda_xyzw(vu.vf27, vu.vf25); lq_buffer_xyzw(vu.vf10, vu.vi11 + 1); + // lq.xyzw vf12, 2(vi11) | maddz.xyzw vf26, vf28, vf25 + vu.acc.madd_xyzw(vu.vf26, vu.vf28, vu.vf25.z()); lq_buffer_xyzw(vu.vf12, vu.vi11 + 2); + // lq.xyzw vf25, 3(vi11) | nop + lq_buffer_xyzw(vu.vf25, vu.vi11 + 3); + // sq.xyzw vf09, 0(vi10) | mula.xyzw ACC, vf15, vf08 + vu.acc.mula_xyzw(vu.vf15, vu.vf08); sq_buffer_xyzw(vu.vf09, vu.vi10); + // sq.xyzw vf11, 1(vi10) | maddz.xyzw vf09, vf16, vf08 + vu.acc.madd_xyzw(vu.vf09, vu.vf16, vu.vf08.z()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf13, 2(vi10) | mula.xyzw ACC, vf15, vf10 + vu.acc.mula_xyzw(vu.vf15, vu.vf10); sq_buffer_xyzw(vu.vf13, vu.vi10 + 2); + // sq.xyzw vf26, 3(vi10) | maddz.xyzw vf11, vf16, vf10 + vu.acc.madd_xyzw(vu.vf11, vu.vf16, vu.vf10.z()); sq_buffer_xyzw(vu.vf26, vu.vi10 + 3); + // iaddi vi13, vi13, 0x1 | nop + vu.vi13 = vu.vi13 + 1; +// BRANCH! + // ibne vi00, vi11, L12 | mula.xyzw ACC, vf15, vf12 + vu.acc.mula_xyzw(vu.vf15, vu.vf12); bc = (vu.vi11 != 0); + // ilwr.z vi09, vi13 | maddz.xyzw vf13, vf16, vf12 + vu.acc.madd_xyzw(vu.vf13, vu.vf16, vu.vf12.z()); ilw_buffer(Mask::z, vu.vi09, vu.vi13); + if (bc) { goto L12; } + + + L13: + // ilw.x vi02, 3(vi12) | nop + ilw_buffer(Mask::x, vu.vi02, vu.vi12 + 3); +// BRANCH! + // ibeq vi00, vi04, L25 | nop + bc = (vu.vi04 == 0); + // iadd vi01, vi01, vi12 | nop + vu.vi01 = vu.vi01 + vu.vi12; + if (bc) { goto L25; } + + + // ilwr.x vi08, vi01 | nop + ilw_buffer(Mask::x, vu.vi08, vu.vi01); + // lqi.xyzw vf08, vi01 | nop + lq_buffer_xyzw(vu.vf08, vu.vi01++); + // lqi.xyzw vf11, vi01 | nop + lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | nop + lq_buffer_xyzw(vu.vf14, vu.vi01++); + // lq.xyz vf29, 4(vi08) | nop + lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyz vf30, 5(vi08) | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); + // lq.xyzw vf31, 6(vi08) | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + // iaddi vi04, vi04, -0x1 | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); vu.vi04 = vu.vi04 + -1; + // iadd vi02, vi02, vi12 | nop + vu.vi02 = vu.vi02 + vu.vi12; + // lqi.xyzw vf24, vi02 | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); lq_buffer_xyzw(vu.vf24, vu.vi02++); + // mtir vi10, vf11.x | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | maddz.xyz vf11, vf31, vf14 + vu.vi13 = vu.vf11.y_as_u16(); vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); + // lq.xyzw vf25, 0(vi08) | nop + lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf26, 1(vi08) | itof0.xyzw vf24, vf24 + vu.vf24.itof0(Mask::xyzw, vu.vf24); lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // lq.xyzw vf27, 2(vi08) | nop + lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // erleng.xyz P, vf11 | nop + vu.P = erleng(vu.vf11); /* TODO erleng */ + // lq.xyzw vf28, 3(vi08) | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // ior vi15, vi07, vi00 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); vu.vi15 = vu.vi07; + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + // lqi.xyzw vf09, vi01 | nop + lq_buffer_xyzw(vu.vf09, vu.vi01++); + // ilwr.y vi03, vi12 | nop + ilw_buffer(Mask::y, vu.vi03, vu.vi12); + // ilw.z vi07, 1(vi12) | nop + ilw_buffer(Mask::z, vu.vi07, vu.vi12 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | nop + lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi08, vf09.x | nop + vu.vi08 = vu.vf09.x_as_u16(); +// BRANCH! + // ibeq vi00, vi15, L14 | nop + bc = (vu.vi15 == 0); + // iadd vi03, vi03, vi12 | nop + vu.vi03 = vu.vi03 + vu.vi12; + if (bc) { goto L14; } + + + // nop | miniw.w vf08, vf08, vf01 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf01.w()); + L14: + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // iadd vi04, vi04, vi03 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vi04 = vu.vi04 + vu.vi03; + // lq.xyz vf29, 4(vi08) | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyz vf30, 5(vi08) | nop + lq_buffer_xyz(vu.vf30, vu.vi08 + 5); + // iadd vi06, vi06, vi04 | nop + vu.vi06 = vu.vi06 + vu.vi04; + // lq.xyzw vf31, 6(vi08) | nop + lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + // lq.xyzw vf25, 0(vi08) | nop + lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf26, 1(vi08) | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | nop + vu.vi14 = vu.vf12.y_as_u16(); + // lq.xyzw vf27, 2(vi08) | nop + lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + // iadd vi07, vi07, vi06 | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); vu.vi07 = vu.vi07 + vu.vi06; + // lq.xyzw vf28, 3(vi08) | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // nop | nop + + // 1024.0 | miniw.w vf08, vf08, vf03 :i + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); vu.I = 1024.0; +// BRANCH! + // ibne vi00, vi15, L82 | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); bc = (vu.vi15 != 0); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + if (bc) { goto L82; } + + + // erleng.xyz P, vf12 | nop + vu.P = erleng(vu.vf12); /* TODO erleng */ + // nop | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + // lqi.xyzw vf10, vi01 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); lq_buffer_xyzw(vu.vf10, vu.vi01++); +// BRANCH! + // ibne vi04, vi03, L16 | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); bc = (vu.vi04 != vu.vi03); + // nop | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); + if (bc) { goto L16; } + + +// BRANCH! + // ibne vi06, vi03, JUMP_1A1 | nop + bc = (vu.vi06 != vu.vi03); + // nop | nop + + if (bc) { goto JUMP_1A1; } + + +// BRANCH! + // b L67 | nop + bc = true; + // nop | nop + + if (bc) { goto L67; } + + + L15: + // lqi.xyzw vf10, vi01 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); lq_buffer_xyzw(vu.vf10, vu.vi01++); + // sq.xyzw vf13, 1(vi12) | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); + // sq.xyzw vf13, 1(vi15) | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + L16: + // lqi.xyzw vf13, vi01 | add.xyzw vf09, vf09, vf28 + vu.vf09.add_xyzw(vu.vf09, vu.vf28); lq_buffer_xyzw(vu.vf13, vu.vi01++); + // lqi.xyzw vf16, vi01 | maxw.w vf08, vf08, vf02 + vu.vf08.max(Mask::w, vu.vf08, vu.vf02.w()); lq_buffer_xyzw(vu.vf16, vu.vi01++); + // mtir vi08, vf10.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi08 = vu.vf10.x_as_u16(); + // ilw.y vi09, -9(vi01) | maxx.xyzw vf11, vf11, vf00 + vu.vf11.max_xyzw(vu.vf11, vu.vf00.x()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -9); + // div Q, vf01.w, vf09.w | add.zw vf10, vf10, vf17 + vu.vf10.add(Mask::zw, vu.vf10, vu.vf17); vu.Q = vu.vf01.w() / vu.vf09.w(); + + // move.xyzw vf21, vf08 | add.xyzw vf13, vf13, vf18 + vu.vf13.add_xyzw(vu.vf13, vu.vf18); vu.vf21.move_xyzw(vu.vf08); + // lq.xyz vf29, 4(vi08) | add.xyzw vf16, vf16, vf19 + vu.vf16.add_xyzw(vu.vf16, vu.vf19); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyz vf30, 5(vi08) | mulax.xyzw ACC, vf04, vf11 + vu.acc.mula_xyzw(vu.vf04, vu.vf11.x()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); +// BRANCH! + // ibgtz vi09, L17 | madday.xyzw ACC, vf05, vf11 + vu.acc.madda_xyzw(vu.vf05, vu.vf11.y()); bc = ((s16)vu.vi09) > 0; + // lq.xyzw vf31, 6(vi08) | maddaz.xyzw ACC, vf06, vf11 + vu.acc.madda_xyzw(vu.vf06, vu.vf11.z()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + if (bc) { goto L17; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L17: + // lq.xyzw vf25, 0(vi08) | maddw.xyzw vf11, vf07, vf00 + vu.acc.madd_xyzw(vu.vf11, vu.vf07, vu.vf00.w()); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf26, 1(vi08) | mul.xyz vf09, vf09, Q + vu.vf09.mul(Mask::xyz, vu.vf09, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // mtir vi12, vf13.x | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi15 = vu.vf13.y_as_u16(); + // lq.xyzw vf27, 2(vi08) | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lqi.xyzw vf23, vi03 | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); +// BRANCH! + // ibne vi00, vi09, L18 | mulaz.xyzw ACC, vf29, vf10 + vu.acc.mula_xyzw(vu.vf29, vu.vf10.z()); bc = (vu.vi09 != 0); + // sq.xyzw vf21, 2(vi10) | maddaz.xyzw ACC, vf30, vf13 + vu.acc.madda_xyzw(vu.vf30, vu.vf13.z()); sq_buffer_xyzw(vu.vf21, vu.vi10 + 2); + if (bc) { goto L18; } + + + // nop | ftoi4.xyzw vf21, vf08 + vu.vf21.ftoi4(Mask::xyzw, vu.vf08); + L18: + // mfp.w vf20, P | maddz.xyz vf13, vf31, vf16 + vu.acc.madd_xyz(vu.vf13, vu.vf31, vu.vf16.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf14, 0(vi10) | miniy.xyzw vf11, vf11, vf17 + vu.vf11.mini_xyzw(vu.vf11, vu.vf17.y()); sq_buffer_xyzw(vu.vf14, vu.vi10); + // sq.xyzw vf14, 0(vi13) | miniw.w vf09, vf09, vf03 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf03.w()); sq_buffer_xyzw(vu.vf14, vu.vi13); + // sq.xyzw vf21, 2(vi13) | mulaw.xyzw ACC, vf25, vf10 + vu.acc.mula_xyzw(vu.vf25, vu.vf10.w()); sq_buffer_xyzw(vu.vf21, vu.vi13 + 2); + // lq.xyzw vf28, 3(vi08) | mulw.xyzw vf12, vf12, vf20 + vu.vf12.mul_xyzw(vu.vf12, vu.vf20.w()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // erleng.xyz P, vf13 | ftoi0.xyzw vf11, vf11 + vu.vf11.ftoi0(Mask::xyzw, vu.vf11); vu.P = erleng(vu.vf13); /* TODO erleng */ +// BRANCH! + // ibne vi04, vi03, L19 | maddaw.xyzw ACC, vf26, vf13 + vu.acc.madda_xyzw(vu.vf26, vu.vf13.w()); bc = (vu.vi04 != vu.vi03); + // mr32.z vf16, vf00 | maddw.xyzw vf10, vf27, vf16 + vu.acc.madd_xyzw(vu.vf10, vu.vf27, vu.vf16.w()); vu.vf16.z() = 1.f; + if (bc) { goto L19; } + + +// BRANCH! + // ibne vi06, vi03, L35 | nop + bc = (vu.vi06 != vu.vi03); + // ilw.y vi09, -6(vi01) | nop + ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + if (bc) { goto L35; } + + +// BRANCH! + // ibne vi07, vi03, L72 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L72; } + + +// BRANCH! + // b L143 | nop + bc = true; + // nop | nop + + if (bc) { goto L143; } + + + L19: + // lqi.xyzw vf08, vi01 | mulax.xyzw ACC, vf01, vf12 + vu.acc.mula_xyzw(vu.vf01, vu.vf12.x()); lq_buffer_xyzw(vu.vf08, vu.vi01++); + // sq.xyzw vf11, 1(vi10) | madday.xyzw ACC, vf02, vf12 + vu.acc.madda_xyzw(vu.vf02, vu.vf12.y()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf11, 1(vi13) | maddz.xyzw vf12, vf03, vf12 + vu.acc.madd_xyzw(vu.vf12, vu.vf03, vu.vf12.z()); sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + // lqi.xyzw vf11, vi01 | add.xyzw vf10, vf10, vf28 + vu.vf10.add_xyzw(vu.vf10, vu.vf28); lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | maxw.w vf09, vf09, vf02 + vu.vf09.max(Mask::w, vu.vf09, vu.vf02.w()); lq_buffer_xyzw(vu.vf14, vu.vi01++); + // mtir vi08, vf08.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi08 = vu.vf08.x_as_u16(); + // ilw.y vi09, -9(vi01) | maxx.xyzw vf12, vf12, vf00 + vu.vf12.max_xyzw(vu.vf12, vu.vf00.x()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -9); + // div Q, vf01.w, vf10.w | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); vu.Q = vu.vf01.w() / vu.vf10.w(); + + // move.xyzw vf21, vf09 | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); vu.vf21.move_xyzw(vu.vf09); + // lq.xyz vf29, 4(vi08) | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyz vf30, 5(vi08) | mulax.xyzw ACC, vf04, vf12 + vu.acc.mula_xyzw(vu.vf04, vu.vf12.x()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); +// BRANCH! + // ibgtz vi09, L20 | madday.xyzw ACC, vf05, vf12 + vu.acc.madda_xyzw(vu.vf05, vu.vf12.y()); bc = ((s16)vu.vi09) > 0; + // lq.xyzw vf31, 6(vi08) | maddaz.xyzw ACC, vf06, vf12 + vu.acc.madda_xyzw(vu.vf06, vu.vf12.z()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + if (bc) { goto L20; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L20: + // lq.xyzw vf25, 0(vi08) | maddw.xyzw vf12, vf07, vf00 + vu.acc.madd_xyzw(vu.vf12, vu.vf07, vu.vf00.w()); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf26, 1(vi08) | mul.xyz vf10, vf10, Q + vu.vf10.mul(Mask::xyz, vu.vf10, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // mtir vi10, vf11.x | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi13 = vu.vf11.y_as_u16(); + // lq.xyzw vf27, 2(vi08) | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lqi.xyzw vf23, vi03 | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); +// BRANCH! + // ibne vi00, vi09, L21 | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); bc = (vu.vi09 != 0); + // sq.xyzw vf21, 2(vi11) | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); sq_buffer_xyzw(vu.vf21, vu.vi11 + 2); + if (bc) { goto L21; } + + + // nop | ftoi4.xyzw vf21, vf09 + vu.vf21.ftoi4(Mask::xyzw, vu.vf09); + L21: + // mfp.w vf20, P | maddz.xyz vf11, vf31, vf14 + vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf15, 0(vi11) | miniy.xyzw vf12, vf12, vf17 + vu.vf12.mini_xyzw(vu.vf12, vu.vf17.y()); sq_buffer_xyzw(vu.vf15, vu.vi11); + // sq.xyzw vf15, 0(vi14) | miniw.w vf10, vf10, vf03 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf03.w()); sq_buffer_xyzw(vu.vf15, vu.vi14); + // sq.xyzw vf21, 2(vi14) | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); sq_buffer_xyzw(vu.vf21, vu.vi14 + 2); + // lq.xyzw vf28, 3(vi08) | mulw.xyzw vf13, vf13, vf20 + vu.vf13.mul_xyzw(vu.vf13, vu.vf20.w()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // erleng.xyz P, vf11 | ftoi0.xyzw vf12, vf12 + vu.vf12.ftoi0(Mask::xyzw, vu.vf12); vu.P = erleng(vu.vf11); /* TODO erleng */ +// BRANCH! + // ibne vi04, vi03, L22 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); bc = (vu.vi04 != vu.vi03); + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + if (bc) { goto L22; } + + +// BRANCH! + // ibne vi06, vi03, L40 | nop + bc = (vu.vi06 != vu.vi03); + // ilw.y vi09, -6(vi01) | nop + ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + if (bc) { goto L40; } + + +// BRANCH! + // ibne vi07, vi03, L77 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L77; } + + +// BRANCH! + // b L153 | nop + bc = true; + // nop | nop + + if (bc) { goto L153; } + + + L22: + // lqi.xyzw vf09, vi01 | mulax.xyzw ACC, vf01, vf13 + vu.acc.mula_xyzw(vu.vf01, vu.vf13.x()); lq_buffer_xyzw(vu.vf09, vu.vi01++); + // sq.xyzw vf12, 1(vi11) | madday.xyzw ACC, vf02, vf13 + vu.acc.madda_xyzw(vu.vf02, vu.vf13.y()); sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); + // sq.xyzw vf12, 1(vi14) | maddz.xyzw vf13, vf03, vf13 + vu.acc.madd_xyzw(vu.vf13, vu.vf03, vu.vf13.z()); sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | maxw.w vf10, vf10, vf02 + vu.vf10.max(Mask::w, vu.vf10, vu.vf02.w()); lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi08, vf09.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi08 = vu.vf09.x_as_u16(); + // ilw.y vi09, -9(vi01) | maxx.xyzw vf13, vf13, vf00 + vu.vf13.max_xyzw(vu.vf13, vu.vf00.x()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -9); + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // move.xyzw vf21, vf10 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vf21.move_xyzw(vu.vf10); + // lq.xyz vf29, 4(vi08) | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyz vf30, 5(vi08) | mulax.xyzw ACC, vf04, vf13 + vu.acc.mula_xyzw(vu.vf04, vu.vf13.x()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); +// BRANCH! + // ibgtz vi09, L23 | madday.xyzw ACC, vf05, vf13 + vu.acc.madda_xyzw(vu.vf05, vu.vf13.y()); bc = ((s16)vu.vi09) > 0; + // lq.xyzw vf31, 6(vi08) | maddaz.xyzw ACC, vf06, vf13 + vu.acc.madda_xyzw(vu.vf06, vu.vf13.z()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + if (bc) { goto L23; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L23: + // lq.xyzw vf25, 0(vi08) | maddw.xyzw vf13, vf07, vf00 + vu.acc.madd_xyzw(vu.vf13, vu.vf07, vu.vf00.w()); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf26, 1(vi08) | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi14 = vu.vf12.y_as_u16(); + // lq.xyzw vf27, 2(vi08) | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); +// BRANCH! + // ibne vi00, vi09, L24 | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); bc = (vu.vi09 != 0); + // sq.xyzw vf21, 2(vi12) | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); sq_buffer_xyzw(vu.vf21, vu.vi12 + 2); + if (bc) { goto L24; } + + + // nop | ftoi4.xyzw vf21, vf10 + vu.vf21.ftoi4(Mask::xyzw, vu.vf10); + L24: + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf16, 0(vi12) | miniy.xyzw vf13, vf13, vf17 + vu.vf13.mini_xyzw(vu.vf13, vu.vf17.y()); sq_buffer_xyzw(vu.vf16, vu.vi12); + // sq.xyzw vf16, 0(vi15) | miniw.w vf08, vf08, vf03 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); sq_buffer_xyzw(vu.vf16, vu.vi15); + // sq.xyzw vf21, 2(vi15) | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); sq_buffer_xyzw(vu.vf21, vu.vi15 + 2); + // lq.xyzw vf28, 3(vi08) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // erleng.xyz P, vf12 | ftoi0.xyzw vf13, vf13 + vu.vf13.ftoi0(Mask::xyzw, vu.vf13); vu.P = erleng(vu.vf12); /* TODO erleng */ +// BRANCH! + // ibne vi04, vi03, L15 | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); bc = (vu.vi04 != vu.vi03); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + if (bc) { goto L15; } + + +// BRANCH! + // ibne vi06, vi03, L29 | nop + bc = (vu.vi06 != vu.vi03); + // ilw.y vi09, -6(vi01) | nop + ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + if (bc) { goto L29; } + + +// BRANCH! + // ibne vi07, vi03, L66 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L66; } + + +// BRANCH! + // b L163 | nop + bc = true; + // nop | nop + + if (bc) { goto L163; } + + + L25: +// BRANCH! + // ibeq vi00, vi06, L61 | nop + bc = (vu.vi06 == 0); + // iadd vi02, vi02, vi12 | nop + vu.vi02 = vu.vi02 + vu.vi12; + if (bc) { goto L61; } + + + // lqi.xyzw vf08, vi01 | nop + lq_buffer_xyzw(vu.vf08, vu.vi01++); + // lqi.xyzw vf24, vi02 | nop + lq_buffer_xyzw(vu.vf24, vu.vi02++); + // lqi.xyzw vf11, vi01 | nop + lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | nop + lq_buffer_xyzw(vu.vf14, vu.vi01++); + // mtir vi10, vf08.x | nop + vu.vi10 = vu.vf08.x_as_u16(); + // mtir vi13, vf08.y | itof0.xyzw vf24, vf24 + vu.vf24.itof0(Mask::xyzw, vu.vf24); vu.vi13 = vu.vf08.y_as_u16(); + // iaddi vi06, vi06, -0x1 | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); vu.vi06 = vu.vi06 + -1; + // nop | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); + // iand vi10, vi10, vi05 | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); vu.vi10 = vu.vi10 & vu.vi05; + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // iand vi13, vi13, vi05 | nop + vu.vi13 = vu.vi13 & vu.vi05; + // lq.xyzw vf20, 0(vi10) | nop + lq_buffer_xyzw(vu.vf20, vu.vi10); + // lq.xyzw vf25, 0(vi13) | nop + lq_buffer_xyzw(vu.vf25, vu.vi13); + // lq.xyzw vf23, 1(vi10) | nop + lq_buffer_xyzw(vu.vf23, vu.vi10 + 1); + // lq.xyzw vf26, 1(vi13) | nop + lq_buffer_xyzw(vu.vf26, vu.vi13 + 1); + // lq.xyzw vf20, 2(vi10) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 2); + // lq.xyzw vf27, 2(vi13) | maddy.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi13 + 2); + // lq.xyzw vf23, 3(vi10) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 3); + // lq.xyzw vf28, 3(vi13) | maddy.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi13 + 3); + // lq.xyzw vf20, 4(vi10) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 4); + // lq.xyz vf29, 4(vi13) | maddy.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi13 + 4); + // lq.xyzw vf23, 5(vi10) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 5); + // lq.xyz vf30, 5(vi13) | maddy.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi13 + 5); + // lq.xyzw vf20, 6(vi10) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 6); + // lq.xyzw vf31, 6(vi13) | maddy.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi13 + 6); + // mtir vi10, vf11.x | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | maddy.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.y()); vu.vi13 = vu.vf11.y_as_u16(); + // nop | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); + // nop | maddy.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.y()); + // nop | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); + // nop | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); + // nop | maddz.xyz vf11, vf31, vf14 + vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); + // nop | nop + + // nop | nop + + // nop | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); + // iaddiu vi08, vi00, 0x243 | nop + vu.vi08 = 0x243; /* 579 */ + + // erleng.xyz P, vf11 | nop + vu.P = erleng(vu.vf11); /* TODO erleng */ + // ior vi15, vi07, vi00 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); vu.vi15 = vu.vi07; + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + // lqi.xyzw vf09, vi01 | nop + lq_buffer_xyzw(vu.vf09, vu.vi01++); + // ilwr.y vi03, vi12 | nop + ilw_buffer(Mask::y, vu.vi03, vu.vi12); + // ilw.z vi07, 1(vi12) | nop + ilw_buffer(Mask::z, vu.vi07, vu.vi12 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | nop + lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi11, vf09.x | nop + vu.vi11 = vu.vf09.x_as_u16(); +// BRANCH! + // ibeq vi00, vi15, L26 | nop + bc = (vu.vi15 == 0); + // mtir vi14, vf09.y | nop + vu.vi14 = vu.vf09.y_as_u16(); + if (bc) { goto L26; } + + + // iaddiu vi08, vi00, 0x539 | miniw.w vf08, vf08, vf01 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf01.w()); vu.vi08 = 0x539; /* 1337 */ + + L26: + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // iadd vi03, vi03, vi12 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vi03 = vu.vi03 + vu.vi12; + // iand vi11, vi11, vi05 | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); vu.vi11 = vu.vi11 & vu.vi05; + // iadd vi06, vi06, vi03 | nop + vu.vi06 = vu.vi06 + vu.vi03; + // iadd vi07, vi07, vi06 | nop + vu.vi07 = vu.vi07 + vu.vi06; + // iand vi14, vi14, vi05 | nop + vu.vi14 = vu.vi14 & vu.vi05; +// BRANCH! + // ibne vi05, vi11, L27 | nop + bc = (vu.vi05 != vu.vi11); + // nop | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ + if (bc) { goto L27; } + + + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | nop + vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L28 | nop + bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L28; } + + + L27: + // lq.xyzw vf20, 0(vi11) | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi11); + // lq.xyzw vf25, 0(vi14) | nop + lq_buffer_xyzw(vu.vf25, vu.vi14); + // lq.xyzw vf23, 1(vi11) | nop + lq_buffer_xyzw(vu.vf23, vu.vi11 + 1); + // lq.xyzw vf26, 1(vi14) | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi14 + 1); + // lq.xyzw vf20, 2(vi11) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 2); + // lq.xyzw vf27, 2(vi14) | maddw.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.w()); lq_buffer_xyzw(vu.vf27, vu.vi14 + 2); + // lq.xyzw vf23, 3(vi11) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 3); + // lq.xyzw vf28, 3(vi14) | maddw.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.w()); lq_buffer_xyzw(vu.vf28, vu.vi14 + 3); + // lq.xyzw vf20, 4(vi11) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 4); + // lq.xyz vf29, 4(vi14) | maddw.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.w()); lq_buffer_xyz(vu.vf29, vu.vi14 + 4); + // lq.xyzw vf23, 5(vi11) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 5); + // lq.xyz vf30, 5(vi14) | maddw.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.w()); lq_buffer_xyz(vu.vf30, vu.vi14 + 5); + // lq.xyzw vf20, 6(vi11) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 6); + // lq.xyzw vf31, 6(vi14) | maddw.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.w()); lq_buffer_xyzw(vu.vf31, vu.vi14 + 6); + // lqi.xyzw vf23, vi02 | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi11, vf12.x | maddw.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.w()); vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); vu.vi14 = vu.vf12.y_as_u16(); + // iaddiu vi08, vi00, 0x1a1 | maddw.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.w()); vu.vi08 = 0x1a1; /* 417 */ + +// BRANCH! + // ibeq vi00, vi15, L28 | nop + bc = (vu.vi15 == 0); + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L28; } + + + // iaddiu vi08, vi00, 0x48e | nop + vu.vi08 = 0x48e; /* 1166 */ + + L28: + // nop | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); + // nop | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // nop | nop + + // 1024.0 | miniw.w vf08, vf08, vf03 :i + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); vu.I = 1024.0; +// BRANCH! + // ibne vi00, vi15, L93 | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); bc = (vu.vi15 != 0); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + if (bc) { goto L93; } + + + // erleng.xyz P, vf12 | nop + vu.P = erleng(vu.vf12); /* TODO erleng */ +// BRANCH! + // ibeq vi06, vi03, L65 | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); bc = (vu.vi06 == vu.vi03); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + if (bc) { goto L65; } + + + // lqi.xyzw vf10, vi01 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); lq_buffer_xyzw(vu.vf10, vu.vi01++); + // jr vi08 | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); + // nop | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); + switch (vu.vi08) { + case 0x1a1: + goto JUMP_1A1; + case 0x48e: + goto JUMP_48E; +case 0x243: +goto JUMP_243; +default: +assert(false); +} + L29: + // lqi.xyzw vf10, vi01 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); lq_buffer_xyzw(vu.vf10, vu.vi01++); + // sq.xyzw vf13, 1(vi12) | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); + // sq.xyzw vf13, 1(vi15) | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + JUMP_1A1: + // lqi.xyzw vf13, vi01 | add.xyzw vf09, vf09, vf28 + vu.vf09.add_xyzw(vu.vf09, vu.vf28); lq_buffer_xyzw(vu.vf13, vu.vi01++); + // lqi.xyzw vf16, vi01 | maxw.w vf08, vf08, vf02 + vu.vf08.max(Mask::w, vu.vf08, vu.vf02.w()); lq_buffer_xyzw(vu.vf16, vu.vi01++); + // mtir vi12, vf10.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi12 = vu.vf10.x_as_u16(); + // mtir vi15, vf10.y | maxx.xyzw vf11, vf11, vf00 + vu.vf11.max_xyzw(vu.vf11, vu.vf00.x()); vu.vi15 = vu.vf10.y_as_u16(); + // div Q, vf01.w, vf09.w | add.zw vf10, vf10, vf17 + vu.vf10.add(Mask::zw, vu.vf10, vu.vf17); vu.Q = vu.vf01.w() / vu.vf09.w(); + + // move.xyzw vf21, vf08 | add.xyzw vf13, vf13, vf18 + vu.vf13.add_xyzw(vu.vf13, vu.vf18); vu.vf21.move_xyzw(vu.vf08); + // iand vi12, vi12, vi05 | add.xyzw vf16, vf16, vf19 + vu.vf16.add_xyzw(vu.vf16, vu.vf19); vu.vi12 = vu.vi12 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf11 + vu.acc.mula_xyzw(vu.vf04, vu.vf11.x()); +// BRANCH! + // ibgtz vi09, L31 | madday.xyzw ACC, vf05, vf11 + vu.acc.madda_xyzw(vu.vf05, vu.vf11.y()); bc = ((s16)vu.vi09) > 0; + // iand vi15, vi15, vi05 | maddaz.xyzw ACC, vf06, vf11 + vu.acc.madda_xyzw(vu.vf06, vu.vf11.z()); vu.vi15 = vu.vi15 & vu.vi05; + if (bc) { goto L31; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L31: +// BRANCH! + // ibne vi05, vi12, L32 | maddw.xyzw vf11, vf07, vf00 + vu.acc.madd_xyzw(vu.vf11, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi12); + // ilw.x vi09, -9(vi01) | mul.xyz vf09, vf09, Q + vu.vf09.mul(Mask::xyz, vu.vf09, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L32; } + + + // mtir vi12, vf13.x | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi15 = vu.vf13.y_as_u16(); +// BRANCH! + // b L33 | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L33; } + + + L32: + // lq.xyzw vf20, 0(vi12) | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi12); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf25, 0(vi15) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi15); + // lq.xyzw vf23, 1(vi12) | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi12 + 1); + // lq.xyzw vf26, 1(vi15) | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi15 + 1); + // lq.xyzw vf20, 2(vi12) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 2); + // lq.xyzw vf27, 2(vi15) | maddy.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi15 + 2); + // lq.xyzw vf23, 3(vi12) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi12 + 3); + // lq.xyzw vf28, 3(vi15) | maddy.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi15 + 3); + // lq.xyzw vf20, 4(vi12) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 4); + // lq.xyz vf29, 4(vi15) | maddy.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi15 + 4); + // lq.xyzw vf23, 5(vi12) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi12 + 5); + // lq.xyz vf30, 5(vi15) | maddy.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi15 + 5); + // lq.xyzw vf20, 6(vi12) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 6); + // lq.xyzw vf31, 6(vi15) | maddy.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi15 + 6); + // mtir vi12, vf13.x | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | maddy.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.y()); vu.vi15 = vu.vf13.y_as_u16(); +// BRANCH! + // b L49 | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); bc = true; + // lqi.xyzw vf23, vi03 | maddy.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L49; } + + + L33: +// BRANCH! + // ibgez vi09, L34 | mulaz.xyzw ACC, vf29, vf10 + vu.acc.mula_xyzw(vu.vf29, vu.vf10.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi10) | maddaz.xyzw ACC, vf30, vf13 + vu.acc.madda_xyzw(vu.vf30, vu.vf13.z()); sq_buffer_xyzw(vu.vf21, vu.vi10 + 2); + if (bc) { goto L34; } + + + // nop | ftoi4.xyzw vf21, vf08 + vu.vf21.ftoi4(Mask::xyzw, vu.vf08); + L34: + // mfp.w vf20, P | maddz.xyz vf13, vf31, vf16 + vu.acc.madd_xyz(vu.vf13, vu.vf31, vu.vf16.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf14, 0(vi10) | miniy.xyzw vf11, vf11, vf17 + vu.vf11.mini_xyzw(vu.vf11, vu.vf17.y()); sq_buffer_xyzw(vu.vf14, vu.vi10); + // sq.xyzw vf14, 0(vi13) | miniw.w vf09, vf09, vf03 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf03.w()); sq_buffer_xyzw(vu.vf14, vu.vi13); + // sq.xyzw vf21, 2(vi13) | mulaw.xyzw ACC, vf25, vf10 + vu.acc.mula_xyzw(vu.vf25, vu.vf10.w()); sq_buffer_xyzw(vu.vf21, vu.vi13 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf12, vf12, vf20 + vu.vf12.mul_xyzw(vu.vf12, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // erleng.xyz P, vf13 | ftoi0.xyzw vf11, vf11 + vu.vf11.ftoi0(Mask::xyzw, vu.vf11); vu.P = erleng(vu.vf13); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L35 | maddaw.xyzw ACC, vf26, vf13 + vu.acc.madda_xyzw(vu.vf26, vu.vf13.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf16, vf00 | maddw.xyzw vf10, vf27, vf16 + vu.acc.madd_xyzw(vu.vf10, vu.vf27, vu.vf16.w()); vu.vf16.z() = 1.f; + if (bc) { goto L35; } + + +// BRANCH! + // ibne vi07, vi03, L72 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L72; } + + +// BRANCH! + // b L143 | nop + bc = true; + // nop | nop + + if (bc) { goto L143; } + + + L35: + // lqi.xyzw vf08, vi01 | mulax.xyzw ACC, vf01, vf12 + vu.acc.mula_xyzw(vu.vf01, vu.vf12.x()); lq_buffer_xyzw(vu.vf08, vu.vi01++); + // sq.xyzw vf11, 1(vi10) | madday.xyzw ACC, vf02, vf12 + vu.acc.madda_xyzw(vu.vf02, vu.vf12.y()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf11, 1(vi13) | maddz.xyzw vf12, vf03, vf12 + vu.acc.madd_xyzw(vu.vf12, vu.vf03, vu.vf12.z()); sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + // lqi.xyzw vf11, vi01 | add.xyzw vf10, vf10, vf28 + vu.vf10.add_xyzw(vu.vf10, vu.vf28); lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | maxw.w vf09, vf09, vf02 + vu.vf09.max(Mask::w, vu.vf09, vu.vf02.w()); lq_buffer_xyzw(vu.vf14, vu.vi01++); + // mtir vi10, vf08.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi10 = vu.vf08.x_as_u16(); + // mtir vi13, vf08.y | maxx.xyzw vf12, vf12, vf00 + vu.vf12.max_xyzw(vu.vf12, vu.vf00.x()); vu.vi13 = vu.vf08.y_as_u16(); + // div Q, vf01.w, vf10.w | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); vu.Q = vu.vf01.w() / vu.vf10.w(); + + // move.xyzw vf21, vf09 | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); vu.vf21.move_xyzw(vu.vf09); + // iand vi10, vi10, vi05 | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); vu.vi10 = vu.vi10 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf12 + vu.acc.mula_xyzw(vu.vf04, vu.vf12.x()); +// BRANCH! + // ibgtz vi09, L36 | madday.xyzw ACC, vf05, vf12 + vu.acc.madda_xyzw(vu.vf05, vu.vf12.y()); bc = ((s16)vu.vi09) > 0; + // iand vi13, vi13, vi05 | maddaz.xyzw ACC, vf06, vf12 + vu.acc.madda_xyzw(vu.vf06, vu.vf12.z()); vu.vi13 = vu.vi13 & vu.vi05; + if (bc) { goto L36; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L36: +// BRANCH! + // ibne vi05, vi10, L37 | maddw.xyzw vf12, vf07, vf00 + vu.acc.madd_xyzw(vu.vf12, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi10); + // ilw.x vi09, -9(vi01) | mul.xyz vf10, vf10, Q + vu.vf10.mul(Mask::xyz, vu.vf10, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L37; } + + + // mtir vi10, vf11.x | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi13 = vu.vf11.y_as_u16(); +// BRANCH! + // b L38 | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L38; } + + + L37: + // lq.xyzw vf20, 0(vi10) | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi10); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf25, 0(vi13) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi13); + // lq.xyzw vf23, 1(vi10) | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi10 + 1); + // lq.xyzw vf26, 1(vi13) | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi13 + 1); + // lq.xyzw vf20, 2(vi10) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 2); + // lq.xyzw vf27, 2(vi13) | maddy.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi13 + 2); + // lq.xyzw vf23, 3(vi10) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 3); + // lq.xyzw vf28, 3(vi13) | maddy.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi13 + 3); + // lq.xyzw vf20, 4(vi10) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 4); + // lq.xyz vf29, 4(vi13) | maddy.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi13 + 4); + // lq.xyzw vf23, 5(vi10) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 5); + // lq.xyz vf30, 5(vi13) | maddy.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi13 + 5); + // lq.xyzw vf20, 6(vi10) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 6); + // lq.xyzw vf31, 6(vi13) | maddy.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi13 + 6); + // mtir vi10, vf11.x | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | maddy.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.y()); vu.vi13 = vu.vf11.y_as_u16(); +// BRANCH! + // b L54 | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); bc = true; + // lqi.xyzw vf23, vi03 | maddy.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L54; } + + + L38: +// BRANCH! + // ibgez vi09, L39 | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi11) | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); sq_buffer_xyzw(vu.vf21, vu.vi11 + 2); + if (bc) { goto L39; } + + + // nop | ftoi4.xyzw vf21, vf09 + vu.vf21.ftoi4(Mask::xyzw, vu.vf09); + L39: + // mfp.w vf20, P | maddz.xyz vf11, vf31, vf14 + vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf15, 0(vi11) | miniy.xyzw vf12, vf12, vf17 + vu.vf12.mini_xyzw(vu.vf12, vu.vf17.y()); sq_buffer_xyzw(vu.vf15, vu.vi11); + // sq.xyzw vf15, 0(vi14) | miniw.w vf10, vf10, vf03 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf03.w()); sq_buffer_xyzw(vu.vf15, vu.vi14); + // sq.xyzw vf21, 2(vi14) | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); sq_buffer_xyzw(vu.vf21, vu.vi14 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf13, vf13, vf20 + vu.vf13.mul_xyzw(vu.vf13, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // erleng.xyz P, vf11 | ftoi0.xyzw vf12, vf12 + vu.vf12.ftoi0(Mask::xyzw, vu.vf12); vu.P = erleng(vu.vf11); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L40 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + if (bc) { goto L40; } + + +// BRANCH! + // ibne vi07, vi03, L77 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L77; } + + +// BRANCH! + // b L153 | nop + bc = true; + // nop | nop + + if (bc) { goto L153; } + + + L40: + // lqi.xyzw vf09, vi01 | mulax.xyzw ACC, vf01, vf13 + vu.acc.mula_xyzw(vu.vf01, vu.vf13.x()); lq_buffer_xyzw(vu.vf09, vu.vi01++); + // sq.xyzw vf12, 1(vi11) | madday.xyzw ACC, vf02, vf13 + vu.acc.madda_xyzw(vu.vf02, vu.vf13.y()); sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); + // sq.xyzw vf12, 1(vi14) | maddz.xyzw vf13, vf03, vf13 + vu.acc.madd_xyzw(vu.vf13, vu.vf03, vu.vf13.z()); sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | maxw.w vf10, vf10, vf02 + vu.vf10.max(Mask::w, vu.vf10, vu.vf02.w()); lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi11, vf09.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi11 = vu.vf09.x_as_u16(); + // mtir vi14, vf09.y | maxx.xyzw vf13, vf13, vf00 + vu.vf13.max_xyzw(vu.vf13, vu.vf00.x()); vu.vi14 = vu.vf09.y_as_u16(); + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // move.xyzw vf21, vf10 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vf21.move_xyzw(vu.vf10); + // iand vi11, vi11, vi05 | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); vu.vi11 = vu.vi11 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf13 + vu.acc.mula_xyzw(vu.vf04, vu.vf13.x()); +// BRANCH! + // ibgtz vi09, L41 | madday.xyzw ACC, vf05, vf13 + vu.acc.madda_xyzw(vu.vf05, vu.vf13.y()); bc = ((s16)vu.vi09) > 0; + // iand vi14, vi14, vi05 | maddaz.xyzw ACC, vf06, vf13 + vu.acc.madda_xyzw(vu.vf06, vu.vf13.z()); vu.vi14 = vu.vi14 & vu.vi05; + if (bc) { goto L41; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L41: +// BRANCH! + // ibne vi05, vi11, L42 | maddw.xyzw vf13, vf07, vf00 + vu.acc.madd_xyzw(vu.vf13, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi11); + // ilw.x vi09, -9(vi01) | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L42; } + + + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L43 | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L43; } + + + L42: + // lq.xyzw vf20, 0(vi11) | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi11); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf25, 0(vi14) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi14); + // lq.xyzw vf23, 1(vi11) | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi11 + 1); + // lq.xyzw vf26, 1(vi14) | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi14 + 1); + // lq.xyzw vf20, 2(vi11) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 2); + // lq.xyzw vf27, 2(vi14) | maddy.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi14 + 2); + // lq.xyzw vf23, 3(vi11) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 3); + // lq.xyzw vf28, 3(vi14) | maddy.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi14 + 3); + // lq.xyzw vf20, 4(vi11) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 4); + // lq.xyz vf29, 4(vi14) | maddy.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi14 + 4); + // lq.xyzw vf23, 5(vi11) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 5); + // lq.xyz vf30, 5(vi14) | maddy.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi14 + 5); + // lq.xyzw vf20, 6(vi11) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 6); + // lq.xyzw vf31, 6(vi14) | maddy.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi14 + 6); + // mtir vi11, vf12.x | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | maddy.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.y()); vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L59 | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); bc = true; + // lqi.xyzw vf23, vi03 | maddy.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L59; } + + + L43: +// BRANCH! + // ibgez vi09, L44 | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi12) | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); sq_buffer_xyzw(vu.vf21, vu.vi12 + 2); + if (bc) { goto L44; } + + + // nop | ftoi4.xyzw vf21, vf10 + vu.vf21.ftoi4(Mask::xyzw, vu.vf10); + L44: + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf16, 0(vi12) | miniy.xyzw vf13, vf13, vf17 + vu.vf13.mini_xyzw(vu.vf13, vu.vf17.y()); sq_buffer_xyzw(vu.vf16, vu.vi12); + // sq.xyzw vf16, 0(vi15) | miniw.w vf08, vf08, vf03 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); sq_buffer_xyzw(vu.vf16, vu.vi15); + // sq.xyzw vf21, 2(vi15) | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); sq_buffer_xyzw(vu.vf21, vu.vi15 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // erleng.xyz P, vf12 | ftoi0.xyzw vf13, vf13 + vu.vf13.ftoi0(Mask::xyzw, vu.vf13); vu.P = erleng(vu.vf12); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L29 | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + if (bc) { goto L29; } + + +// BRANCH! + // ibne vi07, vi03, L66 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L66; } + + +// BRANCH! + // b L163 | nop + bc = true; + // nop | nop + + if (bc) { goto L163; } + + + L45: + // lqi.xyzw vf10, vi01 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); lq_buffer_xyzw(vu.vf10, vu.vi01++); + // sq.xyzw vf13, 1(vi12) | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); + // sq.xyzw vf13, 1(vi15) | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + JUMP_243: + // lqi.xyzw vf13, vi01 | add.xyzw vf09, vf09, vf28 + vu.vf09.add_xyzw(vu.vf09, vu.vf28); lq_buffer_xyzw(vu.vf13, vu.vi01++); + // lqi.xyzw vf16, vi01 | maxw.w vf08, vf08, vf02 + vu.vf08.max(Mask::w, vu.vf08, vu.vf02.w()); lq_buffer_xyzw(vu.vf16, vu.vi01++); + // mtir vi12, vf10.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi12 = vu.vf10.x_as_u16(); + // mtir vi15, vf10.y | maxx.xyzw vf11, vf11, vf00 + vu.vf11.max_xyzw(vu.vf11, vu.vf00.x()); vu.vi15 = vu.vf10.y_as_u16(); + // div Q, vf01.w, vf09.w | add.zw vf10, vf10, vf17 + vu.vf10.add(Mask::zw, vu.vf10, vu.vf17); vu.Q = vu.vf01.w() / vu.vf09.w(); + + // move.xyzw vf21, vf08 | add.xyzw vf13, vf13, vf18 + vu.vf13.add_xyzw(vu.vf13, vu.vf18); vu.vf21.move_xyzw(vu.vf08); + // iand vi12, vi12, vi05 | add.xyzw vf16, vf16, vf19 + vu.vf16.add_xyzw(vu.vf16, vu.vf19); vu.vi12 = vu.vi12 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf11 + vu.acc.mula_xyzw(vu.vf04, vu.vf11.x()); +// BRANCH! + // ibgtz vi09, L47 | madday.xyzw ACC, vf05, vf11 + vu.acc.madda_xyzw(vu.vf05, vu.vf11.y()); bc = ((s16)vu.vi09) > 0; + // iand vi15, vi15, vi05 | maddaz.xyzw ACC, vf06, vf11 + vu.acc.madda_xyzw(vu.vf06, vu.vf11.z()); vu.vi15 = vu.vi15 & vu.vi05; + if (bc) { goto L47; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L47: +// BRANCH! + // ibne vi05, vi12, L48 | maddw.xyzw vf11, vf07, vf00 + vu.acc.madd_xyzw(vu.vf11, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi12); + // ilw.x vi09, -9(vi01) | mul.xyz vf09, vf09, Q + vu.vf09.mul(Mask::xyz, vu.vf09, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L48; } + + + // mtir vi12, vf13.x | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi15 = vu.vf13.y_as_u16(); +// BRANCH! + // b L49 | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L49; } + + + L48: + // lq.xyzw vf20, 0(vi12) | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi12); + // lq.xyzw vf25, 0(vi15) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi15); + // lq.xyzw vf23, 1(vi12) | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi12 + 1); + // lq.xyzw vf26, 1(vi15) | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi15 + 1); + // lq.xyzw vf20, 2(vi12) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 2); + // lq.xyzw vf27, 2(vi15) | maddw.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.w()); lq_buffer_xyzw(vu.vf27, vu.vi15 + 2); + // lq.xyzw vf23, 3(vi12) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi12 + 3); + // lq.xyzw vf28, 3(vi15) | maddw.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.w()); lq_buffer_xyzw(vu.vf28, vu.vi15 + 3); + // lq.xyzw vf20, 4(vi12) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 4); + // lq.xyz vf29, 4(vi15) | maddw.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.w()); lq_buffer_xyz(vu.vf29, vu.vi15 + 4); + // lq.xyzw vf23, 5(vi12) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi12 + 5); + // lq.xyz vf30, 5(vi15) | maddw.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.w()); lq_buffer_xyz(vu.vf30, vu.vi15 + 5); + // lq.xyzw vf20, 6(vi12) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 6); + // lq.xyzw vf31, 6(vi15) | maddw.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.w()); lq_buffer_xyzw(vu.vf31, vu.vi15 + 6); + // lqi.xyzw vf23, vi02 | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi12, vf13.x | maddw.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.w()); vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); vu.vi15 = vu.vf13.y_as_u16(); +// BRANCH! + // b L33 | maddw.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.w()); bc = true; + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L33; } + + + L49: +// BRANCH! + // ibgez vi09, L50 | mulaz.xyzw ACC, vf29, vf10 + vu.acc.mula_xyzw(vu.vf29, vu.vf10.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi10) | maddaz.xyzw ACC, vf30, vf13 + vu.acc.madda_xyzw(vu.vf30, vu.vf13.z()); sq_buffer_xyzw(vu.vf21, vu.vi10 + 2); + if (bc) { goto L50; } + + + // nop | ftoi4.xyzw vf21, vf08 + vu.vf21.ftoi4(Mask::xyzw, vu.vf08); + L50: + // mfp.w vf20, P | maddz.xyz vf13, vf31, vf16 + vu.acc.madd_xyz(vu.vf13, vu.vf31, vu.vf16.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf14, 0(vi10) | miniy.xyzw vf11, vf11, vf17 + vu.vf11.mini_xyzw(vu.vf11, vu.vf17.y()); sq_buffer_xyzw(vu.vf14, vu.vi10); + // sq.xyzw vf14, 0(vi13) | miniw.w vf09, vf09, vf03 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf03.w()); sq_buffer_xyzw(vu.vf14, vu.vi13); + // sq.xyzw vf21, 2(vi13) | mulaw.xyzw ACC, vf25, vf10 + vu.acc.mula_xyzw(vu.vf25, vu.vf10.w()); sq_buffer_xyzw(vu.vf21, vu.vi13 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf12, vf12, vf20 + vu.vf12.mul_xyzw(vu.vf12, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // erleng.xyz P, vf13 | ftoi0.xyzw vf11, vf11 + vu.vf11.ftoi0(Mask::xyzw, vu.vf11); vu.P = erleng(vu.vf13); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L51 | maddaw.xyzw ACC, vf26, vf13 + vu.acc.madda_xyzw(vu.vf26, vu.vf13.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf16, vf00 | maddw.xyzw vf10, vf27, vf16 + vu.acc.madd_xyzw(vu.vf10, vu.vf27, vu.vf16.w()); vu.vf16.z() = 1.f; + if (bc) { goto L51; } + + +// BRANCH! + // ibne vi07, vi03, L72 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L72; } + + +// BRANCH! + // b L143 | nop + bc = true; + // nop | nop + + if (bc) { goto L143; } + + + L51: + // lqi.xyzw vf08, vi01 | mulax.xyzw ACC, vf01, vf12 + vu.acc.mula_xyzw(vu.vf01, vu.vf12.x()); lq_buffer_xyzw(vu.vf08, vu.vi01++); + // sq.xyzw vf11, 1(vi10) | madday.xyzw ACC, vf02, vf12 + vu.acc.madda_xyzw(vu.vf02, vu.vf12.y()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf11, 1(vi13) | maddz.xyzw vf12, vf03, vf12 + vu.acc.madd_xyzw(vu.vf12, vu.vf03, vu.vf12.z()); sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + // lqi.xyzw vf11, vi01 | add.xyzw vf10, vf10, vf28 + vu.vf10.add_xyzw(vu.vf10, vu.vf28); lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | maxw.w vf09, vf09, vf02 + vu.vf09.max(Mask::w, vu.vf09, vu.vf02.w()); lq_buffer_xyzw(vu.vf14, vu.vi01++); + // mtir vi10, vf08.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi10 = vu.vf08.x_as_u16(); + // mtir vi13, vf08.y | maxx.xyzw vf12, vf12, vf00 + vu.vf12.max_xyzw(vu.vf12, vu.vf00.x()); vu.vi13 = vu.vf08.y_as_u16(); + // div Q, vf01.w, vf10.w | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); vu.Q = vu.vf01.w() / vu.vf10.w(); + + // move.xyzw vf21, vf09 | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); vu.vf21.move_xyzw(vu.vf09); + // iand vi10, vi10, vi05 | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); vu.vi10 = vu.vi10 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf12 + vu.acc.mula_xyzw(vu.vf04, vu.vf12.x()); +// BRANCH! + // ibgtz vi09, L52 | madday.xyzw ACC, vf05, vf12 + vu.acc.madda_xyzw(vu.vf05, vu.vf12.y()); bc = ((s16)vu.vi09) > 0; + // iand vi13, vi13, vi05 | maddaz.xyzw ACC, vf06, vf12 + vu.acc.madda_xyzw(vu.vf06, vu.vf12.z()); vu.vi13 = vu.vi13 & vu.vi05; + if (bc) { goto L52; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L52: +// BRANCH! + // ibne vi05, vi10, L53 | maddw.xyzw vf12, vf07, vf00 + vu.acc.madd_xyzw(vu.vf12, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi10); + // ilw.x vi09, -9(vi01) | mul.xyz vf10, vf10, Q + vu.vf10.mul(Mask::xyz, vu.vf10, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L53; } + + + // mtir vi10, vf11.x | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi13 = vu.vf11.y_as_u16(); +// BRANCH! + // b L54 | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L54; } + + + L53: + // lq.xyzw vf20, 0(vi10) | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi10); + // lq.xyzw vf25, 0(vi13) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi13); + // lq.xyzw vf23, 1(vi10) | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi10 + 1); + // lq.xyzw vf26, 1(vi13) | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi13 + 1); + // lq.xyzw vf20, 2(vi10) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 2); + // lq.xyzw vf27, 2(vi13) | maddw.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.w()); lq_buffer_xyzw(vu.vf27, vu.vi13 + 2); + // lq.xyzw vf23, 3(vi10) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 3); + // lq.xyzw vf28, 3(vi13) | maddw.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.w()); lq_buffer_xyzw(vu.vf28, vu.vi13 + 3); + // lq.xyzw vf20, 4(vi10) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 4); + // lq.xyz vf29, 4(vi13) | maddw.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.w()); lq_buffer_xyz(vu.vf29, vu.vi13 + 4); + // lq.xyzw vf23, 5(vi10) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 5); + // lq.xyz vf30, 5(vi13) | maddw.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.w()); lq_buffer_xyz(vu.vf30, vu.vi13 + 5); + // lq.xyzw vf20, 6(vi10) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 6); + // lq.xyzw vf31, 6(vi13) | maddw.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.w()); lq_buffer_xyzw(vu.vf31, vu.vi13 + 6); + // lqi.xyzw vf23, vi02 | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi10, vf11.x | maddw.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.w()); vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); vu.vi13 = vu.vf11.y_as_u16(); +// BRANCH! + // b L38 | maddw.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.w()); bc = true; + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L38; } + + + L54: +// BRANCH! + // ibgez vi09, L55 | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi11) | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); sq_buffer_xyzw(vu.vf21, vu.vi11 + 2); + if (bc) { goto L55; } + + + // nop | ftoi4.xyzw vf21, vf09 + vu.vf21.ftoi4(Mask::xyzw, vu.vf09); + L55: + // mfp.w vf20, P | maddz.xyz vf11, vf31, vf14 + vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf15, 0(vi11) | miniy.xyzw vf12, vf12, vf17 + vu.vf12.mini_xyzw(vu.vf12, vu.vf17.y()); sq_buffer_xyzw(vu.vf15, vu.vi11); + // sq.xyzw vf15, 0(vi14) | miniw.w vf10, vf10, vf03 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf03.w()); sq_buffer_xyzw(vu.vf15, vu.vi14); + // sq.xyzw vf21, 2(vi14) | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); sq_buffer_xyzw(vu.vf21, vu.vi14 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf13, vf13, vf20 + vu.vf13.mul_xyzw(vu.vf13, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // erleng.xyz P, vf11 | ftoi0.xyzw vf12, vf12 + vu.vf12.ftoi0(Mask::xyzw, vu.vf12); vu.P = erleng(vu.vf11); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L56 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + if (bc) { goto L56; } + + +// BRANCH! + // ibne vi07, vi03, L77 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L77; } + + +// BRANCH! + // b L153 | nop + bc = true; + // nop | nop + + if (bc) { goto L153; } + + + L56: + // lqi.xyzw vf09, vi01 | mulax.xyzw ACC, vf01, vf13 + vu.acc.mula_xyzw(vu.vf01, vu.vf13.x()); lq_buffer_xyzw(vu.vf09, vu.vi01++); + // sq.xyzw vf12, 1(vi11) | madday.xyzw ACC, vf02, vf13 + vu.acc.madda_xyzw(vu.vf02, vu.vf13.y()); sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); + // sq.xyzw vf12, 1(vi14) | maddz.xyzw vf13, vf03, vf13 + vu.acc.madd_xyzw(vu.vf13, vu.vf03, vu.vf13.z()); sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | maxw.w vf10, vf10, vf02 + vu.vf10.max(Mask::w, vu.vf10, vu.vf02.w()); lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi11, vf09.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi11 = vu.vf09.x_as_u16(); + // mtir vi14, vf09.y | maxx.xyzw vf13, vf13, vf00 + vu.vf13.max_xyzw(vu.vf13, vu.vf00.x()); vu.vi14 = vu.vf09.y_as_u16(); + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // move.xyzw vf21, vf10 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vf21.move_xyzw(vu.vf10); + // iand vi11, vi11, vi05 | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); vu.vi11 = vu.vi11 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf13 + vu.acc.mula_xyzw(vu.vf04, vu.vf13.x()); +// BRANCH! + // ibgtz vi09, L57 | madday.xyzw ACC, vf05, vf13 + vu.acc.madda_xyzw(vu.vf05, vu.vf13.y()); bc = ((s16)vu.vi09) > 0; + // iand vi14, vi14, vi05 | maddaz.xyzw ACC, vf06, vf13 + vu.acc.madda_xyzw(vu.vf06, vu.vf13.z()); vu.vi14 = vu.vi14 & vu.vi05; + if (bc) { goto L57; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L57: +// BRANCH! + // ibne vi05, vi11, L58 | maddw.xyzw vf13, vf07, vf00 + vu.acc.madd_xyzw(vu.vf13, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi11); + // ilw.x vi09, -9(vi01) | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L58; } + + + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L59 | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L59; } + + + L58: + // lq.xyzw vf20, 0(vi11) | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi11); + // lq.xyzw vf25, 0(vi14) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi14); + // lq.xyzw vf23, 1(vi11) | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi11 + 1); + // lq.xyzw vf26, 1(vi14) | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi14 + 1); + // lq.xyzw vf20, 2(vi11) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 2); + // lq.xyzw vf27, 2(vi14) | maddw.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.w()); lq_buffer_xyzw(vu.vf27, vu.vi14 + 2); + // lq.xyzw vf23, 3(vi11) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 3); + // lq.xyzw vf28, 3(vi14) | maddw.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.w()); lq_buffer_xyzw(vu.vf28, vu.vi14 + 3); + // lq.xyzw vf20, 4(vi11) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 4); + // lq.xyz vf29, 4(vi14) | maddw.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.w()); lq_buffer_xyz(vu.vf29, vu.vi14 + 4); + // lq.xyzw vf23, 5(vi11) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 5); + // lq.xyz vf30, 5(vi14) | maddw.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.w()); lq_buffer_xyz(vu.vf30, vu.vi14 + 5); + // lq.xyzw vf20, 6(vi11) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 6); + // lq.xyzw vf31, 6(vi14) | maddw.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.w()); lq_buffer_xyzw(vu.vf31, vu.vi14 + 6); + // lqi.xyzw vf23, vi02 | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi11, vf12.x | maddw.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.w()); vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L43 | maddw.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.w()); bc = true; + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L43; } + + + L59: +// BRANCH! + // ibgez vi09, L60 | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi12) | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); sq_buffer_xyzw(vu.vf21, vu.vi12 + 2); + if (bc) { goto L60; } + + + // nop | ftoi4.xyzw vf21, vf10 + vu.vf21.ftoi4(Mask::xyzw, vu.vf10); + L60: + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf16, 0(vi12) | miniy.xyzw vf13, vf13, vf17 + vu.vf13.mini_xyzw(vu.vf13, vu.vf17.y()); sq_buffer_xyzw(vu.vf16, vu.vi12); + // sq.xyzw vf16, 0(vi15) | miniw.w vf08, vf08, vf03 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); sq_buffer_xyzw(vu.vf16, vu.vi15); + // sq.xyzw vf21, 2(vi15) | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); sq_buffer_xyzw(vu.vf21, vu.vi15 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // erleng.xyz P, vf12 | ftoi0.xyzw vf13, vf13 + vu.vf13.ftoi0(Mask::xyzw, vu.vf13); vu.P = erleng(vu.vf12); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L45 | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + if (bc) { goto L45; } + + +// BRANCH! + // ibne vi07, vi03, L72 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L72; } + + +// BRANCH! + // b L163 | nop + bc = true; + // nop | nop + + if (bc) { goto L163; } + + + L61: + // lqi.xyzw vf08, vi01 | nop + lq_buffer_xyzw(vu.vf08, vu.vi01++); + // lqi.xyzw vf24, vi02 | nop + lq_buffer_xyzw(vu.vf24, vu.vi02++); + // lqi.xyzw vf11, vi01 | nop + lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | nop + lq_buffer_xyzw(vu.vf14, vu.vi01++); + // mtir vi10, vf08.x | nop + vu.vi10 = vu.vf08.x_as_u16(); + // mtir vi13, vf08.y | itof0.xyzw vf24, vf24 + vu.vf24.itof0(Mask::xyzw, vu.vf24); vu.vi13 = vu.vf08.y_as_u16(); + // nop | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); + // nop | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); + // iand vi10, vi10, vi05 | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); vu.vi10 = vu.vi10 & vu.vi05; + // ilw.w vi08, -1(vi02) | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); ilw_buffer(Mask::w, vu.vi08, vu.vi02 + -1); + // iand vi13, vi13, vi05 | nop + vu.vi13 = vu.vi13 & vu.vi05; + // lq.xyzw vf20, 0(vi10) | nop + lq_buffer_xyzw(vu.vf20, vu.vi10); + // lq.xyzw vf31, 0(vi13) | nop + lq_buffer_xyzw(vu.vf31, vu.vi13); + // lq.xyzw vf25, 0(vi08) | nop + lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf23, 1(vi10) | nop + lq_buffer_xyzw(vu.vf23, vu.vi10 + 1); + // lq.xyzw vf20, 1(vi13) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi13 + 1); + // lq.xyzw vf26, 1(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // lq.xyzw vf31, 2(vi10) | maddz.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi10 + 2); + // lq.xyzw vf23, 2(vi13) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi13 + 2); + // lq.xyzw vf27, 2(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lq.xyzw vf20, 3(vi10) | maddz.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 3); + // lq.xyzw vf31, 3(vi13) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf31, vu.vi13 + 3); + // lq.xyzw vf28, 3(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // lq.xyzw vf23, 4(vi10) | maddz.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 4); + // lq.xyzw vf20, 4(vi13) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi13 + 4); + // lq.xyz vf29, 4(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyzw vf31, 5(vi10) | maddz.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi10 + 5); + // lq.xyzw vf23, 5(vi13) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi13 + 5); + // lq.xyz vf30, 5(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); + // lq.xyzw vf20, 6(vi10) | maddz.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 6); + // lq.xyzw vf22, 6(vi13) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf22, vu.vi13 + 6); + // lq.xyzw vf31, 6(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + // lqi.xyzw vf23, vi02 | maddz.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi10, vf11.x | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | madday.xyzw ACC, vf22, vf24 + vu.acc.madda_xyzw(vu.vf22, vu.vf24.y()); vu.vi13 = vu.vf11.y_as_u16(); + // lq.xyzw vf22, 2(vi00) | maddz.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.z()); lq_buffer_xyzw(vu.vf22, 2); + // nop | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); + // nop | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); + // nop | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); + // nop | maddz.xyz vf11, vf31, vf14 + vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); + // nop | nop + + // nop | nop + + // nop | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); + // nop | nop + + // erleng.xyz P, vf11 | nop + vu.P = erleng(vu.vf11); /* TODO erleng */ + // ior vi15, vi07, vi00 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); vu.vi15 = vu.vi07; + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + // lqi.xyzw vf09, vi01 | nop + lq_buffer_xyzw(vu.vf09, vu.vi01++); + // ilwr.y vi03, vi12 | nop + ilw_buffer(Mask::y, vu.vi03, vu.vi12); + // ilw.z vi07, 1(vi12) | nop + ilw_buffer(Mask::z, vu.vi07, vu.vi12 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | nop + lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi11, vf09.x | nop + vu.vi11 = vu.vf09.x_as_u16(); +// BRANCH! + // ibeq vi00, vi15, L62 | nop + bc = (vu.vi15 == 0); + // mtir vi14, vf09.y | nop + vu.vi14 = vu.vf09.y_as_u16(); + if (bc) { goto L62; } + + + // nop | miniw.w vf08, vf08, vf01 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf01.w()); + L62: + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // iadd vi03, vi03, vi12 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vi03 = vu.vi03 + vu.vi12; + // iand vi11, vi11, vi05 | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); vu.vi11 = vu.vi11 & vu.vi05; + // ilw.w vi08, -1(vi02) | nop + ilw_buffer(Mask::w, vu.vi08, vu.vi02 + -1); + // iadd vi07, vi07, vi03 | nop + vu.vi07 = vu.vi07 + vu.vi03; + // iand vi14, vi14, vi05 | nop + vu.vi14 = vu.vi14 & vu.vi05; +// BRANCH! + // ibne vi05, vi11, L63 | nop + bc = (vu.vi05 != vu.vi11); + // iaddi vi07, vi07, -0x1 | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ vu.vi07 = vu.vi07 + -1; + if (bc) { goto L63; } + + + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | nop + vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L64 | nop + bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L64; } + + + L63: + // lq.xyzw vf20, 0(vi11) | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi11); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf31, 0(vi14) | nop + lq_buffer_xyzw(vu.vf31, vu.vi14); + // lq.xyzw vf25, 0(vi08) | nop + lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf23, 1(vi11) | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi11 + 1); + // lq.xyzw vf20, 1(vi14) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi14 + 1); + // lq.xyzw vf26, 1(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // lq.xyzw vf31, 2(vi11) | maddz.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi11 + 2); + // lq.xyzw vf23, 2(vi14) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi14 + 2); + // lq.xyzw vf27, 2(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lq.xyzw vf20, 3(vi11) | maddz.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 3); + // lq.xyzw vf31, 3(vi14) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf31, vu.vi14 + 3); + // lq.xyzw vf28, 3(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // lq.xyzw vf23, 4(vi11) | maddz.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 4); + // lq.xyzw vf20, 4(vi14) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi14 + 4); + // lq.xyz vf29, 4(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyzw vf31, 5(vi11) | maddz.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi11 + 5); + // lq.xyzw vf23, 5(vi14) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi14 + 5); + // lq.xyz vf30, 5(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); + // lq.xyzw vf20, 6(vi11) | maddz.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 6); + // lq.xyzw vf22, 6(vi14) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf22, vu.vi14 + 6); + // lq.xyzw vf31, 6(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + // lqi.xyzw vf23, vi02 | maddz.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi11, vf12.x | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | madday.xyzw ACC, vf22, vf24 + vu.acc.madda_xyzw(vu.vf22, vu.vf24.y()); vu.vi14 = vu.vf12.y_as_u16(); + // lq.xyzw vf22, 2(vi00) | maddz.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.z()); lq_buffer_xyzw(vu.vf22, 2); + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + L64: + // nop | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); + // nop | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // nop | nop + + // 1024.0 | miniw.w vf08, vf08, vf03 :i + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); vu.I = 1024.0; +// BRANCH! + // ibne vi00, vi15, L125 | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); bc = (vu.vi15 != 0); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + if (bc) { goto L125; } + + + // erleng.xyz P, vf12 | nop + vu.P = erleng(vu.vf12); /* TODO erleng */ + // nop | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + L65: + // lqi.xyzw vf10, vi01 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); lq_buffer_xyzw(vu.vf10, vu.vi01++); +// BRANCH! + // b L67 | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); bc = true; + // nop | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); + if (bc) { goto L67; } + + + L66: + // lqi.xyzw vf10, vi01 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); lq_buffer_xyzw(vu.vf10, vu.vi01++); + // sq.xyzw vf13, 1(vi12) | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); + // sq.xyzw vf13, 1(vi15) | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + L67: + // lqi.xyzw vf13, vi01 | add.xyzw vf09, vf09, vf28 + vu.vf09.add_xyzw(vu.vf09, vu.vf28); lq_buffer_xyzw(vu.vf13, vu.vi01++); + // lqi.xyzw vf16, vi01 | maxw.w vf08, vf08, vf02 + vu.vf08.max(Mask::w, vu.vf08, vu.vf02.w()); lq_buffer_xyzw(vu.vf16, vu.vi01++); + // mtir vi12, vf10.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi12 = vu.vf10.x_as_u16(); + // mtir vi15, vf10.y | maxx.xyzw vf11, vf11, vf00 + vu.vf11.max_xyzw(vu.vf11, vu.vf00.x()); vu.vi15 = vu.vf10.y_as_u16(); + // div Q, vf01.w, vf09.w | add.zw vf10, vf10, vf17 + vu.vf10.add(Mask::zw, vu.vf10, vu.vf17); vu.Q = vu.vf01.w() / vu.vf09.w(); + + // move.xyzw vf21, vf08 | add.xyzw vf13, vf13, vf18 + vu.vf13.add_xyzw(vu.vf13, vu.vf18); vu.vf21.move_xyzw(vu.vf08); + // iand vi12, vi12, vi05 | add.xyzw vf16, vf16, vf19 + vu.vf16.add_xyzw(vu.vf16, vu.vf19); vu.vi12 = vu.vi12 & vu.vi05; + // ilw.w vi08, -1(vi02) | mulax.xyzw ACC, vf04, vf11 + vu.acc.mula_xyzw(vu.vf04, vu.vf11.x()); ilw_buffer(Mask::w, vu.vi08, vu.vi02 + -1); +// BRANCH! + // ibgtz vi09, L68 | madday.xyzw ACC, vf05, vf11 + vu.acc.madda_xyzw(vu.vf05, vu.vf11.y()); bc = ((s16)vu.vi09) > 0; + // iand vi15, vi15, vi05 | maddaz.xyzw ACC, vf06, vf11 + vu.acc.madda_xyzw(vu.vf06, vu.vf11.z()); vu.vi15 = vu.vi15 & vu.vi05; + if (bc) { goto L68; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L68: +// BRANCH! + // ibne vi05, vi12, L69 | maddw.xyzw vf11, vf07, vf00 + vu.acc.madd_xyzw(vu.vf11, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi12); + // ilw.x vi09, -9(vi01) | mul.xyz vf09, vf09, Q + vu.vf09.mul(Mask::xyz, vu.vf09, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L69; } + + + // mtir vi12, vf13.x | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi15 = vu.vf13.y_as_u16(); +// BRANCH! + // b L70 | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L70; } + + + L69: + // lq.xyzw vf20, 0(vi12) | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi12); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf31, 0(vi15) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf31, vu.vi15); + // lq.xyzw vf25, 0(vi08) | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf23, 1(vi12) | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi12 + 1); + // lq.xyzw vf20, 1(vi15) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi15 + 1); + // lq.xyzw vf26, 1(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // lq.xyzw vf31, 2(vi12) | maddz.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi12 + 2); + // lq.xyzw vf23, 2(vi15) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi15 + 2); + // lq.xyzw vf27, 2(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lq.xyzw vf20, 3(vi12) | maddz.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 3); + // lq.xyzw vf31, 3(vi15) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf31, vu.vi15 + 3); + // lq.xyzw vf28, 3(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // lq.xyzw vf23, 4(vi12) | maddz.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi12 + 4); + // lq.xyzw vf20, 4(vi15) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi15 + 4); + // lq.xyz vf29, 4(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyzw vf31, 5(vi12) | maddz.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi12 + 5); + // lq.xyzw vf23, 5(vi15) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi15 + 5); + // lq.xyz vf30, 5(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); + // lq.xyzw vf20, 6(vi12) | maddz.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 6); + // lq.xyzw vf22, 6(vi15) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf22, vu.vi15 + 6); + // lq.xyzw vf31, 6(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + // lqi.xyzw vf23, vi02 | maddz.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi12, vf13.x | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | madday.xyzw ACC, vf22, vf24 + vu.acc.madda_xyzw(vu.vf22, vu.vf24.y()); vu.vi15 = vu.vf13.y_as_u16(); + // lq.xyzw vf22, 2(vi00) | maddz.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.z()); lq_buffer_xyzw(vu.vf22, 2); + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + L70: +// BRANCH! + // ibgez vi09, L71 | mulaz.xyzw ACC, vf29, vf10 + vu.acc.mula_xyzw(vu.vf29, vu.vf10.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi10) | maddaz.xyzw ACC, vf30, vf13 + vu.acc.madda_xyzw(vu.vf30, vu.vf13.z()); sq_buffer_xyzw(vu.vf21, vu.vi10 + 2); + if (bc) { goto L71; } + + + // nop | ftoi4.xyzw vf21, vf08 + vu.vf21.ftoi4(Mask::xyzw, vu.vf08); + L71: + // mfp.w vf20, P | maddz.xyz vf13, vf31, vf16 + vu.acc.madd_xyz(vu.vf13, vu.vf31, vu.vf16.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf14, 0(vi10) | miniy.xyzw vf11, vf11, vf17 + vu.vf11.mini_xyzw(vu.vf11, vu.vf17.y()); sq_buffer_xyzw(vu.vf14, vu.vi10); + // sq.xyzw vf14, 0(vi13) | miniw.w vf09, vf09, vf03 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf03.w()); sq_buffer_xyzw(vu.vf14, vu.vi13); + // sq.xyzw vf21, 2(vi13) | mulaw.xyzw ACC, vf25, vf10 + vu.acc.mula_xyzw(vu.vf25, vu.vf10.w()); sq_buffer_xyzw(vu.vf21, vu.vi13 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf12, vf12, vf20 + vu.vf12.mul_xyzw(vu.vf12, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // erleng.xyz P, vf13 | ftoi0.xyzw vf11, vf11 + vu.vf11.ftoi0(Mask::xyzw, vu.vf11); vu.P = erleng(vu.vf13); /* TODO erleng */ +// BRANCH! + // ibeq vi07, vi03, L143 | maddaw.xyzw ACC, vf26, vf13 + vu.acc.madda_xyzw(vu.vf26, vu.vf13.w()); bc = (vu.vi07 == vu.vi03); + // mr32.z vf16, vf00 | maddw.xyzw vf10, vf27, vf16 + vu.acc.madd_xyzw(vu.vf10, vu.vf27, vu.vf16.w()); vu.vf16.z() = 1.f; + if (bc) { goto L143; } + + + L72: + // lqi.xyzw vf08, vi01 | mulax.xyzw ACC, vf01, vf12 + vu.acc.mula_xyzw(vu.vf01, vu.vf12.x()); lq_buffer_xyzw(vu.vf08, vu.vi01++); + // sq.xyzw vf11, 1(vi10) | madday.xyzw ACC, vf02, vf12 + vu.acc.madda_xyzw(vu.vf02, vu.vf12.y()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf11, 1(vi13) | maddz.xyzw vf12, vf03, vf12 + vu.acc.madd_xyzw(vu.vf12, vu.vf03, vu.vf12.z()); sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + // lqi.xyzw vf11, vi01 | add.xyzw vf10, vf10, vf28 + vu.vf10.add_xyzw(vu.vf10, vu.vf28); lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | maxw.w vf09, vf09, vf02 + vu.vf09.max(Mask::w, vu.vf09, vu.vf02.w()); lq_buffer_xyzw(vu.vf14, vu.vi01++); + // mtir vi10, vf08.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi10 = vu.vf08.x_as_u16(); + // mtir vi13, vf08.y | maxx.xyzw vf12, vf12, vf00 + vu.vf12.max_xyzw(vu.vf12, vu.vf00.x()); vu.vi13 = vu.vf08.y_as_u16(); + // div Q, vf01.w, vf10.w | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); vu.Q = vu.vf01.w() / vu.vf10.w(); + + // move.xyzw vf21, vf09 | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); vu.vf21.move_xyzw(vu.vf09); + // iand vi10, vi10, vi05 | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); vu.vi10 = vu.vi10 & vu.vi05; + // ilw.w vi08, -1(vi02) | mulax.xyzw ACC, vf04, vf12 + vu.acc.mula_xyzw(vu.vf04, vu.vf12.x()); ilw_buffer(Mask::w, vu.vi08, vu.vi02 + -1); +// BRANCH! + // ibgtz vi09, L73 | madday.xyzw ACC, vf05, vf12 + vu.acc.madda_xyzw(vu.vf05, vu.vf12.y()); bc = ((s16)vu.vi09) > 0; + // iand vi13, vi13, vi05 | maddaz.xyzw ACC, vf06, vf12 + vu.acc.madda_xyzw(vu.vf06, vu.vf12.z()); vu.vi13 = vu.vi13 & vu.vi05; + if (bc) { goto L73; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L73: +// BRANCH! + // ibne vi05, vi10, L74 | maddw.xyzw vf12, vf07, vf00 + vu.acc.madd_xyzw(vu.vf12, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi10); + // ilw.x vi09, -9(vi01) | mul.xyz vf10, vf10, Q + vu.vf10.mul(Mask::xyz, vu.vf10, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L74; } + + + // mtir vi10, vf11.x | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi13 = vu.vf11.y_as_u16(); +// BRANCH! + // b L75 | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L75; } + + + L74: + // lq.xyzw vf20, 0(vi10) | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi10); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf31, 0(vi13) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf31, vu.vi13); + // lq.xyzw vf25, 0(vi08) | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf23, 1(vi10) | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi10 + 1); + // lq.xyzw vf20, 1(vi13) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi13 + 1); + // lq.xyzw vf26, 1(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // lq.xyzw vf31, 2(vi10) | maddz.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi10 + 2); + // lq.xyzw vf23, 2(vi13) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi13 + 2); + // lq.xyzw vf27, 2(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lq.xyzw vf20, 3(vi10) | maddz.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 3); + // lq.xyzw vf31, 3(vi13) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf31, vu.vi13 + 3); + // lq.xyzw vf28, 3(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // lq.xyzw vf23, 4(vi10) | maddz.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 4); + // lq.xyzw vf20, 4(vi13) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi13 + 4); + // lq.xyz vf29, 4(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyzw vf31, 5(vi10) | maddz.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi10 + 5); + // lq.xyzw vf23, 5(vi13) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi13 + 5); + // lq.xyz vf30, 5(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); + // lq.xyzw vf20, 6(vi10) | maddz.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 6); + // lq.xyzw vf22, 6(vi13) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf22, vu.vi13 + 6); + // lq.xyzw vf31, 6(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + // lqi.xyzw vf23, vi02 | maddz.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi10, vf11.x | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | madday.xyzw ACC, vf22, vf24 + vu.acc.madda_xyzw(vu.vf22, vu.vf24.y()); vu.vi13 = vu.vf11.y_as_u16(); + // lq.xyzw vf22, 2(vi00) | maddz.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.z()); lq_buffer_xyzw(vu.vf22, 2); + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + L75: +// BRANCH! + // ibgez vi09, L76 | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi11) | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); sq_buffer_xyzw(vu.vf21, vu.vi11 + 2); + if (bc) { goto L76; } + + + // nop | ftoi4.xyzw vf21, vf09 + vu.vf21.ftoi4(Mask::xyzw, vu.vf09); + L76: + // mfp.w vf20, P | maddz.xyz vf11, vf31, vf14 + vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf15, 0(vi11) | miniy.xyzw vf12, vf12, vf17 + vu.vf12.mini_xyzw(vu.vf12, vu.vf17.y()); sq_buffer_xyzw(vu.vf15, vu.vi11); + // sq.xyzw vf15, 0(vi14) | miniw.w vf10, vf10, vf03 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf03.w()); sq_buffer_xyzw(vu.vf15, vu.vi14); + // sq.xyzw vf21, 2(vi14) | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); sq_buffer_xyzw(vu.vf21, vu.vi14 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf13, vf13, vf20 + vu.vf13.mul_xyzw(vu.vf13, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // erleng.xyz P, vf11 | ftoi0.xyzw vf12, vf12 + vu.vf12.ftoi0(Mask::xyzw, vu.vf12); vu.P = erleng(vu.vf11); /* TODO erleng */ +// BRANCH! + // ibeq vi07, vi03, L153 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); bc = (vu.vi07 == vu.vi03); + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + if (bc) { goto L153; } + + + L77: + // lqi.xyzw vf09, vi01 | mulax.xyzw ACC, vf01, vf13 + vu.acc.mula_xyzw(vu.vf01, vu.vf13.x()); lq_buffer_xyzw(vu.vf09, vu.vi01++); + // sq.xyzw vf12, 1(vi11) | madday.xyzw ACC, vf02, vf13 + vu.acc.madda_xyzw(vu.vf02, vu.vf13.y()); sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); + // sq.xyzw vf12, 1(vi14) | maddz.xyzw vf13, vf03, vf13 + vu.acc.madd_xyzw(vu.vf13, vu.vf03, vu.vf13.z()); sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | maxw.w vf10, vf10, vf02 + vu.vf10.max(Mask::w, vu.vf10, vu.vf02.w()); lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi11, vf09.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi11 = vu.vf09.x_as_u16(); + // mtir vi14, vf09.y | maxx.xyzw vf13, vf13, vf00 + vu.vf13.max_xyzw(vu.vf13, vu.vf00.x()); vu.vi14 = vu.vf09.y_as_u16(); + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // move.xyzw vf21, vf10 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vf21.move_xyzw(vu.vf10); + // iand vi11, vi11, vi05 | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); vu.vi11 = vu.vi11 & vu.vi05; + // ilw.w vi08, -1(vi02) | mulax.xyzw ACC, vf04, vf13 + vu.acc.mula_xyzw(vu.vf04, vu.vf13.x()); ilw_buffer(Mask::w, vu.vi08, vu.vi02 + -1); +// BRANCH! + // ibgtz vi09, L78 | madday.xyzw ACC, vf05, vf13 + vu.acc.madda_xyzw(vu.vf05, vu.vf13.y()); bc = ((s16)vu.vi09) > 0; + // iand vi14, vi14, vi05 | maddaz.xyzw ACC, vf06, vf13 + vu.acc.madda_xyzw(vu.vf06, vu.vf13.z()); vu.vi14 = vu.vi14 & vu.vi05; + if (bc) { goto L78; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L78: +// BRANCH! + // ibne vi05, vi11, L79 | maddw.xyzw vf13, vf07, vf00 + vu.acc.madd_xyzw(vu.vf13, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi11); + // ilw.x vi09, -9(vi01) | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L79; } + + + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L80 | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L80; } + + + L79: + // lq.xyzw vf20, 0(vi11) | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi11); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf31, 0(vi14) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf31, vu.vi14); + // lq.xyzw vf25, 0(vi08) | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf23, 1(vi11) | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi11 + 1); + // lq.xyzw vf20, 1(vi14) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi14 + 1); + // lq.xyzw vf26, 1(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // lq.xyzw vf31, 2(vi11) | maddz.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi11 + 2); + // lq.xyzw vf23, 2(vi14) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi14 + 2); + // lq.xyzw vf27, 2(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lq.xyzw vf20, 3(vi11) | maddz.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 3); + // lq.xyzw vf31, 3(vi14) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf31, vu.vi14 + 3); + // lq.xyzw vf28, 3(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // lq.xyzw vf23, 4(vi11) | maddz.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 4); + // lq.xyzw vf20, 4(vi14) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi14 + 4); + // lq.xyz vf29, 4(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyzw vf31, 5(vi11) | maddz.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi11 + 5); + // lq.xyzw vf23, 5(vi14) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi14 + 5); + // lq.xyz vf30, 5(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); + // lq.xyzw vf20, 6(vi11) | maddz.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 6); + // lq.xyzw vf22, 6(vi14) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf22, vu.vi14 + 6); + // lq.xyzw vf31, 6(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + // lqi.xyzw vf23, vi02 | maddz.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi11, vf12.x | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | madday.xyzw ACC, vf22, vf24 + vu.acc.madda_xyzw(vu.vf22, vu.vf24.y()); vu.vi14 = vu.vf12.y_as_u16(); + // lq.xyzw vf22, 2(vi00) | maddz.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.z()); lq_buffer_xyzw(vu.vf22, 2); + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + L80: +// BRANCH! + // ibgez vi09, L81 | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi12) | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); sq_buffer_xyzw(vu.vf21, vu.vi12 + 2); + if (bc) { goto L81; } + + + // nop | ftoi4.xyzw vf21, vf10 + vu.vf21.ftoi4(Mask::xyzw, vu.vf10); + L81: + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf16, 0(vi12) | miniy.xyzw vf13, vf13, vf17 + vu.vf13.mini_xyzw(vu.vf13, vu.vf17.y()); sq_buffer_xyzw(vu.vf16, vu.vi12); + // sq.xyzw vf16, 0(vi15) | miniw.w vf08, vf08, vf03 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); sq_buffer_xyzw(vu.vf16, vu.vi15); + // sq.xyzw vf21, 2(vi15) | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); sq_buffer_xyzw(vu.vf21, vu.vi15 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // erleng.xyz P, vf12 | ftoi0.xyzw vf13, vf13 + vu.vf13.ftoi0(Mask::xyzw, vu.vf13); vu.P = erleng(vu.vf12); /* TODO erleng */ +// BRANCH! + // ibne vi07, vi03, L66 | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); bc = (vu.vi07 != vu.vi03); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + if (bc) { goto L66; } + + +// BRANCH! + // b L163 | nop + bc = true; + // nop | nop + + if (bc) { goto L163; } + + + L82: + // erleng.xyz P, vf12 | maxi.xy vf08, vf08, I + vu.vf08.maxi(Mask::xy, vu.vf08, vu.I); vu.P = erleng(vu.vf12); /* TODO erleng */ + // 3072.0 | nop :i + vu.I = 3072.0; + // nop | minii.xy vf08, vf08, I + vu.vf08.minii(Mask::xy, vu.vf08, vu.I); + // nop | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + // lqi.xyzw vf10, vi01 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); lq_buffer_xyzw(vu.vf10, vu.vi01++); +// BRANCH! + // ibne vi04, vi03, L84 | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); bc = (vu.vi04 != vu.vi03); + // nop | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); + if (bc) { goto L84; } + + +// BRANCH! + // ibne vi06, vi03, JUMP_48E | nop + bc = (vu.vi06 != vu.vi03); + // nop | nop + + if (bc) { goto JUMP_48E; } + + +// BRANCH! + // b L128 | nop + bc = true; + // nop | nop + + if (bc) { goto L128; } + + + L83: + // 3072.0 | mulax.xyzw ACC, vf01, vf11 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); vu.I = 3072.0; + // lqi.xyzw vf10, vi01 | minii.xy vf08, vf08, I + vu.vf08.minii(Mask::xy, vu.vf08, vu.I); lq_buffer_xyzw(vu.vf10, vu.vi01++); + // sq.xyzw vf13, 1(vi12) | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); + // sq.xyzw vf13, 1(vi15) | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + L84: + // lqi.xyzw vf13, vi01 | add.xyzw vf09, vf09, vf28 + vu.vf09.add_xyzw(vu.vf09, vu.vf28); lq_buffer_xyzw(vu.vf13, vu.vi01++); + // lqi.xyzw vf16, vi01 | maxw.w vf08, vf08, vf02 + vu.vf08.max(Mask::w, vu.vf08, vu.vf02.w()); lq_buffer_xyzw(vu.vf16, vu.vi01++); + // mtir vi08, vf10.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi08 = vu.vf10.x_as_u16(); + // ilw.y vi09, -9(vi01) | maxx.xyzw vf11, vf11, vf00 + vu.vf11.max_xyzw(vu.vf11, vu.vf00.x()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -9); + // nop | miniw.w vf09, vf09, vf01 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf01.w()); + // div Q, vf01.w, vf09.w | add.zw vf10, vf10, vf17 + vu.vf10.add(Mask::zw, vu.vf10, vu.vf17); vu.Q = vu.vf01.w() / vu.vf09.w(); + + // move.xyzw vf21, vf08 | add.xyzw vf13, vf13, vf18 + vu.vf13.add_xyzw(vu.vf13, vu.vf18); vu.vf21.move_xyzw(vu.vf08); + // lq.xyz vf29, 4(vi08) | add.xyzw vf16, vf16, vf19 + vu.vf16.add_xyzw(vu.vf16, vu.vf19); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyz vf30, 5(vi08) | mulax.xyzw ACC, vf04, vf11 + vu.acc.mula_xyzw(vu.vf04, vu.vf11.x()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); +// BRANCH! + // ibgtz vi09, L85 | madday.xyzw ACC, vf05, vf11 + vu.acc.madda_xyzw(vu.vf05, vu.vf11.y()); bc = ((s16)vu.vi09) > 0; + // lq.xyzw vf31, 6(vi08) | maddaz.xyzw ACC, vf06, vf11 + vu.acc.madda_xyzw(vu.vf06, vu.vf11.z()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + if (bc) { goto L85; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L85: + // lq.xyzw vf25, 0(vi08) | maddw.xyzw vf11, vf07, vf00 + vu.acc.madd_xyzw(vu.vf11, vu.vf07, vu.vf00.w()); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf26, 1(vi08) | mul.xyz vf09, vf09, Q + vu.vf09.mul(Mask::xyz, vu.vf09, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // mtir vi12, vf13.x | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi15 = vu.vf13.y_as_u16(); + // lq.xyzw vf27, 2(vi08) | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lqi.xyzw vf23, vi03 | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); +// BRANCH! + // ibne vi00, vi09, L86 | mulaz.xyzw ACC, vf29, vf10 + vu.acc.mula_xyzw(vu.vf29, vu.vf10.z()); bc = (vu.vi09 != 0); + // sq.xyzw vf21, 2(vi10) | maddaz.xyzw ACC, vf30, vf13 + vu.acc.madda_xyzw(vu.vf30, vu.vf13.z()); sq_buffer_xyzw(vu.vf21, vu.vi10 + 2); + if (bc) { goto L86; } + + + // nop | ftoi4.xyzw vf21, vf08 + vu.vf21.ftoi4(Mask::xyzw, vu.vf08); + L86: + // mfp.w vf20, P | maddz.xyz vf13, vf31, vf16 + vu.acc.madd_xyz(vu.vf13, vu.vf31, vu.vf16.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf14, 0(vi10) | miniy.xyzw vf11, vf11, vf17 + vu.vf11.mini_xyzw(vu.vf11, vu.vf17.y()); sq_buffer_xyzw(vu.vf14, vu.vi10); + // sq.xyzw vf14, 0(vi13) | miniw.w vf09, vf09, vf03 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf03.w()); sq_buffer_xyzw(vu.vf14, vu.vi13); + // sq.xyzw vf21, 2(vi13) | mulaw.xyzw ACC, vf25, vf10 + vu.acc.mula_xyzw(vu.vf25, vu.vf10.w()); sq_buffer_xyzw(vu.vf21, vu.vi13 + 2); + // lq.xyzw vf28, 3(vi08) | mulw.xyzw vf12, vf12, vf20 + vu.vf12.mul_xyzw(vu.vf12, vu.vf20.w()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // 1024.0 | ftoi0.xyzw vf11, vf11 :i + vu.vf11.ftoi0(Mask::xyzw, vu.vf11); vu.I = 1024.0; + // erleng.xyz P, vf13 | maxi.xy vf09, vf09, I + vu.vf09.maxi(Mask::xy, vu.vf09, vu.I); vu.P = erleng(vu.vf13); /* TODO erleng */ +// BRANCH! + // ibne vi04, vi03, L87 | maddaw.xyzw ACC, vf26, vf13 + vu.acc.madda_xyzw(vu.vf26, vu.vf13.w()); bc = (vu.vi04 != vu.vi03); + // mr32.z vf16, vf00 | maddw.xyzw vf10, vf27, vf16 + vu.acc.madd_xyzw(vu.vf10, vu.vf27, vu.vf16.w()); vu.vf16.z() = 1.f; + if (bc) { goto L87; } + + +// BRANCH! + // ibne vi06, vi03, L100 | nop + bc = (vu.vi06 != vu.vi03); + // ilw.y vi09, -6(vi01) | nop + ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + if (bc) { goto L100; } + + +// BRANCH! + // ibne vi07, vi03, L133 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L133; } + + +// BRANCH! + // b L143 | nop + bc = true; + // nop | nop + + if (bc) { goto L143; } + + + L87: + // 3072.0 | mulax.xyzw ACC, vf01, vf12 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf12.x()); vu.I = 3072.0; + // lqi.xyzw vf08, vi01 | minii.xy vf09, vf09, I + vu.vf09.minii(Mask::xy, vu.vf09, vu.I); lq_buffer_xyzw(vu.vf08, vu.vi01++); + // sq.xyzw vf11, 1(vi10) | madday.xyzw ACC, vf02, vf12 + vu.acc.madda_xyzw(vu.vf02, vu.vf12.y()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf11, 1(vi13) | maddz.xyzw vf12, vf03, vf12 + vu.acc.madd_xyzw(vu.vf12, vu.vf03, vu.vf12.z()); sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + // lqi.xyzw vf11, vi01 | add.xyzw vf10, vf10, vf28 + vu.vf10.add_xyzw(vu.vf10, vu.vf28); lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | maxw.w vf09, vf09, vf02 + vu.vf09.max(Mask::w, vu.vf09, vu.vf02.w()); lq_buffer_xyzw(vu.vf14, vu.vi01++); + // mtir vi08, vf08.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi08 = vu.vf08.x_as_u16(); + // ilw.y vi09, -9(vi01) | maxx.xyzw vf12, vf12, vf00 + vu.vf12.max_xyzw(vu.vf12, vu.vf00.x()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -9); + // nop | miniw.w vf10, vf10, vf01 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf01.w()); + // div Q, vf01.w, vf10.w | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); vu.Q = vu.vf01.w() / vu.vf10.w(); + + // move.xyzw vf21, vf09 | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); vu.vf21.move_xyzw(vu.vf09); + // lq.xyz vf29, 4(vi08) | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyz vf30, 5(vi08) | mulax.xyzw ACC, vf04, vf12 + vu.acc.mula_xyzw(vu.vf04, vu.vf12.x()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); +// BRANCH! + // ibgtz vi09, L88 | madday.xyzw ACC, vf05, vf12 + vu.acc.madda_xyzw(vu.vf05, vu.vf12.y()); bc = ((s16)vu.vi09) > 0; + // lq.xyzw vf31, 6(vi08) | maddaz.xyzw ACC, vf06, vf12 + vu.acc.madda_xyzw(vu.vf06, vu.vf12.z()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + if (bc) { goto L88; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L88: + // lq.xyzw vf25, 0(vi08) | maddw.xyzw vf12, vf07, vf00 + vu.acc.madd_xyzw(vu.vf12, vu.vf07, vu.vf00.w()); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf26, 1(vi08) | mul.xyz vf10, vf10, Q + vu.vf10.mul(Mask::xyz, vu.vf10, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // mtir vi10, vf11.x | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi13 = vu.vf11.y_as_u16(); + // lq.xyzw vf27, 2(vi08) | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lqi.xyzw vf23, vi03 | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); +// BRANCH! + // ibne vi00, vi09, L89 | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); bc = (vu.vi09 != 0); + // sq.xyzw vf21, 2(vi11) | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); sq_buffer_xyzw(vu.vf21, vu.vi11 + 2); + if (bc) { goto L89; } + + + // nop | ftoi4.xyzw vf21, vf09 + vu.vf21.ftoi4(Mask::xyzw, vu.vf09); + L89: + // mfp.w vf20, P | maddz.xyz vf11, vf31, vf14 + vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf15, 0(vi11) | miniy.xyzw vf12, vf12, vf17 + vu.vf12.mini_xyzw(vu.vf12, vu.vf17.y()); sq_buffer_xyzw(vu.vf15, vu.vi11); + // sq.xyzw vf15, 0(vi14) | miniw.w vf10, vf10, vf03 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf03.w()); sq_buffer_xyzw(vu.vf15, vu.vi14); + // sq.xyzw vf21, 2(vi14) | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); sq_buffer_xyzw(vu.vf21, vu.vi14 + 2); + // lq.xyzw vf28, 3(vi08) | mulw.xyzw vf13, vf13, vf20 + vu.vf13.mul_xyzw(vu.vf13, vu.vf20.w()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // 1024.0 | ftoi0.xyzw vf12, vf12 :i + vu.vf12.ftoi0(Mask::xyzw, vu.vf12); vu.I = 1024.0; + // erleng.xyz P, vf11 | maxi.xy vf10, vf10, I + vu.vf10.maxi(Mask::xy, vu.vf10, vu.I); vu.P = erleng(vu.vf11); /* TODO erleng */ +// BRANCH! + // ibne vi04, vi03, L90 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); bc = (vu.vi04 != vu.vi03); + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + if (bc) { goto L90; } + + +// BRANCH! + // ibne vi06, vi03, L105 | nop + bc = (vu.vi06 != vu.vi03); + // ilw.y vi09, -6(vi01) | nop + ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + if (bc) { goto L105; } + + +// BRANCH! + // ibne vi07, vi03, L138 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L138; } + + +// BRANCH! + // b L153 | nop + bc = true; + // nop | nop + + if (bc) { goto L153; } + + + L90: + // 3072.0 | mulax.xyzw ACC, vf01, vf13 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf13.x()); vu.I = 3072.0; + // lqi.xyzw vf09, vi01 | minii.xy vf10, vf10, I + vu.vf10.minii(Mask::xy, vu.vf10, vu.I); lq_buffer_xyzw(vu.vf09, vu.vi01++); + // sq.xyzw vf12, 1(vi11) | madday.xyzw ACC, vf02, vf13 + vu.acc.madda_xyzw(vu.vf02, vu.vf13.y()); sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); + // sq.xyzw vf12, 1(vi14) | maddz.xyzw vf13, vf03, vf13 + vu.acc.madd_xyzw(vu.vf13, vu.vf03, vu.vf13.z()); sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | maxw.w vf10, vf10, vf02 + vu.vf10.max(Mask::w, vu.vf10, vu.vf02.w()); lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi08, vf09.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi08 = vu.vf09.x_as_u16(); + // ilw.y vi09, -9(vi01) | maxx.xyzw vf13, vf13, vf00 + vu.vf13.max_xyzw(vu.vf13, vu.vf00.x()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -9); + // nop | miniw.w vf08, vf08, vf01 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf01.w()); + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // move.xyzw vf21, vf10 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vf21.move_xyzw(vu.vf10); + // lq.xyz vf29, 4(vi08) | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyz vf30, 5(vi08) | mulax.xyzw ACC, vf04, vf13 + vu.acc.mula_xyzw(vu.vf04, vu.vf13.x()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); +// BRANCH! + // ibgtz vi09, L91 | madday.xyzw ACC, vf05, vf13 + vu.acc.madda_xyzw(vu.vf05, vu.vf13.y()); bc = ((s16)vu.vi09) > 0; + // lq.xyzw vf31, 6(vi08) | maddaz.xyzw ACC, vf06, vf13 + vu.acc.madda_xyzw(vu.vf06, vu.vf13.z()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + if (bc) { goto L91; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L91: + // lq.xyzw vf25, 0(vi08) | maddw.xyzw vf13, vf07, vf00 + vu.acc.madd_xyzw(vu.vf13, vu.vf07, vu.vf00.w()); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf26, 1(vi08) | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi14 = vu.vf12.y_as_u16(); + // lq.xyzw vf27, 2(vi08) | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); +// BRANCH! + // ibne vi00, vi09, L92 | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); bc = (vu.vi09 != 0); + // sq.xyzw vf21, 2(vi12) | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); sq_buffer_xyzw(vu.vf21, vu.vi12 + 2); + if (bc) { goto L92; } + + + // nop | ftoi4.xyzw vf21, vf10 + vu.vf21.ftoi4(Mask::xyzw, vu.vf10); + L92: + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf16, 0(vi12) | miniy.xyzw vf13, vf13, vf17 + vu.vf13.mini_xyzw(vu.vf13, vu.vf17.y()); sq_buffer_xyzw(vu.vf16, vu.vi12); + // sq.xyzw vf16, 0(vi15) | miniw.w vf08, vf08, vf03 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); sq_buffer_xyzw(vu.vf16, vu.vi15); + // sq.xyzw vf21, 2(vi15) | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); sq_buffer_xyzw(vu.vf21, vu.vi15 + 2); + // lq.xyzw vf28, 3(vi08) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // 1024.0 | ftoi0.xyzw vf13, vf13 :i + vu.vf13.ftoi0(Mask::xyzw, vu.vf13); vu.I = 1024.0; + // erleng.xyz P, vf12 | maxi.xy vf08, vf08, I + vu.vf08.maxi(Mask::xy, vu.vf08, vu.I); vu.P = erleng(vu.vf12); /* TODO erleng */ +// BRANCH! + // ibne vi04, vi03, L83 | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); bc = (vu.vi04 != vu.vi03); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + if (bc) { goto L83; } + + +// BRANCH! + // ibne vi06, vi03, L94 | nop + bc = (vu.vi06 != vu.vi03); + // ilw.y vi09, -6(vi01) | nop + ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + if (bc) { goto L94; } + + +// BRANCH! + // ibne vi07, vi03, L127 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L127; } + + +// BRANCH! + // b L163 | nop + bc = true; + // nop | nop + + if (bc) { goto L163; } + + + L93: + // erleng.xyz P, vf12 | maxi.xy vf08, vf08, I + vu.vf08.maxi(Mask::xy, vu.vf08, vu.I); vu.P = erleng(vu.vf12); /* TODO erleng */ + // 3072.0 | nop :i + vu.I = 3072.0; + // nop | minii.xy vf08, vf08, I + vu.vf08.minii(Mask::xy, vu.vf08, vu.I); +// BRANCH! + // ibeq vi06, vi03, L126 | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); bc = (vu.vi06 == vu.vi03); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + if (bc) { goto L126; } + + + // lqi.xyzw vf10, vi01 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); lq_buffer_xyzw(vu.vf10, vu.vi01++); + // jr vi08 | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); + // nop | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); + switch (vu.vi08) { + case 0x1a1: + goto JUMP_1A1; + case 0x48e: + goto JUMP_48E; + case 0x243: + goto JUMP_243; + case 0x539: + goto JUMP_539; + default: + fmt::print("bad jump to {:x}\n", vu.vi08); + assert(false); + } + L94: + // 3072.0 | mulax.xyzw ACC, vf01, vf11 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); vu.I = 3072.0; + // lqi.xyzw vf10, vi01 | minii.xy vf08, vf08, I + vu.vf08.minii(Mask::xy, vu.vf08, vu.I); lq_buffer_xyzw(vu.vf10, vu.vi01++); + // sq.xyzw vf13, 1(vi12) | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); + // sq.xyzw vf13, 1(vi15) | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + JUMP_48E: + // lqi.xyzw vf13, vi01 | add.xyzw vf09, vf09, vf28 + vu.vf09.add_xyzw(vu.vf09, vu.vf28); lq_buffer_xyzw(vu.vf13, vu.vi01++); + // lqi.xyzw vf16, vi01 | maxw.w vf08, vf08, vf02 + vu.vf08.max(Mask::w, vu.vf08, vu.vf02.w()); lq_buffer_xyzw(vu.vf16, vu.vi01++); + // mtir vi12, vf10.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi12 = vu.vf10.x_as_u16(); + // mtir vi15, vf10.y | maxx.xyzw vf11, vf11, vf00 + vu.vf11.max_xyzw(vu.vf11, vu.vf00.x()); vu.vi15 = vu.vf10.y_as_u16(); + // nop | miniw.w vf09, vf09, vf01 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf01.w()); + // div Q, vf01.w, vf09.w | add.zw vf10, vf10, vf17 + vu.vf10.add(Mask::zw, vu.vf10, vu.vf17); vu.Q = vu.vf01.w() / vu.vf09.w(); + + // move.xyzw vf21, vf08 | add.xyzw vf13, vf13, vf18 + vu.vf13.add_xyzw(vu.vf13, vu.vf18); vu.vf21.move_xyzw(vu.vf08); + // iand vi12, vi12, vi05 | add.xyzw vf16, vf16, vf19 + vu.vf16.add_xyzw(vu.vf16, vu.vf19); vu.vi12 = vu.vi12 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf11 + vu.acc.mula_xyzw(vu.vf04, vu.vf11.x()); +// BRANCH! + // ibgtz vi09, L96 | madday.xyzw ACC, vf05, vf11 + vu.acc.madda_xyzw(vu.vf05, vu.vf11.y()); bc = ((s16)vu.vi09) > 0; + // iand vi15, vi15, vi05 | maddaz.xyzw ACC, vf06, vf11 + vu.acc.madda_xyzw(vu.vf06, vu.vf11.z()); vu.vi15 = vu.vi15 & vu.vi05; + if (bc) { goto L96; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L96: +// BRANCH! + // ibne vi05, vi12, L97 | maddw.xyzw vf11, vf07, vf00 + vu.acc.madd_xyzw(vu.vf11, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi12); + // ilw.x vi09, -9(vi01) | mul.xyz vf09, vf09, Q + vu.vf09.mul(Mask::xyz, vu.vf09, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L97; } + + + // mtir vi12, vf13.x | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi15 = vu.vf13.y_as_u16(); +// BRANCH! + // b L98 | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L98; } + + + L97: + // lq.xyzw vf20, 0(vi12) | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi12); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf25, 0(vi15) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi15); + // lq.xyzw vf23, 1(vi12) | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi12 + 1); + // lq.xyzw vf26, 1(vi15) | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi15 + 1); + // lq.xyzw vf20, 2(vi12) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 2); + // lq.xyzw vf27, 2(vi15) | maddy.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi15 + 2); + // lq.xyzw vf23, 3(vi12) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi12 + 3); + // lq.xyzw vf28, 3(vi15) | maddy.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi15 + 3); + // lq.xyzw vf20, 4(vi12) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 4); + // lq.xyz vf29, 4(vi15) | maddy.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi15 + 4); + // lq.xyzw vf23, 5(vi12) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi12 + 5); + // lq.xyz vf30, 5(vi15) | maddy.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi15 + 5); + // lq.xyzw vf20, 6(vi12) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 6); + // lq.xyzw vf31, 6(vi15) | maddy.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi15 + 6); + // mtir vi12, vf13.x | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | maddy.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.y()); vu.vi15 = vu.vf13.y_as_u16(); +// BRANCH! + // b L113 | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); bc = true; + // lqi.xyzw vf23, vi03 | maddy.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L113; } + + + L98: +// BRANCH! + // ibgez vi09, L99 | mulaz.xyzw ACC, vf29, vf10 + vu.acc.mula_xyzw(vu.vf29, vu.vf10.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi10) | maddaz.xyzw ACC, vf30, vf13 + vu.acc.madda_xyzw(vu.vf30, vu.vf13.z()); sq_buffer_xyzw(vu.vf21, vu.vi10 + 2); + if (bc) { goto L99; } + + + // nop | ftoi4.xyzw vf21, vf08 + vu.vf21.ftoi4(Mask::xyzw, vu.vf08); + L99: + // mfp.w vf20, P | maddz.xyz vf13, vf31, vf16 + vu.acc.madd_xyz(vu.vf13, vu.vf31, vu.vf16.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf14, 0(vi10) | miniy.xyzw vf11, vf11, vf17 + vu.vf11.mini_xyzw(vu.vf11, vu.vf17.y()); sq_buffer_xyzw(vu.vf14, vu.vi10); + // sq.xyzw vf14, 0(vi13) | miniw.w vf09, vf09, vf03 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf03.w()); sq_buffer_xyzw(vu.vf14, vu.vi13); + // sq.xyzw vf21, 2(vi13) | mulaw.xyzw ACC, vf25, vf10 + vu.acc.mula_xyzw(vu.vf25, vu.vf10.w()); sq_buffer_xyzw(vu.vf21, vu.vi13 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf12, vf12, vf20 + vu.vf12.mul_xyzw(vu.vf12, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // 1024.0 | ftoi0.xyzw vf11, vf11 :i + vu.vf11.ftoi0(Mask::xyzw, vu.vf11); vu.I = 1024.0; + // erleng.xyz P, vf13 | maxi.xy vf09, vf09, I + vu.vf09.maxi(Mask::xy, vu.vf09, vu.I); vu.P = erleng(vu.vf13); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L100 | maddaw.xyzw ACC, vf26, vf13 + vu.acc.madda_xyzw(vu.vf26, vu.vf13.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf16, vf00 | maddw.xyzw vf10, vf27, vf16 + vu.acc.madd_xyzw(vu.vf10, vu.vf27, vu.vf16.w()); vu.vf16.z() = 1.f; + if (bc) { goto L100; } + + +// BRANCH! + // ibne vi07, vi03, L133 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L133; } + + +// BRANCH! + // b L143 | nop + bc = true; + // nop | nop + + if (bc) { goto L143; } + + + L100: + // 3072.0 | mulax.xyzw ACC, vf01, vf12 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf12.x()); vu.I = 3072.0; + // lqi.xyzw vf08, vi01 | minii.xy vf09, vf09, I + vu.vf09.minii(Mask::xy, vu.vf09, vu.I); lq_buffer_xyzw(vu.vf08, vu.vi01++); + // sq.xyzw vf11, 1(vi10) | madday.xyzw ACC, vf02, vf12 + vu.acc.madda_xyzw(vu.vf02, vu.vf12.y()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf11, 1(vi13) | maddz.xyzw vf12, vf03, vf12 + vu.acc.madd_xyzw(vu.vf12, vu.vf03, vu.vf12.z()); sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + // lqi.xyzw vf11, vi01 | add.xyzw vf10, vf10, vf28 + vu.vf10.add_xyzw(vu.vf10, vu.vf28); lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | maxw.w vf09, vf09, vf02 + vu.vf09.max(Mask::w, vu.vf09, vu.vf02.w()); lq_buffer_xyzw(vu.vf14, vu.vi01++); + // mtir vi10, vf08.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi10 = vu.vf08.x_as_u16(); + // mtir vi13, vf08.y | maxx.xyzw vf12, vf12, vf00 + vu.vf12.max_xyzw(vu.vf12, vu.vf00.x()); vu.vi13 = vu.vf08.y_as_u16(); + // nop | miniw.w vf10, vf10, vf01 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf01.w()); + // div Q, vf01.w, vf10.w | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); vu.Q = vu.vf01.w() / vu.vf10.w(); + + // move.xyzw vf21, vf09 | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); vu.vf21.move_xyzw(vu.vf09); + // iand vi10, vi10, vi05 | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); vu.vi10 = vu.vi10 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf12 + vu.acc.mula_xyzw(vu.vf04, vu.vf12.x()); +// BRANCH! + // ibgtz vi09, L101 | madday.xyzw ACC, vf05, vf12 + vu.acc.madda_xyzw(vu.vf05, vu.vf12.y()); bc = ((s16)vu.vi09) > 0; + // iand vi13, vi13, vi05 | maddaz.xyzw ACC, vf06, vf12 + vu.acc.madda_xyzw(vu.vf06, vu.vf12.z()); vu.vi13 = vu.vi13 & vu.vi05; + if (bc) { goto L101; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L101: +// BRANCH! + // ibne vi05, vi10, L102 | maddw.xyzw vf12, vf07, vf00 + vu.acc.madd_xyzw(vu.vf12, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi10); + // ilw.x vi09, -9(vi01) | mul.xyz vf10, vf10, Q + vu.vf10.mul(Mask::xyz, vu.vf10, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L102; } + + + // mtir vi10, vf11.x | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi13 = vu.vf11.y_as_u16(); +// BRANCH! + // b L103 | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L103; } + + + L102: + // lq.xyzw vf20, 0(vi10) | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi10); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf25, 0(vi13) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi13); + // lq.xyzw vf23, 1(vi10) | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi10 + 1); + // lq.xyzw vf26, 1(vi13) | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi13 + 1); + // lq.xyzw vf20, 2(vi10) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 2); + // lq.xyzw vf27, 2(vi13) | maddy.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi13 + 2); + // lq.xyzw vf23, 3(vi10) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 3); + // lq.xyzw vf28, 3(vi13) | maddy.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi13 + 3); + // lq.xyzw vf20, 4(vi10) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 4); + // lq.xyz vf29, 4(vi13) | maddy.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi13 + 4); + // lq.xyzw vf23, 5(vi10) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 5); + // lq.xyz vf30, 5(vi13) | maddy.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi13 + 5); + // lq.xyzw vf20, 6(vi10) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 6); + // lq.xyzw vf31, 6(vi13) | maddy.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi13 + 6); + // mtir vi10, vf11.x | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | maddy.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.y()); vu.vi13 = vu.vf11.y_as_u16(); +// BRANCH! + // b L118 | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); bc = true; + // lqi.xyzw vf23, vi03 | maddy.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L118; } + + + L103: +// BRANCH! + // ibgez vi09, L104 | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi11) | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); sq_buffer_xyzw(vu.vf21, vu.vi11 + 2); + if (bc) { goto L104; } + + + // nop | ftoi4.xyzw vf21, vf09 + vu.vf21.ftoi4(Mask::xyzw, vu.vf09); + L104: + // mfp.w vf20, P | maddz.xyz vf11, vf31, vf14 + vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf15, 0(vi11) | miniy.xyzw vf12, vf12, vf17 + vu.vf12.mini_xyzw(vu.vf12, vu.vf17.y()); sq_buffer_xyzw(vu.vf15, vu.vi11); + // sq.xyzw vf15, 0(vi14) | miniw.w vf10, vf10, vf03 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf03.w()); sq_buffer_xyzw(vu.vf15, vu.vi14); + // sq.xyzw vf21, 2(vi14) | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); sq_buffer_xyzw(vu.vf21, vu.vi14 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf13, vf13, vf20 + vu.vf13.mul_xyzw(vu.vf13, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // 1024.0 | ftoi0.xyzw vf12, vf12 :i + vu.vf12.ftoi0(Mask::xyzw, vu.vf12); vu.I = 1024.0; + // erleng.xyz P, vf11 | maxi.xy vf10, vf10, I + vu.vf10.maxi(Mask::xy, vu.vf10, vu.I); vu.P = erleng(vu.vf11); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L105 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + if (bc) { goto L105; } + + +// BRANCH! + // ibne vi07, vi03, L138 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L138; } + + +// BRANCH! + // b L153 | nop + bc = true; + // nop | nop + + if (bc) { goto L153; } + + + L105: + // 3072.0 | mulax.xyzw ACC, vf01, vf13 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf13.x()); vu.I = 3072.0; + // lqi.xyzw vf09, vi01 | minii.xy vf10, vf10, I + vu.vf10.minii(Mask::xy, vu.vf10, vu.I); lq_buffer_xyzw(vu.vf09, vu.vi01++); + // sq.xyzw vf12, 1(vi11) | madday.xyzw ACC, vf02, vf13 + vu.acc.madda_xyzw(vu.vf02, vu.vf13.y()); sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); + // sq.xyzw vf12, 1(vi14) | maddz.xyzw vf13, vf03, vf13 + vu.acc.madd_xyzw(vu.vf13, vu.vf03, vu.vf13.z()); sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | maxw.w vf10, vf10, vf02 + vu.vf10.max(Mask::w, vu.vf10, vu.vf02.w()); lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi11, vf09.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi11 = vu.vf09.x_as_u16(); + // mtir vi14, vf09.y | maxx.xyzw vf13, vf13, vf00 + vu.vf13.max_xyzw(vu.vf13, vu.vf00.x()); vu.vi14 = vu.vf09.y_as_u16(); + // nop | miniw.w vf08, vf08, vf01 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf01.w()); + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // move.xyzw vf21, vf10 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vf21.move_xyzw(vu.vf10); + // iand vi11, vi11, vi05 | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); vu.vi11 = vu.vi11 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf13 + vu.acc.mula_xyzw(vu.vf04, vu.vf13.x()); +// BRANCH! + // ibgtz vi09, L106 | madday.xyzw ACC, vf05, vf13 + vu.acc.madda_xyzw(vu.vf05, vu.vf13.y()); bc = ((s16)vu.vi09) > 0; + // iand vi14, vi14, vi05 | maddaz.xyzw ACC, vf06, vf13 + vu.acc.madda_xyzw(vu.vf06, vu.vf13.z()); vu.vi14 = vu.vi14 & vu.vi05; + if (bc) { goto L106; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L106: +// BRANCH! + // ibne vi05, vi11, L107 | maddw.xyzw vf13, vf07, vf00 + vu.acc.madd_xyzw(vu.vf13, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi11); + // ilw.x vi09, -9(vi01) | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L107; } + + + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L108 | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L108; } + + + L107: + // lq.xyzw vf20, 0(vi11) | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi11); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf25, 0(vi14) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi14); + // lq.xyzw vf23, 1(vi11) | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi11 + 1); + // lq.xyzw vf26, 1(vi14) | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi14 + 1); + // lq.xyzw vf20, 2(vi11) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 2); + // lq.xyzw vf27, 2(vi14) | maddy.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi14 + 2); + // lq.xyzw vf23, 3(vi11) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 3); + // lq.xyzw vf28, 3(vi14) | maddy.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi14 + 3); + // lq.xyzw vf20, 4(vi11) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 4); + // lq.xyz vf29, 4(vi14) | maddy.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi14 + 4); + // lq.xyzw vf23, 5(vi11) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 5); + // lq.xyz vf30, 5(vi14) | maddy.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi14 + 5); + // lq.xyzw vf20, 6(vi11) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 6); + // lq.xyzw vf31, 6(vi14) | maddy.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi14 + 6); + // mtir vi11, vf12.x | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | maddy.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.y()); vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L123 | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); bc = true; + // lqi.xyzw vf23, vi03 | maddy.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L123; } + + + L108: +// BRANCH! + // ibgez vi09, L109 | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi12) | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); sq_buffer_xyzw(vu.vf21, vu.vi12 + 2); + if (bc) { goto L109; } + + + // nop | ftoi4.xyzw vf21, vf10 + vu.vf21.ftoi4(Mask::xyzw, vu.vf10); + L109: + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf16, 0(vi12) | miniy.xyzw vf13, vf13, vf17 + vu.vf13.mini_xyzw(vu.vf13, vu.vf17.y()); sq_buffer_xyzw(vu.vf16, vu.vi12); + // sq.xyzw vf16, 0(vi15) | miniw.w vf08, vf08, vf03 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); sq_buffer_xyzw(vu.vf16, vu.vi15); + // sq.xyzw vf21, 2(vi15) | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); sq_buffer_xyzw(vu.vf21, vu.vi15 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // 1024.0 | ftoi0.xyzw vf13, vf13 :i + vu.vf13.ftoi0(Mask::xyzw, vu.vf13); vu.I = 1024.0; + // erleng.xyz P, vf12 | maxi.xy vf08, vf08, I + vu.vf08.maxi(Mask::xy, vu.vf08, vu.I); vu.P = erleng(vu.vf12); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L94 | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + if (bc) { goto L94; } + + +// BRANCH! + // ibne vi07, vi03, L127 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L127; } + + +// BRANCH! + // b L163 | nop + bc = true; + // nop | nop + + if (bc) { goto L163; } + + + L110: + // 3072.0 | mulax.xyzw ACC, vf01, vf11 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); vu.I = 3072.0; + // lqi.xyzw vf10, vi01 | minii.xy vf08, vf08, I + vu.vf08.minii(Mask::xy, vu.vf08, vu.I); lq_buffer_xyzw(vu.vf10, vu.vi01++); + // sq.xyzw vf13, 1(vi12) | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); + // sq.xyzw vf13, 1(vi15) | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + JUMP_539: + // lqi.xyzw vf13, vi01 | add.xyzw vf09, vf09, vf28 + vu.vf09.add_xyzw(vu.vf09, vu.vf28); lq_buffer_xyzw(vu.vf13, vu.vi01++); + // lqi.xyzw vf16, vi01 | maxw.w vf08, vf08, vf02 + vu.vf08.max(Mask::w, vu.vf08, vu.vf02.w()); lq_buffer_xyzw(vu.vf16, vu.vi01++); + // mtir vi12, vf10.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi12 = vu.vf10.x_as_u16(); + // mtir vi15, vf10.y | maxx.xyzw vf11, vf11, vf00 + vu.vf11.max_xyzw(vu.vf11, vu.vf00.x()); vu.vi15 = vu.vf10.y_as_u16(); + // nop | miniw.w vf09, vf09, vf01 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf01.w()); + // div Q, vf01.w, vf09.w | add.zw vf10, vf10, vf17 + vu.vf10.add(Mask::zw, vu.vf10, vu.vf17); vu.Q = vu.vf01.w() / vu.vf09.w(); + + // move.xyzw vf21, vf08 | add.xyzw vf13, vf13, vf18 + vu.vf13.add_xyzw(vu.vf13, vu.vf18); vu.vf21.move_xyzw(vu.vf08); + // iand vi12, vi12, vi05 | add.xyzw vf16, vf16, vf19 + vu.vf16.add_xyzw(vu.vf16, vu.vf19); vu.vi12 = vu.vi12 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf11 + vu.acc.mula_xyzw(vu.vf04, vu.vf11.x()); +// BRANCH! + // ibgtz vi09, L111 | madday.xyzw ACC, vf05, vf11 + vu.acc.madda_xyzw(vu.vf05, vu.vf11.y()); bc = ((s16)vu.vi09) > 0; + // iand vi15, vi15, vi05 | maddaz.xyzw ACC, vf06, vf11 + vu.acc.madda_xyzw(vu.vf06, vu.vf11.z()); vu.vi15 = vu.vi15 & vu.vi05; + if (bc) { goto L111; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L111: +// BRANCH! + // ibne vi05, vi12, L112 | maddw.xyzw vf11, vf07, vf00 + vu.acc.madd_xyzw(vu.vf11, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi12); + // ilw.x vi09, -9(vi01) | mul.xyz vf09, vf09, Q + vu.vf09.mul(Mask::xyz, vu.vf09, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L112; } + + + // mtir vi12, vf13.x | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi15 = vu.vf13.y_as_u16(); +// BRANCH! + // b L113 | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L113; } + + + L112: + // lq.xyzw vf20, 0(vi12) | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi12); + // lq.xyzw vf25, 0(vi15) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi15); + // lq.xyzw vf23, 1(vi12) | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi12 + 1); + // lq.xyzw vf26, 1(vi15) | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi15 + 1); + // lq.xyzw vf20, 2(vi12) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 2); + // lq.xyzw vf27, 2(vi15) | maddw.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.w()); lq_buffer_xyzw(vu.vf27, vu.vi15 + 2); + // lq.xyzw vf23, 3(vi12) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi12 + 3); + // lq.xyzw vf28, 3(vi15) | maddw.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.w()); lq_buffer_xyzw(vu.vf28, vu.vi15 + 3); + // lq.xyzw vf20, 4(vi12) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 4); + // lq.xyz vf29, 4(vi15) | maddw.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.w()); lq_buffer_xyz(vu.vf29, vu.vi15 + 4); + // lq.xyzw vf23, 5(vi12) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi12 + 5); + // lq.xyz vf30, 5(vi15) | maddw.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.w()); lq_buffer_xyz(vu.vf30, vu.vi15 + 5); + // lq.xyzw vf20, 6(vi12) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 6); + // lq.xyzw vf31, 6(vi15) | maddw.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.w()); lq_buffer_xyzw(vu.vf31, vu.vi15 + 6); + // lqi.xyzw vf23, vi02 | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi12, vf13.x | maddw.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.w()); vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); vu.vi15 = vu.vf13.y_as_u16(); +// BRANCH! + // b L98 | maddw.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.w()); bc = true; + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L98; } + + + L113: +// BRANCH! + // ibgez vi09, L114 | mulaz.xyzw ACC, vf29, vf10 + vu.acc.mula_xyzw(vu.vf29, vu.vf10.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi10) | maddaz.xyzw ACC, vf30, vf13 + vu.acc.madda_xyzw(vu.vf30, vu.vf13.z()); sq_buffer_xyzw(vu.vf21, vu.vi10 + 2); + if (bc) { goto L114; } + + + // nop | ftoi4.xyzw vf21, vf08 + vu.vf21.ftoi4(Mask::xyzw, vu.vf08); + L114: + // mfp.w vf20, P | maddz.xyz vf13, vf31, vf16 + vu.acc.madd_xyz(vu.vf13, vu.vf31, vu.vf16.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf14, 0(vi10) | miniy.xyzw vf11, vf11, vf17 + vu.vf11.mini_xyzw(vu.vf11, vu.vf17.y()); sq_buffer_xyzw(vu.vf14, vu.vi10); + // sq.xyzw vf14, 0(vi13) | miniw.w vf09, vf09, vf03 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf03.w()); sq_buffer_xyzw(vu.vf14, vu.vi13); + // sq.xyzw vf21, 2(vi13) | mulaw.xyzw ACC, vf25, vf10 + vu.acc.mula_xyzw(vu.vf25, vu.vf10.w()); sq_buffer_xyzw(vu.vf21, vu.vi13 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf12, vf12, vf20 + vu.vf12.mul_xyzw(vu.vf12, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // 1024.0 | ftoi0.xyzw vf11, vf11 :i + vu.vf11.ftoi0(Mask::xyzw, vu.vf11); vu.I = 1024.0; + // erleng.xyz P, vf13 | maxi.xy vf09, vf09, I + vu.vf09.maxi(Mask::xy, vu.vf09, vu.I); vu.P = erleng(vu.vf13); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L115 | maddaw.xyzw ACC, vf26, vf13 + vu.acc.madda_xyzw(vu.vf26, vu.vf13.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf16, vf00 | maddw.xyzw vf10, vf27, vf16 + vu.acc.madd_xyzw(vu.vf10, vu.vf27, vu.vf16.w()); vu.vf16.z() = 1.f; + if (bc) { goto L115; } + + +// BRANCH! + // ibne vi07, vi03, L133 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L133; } + + +// BRANCH! + // b L143 | nop + bc = true; + // nop | nop + + if (bc) { goto L143; } + + + L115: + // 3072.0 | mulax.xyzw ACC, vf01, vf12 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf12.x()); vu.I = 3072.0; + // lqi.xyzw vf08, vi01 | minii.xy vf09, vf09, I + vu.vf09.minii(Mask::xy, vu.vf09, vu.I); lq_buffer_xyzw(vu.vf08, vu.vi01++); + // sq.xyzw vf11, 1(vi10) | madday.xyzw ACC, vf02, vf12 + vu.acc.madda_xyzw(vu.vf02, vu.vf12.y()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf11, 1(vi13) | maddz.xyzw vf12, vf03, vf12 + vu.acc.madd_xyzw(vu.vf12, vu.vf03, vu.vf12.z()); sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + // lqi.xyzw vf11, vi01 | add.xyzw vf10, vf10, vf28 + vu.vf10.add_xyzw(vu.vf10, vu.vf28); lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | maxw.w vf09, vf09, vf02 + vu.vf09.max(Mask::w, vu.vf09, vu.vf02.w()); lq_buffer_xyzw(vu.vf14, vu.vi01++); + // mtir vi10, vf08.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi10 = vu.vf08.x_as_u16(); + // mtir vi13, vf08.y | maxx.xyzw vf12, vf12, vf00 + vu.vf12.max_xyzw(vu.vf12, vu.vf00.x()); vu.vi13 = vu.vf08.y_as_u16(); + // nop | miniw.w vf10, vf10, vf01 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf01.w()); + // div Q, vf01.w, vf10.w | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); vu.Q = vu.vf01.w() / vu.vf10.w(); + + // move.xyzw vf21, vf09 | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); vu.vf21.move_xyzw(vu.vf09); + // iand vi10, vi10, vi05 | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); vu.vi10 = vu.vi10 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf12 + vu.acc.mula_xyzw(vu.vf04, vu.vf12.x()); +// BRANCH! + // ibgtz vi09, L116 | madday.xyzw ACC, vf05, vf12 + vu.acc.madda_xyzw(vu.vf05, vu.vf12.y()); bc = ((s16)vu.vi09) > 0; + // iand vi13, vi13, vi05 | maddaz.xyzw ACC, vf06, vf12 + vu.acc.madda_xyzw(vu.vf06, vu.vf12.z()); vu.vi13 = vu.vi13 & vu.vi05; + if (bc) { goto L116; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L116: +// BRANCH! + // ibne vi05, vi10, L117 | maddw.xyzw vf12, vf07, vf00 + vu.acc.madd_xyzw(vu.vf12, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi10); + // ilw.x vi09, -9(vi01) | mul.xyz vf10, vf10, Q + vu.vf10.mul(Mask::xyz, vu.vf10, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L117; } + + + // mtir vi10, vf11.x | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi13 = vu.vf11.y_as_u16(); +// BRANCH! + // b L118 | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L118; } + + + L117: + // lq.xyzw vf20, 0(vi10) | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi10); + // lq.xyzw vf25, 0(vi13) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi13); + // lq.xyzw vf23, 1(vi10) | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi10 + 1); + // lq.xyzw vf26, 1(vi13) | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi13 + 1); + // lq.xyzw vf20, 2(vi10) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 2); + // lq.xyzw vf27, 2(vi13) | maddw.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.w()); lq_buffer_xyzw(vu.vf27, vu.vi13 + 2); + // lq.xyzw vf23, 3(vi10) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 3); + // lq.xyzw vf28, 3(vi13) | maddw.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.w()); lq_buffer_xyzw(vu.vf28, vu.vi13 + 3); + // lq.xyzw vf20, 4(vi10) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 4); + // lq.xyz vf29, 4(vi13) | maddw.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.w()); lq_buffer_xyz(vu.vf29, vu.vi13 + 4); + // lq.xyzw vf23, 5(vi10) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 5); + // lq.xyz vf30, 5(vi13) | maddw.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.w()); lq_buffer_xyz(vu.vf30, vu.vi13 + 5); + // lq.xyzw vf20, 6(vi10) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 6); + // lq.xyzw vf31, 6(vi13) | maddw.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.w()); lq_buffer_xyzw(vu.vf31, vu.vi13 + 6); + // lqi.xyzw vf23, vi02 | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi10, vf11.x | maddw.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.w()); vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); vu.vi13 = vu.vf11.y_as_u16(); +// BRANCH! + // b L103 | maddw.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.w()); bc = true; + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L103; } + + + L118: +// BRANCH! + // ibgez vi09, L119 | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi11) | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); sq_buffer_xyzw(vu.vf21, vu.vi11 + 2); + if (bc) { goto L119; } + + + // nop | ftoi4.xyzw vf21, vf09 + vu.vf21.ftoi4(Mask::xyzw, vu.vf09); + L119: + // mfp.w vf20, P | maddz.xyz vf11, vf31, vf14 + vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf15, 0(vi11) | miniy.xyzw vf12, vf12, vf17 + vu.vf12.mini_xyzw(vu.vf12, vu.vf17.y()); sq_buffer_xyzw(vu.vf15, vu.vi11); + // sq.xyzw vf15, 0(vi14) | miniw.w vf10, vf10, vf03 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf03.w()); sq_buffer_xyzw(vu.vf15, vu.vi14); + // sq.xyzw vf21, 2(vi14) | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); sq_buffer_xyzw(vu.vf21, vu.vi14 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf13, vf13, vf20 + vu.vf13.mul_xyzw(vu.vf13, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // 1024.0 | ftoi0.xyzw vf12, vf12 :i + vu.vf12.ftoi0(Mask::xyzw, vu.vf12); vu.I = 1024.0; + // erleng.xyz P, vf11 | maxi.xy vf10, vf10, I + vu.vf10.maxi(Mask::xy, vu.vf10, vu.I); vu.P = erleng(vu.vf11); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L120 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + if (bc) { goto L120; } + + +// BRANCH! + // ibne vi07, vi03, L138 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L138; } + + +// BRANCH! + // b L153 | nop + bc = true; + // nop | nop + + if (bc) { goto L153; } + + + L120: + // 3072.0 | mulax.xyzw ACC, vf01, vf13 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf13.x()); vu.I = 3072.0; + // lqi.xyzw vf09, vi01 | minii.xy vf10, vf10, I + vu.vf10.minii(Mask::xy, vu.vf10, vu.I); lq_buffer_xyzw(vu.vf09, vu.vi01++); + // sq.xyzw vf12, 1(vi11) | madday.xyzw ACC, vf02, vf13 + vu.acc.madda_xyzw(vu.vf02, vu.vf13.y()); sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); + // sq.xyzw vf12, 1(vi14) | maddz.xyzw vf13, vf03, vf13 + vu.acc.madd_xyzw(vu.vf13, vu.vf03, vu.vf13.z()); sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | maxw.w vf10, vf10, vf02 + vu.vf10.max(Mask::w, vu.vf10, vu.vf02.w()); lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi11, vf09.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi11 = vu.vf09.x_as_u16(); + // mtir vi14, vf09.y | maxx.xyzw vf13, vf13, vf00 + vu.vf13.max_xyzw(vu.vf13, vu.vf00.x()); vu.vi14 = vu.vf09.y_as_u16(); + // nop | miniw.w vf08, vf08, vf01 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf01.w()); + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // move.xyzw vf21, vf10 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vf21.move_xyzw(vu.vf10); + // iand vi11, vi11, vi05 | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); vu.vi11 = vu.vi11 & vu.vi05; + // nop | mulax.xyzw ACC, vf04, vf13 + vu.acc.mula_xyzw(vu.vf04, vu.vf13.x()); +// BRANCH! + // ibgtz vi09, L121 | madday.xyzw ACC, vf05, vf13 + vu.acc.madda_xyzw(vu.vf05, vu.vf13.y()); bc = ((s16)vu.vi09) > 0; + // iand vi14, vi14, vi05 | maddaz.xyzw ACC, vf06, vf13 + vu.acc.madda_xyzw(vu.vf06, vu.vf13.z()); vu.vi14 = vu.vi14 & vu.vi05; + if (bc) { goto L121; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L121: +// BRANCH! + // ibne vi05, vi11, L122 | maddw.xyzw vf13, vf07, vf00 + vu.acc.madd_xyzw(vu.vf13, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi11); + // ilw.x vi09, -9(vi01) | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L122; } + + + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L123 | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L123; } + + + L122: + // lq.xyzw vf20, 0(vi11) | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi11); + // lq.xyzw vf25, 0(vi14) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf25, vu.vi14); + // lq.xyzw vf23, 1(vi11) | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi11 + 1); + // lq.xyzw vf26, 1(vi14) | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf26, vu.vi14 + 1); + // lq.xyzw vf20, 2(vi11) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 2); + // lq.xyzw vf27, 2(vi14) | maddw.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.w()); lq_buffer_xyzw(vu.vf27, vu.vi14 + 2); + // lq.xyzw vf23, 3(vi11) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 3); + // lq.xyzw vf28, 3(vi14) | maddw.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.w()); lq_buffer_xyzw(vu.vf28, vu.vi14 + 3); + // lq.xyzw vf20, 4(vi11) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 4); + // lq.xyz vf29, 4(vi14) | maddw.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.w()); lq_buffer_xyz(vu.vf29, vu.vi14 + 4); + // lq.xyzw vf23, 5(vi11) | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 5); + // lq.xyz vf30, 5(vi14) | maddw.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.w()); lq_buffer_xyz(vu.vf30, vu.vi14 + 5); + // lq.xyzw vf20, 6(vi11) | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 6); + // lq.xyzw vf31, 6(vi14) | maddw.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.w()); lq_buffer_xyzw(vu.vf31, vu.vi14 + 6); + // lqi.xyzw vf23, vi02 | mulaz.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi11, vf12.x | maddw.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.w()); vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | mulaz.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.z()); vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L108 | maddw.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.w()); bc = true; + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L108; } + + + L123: +// BRANCH! + // ibgez vi09, L124 | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi12) | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); sq_buffer_xyzw(vu.vf21, vu.vi12 + 2); + if (bc) { goto L124; } + + + // nop | ftoi4.xyzw vf21, vf10 + vu.vf21.ftoi4(Mask::xyzw, vu.vf10); + L124: + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf16, 0(vi12) | miniy.xyzw vf13, vf13, vf17 + vu.vf13.mini_xyzw(vu.vf13, vu.vf17.y()); sq_buffer_xyzw(vu.vf16, vu.vi12); + // sq.xyzw vf16, 0(vi15) | miniw.w vf08, vf08, vf03 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); sq_buffer_xyzw(vu.vf16, vu.vi15); + // sq.xyzw vf21, 2(vi15) | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); sq_buffer_xyzw(vu.vf21, vu.vi15 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // 1024.0 | ftoi0.xyzw vf13, vf13 :i + vu.vf13.ftoi0(Mask::xyzw, vu.vf13); vu.I = 1024.0; + // erleng.xyz P, vf12 | maxi.xy vf08, vf08, I + vu.vf08.maxi(Mask::xy, vu.vf08, vu.I); vu.P = erleng(vu.vf12); /* TODO erleng */ +// BRANCH! + // ibne vi06, vi03, L110 | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); bc = (vu.vi06 != vu.vi03); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + if (bc) { goto L110; } + + +// BRANCH! + // ibne vi07, vi03, L133 | nop + bc = (vu.vi07 != vu.vi03); + // nop | nop + + if (bc) { goto L133; } + + +// BRANCH! + // b L163 | nop + bc = true; + // nop | nop + + if (bc) { goto L163; } + + + L125: + // erleng.xyz P, vf12 | maxi.xy vf08, vf08, I + vu.vf08.maxi(Mask::xy, vu.vf08, vu.I); vu.P = erleng(vu.vf12); /* TODO erleng */ + // 3072.0 | nop :i + vu.I = 3072.0; + // nop | minii.xy vf08, vf08, I + vu.vf08.minii(Mask::xy, vu.vf08, vu.I); + // nop | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + L126: + // lqi.xyzw vf10, vi01 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); lq_buffer_xyzw(vu.vf10, vu.vi01++); +// BRANCH! + // b L128 | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); bc = true; + // nop | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); + if (bc) { goto L128; } + + + L127: + // 3072.0 | mulax.xyzw ACC, vf01, vf11 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); vu.I = 3072.0; + // lqi.xyzw vf10, vi01 | minii.xy vf08, vf08, I + vu.vf08.minii(Mask::xy, vu.vf08, vu.I); lq_buffer_xyzw(vu.vf10, vu.vi01++); + // sq.xyzw vf13, 1(vi12) | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); + // sq.xyzw vf13, 1(vi15) | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + L128: + // lqi.xyzw vf13, vi01 | add.xyzw vf09, vf09, vf28 + vu.vf09.add_xyzw(vu.vf09, vu.vf28); lq_buffer_xyzw(vu.vf13, vu.vi01++); + // lqi.xyzw vf16, vi01 | maxw.w vf08, vf08, vf02 + vu.vf08.max(Mask::w, vu.vf08, vu.vf02.w()); lq_buffer_xyzw(vu.vf16, vu.vi01++); + // mtir vi12, vf10.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi12 = vu.vf10.x_as_u16(); + // mtir vi15, vf10.y | maxx.xyzw vf11, vf11, vf00 + vu.vf11.max_xyzw(vu.vf11, vu.vf00.x()); vu.vi15 = vu.vf10.y_as_u16(); + // nop | miniw.w vf09, vf09, vf01 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf01.w()); + // div Q, vf01.w, vf09.w | add.zw vf10, vf10, vf17 + vu.vf10.add(Mask::zw, vu.vf10, vu.vf17); vu.Q = vu.vf01.w() / vu.vf09.w(); + + // move.xyzw vf21, vf08 | add.xyzw vf13, vf13, vf18 + vu.vf13.add_xyzw(vu.vf13, vu.vf18); vu.vf21.move_xyzw(vu.vf08); + // iand vi12, vi12, vi05 | add.xyzw vf16, vf16, vf19 + vu.vf16.add_xyzw(vu.vf16, vu.vf19); vu.vi12 = vu.vi12 & vu.vi05; + // ilw.w vi08, -1(vi02) | mulax.xyzw ACC, vf04, vf11 + vu.acc.mula_xyzw(vu.vf04, vu.vf11.x()); ilw_buffer(Mask::w, vu.vi08, vu.vi02 + -1); +// BRANCH! + // ibgtz vi09, L129 | madday.xyzw ACC, vf05, vf11 + vu.acc.madda_xyzw(vu.vf05, vu.vf11.y()); bc = ((s16)vu.vi09) > 0; + // iand vi15, vi15, vi05 | maddaz.xyzw ACC, vf06, vf11 + vu.acc.madda_xyzw(vu.vf06, vu.vf11.z()); vu.vi15 = vu.vi15 & vu.vi05; + if (bc) { goto L129; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L129: +// BRANCH! + // ibne vi05, vi12, L130 | maddw.xyzw vf11, vf07, vf00 + vu.acc.madd_xyzw(vu.vf11, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi12); + // ilw.x vi09, -9(vi01) | mul.xyz vf09, vf09, Q + vu.vf09.mul(Mask::xyz, vu.vf09, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L130; } + + + // mtir vi12, vf13.x | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi15 = vu.vf13.y_as_u16(); +// BRANCH! + // b L131 | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L131; } + + + L130: + // lq.xyzw vf20, 0(vi12) | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi12); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf31, 0(vi15) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf31, vu.vi15); + // lq.xyzw vf25, 0(vi08) | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf23, 1(vi12) | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi12 + 1); + // lq.xyzw vf20, 1(vi15) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi15 + 1); + // lq.xyzw vf26, 1(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // lq.xyzw vf31, 2(vi12) | maddz.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi12 + 2); + // lq.xyzw vf23, 2(vi15) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi15 + 2); + // lq.xyzw vf27, 2(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lq.xyzw vf20, 3(vi12) | maddz.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 3); + // lq.xyzw vf31, 3(vi15) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf31, vu.vi15 + 3); + // lq.xyzw vf28, 3(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // lq.xyzw vf23, 4(vi12) | maddz.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi12 + 4); + // lq.xyzw vf20, 4(vi15) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi15 + 4); + // lq.xyz vf29, 4(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyzw vf31, 5(vi12) | maddz.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi12 + 5); + // lq.xyzw vf23, 5(vi15) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi15 + 5); + // lq.xyz vf30, 5(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); + // lq.xyzw vf20, 6(vi12) | maddz.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi12 + 6); + // lq.xyzw vf22, 6(vi15) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf22, vu.vi15 + 6); + // lq.xyzw vf31, 6(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + // lqi.xyzw vf23, vi02 | maddz.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi12, vf13.x | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); vu.vi12 = vu.vf13.x_as_u16(); + // mtir vi15, vf13.y | madday.xyzw ACC, vf22, vf24 + vu.acc.madda_xyzw(vu.vf22, vu.vf24.y()); vu.vi15 = vu.vf13.y_as_u16(); + // lq.xyzw vf22, 2(vi00) | maddz.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.z()); lq_buffer_xyzw(vu.vf22, 2); + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + L131: +// BRANCH! + // ibgez vi09, L132 | mulaz.xyzw ACC, vf29, vf10 + vu.acc.mula_xyzw(vu.vf29, vu.vf10.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi10) | maddaz.xyzw ACC, vf30, vf13 + vu.acc.madda_xyzw(vu.vf30, vu.vf13.z()); sq_buffer_xyzw(vu.vf21, vu.vi10 + 2); + if (bc) { goto L132; } + + + // nop | ftoi4.xyzw vf21, vf08 + vu.vf21.ftoi4(Mask::xyzw, vu.vf08); + L132: + // mfp.w vf20, P | maddz.xyz vf13, vf31, vf16 + vu.acc.madd_xyz(vu.vf13, vu.vf31, vu.vf16.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf14, 0(vi10) | miniy.xyzw vf11, vf11, vf17 + vu.vf11.mini_xyzw(vu.vf11, vu.vf17.y()); sq_buffer_xyzw(vu.vf14, vu.vi10); + // sq.xyzw vf14, 0(vi13) | miniw.w vf09, vf09, vf03 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf03.w()); sq_buffer_xyzw(vu.vf14, vu.vi13); + // sq.xyzw vf21, 2(vi13) | mulaw.xyzw ACC, vf25, vf10 + vu.acc.mula_xyzw(vu.vf25, vu.vf10.w()); sq_buffer_xyzw(vu.vf21, vu.vi13 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf12, vf12, vf20 + vu.vf12.mul_xyzw(vu.vf12, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // 1024.0 | ftoi0.xyzw vf11, vf11 :i + vu.vf11.ftoi0(Mask::xyzw, vu.vf11); vu.I = 1024.0; + // erleng.xyz P, vf13 | maxi.xy vf09, vf09, I + vu.vf09.maxi(Mask::xy, vu.vf09, vu.I); vu.P = erleng(vu.vf13); /* TODO erleng */ +// BRANCH! + // ibeq vi07, vi03, L143 | maddaw.xyzw ACC, vf26, vf13 + vu.acc.madda_xyzw(vu.vf26, vu.vf13.w()); bc = (vu.vi07 == vu.vi03); + // mr32.z vf16, vf00 | maddw.xyzw vf10, vf27, vf16 + vu.acc.madd_xyzw(vu.vf10, vu.vf27, vu.vf16.w()); vu.vf16.z() = 1.f; + if (bc) { goto L143; } + + + L133: + // 3072.0 | mulax.xyzw ACC, vf01, vf12 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf12.x()); vu.I = 3072.0; + // lqi.xyzw vf08, vi01 | minii.xy vf09, vf09, I + vu.vf09.minii(Mask::xy, vu.vf09, vu.I); lq_buffer_xyzw(vu.vf08, vu.vi01++); + // sq.xyzw vf11, 1(vi10) | madday.xyzw ACC, vf02, vf12 + vu.acc.madda_xyzw(vu.vf02, vu.vf12.y()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf11, 1(vi13) | maddz.xyzw vf12, vf03, vf12 + vu.acc.madd_xyzw(vu.vf12, vu.vf03, vu.vf12.z()); sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + // lqi.xyzw vf11, vi01 | add.xyzw vf10, vf10, vf28 + vu.vf10.add_xyzw(vu.vf10, vu.vf28); lq_buffer_xyzw(vu.vf11, vu.vi01++); + // lqi.xyzw vf14, vi01 | maxw.w vf09, vf09, vf02 + vu.vf09.max(Mask::w, vu.vf09, vu.vf02.w()); lq_buffer_xyzw(vu.vf14, vu.vi01++); + // mtir vi10, vf08.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi10 = vu.vf08.x_as_u16(); + // mtir vi13, vf08.y | maxx.xyzw vf12, vf12, vf00 + vu.vf12.max_xyzw(vu.vf12, vu.vf00.x()); vu.vi13 = vu.vf08.y_as_u16(); + // nop | miniw.w vf10, vf10, vf01 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf01.w()); + // div Q, vf01.w, vf10.w | add.zw vf08, vf08, vf17 + vu.vf08.add(Mask::zw, vu.vf08, vu.vf17); vu.Q = vu.vf01.w() / vu.vf10.w(); + + // move.xyzw vf21, vf09 | add.xyzw vf11, vf11, vf18 + vu.vf11.add_xyzw(vu.vf11, vu.vf18); vu.vf21.move_xyzw(vu.vf09); + // iand vi10, vi10, vi05 | add.xyzw vf14, vf14, vf19 + vu.vf14.add_xyzw(vu.vf14, vu.vf19); vu.vi10 = vu.vi10 & vu.vi05; + // ilw.w vi08, -1(vi02) | mulax.xyzw ACC, vf04, vf12 + vu.acc.mula_xyzw(vu.vf04, vu.vf12.x()); ilw_buffer(Mask::w, vu.vi08, vu.vi02 + -1); +// BRANCH! + // ibgtz vi09, L134 | madday.xyzw ACC, vf05, vf12 + vu.acc.madda_xyzw(vu.vf05, vu.vf12.y()); bc = ((s16)vu.vi09) > 0; + // iand vi13, vi13, vi05 | maddaz.xyzw ACC, vf06, vf12 + vu.acc.madda_xyzw(vu.vf06, vu.vf12.z()); vu.vi13 = vu.vi13 & vu.vi05; + if (bc) { goto L134; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L134: +// BRANCH! + // ibne vi05, vi10, L135 | maddw.xyzw vf12, vf07, vf00 + vu.acc.madd_xyzw(vu.vf12, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi10); + // ilw.x vi09, -9(vi01) | mul.xyz vf10, vf10, Q + vu.vf10.mul(Mask::xyz, vu.vf10, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L135; } + + + // mtir vi10, vf11.x | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi13 = vu.vf11.y_as_u16(); +// BRANCH! + // b L136 | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L136; } + + + L135: + // lq.xyzw vf20, 0(vi10) | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi10); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf31, 0(vi13) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf31, vu.vi13); + // lq.xyzw vf25, 0(vi08) | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf23, 1(vi10) | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi10 + 1); + // lq.xyzw vf20, 1(vi13) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi13 + 1); + // lq.xyzw vf26, 1(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // lq.xyzw vf31, 2(vi10) | maddz.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi10 + 2); + // lq.xyzw vf23, 2(vi13) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi13 + 2); + // lq.xyzw vf27, 2(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lq.xyzw vf20, 3(vi10) | maddz.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 3); + // lq.xyzw vf31, 3(vi13) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf31, vu.vi13 + 3); + // lq.xyzw vf28, 3(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // lq.xyzw vf23, 4(vi10) | maddz.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi10 + 4); + // lq.xyzw vf20, 4(vi13) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi13 + 4); + // lq.xyz vf29, 4(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyzw vf31, 5(vi10) | maddz.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi10 + 5); + // lq.xyzw vf23, 5(vi13) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi13 + 5); + // lq.xyz vf30, 5(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); + // lq.xyzw vf20, 6(vi10) | maddz.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi10 + 6); + // lq.xyzw vf22, 6(vi13) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf22, vu.vi13 + 6); + // lq.xyzw vf31, 6(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + // lqi.xyzw vf23, vi02 | maddz.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi10, vf11.x | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); vu.vi10 = vu.vf11.x_as_u16(); + // mtir vi13, vf11.y | madday.xyzw ACC, vf22, vf24 + vu.acc.madda_xyzw(vu.vf22, vu.vf24.y()); vu.vi13 = vu.vf11.y_as_u16(); + // lq.xyzw vf22, 2(vi00) | maddz.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.z()); lq_buffer_xyzw(vu.vf22, 2); + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + L136: +// BRANCH! + // ibgez vi09, L137 | mulaz.xyzw ACC, vf29, vf08 + vu.acc.mula_xyzw(vu.vf29, vu.vf08.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi11) | maddaz.xyzw ACC, vf30, vf11 + vu.acc.madda_xyzw(vu.vf30, vu.vf11.z()); sq_buffer_xyzw(vu.vf21, vu.vi11 + 2); + if (bc) { goto L137; } + + + // nop | ftoi4.xyzw vf21, vf09 + vu.vf21.ftoi4(Mask::xyzw, vu.vf09); + L137: + // mfp.w vf20, P | maddz.xyz vf11, vf31, vf14 + vu.acc.madd_xyz(vu.vf11, vu.vf31, vu.vf14.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf15, 0(vi11) | miniy.xyzw vf12, vf12, vf17 + vu.vf12.mini_xyzw(vu.vf12, vu.vf17.y()); sq_buffer_xyzw(vu.vf15, vu.vi11); + // sq.xyzw vf15, 0(vi14) | miniw.w vf10, vf10, vf03 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf03.w()); sq_buffer_xyzw(vu.vf15, vu.vi14); + // sq.xyzw vf21, 2(vi14) | mulaw.xyzw ACC, vf25, vf08 + vu.acc.mula_xyzw(vu.vf25, vu.vf08.w()); sq_buffer_xyzw(vu.vf21, vu.vi14 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf13, vf13, vf20 + vu.vf13.mul_xyzw(vu.vf13, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // 1024.0 | ftoi0.xyzw vf12, vf12 :i + vu.vf12.ftoi0(Mask::xyzw, vu.vf12); vu.I = 1024.0; + // erleng.xyz P, vf11 | maxi.xy vf10, vf10, I + vu.vf10.maxi(Mask::xy, vu.vf10, vu.I); vu.P = erleng(vu.vf11); /* TODO erleng */ +// BRANCH! + // ibeq vi07, vi03, L153 | maddaw.xyzw ACC, vf26, vf11 + vu.acc.madda_xyzw(vu.vf26, vu.vf11.w()); bc = (vu.vi07 == vu.vi03); + // mr32.z vf14, vf00 | maddw.xyzw vf08, vf27, vf14 + vu.acc.madd_xyzw(vu.vf08, vu.vf27, vu.vf14.w()); vu.vf14.z() = 1.f; + if (bc) { goto L153; } + + + L138: + // 3072.0 | mulax.xyzw ACC, vf01, vf13 :i + vu.acc.mula_xyzw(vu.vf01, vu.vf13.x()); vu.I = 3072.0; + // lqi.xyzw vf09, vi01 | minii.xy vf10, vf10, I + vu.vf10.minii(Mask::xy, vu.vf10, vu.I); lq_buffer_xyzw(vu.vf09, vu.vi01++); + // sq.xyzw vf12, 1(vi11) | madday.xyzw ACC, vf02, vf13 + vu.acc.madda_xyzw(vu.vf02, vu.vf13.y()); sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); + // sq.xyzw vf12, 1(vi14) | maddz.xyzw vf13, vf03, vf13 + vu.acc.madd_xyzw(vu.vf13, vu.vf03, vu.vf13.z()); sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + // lqi.xyzw vf12, vi01 | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); lq_buffer_xyzw(vu.vf12, vu.vi01++); + // lqi.xyzw vf15, vi01 | maxw.w vf10, vf10, vf02 + vu.vf10.max(Mask::w, vu.vf10, vu.vf02.w()); lq_buffer_xyzw(vu.vf15, vu.vi01++); + // mtir vi11, vf09.x | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); vu.vi11 = vu.vf09.x_as_u16(); + // mtir vi14, vf09.y | maxx.xyzw vf13, vf13, vf00 + vu.vf13.max_xyzw(vu.vf13, vu.vf00.x()); vu.vi14 = vu.vf09.y_as_u16(); + // nop | miniw.w vf08, vf08, vf01 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf01.w()); + // div Q, vf01.w, vf08.w | add.zw vf09, vf09, vf17 + vu.vf09.add(Mask::zw, vu.vf09, vu.vf17); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // move.xyzw vf21, vf10 | add.xyzw vf12, vf12, vf18 + vu.vf12.add_xyzw(vu.vf12, vu.vf18); vu.vf21.move_xyzw(vu.vf10); + // iand vi11, vi11, vi05 | add.xyzw vf15, vf15, vf19 + vu.vf15.add_xyzw(vu.vf15, vu.vf19); vu.vi11 = vu.vi11 & vu.vi05; + // ilw.w vi08, -1(vi02) | mulax.xyzw ACC, vf04, vf13 + vu.acc.mula_xyzw(vu.vf04, vu.vf13.x()); ilw_buffer(Mask::w, vu.vi08, vu.vi02 + -1); +// BRANCH! + // ibgtz vi09, L139 | madday.xyzw ACC, vf05, vf13 + vu.acc.madda_xyzw(vu.vf05, vu.vf13.y()); bc = ((s16)vu.vi09) > 0; + // iand vi14, vi14, vi05 | maddaz.xyzw ACC, vf06, vf13 + vu.acc.madda_xyzw(vu.vf06, vu.vf13.z()); vu.vi14 = vu.vi14 & vu.vi05; + if (bc) { goto L139; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L139: +// BRANCH! + // ibne vi05, vi11, L140 | maddw.xyzw vf13, vf07, vf00 + vu.acc.madd_xyzw(vu.vf13, vu.vf07, vu.vf00.w()); bc = (vu.vi05 != vu.vi11); + // ilw.x vi09, -9(vi01) | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -9); + if (bc) { goto L140; } + + + // mtir vi11, vf12.x | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi14 = vu.vf12.y_as_u16(); +// BRANCH! + // b L141 | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); bc = true; + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); + if (bc) { goto L141; } + + + L140: + // lq.xyzw vf20, 0(vi11) | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ lq_buffer_xyzw(vu.vf20, vu.vi11); + // nop | mulw.xyzw vf24, vf24, vf29 + vu.vf24.mul_xyzw(vu.vf24, vu.vf29.w()); + // lq.xyzw vf31, 0(vi14) | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); lq_buffer_xyzw(vu.vf31, vu.vi14); + // lq.xyzw vf25, 0(vi08) | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); lq_buffer_xyzw(vu.vf25, vu.vi08); + // lq.xyzw vf23, 1(vi11) | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi11 + 1); + // lq.xyzw vf20, 1(vi14) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi14 + 1); + // lq.xyzw vf26, 1(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyzw(vu.vf26, vu.vi08 + 1); + // lq.xyzw vf31, 2(vi11) | maddz.xyzw vf25, vf25, vf24 + vu.acc.madd_xyzw(vu.vf25, vu.vf25, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi11 + 2); + // lq.xyzw vf23, 2(vi14) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi14 + 2); + // lq.xyzw vf27, 2(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyzw(vu.vf27, vu.vi08 + 2); + // lq.xyzw vf20, 3(vi11) | maddz.xyzw vf26, vf26, vf24 + vu.acc.madd_xyzw(vu.vf26, vu.vf26, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 3); + // lq.xyzw vf31, 3(vi14) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf31, vu.vi14 + 3); + // lq.xyzw vf28, 3(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf28, vu.vi08 + 3); + // lq.xyzw vf23, 4(vi11) | maddz.xyzw vf27, vf27, vf24 + vu.acc.madd_xyzw(vu.vf27, vu.vf27, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi11 + 4); + // lq.xyzw vf20, 4(vi14) | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); lq_buffer_xyzw(vu.vf20, vu.vi14 + 4); + // lq.xyz vf29, 4(vi08) | madday.xyzw ACC, vf31, vf24 + vu.acc.madda_xyzw(vu.vf31, vu.vf24.y()); lq_buffer_xyz(vu.vf29, vu.vi08 + 4); + // lq.xyzw vf31, 5(vi11) | maddz.xyzw vf28, vf28, vf24 + vu.acc.madd_xyzw(vu.vf28, vu.vf28, vu.vf24.z()); lq_buffer_xyzw(vu.vf31, vu.vi11 + 5); + // lq.xyzw vf23, 5(vi14) | mulax.xyzw ACC, vf23, vf24 + vu.acc.mula_xyzw(vu.vf23, vu.vf24.x()); lq_buffer_xyzw(vu.vf23, vu.vi14 + 5); + // lq.xyz vf30, 5(vi08) | madday.xyzw ACC, vf20, vf24 + vu.acc.madda_xyzw(vu.vf20, vu.vf24.y()); lq_buffer_xyz(vu.vf30, vu.vi08 + 5); + // lq.xyzw vf20, 6(vi11) | maddz.xyz vf29, vf29, vf24 + vu.acc.madd_xyz(vu.vf29, vu.vf29, vu.vf24.z()); lq_buffer_xyzw(vu.vf20, vu.vi11 + 6); + // lq.xyzw vf22, 6(vi14) | mulax.xyzw ACC, vf31, vf24 + vu.acc.mula_xyzw(vu.vf31, vu.vf24.x()); lq_buffer_xyzw(vu.vf22, vu.vi14 + 6); + // lq.xyzw vf31, 6(vi08) | madday.xyzw ACC, vf23, vf24 + vu.acc.madda_xyzw(vu.vf23, vu.vf24.y()); lq_buffer_xyzw(vu.vf31, vu.vi08 + 6); + // lqi.xyzw vf23, vi02 | maddz.xyz vf30, vf30, vf24 + vu.acc.madd_xyz(vu.vf30, vu.vf30, vu.vf24.z()); lq_buffer_xyzw(vu.vf23, vu.vi02++); + // mtir vi11, vf12.x | mulax.xyzw ACC, vf20, vf24 + vu.acc.mula_xyzw(vu.vf20, vu.vf24.x()); vu.vi11 = vu.vf12.x_as_u16(); + // mtir vi14, vf12.y | madday.xyzw ACC, vf22, vf24 + vu.acc.madda_xyzw(vu.vf22, vu.vf24.y()); vu.vi14 = vu.vf12.y_as_u16(); + // lq.xyzw vf22, 2(vi00) | maddz.xyzw vf31, vf31, vf24 + vu.acc.madd_xyzw(vu.vf31, vu.vf31, vu.vf24.z()); lq_buffer_xyzw(vu.vf22, 2); + // lqi.xyzw vf23, vi03 | itof0.xyzw vf24, vf23 + vu.vf24.itof0(Mask::xyzw, vu.vf23); lq_buffer_xyzw(vu.vf23, vu.vi03++); + L141: +// BRANCH! + // ibgez vi09, L142 | mulaz.xyzw ACC, vf29, vf09 + vu.acc.mula_xyzw(vu.vf29, vu.vf09.z()); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi12) | maddaz.xyzw ACC, vf30, vf12 + vu.acc.madda_xyzw(vu.vf30, vu.vf12.z()); sq_buffer_xyzw(vu.vf21, vu.vi12 + 2); + if (bc) { goto L142; } + + + // nop | ftoi4.xyzw vf21, vf10 + vu.vf21.ftoi4(Mask::xyzw, vu.vf10); + L142: + // mfp.w vf20, P | maddz.xyz vf12, vf31, vf15 + vu.acc.madd_xyz(vu.vf12, vu.vf31, vu.vf15.z()); vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf16, 0(vi12) | miniy.xyzw vf13, vf13, vf17 + vu.vf13.mini_xyzw(vu.vf13, vu.vf17.y()); sq_buffer_xyzw(vu.vf16, vu.vi12); + // sq.xyzw vf16, 0(vi15) | miniw.w vf08, vf08, vf03 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); sq_buffer_xyzw(vu.vf16, vu.vi15); + // sq.xyzw vf21, 2(vi15) | mulaw.xyzw ACC, vf25, vf09 + vu.acc.mula_xyzw(vu.vf25, vu.vf09.w()); sq_buffer_xyzw(vu.vf21, vu.vi15 + 2); + // ilw.y vi09, -6(vi01) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -6); + // 1024.0 | ftoi0.xyzw vf13, vf13 :i + vu.vf13.ftoi0(Mask::xyzw, vu.vf13); vu.I = 1024.0; + // erleng.xyz P, vf12 | maxi.xy vf08, vf08, I + vu.vf08.maxi(Mask::xy, vu.vf08, vu.I); vu.P = erleng(vu.vf12); /* TODO erleng */ +// BRANCH! + // ibne vi07, vi03, L127 | maddaw.xyzw ACC, vf26, vf12 + vu.acc.madda_xyzw(vu.vf26, vu.vf12.w()); bc = (vu.vi07 != vu.vi03); + // mr32.z vf15, vf00 | maddw.xyzw vf09, vf27, vf15 + vu.acc.madd_xyzw(vu.vf09, vu.vf27, vu.vf15.w()); vu.vf15.z() = 1.f; + if (bc) { goto L127; } + + +// BRANCH! + // b L163 | nop + bc = true; + // nop | nop + + if (bc) { goto L163; } + + + L143: + // ilw.w vi08, 1(vi00) | nop + ilw_buffer(Mask::w, vu.vi08, 1); + // xtop vi02 | mulax.xyzw ACC, vf01, vf12 + vu.acc.mula_xyzw(vu.vf01, vu.vf12.x()); vu.vi02 = xtop(); + // sq.xyzw vf11, 1(vi10) | madday.xyzw ACC, vf02, vf12 + vu.acc.madda_xyzw(vu.vf02, vu.vf12.y()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf11, 1(vi13) | maddz.xyzw vf12, vf03, vf12 + vu.acc.madd_xyzw(vu.vf12, vu.vf03, vu.vf12.z()); sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + // iaddiu vi04, vi02, 0x8c | add.xyzw vf10, vf10, vf28 + vu.vf10.add_xyzw(vu.vf10, vu.vf28); vu.vi04 = vu.vi02 + 0x8c; /* 140 */ + // ilwr.x vi05, vi04 | maxw.w vf09, vf09, vf02 + vu.vf09.max(Mask::w, vu.vf09, vu.vf02.w()); ilw_buffer(Mask::x, vu.vi05, vu.vi04); + // ilw.w vi06, 1(vi04) | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); ilw_buffer(Mask::w, vu.vi06, vu.vi04 + 1); +// BRANCH! + // ibne vi00, vi08, L151 | nop + bc = (vu.vi08 != 0); + // ilw.x vi07, 2(vi04) | maxx.xyzw vf12, vf12, vf00 + vu.vf12.max_xyzw(vu.vf12, vu.vf00.x()); ilw_buffer(Mask::x, vu.vi07, vu.vi04 + 2); + if (bc) { goto L151; } + + + L144: + // div Q, vf01.w, vf10.w | minix.xyzw vf25, vf00, vf00 + vu.vf25.mini_xyzw(vu.vf00, vu.vf00.x()); vu.Q = vu.vf01.w() / vu.vf10.w(); + + // move.xyzw vf21, vf09 | minix.xyzw vf26, vf00, vf00 + vu.vf26.mini_xyzw(vu.vf00, vu.vf00.x()); vu.vf21.move_xyzw(vu.vf09); + // iadd vi05, vi05, vi04 | nop + vu.vi05 = vu.vi05 + vu.vi04; + // iaddiu vi04, vi02, 0x173 | mulax.xyzw ACC, vf04, vf12 + vu.acc.mula_xyzw(vu.vf04, vu.vf12.x()); vu.vi04 = vu.vi02 + 0x173; /* 371 */ +// BRANCH! + // ibgtz vi09, L145 | madday.xyzw ACC, vf05, vf12 + vu.acc.madda_xyzw(vu.vf05, vu.vf12.y()); bc = ((s16)vu.vi09) > 0; + // iadd vi06, vi06, vi05 | maddaz.xyzw ACC, vf06, vf12 + vu.acc.madda_xyzw(vu.vf06, vu.vf12.z()); vu.vi06 = vu.vi06 + vu.vi05; + if (bc) { goto L145; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L145: + // iadd vi07, vi07, vi06 | maddw.xyzw vf12, vf07, vf00 + vu.acc.madd_xyzw(vu.vf12, vu.vf07, vu.vf00.w()); vu.vi07 = vu.vi07 + vu.vi06; + // ilw.x vi09, -6(vi01) | mul.xyz vf10, vf10, Q + vu.vf10.mul(Mask::xyz, vu.vf10, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -6); + // iaddiu vi08, vi00, 0x1ba | mul.xyzw vf16, vf16, Q + vu.vf16.mul_xyzw(vu.vf16, vu.Q); /* TODO mulq */ vu.vi08 = 0x1ba; /* 442 */ + + // isub vi08, vi08, vi02 | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi08 = vu.vi08 - vu.vi02; + // iaddiu vi08, vi08, 0x173 | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); vu.vi08 = vu.vi08 + 0x173; /* 371 */ + // lqi.xyzw vf23, vi03 | add.xyzw vf10, vf10, vf22 + vu.vf10.add_xyzw(vu.vf10, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); +// BRANCH! + // ibgez vi09, L146 | nop + bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi11) | nop + sq_buffer_xyzw(vu.vf21, vu.vi11 + 2); + if (bc) { goto L146; } + + + // nop | ftoi4.xyzw vf21, vf09 + vu.vf21.ftoi4(Mask::xyzw, vu.vf09); + L146: + // mfp.w vf20, P | nop + vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf15, 0(vi11) | miniy.xyzw vf12, vf12, vf17 + vu.vf12.mini_xyzw(vu.vf12, vu.vf17.y()); sq_buffer_xyzw(vu.vf15, vu.vi11); + // sq.xyzw vf15, 0(vi14) | miniw.w vf10, vf10, vf03 + vu.vf10.mini(Mask::w, vu.vf10, vu.vf03.w()); sq_buffer_xyzw(vu.vf15, vu.vi14); + // sq.xyzw vf21, 2(vi14) | nop + sq_buffer_xyzw(vu.vf21, vu.vi14 + 2); + // ilw.y vi09, -3(vi01) | mulw.xyzw vf13, vf13, vf20 + vu.vf13.mul_xyzw(vu.vf13, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -3); + // mfir.x vf25, vi04 | ftoi0.xyzw vf12, vf12 + vu.vf12.ftoi0(Mask::xyzw, vu.vf12); vu.vf25.mfir(Mask::x, vu.vi04); + // mfir.y vf25, vi04 | nop + vu.vf25.mfir(Mask::y, vu.vi04); + // mfir.x vf26, vi08 | nop + vu.vf26.mfir(Mask::x, vu.vi08); + // ilw.w vi02, 1(vi00) | nop + ilw_buffer(Mask::w, vu.vi02, 1); + // mfir.y vf26, vi04 | mulax.xyzw ACC, vf01, vf13 + vu.acc.mula_xyzw(vu.vf01, vu.vf13.x()); vu.vf26.mfir(Mask::y, vu.vi04); + // sq.xyzw vf12, 1(vi11) | madday.xyzw ACC, vf02, vf13 + vu.acc.madda_xyzw(vu.vf02, vu.vf13.y()); sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); + // sq.xyzw vf12, 1(vi14) | maddz.xyzw vf13, vf03, vf13 + vu.acc.madd_xyzw(vu.vf13, vu.vf03, vu.vf13.z()); sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + // nop | nop + +// BRANCH! + // ibne vi00, vi02, L152 | maxw.w vf10, vf10, vf02 + vu.vf10.max(Mask::w, vu.vf10, vu.vf02.w()); bc = (vu.vi02 != 0); + // nop | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); + if (bc) { goto L152; } + + + L147: + // 8388608.0 | maxx.xyzw vf13, vf13, vf00 :i + vu.vf13.max_xyzw(vu.vf13, vu.vf00.x()); vu.I = 8388608.0; + // 256.0 | maxi.xy vf27, vf00, I :i + vu.vf27.maxi(Mask::xy, vu.vf00, vu.I); vu.I = 256.0; + // move.xyzw vf21, vf10 | maxi.w vf27, vf00, I + vu.vf27.maxi(Mask::w, vu.vf00, vu.I); vu.vf21.move_xyzw(vu.vf10); + // nop | nop + + // nop | mulax.xyzw ACC, vf04, vf13 + vu.acc.mula_xyzw(vu.vf04, vu.vf13.x()); +// BRANCH! + // ibgtz vi09, L148 | madday.xyzw ACC, vf05, vf13 + vu.acc.madda_xyzw(vu.vf05, vu.vf13.y()); bc = ((s16)vu.vi09) > 0; + // nop | maddaz.xyzw ACC, vf06, vf13 + vu.acc.madda_xyzw(vu.vf06, vu.vf13.z()); + if (bc) { goto L148; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L148: + // nop | maddw.xyzw vf13, vf07, vf00 + vu.acc.madd_xyzw(vu.vf13, vu.vf07, vu.vf00.w()); + // ilw.x vi09, -3(vi01) | itof0.xyzw vf25, vf25 + vu.vf25.itof0(Mask::xyzw, vu.vf25); ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -3); + // nop | itof0.xyzw vf26, vf26 + vu.vf26.itof0(Mask::xyzw, vu.vf26); + // nop | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); + // nop | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); + // ior vi02, vi05, vi00 | add.xyzw vf25, vf25, vf27 + vu.vf25.add_xyzw(vu.vf25, vu.vf27); vu.vi02 = vu.vi05; +// BRANCH! + // ibgez vi09, L149 | add.xyzw vf26, vf26, vf27 + vu.vf26.add_xyzw(vu.vf26, vu.vf27); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi12) | nop + sq_buffer_xyzw(vu.vf21, vu.vi12 + 2); + if (bc) { goto L149; } + + + // nop | ftoi4.xyzw vf21, vf10 + vu.vf21.ftoi4(Mask::xyzw, vu.vf10); + L149: +// BRANCH! + // ibne vi06, vi05, L150 | nop + bc = (vu.vi06 != vu.vi05); + // sq.xyzw vf16, 0(vi12) | miniy.xyzw vf13, vf13, vf17 + vu.vf13.mini_xyzw(vu.vf13, vu.vf17.y()); sq_buffer_xyzw(vu.vf16, vu.vi12); + if (bc) { goto L150; } + + + // ior vi06, vi07, vi00 | max.xyzw vf25, vf26, vf26 + vu.vf25.max_xyzw(vu.vf26, vu.vf26); vu.vi06 = vu.vi07; + L150: + // sq.xyzw vf16, 0(vi15) | nop + sq_buffer_xyzw(vu.vf16, vu.vi15); + // sq.xyzw vf21, 2(vi15) | nop + sq_buffer_xyzw(vu.vf21, vu.vi15 + 2); + // lqi.xyzw vf27, vi05 | nop + lq_buffer_xyzw(vu.vf27, vu.vi05++); + // nop | ftoi0.xyzw vf13, vf13 + vu.vf13.ftoi0(Mask::xyzw, vu.vf13); + // nop | nop + + // nop | nop + + // nop | itof0.xyzw vf27, vf27 + vu.vf27.itof0(Mask::xyzw, vu.vf27); + // sq.xyzw vf13, 1(vi12) | nop + sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); +// BRANCH! + // b L173 | nop + bc = true; + // sq.xyzw vf13, 1(vi15) | nop + sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + if (bc) { goto L173; } + + + L151: + // 3072.0 | miniw.w vf10, vf10, vf01 :i + vu.vf10.mini(Mask::w, vu.vf10, vu.vf01.w()); vu.I = 3072.0; +// BRANCH! + // b L144 | minii.xy vf09, vf09, I + vu.vf09.minii(Mask::xy, vu.vf09, vu.I); bc = true; + // nop | nop + + if (bc) { goto L144; } + + + L152: + // 1024.0 | nop :i + vu.I = 1024.0; + // 3072.0 | maxi.xy vf10, vf10, I :i + vu.vf10.maxi(Mask::xy, vu.vf10, vu.I); vu.I = 3072.0; +// BRANCH! + // b L147 | minii.xy vf10, vf10, I + vu.vf10.minii(Mask::xy, vu.vf10, vu.I); bc = true; + // isw.w vi00, 1(vi00) | nop + isw_buffer(Mask::w, vu.vi00, 1); + if (bc) { goto L147; } + + + L153: + // ilw.w vi08, 1(vi00) | nop + ilw_buffer(Mask::w, vu.vi08, 1); + // xtop vi02 | mulax.xyzw ACC, vf01, vf13 + vu.acc.mula_xyzw(vu.vf01, vu.vf13.x()); vu.vi02 = xtop(); + // sq.xyzw vf12, 1(vi11) | madday.xyzw ACC, vf02, vf13 + vu.acc.madda_xyzw(vu.vf02, vu.vf13.y()); sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); + // sq.xyzw vf12, 1(vi14) | maddz.xyzw vf13, vf03, vf13 + vu.acc.madd_xyzw(vu.vf13, vu.vf03, vu.vf13.z()); sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + // iaddiu vi04, vi02, 0x8c | add.xyzw vf08, vf08, vf28 + vu.vf08.add_xyzw(vu.vf08, vu.vf28); vu.vi04 = vu.vi02 + 0x8c; /* 140 */ + // ilwr.x vi05, vi04 | maxw.w vf10, vf10, vf02 + vu.vf10.max(Mask::w, vu.vf10, vu.vf02.w()); ilw_buffer(Mask::x, vu.vi05, vu.vi04); + // ilw.w vi06, 1(vi04) | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); ilw_buffer(Mask::w, vu.vi06, vu.vi04 + 1); +// BRANCH! + // ibne vi00, vi08, L161 | nop + bc = (vu.vi08 != 0); + // ilw.x vi07, 2(vi04) | maxx.xyzw vf13, vf13, vf00 + vu.vf13.max_xyzw(vu.vf13, vu.vf00.x()); ilw_buffer(Mask::x, vu.vi07, vu.vi04 + 2); + if (bc) { goto L161; } + + + L154: + // div Q, vf01.w, vf08.w | minix.xyzw vf25, vf00, vf00 + vu.vf25.mini_xyzw(vu.vf00, vu.vf00.x()); vu.Q = vu.vf01.w() / vu.vf08.w(); + + // move.xyzw vf21, vf10 | minix.xyzw vf26, vf00, vf00 + vu.vf26.mini_xyzw(vu.vf00, vu.vf00.x()); vu.vf21.move_xyzw(vu.vf10); + // iadd vi05, vi05, vi04 | nop + vu.vi05 = vu.vi05 + vu.vi04; + // iaddiu vi04, vi02, 0x173 | mulax.xyzw ACC, vf04, vf13 + vu.acc.mula_xyzw(vu.vf04, vu.vf13.x()); vu.vi04 = vu.vi02 + 0x173; /* 371 */ +// BRANCH! + // ibgtz vi09, L155 | madday.xyzw ACC, vf05, vf13 + vu.acc.madda_xyzw(vu.vf05, vu.vf13.y()); bc = ((s16)vu.vi09) > 0; + // iadd vi06, vi06, vi05 | maddaz.xyzw ACC, vf06, vf13 + vu.acc.madda_xyzw(vu.vf06, vu.vf13.z()); vu.vi06 = vu.vi06 + vu.vi05; + if (bc) { goto L155; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L155: + // iadd vi07, vi07, vi06 | maddw.xyzw vf13, vf07, vf00 + vu.acc.madd_xyzw(vu.vf13, vu.vf07, vu.vf00.w()); vu.vi07 = vu.vi07 + vu.vi06; + // ilw.x vi09, -6(vi01) | mul.xyz vf08, vf08, Q + vu.vf08.mul(Mask::xyz, vu.vf08, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -6); + // iaddiu vi08, vi00, 0x1ba | mul.xyzw vf14, vf14, Q + vu.vf14.mul_xyzw(vu.vf14, vu.Q); /* TODO mulq */ vu.vi08 = 0x1ba; /* 442 */ + + // isub vi08, vi08, vi02 | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi08 = vu.vi08 - vu.vi02; + // iaddiu vi08, vi08, 0x173 | mul.xyzw vf13, vf13, vf23 + vu.vf13.mul_xyzw(vu.vf13, vu.vf23); vu.vi08 = vu.vi08 + 0x173; /* 371 */ + // lqi.xyzw vf23, vi03 | add.xyzw vf08, vf08, vf22 + vu.vf08.add_xyzw(vu.vf08, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); +// BRANCH! + // ibgez vi09, L156 | nop + bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi12) | nop + sq_buffer_xyzw(vu.vf21, vu.vi12 + 2); + if (bc) { goto L156; } + + + // nop | ftoi4.xyzw vf21, vf10 + vu.vf21.ftoi4(Mask::xyzw, vu.vf10); + L156: + // mfp.w vf20, P | nop + vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf16, 0(vi12) | miniy.xyzw vf13, vf13, vf17 + vu.vf13.mini_xyzw(vu.vf13, vu.vf17.y()); sq_buffer_xyzw(vu.vf16, vu.vi12); + // sq.xyzw vf16, 0(vi15) | miniw.w vf08, vf08, vf03 + vu.vf08.mini(Mask::w, vu.vf08, vu.vf03.w()); sq_buffer_xyzw(vu.vf16, vu.vi15); + // sq.xyzw vf21, 2(vi15) | nop + sq_buffer_xyzw(vu.vf21, vu.vi15 + 2); + // ilw.y vi09, -3(vi01) | mulw.xyzw vf11, vf11, vf20 + vu.vf11.mul_xyzw(vu.vf11, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -3); + // mfir.x vf25, vi04 | ftoi0.xyzw vf13, vf13 + vu.vf13.ftoi0(Mask::xyzw, vu.vf13); vu.vf25.mfir(Mask::x, vu.vi04); + // mfir.y vf25, vi04 | nop + vu.vf25.mfir(Mask::y, vu.vi04); + // mfir.x vf26, vi08 | nop + vu.vf26.mfir(Mask::x, vu.vi08); + // ilw.w vi02, 1(vi00) | nop + ilw_buffer(Mask::w, vu.vi02, 1); + // mfir.y vf26, vi04 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); vu.vf26.mfir(Mask::y, vu.vi04); + // sq.xyzw vf13, 1(vi12) | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); + // sq.xyzw vf13, 1(vi15) | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + // nop | nop + +// BRANCH! + // ibne vi00, vi02, L162 | maxw.w vf08, vf08, vf02 + vu.vf08.max(Mask::w, vu.vf08, vu.vf02.w()); bc = (vu.vi02 != 0); + // nop | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); + if (bc) { goto L162; } + + + L157: + // 8388608.0 | maxx.xyzw vf11, vf11, vf00 :i + vu.vf11.max_xyzw(vu.vf11, vu.vf00.x()); vu.I = 8388608.0; + // 256.0 | maxi.xy vf27, vf00, I :i + vu.vf27.maxi(Mask::xy, vu.vf00, vu.I); vu.I = 256.0; + // move.xyzw vf21, vf08 | maxi.w vf27, vf00, I + vu.vf27.maxi(Mask::w, vu.vf00, vu.I); vu.vf21.move_xyzw(vu.vf08); + // nop | nop + + // nop | mulax.xyzw ACC, vf04, vf11 + vu.acc.mula_xyzw(vu.vf04, vu.vf11.x()); +// BRANCH! + // ibgtz vi09, L158 | madday.xyzw ACC, vf05, vf11 + vu.acc.madda_xyzw(vu.vf05, vu.vf11.y()); bc = ((s16)vu.vi09) > 0; + // nop | maddaz.xyzw ACC, vf06, vf11 + vu.acc.madda_xyzw(vu.vf06, vu.vf11.z()); + if (bc) { goto L158; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L158: + // nop | maddw.xyzw vf11, vf07, vf00 + vu.acc.madd_xyzw(vu.vf11, vu.vf07, vu.vf00.w()); + // ilw.x vi09, -3(vi01) | itof0.xyzw vf25, vf25 + vu.vf25.itof0(Mask::xyzw, vu.vf25); ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -3); + // nop | itof0.xyzw vf26, vf26 + vu.vf26.itof0(Mask::xyzw, vu.vf26); + // nop | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); + // nop | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); + // ior vi02, vi05, vi00 | add.xyzw vf25, vf25, vf27 + vu.vf25.add_xyzw(vu.vf25, vu.vf27); vu.vi02 = vu.vi05; +// BRANCH! + // ibgez vi09, L159 | add.xyzw vf26, vf26, vf27 + vu.vf26.add_xyzw(vu.vf26, vu.vf27); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi10) | nop + sq_buffer_xyzw(vu.vf21, vu.vi10 + 2); + if (bc) { goto L159; } + + + // nop | ftoi4.xyzw vf21, vf08 + vu.vf21.ftoi4(Mask::xyzw, vu.vf08); + L159: +// BRANCH! + // ibne vi06, vi05, L160 | nop + bc = (vu.vi06 != vu.vi05); + // sq.xyzw vf14, 0(vi10) | miniy.xyzw vf11, vf11, vf17 + vu.vf11.mini_xyzw(vu.vf11, vu.vf17.y()); sq_buffer_xyzw(vu.vf14, vu.vi10); + if (bc) { goto L160; } + + + // ior vi06, vi07, vi00 | max.xyzw vf25, vf26, vf26 + vu.vf25.max_xyzw(vu.vf26, vu.vf26); vu.vi06 = vu.vi07; + L160: + // sq.xyzw vf14, 0(vi13) | nop + sq_buffer_xyzw(vu.vf14, vu.vi13); + // sq.xyzw vf21, 2(vi13) | nop + sq_buffer_xyzw(vu.vf21, vu.vi13 + 2); + // lqi.xyzw vf27, vi05 | nop + lq_buffer_xyzw(vu.vf27, vu.vi05++); + // nop | ftoi0.xyzw vf11, vf11 + vu.vf11.ftoi0(Mask::xyzw, vu.vf11); + // nop | nop + + // nop | nop + + // nop | itof0.xyzw vf27, vf27 + vu.vf27.itof0(Mask::xyzw, vu.vf27); + // sq.xyzw vf11, 1(vi10) | nop + sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); +// BRANCH! + // b L173 | nop + bc = true; + // sq.xyzw vf11, 1(vi13) | nop + sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + if (bc) { goto L173; } + + + L161: + // 3072.0 | miniw.w vf08, vf08, vf01 :i + vu.vf08.mini(Mask::w, vu.vf08, vu.vf01.w()); vu.I = 3072.0; +// BRANCH! + // b L154 | minii.xy vf10, vf10, I + vu.vf10.minii(Mask::xy, vu.vf10, vu.I); bc = true; + // nop | nop + + if (bc) { goto L154; } + + + L162: + // 1024.0 | nop :i + vu.I = 1024.0; + // 3072.0 | maxi.xy vf08, vf08, I :i + vu.vf08.maxi(Mask::xy, vu.vf08, vu.I); vu.I = 3072.0; +// BRANCH! + // b L157 | minii.xy vf08, vf08, I + vu.vf08.minii(Mask::xy, vu.vf08, vu.I); bc = true; + // isw.w vi00, 1(vi00) | nop + isw_buffer(Mask::w, vu.vi00, 1); + if (bc) { goto L157; } + + + L163: + // ilw.w vi08, 1(vi00) | nop + ilw_buffer(Mask::w, vu.vi08, 1); + // xtop vi02 | mulax.xyzw ACC, vf01, vf11 + vu.acc.mula_xyzw(vu.vf01, vu.vf11.x()); vu.vi02 = xtop(); + // sq.xyzw vf13, 1(vi12) | madday.xyzw ACC, vf02, vf11 + vu.acc.madda_xyzw(vu.vf02, vu.vf11.y()); sq_buffer_xyzw(vu.vf13, vu.vi12 + 1); + // sq.xyzw vf13, 1(vi15) | maddz.xyzw vf11, vf03, vf11 + vu.acc.madd_xyzw(vu.vf11, vu.vf03, vu.vf11.z()); sq_buffer_xyzw(vu.vf13, vu.vi15 + 1); + // iaddiu vi04, vi02, 0x8c | add.xyzw vf09, vf09, vf28 + vu.vf09.add_xyzw(vu.vf09, vu.vf28); vu.vi04 = vu.vi02 + 0x8c; /* 140 */ + // ilwr.x vi05, vi04 | maxw.w vf08, vf08, vf02 + vu.vf08.max(Mask::w, vu.vf08, vu.vf02.w()); ilw_buffer(Mask::x, vu.vi05, vu.vi04); + // ilw.w vi06, 1(vi04) | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); ilw_buffer(Mask::w, vu.vi06, vu.vi04 + 1); +// BRANCH! + // ibne vi00, vi08, L171 | nop + bc = (vu.vi08 != 0); + // ilw.x vi07, 2(vi04) | maxx.xyzw vf11, vf11, vf00 + vu.vf11.max_xyzw(vu.vf11, vu.vf00.x()); ilw_buffer(Mask::x, vu.vi07, vu.vi04 + 2); + if (bc) { goto L171; } + + + L164: + // div Q, vf01.w, vf09.w | minix.xyzw vf25, vf00, vf00 + vu.vf25.mini_xyzw(vu.vf00, vu.vf00.x()); vu.Q = vu.vf01.w() / vu.vf09.w(); + + // move.xyzw vf21, vf08 | minix.xyzw vf26, vf00, vf00 + vu.vf26.mini_xyzw(vu.vf00, vu.vf00.x()); vu.vf21.move_xyzw(vu.vf08); + // iadd vi05, vi05, vi04 | nop + vu.vi05 = vu.vi05 + vu.vi04; + // iaddiu vi04, vi02, 0x173 | mulax.xyzw ACC, vf04, vf11 + vu.acc.mula_xyzw(vu.vf04, vu.vf11.x()); vu.vi04 = vu.vi02 + 0x173; /* 371 */ +// BRANCH! + // ibgtz vi09, L165 | madday.xyzw ACC, vf05, vf11 + vu.acc.madda_xyzw(vu.vf05, vu.vf11.y()); bc = ((s16)vu.vi09) > 0; + // iadd vi06, vi06, vi05 | maddaz.xyzw ACC, vf06, vf11 + vu.acc.madda_xyzw(vu.vf06, vu.vf11.z()); vu.vi06 = vu.vi06 + vu.vi05; + if (bc) { goto L165; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L165: + // iadd vi07, vi07, vi06 | maddw.xyzw vf11, vf07, vf00 + vu.acc.madd_xyzw(vu.vf11, vu.vf07, vu.vf00.w()); vu.vi07 = vu.vi07 + vu.vi06; + // ilw.x vi09, -6(vi01) | mul.xyz vf09, vf09, Q + vu.vf09.mul(Mask::xyz, vu.vf09, vu.Q); /* TODO mulq */ ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -6); + // iaddiu vi08, vi00, 0x1ba | mul.xyzw vf15, vf15, Q + vu.vf15.mul_xyzw(vu.vf15, vu.Q); /* TODO mulq */ vu.vi08 = 0x1ba; /* 442 */ + + // isub vi08, vi08, vi02 | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); vu.vi08 = vu.vi08 - vu.vi02; + // iaddiu vi08, vi08, 0x173 | mul.xyzw vf11, vf11, vf23 + vu.vf11.mul_xyzw(vu.vf11, vu.vf23); vu.vi08 = vu.vi08 + 0x173; /* 371 */ + // lqi.xyzw vf23, vi03 | add.xyzw vf09, vf09, vf22 + vu.vf09.add_xyzw(vu.vf09, vu.vf22); lq_buffer_xyzw(vu.vf23, vu.vi03++); +// BRANCH! + // ibgez vi09, L166 | nop + bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi10) | nop + sq_buffer_xyzw(vu.vf21, vu.vi10 + 2); + if (bc) { goto L166; } + + + // nop | ftoi4.xyzw vf21, vf08 + vu.vf21.ftoi4(Mask::xyzw, vu.vf08); + L166: + // mfp.w vf20, P | nop + vu.vf20.mfp(Mask::w, vu.P); + // sq.xyzw vf14, 0(vi10) | miniy.xyzw vf11, vf11, vf17 + vu.vf11.mini_xyzw(vu.vf11, vu.vf17.y()); sq_buffer_xyzw(vu.vf14, vu.vi10); + // sq.xyzw vf14, 0(vi13) | miniw.w vf09, vf09, vf03 + vu.vf09.mini(Mask::w, vu.vf09, vu.vf03.w()); sq_buffer_xyzw(vu.vf14, vu.vi13); + // sq.xyzw vf21, 2(vi13) | nop + sq_buffer_xyzw(vu.vf21, vu.vi13 + 2); + // ilw.y vi09, -3(vi01) | mulw.xyzw vf12, vf12, vf20 + vu.vf12.mul_xyzw(vu.vf12, vu.vf20.w()); ilw_buffer(Mask::y, vu.vi09, vu.vi01 + -3); + // mfir.x vf25, vi04 | ftoi0.xyzw vf11, vf11 + vu.vf11.ftoi0(Mask::xyzw, vu.vf11); vu.vf25.mfir(Mask::x, vu.vi04); + // mfir.y vf25, vi04 | nop + vu.vf25.mfir(Mask::y, vu.vi04); + // mfir.x vf26, vi08 | nop + vu.vf26.mfir(Mask::x, vu.vi08); + // ilw.w vi02, 1(vi00) | nop + ilw_buffer(Mask::w, vu.vi02, 1); + // mfir.y vf26, vi04 | mulax.xyzw ACC, vf01, vf12 + vu.acc.mula_xyzw(vu.vf01, vu.vf12.x()); vu.vf26.mfir(Mask::y, vu.vi04); + // sq.xyzw vf11, 1(vi10) | madday.xyzw ACC, vf02, vf12 + vu.acc.madda_xyzw(vu.vf02, vu.vf12.y()); sq_buffer_xyzw(vu.vf11, vu.vi10 + 1); + // sq.xyzw vf11, 1(vi13) | maddz.xyzw vf12, vf03, vf12 + vu.acc.madd_xyzw(vu.vf12, vu.vf03, vu.vf12.z()); sq_buffer_xyzw(vu.vf11, vu.vi13 + 1); + // nop | nop + +// BRANCH! + // ibne vi00, vi02, L172 | maxw.w vf09, vf09, vf02 + vu.vf09.max(Mask::w, vu.vf09, vu.vf02.w()); bc = (vu.vi02 != 0); + // nop | itof0.xyzw vf23, vf23 + vu.vf23.itof0(Mask::xyzw, vu.vf23); + if (bc) { goto L172; } + + + L167: + // 8388608.0 | maxx.xyzw vf12, vf12, vf00 :i + vu.vf12.max_xyzw(vu.vf12, vu.vf00.x()); vu.I = 8388608.0; + // 256.0 | maxi.xy vf27, vf00, I :i + vu.vf27.maxi(Mask::xy, vu.vf00, vu.I); vu.I = 256.0; + // move.xyzw vf21, vf09 | maxi.w vf27, vf00, I + vu.vf27.maxi(Mask::w, vu.vf00, vu.I); vu.vf21.move_xyzw(vu.vf09); + // nop | nop + + // nop | mulax.xyzw ACC, vf04, vf12 + vu.acc.mula_xyzw(vu.vf04, vu.vf12.x()); +// BRANCH! + // ibgtz vi09, L168 | madday.xyzw ACC, vf05, vf12 + vu.acc.madda_xyzw(vu.vf05, vu.vf12.y()); bc = ((s16)vu.vi09) > 0; + // nop | maddaz.xyzw ACC, vf06, vf12 + vu.acc.madda_xyzw(vu.vf06, vu.vf12.z()); + if (bc) { goto L168; } + + + // nop | addx.w vf21, vf21, vf17 + vu.vf21.add(Mask::w, vu.vf21, vu.vf17.x()); + L168: + // nop | maddw.xyzw vf12, vf07, vf00 + vu.acc.madd_xyzw(vu.vf12, vu.vf07, vu.vf00.w()); + // ilw.x vi09, -3(vi01) | itof0.xyzw vf25, vf25 + vu.vf25.itof0(Mask::xyzw, vu.vf25); ilw_buffer(Mask::x, vu.vi09, vu.vi01 + -3); + // nop | itof0.xyzw vf26, vf26 + vu.vf26.itof0(Mask::xyzw, vu.vf26); + // nop | ftoi4.xyzw vf21, vf21 + vu.vf21.ftoi4(Mask::xyzw, vu.vf21); + // nop | mul.xyzw vf12, vf12, vf23 + vu.vf12.mul_xyzw(vu.vf12, vu.vf23); + // ior vi02, vi05, vi00 | add.xyzw vf25, vf25, vf27 + vu.vf25.add_xyzw(vu.vf25, vu.vf27); vu.vi02 = vu.vi05; +// BRANCH! + // ibgez vi09, L169 | add.xyzw vf26, vf26, vf27 + vu.vf26.add_xyzw(vu.vf26, vu.vf27); bc = ((s16)vu.vi09) >= 0; + // sq.xyzw vf21, 2(vi11) | nop + sq_buffer_xyzw(vu.vf21, vu.vi11 + 2); + if (bc) { goto L169; } + + + // nop | ftoi4.xyzw vf21, vf09 + vu.vf21.ftoi4(Mask::xyzw, vu.vf09); + L169: +// BRANCH! + // ibne vi06, vi05, L170 | nop + bc = (vu.vi06 != vu.vi05); + // sq.xyzw vf15, 0(vi11) | miniy.xyzw vf12, vf12, vf17 + vu.vf12.mini_xyzw(vu.vf12, vu.vf17.y()); sq_buffer_xyzw(vu.vf15, vu.vi11); + if (bc) { goto L170; } + + + // ior vi06, vi07, vi00 | max.xyzw vf25, vf26, vf26 + vu.vf25.max_xyzw(vu.vf26, vu.vf26); vu.vi06 = vu.vi07; + L170: + // sq.xyzw vf15, 0(vi14) | nop + sq_buffer_xyzw(vu.vf15, vu.vi14); + // sq.xyzw vf21, 2(vi14) | nop + sq_buffer_xyzw(vu.vf21, vu.vi14 + 2); + // lqi.xyzw vf27, vi05 | nop + lq_buffer_xyzw(vu.vf27, vu.vi05++); + // nop | ftoi0.xyzw vf12, vf12 + vu.vf12.ftoi0(Mask::xyzw, vu.vf12); + // nop | nop + + // nop | nop + + // nop | itof0.xyzw vf27, vf27 + vu.vf27.itof0(Mask::xyzw, vu.vf27); + // sq.xyzw vf12, 1(vi11) | nop + sq_buffer_xyzw(vu.vf12, vu.vi11 + 1); +// BRANCH! + // b L173 | nop + bc = true; + // sq.xyzw vf12, 1(vi14) | nop + sq_buffer_xyzw(vu.vf12, vu.vi14 + 1); + if (bc) { goto L173; } + + + L171: + // 3072.0 | miniw.w vf09, vf09, vf01 :i + vu.vf09.mini(Mask::w, vu.vf09, vu.vf01.w()); vu.I = 3072.0; +// BRANCH! + // b L164 | minii.xy vf08, vf08, I + vu.vf08.minii(Mask::xy, vu.vf08, vu.I); bc = true; + // nop | nop + + if (bc) { goto L164; } + + + L172: + // 1024.0 | nop :i + vu.I = 1024.0; + // 3072.0 | maxi.xy vf09, vf09, I :i + vu.vf09.maxi(Mask::xy, vu.vf09, vu.I); vu.I = 3072.0; +// BRANCH! + // b L167 | minii.xy vf09, vf09, I + vu.vf09.minii(Mask::xy, vu.vf09, vu.I); bc = true; + // isw.w vi00, 1(vi00) | nop + isw_buffer(Mask::w, vu.vi00, 1); + if (bc) { goto L167; } + + + L173: +// BRANCH! + // ibeq vi07, vi02, L179 | nop + bc = (vu.vi07 == vu.vi02); + // ilw.w vi15, 132(vi00) | nop + vu.hack_old_vi15 = vu.vi15; + ilw_buffer(Mask::w, vu.vi15, 132); + if (bc) { goto L179; } + + +// BRANCH! + // ibne vi06, vi05, L174 | add.xyzw vf11, vf27, vf25 + vu.vf11.add_xyzw(vu.vf27, vu.vf25); bc = (vu.vi06 != vu.vi05); + // nop | nop + + if (bc) { goto L174; } + + +// BRANCH! + // ibne vi07, vi06, L174 | nop + bc = (vu.vi07 != vu.vi06); + // ior vi06, vi07, vi00 | max.xyzw vf25, vf26, vf26 + vu.vf25.max_xyzw(vu.vf26, vu.vf26); vu.vi06 = vu.vi07; + if (bc) { goto L174; } + + + // nop | nop + + // nop | nop + + // mtir vi08, vf11.x | nop + vu.vi08 = vu.vf11.x_as_u16(); + // mtir vi10, vf11.y | nop + vu.vi10 = vu.vf11.y_as_u16(); + // nop | nop + + // nop | nop + + // lq.xyzw vf16, 2(vi08) | maxx.xyzw vf15, vf11, vf00 + vu.vf15.max_xyzw(vu.vf11, vu.vf00.x()); lq_buffer_xyzw(vu.vf16, vu.vi08 + 2); + // lq.xyzw vf13, 0(vi08) | nop + lq_buffer_xyzw(vu.vf13, vu.vi08); +// BRANCH! + // b L178 | nop + bc = true; + // nop | nop + + if (bc) { goto L178; } + + + L174: + // lqi.xyzw vf27, vi05 | nop + lq_buffer_xyzw(vu.vf27, vu.vi05++); + // nop | nop + + // mtir vi08, vf11.x | nop + vu.vi08 = vu.vf11.x_as_u16(); + // mtir vi09, vf11.y | nop + vu.vi09 = vu.vf11.y_as_u16(); + // nop | itof0.xyzw vf27, vf27 + vu.vf27.itof0(Mask::xyzw, vu.vf27); + // nop | nop + + // lq.xyzw vf12, 2(vi08) | maxx.xyzw vf15, vf11, vf00 + vu.vf15.max_xyzw(vu.vf11, vu.vf00.x()); lq_buffer_xyzw(vu.vf12, vu.vi08 + 2); + // lq.xyzw vf13, 0(vi08) | nop + lq_buffer_xyzw(vu.vf13, vu.vi08); +// BRANCH! + // ibne vi06, vi05, L175 | add.xyzw vf11, vf27, vf25 + vu.vf11.add_xyzw(vu.vf27, vu.vf25); bc = (vu.vi06 != vu.vi05); + // nop | nop + + if (bc) { goto L175; } + + +// BRANCH! + // ibeq vi07, vi06, L177 | nop + bc = (vu.vi07 == vu.vi06); + // ior vi06, vi07, vi00 | max.xyzw vf25, vf26, vf26 + vu.vf25.max_xyzw(vu.vf26, vu.vf26); vu.vi06 = vu.vi07; + if (bc) { goto L177; } + + + L175: + // lqi.xyzw vf27, vi05 | itof15.w vf12, vf12 + vu.vf12.itof15(Mask::w, vu.vf12); lq_buffer_xyzw(vu.vf27, vu.vi05++); + // lq.xyzw vf14, 1(vi08) | nop + lq_buffer_xyzw(vu.vf14, vu.vi08 + 1); + // mtir vi08, vf11.x | nop + vu.vi08 = vu.vf11.x_as_u16(); + // mtir vi10, vf11.y | nop + vu.vi10 = vu.vf11.y_as_u16(); + // sq.xyzw vf13, 0(vi09) | itof0.xyzw vf27, vf27 + vu.vf27.itof0(Mask::xyzw, vu.vf27); sq_buffer_xyzw(vu.vf13, vu.vi09); + // sq.xyzw vf14, 1(vi09) | add.w vf12, vf12, vf15 + vu.vf12.add(Mask::w, vu.vf12, vu.vf15); sq_buffer_xyzw(vu.vf14, vu.vi09 + 1); + // lq.xyzw vf16, 2(vi08) | maxx.xyzw vf15, vf11, vf00 + vu.vf15.max_xyzw(vu.vf11, vu.vf00.x()); lq_buffer_xyzw(vu.vf16, vu.vi08 + 2); + // lq.xyzw vf13, 0(vi08) | nop + lq_buffer_xyzw(vu.vf13, vu.vi08); +// BRANCH! + // ibne vi06, vi05, L176 | add.xyzw vf11, vf27, vf25 + vu.vf11.add_xyzw(vu.vf27, vu.vf25); bc = (vu.vi06 != vu.vi05); + // sq.xyzw vf12, 2(vi09) | nop + sq_buffer_xyzw(vu.vf12, vu.vi09 + 2); + if (bc) { goto L176; } + + +// BRANCH! + // ibne vi07, vi06, L176 | nop + bc = (vu.vi07 != vu.vi06); + // ior vi06, vi07, vi00 | max.xyzw vf25, vf26, vf26 + vu.vf25.max_xyzw(vu.vf26, vu.vf26); vu.vi06 = vu.vi07; + if (bc) { goto L176; } + + + // move.xyzw vf12, vf16 | nop + vu.vf12.move_xyzw(vu.vf16); +// BRANCH! + // b L177 | nop + bc = true; + // ior vi09, vi10, vi00 | nop + vu.vi09 = vu.vi10; + if (bc) { goto L177; } + + + L176: + // lqi.xyzw vf27, vi05 | itof15.w vf16, vf16 + vu.vf16.itof15(Mask::w, vu.vf16); lq_buffer_xyzw(vu.vf27, vu.vi05++); + // lq.xyzw vf14, 1(vi08) | nop + lq_buffer_xyzw(vu.vf14, vu.vi08 + 1); + // mtir vi08, vf11.x | nop + vu.vi08 = vu.vf11.x_as_u16(); + // mtir vi09, vf11.y | nop + vu.vi09 = vu.vf11.y_as_u16(); + // sq.xyzw vf13, 0(vi10) | itof0.xyzw vf27, vf27 + vu.vf27.itof0(Mask::xyzw, vu.vf27); sq_buffer_xyzw(vu.vf13, vu.vi10); + // sq.xyzw vf14, 1(vi10) | add.w vf16, vf16, vf15 + vu.vf16.add(Mask::w, vu.vf16, vu.vf15); sq_buffer_xyzw(vu.vf14, vu.vi10 + 1); + // lq.xyzw vf12, 2(vi08) | maxx.xyzw vf15, vf11, vf00 + vu.vf15.max_xyzw(vu.vf11, vu.vf00.x()); lq_buffer_xyzw(vu.vf12, vu.vi08 + 2); + // lq.xyzw vf13, 0(vi08) | nop + lq_buffer_xyzw(vu.vf13, vu.vi08); +// BRANCH! + // ibne vi06, vi05, L175 | add.xyzw vf11, vf27, vf25 + vu.vf11.add_xyzw(vu.vf27, vu.vf25); bc = (vu.vi06 != vu.vi05); + // sq.xyzw vf16, 2(vi10) | nop + sq_buffer_xyzw(vu.vf16, vu.vi10 + 2); + if (bc) { goto L175; } + + +// BRANCH! + // ibne vi07, vi06, L175 | nop + bc = (vu.vi07 != vu.vi06); + // ior vi06, vi07, vi00 | max.xyzw vf25, vf26, vf26 + vu.vf25.max_xyzw(vu.vf26, vu.vf26); vu.vi06 = vu.vi07; + if (bc) { goto L175; } + + + L177: + // nop | itof15.w vf12, vf12 + vu.vf12.itof15(Mask::w, vu.vf12); + // lq.xyzw vf14, 1(vi08) | nop + lq_buffer_xyzw(vu.vf14, vu.vi08 + 1); + // mtir vi08, vf11.x | nop + vu.vi08 = vu.vf11.x_as_u16(); + // mtir vi10, vf11.y | nop + vu.vi10 = vu.vf11.y_as_u16(); + // sq.xyzw vf13, 0(vi09) | nop + sq_buffer_xyzw(vu.vf13, vu.vi09); + // sq.xyzw vf14, 1(vi09) | add.w vf12, vf12, vf15 + vu.vf12.add(Mask::w, vu.vf12, vu.vf15); sq_buffer_xyzw(vu.vf14, vu.vi09 + 1); + // lq.xyzw vf16, 2(vi08) | maxx.xyzw vf15, vf11, vf00 + vu.vf15.max_xyzw(vu.vf11, vu.vf00.x()); lq_buffer_xyzw(vu.vf16, vu.vi08 + 2); + // lq.xyzw vf13, 0(vi08) | nop + lq_buffer_xyzw(vu.vf13, vu.vi08); + // nop | nop + + // sq.xyzw vf12, 2(vi09) | nop + sq_buffer_xyzw(vu.vf12, vu.vi09 + 2); + L178: + // nop | itof15.w vf16, vf16 + vu.vf16.itof15(Mask::w, vu.vf16); + // lq.xyzw vf14, 1(vi08) | nop + lq_buffer_xyzw(vu.vf14, vu.vi08 + 1); + // nop | nop + + // nop | nop + + // sq.xyzw vf13, 0(vi10) | nop + sq_buffer_xyzw(vu.vf13, vu.vi10); + // sq.xyzw vf14, 1(vi10) | add.w vf16, vf16, vf15 + vu.vf16.add(Mask::w, vu.vf16, vu.vf15); sq_buffer_xyzw(vu.vf14, vu.vi10 + 1); + // nop | nop + + // nop | nop + + // nop | nop + + // sq.xyzw vf16, 2(vi10) | nop + sq_buffer_xyzw(vu.vf16, vu.vi10 + 2); + L179: +// BRANCH! + // ibne vi00, vi15, L180 | nop + bc = (vu.vi15 != 0); + // nop | nop + + if (bc) { goto L180; } + + + // xgkick vi04 | nop + xgkick(vu.vi04, render_state, prof); + // nop | nop :e + return; + + // nop | nop + + L180: + // lq.xyzw vf20, 132(vi00) | nop + lq_buffer_xyzw(vu.vf20, 132); + // lq.xyzw vf21, 1(vi00) | nop + lq_buffer_xyzw(vu.vf21, 1); + // iaddi vi01, vi00, 0x1 | nop + vu.vi01 = 1; + // isw.x vi01, -2(vi04) | nop + isw_buffer(Mask::x, vu.vi01, vu.vi04 + -2); + // iaddiu vi02, vi00, 0x47 | maxw.x vf20, vf00, vf20 + vu.vf20.max(Mask::x, vu.vf00, vu.vf20.w()); vu.vi02 = 0x47; /* 71 */ + + // isw.z vi02, -1(vi04) | nop + isw_buffer(Mask::z, vu.vi02, vu.vi04 + -1); + // sq.yzw vf21, -2(vi04) | nop + sq_buffer(Mask::yzw, vu.vf21, vu.vi04 + -2); + // isw.w vi00, 132(vi00) | nop + isw_buffer(Mask::w, vu.vi00, 132); + // sq.x vf20, -1(vi04) | nop + sq_buffer(Mask::x, vu.vf20, vu.vi04 + -1); + // iaddi vi04, vi04, -0x2 | nop + vu.vi04 = vu.vi04 + -2; + // xgkick vi04 | nop + xgkick(vu.vi04, render_state, prof); + // nop | nop :e +} + diff --git a/game/graphics/opengl_renderer/MercRenderer.cpp b/game/graphics/opengl_renderer/MercRenderer.cpp new file mode 100644 index 0000000000..8cc0395f33 --- /dev/null +++ b/game/graphics/opengl_renderer/MercRenderer.cpp @@ -0,0 +1,346 @@ +#include "MercRenderer.h" + +#include "third-party/imgui/imgui.h" + +MercRenderer::MercRenderer(const std::string& name, BucketId my_id) + : BucketRenderer(name, my_id), + m_direct(fmt::format("{}-dir", name), my_id, 0x30000, DirectRenderer::Mode::NORMAL) { + memset(m_buffer.data, 0, sizeof(m_buffer.data)); +} + +void MercRenderer::render(DmaFollower& dma, + SharedRenderState* render_state, + ScopedProfilerNode& prof) { + m_stats = Stats(); + + // skip if disabled + if (!m_enabled) { + while (dma.current_tag_offset() != render_state->next_bucket) { + dma.read_and_advance(); + } + return; + } + + // process the first tag. this is just jumping to the merc-specific dma. + auto data0 = dma.read_and_advance(); + assert(data0.vif1() == 0); + assert(data0.vif0() == 0); + assert(data0.size_bytes == 0); + if (dma.current_tag().kind == DmaTag::Kind::CALL) { + // renderer didn't run, let's just get out of here. + for (int i = 0; i < 4; i++) { + dma.read_and_advance(); + } + assert(dma.current_tag_offset() == render_state->next_bucket); + return; + } + m_stats.had_data = true; + assert(data0.size_bytes == 0); + assert(data0.vif0() == 0); + assert(data0.vif1() == 0); + + // if we reach here, there's stuff to draw + handle_setup(dma, render_state, prof); + + m_direct.reset_state(); + while (dma.current_tag_offset() != render_state->next_bucket) { + handle_merc_chain(dma, render_state, prof); + } + assert(dma.current_tag_offset() == render_state->next_bucket); + m_direct.flush_pending(render_state, prof); +} + +bool tag_is_nothing_next(const DmaFollower& dma) { + return dma.current_tag().kind == DmaTag::Kind::NEXT && dma.current_tag().qwc == 0 && + dma.current_tag_vif0() == 0 && dma.current_tag_vif1() == 0; +} + +void MercRenderer::unpack32(const VifCodeUnpack& up, const u8* data, u32 imm) { + assert(!up.is_unsigned); + u32 addr = up.addr_qw; + assert(imm != 0); + assert(!m_vif.stmod); + if (up.use_tops_flag) { + addr += xitop(); + } + + u32 start_in_buff = (addr)*16; + u32 end_in_buff = start_in_buff + imm * 16; + assert(start_in_buff < sizeof(m_buffer.data)); + assert(end_in_buff <= sizeof(m_buffer.data)); + memcpy(m_buffer.data + start_in_buff, data, imm * 16); +} + +void MercRenderer::unpack8(const VifCodeUnpack& up, const u8* data, u32 imm) { + // assert(m_vif.stmod); + + assert(up.is_unsigned); + u32 addr = up.addr_qw; + if (up.use_tops_flag) { + addr += xitop(); + } + assert(imm != 0); + + u32 start_in_buff = (addr)*16; + u32 end_in_buff = start_in_buff + imm * 16; + assert(start_in_buff < sizeof(m_buffer.data)); + assert(end_in_buff <= sizeof(m_buffer.data)); + + u8* out_ptr = m_buffer.data + start_in_buff; + + if (m_vif.stmod) { + // use row + auto row = _mm_loadu_si128((const __m128i*)m_vif.row); + for (u32 qw = 0; qw < imm; qw++) { + _mm_storeu_si128((__m128i*)out_ptr, + _mm_add_epi32(row, _mm_cvtepu8_epi32(_mm_loadu_si64(data)))); + data += 4; + out_ptr += 16; + } + } else { + // no row + for (u32 qw = 0; qw < imm; qw++) { + _mm_storeu_si128((__m128i*)out_ptr, _mm_cvtepu8_epi32(_mm_loadu_si64(data))); + data += 4; + out_ptr += 16; + } + } + + /* + u32 row[4]; + if (m_vif.stmod) { + memcpy(row, m_vif.row, 16); + } else { + memset(row, 0, 16); + } + + u32 temp[4]; + for (u32 i = 0; i < imm; i++) { + for (u32 j = 0; j < 4; j++) { + temp[j] = row[j] + data[4 * i + j]; + } + memcpy(m_buffer.data + start_in_buff + i * 16, temp, 16); + } + */ +} + +void MercRenderer::handle_merc_chain(DmaFollower& dma, + SharedRenderState* render_state, + ScopedProfilerNode& prof) { + // fmt::print("DMA: {}\n", dma.current_tag().print()); + while (tag_is_nothing_next(dma)) { + auto nothing = dma.read_and_advance(); + assert(nothing.size_bytes == 0); + } + if (dma.current_tag().kind == DmaTag::Kind::CALL) { + for (int i = 0; i < 4; i++) { + dma.read_and_advance(); + } + return; + } + + auto init = dma.read_and_advance(); + + assert(init.vifcode0().kind == VifCode::Kind::STROW); + assert(init.size_bytes == 16); + m_vif.row[0] = init.vif1(); + memcpy(m_vif.row + 1, init.data, 12); + u32 extra; + memcpy(&extra, init.data + 12, 4); + assert(extra == 0); + DmaTransfer next; + + bool setting_up = true; + u32 mscal_addr = -1; + while (setting_up) { + next = dma.read_and_advance(); + u32 offset_in_data = 0; + // fmt::print("START {} : {} {}\n", next.size_bytes, next.vifcode0().print(), + // next.vifcode1().print()); + auto vif0 = next.vifcode0(); + switch (vif0.kind) { + case VifCode::Kind::NOP: + case VifCode::Kind::FLUSHE: + break; + case VifCode::Kind::STMOD: + assert(vif0.immediate == 0 || vif0.immediate == 1); + m_vif.stmod = vif0.immediate; + break; + default: + assert(false); + } + + auto vif1 = next.vifcode1(); + switch (vif1.kind) { + case VifCode::Kind::UNPACK_V4_8: { + // todo unpack + m_stats.unpack_count++; + m_stats.unpack_bytes += vif1.num * 4; + VifCodeUnpack up(vif1); + unpack8(up, next.data, vif1.num); + offset_in_data += 4 * vif1.num; + } break; + case VifCode::Kind::UNPACK_V4_32: { + // todo unpack + VifCodeUnpack up(vif1); + unpack32(up, next.data, vif1.num); + m_stats.unpack_bytes += vif1.num * 16; + offset_in_data += 16 * vif1.num; + } break; + case VifCode::Kind::MSCAL: + mscal_addr = vif1.immediate; + assert(next.size_bytes == 0); + setting_up = false; + break; + default: + assert(false); + } + + assert(offset_in_data <= next.size_bytes); + if (offset_in_data < next.size_bytes) { + assert((offset_in_data % 4) == 0); + u32 leftover = next.size_bytes - offset_in_data; + if (leftover < 16) { + for (u32 i = 0; i < leftover; i++) { + assert(next.data[offset_in_data + i] == 0); + } + } else { + assert(false); + } + } + } + + m_dbf = !m_dbf; + switch (mscal_addr) { + case 17: + m_stats.mscal_17++; + if (m_enable_prime_mscals) { + mscal(17, render_state, prof); + } + break; + case 32: + m_stats.mscal_32++; + if (m_enable_prime_mscals) { + mscal(32, render_state, prof); + } + break; + + case 20: + m_stats.mscal_20++; + if (m_enable_normal_mscals) { + mscal(20, render_state, prof); + } + break; + case 35: + m_stats.mscal_35++; + if (m_enable_normal_mscals) { + mscal(35, render_state, prof); + } + break; + default: + fmt::print("unknown mscal: {}\n", mscal_addr); + assert(false); + } + + // while (true) { + // next = dma.read_and_advance(); + // if (next.vif0() == 0 && next.vifcode1().kind == VifCode::Kind::UNPACK_V4_8) { + // + // } else { + // fmt::print("{} : {} {}\n", next.size_bytes, next.vifcode0().print(), + // next.vifcode1().print()); assert(false); + // } + // } +} + +/*! + * Handle the setup DMA data prepared by merc-vu1-init-buffer in GOAL + */ +void MercRenderer::handle_setup(DmaFollower& dma, + SharedRenderState* render_state, + ScopedProfilerNode& prof) { + auto first = dma.read_and_advance(); + + // 10 quadword setup packet + assert(first.size_bytes == 10 * 16); + // m_stats.str += fmt::format("Setup 0: {} {} {}", first.size_bytes / 16, + // first.vifcode0().print(), first.vifcode1().print()); + + // transferred vifcodes + { + auto vif0 = first.vifcode0(); + auto vif1 = first.vifcode1(); + // STCYCL 4, 4 + assert(vif0.kind == VifCode::Kind::STCYCL); + auto vif0_st = VifCodeStcycl(vif0); + assert(vif0_st.cl == 4 && vif0_st.wl == 4); + // STMOD + assert(vif1.kind == VifCode::Kind::STMOD); + assert(vif1.immediate == 0); + } + + // 1 qw with 4 vifcodes. + u32 vifcode_data[4]; + memcpy(vifcode_data, first.data, 16); + { + auto vif0 = VifCode(vifcode_data[0]); + assert(vif0.kind == VifCode::Kind::BASE); + assert(vif0.immediate == MercDataMemory::BUFFER_BASE); + auto vif1 = VifCode(vifcode_data[1]); + assert(vif1.kind == VifCode::Kind::OFFSET); + assert((s16)vif1.immediate == MercDataMemory::BUFFER_OFFSET); + auto vif2 = VifCode(vifcode_data[2]); + assert(vif2.kind == VifCode::Kind::NOP); + auto vif3 = VifCode(vifcode_data[3]); + assert(vif3.kind == VifCode::Kind::UNPACK_V4_32); + VifCodeUnpack up(vif3); + assert(up.addr_qw == MercDataMemory::LOW_MEMORY); + assert(!up.use_tops_flag); + assert(vif3.num == 8); + } + + // 8 qw's of low memory data + memcpy(&m_low_memory, first.data + 16, sizeof(LowMemory)); + m_stats.str += fmt::format("Fog: {}\n", m_low_memory.fog.to_string_aligned()); + + // 1 qw with another 4 vifcodes. + u32 vifcode_final_data[4]; + memcpy(vifcode_final_data, first.data + 16 + sizeof(LowMemory), 16); + { + assert(VifCode(vifcode_final_data[0]).kind == VifCode::Kind::FLUSHE); + assert(vifcode_final_data[1] == 0); + assert(vifcode_final_data[2] == 0); + VifCode mscal(vifcode_final_data[3]); + assert(mscal.kind == VifCode::Kind::MSCAL); + assert(mscal.immediate == 0); + } + + // copy low memory into the VU "emulation" RAM. + memcpy(m_buffer.data, &m_low_memory, sizeof(LowMemory)); + mscal(0, render_state, prof); + + auto second = dma.read_and_advance(); + assert(second.size_bytes == 32); // setting up test register. + m_direct.render_gif(second.data, 32, render_state, prof); + auto nothing = dma.read_and_advance(); + assert(nothing.size_bytes == 0); + assert(nothing.vif0() == 0); + assert(nothing.vif1() == 0); +} + +void MercRenderer::draw_debug_window() { + ImGui::Text("Ran? %d\n", m_stats.had_data); + ImGui::Text("%d unpacks, %d bytes\n", m_stats.unpack_count, m_stats.unpack_bytes); + ImGui::Text("MSCAL: [17] %d [20] %d [32] %d [35] %d \n", m_stats.mscal_17, m_stats.mscal_20, + m_stats.mscal_32, m_stats.mscal_35); + ImGui::Text("Debug:\n%s\n", m_stats.str.c_str()); + ImGui::Checkbox("Normal MSCAL enable", &m_enable_normal_mscals); + ImGui::Checkbox("Prime MSCAL enable", &m_enable_prime_mscals); + ImGui::Checkbox("Send to direct", &m_enable_send_to_direct); +} + +void MercRenderer::xgkick(u16 addr, SharedRenderState* render_state, ScopedProfilerNode& prof) { + if (m_enable_send_to_direct) { + m_direct.render_gif(m_buffer.data + (16 * addr), UINT32_MAX, render_state, prof); + } +} diff --git a/game/graphics/opengl_renderer/MercRenderer.h b/game/graphics/opengl_renderer/MercRenderer.h new file mode 100644 index 0000000000..07a0d6f095 --- /dev/null +++ b/game/graphics/opengl_renderer/MercRenderer.h @@ -0,0 +1,539 @@ +#pragma once + +#include "game/graphics/opengl_renderer/BucketRenderer.h" +#include "common/math/Vector.h" +#include "game/graphics/opengl_renderer/DirectRenderer.h" + +#include "immintrin.h" + +enum class Mask { + NONE = 0, + x = 1, + y = 2, + xy = 3, + z = 4, + xz = 5, + yz = 6, + xyz = 7, + w = 8, + xw = 9, + yw = 10, + xyw = 11, + zw = 12, + xzw = 13, + yzw = 14, + xyzw = 15 +}; + +#ifdef __linux__ +#define REALLY_INLINE __attribute__((always_inline)) +#else +#define REALLY_INLINE __forceinline +#endif + +// note: must be aligned. +static inline REALLY_INLINE void copy_vector(void* dest, const void* src) { + __m128 val = _mm_load_ps((const float*)src); + _mm_store_ps((float*)dest, val); +} + +inline float vu_max(float a, float b) { + return std::max(b, a); + // s32 ai, bi; + // memcpy(&ai, &a, 4); + // memcpy(&bi, &b, 4); + // bool flip = ai < 0 && bi < 0; + // if (ai > bi) { + // return flip ? b : a; + // } else { + // return flip ? a : b; + // } +} + +inline float vu_min(float a, float b) { + s32 ai, bi; + memcpy(&ai, &a, 4); + memcpy(&bi, &b, 4); + bool flip = ai < 0 && bi < 0; + if (ai > bi) { + return flip ? a : b; + } else { + return flip ? b : a; + } +} + +struct alignas(16) Vf { + REALLY_INLINE __m128 load() const { return _mm_load_ps(data); } + + REALLY_INLINE void move_xyzw(const Vf& src) { copy_vector(data, src.data); } + + float data[4]; + float& x() { return data[0]; } + float& y() { return data[1]; } + float& z() { return data[2]; } + float& w() { return data[3]; } + + const float& x() const { return data[0]; } + const float& y() const { return data[1]; } + const float& z() const { return data[2]; } + const float& w() const { return data[3]; } + + u16 x_as_u16() const { + u16 result; + memcpy(&result, &data[0], 2); + return result; + } + + u16 y_as_u16() const { + u16 result; + memcpy(&result, &data[1], 2); + return result; + } + + u16 z_as_u16() const { + u16 result; + memcpy(&result, &data[2], 2); + return result; + } + + u16 w_as_u16() const { + u16 result; + memcpy(&result, &data[3], 2); + return result; + } + + u32 x_as_u32() const { + u32 result; + memcpy(&result, &data[0], 4); + return result; + } + + u32 y_as_u32() const { + u32 result; + memcpy(&result, &data[1], 4); + return result; + } + + u32 z_as_u32() const { + u32 result; + memcpy(&result, &data[2], 4); + return result; + } + + u32 w_as_u32() const { + u32 result; + memcpy(&result, &data[3], 4); + return result; + } + + Vf() = default; + Vf(const math::Vector4f& vec) { memcpy(data, vec.data(), 16); } + Vf(float a, float b, float c, float d) { + data[0] = a; + data[1] = b; + data[2] = c; + data[3] = d; + } + + std::string str_float() const { return fmt::format("{} {} {} {}", x(), y(), z(), w()); } + + float& operator[](int i) { return data[i]; } + float operator[](int i) const { return data[i]; } + + void mr32(Mask mask, const Vf& other) { + float temp[4]; + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + temp[i] = other[(i + 1) % 4]; + } + } + + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = temp[i]; + } + } + } + + REALLY_INLINE void mr32_z(const Vf& other) { data[2] = other.data[3]; } + + void mfir(Mask mask, s16 in) { + s32 sext = in; + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + memcpy(data + i, &sext, 4); + } + } + } + + void maxi(Mask mask, const Vf& other, float I) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = vu_max(other[i], I); + } + } + } + + void max(Mask mask, const Vf& other, float I) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = vu_max(other[i], I); + } + } + } + + void max(Mask mask, const Vf& other, const Vf& b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = vu_max(other[i], b[i]); + } + } + } + + REALLY_INLINE void max_xyzw(const Vf& a, const Vf& b) { + _mm_store_ps(data, _mm_max_ps(_mm_load_ps(a.data), _mm_load_ps(b.data))); + } + + REALLY_INLINE void max_xyzw(const Vf& a, float b) { + _mm_store_ps(data, _mm_max_ps(_mm_load_ps(a.data), _mm_set1_ps(b))); + } + + REALLY_INLINE void mini_xyzw(const Vf& a, const Vf& b) { + _mm_store_ps(data, _mm_min_ps(_mm_load_ps(a.data), _mm_load_ps(b.data))); + } + + REALLY_INLINE void mini_xyzw(const Vf& a, float b) { + _mm_store_ps(data, _mm_min_ps(_mm_load_ps(a.data), _mm_set1_ps(b))); + } + + void minii(Mask mask, const Vf& other, float I) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = vu_min(other[i], I); + } + } + } + + void mini(Mask mask, const Vf& other, float I) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = vu_min(other[i], I); + } + } + } + + void move(Mask mask, const Vf& other) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = other[i]; + } + } + } + + void mfp(Mask mask, float other) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = other; + } + } + } + + void add(Mask mask, const Vf& a, const Vf& b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = a[i] + b[i]; + } + } + } + + REALLY_INLINE void add_xyzw(const Vf& a, const Vf& b) { + _mm_store_ps(data, _mm_add_ps(_mm_load_ps(a.data), _mm_load_ps(b.data))); + } + + void add(Mask mask, const Vf& a, float b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = a[i] + b; + } + } + } + + REALLY_INLINE void mul_xyzw(const Vf& a, const Vf& b) { + _mm_store_ps(data, _mm_mul_ps(_mm_load_ps(a.data), _mm_load_ps(b.data))); + } + + REALLY_INLINE void mul_xyzw(const Vf& a, float b) { + _mm_store_ps(data, _mm_mul_ps(_mm_load_ps(a.data), _mm_set1_ps(b))); + } + + void mul(Mask mask, const Vf& a, const Vf& b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = a[i] * b[i]; + } + } + } + + void mul(Mask mask, const Vf& a, float b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = a[i] * b; + } + } + } + + void itof0(Mask mask, const Vf& a) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + s32 val; + memcpy(&val, &a.data[i], 4); + data[i] = val; + } + } + } + + void itof15(Mask mask, const Vf& a) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + s32 val; + memcpy(&val, &a.data[i], 4); + data[i] = ((float)val) * (1.f / 32768.f); + ; + } + } + } + + void ftoi4(Mask mask, const Vf& a) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + s32 val = a.data[i] * 16.f; + memcpy(&data[i], &val, 4); + } + } + } + + void ftoi0(Mask mask, const Vf& a) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + s32 val = a.data[i]; + memcpy(&data[i], &val, 4); + } + } + } +}; + +struct alignas(16) Accumulator { + float data[4]; + + void adda(Mask mask, const Vf& a, float b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = a[i] + b; + } + } + } + + void madda(Mask mask, const Vf& a, const Vf& b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] += a[i] * b[i]; + } + } + } + + void madda(Mask mask, const Vf& a, float b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] += a[i] * b; + } + } + } + + REALLY_INLINE void madda_xyzw(const Vf& _a, float _b) { + auto b = _mm_set1_ps(_b); + auto a = _mm_load_ps(_a.data); + auto acc = _mm_load_ps(data); + _mm_store_ps(data, _mm_fmadd_ps(a, b, acc)); + } + + REALLY_INLINE void madda_xyzw(const Vf& _a, const Vf& _b) { + auto b = _mm_load_ps(_b.data); + auto a = _mm_load_ps(_a.data); + auto acc = _mm_load_ps(data); + _mm_store_ps(data, _mm_fmadd_ps(a, b, acc)); + } + + void madd(Mask mask, Vf& dest, const Vf& a, const Vf& b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + dest[i] = data[i] + a[i] * b[i]; + } + } + } + + REALLY_INLINE void madd_xyzw(Vf& dest, const Vf& _a, float _b) { + auto b = _mm_set1_ps(_b); + auto a = _mm_load_ps(_a.data); + auto acc = _mm_load_ps(data); + _mm_store_ps(dest.data, _mm_fmadd_ps(a, b, acc)); + } + + REALLY_INLINE void madd_xyz(Vf& dest, const Vf& _a, float _b) { + auto b = _mm_set1_ps(_b); + auto a = _mm_load_ps(_a.data); + auto acc = _mm_load_ps(data); + auto prod = _mm_fmadd_ps(a, b, acc); + prod = _mm_blend_ps(prod, _mm_load_ps(dest.data), 0b1000); + _mm_store_ps(dest.data, prod); + } + + void madd(Mask mask, Vf& dest, const Vf& a, float b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + dest[i] = data[i] + a[i] * b; + } + } + } + + void mula(Mask mask, const Vf& a, const Vf& b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = a[i] * b[i]; + } + } + } + + void mula(Mask mask, const Vf& a, float b) { + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + data[i] = a[i] * b; + } + } + } + + REALLY_INLINE void mula_xyzw(const Vf& _a, float _b) { + auto b = _mm_set1_ps(_b); + auto a = _mm_load_ps(_a.data); + _mm_store_ps(data, _mm_mul_ps(a, b)); + } + + REALLY_INLINE void mula_xyzw(const Vf& _a, const Vf& _b) { + auto b = _mm_load_ps(_b.data); + auto a = _mm_load_ps(_a.data); + _mm_store_ps(data, _mm_mul_ps(a, b)); + } +}; + +class MercRenderer : public BucketRenderer { + public: + MercRenderer(const std::string& name, BucketId my_id); + void render(DmaFollower& dma, SharedRenderState* render_state, ScopedProfilerNode& prof) override; + void draw_debug_window() override; + + private: + void handle_setup(DmaFollower& dma, SharedRenderState* render_state, ScopedProfilerNode& prof); + void handle_merc_chain(DmaFollower& dma, + SharedRenderState* render_state, + ScopedProfilerNode& prof); + void unpack8(const VifCodeUnpack& up, const u8* data, u32 imm); + void unpack32(const VifCodeUnpack& up, const u8* data, u32 imm); + + void mscal(int enter_address, SharedRenderState* render_state, ScopedProfilerNode& prof); + + template + void mscal_impl(int enter_address, SharedRenderState* render_state, ScopedProfilerNode& prof); + + void xgkick(u16 addr, SharedRenderState* render_state, ScopedProfilerNode& prof); + + enum MercDataMemory { + LOW_MEMORY = 0, + BUFFER_BASE = 442, + // this negative offset is what broke jak graphics in Dobiestation for a long time. + BUFFER_OFFSET = -442 + }; + + struct LowMemory { + u8 tri_strip_tag[16]; + u8 ad_gif_tag[16]; + math::Vector4f hvdf_offset; + math::Vector4f perspective[4]; + math::Vector4f fog; + } m_low_memory; + static_assert(sizeof(LowMemory) == 0x80); + + struct alignas(16) BufferMemory { + u8 data[1024 * 16]; + } m_buffer; + + void sq_buffer(Mask mask, const Vf& data, u32 qw) { + // if (data.x_as_u32() == 0x80000000 && data.y_as_u32() == 0x80000000) { + // fmt::print("big store line {}: {} : {} {} {} {}\n", line_number, qw, data.x(), data.y(), + // data.z(), data.w()); + // } + // sketchy... + // qw &= 1023; + assert(qw * 16 < sizeof(m_buffer.data)); + for (int i = 0; i < 4; i++) { + if ((u64)mask & (1 << i)) { + memcpy(m_buffer.data + qw * 16 + i * 4, data.data + i, 4); + } + } + } + + void lq_buffer(Mask mask, Vf& dest, u16 addr); + + template + void lq_buffer_xyzw(Vf& dest, u16 addr); + + template + void lq_buffer_xyz(Vf& dest, u16 addr); + + template + void sq_buffer_xyzw(const Vf& src, u16 addr); + + void isw_buffer(Mask mask, u16 val, u16 addr); + void ilw_buffer(Mask mask, u16& dest, u16 addr); + + u16 xtop(); + u16 xitop(); + + DirectRenderer m_direct; + + struct { + u32 row[4] = {0, 0, 0, 0}; + bool stmod = false; + } m_vif; + + struct Stats { + int unpack_count = 0; + int unpack_bytes = 0; + int mscal_35 = 0; + int mscal_20 = 0; + int mscal_17 = 0; + int mscal_32 = 0; + bool had_data = false; + std::string str; + } m_stats; + + bool m_dbf = false; + + bool m_enable_prime_mscals = true; + bool m_enable_normal_mscals = true; + bool m_enable_send_to_direct = true; + + struct Vu { + Vf vf01, vf02, vf03, vf04, vf05, vf06, vf07, vf08, vf09, vf10, vf11, vf12, vf13, vf14, vf15, + vf16, vf17, vf18, vf19, vf20, vf21, vf22, vf23, vf24, vf25, vf26, vf27, vf28, vf29, vf30, + vf31; + const Vf vf00; + u16 vi01, vi02, vi03, vi04, vi05, vi06, vi07, vi09, vi08, vi11, vi12, vi13, vi10, vi14, vi15; + float I, P, Q; + + Accumulator acc; + const u16 vi00 = 0; + + u16 hack_old_vi15 = 0; + + Vu() : vf00(0, 0, 0, 1) {} + } vu; +}; diff --git a/game/graphics/opengl_renderer/OpenGLRenderer.cpp b/game/graphics/opengl_renderer/OpenGLRenderer.cpp index c8ab07e66e..7e52fc13b3 100644 --- a/game/graphics/opengl_renderer/OpenGLRenderer.cpp +++ b/game/graphics/opengl_renderer/OpenGLRenderer.cpp @@ -11,6 +11,7 @@ #include "game/graphics/opengl_renderer/Sprite3.h" #include "game/graphics/opengl_renderer/tfrag/TFragment.h" #include "game/graphics/opengl_renderer/tfrag/Tie3.h" +#include "game/graphics/opengl_renderer/MercRenderer.h" // for the vif callback #include "game/kernel/kmachine.h" @@ -68,44 +69,136 @@ void OpenGLRenderer::init_bucket_renderers() { tfrag3::TFragmentTreeKind::LOWRES}; std::vector dirt_tfrags = {tfrag3::TFragmentTreeKind::DIRT}; std::vector ice_tfrags = {tfrag3::TFragmentTreeKind::ICE}; - - init_bucket_renderer("bucket0", BucketId::BUCKET0); - init_bucket_renderer("sky", BucketId::SKY_DRAW); - - init_bucket_renderer("tfrag-tex-0", BucketId::TFRAG_TEX_LEVEL0); - init_bucket_renderer("tfrag-0", BucketId::TFRAG_LEVEL0, normal_tfrags, false, 0); - init_bucket_renderer("tie-0", BucketId::TIE_LEVEL0, 0); - init_bucket_renderer("tfrag-tex-1", BucketId::TFRAG_TEX_LEVEL1); - init_bucket_renderer("tfrag-1", BucketId::TFRAG_LEVEL1, normal_tfrags, false, 1); - init_bucket_renderer("tie-1", BucketId::TIE_LEVEL1, 1); - init_bucket_renderer("shrub-tex-0", BucketId::SHRUB_TEX_LEVEL0); - init_bucket_renderer("shrub-tex-1", BucketId::SHRUB_TEX_LEVEL1); - init_bucket_renderer("alpha-tex-0", BucketId::ALPHA_TEX_LEVEL0); - init_bucket_renderer("alpha-tex-1", BucketId::ALPHA_TEX_LEVEL1); auto sky_gpu_blender = std::make_shared(); auto sky_cpu_blender = std::make_shared(); + + //------------- + // PRE TEXTURE + //------------- + // 0 + // 1 + // 2 + init_bucket_renderer("sky", BucketId::SKY_DRAW); // 3 + // 4 + + //----------------------- + // LEVEL 0 tfrag texture + //----------------------- + init_bucket_renderer("tfrag-tex-0", BucketId::TFRAG_TEX_LEVEL0); // 5 + init_bucket_renderer("tfrag-0", BucketId::TFRAG_LEVEL0, normal_tfrags, false, 0); // 6 + // 7 + // 8 + init_bucket_renderer("tie-0", BucketId::TIE_LEVEL0, 0); // 9 + init_bucket_renderer("merc-tf-0", BucketId::MERC_TFRAG_TEX_LEVEL0); // 10 + // 11 + + //----------------------- + // LEVEL 1 tfrag texture + //----------------------- + init_bucket_renderer("tfrag-tex-1", BucketId::TFRAG_TEX_LEVEL1); // 12 + init_bucket_renderer("tfrag-1", BucketId::TFRAG_LEVEL1, normal_tfrags, false, 1); + // 14 + // 15 + init_bucket_renderer("tie-1", BucketId::TIE_LEVEL1, 1); + init_bucket_renderer("merc-tf-1", BucketId::MERC_TFRAG_TEX_LEVEL1); // 17 + // 18?? + + //----------------------- + // LEVEL 0 shrub texture + //----------------------- + init_bucket_renderer("shrub-tex-0", BucketId::SHRUB_TEX_LEVEL0); // 19 + // 20 + // 21 + // 22 + // 23 + // 24 + + //----------------------- + // LEVEL 1 shrub texture + //----------------------- + init_bucket_renderer("shrub-tex-1", BucketId::SHRUB_TEX_LEVEL1); // 25 + // 26 + // 27 + // 28 + // 29 + // 30 + + //----------------------- + // LEVEL 0 alpha texture + //----------------------- + init_bucket_renderer("alpha-tex-0", BucketId::ALPHA_TEX_LEVEL0); // 31 init_bucket_renderer("sky-blend-and-tfrag-trans-0", BucketId::TFRAG_TRANS0_AND_SKY_BLEND_LEVEL0, 0, - sky_gpu_blender, sky_cpu_blender); + sky_gpu_blender, sky_cpu_blender); // 32 + // 33 init_bucket_renderer("tfrag-dirt-0", BucketId::TFRAG_DIRT_LEVEL0, dirt_tfrags, false, - 0); + 0); // 34 + // 35 init_bucket_renderer("tfrag-ice-0", BucketId::TFRAG_ICE_LEVEL0, ice_tfrags, false, 0); + // 37 + + //----------------------- + // LEVEL 1 alpha texture + //----------------------- + init_bucket_renderer("alpha-tex-1", BucketId::ALPHA_TEX_LEVEL1); // 38 init_bucket_renderer("sky-blend-and-tfrag-trans-1", BucketId::TFRAG_TRANS1_AND_SKY_BLEND_LEVEL1, 1, - sky_gpu_blender, sky_cpu_blender); + sky_gpu_blender, sky_cpu_blender); // 39 + // 40 init_bucket_renderer("tfrag-dirt-1", BucketId::TFRAG_DIRT_LEVEL1, dirt_tfrags, false, - 1); + 1); // 41 + // 42 init_bucket_renderer("tfrag-ice-1", BucketId::TFRAG_ICE_LEVEL1, ice_tfrags, false, 1); - init_bucket_renderer("pris-tex-0", BucketId::PRIS_TEX_LEVEL0); - init_bucket_renderer("pris-tex-1", BucketId::PRIS_TEX_LEVEL1); - init_bucket_renderer("water-tex-0", BucketId::WATER_TEX_LEVEL0); - init_bucket_renderer("water-tex-1", BucketId::WATER_TEX_LEVEL1); - init_bucket_renderer("pre-sprite-tex", BucketId::PRE_SPRITE_TEX); + // 44 + init_bucket_renderer("merc-after-alpha", BucketId::MERC_AFTER_ALPHA); + // 46? + // 47? + + //----------------------- + // LEVEL 0 pris texture + //----------------------- + init_bucket_renderer("pris-tex-0", BucketId::PRIS_TEX_LEVEL0); // 48 + init_bucket_renderer("merc-pris-0", BucketId::MERC_PRIS_LEVEL0); // 49 + // 50 + + //----------------------- + // LEVEL 1 pris texture + //----------------------- + init_bucket_renderer("pris-tex-1", BucketId::PRIS_TEX_LEVEL1); // 51 + init_bucket_renderer("merc-pris-1", BucketId::MERC_PRIS_LEVEL1); // 52 + // 53 + + // 54? + init_bucket_renderer("merc-after-pris", BucketId::MERC_AFTER_PRIS); // 55 + // 56? + + //----------------------- + // LEVEL 0 water texture + //----------------------- + init_bucket_renderer("water-tex-0", BucketId::WATER_TEX_LEVEL0); // 57 + init_bucket_renderer("merc-water-0", BucketId::MERC_WATER_LEVEL0); // 58 + // 59 + + //----------------------- + // LEVEL 1 water texture + //----------------------- + init_bucket_renderer("water-tex-1", BucketId::WATER_TEX_LEVEL1); // 60 + init_bucket_renderer("merc-water-1", BucketId::MERC_WATER_LEVEL1); // 61 + // 62 + + // 63? + // 64? + + //----------------------- + // COMMON texture + //----------------------- + init_bucket_renderer("pre-sprite-tex", BucketId::PRE_SPRITE_TEX); // 65 + std::vector> sprite_renderers; sprite_renderers.push_back(std::make_unique("sprite-renderer", BucketId::SPRITE)); sprite_renderers.push_back(std::make_unique("sprite-3", BucketId::SPRITE)); + init_bucket_renderer("sprite", BucketId::SPRITE, std::move(sprite_renderers)); // 66 - init_bucket_renderer("sprite", BucketId::SPRITE, std::move(sprite_renderers)); init_bucket_renderer("debug-draw-0", BucketId::DEBUG_DRAW_0, 0x20000, DirectRenderer::Mode::NORMAL); init_bucket_renderer("debug-draw-1", BucketId::DEBUG_DRAW_1, 0x8000, @@ -184,6 +277,7 @@ void OpenGLRenderer::draw_renderer_selection_window() { ImGui::Checkbox("Sky CPU", &m_render_state.use_sky_cpu); ImGui::Checkbox("Occlusion Cull", &m_render_state.use_occlusion_culling); + ImGui::Checkbox("Render Debug (slower)", &m_render_state.render_debug); for (size_t i = 0; i < m_bucket_renderers.size(); i++) { auto renderer = m_bucket_renderers[i].get(); diff --git a/game/graphics/opengl_renderer/shaders/direct_basic.vert b/game/graphics/opengl_renderer/shaders/direct_basic.vert index f2b1d11b3c..f54b0f8e1b 100644 --- a/game/graphics/opengl_renderer/shaders/direct_basic.vert +++ b/game/graphics/opengl_renderer/shaders/direct_basic.vert @@ -12,5 +12,5 @@ void main() { gl_Position = vec4((position_in.x - 0.5) * 16., -(position_in.y - 0.5) * 32, position_in.z * 2 - 1., 1.0); // scissoring area adjust gl_Position.y *= 512.0/448.0; - fragment_color = vec4(rgba_in.x, rgba_in.y, rgba_in.z, rgba_in.w + 0.5); + fragment_color = vec4(rgba_in.x, rgba_in.y, rgba_in.z, rgba_in.w * 2.); } diff --git a/game/graphics/opengl_renderer/shaders/direct_basic_textured.frag b/game/graphics/opengl_renderer/shaders/direct_basic_textured.frag index 39757c51b6..348bd277d5 100644 --- a/game/graphics/opengl_renderer/shaders/direct_basic_textured.frag +++ b/game/graphics/opengl_renderer/shaders/direct_basic_textured.frag @@ -41,7 +41,7 @@ void main() { T0.w = 1.0; } color = fragment_color * T0 * 2.0; - if (color.a <= alpha_reject) { + if (color.a < alpha_reject) { discard; } } diff --git a/game/graphics/opengl_renderer/tfrag/tfrag_common.cpp b/game/graphics/opengl_renderer/tfrag/tfrag_common.cpp index b6d666fb38..fe82b62153 100644 --- a/game/graphics/opengl_renderer/tfrag/tfrag_common.cpp +++ b/game/graphics/opengl_renderer/tfrag/tfrag_common.cpp @@ -114,7 +114,7 @@ DoubleDraw setup_opengl_from_draw_mode(DrawMode mode, u32 tex_unit, bool mipmap) } } - if (mode.get_depth_write_enable()) { + if (mode.get_depth_write_enable() && !alpha_hack_to_disable_z_write) { glDepthMask(GL_TRUE); } else { glDepthMask(GL_FALSE); diff --git a/game/mips2c/functions/bones.cpp b/game/mips2c/functions/bones.cpp index 6d3dcde9be..3a2a91b70c 100644 --- a/game/mips2c/functions/bones.cpp +++ b/game/mips2c/functions/bones.cpp @@ -689,3 +689,590 @@ void link() { } // namespace bones_mtx_calc } // namespace Mips2C +//--------------------------MIPS2C--------------------- +#include "game/mips2c/mips2c_private.h" +#include "game/kernel/kscheme.h" +namespace Mips2C { +namespace draw_bones_merc { +struct Cache { + void* merc_bucket_info; // *merc-bucket-info* + void* merc_global_stats; // *merc-global-stats* + void* fake_scratchpad_data; +} cache; + +u64 execute(void* ctxt) { + auto* c = (ExecutionContext*)ctxt; + bool bc = false; + c->daddiu(sp, sp, -128); // daddiu sp, sp, -128 + c->sd(ra, 0, sp); // sd ra, 0(sp) + c->sq(s0, 16, sp); // sq s0, 16(sp) + c->sq(s1, 32, sp); // sq s1, 32(sp) + c->sq(s2, 48, sp); // sq s2, 48(sp) + c->sq(s3, 64, sp); // sq s3, 64(sp) + c->sq(s4, 80, sp); // sq s4, 80(sp) + c->sq(s5, 96, sp); // sq s5, 96(sp) + c->sq(gp, 112, sp); // sq gp, 112(sp) + c->mov64(t8, a3); // or t8, a3, r0 + c->mov64(v1, t0); // or v1, t0, r0 + c->lui(t0, 4096); // lui t0, 4096 + c->lui(t1, 18304); // lui t1, 18304 + c->daddiu(t0, t0, 1); // daddiu t0, t0, 1 + c->dsll32(t1, t1, 0); // dsll32 t1, t1, 0 + c->lui(a3, 12288); // lui a3, 12288 + c->lui(t7, 19201); // lui t7, 19201 + c->pcpyld(t0, a3, t0); // pcpyld t0, a3, t0 + c->lbu(a3, 58, a0); // lbu a3, 58(a0) + c->pcpyld(t1, t7, t1); // pcpyld t1, t7, t1 + c->lui(t2, 28160); // lui t2, 28160 + c->addiu(t7, r0, 8); // addiu t7, r0, 8 + c->multu3(a3, a3, t7); // multu3 a3, a3, t7 + c->lui(t3, 1280); // lui t3, 1280 + c->lui(t4, 27648); // lui t4, 27648 + c->dsll32(t2, t2, 0); // dsll32 t2, t2, 0 + c->dsll32(t4, t4, 0); // dsll32 t4, t4, 0 + c->daddu(t4, t4, t3); // daddu t4, t4, t3 + c->daddu(t3, t2, t3); // daddu t3, t2, t3 + c->daddiu(t3, t3, 1); // daddiu t3, t3, 1 + c->daddu(a0, a3, a0); // daddu a0, a3, a0 + c->pcpyld(t2, t2, r0); // pcpyld t2, t2, r0 + c->lw(t7, 24, a0); // lw t7, 24(a0) + c->pcpyld(t3, t3, r0); // pcpyld t3, t3, r0 + c->pcpyld(t4, t4, r0); // pcpyld t4, t4, r0 + c->mov64(a0, a2); // or a0, a2, r0 + c->lui(t5, 12288); // lui t5, 12288 + c->lui(t6, 4096); // lui t6, 4096 + c->daddiu(t5, t5, 7); // daddiu t5, t5, 7 + c->lui(t9, 5120); // lui t9, 5120 + c->lui(a3, 27655); // lui a3, 27655 + c->daddu(t8, t9, t8); // daddu t8, t9, t8 + c->dsll32(a3, a3, 0); // dsll32 a3, a3, 0 + c->dsll32(t9, t8, 0); // dsll32 t9, t8, 0 + c->pcpyld(t5, a3, t5); // pcpyld t5, a3, t5 + c->lwu(t8, 52, t7); // lwu t8, 52(t7) + c->pcpyld(t6, t9, t6); // pcpyld t6, t9, t6 + c->daddiu(t9, t7, 108); // daddiu t9, t7, 108 + c->load_symbol(a3, cache.merc_bucket_info); // lw a3, *merc-bucket-info*(s7) + c->daddiu(ra, a3, 124); // daddiu ra, a3, 124 + + block_1: + c->lbu(gp, 4, ra); // lbu gp, 4(ra) + c->load_symbol(a3, cache.merc_global_stats); // lw a3, *merc-global-stats*(s7) + c->daddu(a3, r0, a3); // daddu a3, r0, a3 + bc = c->sgpr64(gp) != 0; // bne gp, r0, L77 + c->lhu(s4, 2, a3); // lhu s4, 2(a3) + if (bc) {goto block_11;} // branch non-likely + + c->lhu(s3, 18, t9); // lhu s3, 18(t9) + c->lwu(gp, 4, a3); // lwu gp, 4(a3) + c->lhu(s5, 22, t9); // lhu s5, 22(t9) + c->daddu(s4, s4, s3); // daddu s4, s4, s3 + c->lwu(s3, 8, a3); // lwu s3, 8(a3) + c->lhu(s2, 24, t9); // lhu s2, 24(t9) + c->daddu(gp, gp, s5); // daddu gp, gp, s5 + c->sh(s4, 2, a3); // sh s4, 2(a3) + c->sw(gp, 4, a3); // sw gp, 4(a3) + c->daddu(s5, s3, s2); // daddu s5, s3, s2 + c->lwu(t2, 0, t9); // lwu t2, 0(t9) + c->lwu(gp, 4, t9); // lwu gp, 4(t9) + c->lui(s4, 12288); // lui s4, 12288 + c->dsll32(t2, t2, 0); // dsll32 t2, t2, 0 + c->sw(s5, 8, a3); // sw s5, 8(a3) + c->or_(t2, t2, s4); // or t2, t2, s4 + c->addiu(s5, r0, 0); // addiu s5, r0, 0 + c->lhu(s4, 18, t9); // lhu s4, 18(t9) + + block_3: + c->lbu(s0, 0, gp); // lbu s0, 0(gp) + // nop // sll r0, r0, 0 + c->lbu(s2, 1, gp); // lbu s2, 1(gp) + c->xori(s1, r0, 49292); // xori s1, r0, 49292 + c->lbu(s3, 2, gp); // lbu s3, 2(gp) + c->daddiu(v0, s0, 3); // daddiu v0, s0, 3 + c->lw(a3, 44, t7); // lw a3, 44(t7) + c->srl(v0, v0, 2); // srl v0, v0, 2 + c->sq(t0, 0, a2); // sq t0, 0(a2) + c->xor_(t2, t2, v0); // xor t2, t2, v0 + c->sq(t2, 32, a2); // sq t2, 32(a2) + c->xor_(t2, t2, v0); // xor t2, t2, v0 + c->sh(s1, 44, a2); // sh s1, 44(a2) + c->daddu(s1, s1, s0); // daddu s1, s1, s0 + c->sb(s0, 46, a2); // sb s0, 46(a2) + c->dsll32(s0, v0, 4); // dsll32 s0, v0, 4 + c->daddu(t3, t2, s0); // daddu t3, t2, s0 + c->daddiu(s0, s2, 3); // daddiu s0, s2, 3 + c->sw(a3, 12, a2); // sw a3, 12(a2) + c->srl(s0, s0, 2); // srl s0, s0, 2 + c->sq(t1, 16, a2); // sq t1, 16(a2) + c->xor_(t3, t3, s0); // xor t3, t3, s0 + c->sq(t3, 48, a2); // sq t3, 48(a2) + c->xor_(t3, t3, s0); // xor t3, t3, s0 + c->sh(s1, 60, a2); // sh s1, 60(a2) + c->daddu(s1, s1, s2); // daddu s1, s1, s2 + c->sb(s2, 62, a2); // sb s2, 62(a2) + c->dsll32(s2, s0, 4); // dsll32 s2, s0, 4 + c->sw(a3, 16, a2); // sw a3, 16(a2) + c->daddu(t4, t3, s2); // daddu t4, t3, s2 + c->xor_(t4, t4, s3); // xor t4, t4, s3 + c->xori(a3, s1, 16384); // xori a3, s1, 16384 + c->sq(t4, 64, a2); // sq t4, 64(a2) + c->xor_(t4, t4, s3); // xor t4, t4, s3 + c->sb(s3, 78, a2); // sb s3, 78(a2) + c->dsll32(s3, s3, 4); // dsll32 s3, s3, 4 + c->sh(a3, 76, a2); // sh a3, 76(a2) + c->daddu(t2, t4, s3); // daddu t2, t4, s3 + c->lbu(s3, 3, gp); // lbu s3, 3(gp) + c->daddiu(gp, gp, 4); // daddiu gp, gp, 4 + bc = c->sgpr64(s5) != 0; // bne s5, r0, L73 + c->daddiu(a2, a2, 80); // daddiu a2, a2, 80 + if (bc) {goto block_5;} // branch non-likely + + c->sd(t6, 0, a2); // sd t6, 0(a2) + c->addiu(s2, r0, 8); // addiu s2, r0, 8 + c->sd(t6, 8, a2); // sd t6, 8(a2) + c->lui(a3, 27656); // lui a3, 27656 + c->sb(s2, 0, a2); // sb s2, 0(a2) + c->daddiu(a3, a3, 132); // daddiu a3, a3, 132 + c->load_symbol(s2, cache.merc_bucket_info); // lw s2, *merc-bucket-info*(s7) + c->daddu(s2, r0, s2); // daddu s2, r0, s2 + c->sw(a3, 12, a2); // sw a3, 12(a2) + c->lq(a3, 0, s2); // lq a3, 0(s2) + c->lq(s1, 16, s2); // lq s1, 16(s2) + c->lq(s0, 32, s2); // lq s0, 32(s2) + c->lq(v0, 48, s2); // lq v0, 48(s2) + c->sq(a3, 16, a2); // sq a3, 16(a2) + c->sq(s1, 32, a2); // sq s1, 32(a2) + c->sq(s0, 48, a2); // sq s0, 48(a2) + c->sq(v0, 64, a2); // sq v0, 64(a2) + c->lq(a3, 64, s2); // lq a3, 64(s2) + c->lq(s1, 80, s2); // lq s1, 80(s2) + c->lq(s0, 96, s2); // lq s0, 96(s2) + c->lui(v0, 16261); // lui v0, 16261 + c->lq(s2, 28, t7); // lq s2, 28(t7) + c->daddiu(v0, v0, 619); // daddiu v0, v0, 619 + c->sq(a3, 80, a2); // sq a3, 80(a2) + c->lbu(a3, 5, ra); // lbu a3, 5(ra) + c->sq(s1, 96, a2); // sq s1, 96(a2) + c->sq(s0, 112, a2); // sq s0, 112(a2) + c->dsubu(a3, v0, a3); // dsubu a3, v0, a3 + c->sq(s2, 128, a2); // sq s2, 128(a2) + c->sw(a3, 28, a2); // sw a3, 28(a2) + c->daddiu(a2, a2, 144); // daddiu a2, a2, 144 + + block_5: + bc = c->sgpr64(s3) == 0; // beq s3, r0, L75 + c->addiu(s2, r0, 128); // addiu s2, r0, 128 + if (bc) {goto block_8;} // branch non-likely + + c->lbu(a3, 0, gp); // lbu a3, 0(gp) + + block_7: + c->multu3(s1, a3, s2); // multu3 s1, a3, s2 + c->sq(t5, 0, a2); // sq t5, 0(a2) + c->lbu(s0, 1, gp); // lbu s0, 1(gp) + c->daddiu(gp, gp, 2); // daddiu gp, gp, 2 + c->lbu(a3, 0, gp); // lbu a3, 0(gp) + c->daddiu(s3, s3, -1); // daddiu s3, s3, -1 + c->sb(s0, 12, a2); // sb s0, 12(a2) + c->daddiu(a2, a2, 16); // daddiu a2, a2, 16 + c->daddu(s1, s1, a1); // daddu s1, s1, a1 + // nop // sll r0, r0, 0 + bc = c->sgpr64(s3) != 0; // bne s3, r0, L74 + c->sw(s1, -12, a2); // sw s1, -12(a2) + if (bc) {goto block_7;} // branch non-likely + + + block_8: + c->sq(t6, 0, a2); // sq t6, 0(a2) + c->daddiu(a2, a2, 16); // daddiu a2, a2, 16 + bc = c->sgpr64(s5) != 0; // bne s5, r0, L76 + c->daddiu(s5, s5, 1); // daddiu s5, s5, 1 + if (bc) {goto block_10;} // branch non-likely + + c->mov64(a3, v1); // or a3, v1, r0 + c->sb(a3, -4, a2); // sb a3, -4(a2) + + block_10: + bc = c->sgpr64(s5) != c->sgpr64(s4); // bne s5, s4, L72 + // nop // sll r0, r0, 0 + if (bc) {goto block_3;} // branch non-likely + + + block_11: + c->daddiu(t9, t9, 32); // daddiu t9, t9, 32 + c->daddiu(ra, ra, 8); // daddiu ra, ra, 8 + c->daddiu(t8, t8, -1); // daddiu t8, t8, -1 + bc = c->sgpr64(t8) != 0; // bne t8, r0, L71 + // c->lui(a3, 28672); // lui a3, 28672 + get_fake_spad_addr(a3, cache.fake_scratchpad_data, 0, c); + if (bc) {goto block_1;} // branch non-likely + + c->lw(v1, 220, a3); // lw v1, 220(a3) + bc = c->sgpr64(v1) != 0; // bne v1, r0, L78 + // nop // sll r0, r0, 0 + if (bc) {goto block_15;} // branch non-likely + + bc = c->sgpr64(a2) == c->sgpr64(a0); // beq a2, a0, L78 + // nop // sll r0, r0, 0 + if (bc) {goto block_15;} // branch non-likely + + c->sw(a0, 220, a3); // sw a0, 220(a3) + + block_15: + c->mov64(v0, a2); // or v0, a2, r0 + c->ld(ra, 0, sp); // ld ra, 0(sp) + c->lq(gp, 112, sp); // lq gp, 112(sp) + c->lq(s5, 96, sp); // lq s5, 96(sp) + c->lq(s4, 80, sp); // lq s4, 80(sp) + c->lq(s3, 64, sp); // lq s3, 64(sp) + c->lq(s2, 48, sp); // lq s2, 48(sp) + c->lq(s1, 32, sp); // lq s1, 32(sp) + c->lq(s0, 16, sp); // lq s0, 16(sp) + //jr ra // jr ra + c->daddiu(sp, sp, 128); // daddiu sp, sp, 128 + goto end_of_function; // return + + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + end_of_function: + return c->gprs[v0].du64[0]; +} + +void link() { + cache.merc_bucket_info = intern_from_c("*merc-bucket-info*").c(); + cache.merc_global_stats = intern_from_c("*merc-global-stats*").c(); + cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c(); + gLinkedFunctionTable.reg("draw-bones-merc", execute, 512); +} + +} // namespace draw_bones_merc +} // namespace Mips2C + +//--------------------------MIPS2C--------------------- +#include "game/mips2c/mips2c_private.h" +#include "game/kernel/kscheme.h" +namespace Mips2C { +namespace draw_bones_check_longest_edge_asm { +struct Cache { + void* math_camera; // *math-camera* + void* fake_scratchpad_data; +} cache; + +u64 execute(void* ctxt) { + auto* c = (ExecutionContext*)ctxt; + bool bc = false; + bool cop1_bc = false; + float acc; + c->daddiu(sp, sp, -16); // daddiu sp, sp, -16 + c->sd(fp, 8, sp); // sd fp, 8(sp) + c->mov64(fp, t9); // or fp, t9, r0 + // c->lui(at, 28672); // lui at, 28672 + get_fake_spad_addr(at, cache.fake_scratchpad_data, 0, c); + c->mov64(v0, s7); // or v0, s7, r0 + c->load_symbol(v1, cache.math_camera); // lw v1, *math-camera*(s7) + c->lwc1(f0, 64, a0); // lwc1 f0, 64(a0) + c->lwc1(f7, 176, at); // lwc1 f7, 176(at) + c->lwc1(f3, 180, at); // lwc1 f3, 180(at) + c->lwc1(f6, 184, at); // lwc1 f6, 184(at) + c->lwc1(f4, 136, a0); // lwc1 f4, 136(a0) + c->lwc1(f12, 0, v1); // lwc1 f12, 0(v1) + c->lwc1(f11, 64, v1); // lwc1 f11, 64(v1) + c->mtc1(f1, a1); // mtc1 f1, a1 + c->mtc1(f9, r0); // mtc1 f9, r0 + c->mtc1(f10, r0); // mtc1 f10, r0 + c->mtc1(f2, r0); // mtc1 f2, r0 + c->mtc1(f2, r0); // mtc1 f2, r0 + c->mtc1(f5, r0); // mtc1 f5, r0 + c->mtc1(f8, r0); // mtc1 f8, r0 + c->lw_float_constant(a0, 0x3f800000); // lw a0, L168(fp) 1.0 + c->mtc1(f5, a0); // mtc1 f5, a0 + cop1_bc = c->fprs[f1] < c->fprs[f11]; // c.lt.s f1, f11 + bc = cop1_bc; // bc1t L69 + // nop // sll r0, r0, 0 + if (bc) {goto block_37;} // branch non-likely + + c->lwc1(f11, 12, v1); // lwc1 f11, 12(v1) + c->lwc1(f13, 16, v1); // lwc1 f13, 16(v1) + c->muls(f11, f11, f12); // mul.s f11, f11, f12 + c->muls(f13, f13, f12); // mul.s f13, f13, f12 + c->subs(f14, f6, f4); // sub.s f14, f6, f4 + cop1_bc = c->fprs[f12] < c->fprs[f14]; // c.lt.s f12, f14 + bc = !cop1_bc; // bc1f L53 + c->lwc1(f12, 60, v1); // lwc1 f12, 60(v1) + if (bc) {goto block_3;} // branch non-likely + + c->muls(f12, f14, f12); // mul.s f12, f14, f12 + cop1_bc = c->fprs[f0] < c->fprs[f12]; // c.lt.s f0, f12 + bc = cop1_bc; // bc1t L68 + // nop // sll r0, r0, 0 + if (bc) { +// fmt::print("pass 1 due to {} {}\n", c->fprs[f0], c->fprs[f12]); +goto block_36;} // branch non-likely + + + block_3: + c->subs(f14, f3, f4); // sub.s f14, f3, f4 + cop1_bc = c->fprs[f13] < c->fprs[f14]; // c.lt.s f13, f14 + bc = !cop1_bc; // bc1f L54 + c->lwc1(f12, 56, v1); // lwc1 f12, 56(v1) + if (bc) {goto block_5;} // branch non-likely + + //beq r0, r0, L55 // beq r0, r0, L55 + c->muls(f10, f14, f12); // mul.s f10, f14, f12 + goto block_7; // branch always + + + block_5: + c->adds(f14, f3, f4); // add.s f14, f3, f4 + c->negs(f13, f13); // neg.s f13, f13 + cop1_bc = c->fprs[f14] < c->fprs[f13]; // c.lt.s f14, f13 + bc = !cop1_bc; // bc1f L55 + c->negs(f13, f14); // neg.s f13, f14 + if (bc) {goto block_7;} // branch non-likely + + c->muls(f10, f13, f12); // mul.s f10, f13, f12 + + block_7: + cop1_bc = c->fprs[f0] < c->fprs[f10]; // c.lt.s f0, f10 + bc = cop1_bc; // bc1t L68 + // nop // sll r0, r0, 0 + if (bc) { +// fmt::print("pass 2 due to {} {}\n", c->fprs[f0], c->fprs[f10]); +goto block_36;} // branch non-likely + + c->subs(f12, f7, f4); // sub.s f12, f7, f4 + cop1_bc = c->fprs[f11] < c->fprs[f12]; // c.lt.s f11, f12 + bc = !cop1_bc; // bc1f L56 + c->lwc1(f10, 52, v1); // lwc1 f10, 52(v1) + if (bc) {goto block_10;} // branch non-likely + + //beq r0, r0, L57 // beq r0, r0, L57 + c->muls(f9, f12, f10); // mul.s f9, f12, f10 + goto block_12; // branch always + + + block_10: + c->adds(f12, f7, f4); // add.s f12, f7, f4 + c->negs(f11, f11); // neg.s f11, f11 + cop1_bc = c->fprs[f12] < c->fprs[f11]; // c.lt.s f12, f11 + bc = !cop1_bc; // bc1f L57 + c->negs(f11, f12); // neg.s f11, f12 + if (bc) {goto block_12;} // branch non-likely + + c->muls(f9, f11, f10); // mul.s f9, f11, f10 + + block_12: + cop1_bc = c->fprs[f0] < c->fprs[f9]; // c.lt.s f0, f9 + bc = cop1_bc; // bc1t L68 + // nop // sll r0, r0, 0 + if (bc) { +// fmt::print("pass 3 due to {} {}\n", c->fprs[f0], c->fprs[f9]); +goto block_36;} // branch non-likely + + + c->abss(f14, f7);// Unknown instr: abs.s f14, f7 + c->movs(f12, f6); // mov.s f12, f6 + acc = c->fprs[f14] * c->fprs[f14]; // Unknown instr: mula.s f14, f14 + c->fprs[f15] = acc + c->fprs[f12] * c->fprs[f12]; // Unknown instr: madd.s f15, f12, f12 + c->lwc1(f9, 76, v1); // lwc1 f9, 76(v1) + c->lwc1(f13, 80, v1); // lwc1 f13, 80(v1) + c->lwc1(f10, 84, v1); // lwc1 f10, 84(v1) + c->lwc1(f11, 88, v1); // lwc1 f11, 88(v1) + c->fprs[f16] = c->fprs[f5] / (std::sqrt(std::abs(c->fprs[f15]))); // Unknown instr: rsqrt.s f16, f5, f15 + c->muls(f15, f14, f16); // mul.s f15, f14, f16 + c->muls(f16, f12, f16); // mul.s f16, f12, f16 + acc = c->fprs[f9] * c->fprs[f16]; // Unknown instr: mula.s f9, f16 + c->fprs[f12] = acc - c->fprs[f13] * c->fprs[f15]; // Unknown instr: msub.s f12, f13, f15 + acc = c->fprs[f10] * c->fprs[f16]; // Unknown instr: mula.s f10, f16 + c->fprs[f14] = acc - c->fprs[f11] * c->fprs[f15];// Unknown instr: msub.s f14, f11, f15 + acc = c->fprs[f9] * c->fprs[f15];// Unknown instr: mula.s f9, f15 + c->fprs[f9] = acc + c->fprs[f13] * c->fprs[f16];// Unknown instr: madd.s f9, f13, f16 + acc = c->fprs[f10] * c->fprs[f15];// Unknown instr: mula.s f10, f15 + c->fprs[f10] = acc + c->fprs[f11] * c->fprs[f16];// Unknown instr: madd.s f10, f11, f16 + cop1_bc = c->fprs[f8] < c->fprs[f12]; // c.lt.s f8, f12 + bc = cop1_bc; // bc1t L58 + // nop // sll r0, r0, 0 + if (bc) {goto block_17;} // branch non-likely + + cop1_bc = c->fprs[f8] < c->fprs[f14]; // c.lt.s f8, f14 + bc = cop1_bc; // bc1t L59 + // nop // sll r0, r0, 0 + if (bc) {goto block_18;} // branch non-likely + + cop1_bc = c->fprs[f8] < c->fprs[f9]; // c.lt.s f8, f9 + bc = cop1_bc; // bc1t L60 + // nop // sll r0, r0, 0 + if (bc) {goto block_19;} // branch non-likely + + //beq r0, r0, L62 // beq r0, r0, L62 + // nop // sll r0, r0, 0 + goto block_23; // branch always + + + block_17: + //beq r0, r0, L62 // beq r0, r0, L62 + c->divs(f2, f1, f10); // div.s f2, f1, f10 + goto block_23; // branch always + + + block_18: + c->negs(f2, f12); // neg.s f2, f12 + c->divs(f2, f2, f9); // div.s f2, f2, f9 + c->divs(f7, f14, f10); // div.s f7, f14, f10 + c->adds(f2, f7, f2); // add.s f2, f7, f2 + //beq r0, r0, L62 // beq r0, r0, L62 + c->muls(f2, f2, f1); // mul.s f2, f2, f1 + goto block_23; // branch always + + + block_19: + c->subs(f8, f7, f4); // sub.s f8, f7, f4 + c->adds(f10, f7, f4); // add.s f10, f7, f4 + c->negs(f11, f7); // neg.s f11, f7 + cop1_bc = c->fprs[f7] < c->fprs[f8]; // c.lt.s f7, f8 + bc = cop1_bc; // bc1t L61 + // nop // sll r0, r0, 0 + if (bc) {goto block_22;} // branch non-likely + + cop1_bc = c->fprs[f10] < c->fprs[f11]; // c.lt.s f10, f11 + bc = cop1_bc; // bc1t L61 + // nop // sll r0, r0, 0 + if (bc) {goto block_22;} // branch non-likely + + //beq r0, r0, L62 // beq r0, r0, L62 + // nop // sll r0, r0, 0 + goto block_23; // branch always + + + block_22: + c->negs(f2, f12); // neg.s f2, f12 + c->muls(f2, f1, f2); // mul.s f2, f1, f2 + c->divs(f2, f2, f9); // div.s f2, f2, f9 + + block_23: + cop1_bc = c->fprs[f0] < c->fprs[f2]; // c.lt.s f0, f2 + bc = cop1_bc; // bc1t L68 + // nop // sll r0, r0, 0 + if (bc) { +// fmt::print("pass 4 due to {} {}\n", c->fprs[f0], c->fprs[f2]); +goto block_36;} // branch non-likely + + c->abss(f10, f3);// Unknown instr: abs.s f10, f3 + c->movs(f12, f6); // mov.s f12, f6 + acc = c->fprs[f10] * c->fprs[f10];// Unknown instr: mula.s f10, f10 + c->fprs[f9] = acc + c->fprs[f12] * c->fprs[f12];// Unknown instr: madd.s f9, f12, f12 + c->lwc1(f7, 96, v1); // lwc1 f7, 96(v1) + c->lwc1(f8, 100, v1); // lwc1 f8, 100(v1) + c->lwc1(f6, 104, v1); // lwc1 f6, 104(v1) + c->fprs[f5] = c->fprs[f5] / std::sqrt(std::abs(c->fprs[f9])); // Unknown instr: rsqrt.s f5, f5, f9 + c->lwc1(f11, 108, v1); // lwc1 f11, 108(v1) + c->mtc1(f9, r0); // mtc1 f9, r0 + c->muls(f13, f10, f5); // mul.s f13, f10, f5 + c->muls(f14, f12, f5); // mul.s f14, f12, f5 + acc = c->fprs[f7] * c->fprs[f14];// Unknown instr: mula.s f7, f14 + c->fprs[f10] = acc - c->fprs[f8] * c->fprs[f13];// Unknown instr: msub.s f10, f8, f13 + acc = c->fprs[f6] * c->fprs[f14];// Unknown instr: mula.s f6, f14 + c->fprs[f12] = acc - c->fprs[f11] * c->fprs[f13];// Unknown instr: msub.s f12, f11, f13 + acc = c->fprs[f7] * c->fprs[f13];// Unknown instr: mula.s f7, f13 + c->fprs[f5] = acc + c->fprs[f8] * c->fprs[f14];// Unknown instr: madd.s f5, f8, f14 + acc = c->fprs[f6] * c->fprs[f13];// Unknown instr: mula.s f6, f13 + c->fprs[f6] = acc + c->fprs[f11] * c->fprs[f14];// Unknown instr: madd.s f6, f11, f14 + cop1_bc = c->fprs[f9] < c->fprs[f10]; // c.lt.s f9, f10 + bc = cop1_bc; // bc1t L63 + // nop // sll r0, r0, 0 + if (bc) {goto block_28;} // branch non-likely + + cop1_bc = c->fprs[f9] < c->fprs[f12]; // c.lt.s f9, f12 + bc = cop1_bc; // bc1t L64 + // nop // sll r0, r0, 0 + if (bc) {goto block_29;} // branch non-likely + + cop1_bc = c->fprs[f9] < c->fprs[f5]; // c.lt.s f9, f5 + bc = cop1_bc; // bc1t L65 + // nop // sll r0, r0, 0 + if (bc) {goto block_30;} // branch non-likely + + //beq r0, r0, L67 // beq r0, r0, L67 + // nop // sll r0, r0, 0 + goto block_34; // branch always + + + block_28: + //beq r0, r0, L67 // beq r0, r0, L67 + c->divs(f1, f1, f6); // div.s f1, f1, f6 + goto block_34; // branch always + + + block_29: + c->negs(f3, f10); // neg.s f3, f10 + c->divs(f3, f3, f5); // div.s f3, f3, f5 + c->divs(f4, f12, f6); // div.s f4, f12, f6 + c->adds(f3, f4, f3); // add.s f3, f4, f3 + //beq r0, r0, L67 // beq r0, r0, L67 + c->muls(f1, f3, f1); // mul.s f1, f3, f1 + goto block_34; // branch always + + + block_30: + c->subs(f6, f3, f4); // sub.s f6, f3, f4 + c->adds(f4, f3, f4); // add.s f4, f3, f4 + c->negs(f7, f3); // neg.s f7, f3 + cop1_bc = c->fprs[f3] < c->fprs[f6]; // c.lt.s f3, f6 + bc = cop1_bc; // bc1t L66 + // nop // sll r0, r0, 0 + if (bc) {goto block_33;} // branch non-likely + + cop1_bc = c->fprs[f4] < c->fprs[f7]; // c.lt.s f4, f7 + bc = cop1_bc; // bc1t L66 + // nop // sll r0, r0, 0 + if (bc) {goto block_33;} // branch non-likely + + //beq r0, r0, L67 // beq r0, r0, L67 + // nop // sll r0, r0, 0 + goto block_34; // branch always + + + block_33: + c->negs(f3, f10); // neg.s f3, f10 + c->muls(f1, f1, f3); // mul.s f1, f1, f3 + c->divs(f1, f1, f5); // div.s f1, f1, f5 + + block_34: +//fmt::print("check: {} {}\n", c->fprs[f0], c->fprs[f2]); + cop1_bc = c->fprs[f0] < c->fprs[f2]; // c.lt.s f0, f2 + bc = cop1_bc; // bc1t L68 + // nop // sll r0, r0, 0 + if (bc) { +// fmt::print("pass 5 due to {} {}\n", c->fprs[f0], c->fprs[f2]); +goto block_36;} // branch non-likely + + //beq r0, r0, L69 // beq r0, r0, L69 + // nop // sll r0, r0, 0 + goto block_37; // branch always + + + block_36: +// fmt::print("pass!\n"); + c->daddiu(v0, s7, 8); // daddiu v0, s7, #t + + block_37: + c->ld(fp, 8, sp); // ld fp, 8(sp) + //jr ra // jr ra + c->daddiu(sp, sp, 16); // daddiu sp, sp, 16 + goto end_of_function; // return + + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + end_of_function: + return c->gprs[v0].du64[0]; +} + +void link() { + cache.math_camera = intern_from_c("*math-camera*").c(); + gLinkedFunctionTable.reg("draw-bones-check-longest-edge-asm", execute, 128); + cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c(); +} + +} // namespace draw_bones_check_longest_edge_asm +} // namespace Mips2C + diff --git a/game/mips2c/functions/merc_blend_shape.cpp b/game/mips2c/functions/merc_blend_shape.cpp new file mode 100644 index 0000000000..3ab10d2483 --- /dev/null +++ b/game/mips2c/functions/merc_blend_shape.cpp @@ -0,0 +1,588 @@ + +// clang-format off +//--------------------------MIPS2C--------------------- +#include "game/mips2c/mips2c_private.h" +#include "game/kernel/kscheme.h" +namespace Mips2C { +namespace blerc_execute { +struct Cache { + void* blerc_globals; // *blerc-globals* + void* gsf_buffer; // *gsf-buffer* + void* stats_blerc; // *stats-blerc* + void* flush_cache; // flush-cache + void* fake_scratchpad_data; // *fake-scratchpad-data* +} cache; + +u64 execute(void* ctxt) { + auto* c = (ExecutionContext*)ctxt; + bool bc = false; + u32 call_addr = 0; + u32 madr, sadr, qwc, tadr; + c->daddiu(sp, sp, -96); // daddiu sp, sp, -96 + c->sd(ra, 0, sp); // sd ra, 0(sp) + c->sq(s2, 16, sp); // sq s2, 16(sp) + c->sq(s3, 32, sp); // sq s3, 32(sp) + c->sq(s4, 48, sp); // sq s4, 48(sp) + c->sq(s5, 64, sp); // sq s5, 64(sp) + c->sq(gp, 80, sp); // sq gp, 80(sp) + c->load_symbol(v1, cache.blerc_globals); // lw v1, *blerc-globals*(s7) + c->lwu(s5, 0, v1); // lwu s5, 0(v1) + bc = c->sgpr64(s5) == 0; // beq s5, r0, L46 + c->mov64(v1, s7); // or v1, s7, r0 + if (bc) {goto block_33;} // branch non-likely + + c->addiu(v1, r0, 0); // addiu v1, r0, 0 + c->addiu(gp, r0, 0); // addiu gp, r0, 0 + c->addiu(v1, r0, 0); // addiu v1, r0, 0 + c->load_symbol(v1, cache.gsf_buffer); // lw v1, *gsf-buffer*(s7) + c->load_symbol(t9, cache.flush_cache); // lw t9, flush-cache(s7) + c->addiu(a0, r0, 0); // addiu a0, r0, 0 + call_addr = c->gprs[t9].du32[0]; // function call: + c->sll(v0, ra, 0); // sll v0, ra, 0 + c->jalr(call_addr); // jalr ra, t9 + c->addiu(v1, r0, 848); // addiu v1, r0, 848 + // c->lui(a0, 28672); // lui a0, 28672 + get_fake_spad_addr(a0, cache.fake_scratchpad_data, 0, c); + c->daddu(a1, v1, a0); // daddu a1, v1, a0 + c->load_symbol(v1, cache.blerc_globals); // lw v1, *blerc-globals*(s7) + c->daddu(v1, r0, v1); // daddu v1, r0, v1 + // nop // sll r0, r0, 0 + c->lui(a0, 4096); // lui a0, 4096 + // nop // sll r0, r0, 0 + c->ori(a0, a0, 54272); // ori a0, a0, 54272 // spr to + c->andi(a1, a1, 16383); // andi a1, a1, 16383 +/* + block_2: + c->lw(a2, 0, a0); // lw a2, 0(a0) + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + c->andi(a2, a2, 256); // andi a2, a2, 256 + // nop // sll r0, r0, 0 + bc = c->sgpr64(a2) != 0; // bne a2, r0, L28 + c->lw(a2, 0, v1); // lw a2, 0(v1) + if (bc) {goto block_2;} // branch non-likely + */ + c->lw(a2, 0, v1); + + bc = c->sgpr64(a2) == 0; // beq a2, r0, L29 + //c->sw(a1, 128, a0); // sw a1, 128(a0) + sadr = c->sgpr64(a1); + if (bc) {goto block_5;} // branch non-likely + + c->addiu(v1, r0, 324); // addiu v1, r0, 324 + //c->sw(a2, 48, a0); // sw a2, 48(a0) + tadr = c->sgpr64(a2); + //c->sw(r0, 32, a0); // sw r0, 32(a0) + // Unknown instr: sync.l + //c->sw(v1, 0, a0); // sw v1, 0(a0) + spad_to_dma_blerc_chain(cache.fake_scratchpad_data, sadr, tadr); + // Unknown instr: sync.l + + block_5: + c->gprs[v1].du64[0] = 0; // or v1, r0, r0 + //beq r0, r0, L45 // beq r0, r0, L45 + // nop // sll r0, r0, 0 + goto block_31; // branch always + + + block_6: + bc = c->sgpr64(gp) != 0; // bne gp, r0, L31 + // nop // sll r0, r0, 0 + if (bc) {goto block_8;} // branch non-likely + + //c->lui(v1, 28672); // lui v1, 28672 + get_fake_spad_addr(v1, cache.fake_scratchpad_data, 0, c); + c->daddu(a0, r0, v1); // daddu a0, r0, v1 + //beq r0, r0, L32 // beq r0, r0, L32 + // nop // sll r0, r0, 0 + goto block_9; // branch always + + + block_8: + c->addiu(v1, r0, 8192); // addiu v1, r0, 8192 + // c->lui(a0, 28672); // lui a0, 28672 + get_fake_spad_addr(a0, cache.fake_scratchpad_data, 0, c); + c->daddu(a0, v1, a0); // daddu a0, v1, a0 + + block_9: + bc = c->sgpr64(gp) != 0; // bne gp, r0, L33 + // nop // sll r0, r0, 0 + if (bc) {goto block_11;} // branch non-likely + + c->addiu(v1, r0, 8192); // addiu v1, r0, 8192 + // c->lui(a1, 28672); // lui a1, 28672 + get_fake_spad_addr(a1, cache.fake_scratchpad_data, 0, c); + c->daddu(a1, v1, a1); // daddu a1, v1, a1 + //beq r0, r0, L34 // beq r0, r0, L34 + // nop // sll r0, r0, 0 + goto block_12; // branch always + + + block_11: + // c->lui(v1, 28672); // lui v1, 28672 + get_fake_spad_addr(v1, cache.fake_scratchpad_data, 0, c); + c->daddu(a1, r0, v1); // daddu a1, r0, v1 + + block_12: + c->daddiu(v1, a0, 848); // daddiu v1, a0, 848 + c->daddu(a2, r0, a0); // daddu a2, r0, a0 + c->daddiu(a3, a1, 848); // daddiu a3, a1, 848 + c->daddiu(a1, v1, 12); // daddiu a1, v1, 12 + // nop // sll r0, r0, 0 + c->lui(a2, 4096); // lui a2, 4096 + // nop // sll r0, r0, 0 + c->ori(a2, a2, 54272); // ori a2, a2, 54272 + c->andi(a3, a3, 16383); // andi a3, a3, 16383 + + +/* + block_13: + c->lw(t0, 0, a2); // lw t0, 0(a2) + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + c->andi(t0, t0, 256); // andi t0, t0, 256 + // nop // sll r0, r0, 0 + bc = c->sgpr64(t0) != 0; // bne t0, r0, L35 + c->lw(t0, 0, a1); // lw t0, 0(a1) + if (bc) {goto block_13;} // branch non-likely + */ + + c->lw(t0, 0, a1); + + + bc = c->sgpr64(t0) == 0; // beq t0, r0, L36 + // c->sw(a3, 128, a2); // sw a3, 128(a2) + sadr = c->sgpr64(a3); + if (bc) {goto block_16;} // branch non-likely + + c->addiu(a1, r0, 324); // addiu a1, r0, 324 + // c->sw(t0, 48, a2); // sw t0, 48(a2) + tadr = c->sgpr64(t0); + // c->sw(r0, 32, a2); // sw r0, 32(a2) + // Unknown instr: sync.l + //c->sw(a1, 0, a2); // sw a1, 0(a2) + // tadr here is bogus, it's reading something uploaded by the other transfer. + spad_to_dma_blerc_chain(cache.fake_scratchpad_data, sadr, tadr); + + // Unknown instr: sync.l + + block_16: + c->gprs[a1].du64[0] = 0; // or a1, r0, r0 + c->mov64(a2, a0); // or a2, a0, r0 + c->load_symbol(a3, cache.gsf_buffer); // lw a3, *gsf-buffer*(s7) + c->daddiu(t2, a2, 880); // daddiu t2, a2, 880 + c->lb(t1, 0, t2); // lb t1, 0(t2) + // nop // sll r0, r0, 0 + c->mov64(t0, a2); // or t0, a2, r0 + c->lw(a1, 868, a2); // lw a1, 868(a2) + c->daddiu(t3, t1, 1); // daddiu t3, t1, 1 + + c->mov64(t1, a3); // or t1, a3, r0 + c->sll(t8, t3, 4); // sll t8, t3, 4 + c->sll(t3, a1, 4); // sll t3, a1, 4 + c->daddu(t9, t3, a3); // daddu t9, t3, a3 + c->daddu(t3, t2, t8); // daddu t3, t2, t8 + bc = c->sgpr64(a1) == 0; // beq a1, r0, L39 + c->daddiu(ra, t2, 16); // daddiu ra, t2, 16 + if (bc) {goto block_21;} // branch non-likely + + c->lh(t5, 12, t3); // lh t5, 12(t3) + c->daddu(t2, t3, t8); // daddu t2, t3, t8 + //beq r0, r0, L38 // beq r0, r0, L38 + // nop // sll r0, r0, 0 + goto block_19; // branch always + + + block_18: + c->lh(t5, 12, t2); // lh t5, 12(t2) + c->daddu(t2, t2, t8); // daddu t2, t2, t8 + c->sq(t6, 0, t1); // sq t6, 0(t1) + c->daddiu(t1, t1, 16); // daddiu t1, t1, 16 + + block_19: + c->pcpyh(t5, t5); // pcpyh t5, t5 + c->mfc1(r0, f31); // mfc1 r0, f31 + //fmt::print("loop: {:x} {:x}\n", c->sgpr64(t1), c->sgpr64(t9)); + bc = c->sgpr64(t1) != c->sgpr64(t9); // bne t1, t9, L37 + c->pcpyld(t6, t5, t5); // pcpyld t6, t5, t5 + if (bc) {goto block_18;} // branch non-likely + + c->dsubu(t3, t2, t8); // dsubu t3, t2, t8 + // nop // sll r0, r0, 0 + + block_21: + c->addiu(t1, r0, 255); // addiu t1, r0, 255 + c->addiu(t2, r0, 8192); // addiu t2, r0, 8192 + c->lb(s5, 0, t3); // lb s5, 0(t3) + c->daddiu(s4, t3, 16); // daddiu s4, t3, 16 + c->pcpyh(t1, t1); // pcpyh t1, t1 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->pcpyld(t1, t1, t1); // pcpyld t1, t1, t1 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->pcpyh(t2, t2); // pcpyh t2, t2 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->pcpyld(t2, t2, t2); // pcpyld t2, t2, t2 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->mov128_gpr_gpr(t3, t1); // por t3, t1, r0 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->mov128_gpr_gpr(t4, r0); // por t4, r0, r0 + c->mfc1(r0, f31); // mfc1 r0, f31 + + block_22: + c->ld(t6, 0, ra); // ld t6, 0(ra) + c->daddu(s2, ra, t8); // daddu s2, ra, t8 + c->daddiu(ra, ra, 8); // daddiu ra, ra, 8 + c->mov64(s3, a3); // or s3, a3, r0 + c->pextlb(t6, r0, t6); // pextlb t6, r0, t6 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->pmulth(t7, t6, t2); // pmulth t7, t6, t2 + c->ld(t5, 0, s2); // ld t5, 0(s2) + c->daddiu(s5, s5, -1); // daddiu s5, s5, -1 + // nop // sll r0, r0, 0 + //beq r0, r0, L42 // beq r0, r0, L42 + c->daddu(s2, s2, t8); // daddu s2, s2, t8 + goto block_24; // branch always + + + block_23: + c->pmaddh(t7, t5, t6); // pmaddh t7, t5, t6 + c->ld(t5, 0, s2); // ld t5, 0(s2) + c->daddu(s2, s2, t8); // daddu s2, s2, t8 + c->daddiu(s3, s3, 16); // daddiu s3, s3, 16 + + block_24: + c->lq(t6, 0, s3); // lq t6, 0(s3) + c->pextlb(t5, t5, r0); // pextlb t5, t5, r0 + bc = c->sgpr64(s3) != c->sgpr64(t9); // bne s3, t9, L41 + c->psrah(t5, t5, 8); // psrah t5, t5, 8 + if (bc) {goto block_23;} // branch non-likely + + //todo // Unknown instr: pmfhl.uw t5 + c->gprs[t5].du32[0] = c->lo.du32[1]; + c->gprs[t5].du32[1] = c->hi.du32[1]; + c->gprs[t5].du32[2] = c->lo.du32[3]; + c->gprs[t5].du32[3] = c->hi.du32[3]; + c->mfc1(r0, f31); // mfc1 r0, f31 + c->psraw(t7, t7, 13); // psraw t7, t7, 13 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->psraw(t5, t5, 13); // psraw t5, t5, 13 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->pinteh(t5, t5, t7); // pinteh t5, t5, t7 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->pminh(t3, t3, t5); // pminh t3, t3, t5 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->pmaxh(t4, t4, t5); // pmaxh t4, t4, t5 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->pminh(t5, t5, t1); // pminh t5, t5, t1 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->pmaxh(t5, t5, r0); // pmaxh t5, t5, r0 + c->lq(t7, 0, s4); // lq t7, 0(s4) + c->ppacb(t5, r0, t5); // ppacb t5, r0, t5 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->ppach(t7, r0, t7); // ppach t7, r0, t7 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->pextlh(t5, t5, t7); // pextlh t5, t5, t7 + c->mfc1(r0, f31); // mfc1 r0, f31 + c->sq(t5, 0, t0); // sq t5, 0(t0) + c->daddiu(t0, t0, 16); // daddiu t0, t0, 16 + bc = c->sgpr64(s5) != 0; // bne s5, r0, L40 + c->daddiu(s4, s4, 16); // daddiu s4, s4, 16 + if (bc) {goto block_22;} // branch non-likely + + c->load_symbol(a3, cache.stats_blerc); // lw a3, *stats-blerc*(s7) + bc = c->sgpr64(a3) == c->sgpr64(s7); // beq a3, s7, L43 + c->load_symbol(a3, cache.blerc_globals); // lw a3, *blerc-globals*(s7) + if (bc) {goto block_28;} // branch non-likely + + c->lw(t2, 12, a3); // lw t2, 12(a3) + c->lw(t1, 16, a3); // lw t1, 16(a3) + c->lw(t0, 20, a3); // lw t0, 20(a3) + c->lw(a2, 864, a2); // lw a2, 864(a2) + c->multu3(a1, a1, a2); // multu3 a1, a1, a2 + c->daddiu(t2, t2, 1); // daddiu t2, t2, 1 + c->daddu(a2, t1, a2); // daddu a2, t1, a2 + c->daddu(a1, t0, a1); // daddu a1, t0, a1 + c->sw(t2, 12, a3); // sw t2, 12(a3) + c->sw(a2, 16, a3); // sw a2, 16(a3) + c->sw(a1, 20, a3); // sw a1, 20(a3) + c->pcpyud(a1, t3, r0); // pcpyud a1, t3, r0 + c->pminh(t3, t3, a1); // pminh t3, t3, a1 + c->dsrl32(a1, t3, 0); // dsrl32 a1, t3, 0 + c->pminh(t3, t3, a1); // pminh t3, t3, a1 + c->dsrl(t3, t3, 16); // dsrl t3, t3, 16 + c->lh(a1, 8, a3); // lh a1, 8(a3) + c->pminh(t3, t3, a1); // pminh t3, t3, a1 + c->sh(t3, 8, a3); // sh t3, 8(a3) + c->pcpyud(a1, t4, r0); // pcpyud a1, t4, r0 + c->pmaxh(t4, t4, a1); // pmaxh t4, t4, a1 + c->dsrl32(a1, t4, 0); // dsrl32 a1, t4, 0 + c->pmaxh(t4, t4, a1); // pmaxh t4, t4, a1 + c->dsrl(t4, t4, 16); // dsrl t4, t4, 16 + c->lh(a1, 10, a3); // lh a1, 10(a3) + c->pmaxh(t4, t4, a1); // pmaxh t4, t4, a1 + c->sh(t4, 10, a3); // sh t4, 10(a3) + + block_28: + c->gprs[a1].du64[0] = 0; // or a1, r0, r0 + c->lwu(a1, 872, a0); // lwu a1, 872(a0) + c->mov64(a3, a0); // or a3, a0, r0 + c->lwu(a0, 876, a0); // lwu a0, 876(a0) + c->lui(a2, 4096); // lui a2, 4096 + // nop // sll r0, r0, 0 + c->ori(a2, a2, 53248); // ori a2, a2, 53248 + c->andi(a3, a3, 16383); // andi a3, a3, 16383 + +/* + block_29: + c->lw(t0, 0, a2); // lw t0, 0(a2) + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + c->andi(t0, t0, 256); // andi t0, t0, 256 + // nop // sll r0, r0, 0 + bc = c->sgpr64(t0) != 0; // bne t0, r0, L44 + // nop // sll r0, r0, 0 + if (bc) {goto block_29;} // branch non-likely + */ + + // c->sw(a3, 128, a2); // sw a3, 128(a2) + sadr = c->sgpr64(a3); + c->addiu(a3, r0, 256); // addiu a3, r0, 256 + // c->sw(a1, 16, a2); // sw a1, 16(a2) + madr = c->sgpr64(a1); + // nop // sll r0, r0, 0 + // c->sw(a0, 32, a2); // sw a0, 32(a2) + qwc = c->sgpr64(a0); + // Unknown instr: sync.l + // c->sw(a3, 0, a2); // sw a3, 0(a2) + spad_from_dma_no_sadr_off(cache.fake_scratchpad_data, madr, sadr, qwc); + // Unknown instr: sync.l + c->gprs[a0].du64[0] = 0; // or a0, r0, r0 + c->addiu(a0, r0, 1); // addiu a0, r0, 1 + c->dsubu(gp, a0, gp); // dsubu gp, a0, gp + c->lwu(s5, 12, v1); // lwu s5, 12(v1) + c->mov64(v1, s5); // or v1, s5, r0 + + block_31: + bc = c->sgpr64(s5) != 0; // bne s5, r0, L30 + // nop // sll r0, r0, 0 + if (bc) {goto block_6;} // branch non-likely + + c->mov64(v1, s7); // or v1, s7, r0 + + block_33: + c->gprs[v0].du64[0] = 0; // or v0, r0, r0 + c->ld(ra, 0, sp); // ld ra, 0(sp) + c->lq(gp, 80, sp); // lq gp, 80(sp) + c->lq(s5, 64, sp); // lq s5, 64(sp) + c->lq(s4, 48, sp); // lq s4, 48(sp) + c->lq(s3, 32, sp); // lq s3, 32(sp) + c->lq(s2, 16, sp); // lq s2, 16(sp) + //jr ra // jr ra + c->daddiu(sp, sp, 96); // daddiu sp, sp, 96 + goto end_of_function; // return + + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + end_of_function: + return c->gprs[v0].du64[0]; +} + +void link() { + cache.blerc_globals = intern_from_c("*blerc-globals*").c(); + cache.gsf_buffer = intern_from_c("*gsf-buffer*").c(); + cache.stats_blerc = intern_from_c("*stats-blerc*").c(); + cache.flush_cache = intern_from_c("flush-cache").c(); + cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c(); + gLinkedFunctionTable.reg("blerc-execute", execute, 256); +} + +} // namespace blerc_execute +} // namespace Mips2C + + +//--------------------------MIPS2C--------------------- +#include "game/mips2c/mips2c_private.h" +#include "game/kernel/kscheme.h" +namespace Mips2C { +namespace setup_blerc_chains_for_one_fragment { +struct Cache { + void* blerc_globals; // *blerc-globals* + void* fake_scratchpad_data; // *fake-scratchpad-data* + +} cache; + +u64 execute(void* ctxt) { + auto* c = (ExecutionContext*)ctxt; + bool bc = false; + c->daddiu(sp, sp, -128); // daddiu sp, sp, -128 + c->sd(ra, 0, sp); // sd ra, 0(sp) + c->sq(s0, 16, sp); // sq s0, 16(sp) + c->sq(s1, 32, sp); // sq s1, 32(sp) + c->sq(s2, 48, sp); // sq s2, 48(sp) + c->sq(s3, 64, sp); // sq s3, 64(sp) + c->sq(s4, 80, sp); // sq s4, 80(sp) + c->sq(s5, 96, sp); // sq s5, 96(sp) + c->sq(gp, 112, sp); // sq gp, 112(sp) + c->lb(v1, 0, t0); // lb v1, 0(t0) + c->addiu(t2, r0, 0); // addiu t2, r0, 0 + c->mov128_gpr_gpr(t7, r0); // por t7, r0, r0 + c->load_symbol(t3, cache.blerc_globals); // lw t3, *blerc-globals*(s7) + c->lw(t3, 4, t3); // lw t3, 4(t3) + c->mov64(t4, v1); // or t4, v1, r0 + + block_1: + c->lui(t7, 4096); // lui t7, 4096 + // nop // sll r0, r0, 0 + c->daddiu(t7, t7, 1); // daddiu t7, t7, 1 + // nop // sll r0, r0, 0 + bc = c->sgpr64(t3) == 0; // beq t3, r0, L11 + c->sq(t7, 0, a2); // sq t7, 0(a2) + if (bc) {goto block_3;} // branch non-likely + + c->sw(a2, 12, t3); // sw a2, 12(t3) + // nop // sll r0, r0, 0 + + block_3: + c->mov64(t3, a2); // or t3, a2, r0 + c->daddu(t6, t4, t4); // daddu t6, t4, t4 + c->daddu(t5, v1, v1); // daddu t5, v1, v1 + c->daddu(t6, t6, t4); // daddu t6, t6, t4 + c->daddu(t7, t5, v1); // daddu t7, t5, v1 + c->daddu(t5, t6, t6); // daddu t5, t6, t6 + c->daddu(t6, t7, t7); // daddu t6, t7, t7 + c->daddu(t7, t5, t5); // daddu t7, t5, t5 + c->daddiu(t6, t6, 15); // daddiu t6, t6, 15 + c->daddiu(t5, t5, 15); // daddiu t5, t5, 15 + c->andi(t6, t6, 65520); // andi t6, t6, 65520 + c->dsrl(t5, t5, 4); // dsrl t5, t5, 4 + c->daddu(t8, t2, t2); // daddu t8, t2, t2 + c->daddiu(t7, t7, 15); // daddiu t7, t7, 15 + c->daddu(t9, t8, t2); // daddu t9, t8, t2 + c->dsrl(t8, t7, 4); // dsrl t8, t7, 4 + c->daddu(ra, t9, t9); // daddu ra, t9, t9 + c->addiu(t9, r0, 0); // addiu t9, r0, 0 + c->daddu(t7, ra, ra); // daddu t7, ra, ra + c->daddiu(s3, a2, 32); // daddiu s3, a2, 32 + c->daddu(s2, ra, a3); // daddu s2, ra, a3 + c->daddu(ra, t7, t1); // daddu ra, t7, t1 + c->lui(t7, 12288); // lui t7, 12288 + c->daddiu(gp, a0, -1); // daddiu gp, a0, -1 + c->daddu(t7, t7, t5); // daddu t7, t7, t5 + c->mov64(s5, a1); // or s5, a1, r0 + c->sq(t7, 0, s3); // sq t7, 0(s3) + c->daddiu(s4, t0, 2); // daddiu s4, t0, 2 + c->sw(s2, 4, s3); // sw s2, 4(s3) + c->daddu(s2, s2, t6); // daddu s2, s2, t6 + c->daddiu(s3, s3, 16); // daddiu s3, s3, 16 + // nop // sll r0, r0, 0 + + block_4: + c->lb(s1, 0, s4); // lb s1, 0(s4) + c->daddiu(s4, s4, 1); // daddiu s4, s4, 1 + c->lh(s0, 0, s5); // lh s0, 0(s5) + c->daddiu(s5, s5, 2); // daddiu s5, s5, 2 + bc = c->sgpr64(s1) == 0; // beq s1, r0, L13 + c->sq(t7, 0, s3); // sq t7, 0(s3) + if (bc) {goto block_7;} // branch non-likely + + c->sw(s2, 4, s3); // sw s2, 4(s3) + c->daddu(s2, s2, t6); // daddu s2, s2, t6 + bc = c->sgpr64(s0) == 0; // beq s0, r0, L13 + c->sw(s0, 12, s3); // sw s0, 12(s3) no + if (bc) {goto block_7;} // branch non-likely + + c->daddiu(s3, s3, 16); // daddiu s3, s3, 16 + c->daddiu(t9, t9, 1); // daddiu t9, t9, 1 + + block_7: + bc = c->sgpr64(gp) != 0; // bne gp, r0, L12 + c->daddiu(gp, gp, -1); // daddiu gp, gp, -1 + if (bc) {goto block_4;} // branch non-likely + + c->sq(t7, 0, s3); // sq t7, 0(s3) + c->mov128_gpr_gpr(t6, r0); // por t6, r0, r0 + c->sw(ra, 4, s3); // sw ra, 4(s3) + // c->lui(t6, 28672); // lui t6, 28672 + get_fake_spad_addr(t6, cache.fake_scratchpad_data, 0, c); + c->sb(t8, 0, s3); // sb t8, 0(s3) + // nop // sll r0, r0, 0 + c->sq(t6, 16, s3); // sq t6, 16(s3) + c->daddiu(t6, s3, 32); // daddiu t6, s3, 32 + c->sw(t9, 20, a2); // sw t9, 20(a2) + // nop // sll r0, r0, 0 + c->sw(t4, 16, a2); // sw t4, 16(a2) + // nop // sll r0, r0, 0 + c->sw(ra, 24, a2); // sw ra, 24(a2) + // nop // sll r0, r0, 0 + c->sw(t8, 28, a2); // sw t8, 28(a2) + // nop // sll r0, r0, 0 + bc = c->sgpr64(t4) != c->sgpr64(v1); // bne t4, v1, L14 + c->daddiu(t5, t5, 1); // daddiu t5, t5, 1 + if (bc) {goto block_11;} // branch non-likely + + c->daddiu(t7, t9, 3); // daddiu t7, t9, 3 + c->multu3(t5, t5, t7); // multu3 t5, t5, t7 + c->daddiu(t5, t5, -457); // daddiu t5, t5, -457 + // nop // sll r0, r0, 0 + bc = ((s64)c->sgpr64(t5)) <= 0; // blez t5, L14 + // nop // sll r0, r0, 0 + if (bc) {goto block_11;} // branch non-likely + + //beq r0, r0, L10 // beq r0, r0, L10 + c->addiu(t4, r0, 24); // addiu t4, r0, 24 + goto block_1; // branch always + + + block_11: + c->mov64(a2, t6); // or a2, t6, r0 + c->daddu(t2, t2, t4); // daddu t2, t2, t4 + bc = c->sgpr64(t2) == c->sgpr64(v1); // beq t2, v1, L15 + c->daddu(t5, t2, t4); // daddu t5, t2, t4 + if (bc) {goto block_14;} // branch non-likely + + c->dsubu(t5, t5, v1); // dsubu t5, t5, v1 + // nop // sll r0, r0, 0 + bc = ((s64)c->sgpr64(t5)) <= 0; // blez t5, L10 + // nop // sll r0, r0, 0 + if (bc) {goto block_1;} // branch non-likely + + //beq r0, r0, L10 // beq r0, r0, L10 + c->dsubu(t4, v1, t2); // dsubu t4, v1, t2 + goto block_1; // branch always + + + block_14: + c->load_symbol(v1, cache.blerc_globals); // lw v1, *blerc-globals*(s7) + c->sw(t3, 4, v1); // sw t3, 4(v1) + c->mov64(v0, a2); // or v0, a2, r0 + c->ld(ra, 0, sp); // ld ra, 0(sp) + c->lq(gp, 112, sp); // lq gp, 112(sp) + c->lq(s5, 96, sp); // lq s5, 96(sp) + c->lq(s4, 80, sp); // lq s4, 80(sp) + c->lq(s3, 64, sp); // lq s3, 64(sp) + c->lq(s2, 48, sp); // lq s2, 48(sp) + c->lq(s1, 32, sp); // lq s1, 32(sp) + c->lq(s0, 16, sp); // lq s0, 16(sp) + //jr ra // jr ra + c->daddiu(sp, sp, 128); // daddiu sp, sp, 128 + goto end_of_function; // return + + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + // nop // sll r0, r0, 0 + end_of_function: + return c->gprs[v0].du64[0]; +} + +void link() { + cache.blerc_globals = intern_from_c("*blerc-globals*").c(); + gLinkedFunctionTable.reg("setup-blerc-chains-for-one-fragment", execute, 256); + cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c(); +} + +} // namespace setup_blerc_chains_for_one_fragment +} // namespace Mips2C diff --git a/game/mips2c/mips2c_private.h b/game/mips2c/mips2c_private.h index 356005e04b..2d659eb308 100644 --- a/game/mips2c/mips2c_private.h +++ b/game/mips2c/mips2c_private.h @@ -8,6 +8,7 @@ #include "common/util/BitUtils.h" #include "third-party/fmt/core.h" #include "common/util/assert.h" +#include "common/dma/dma.h" // This file contains utility functions for code generated by the mips2c pass. // This is only useful for @@ -485,7 +486,7 @@ struct ExecutionContext { } void pmulth(int rd, int rs, int rt) { - assert(rd == 0); + // assert(rd == 0); s32 temp; auto s = gpr_src(rs); @@ -493,59 +494,70 @@ struct ExecutionContext { temp = (s32)s.ds16[0] * (s32)t.ds16[0]; lo.du32[0] = temp; - /*if (_Rd_) cpuRegs.GPR.r[_Rd_].UL[0] = temp;*/ + if (rd) + gprs[rd].du32[0] = temp; temp = (s32)s.ds16[1] * (s32)t.ds16[1]; lo.du32[1] = temp; temp = (s32)s.ds16[2] * (s32)t.ds16[2]; hi.du32[0] = temp; - /*if (_Rd_) cpuRegs.GPR.r[_Rd_].UL[1] = temp;*/ + if (rd) + gprs[rd].du32[1] = temp; temp = (s32)s.ds16[3] * (s32)t.ds16[3]; hi.du32[1] = temp; temp = (s32)s.ds16[4] * (s32)t.ds16[4]; lo.du32[2] = temp; - /*if (_Rd_) cpuRegs.GPR.r[_Rd_].UL[2] = temp;*/ + if (rd) + gprs[rd].du32[2] = temp; temp = (s32)s.ds16[5] * (s32)t.ds16[5]; lo.du32[3] = temp; temp = (s32)s.ds16[6] * (s32)t.ds16[6]; hi.du32[2] = temp; - /*if (_Rd_) cpuRegs.GPR.r[_Rd_].UL[3] = temp;*/ + if (rd) + gprs[rd].du32[3] = temp; temp = (s32)s.ds16[7] * (s32)t.ds16[7]; hi.du32[3] = temp; } void pmaddh(int rd, int rs, int rt) { - assert(rd == 0); s32 temp; auto s = gpr_src(rs); auto t = gpr_src(rt); temp = lo.du32[0] + (s32)s.ds16[0] * (s32)t.ds16[0]; lo.du32[0] = temp; + if (rd) + gprs[rd].du32[0] = temp; temp = lo.du32[1] + (s32)s.ds16[1] * (s32)t.ds16[1]; lo.du32[1] = temp; temp = hi.du32[0] + (s32)s.ds16[2] * (s32)t.ds16[2]; hi.du32[0] = temp; + if (rd) + gprs[rd].du32[1] = temp; temp = hi.du32[1] + (s32)s.ds16[3] * (s32)t.ds16[3]; hi.du32[1] = temp; temp = lo.du32[2] + (s32)s.ds16[4] * (s32)t.ds16[4]; lo.du32[2] = temp; + if (rd) + gprs[rd].du32[2] = temp; temp = lo.du32[3] + (s32)s.ds16[5] * (s32)t.ds16[5]; lo.du32[3] = temp; temp = hi.du32[2] + (s32)s.ds16[6] * (s32)t.ds16[6]; hi.du32[2] = temp; + if (rd) + gprs[rd].du32[3] = temp; temp = hi.du32[3] + (s32)s.ds16[7] * (s32)t.ds16[7]; hi.du32[3] = temp; @@ -858,6 +870,12 @@ struct ExecutionContext { } void mult3(int dst, int src0, int src1) { + u32 result = gpr_src(src0).ds32[0] * gpr_src(src1).ds32[0]; + s32 sresult = result; + gprs[dst].ds64[0] = sresult; + } + + void multu3(int dst, int src0, int src1) { u32 result = gpr_src(src0).du32[0] * gpr_src(src1).du32[0]; s32 sresult = result; gprs[dst].ds64[0] = sresult; @@ -942,6 +960,33 @@ struct ExecutionContext { } } + void pmaxh(int dst, int src0, int src1) { + auto s0 = gpr_src(src0); + auto s1 = gpr_src(src1); + for (int i = 0; i < 8; i++) { + gprs[dst].ds16[i] = std::max(s0.ds16[i], s1.ds16[i]); + } + } + + void pcpyh(int dst, int src) { + auto s0 = gpr_src(src); + gprs[dst].du16[0] = s0.du16[0]; + gprs[dst].du16[1] = s0.du16[0]; + gprs[dst].du16[2] = s0.du16[0]; + gprs[dst].du16[3] = s0.du16[0]; + gprs[dst].du16[4] = s0.du16[4]; + gprs[dst].du16[5] = s0.du16[4]; + gprs[dst].du16[6] = s0.du16[4]; + gprs[dst].du16[7] = s0.du16[4]; + } + + void psrah(int dest, int src, int sa) { + auto s = gpr_src(src); + for (int i = 0; i < 8; i++) { + gprs[dest].ds16[i] = s.ds16[i] >> (sa & 0xf); + } + } + void mov128_vf_gpr(int dst, int src) { vfs[dst] = gpr_src(src); } void mov128_gpr_vf(int dst, int src) { gprs[dst] = vf_src(src); } void mov128_gpr_gpr(int dst, int src) { gprs[dst] = gpr_src(src); } @@ -1026,6 +1071,7 @@ struct ExecutionContext { } void movs(int dst, int src) { fprs[dst] = fprs[src]; } + void abss(int dst, int src) { fprs[dst] = std::abs(fprs[src]); } void cvtws(int dst, int src) { // float to int @@ -1167,4 +1213,11 @@ inline void load_vfs_from_tf_regs(const void* tf_regs_sym, ExecutionContext* c) u8* c_addr_of_vf1 = g_ee_main_mem + goal_addr_of_vf1; memcpy(&c->vfs[1], c_addr_of_vf1, 31 * 16); } + +inline void spad_to_dma_blerc_chain(void* spad_sym_addr, u32 sadr, u32 tadr) { + u32 spad_addr_goal; + memcpy(&spad_addr_goal, spad_sym_addr, 4); + void* spad_addr_c = g_ee_main_mem + spad_addr_goal; + emulate_dma(g_ee_main_mem, spad_addr_c, tadr, sadr); +} } // namespace Mips2C diff --git a/game/mips2c/mips2c_table.cpp b/game/mips2c/mips2c_table.cpp index 3fc2ccc125..a9f8bce0eb 100644 --- a/game/mips2c/mips2c_table.cpp +++ b/game/mips2c/mips2c_table.cpp @@ -212,6 +212,18 @@ extern void link(); namespace cspace_parented_transformq_joint { extern void link(); } +namespace draw_bones_merc { +extern void link(); +} +namespace draw_bones_check_longest_edge_asm { +extern void link(); +} +namespace blerc_execute { +extern void link(); +} +namespace setup_blerc_chains_for_one_fragment { +extern void link(); +} LinkedFunctionTable gLinkedFunctionTable; Rng gRng; std::unordered_map> gMips2CLinkCallbacks = { @@ -245,7 +257,9 @@ std::unordered_map> gMips2CLinkCallbacks = {method_16_collide_edge_work::link, method_15_collide_edge_work::link, method_10_collide_edge_hold_list::link, method_18_collide_edge_work::link}}, {"joint", {calc_animation_from_spr::link, cspace_parented_transformq_joint::link}}, - {"bones", {bones_mtx_calc::link}}}; + {"bones", + {bones_mtx_calc::link, draw_bones_merc::link, draw_bones_check_longest_edge_asm::link}}, + {"merc-blend-shape", {blerc_execute::link, setup_blerc_chains_for_one_fragment::link}}}; void LinkedFunctionTable::reg(const std::string& name, u64 (*exec)(void*), u32 stack_size) { const auto& it = m_executes.insert({name, {exec, Ptr()}}); diff --git a/goal_src/engine/anim/bones.gc b/goal_src/engine/anim/bones.gc index 38eccf9bdb..f550f8b72b 100644 --- a/goal_src/engine/anim/bones.gc +++ b/goal_src/engine/anim/bones.gc @@ -656,10 +656,16 @@ ) ) -(define-extern draw-bones (function draw-control dma-buffer float none)) +;; draw-bones-shadow +;; draw-bones-generic-merc +;; draw-boes-merc +;; draw-bones-check-longest-edge +;; draw-bones-check-longest-edgei-asm +;; draw-bones +;; draw-bones-hud ;; HACK incomplete: -(defun draw-bones ((arg0 draw-control) (arg1 dma-buffer) (arg2 float)) +(defun draw-bones-hack ((arg0 draw-control) (arg1 dma-buffer) (arg2 float)) (local-vars (at-0 object) (a0-16 int) @@ -749,8 +755,430 @@ ))) (none)) +(def-mips2c draw-bones-merc (function draw-control object object int int pointer)) +(def-mips2c draw-bones-check-longest-edge-asm (function draw-control float symbol)) + +(defun draw-bones ((arg0 draw-control) (dma-buf dma-buffer) (arg2 float)) + "Main draw function for all bone-related renderers. Will set up merc, generic and shadow. + and also add the bones to the calculation list." + (local-vars (a0-16 int) (a0-17 int) (a0-62 int) (a2-10 int) (a2-12 int) + (used-merc int) (used-mercneric int) (effect-idx int) (sv-144 ripple-control)) + (rlet ((vf1 :class vf) (vf2 :class vf) (vf3 :class vf) (vf4 :class vf) (vf5 :class vf) (vf6 :class vf) + (vf7 :class vf) (vf8 :class vf) (vf9 :class vf) (acc :class vf)) + + ;; compute the number of bones. I believe this num-joints doesn't count align/prejoint/main, so each needs a bone + (let* ((num-bones (+ (-> arg0 mgeo num-joints) 3)) + ;; we'll use 128-bytes/bone. + (bone-data-size (* num-bones 128)) + ;; temp work + (spr-work (scratchpad-object terrain-context)) + ) + + ;;;;;;;;;;;;;;;;;;;;;;;;; + ;; BONE CALC SETUP + ;;;;;;;;;;;;;;;;;;;;;;;;; + + ;; next, grab some DMA data. + ;; we'll also use this for storing bone calculation entries. + (let* ((dma-data-start (-> dma-buf base)) + ;; first qw is the tag, stash the bone-calc-entry right after that. + (bone-calc-entry (the-as bone-calculation (&+ dma-data-start 16))) + ;; after that we'll use the space for storing bone matrices. + ;; we won't calculate them now, but instead we'll tell the *bone-calculation-list* to put them here later. + (matrix-data (the-as object (&+ dma-data-start 64))) + ) + + ;; align the matrix data to 64 bytes (we know it is at least 16 byte aligned) + (let ((a2-1 (logand (the-as int matrix-data) 48))) + (b! (zero? a2-1) cfg-2 :delay (nop!)) + (set! matrix-data (&- (&+ (the-as pointer matrix-data) 64) (the-as uint a2-1))) + ) + (label cfg-2) + + ;; start recording perf stats. + ;; this just counts the stats for adding the calculation to the linked list. + ;; which is really fast and not worth profiling. + ;; I suspect the bone calculation originally was here, + ;; but they moved it and forgot to move the performance counters too. + (reset! (-> *perf-stats* data (perf-stat-bucket bones))) + + ;; figure out where everything will be + (let ((a2-6 (the-as bone-regs (+ 240 (scratchpad-object int))))) + ;; the joints are stored in the static art data + (set! (-> a2-6 joint-ptr) (the-as (inline-array joint) (-> arg0 jgeo data 0))) + ;; the final bones output used by the rest of the engine is stored in + ;; the process-drawable's skeleton + (set! (-> a2-6 bone-ptr) (-> arg0 skeleton bones)) + (set! (-> a2-6 num-bones) (the-as uint num-bones)) + ) + + ;; Add the bone calculation to the list, to be done later. + ;; this will write to both the "matrix data" and the bones array. + (let ((t0-2 matrix-data) + (t1-0 0) + (t4-0 (the-as bone-memory (+ 16 (scratchpad-object int)))) + (a2-8 *bone-calculation-list*) + (a3-8 bone-calc-entry) + ) + (let ((t2-0 (-> t4-0 work regs joint-ptr)) + (t3-0 (-> t4-0 work regs bone-ptr)) + (t4-1 (-> t4-0 work regs num-bones)) + (t5-0 a3-8) + ) + (set! (-> t5-0 flags) (the-as bone-calc-flags t1-0)) + (set! (-> t5-0 num-bones) t4-1) + (set! (-> t5-0 matrix-area) (the-as (inline-array matrix) t0-2)) + (set! (-> t5-0 joints) t2-0) + (set! (-> t5-0 bones) t3-0) + (set! (-> t5-0 next) (the-as bone-calculation 0)) + ) + (if (nonzero? (-> a2-8 next)) + (set! (-> a2-8 next next) a3-8) + ) + (if (zero? (-> a2-8 first)) + (set! (-> a2-8 first) a3-8) + ) + (set! (-> a2-8 next) a3-8) + ) + (&+ bone-calc-entry 48) + ;; end stat collection + (read! (-> *perf-stats* data (perf-stat-bucket bones))) + + ;; set up the dma buffer + (let ((s2-0 (the-as object (+ (the-as uint matrix-data) bone-data-size)))) + (let ((a0-2 (shl (the-as int s2-0) 32))) + (set! (-> (the-as (pointer uint128) dma-data-start)) + (logior (-> spr-work work foreground bone-mem work next-tag quad) a0-2) + ) + ;; NOTE: does this work correctly for the upper 64 bits?? + ) + + ;; only data-format 1 is supported. + (when (= (-> arg0 data-format) 1) + ;; lights should be converted to a single vu-lights already, by the drawing code. + ;; it stashes lights on the scratchpad. We'll load these here and transform them. + ;; the result goes in the merc-bucke-info. + (let ((v1-6 (the-as vu-lights (+ 64 (scratchpad-object int)))) + (a0-7 (-> *merc-bucket-info* light)) + ) + (let ((a1-8 (-> *math-camera* inv-camera-rot))) + (.lvf vf4 (&-> a1-8 vector 0 quad)) + (.lvf vf5 (&-> a1-8 vector 1 quad)) + (.lvf vf6 (&-> a1-8 vector 2 quad)) + ) + (.lvf vf1 (&-> v1-6 direction 0 quad)) + (.lvf vf2 (&-> v1-6 direction 1 quad)) + (.lvf vf3 (&-> v1-6 direction 2 quad)) + ;;(.vcallms 54) + ;; TODO! + + ;mulax.xyzw ACC, vf01, vf04 + (.mul.x.vf acc vf1 vf4) + ;madday.xyzw ACC, vf02, vf04 + (.add.mul.y.vf acc vf2 vf4 acc) + ;maddz.xyzw vf07, vf03, vf04 + (.add.mul.z.vf vf7 vf3 vf4 acc) + + ;mulax.xyzw ACC, vf01, vf05 + (.mul.x.vf acc vf1 vf5) + ;madday.xyzw ACC, vf02, vf05 + (.add.mul.y.vf acc vf2 vf5 acc) + ;maddz.xyzw vf08, vf03, vf05 + (.add.mul.z.vf vf8 vf3 vf5 acc) + + ;mulax.xyzw ACC, vf01, vf06 + (.mul.x.vf acc vf1 vf6) + ;madday.xyzw ACC, vf02, vf06 :e + (.add.mul.y.vf acc vf2 vf6 acc) + ;maddz.xyzw vf09, vf03, vf06 + (.add.mul.z.vf vf9 vf3 vf6 acc) + + (let ((a1-9 (-> v1-6 color 0 quad))) + (let ((a2-14 (-> v1-6 color 1 quad))) + (let ((a3-11 (-> v1-6 color 2 quad))) + (let ((v1-7 (-> v1-6 ambient quad))) + (set! (-> a0-7 color 0 quad) a1-9) + (set! (-> a0-7 color 1 quad) a2-14) + (set! (-> a0-7 color 2 quad) a3-11) + (set! (-> a0-7 ambient quad) v1-7) + ) + ) + ) + ) + (.svf (&-> a0-7 direction 0 quad) vf7) + (.svf (&-> a0-7 direction 1 quad) vf8) + (.svf (&-> a0-7 direction 2 quad) vf9) + (set! (-> a0-7 direction 1 w) (the-as float 0)) + ) + + ;; the drawable system's culling already knows if we need clipping or not, + ;; we just trust it. + (set! (-> *merc-bucket-info* needs-clip) + (if (logtest? (-> arg0 status) (draw-status needs-clip)) + 1 + 0 + ) + ) + + ;; Now, we need to decide on merc settings. Default to nothing. + (set! used-merc 0) + (set! used-mercneric 0) + (set! (-> *merc-bucket-info* need-mercprime-if-merc) 0) + (set! (-> *merc-bucket-info* must-use-mercneric-for-clip) 0) + + (when (logtest? (-> arg0 status) (draw-status needs-clip)) + ;; we can either clip with "mercprime" (part of merc), or fall back to generic. + ;; the generic approach always works, but is slower, so we try to use mercprime. + ;; the user must provide a longest edge length, and we must pass an edge check (fails if close to camera) + (cond + ((nonzero? (-> arg0 longest-edge)) + ;; TODO this makes close up things bad... + (if (draw-bones-check-longest-edge-asm arg0 arg2) + (set! (-> *merc-bucket-info* need-mercprime-if-merc) 1) ;; clip with mercprime! + (set! (-> *merc-bucket-info* must-use-mercneric-for-clip) 1) ;; failed, use generic + ) + ) + (else + (set! (-> *merc-bucket-info* must-use-mercneric-for-clip) 1) ;; no longest edge info, use generic. + ) + ) + ) + + ;; grab the geometry at the appropriate level of detail. + (let ((geom (-> arg0 lod-set lod (-> arg0 cur-lod) geo))) + ;; loop over effects, and set them up/pick renderers. + (set! effect-idx 0) + (while (< effect-idx (the-as int (-> geom header effect-count))) + + ;; try texture scroll + (when (logtest? (-> geom effect effect-idx effect-bits) 1) + (let* ((v1-35 (-> geom effect effect-idx extra-info)) + (v1-36 (the-as mei-texture-scroll (+ (the-as uint v1-35) (* (-> v1-35 texture-scroll-offset) 16)))) + ) + (if (< arg2 (-> v1-36 max-dist)) + ;; just add to texscroll list. + (texscroll-make-request (-> geom effect effect-idx)) + ) + ) + ) + + ;; try ripple + (when (logtest? (-> geom effect effect-idx effect-bits) 4) + ;; TODO. + ; (when (-> arg0 ripple) + ; (set! sv-144 (-> arg0 ripple)) + ; (let* ((f1-4 (/ (- (-> sv-144 far-fade-dist) arg2) (- (-> sv-144 far-fade-dist) (-> sv-144 close-fade-dist)))) + ; (f1-6 (fmax 0.0 (fmin 1.0 f1-4))) + ; (f0-4 f1-6) + ; (f30-0 (* f1-6 (-> sv-144 global-scale))) + ; ) + ; (set! (-> sv-144 faded-scale) f30-0) + ; (let ((f1-9 (/ f30-0 (* 128.0 (-> geom header xyz-scale))))) + ; 0 + ; (.sll a0-16 num-bones 7) + ; (let ((v1-56 #x20000000)) + ; (.addu a0-17 a0-16 s2-0) + ; (s.q! s2-0 v1-56) + ; ) + ; (let ((v1-57 (+ a0-17 16))) + ; (s.w! (+ s2-0 4) v1-57) + ; ) + ; (.addiu matrix-data s2-0 16) + ; (let ((v1-59 (-> *bone-calculation-list* next))) + ; (logior! (-> v1-59 flags) (bone-calc-flags bncfl00)) + ; (set! (-> v1-59 ripple-scale) f30-0) + ; (set! (-> v1-59 ripple-y-scale) f1-9) + ; (set! (-> v1-59 ripple-normal-scale) (* f0-4 (-> sv-144 individual-normal-scale))) + ; (set! (-> v1-59 ripple-area) (the-as (inline-array vector) matrix-data)) + ; ) + ; ) + ; (set! (-> dma-buf base) (the-as pointer (-> (the-as (pointer uint32) s2-0) 1))) + ; (set! s2-0 (-> dma-buf base)) + ; (if (not (and (= f30-0 0.0) (= (-> sv-144 last-frame-scale) 0.0))) + ; (ripple-make-request (the-as ripple-wave (-> sv-144 waveform)) (-> geom effect effect-idx)) + ; ) + ; (set! (-> sv-144 last-frame-scale) f30-0) + ; ) + ; ) + ) + + + (cond + ((nonzero? (-> arg0 death-timer)) + ;; if using hte death effect, use mercneric always! + (set! (-> *merc-bucket-info* effect effect-idx use-mercneric) (the-as uint 1)) + (set! used-mercneric 1) + used-mercneric + ) + ((nonzero? (-> geom effect effect-idx envmap-usage)) + ;; if we need envmap, set it up. + (let* ((v1-83 (-> geom effect effect-idx extra-info)) + ;; pointer to envmap tint data + (v1-84 (the-as structure (+ (the-as uint v1-83) (* (-> v1-83 envmap-tint-offset) 16)))) + ;; the envmap effect fades away at a certain distance + (f1-12 (-> (the-as mei-envmap-tint v1-84) fade0)) + (f0-8 (-> (the-as mei-envmap-tint v1-84) fade1)) + ) + ;; compute and saturate the envmap effect strength + (let ((f0-9 (+ (* f1-12 arg2) f0-8))) + (if (< 1.0 f0-9) + (set! f0-9 1.0) + ) + (if (< f0-9 0.0) + (set! f0-9 0.0) + ) + + (cond + ;; do envmap stuff if we are using generic anyway, or our strength is > 0. + ((or (nonzero? (-> *merc-bucket-info* must-use-mercneric-for-clip)) (< 0.0 f0-9)) + ;; multiply colors by sun tint. + (let ((v1-85 (&-> (the-as merc-extra-info v1-84) dummy 4)) + (a0-36 (the-as object (-> *merc-bucket-info* effect effect-idx))) + ) + (let ((a1-16 (-> *time-of-day-context* current-sun env-color)) + (f0-10 (* 0.0078125 f0-9)) + ) + (dotimes (a2-15 3) + (set! (-> (the-as (pointer int8) a0-36) a2-15) + (the int (* f0-10 (-> a1-16 data a2-15) (the float (-> v1-85 a2-15)))) + ) + ) + ) + (set! (-> (the-as (pointer uint8) a0-36) 3) (the-as uint 0)) + ) + ;; env mapping, so use mercneric. + (set! (-> *merc-bucket-info* effect effect-idx use-mercneric) (the-as uint 1)) + (set! used-mercneric 1) + used-mercneric + ) + (else + ;; no env map, don't use mercneric. + (set! (-> *merc-bucket-info* effect effect-idx use-mercneric) (the-as uint 0)) + (set! (-> *merc-bucket-info* effect effect-idx ignore-alpha) (the-as uint 1)) + (set! used-merc 1) + ;; note sure what this is exactly... + (when (logtest? (-> geom effect effect-idx effect-bits) 2) + (let ((v1-102 (-> *merc-bucket-info* light))) + (set! (-> v1-102 direction 1 w) 0.000000000000000000000000000000000000011755039) + ) + ) + ) + ) + ) + ) + ) + ;; final two cases are for all other effects that don't matter generic/normal + ((nonzero? (-> *merc-bucket-info* must-use-mercneric-for-clip)) + (set! (-> *merc-bucket-info* effect effect-idx use-mercneric) (the-as uint 1)) + (set! used-mercneric 1) + used-mercneric + ) + (else + (set! (-> *merc-bucket-info* effect effect-idx use-mercneric) (the-as uint 0)) + (set! (-> *merc-bucket-info* effect effect-idx ignore-alpha) (the-as uint 0)) + (set! used-merc 1) + used-merc + ) + ) + + ;; HACK just use merc. + (when (logtest? *vu1-enable-user* (vu1-renderer-mask generic)) + (unless (logtest? (-> arg0 status) (draw-status needs-clip)) + (set! (-> *merc-bucket-info* effect effect-idx use-mercneric) (the-as uint 0)) + ) + (when (and (logtest? (-> arg0 status) (draw-status needs-clip)) ;; we need to clip + ;;(nonzero? (-> arg0 longest-edge)) ;; we known the longest edge + ;;(draw-bones-check-longest-edge-asm arg0 arg2) ;; it's ok to use percprime. + ) + (set! (-> *merc-bucket-info* effect effect-idx use-mercneric) (the-as uint 0)) + (set! (-> *merc-bucket-info* need-mercprime-if-merc) 1) + ) + ) + (set! effect-idx (+ effect-idx 1)) + ) ;; end effect loop + + ;; draw generic! + ;; note: this doesn't do the fully draw, there's some other stuff in process-drawable.gc to actually execute. + ;; TODO!! + ; (when (nonzero? used-mercneric) + ; (when (logtest? *vu1-enable-user* (vu1-renderer-mask generic)) + ; (set! (-> dma-buf base) (draw-bones-generic-merc arg0 matrix-data s2-0 0)) + ; (set! s2-0 (-> dma-buf base)) + ; ) + ; ) + + ;; draw shadow! + ;; TODO + ; (when (-> arg0 shadow) + ; (when #t + ; (set! s2-0 (draw-bones-shadow arg0 matrix-data s2-0)) + ; (set! (-> dma-buf base) (the-as pointer s2-0)) + ; ) + ; ) + + ;; draw merc! + + (set! used-merc 1) + (when (nonzero? used-merc) + (when (logtest? *vu1-enable-user* (vu1-renderer-mask merc)) + (when (= (-> arg0 cur-lod) (-> arg0 lod-set max-lod)) + (let ((f0-13 (- (-> arg0 lod-set lod (-> arg0 cur-lod) dist) arg2))) + (when (< f0-13 81920.0) + (when (zero? (logand (-> geom effect 0 effect-bits) 2)) + (let* ((a1-25 (the int (* 0.0015625 f0-13))) + (v1-147 (min 128 (max 0 a1-25))) + (a0-56 (-> *merc-bucket-info* light)) + ) + (set! (-> a0-56 direction 1 w) 0.000000000000000000000000000000000000011755084) + (set! (-> a0-56 direction 2 w) (the-as float v1-147)) + ) + 0 + ) + ) + ) + ) + (if (nonzero? (-> *merc-bucket-info* need-mercprime-if-merc)) + (set! (-> dma-buf base) (draw-bones-merc arg0 matrix-data s2-0 32 17)) + (set! (-> dma-buf base) (draw-bones-merc arg0 matrix-data s2-0 35 20)) + ) + (set! s2-0 (-> dma-buf base)) + ) + ) + ) ;; end geom processing + + ;; advance death timer. + (when (nonzero? (-> arg0 death-timer)) + (when (not (paused?)) + (+! (-> arg0 death-timer) -1) + (if (>= (the-as uint 1) (-> arg0 death-timer)) + (send-event (-> arg0 process) 'death-end arg0) + ) + ) + ) + ) + (let ((v1-164 (logand (the-as int s2-0) 48))) + 0 + (b! (zero? v1-164) cfg-83 :delay (set! a0-62 #x20000000)) + ;;(s.q! s2-0 a0-62) + (set! (-> (the (pointer uint128) s2-0) 0) (the uint128 a0-62)) + (let ((a0-63 s2-0)) + (set! s2-0 (+ (- (the-as int s2-0) v1-164) 64)) + ;;(s.w! (+ a0-63 4) (the-as int s2-0)) + (set! (-> (the (pointer int32) (+ (the-as uint a0-63) 4))) (the-as int s2-0)) + ) + ) + (label cfg-83) + (set! (-> dma-buf base) (the-as pointer (logand (the-as uint s2-0) (the-as uint #xfffffff)))) + ) + ) + ) + 0 + (none) + ) + ) + (defun draw-bones-hud ((arg0 draw-control) (arg1 dma-buffer)) - ;; hack (none) ) -(define-extern draw-bones-hud (function draw-control dma-buffer none)) \ No newline at end of file + +(define-extern draw-bones-hud (function draw-control dma-buffer none)) diff --git a/goal_src/engine/data/art-h.gc b/goal_src/engine/data/art-h.gc index 52616ee3ed..17e5be8177 100644 --- a/goal_src/engine/data/art-h.gc +++ b/goal_src/engine/data/art-h.gc @@ -246,7 +246,7 @@ (defenum draw-status :type uint8 :bitfield #t - (drwf00 0) + (needs-clip 0) (drwf01 1) (drwf02 2) (drwf03 3) diff --git a/goal_src/engine/dma/dma-h.gc b/goal_src/engine/dma/dma-h.gc index 39239ebe82..e5be55366b 100644 --- a/goal_src/engine/dma/dma-h.gc +++ b/goal_src/engine/dma/dma-h.gc @@ -222,9 +222,7 @@ (tfrag-near-0 7) (tie-near-0 8) (tie-0 9) - ;; merc0 10 - ;; generic0 11 - (bucket-10 10) + (bucket-10 10) ;; merc (bucket-11 11) (tfrag-tex1 12) @@ -234,7 +232,7 @@ (tie-1 16) ;; merc1 17 ;; generic1 18 - (bucket-17 17) + (bucket-17 17) ;; merc (bucket-18 18) (shrub-tex0 19) @@ -259,31 +257,31 @@ (tfrag-ice-near-1 44) - (bucket-45 45) + (bucket-45 45) ;; merc (bucket-46 46) (pris-tex0 48) - (bucket-49 49) + (bucket-49 49) ;; merc (bucket-50 50) ;; merc0 49 ;; generic0 50 (pris-tex1 51) - (bucket-52 52) + (bucket-52 52) ;; merc (bucket-53 53) ;; merc1 52 ;; generic1 53 - (bucket-55 55) + (bucket-55 55) ;; merc (bucket-56 56) (water-tex0 57) - (bucket-58 58) + (bucket-58 58) ;; merc (bucket-59 59) ;; merc0 58 (+ default) ;; generic0 59 (+ default) (water-tex1 60) - (bucket-61 61) + (bucket-61 61) ;; merc (bucket-62 62) (bucket-63 63) ; ocean ;; merc1 61 diff --git a/goal_src/engine/draw/drawable.gc b/goal_src/engine/draw/drawable.gc index 053df56985..64cbe43e15 100644 --- a/goal_src/engine/draw/drawable.gc +++ b/goal_src/engine/draw/drawable.gc @@ -11,8 +11,35 @@ ) (defun guard-band-cull ((arg0 vector)) - #t - ;; todo + (local-vars (v1-0 uint128) (v1-1 uint128) (v1-2 uint128)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf10 :class vf) + (vf20 :class vf) + (vf21 :class vf) + (vf22 :class vf) + (vf23 :class vf) + (vf9 :class vf) + ) + (init-vf0-vector) + ;; NOTE: manually added + (let ((at-0 *math-camera*)) + (.lvf vf20 (&-> at-0 guard-plane 0 quad)) + (.lvf vf21 (&-> at-0 guard-plane 1 quad)) + (.lvf vf22 (&-> at-0 guard-plane 2 quad)) + (.lvf vf23 (&-> at-0 guard-plane 3 quad)) + ) + (.lvf vf10 (&-> arg0 quad)) + (.mul.x.vf acc vf20 vf10) + (.add.mul.y.vf acc vf21 vf10 acc) + (.add.mul.z.vf acc vf22 vf10 acc) + (.sub.mul.w.vf vf9 vf23 vf0 acc) + (.sub.w.vf vf9 vf9 vf10) + (.mov v1-0 vf9) + (.pcgtw v1-1 0 v1-0) + (.ppach v1-2 (the-as uint128 0) v1-1) + (nonzero? (the-as int v1-2)) + ) ) (defun sphere-in-view-frustum? ((arg0 sphere)) @@ -714,8 +741,8 @@ ) ) (if (or (guard-band-cull s4-0) (< cam-dist (* 1.2 (-> *math-camera* d)))) - (logior! (-> arg1 status) (draw-status drwf00)) - (logclear! (-> arg1 status) (draw-status drwf00)) + (logior! (-> arg1 status) (draw-status needs-clip)) + (logclear! (-> arg1 status) (draw-status needs-clip)) ) (logior! (-> arg1 status) (draw-status drwf03)) (if (logtest? (-> arg1 status) (draw-status drwf05)) @@ -903,7 +930,7 @@ ;; tfrag ;; note: PC port uses preconverted tfrag textures. - (#unless PC_PORT + ; (#unless PC_PORT (when (logtest? *texture-enable-user* 1) (dotimes (gp-1 (-> *level* length)) (let ((a1-2 (-> *level* level gp-1))) @@ -913,7 +940,7 @@ ) ) ) - ) + ; ) ;; pris diff --git a/goal_src/engine/draw/process-drawable.gc b/goal_src/engine/draw/process-drawable.gc index e241cb910f..dfb1c67f34 100644 --- a/goal_src/engine/draw/process-drawable.gc +++ b/goal_src/engine/draw/process-drawable.gc @@ -361,7 +361,7 @@ ) ) ) - (draw-bone-lines obj) + ; (draw-bone-lines obj) ;; (draw-joint-spheres obj) 0 @@ -949,9 +949,9 @@ (logior! (-> obj draw status) (draw-status drwf02)) ) ) - ; (if (logtest? (-> obj skel status) 72) - ; (merc-blend-shape obj) - ; ) + (if (logtest? (-> obj skel status) 72) + (merc-blend-shape obj) + ) ; (if (logtest? (-> obj skel status) 384) ; (merc-eye-anim obj) ; ) diff --git a/goal_src/engine/game/main.gc b/goal_src/engine/game/main.gc index b11568a674..fabc3564c6 100644 --- a/goal_src/engine/game/main.gc +++ b/goal_src/engine/game/main.gc @@ -583,7 +583,7 @@ (display-sync disp) (swap-display disp) (free-all-prim-nodes *touching-list*) - ;; bler init + (blerc-init) ;; collide dma (suspend) @@ -592,9 +592,9 @@ ;; start immediately after all process updates finish. ;; drawing effects to be used in foreground drawing. - ; (blerc-execute) - ; (blerc-init) - ; (texscroll-execute) + (blerc-execute) + (blerc-init) + (texscroll-execute) ; (ripple-execute) ;;;;;;;;;;;;;;;;;;;; diff --git a/goal_src/engine/gfx/merc/merc-blend-shape.gc b/goal_src/engine/gfx/merc/merc-blend-shape.gc index 4126b99a4b..208eabe063 100644 --- a/goal_src/engine/gfx/merc/merc-blend-shape.gc +++ b/goal_src/engine/gfx/merc/merc-blend-shape.gc @@ -116,10 +116,145 @@ ;; todo merc-dma-chain-to-spr (unused) ;; todo blerc-execute +(def-mips2c blerc-execute (function none)) + +(define-extern setup-blerc-chains (function merc-ctrl (pointer int16) dma-buffer none)) ;; todo merc-blend-shape -(defun merc-blend-shape ((a process-drawable)) - (the object #f) +(defun merc-blend-shape ((arg0 process-drawable)) + (let* ((v1-2 (-> arg0 skel root-channel 0)) + (a3-0 (-> v1-2 frame-group)) + ) + (when (and a3-0 + (> (-> arg0 skel active-channels) 0) + (zero? (-> arg0 draw cur-lod)) + (logtest? (-> arg0 skel status) 8) + ) + (let ((a1-4 (-> a3-0 blerc-data))) + (when a1-4 + (let* ((a0-10 (-> arg0 draw mgeo)) + (a2-0 (-> a0-10 header blend-target-count)) + (t0-0 (-> v1-2 frame-num)) + (t1-0 (the int t0-0)) + (v1-4 (&+ a1-4 (* (the-as uint t1-0) a2-0))) + (a1-5 (new 'stack-no-clear 'array 'int16 128)) + ) + (let ((a2-1 (-> a0-10 header blend-target-count))) + (cond + ((< t1-0 (+ (-> a3-0 data 0 length) -1)) + (let* ((a3-5 (&+ v1-4 a2-1)) + (t0-1 (* 64.0 (- t0-0 (the float t1-0)))) + (t1-1 (- 64.0 t0-1)) + ) + (dotimes (t2-0 (the-as int a2-1)) + (set! (-> a1-5 t2-0) + (the int (+ (* (the float (+ (-> v1-4 t2-0) -64)) t1-1) (* (the float (+ (-> a3-5 t2-0) -64)) t0-1))) + ) + ) + ) + ) + (else + (dotimes (a3-6 (the-as int a2-1)) + (set! (-> a1-5 a3-6) (the-as int (* (+ (-> v1-4 a3-6) -64) 64))) + ) + ) + ) + ) + (setup-blerc-chains a0-10 a1-5 (-> *display* frames (-> *display* on-screen) frame global-buf)) + ) + (logior! (-> arg0 skel status) 64) + (return (the-as object #f)) + ) + ) + ) + ) + (when (logtest? (-> arg0 skel status) 64) + (set! (-> arg0 skel status) (logand -65 (-> arg0 skel status))) + (setup-blerc-chains + (-> arg0 draw lod-set lod 0 geo) + (new 'static 'array int16 32 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (-> *display* frames (-> *display* on-screen) frame global-buf) + ) + ) + 0 ) -;; todo setup-blerc-chains \ No newline at end of file +;; TODO setup-blerc-chains-for-one-fragment +(def-mips2c setup-blerc-chains-for-one-fragment (function object object object object object object object)) + +(defun setup-blerc-chains ((arg0 merc-ctrl) (arg1 (pointer int16)) (arg2 dma-buffer)) + (local-vars + (sv-16 uint) + (sv-20 pointer) + (sv-24 merc-effect) + (sv-28 uint) + (sv-32 object) + (sv-48 int) + (sv-64 int) + ) + ;; (format 0 "chain setup ctrl ~X array ~X~%" arg0 arg1) + (set! sv-16 (-> arg0 header effect-count)) + (let ((s3-0 (-> arg0 header blend-target-count)) + (v1-1 (-> arg2 base)) + ) + (set! sv-20 (&+ v1-1 0)) + (let ((a2-1 (the-as object (&+ v1-1 16)))) + (if (zero? (-> *blerc-globals* first)) + (set! (-> *blerc-globals* first) (the-as uint a2-1)) + ) + (dotimes (s2-0 (the-as int sv-16)) + ; (format 0 "BLERC CHAIN AT ~X~%" a2-1) + + (set! sv-24 (-> arg0 effect s2-0)) + (set! sv-28 (-> sv-24 blend-frag-count)) + ;; (format 0 " blend frags: ~D~%" sv-28) + (when (nonzero? sv-28) + (let ((v1-15 (the-as object (-> sv-24 frag-geo))) + (s1-0 (the-as structure (-> sv-24 frag-ctrl))) + (s0-0 (the-as object (-> sv-24 blend-data))) + ) + (set! sv-32 (-> sv-24 blend-ctrl)) + (set! sv-48 0) + (while (< sv-48 (the-as int sv-28)) + ;; (format 0 " [~D] loc: ~X~%" sv-48 s0-0) + + (set! sv-64 (+ (the-as int v1-15) + (logand (* (+ (-> (the-as merc-fragment-control s1-0) unsigned-four-count) 3) 4) #xfff0) + ) + ) + (if (nonzero? (-> (the-as (pointer uint8) sv-32) 0)) + (set! a2-1 (setup-blerc-chains-for-one-fragment s3-0 arg1 a2-1 s0-0 sv-32 sv-64)) + ) + (let ((a0-14 (logand (+ (* (the-as uint 6) (-> (the-as merc-blend-ctrl sv-32) blend-vtx-count)) 15) #xfff0))) + (set! v1-15 + (+ sv-64 + (logand (* (+ (-> (the-as merc-fragment-control s1-0) lump-four-count) 3) 4) #xfff0) + (* (-> (the-as merc-fragment-control s1-0) fp-qwc) 16) + ) + ) + (set! s1-0 (&+ s1-0 (* (-> (the-as merc-fragment-control s1-0) mat-xfer-count) 2) 4)) + (set! s0-0 + (+ (the-as int s0-0) (* (the-as uint a0-14) (+ (-> (the-as merc-blend-ctrl sv-32) nonzero-index-count) 1))) + ) + ) + (set! sv-32 (+ (the-as int sv-32) s3-0 2)) + (the-as int sv-32) + (set! sv-48 (+ sv-48 1)) + ;; (format 0 "~%") + ) + ) + ) + ) + (set! (-> (the-as (pointer int64) sv-20)) (logior #x20000000 (shr (shl (the-as int a2-1) 33) 1))) + (let ((v1-33 (the-as (pointer uint32) sv-20))) + (set! (-> (&+ v1-33 8)) 0) + ) + (let ((v1-34 (the-as (pointer uint32) sv-20))) + (set! (-> (&+ v1-34 12)) 0) + ) + (set! (-> arg2 base) (the-as pointer a2-1)) + ) + ) + 0 + (none) + ) \ No newline at end of file diff --git a/goal_src/engine/gfx/merc/merc.gc b/goal_src/engine/gfx/merc/merc.gc index 07cbfc6e4b..3d6602c2d2 100644 --- a/goal_src/engine/gfx/merc/merc.gc +++ b/goal_src/engine/gfx/merc/merc.gc @@ -499,7 +499,6 @@ (&+ v1-20 16) ) ) - (none) ) @@ -520,7 +519,7 @@ ) ;; set the beginning to be the merc init stuff. (set! (-> dma-buf base) - (the-as pointer (merc-vu1-initialize-chain (the-as dma-gif-packet (-> dma-buf base))) ) + (the-as pointer (merc-vu1-initialize-chain (the-as dma-gif-packet (-> dma-buf base)))) ) ;; some other merc setup for the GS. (let* ((v1-8 dma-buf) diff --git a/goal_src/engine/gfx/texture.gc b/goal_src/engine/gfx/texture.gc index 342b44a9f9..1432923c1a 100644 --- a/goal_src/engine/gfx/texture.gc +++ b/goal_src/engine/gfx/texture.gc @@ -1065,6 +1065,13 @@ (dma-buffer-add-gs-set dma-buf (texflush 1) ) + + (#when PC_PORT + (dma-buffer-add-cnt-vif2 dma-buf 1 (new 'static 'vif-tag :cmd (vif-cmd pc-port)) (the-as vif-tag 3)) + (dma-buffer-add-uint64 dma-buf page) + (dma-buffer-add-uint64 dma-buf -1) + ) + ) (shl total-upload-size 14) ) diff --git a/goal_src/engine/gfx/time-of-day.gc b/goal_src/engine/gfx/time-of-day.gc index 027e4444d1..3ede73cae4 100644 --- a/goal_src/engine/gfx/time-of-day.gc +++ b/goal_src/engine/gfx/time-of-day.gc @@ -287,7 +287,7 @@ (set! (-> arg0 sky) #f) (set! (-> arg0 target-interp) 0.0) ;; TODO re-enable - #| + (when *target* (set! (-> *target* draw light-index) (the-as uint 0)) (when (-> *target* sidekick) @@ -295,7 +295,7 @@ 0 ) ) - |# + ;; see if either level gives us a sky. (dotimes (v1-12 (-> *level* length)) @@ -573,7 +573,7 @@ (set! (-> *math-camera* fog-min) (-> arg0 current-fog fog-dists w)) ;; interp target lights. - (let* ((v1-195 0 #|(-> *target* draw light-index)|#) ;; TODO + (let* ((v1-195 0 (-> *target* draw light-index)) ;; TODO (f30-1 (-> arg0 target-interp)) (s4-6 (-> arg0 light-group)) (s5-2 (-> arg0 light-group v1-195)) diff --git a/goal_src/engine/target/logic-target.gc b/goal_src/engine/target/logic-target.gc index b877b783ec..c1e1da5b38 100644 --- a/goal_src/engine/target/logic-target.gc +++ b/goal_src/engine/target/logic-target.gc @@ -2104,8 +2104,6 @@ (set! *target* #f) ) ) - ;; hack added. - (set! *display-target-marks* #t) *target* ) diff --git a/goal_src/engine/target/sidekick.gc b/goal_src/engine/target/sidekick.gc index b41313c594..40439e366c 100644 --- a/goal_src/engine/target/sidekick.gc +++ b/goal_src/engine/target/sidekick.gc @@ -208,9 +208,9 @@ (TODO-RENAME-9 a0-26) ) ) - ; (if (logtest? (-> self skel status) 72) - ; (merc-blend-shape self) - ; ) + (if (logtest? (-> self skel status) 72) + (merc-blend-shape self) + ) ; (if (logtest? (-> self skel status) 384) ; (merc-eye-anim self) ; ) diff --git a/test/decompiler/reference/engine/draw/drawable_REF.gc b/test/decompiler/reference/engine/draw/drawable_REF.gc index 61e31b2b7f..208f564ad8 100644 --- a/test/decompiler/reference/engine/draw/drawable_REF.gc +++ b/test/decompiler/reference/engine/draw/drawable_REF.gc @@ -792,8 +792,8 @@ ) ) (if (or (guard-band-cull s4-0) (< cam-dist (* 1.2 (-> *math-camera* d)))) - (logior! (-> arg1 status) (draw-status drwf00)) - (logclear! (-> arg1 status) (draw-status drwf00)) + (logior! (-> arg1 status) (draw-status needs-clip)) + (logclear! (-> arg1 status) (draw-status needs-clip)) ) (logior! (-> arg1 status) (draw-status drwf03)) (if (logtest? (-> arg1 status) (draw-status drwf05)) diff --git a/test/decompiler/reference/engine/entity/entity_REF.gc b/test/decompiler/reference/engine/entity/entity_REF.gc index 8438023e49..93775139f9 100644 --- a/test/decompiler/reference/engine/entity/entity_REF.gc +++ b/test/decompiler/reference/engine/entity/entity_REF.gc @@ -1061,7 +1061,7 @@ ) ) (when (and *display-actor-vis* *display-actor-anim*) - (let ((s5-3 (entity-by-name (the-as string *display-actor-anim*)))) + (let ((s5-3 (entity-by-name *display-actor-anim*))) (when s5-3 (let ((v0-35 (res-lump-data s5-3 'visvol pointer)) (a1-31 (-> s5-3 extra vis-id)) diff --git a/test/decompiler/reference/engine/game/main-h_REF.gc b/test/decompiler/reference/engine/game/main-h_REF.gc index 7d3b00afb5..23c7eec801 100644 --- a/test/decompiler/reference/engine/game/main-h_REF.gc +++ b/test/decompiler/reference/engine/game/main-h_REF.gc @@ -193,8 +193,8 @@ ;; definition for symbol *display-water-marks*, type symbol (define *display-water-marks* #f) -;; definition for symbol *display-actor-anim*, type symbol -(define *display-actor-anim* #f) +;; definition for symbol *display-actor-anim*, type string +(define *display-actor-anim* (the-as string #f)) ;; definition for symbol *display-process-anim*, type (pointer process) (define *display-process-anim* (the-as (pointer process) #f)) diff --git a/test/decompiler/reference/engine/gfx/merc/merc_REF.gc b/test/decompiler/reference/engine/gfx/merc/merc_REF.gc index 1dceac84c0..a4b794d530 100644 --- a/test/decompiler/reference/engine/gfx/merc/merc_REF.gc +++ b/test/decompiler/reference/engine/gfx/merc/merc_REF.gc @@ -385,7 +385,6 @@ ) ;; definition for function merc-vu1-initialize-chain -;; INFO: Return type mismatch dma-packet vs none. ;; Used lq/sq (defun merc-vu1-initialize-chain ((arg0 dma-gif-packet)) (let ((gp-0 (the-as object (merc-vu1-add-vu-function (the-as dma-packet arg0) merc-vu1-block 1)))) @@ -421,7 +420,6 @@ (&+ v1-20 16) ) ) - (none) ) ;; definition for function merc-vu1-init-buffer diff --git a/test/decompiler/test_VuDisasm.cpp b/test/decompiler/test_VuDisasm.cpp index 15c6bb9933..6122237a7a 100644 --- a/test/decompiler/test_VuDisasm.cpp +++ b/test/decompiler/test_VuDisasm.cpp @@ -159,4 +159,18 @@ TEST(VuDisasm, Merc) { VuDisassembler disasm(VuDisassembler::VuKind::VU1); auto prog = disasm.disassemble(data.data(), data.size() * 4, false); EXPECT_EQ(disasm.to_string(prog), get_expected("merc")); +} + +TEST(VuDisasm, MercToC) { + auto data = get_test_data("merc"); + VuDisassembler disasm(VuDisassembler::VuKind::VU1); + disasm.add_label_with_name(0x1a1, "JUMP_1A1"); + disasm.add_label_with_name(0x48e, "JUMP_48E"); + disasm.add_label_with_name(0x539, "JUMP_539"); + disasm.add_label_with_name(0x243, "JUMP_243"); + disasm.add_label_with_name(20, "ENTER_20"); + disasm.add_label_with_name(35, "ENTER_35"); + auto prog = disasm.disassemble(data.data(), data.size() * 4, false); + // fmt::print("{}\n", disasm.to_string_with_cpp(prog)); + // EXPECT_EQ(disasm.to_string_with_cpp(prog), get_expected("merc")); } \ No newline at end of file