WIP

Author: Grarak

src/jit/emitter/emit.rs

@@ -1,6 +1,7 @@
 use crate::core::CpuType;
 use crate::core::CpuType::ARM7;
 use crate::jit::assembler::block_asm::BlockAsm;
+use crate::jit::assembler::{BlockLabel, BlockReg};
 use crate::jit::inst_threag_regs_handler::{register_restore_spsr, restore_thumb_after_restore_spsr, set_pc_arm_mode};
 use crate::jit::jit_asm::{JitAsm, JitRuntimeData};
 use crate::jit::op::Op;
@@ -18,7 +19,8 @@ impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
         block_asm.start_cond_block(cond);
         match op {
             Op::B | Op::Bl => self.emit_branch_label(block_asm),
-            Op::Bx | Op::BlxReg => self.emit_branch_reg(block_asm),
+            Op::Bx => self.emit_bx(block_asm),
+            Op::BlxReg => self.emit_blx(block_asm),
             Op::Blx => self.emit_blx_label(block_asm),
             Op::Mcr | Op::Mrc => self.emit_cp15(block_asm),
             Op::MsrRc | Op::MsrIc | Op::MsrRs | Op::MsrIs => self.emit_msr(block_asm),
@@ -99,7 +101,7 @@ impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
         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)>(
+    pub fn emit_flush_cycles<ContinueFn: Fn(&mut Self, &mut BlockAsm, BlockLabel, BlockReg), BreakoutFn: Fn(&mut Self, &mut BlockAsm)>(
         &mut self,
         block_asm: &mut BlockAsm,
         target_pre_cycle_count_sum: u16,
@@ -155,7 +157,7 @@ impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
             false,
             MemoryAmount::Half,
         );
-        continue_fn(self, block_asm);
+        continue_fn(self, block_asm, breakout_label, runtime_data_addr_reg);
 
         block_asm.label(breakout_label);
         breakout_fn(self, block_asm);

src/jit/emitter/emit_branch.rs

@@ -80,15 +80,15 @@ impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
         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 target_pre_cycle_count_sum = if target_index == 0 { 0 } else { self.jit_buf.insts_cycle_counts[target_index] };
+            let target_pre_cycle_count_sum = self.jit_buf.insts_cycle_counts[target_index] - self.jit_buf.insts[target_index].cycle as u16;
 
             let backed_up_cpsr_reg = block_asm.new_reg();
             block_asm.mrs_cpsr(backed_up_cpsr_reg);
 
             self.emit_flush_cycles(
                 block_asm,
                 target_pre_cycle_count_sum,
-                |_, block_asm| {
+                |_, block_asm, _, _| {
                     block_asm.msr_cpsr(backed_up_cpsr_reg);
                     block_asm.guest_branch(Cond::AL, target_pc);
                 },
@@ -113,19 +113,37 @@ impl<'a, const CPU: CpuType> JitAsm<'a, CPU> {
         block_asm.epilogue();
     }
 
-    pub fn emit_branch_reg(&mut self, block_asm: &mut BlockAsm) {
+    pub fn emit_bx(&mut self, block_asm: &mut BlockAsm) {
         let inst_info = self.jit_buf.current_inst();
         let branch_to = *inst_info.operands()[0].as_reg_no_shift().unwrap();
 
-        if inst_info.op == Op::BlxReg {
-            block_asm.mov(Reg::LR, self.jit_buf.current_pc + 4);
-        }
         block_asm.mov(Reg::PC, branch_to);
         block_asm.save_context();
         self.emit_branch_out_metadata(block_asm);
         block_asm.epilogue();
     }
 
+    pub fn emit_blx(&mut self, block_asm: &mut BlockAsm) {
+        let inst_info = self.jit_buf.current_inst();
+        let branch_to = *inst_info.operands()[0].as_reg_no_shift().unwrap();
+
+        block_asm.mov(Reg::LR, self.jit_buf.current_pc + 4);
+        block_asm.mov(Reg::PC, branch_to);
+        block_asm.save_context();
+        
+        self.emit_flush_cycles(
+            block_asm,
+            0,
+            |asm, block_asm, breakout_label, runtime_data_addr_reg| {
+                
+            },
+            |asm, block_asm| {
+                asm.emit_branch_out_metadata(block_asm);
+                block_asm.epilogue();
+            },
+        );
+    }
+
     pub fn emit_blx_label(&mut self, block_asm: &mut BlockAsm) {
         if CPU != ARM9 {
             return;

src/jit/inst_branch_handler.rs

@@ -0,0 +1,8 @@
+use crate::core::CpuType;
+use crate::get_jit_asm_ptr;
+
+pub unsafe extern "C" fn block_link<const CPU: CpuType>(total_cycles: u16) {
+    let asm = get_jit_asm_ptr::<CPU>();
+    let runtime_data = &mut (*asm).runtime_data;
+    runtime_data.block_link_stack
+}

src/jit/jit_asm.rs

@@ -45,13 +45,21 @@ impl JitBuf {
     }
 }
 
+#[derive(Copy, Clone, Default)]
+pub struct JitBlockLinkData {
+    pub desired_lr: u32,
+    pub return_pre_cycle_count_sum: u16,
+}
+
 #[repr(C)]
 pub struct JitRuntimeData {
     pub branch_out_pc: u32,
     pub branch_out_total_cycles: u16,
     pub pre_cycle_count_sum: u16,
     pub accumulated_cycles: u16,
     pub idle_loop: bool,
+    pub block_link_ptr: u8,
+    pub block_link_stack: [JitBlockLinkData; 32],
 }
 
 impl JitRuntimeData {
@@ -62,16 +70,22 @@ impl JitRuntimeData {
             pre_cycle_count_sum: 0,
             accumulated_cycles: 0,
             idle_loop: false,
+            block_link_ptr: 0,
+            block_link_stack: [JitBlockLinkData::default(); 32],
         };
+
         let branch_out_pc_ptr = ptr::addr_of!(instance.branch_out_pc) as usize;
         let branch_out_total_cycles_ptr = ptr::addr_of!(instance.branch_out_total_cycles) as usize;
         let pre_cycle_count_sum_ptr = ptr::addr_of!(instance.pre_cycle_count_sum) as usize;
         let accumulated_cycles_ptr = ptr::addr_of!(instance.accumulated_cycles) as usize;
         let idle_loop_ptr = ptr::addr_of!(instance.idle_loop) as usize;
+        let block_link_ptr_ptr = ptr::addr_of!(instance.block_link_ptr) as usize;
+
         assert_eq!(branch_out_total_cycles_ptr - branch_out_pc_ptr, Self::get_out_total_cycles_offset() as usize);
         assert_eq!(pre_cycle_count_sum_ptr - branch_out_pc_ptr, Self::get_pre_cycle_count_sum_offset() as usize);
         assert_eq!(accumulated_cycles_ptr - branch_out_pc_ptr, Self::get_accumulated_cycles_offset() as usize);
         assert_eq!(idle_loop_ptr - branch_out_pc_ptr, Self::get_idle_loop_offset() as usize);
+        assert_eq!(block_link_ptr_ptr - branch_out_pc_ptr, Self::get_block_link_ptr_offset() as usize);
         instance
     }
 
@@ -98,6 +112,10 @@ impl JitRuntimeData {
     pub const fn get_idle_loop_offset() -> u8 {
         Self::get_accumulated_cycles_offset() + 2
     }
+
+    pub const fn get_block_link_ptr_offset() -> u8 {
+        Self::get_idle_loop_offset() + 1
+    }
 }
 
 pub extern "C" fn emit_code_block<const CPU: CpuType>() {
@@ -136,20 +154,20 @@ fn emit_code_block_internal<const CPU: CpuType, const THUMB: bool>(guest_pc: u32
                 assert!(asm.jit_buf.insts_cycle_counts.len() <= u16::MAX as usize, "{CPU:?} {guest_pc:x} {inst_info:?}")
             }
 
-            // let is_unreturnable_branch = !inst_info.out_regs.is_reserved(Reg::LR) && inst_info.is_uncond_branch() && !inst_info.op.is_labelled_branch();
-            let is_uncond_branch = inst_info.is_uncond_branch();
+            let is_unreturnable_branch = !inst_info.out_regs.is_reserved(Reg::LR) && inst_info.is_uncond_branch() && !inst_info.op.is_labelled_branch();
+            // let is_uncond_branch = inst_info.is_uncond_branch();
             let is_unknown = inst_info.op == Op::UnkArm || inst_info.op == Op::UnkThumb;
 
             asm.jit_buf.insts.push(inst_info);
 
             index += if THUMB { 2 } else { 4 };
-            if is_uncond_branch || is_unknown {
+            if is_unreturnable_branch || is_unknown {
                 break;
             }
         }
     }
 
-    // unsafe { BLOCK_LOG = true };
+    unsafe { BLOCK_LOG = true };
 
     let thread_regs = get_regs!(asm.emu, CPU);
     let mut block_asm = unsafe { (*asm.block_asm_buf.get()).new_asm(thread_regs, ptr::addr_of_mut!(asm.host_sp) as _) };
@@ -177,6 +195,7 @@ fn emit_code_block_internal<const CPU: CpuType, const THUMB: bool>(guest_pc: u32
         for &opcode in &opcodes {
             println!("0x{opcode:x},");
         }
+        todo!()
     }
     let insert_entry = get_jit_mut!(asm.emu).insert_block::<CPU>(&opcodes, guest_pc);
     let jit_entry: extern "C" fn() = unsafe { mem::transmute(insert_entry) };
@@ -210,6 +229,7 @@ fn execute_internal<const CPU: CpuType>(guest_pc: u32) -> u16 {
     }
     asm.runtime_data.pre_cycle_count_sum = 0;
     asm.runtime_data.accumulated_cycles = 0;
+    asm.runtime_data.block_link_ptr = 0;
     get_regs_mut!(asm.emu, CPU).cycle_correction = 0;
 
     jit_entry();

src/jit/jit_memory.rs

@@ -154,7 +154,7 @@ impl JitMemory {
     }
 
     fn insert(&mut self, opcodes: &[u32]) -> (usize, usize) {
-        let aligned_size = utils::align_up(opcodes.len() * size_of::<u32>(), *PAGE_SIZE);
+        let aligned_size = utils::align_up(size_of_val(opcodes), *PAGE_SIZE);
         let allocated_offset_addr = self.allocate_block(aligned_size);
 
         utils::write_to_mem_slice(&mut self.mem, allocated_offset_addr, opcodes);

src/jit/mod.rs

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