WIP

Grarak · Grarak · commit af82fd0e15e9 · 2024-10-02T20:58:33.000+02:00
diff --git a/src/jit/assembler/block_asm.rs b/src/jit/assembler/block_asm.rs
@@ -513,7 +513,7 @@ impl<'a> BlockAsm<'a> {
 
             if let BlockInst::Label { label, guest_pc } = self.buf.insts[i] {
                 if let Some((p_label, p_guest_pc)) = previous_label {
-                    let replace_guest_pc = p_guest_pc.or_else(|| guest_pc);
+                    let replace_guest_pc = p_guest_pc.or(guest_pc);
                     previous_label = Some((p_label, replace_guest_pc));
                     let previous_node = BlockInstList::deref(current_node).previous;
                     let previous_i = BlockInstList::deref(previous_node).value;
@@ -559,6 +559,7 @@ impl<'a> BlockAsm<'a> {
             }
         }
         if cycle {
+            println!("ordering {block_i} cycle");
             ordering[*ordering_end] = block_i;
             *ordering_end -= 1;
         } else {
@@ -671,11 +672,9 @@ impl<'a> BlockAsm<'a> {
             let mut current_node = basic_block.block_entry_start;
             while !current_node.is_null() {
                 match &self.buf.insts[BlockInstList::deref(current_node).value] {
-                    BlockInst::Label { guest_pc, .. } => {
-                        if let Some(pc) = guest_pc {
-                            basic_block_start_pc = *pc;
-                            break;
-                        }
+                    BlockInst::Label { guest_pc: Some(pc), .. } => {
+                        basic_block_start_pc = *pc;
+                        break;
                     }
                     BlockInst::GuestPc(pc) => {
                         basic_block_start_pc = *pc;
@@ -753,6 +752,11 @@ impl<'a> BlockAsm<'a> {
 
         let mut reg_intervals = Self::assemble_intervals(&basic_blocks, &basic_blocks_order);
 
+        if unsafe { BLOCK_LOG } {
+            println!("reg intervals {reg_intervals:?} ");
+            println!("block ordering {basic_blocks_order:?}");
+        }
+
         self.buf.reg_allocator.global_mapping.clear();
         let mut free_regs = block_reg_allocator::ALLOCATION_REGS;
         while !free_regs.is_empty() {
diff --git a/src/jit/emitter/emit.rs b/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);
diff --git a/src/jit/emitter/emit_branch.rs b/src/jit/emitter/emit_branch.rs
@@ -1,11 +1,13 @@
+use crate::core::emu::get_jit;
 use crate::core::CpuType;
 use crate::core::CpuType::ARM9;
 use crate::jit::assembler::block_asm::BlockAsm;
+use crate::jit::assembler::BlockOperand;
 use crate::jit::inst_info::InstInfo;
-use crate::jit::jit_asm::JitAsm;
+use crate::jit::jit_asm::{JitAsm, JitRuntimeData, BLOCK_LINK_STACK_SIZE};
 use crate::jit::op::Op;
 use crate::jit::reg::{reg_reserve, Reg, RegReserve};
-use crate::jit::Cond;
+use crate::jit::{jit_memory_map, Cond, MemoryAmount, ShiftType};
 
 pub enum JitBranchInfo {
     Idle,
@@ -80,15 +82,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 +115,89 @@ 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| {
+                let block_link_ptr_reg = block_asm.new_reg();
+
+                block_asm.transfer_read(block_link_ptr_reg, runtime_data_addr_reg, JitRuntimeData::get_block_link_ptr_offset() as u32, false, MemoryAmount::Byte);
+
+                block_asm.cmp(block_link_ptr_reg, BLOCK_LINK_STACK_SIZE as u32);
+                block_asm.branch(breakout_label, Cond::EQ);
+
+                let block_link_stack_ptr_reg = block_asm.new_reg();
+                block_asm.add(block_link_stack_ptr_reg, runtime_data_addr_reg, JitRuntimeData::get_block_link_stack_offset() as u32);
+                block_asm.add(block_link_stack_ptr_reg, block_link_stack_ptr_reg, (block_link_ptr_reg.into(), ShiftType::Lsl, BlockOperand::from(3)));
+                block_asm.transfer_write(Reg::LR, block_link_stack_ptr_reg, 0, false, MemoryAmount::Word);
+
+                let return_pre_cycle_count_sum_reg = block_asm.new_reg();
+                block_asm.mov(return_pre_cycle_count_sum_reg, asm.jit_buf.insts_cycle_counts[asm.jit_buf.current_index] as u32);
+                block_asm.transfer_write(return_pre_cycle_count_sum_reg, block_link_stack_ptr_reg, 4, false, MemoryAmount::Half);
+
+                block_asm.add(block_link_ptr_reg, block_link_ptr_reg, 1);
+                block_asm.transfer_write(block_link_ptr_reg, runtime_data_addr_reg, JitRuntimeData::get_block_link_ptr_offset() as u32, false, MemoryAmount::Byte);
+
+                block_asm.free_reg(return_pre_cycle_count_sum_reg);
+                block_asm.free_reg(block_link_stack_ptr_reg);
+                block_asm.free_reg(block_link_ptr_reg);
+
+                let target_addr_reg = block_asm.new_reg();
+                block_asm.mov(target_addr_reg, (branch_to.into(), ShiftType::Lsr, BlockOperand::from(1)));
+
+                let map_ptr = get_jit!(asm.emu).jit_memory_map.get_map_ptr::<CPU>();
+
+                let map_ptr_reg = block_asm.new_reg();
+                let map_index_reg = block_asm.new_reg();
+                let map_entry_base_ptr_reg = block_asm.new_reg();
+
+                block_asm.mov(map_ptr_reg, map_ptr as u32);
+                block_asm.mov(map_index_reg, (target_addr_reg.into(), ShiftType::Lsr, BlockOperand::from(jit_memory_map::BLOCK_SHIFT as u32)));
+                block_asm.transfer_read(
+                    map_entry_base_ptr_reg,
+                    map_ptr_reg,
+                    (map_index_reg.into(), ShiftType::Lsl, BlockOperand::from(2)),
+                    false,
+                    MemoryAmount::Word,
+                );
+                block_asm.bfc(target_addr_reg, jit_memory_map::BLOCK_SHIFT as u8, 32 - jit_memory_map::BLOCK_SHIFT as u8);
+                block_asm.add(map_entry_base_ptr_reg, map_entry_base_ptr_reg, (target_addr_reg.into(), ShiftType::Lsl, BlockOperand::from(2)));
+
+                let entry_fn_reg = block_asm.new_reg();
+                block_asm.transfer_read(entry_fn_reg, map_entry_base_ptr_reg, 0, false, MemoryAmount::Word);
+                block_asm.call1(entry_fn_reg, 0);
+
+                block_asm.free_reg(entry_fn_reg);
+                block_asm.free_reg(map_entry_base_ptr_reg);
+                block_asm.free_reg(map_index_reg);
+                block_asm.free_reg(map_ptr_reg);
+                block_asm.free_reg(target_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;
diff --git a/src/jit/jit_asm.rs b/src/jit/jit_asm.rs
@@ -11,6 +11,7 @@ use crate::jit::reg::Reg;
 use crate::jit::reg::{reg_reserve, RegReserve};
 use crate::logging::debug_println;
 use crate::{get_jit_asm_ptr, DEBUG_LOG, DEBUG_LOG_BRANCH_OUT};
+use static_assertions::const_assert_eq;
 use std::cell::UnsafeCell;
 use std::{mem, ptr};
 
@@ -45,6 +46,17 @@ impl JitBuf {
     }
 }
 
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct JitBlockLinkData {
+    pub desired_lr: u32,
+    pub return_pre_cycle_count_sum: u16,
+}
+
+const_assert_eq!(size_of::<JitBlockLinkData>(), 8);
+
+pub const BLOCK_LINK_STACK_SIZE: usize = 32;
+
 #[repr(C)]
 pub struct JitRuntimeData {
     pub branch_out_pc: u32,
@@ -53,6 +65,8 @@ pub struct JitRuntimeData {
     pub accumulated_cycles: u16,
     pub idle_loop: bool,
     pub host_sp: usize,
+    pub block_link_ptr: u8,
+    pub block_link_stack: [JitBlockLinkData; BLOCK_LINK_STACK_SIZE],
 }
 
 impl JitRuntimeData {
@@ -64,18 +78,29 @@ impl JitRuntimeData {
             accumulated_cycles: 0,
             idle_loop: false,
             host_sp: 0,
+            block_link_ptr: 0,
+            block_link_stack: [JitBlockLinkData::default(); BLOCK_LINK_STACK_SIZE],
         };
+
         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 host_sp_ptr = ptr::addr_of!(instance.host_sp) as usize;
+        let block_link_ptr_ptr = ptr::addr_of!(instance.block_link_ptr) as usize;
+        let block_link_stack_ptr = ptr::addr_of!(instance.block_link_stack) 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!(host_sp_ptr - branch_out_pc_ptr, Self::get_host_sp_offset() as usize);
+        assert_eq!(block_link_ptr_ptr - branch_out_pc_ptr, Self::get_block_link_ptr_offset() as usize);
+        assert_eq!(block_link_stack_ptr - branch_out_pc_ptr, Self::get_block_link_stack_offset() as usize);
+
+        assert_eq!(size_of_val(&instance.block_link_stack), 32 * 8);
+
         instance
     }
 
@@ -106,6 +131,14 @@ impl JitRuntimeData {
     pub const fn get_host_sp_offset() -> u8 {
         Self::get_idle_loop_offset() + 2
     }
+
+    pub const fn get_block_link_ptr_offset() -> u8 {
+        Self::get_host_sp_offset() + 4
+    }
+
+    pub const fn get_block_link_stack_offset() -> u8 {
+        Self::get_block_link_ptr_offset() + 4
+    }
 }
 
 pub extern "C" fn emit_code_block<const CPU: CpuType>() {
@@ -144,20 +177,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 guest_regs_ptr = get_regs_mut!(asm.emu, CPU).get_reg_mut_ptr();
     let mut block_asm = unsafe { (*asm.block_asm_buf.get()).new_asm(guest_regs_ptr, ptr::addr_of_mut!((*asm).runtime_data.host_sp)) };
@@ -185,6 +218,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(bool) = unsafe { mem::transmute(insert_entry) };
@@ -218,6 +252,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(true);
diff --git a/src/jit/jit_memory.rs b/src/jit/jit_memory.rs
@@ -112,7 +112,7 @@ pub struct JitMemory {
     mem_offset: usize,
     jit_entries: JitEntries,
     jit_live_ranges: JitLiveRanges,
-    jit_memory_map: JitMemoryMap,
+    pub jit_memory_map: JitMemoryMap,
 }
 
 impl JitMemory {
@@ -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);
diff --git a/src/jit/jit_memory_map.rs b/src/jit/jit_memory_map.rs
@@ -3,7 +3,7 @@ use crate::core::CpuType;
 use crate::jit::jit_memory::{JitEntries, JitEntry, JitLiveRanges, JIT_LIVE_RANGE_PAGE_SIZE_SHIFT};
 use crate::utils::HeapMemU32;
 
-const BLOCK_SHIFT: usize = 13;
+pub const BLOCK_SHIFT: usize = 13;
 const BLOCK_SIZE: usize = 1 << BLOCK_SHIFT;
 const SIZE: usize = (1 << 31) / BLOCK_SIZE;
 const LIVE_RANGES_SIZE: usize = 1 << (32 - JIT_LIVE_RANGE_PAGE_SIZE_SHIFT - 5);
@@ -102,4 +102,11 @@ impl JitMemoryMap {
             CpuType::ARM7 => self.live_ranges_map_arm7[(addr >> (JIT_LIVE_RANGE_PAGE_SIZE_SHIFT + 5)) as usize] as _,
         }
     }
+
+    pub fn get_map_ptr<const CPU: CpuType>(&self) -> *const JitEntry {
+        match CPU {
+            CpuType::ARM9 => self.map_arm9.as_ptr() as _,
+            CpuType::ARM7 => self.map_arm7.as_ptr() as _,
+        }
+    }
 }
diff --git a/src/jit/mod.rs b/src/jit/mod.rs
@@ -14,9 +14,9 @@ mod inst_mem_handler;
 mod inst_threag_regs_handler;
 pub mod jit_asm;
 pub mod jit_memory;
+mod jit_memory_map;
 pub mod op;
 pub mod reg;
-mod jit_memory_map;
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 #[repr(u8)]

Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ pub struct JitMemory {`
`112`	`112`	`mem_offset: usize,`
`113`	`113`	`jit_entries: JitEntries,`
`114`	`114`	`jit_live_ranges: JitLiveRanges,`
`115`		`- jit_memory_map: JitMemoryMap,`
	`115`	`+ pub jit_memory_map: JitMemoryMap,`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`impl JitMemory {`
`@@ -154,7 +154,7 @@ impl JitMemory {`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`fn insert(&mut self, opcodes: &[u32]) -> (usize, usize) {`
`157`		`- let aligned_size = utils::align_up(opcodes.len() * size_of::<u32>(), *PAGE_SIZE);`
	`157`	`+ let aligned_size = utils::align_up(size_of_val(opcodes), *PAGE_SIZE);`
`158`	`158`	`let allocated_offset_addr = self.allocate_block(aligned_size);`
`159`	`159`
`160`	`160`	`utils::write_to_mem_slice(&mut self.mem, allocated_offset_addr, opcodes);`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ use crate::core::CpuType;`
`3`	`3`	`use crate::jit::jit_memory::{JitEntries, JitEntry, JitLiveRanges, JIT_LIVE_RANGE_PAGE_SIZE_SHIFT};`
`4`	`4`	`use crate::utils::HeapMemU32;`
`5`	`5`
`6`		`-const BLOCK_SHIFT: usize = 13;`
	`6`	`+pub const BLOCK_SHIFT: usize = 13;`
`7`	`7`	`const BLOCK_SIZE: usize = 1 << BLOCK_SHIFT;`
`8`	`8`	`const SIZE: usize = (1 << 31) / BLOCK_SIZE;`
`9`	`9`	`const LIVE_RANGES_SIZE: usize = 1 << (32 - JIT_LIVE_RANGE_PAGE_SIZE_SHIFT - 5);`
`@@ -102,4 +102,11 @@ impl JitMemoryMap {`
`102`	`102`	`CpuType::ARM7 => self.live_ranges_map_arm7[(addr >> (JIT_LIVE_RANGE_PAGE_SIZE_SHIFT + 5)) as usize] as _,`
`103`	`103`	`}`
`104`	`104`	`}`
	`105`	`+`
	`106`	`+ pub fn get_map_ptr<const CPU: CpuType>(&self) -> *const JitEntry {`
	`107`	`+ match CPU {`
	`108`	`+ CpuType::ARM9 => self.map_arm9.as_ptr() as _,`
	`109`	`+ CpuType::ARM7 => self.map_arm7.as_ptr() as _,`
	`110`	`+ }`
	`111`	`+ }`
`105`	`112`	`}`