WIP

Author: Grarak

src/jit/emitter/emit.rs

@@ -18,7 +18,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),

src/jit/emitter/emit_branch.rs

@@ -113,19 +113,35 @@ 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();
+
+        self.emit_flush_cycles(
+            block_asm,
+            0,
+            |asm, block_asm| {
+                
+            },
+            |asm, block_asm| {
+                block_asm.mov(Reg::PC, branch_to);
+                block_asm.save_context();
+                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/jit_asm.rs

@@ -136,20 +136,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 +177,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) };

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);