Inline cycle flushes

Author: Grarak

src/jit/emitter/emit.rs

@@ -5,7 +5,7 @@ use crate::jit::inst_threag_regs_handler::{register_restore_spsr, restore_thumb_
 use crate::jit::jit_asm::{JitAsm, JitRuntimeData};
 use crate::jit::op::Op;
 use crate::jit::reg::Reg;
-use crate::jit::MemoryAmount;
+use crate::jit::{Cond, MemoryAmount};
 use crate::DEBUG_LOG_BRANCH_OUT;
 
 impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
@@ -98,4 +98,72 @@ impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
     pub fn emit_branch_out_metadata_with_idle_loop(&mut self, block_asm: &mut BlockAsm) {
         self._emit_branch_out_metadata(block_asm, true)
     }
+
+    pub fn emit_flush_cycles<ContinueFn: Fn(&mut Self, &mut BlockAsm), BreakoutFn: Fn(&mut Self, &mut BlockAsm)>(
+        &mut self,
+        block_asm: &mut BlockAsm,
+        target_pre_cycle_count_sum: u16,
+        continue_fn: ContinueFn,
+        breakout_fn: BreakoutFn,
+    ) {
+        let runtime_data_addr_reg = block_asm.new_reg();
+        block_asm.mov(runtime_data_addr_reg, self.runtime_data.get_addr() as u32);
+
+        let accumulated_cycles_reg = block_asm.new_reg();
+        block_asm.transfer_read(
+            accumulated_cycles_reg,
+            runtime_data_addr_reg,
+            JitRuntimeData::get_accumulated_cycles_offset() as u32,
+            false,
+            MemoryAmount::Half,
+        );
+
+        let pre_cycle_count_sum_reg = block_asm.new_reg();
+        block_asm.transfer_read(
+            pre_cycle_count_sum_reg,
+            runtime_data_addr_reg,
+            JitRuntimeData::get_pre_cycle_count_sum_offset() as u32,
+            false,
+            MemoryAmount::Half,
+        );
+
+        let total_cycles_reg = block_asm.new_reg();
+        // +2 for branching
+        block_asm.add(total_cycles_reg, accumulated_cycles_reg, self.jit_buf.insts_cycle_counts[self.jit_buf.current_index] as u32 + 2);
+        block_asm.sub(total_cycles_reg, total_cycles_reg, pre_cycle_count_sum_reg);
+
+        const MAX_LOOP_CYCLE_COUNT: u32 = 200;
+        block_asm.cmp(total_cycles_reg, MAX_LOOP_CYCLE_COUNT - 1);
+
+        let breakout_label = block_asm.new_label();
+        block_asm.branch(breakout_label, Cond::HI);
+
+        block_asm.transfer_write(
+            total_cycles_reg,
+            runtime_data_addr_reg,
+            JitRuntimeData::get_accumulated_cycles_offset() as u32,
+            false,
+            MemoryAmount::Half,
+        );
+
+        let target_pre_cycle_count_sum_reg = block_asm.new_reg();
+        block_asm.mov(target_pre_cycle_count_sum_reg, target_pre_cycle_count_sum as u32);
+        block_asm.transfer_write(
+            target_pre_cycle_count_sum_reg,
+            runtime_data_addr_reg,
+            JitRuntimeData::get_pre_cycle_count_sum_offset() as u32,
+            false,
+            MemoryAmount::Half,
+        );
+        continue_fn(self, block_asm);
+
+        block_asm.label(breakout_label);
+        breakout_fn(self, block_asm);
+
+        block_asm.free_reg(target_pre_cycle_count_sum_reg);
+        block_asm.free_reg(total_cycles_reg);
+        block_asm.free_reg(pre_cycle_count_sum_reg);
+        block_asm.free_reg(accumulated_cycles_reg);
+        block_asm.free_reg(runtime_data_addr_reg);
+    }
 }

src/jit/emitter/emit_branch.rs

@@ -1,8 +1,6 @@
 use crate::core::CpuType;
 use crate::core::CpuType::ARM9;
 use crate::jit::assembler::block_asm::BlockAsm;
-use crate::jit::assembler::BlockReg;
-use crate::jit::inst_branch_handler::branch_label_flush_cycles;
 use crate::jit::inst_info::InstInfo;
 use crate::jit::jit_asm::JitAsm;
 use crate::jit::op::Op;
@@ -79,30 +77,29 @@ impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
             block_asm.save_context();
         };
 
-        let branch_info = Self::analyze_branch_label::<THUMB>(&self.jit_buf.insts, self.jit_buf.current_index, self.jit_buf.current_inst().cond, self.jit_buf.current_pc, target_pc);
+        let branch_info = Self::analyze_branch_label::<THUMB>(&self.jit_buf.insts, self.jit_buf.current_index, cond, self.jit_buf.current_pc, target_pc);
 
         if let JitBranchInfo::Local(target_index) = branch_info {
-            let current_total_cycles = self.jit_buf.insts_cycle_counts[self.jit_buf.current_index];
             let target_pre_cycle_count_sum = if target_index == 0 { 0 } else { self.jit_buf.insts_cycle_counts[target_index] };
 
             let backed_up_cpsr_reg = block_asm.new_reg();
             block_asm.mrs_cpsr(backed_up_cpsr_reg);
 
-            block_asm.call2(branch_label_flush_cycles::<CPU> as *const (), current_total_cycles as u32, target_pre_cycle_count_sum as u32);
-            block_asm.cmp(BlockReg::Fixed(Reg::R0), 1);
-
-            let breakout_label = block_asm.new_label();
-            block_asm.branch(breakout_label, Cond::EQ);
-
-            block_asm.msr_cpsr(backed_up_cpsr_reg);
-            block_asm.guest_branch(Cond::AL, target_pc);
-
-            block_asm.label(breakout_label);
-            block_asm.msr_cpsr(backed_up_cpsr_reg);
-
-            commit_target_pc(block_asm);
-            self.emit_branch_out_metadata(block_asm);
-            block_asm.epilogue();
+            self.emit_flush_cycles(
+                block_asm,
+                target_pre_cycle_count_sum,
+                |_, block_asm| {
+                    block_asm.msr_cpsr(backed_up_cpsr_reg);
+                    block_asm.guest_branch(Cond::AL, target_pc);
+                },
+                |asm, block_asm| {
+                    block_asm.msr_cpsr(backed_up_cpsr_reg);
+
+                    commit_target_pc(block_asm);
+                    asm.emit_branch_out_metadata(block_asm);
+                    block_asm.epilogue();
+                },
+            );
 
             block_asm.free_reg(backed_up_cpsr_reg);
             return;

src/jit/inst_branch_handler.rs

@@ -16,7 +16,6 @@ pub mod jit_asm;
 pub mod jit_memory;
 pub mod op;
 pub mod reg;
-mod inst_branch_handler;
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 #[repr(u8)]