Simplify context loading

Grarak · Grarak · commit d3824efa58ea · 2024-11-03T09:08:27.000+01:00
diff --git a/src/jit/assembler/basic_block.rs b/src/jit/assembler/basic_block.rs
@@ -241,22 +241,17 @@ impl BasicBlock {
         }
     }
 
-    pub fn remove_dead_code(&mut self, asm: &BlockAsm) {
+    pub fn remove_dead_code(&mut self, asm: &mut BlockAsm) {
         let mut current_node = self.insts_link.root;
         let mut i = 0;
         while !current_node.is_null() {
             let inst_i = BlockInstList::deref(current_node).value;
-            let inst = &asm.buf.insts[inst_i];
+            let inst = &mut asm.buf.insts[inst_i];
             if let BlockInstKind::RestoreReg { guest_reg, .. } = &inst.kind {
                 if *guest_reg != Reg::CPSR {
                     let (_, outputs) = inst.get_io();
                     if (self.regs_live_ranges[i + 1] - outputs) == self.regs_live_ranges[i + 1] {
-                        let next_node = BlockInstList::deref(current_node).next;
-                        self.insts_link.remove_entry(current_node);
-                        current_node = next_node;
-                        self.regs_live_ranges.remove(i);
-                        self.used_regs.remove(i);
-                        continue;
+                        inst.skip = true;
                     }
                 }
             }
@@ -289,12 +284,15 @@ impl BasicBlock {
         let mut current_node = self.insts_link.root;
         while !current_node.is_null() {
             let inst_i = BlockInstList::deref(current_node).value;
-            asm.buf.reg_allocator.inst_allocate(&mut asm.buf.insts[inst_i], &self.regs_live_ranges[i..], &self.used_regs[i..]);
-            if !asm.buf.reg_allocator.pre_allocate_insts.is_empty() {
-                for i in asm.buf.insts.len()..asm.buf.insts.len() + asm.buf.reg_allocator.pre_allocate_insts.len() {
-                    self.insts_link.insert_entry_begin(current_node, i);
+            let inst = &mut asm.buf.insts[inst_i];
+            if !inst.skip {
+                asm.buf.reg_allocator.inst_allocate(inst, &self.regs_live_ranges[i..], &self.used_regs[i..]);
+                if !asm.buf.reg_allocator.pre_allocate_insts.is_empty() {
+                    for i in asm.buf.insts.len()..asm.buf.insts.len() + asm.buf.reg_allocator.pre_allocate_insts.len() {
+                        self.insts_link.insert_entry_begin(current_node, i);
+                    }
+                    asm.buf.insts.extend_from_slice(&asm.buf.reg_allocator.pre_allocate_insts);
                 }
-                asm.buf.insts.extend_from_slice(&asm.buf.reg_allocator.pre_allocate_insts);
             }
             i += 1;
             current_node = BlockInstList::deref(current_node).next;
@@ -323,6 +321,9 @@ impl BasicBlock {
         let mut inst_opcodes = Vec::new();
         for entry in self.insts_link.iter() {
             let inst = &mut asm.buf.insts[entry.value];
+            if inst.skip {
+                continue;
+            }
 
             if IS_DEBUG && unsafe { BLOCK_LOG } {
                 match &inst.kind {
diff --git a/src/jit/assembler/block_asm.rs b/src/jit/assembler/block_asm.rs
@@ -12,7 +12,7 @@ use crate::jit::{Cond, MemoryAmount, ShiftType};
 use crate::utils::{NoHashMap, NoHashSet};
 use crate::IS_DEBUG;
 use std::intrinsics::unlikely;
-use std::{ptr, slice};
+use std::slice;
 
 pub static mut BLOCK_LOG: bool = false;
 
@@ -58,7 +58,6 @@ pub struct BlockAsm<'a> {
 
     cond_block_end_label_stack: Vec<(BlockLabel, Cond, usize)>,
 
-    guest_reg_init_offset: Option<usize>,
     is_common_fun: bool,
     host_sp_ptr: *mut usize,
     block_start: usize,
@@ -94,7 +93,6 @@ impl<'a> BlockAsm<'a> {
 
             cond_block_end_label_stack: Vec::new(),
 
-            guest_reg_init_offset: None,
             is_common_fun,
             host_sp_ptr,
             block_start: 0,
@@ -117,7 +115,9 @@ impl<'a> BlockAsm<'a> {
 
         if !is_common_fun {
             instance.mov(thread_regs_addr_reg, guest_regs_ptr as u32);
-            instance.guest_reg_init_offset = Some(instance.buf.insts.len() - 1);
+            for guest_reg in RegReserve::gp() + Reg::SP + Reg::LR {
+                instance.restore_reg(guest_reg);
+            }
             instance.restore_reg(Reg::CPSR);
         }
 
@@ -921,72 +921,14 @@ impl<'a> BlockAsm<'a> {
             basic_block.remove_dead_code(self);
         }
 
-        if let Some(guest_regs_init_offset) = self.guest_reg_init_offset {
-            let required_guest_regs = basic_blocks[0].get_required_inputs().get_guests();
-            if !required_guest_regs.is_empty() {
-                let mut basic_block_i = 0;
-                let mut inst_i = 0;
-                let mut inst_entry = ptr::null_mut();
-
-                'basic_blocks_loop: for (i, basic_block) in basic_blocks.iter_mut().enumerate() {
-                    if !reachable_blocks.contains(&i) {
-                        continue;
-                    }
-
-                    for (j, entry) in basic_block.insts_link.iter().enumerate() {
-                        if entry.value == guest_regs_init_offset {
-                            basic_block_i = i;
-                            inst_i = j;
-                            inst_entry = entry as *const _ as *mut _;
-                            break 'basic_blocks_loop;
-                        }
-                    }
-                }
-
-                let basic_block = &mut basic_blocks[basic_block_i];
-                for i in 0..=inst_i {
-                    basic_block.regs_live_ranges[i].remove_guests(required_guest_regs);
-                }
-                let enter_blocks = unsafe { slice::from_raw_parts(basic_block.enter_blocks.as_ptr(), basic_block.enter_blocks.len()) };
-                Self::remove_guest_input_regs(&mut basic_blocks, required_guest_regs, enter_blocks);
-                let basic_block = &mut basic_blocks[basic_block_i];
-
-                let mut previous_guest_reg = None;
-                for (j, guest_reg) in required_guest_regs.into_iter().enumerate() {
-                    inst_entry = basic_block.insts_link.insert_entry_end(inst_entry, self.buf.insts.len());
-                    self.buf.insts.push(
-                        BlockInstKind::RestoreReg {
-                            guest_reg,
-                            reg_mapped: guest_reg.into(),
-                            thread_regs_addr_reg: self.thread_regs_addr_reg,
-                            tmp_guest_cpsr_reg: self.tmp_guest_cpsr_reg,
-                        }
-                        .into(),
-                    );
-                    let inst_index = inst_i + j + 1;
-
-                    let (inputs, outputs) = self.buf.insts.last().unwrap().get_io();
-                    basic_block.used_regs.insert(inst_index, inputs + outputs);
-
-                    let mut previous_regs_live_range = basic_block.regs_live_ranges[inst_index - 1];
-                    if let Some(previous_guest_reg) = previous_guest_reg {
-                        previous_regs_live_range += BlockReg::from(previous_guest_reg);
-                    }
-                    previous_regs_live_range += inputs;
-                    basic_block.regs_live_ranges.insert(inst_index, previous_regs_live_range);
-
-                    previous_guest_reg = Some(guest_reg);
-                }
-            }
-        }
-
         (basic_blocks, reachable_blocks)
     }
 
     pub fn emit_opcodes(&mut self, block_start_pc: u32, thumb: bool) -> usize {
         let (mut basic_blocks, reachable_blocks) = self.assemble_basic_blocks(block_start_pc, thumb);
 
-        if !basic_blocks[0].get_required_inputs().get_guests().is_empty() {
+        if IS_DEBUG && !basic_blocks[0].get_required_inputs().get_guests().is_empty() {
+            println!("inputs as requirement {:?}", basic_blocks[0].get_required_inputs().get_guests());
             unsafe { BLOCK_LOG = true };
         }
 
@@ -1090,7 +1032,11 @@ impl<'a> BlockAsm<'a> {
                 let branch_to = self.buf.block_opcode_offsets[block_index as usize];
                 branch_to as i32 - branch_placeholder as i32
             };
-            self.buf.opcodes[branch_placeholder] = if encoding.has_return() { B::bl } else { B::b }(diff - 2, Cond::from(u8::from(encoding.cond())));
+            if diff == 1 && !encoding.has_return() {
+                self.buf.opcodes[branch_placeholder] = AluShiftImm::mov_al(Reg::R0, Reg::R0);
+            } else {
+                self.buf.opcodes[branch_placeholder] = if encoding.has_return() { B::bl } else { B::b }(diff - 2, Cond::from(u8::from(encoding.cond())));
+            }
         }
 
         &self.buf.opcodes
diff --git a/src/jit/assembler/block_inst.rs b/src/jit/assembler/block_inst.rs
@@ -78,6 +78,7 @@ pub struct BlockInst {
     pub cond: Cond,
     pub kind: BlockInstKind,
     io_cache: RefCell<Option<(BlockRegSet, BlockRegSet)>>,
+    pub skip: bool,
 }
 
 impl BlockInst {
@@ -86,6 +87,7 @@ impl BlockInst {
             cond,
             kind,
             io_cache: RefCell::new(None),
+            skip: false,
         }
     }
 
@@ -129,7 +131,11 @@ impl From<BlockInstKind> for BlockInst {
 
 impl Debug for BlockInst {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?} {:?}", self.cond, self.kind)
+        if self.skip {
+            write!(f, "SKIPPED: {:?} {:?}", self.cond, self.kind)
+        } else {
+            write!(f, "{:?} {:?}", self.cond, self.kind)
+        }
     }
 }
 
diff --git a/src/jit/emitter/emit_transfer.rs b/src/jit/emitter/emit_transfer.rs
@@ -216,8 +216,6 @@ impl<const CPU: CpuType> JitAsm<'_, CPU> {
         }
         block_asm.restore_reg(Reg::CPSR);
 
-        block_asm.branch(continue_label, Cond::AL);
-
         block_asm.label(continue_label);
 
         block_asm.free_reg(fast_read_addr_masked_reg);

Original file line number	Diff line number	Diff line change
`@@ -78,6 +78,7 @@ pub struct BlockInst {`
`78`	`78`	`pub cond: Cond,`
`79`	`79`	`pub kind: BlockInstKind,`
`80`	`80`	`io_cache: RefCell<Option<(BlockRegSet, BlockRegSet)>>,`
	`81`	`+ pub skip: bool,`
`81`	`82`	`}`
`82`	`83`
`83`	`84`	`impl BlockInst {`
`@@ -86,6 +87,7 @@ impl BlockInst {`
`86`	`87`	`cond,`
`87`	`88`	`kind,`
`88`	`89`	`io_cache: RefCell::new(None),`
	`90`	`+ skip: false,`
`89`	`91`	`}`
`90`	`92`	`}`
`91`	`93`
`@@ -129,7 +131,11 @@ impl From<BlockInstKind> for BlockInst {`
`129`	`131`
`130`	`132`	`impl Debug for BlockInst {`
`131`	`133`	`fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {`
`132`		`- write!(f, "{:?} {:?}", self.cond, self.kind)`
	`134`	`+ if self.skip {`
	`135`	`+ write!(f, "SKIPPED: {:?} {:?}", self.cond, self.kind)`
	`136`	`+ } else {`
	`137`	`+ write!(f, "{:?} {:?}", self.cond, self.kind)`
	`138`	`+ }`
`133`	`139`	`}`
`134`	`140`	`}`
`135`	`141`
Original file line number	Diff line number	Diff line change
`@@ -216,8 +216,6 @@ impl<const CPU: CpuType> JitAsm<'_, CPU> {`
`216`	`216`	`}`
`217`	`217`	`block_asm.restore_reg(Reg::CPSR);`
`218`	`218`
`219`		`- block_asm.branch(continue_label, Cond::AL);`
`220`		`-`
`221`	`219`	`block_asm.label(continue_label);`
`222`	`220`
`223`	`221`	`block_asm.free_reg(fast_read_addr_masked_reg);`