Simplify cpsr store

Author: Grarak

src/jit/assembler/basic_block.rs

@@ -79,25 +79,18 @@ impl BasicBlock {
                                     guest_reg,
                                     reg_mapped: if guest_reg == Reg::PC { last_pc_reg } else { guest_reg.into() },
                                     thread_regs_addr_reg,
-                                    tmp_guest_cpsr_reg,
                                 });
                             }
                         }
                         last_guest_regs_outputs.fill(None);
                         add_inst = false;
                     }
-                    BlockInst::SaveReg {
-                        guest_reg,
-                        thread_regs_addr_reg,
-                        tmp_guest_cpsr_reg,
-                        ..
-                    } => {
+                    BlockInst::SaveReg { guest_reg, thread_regs_addr_reg, .. } => {
                         if guest_reg == Reg::PC {
                             asm.buf.insts[i] = BlockInst::SaveReg {
                                 guest_reg: Reg::PC,
                                 reg_mapped: last_pc_reg,
                                 thread_regs_addr_reg,
-                                tmp_guest_cpsr_reg,
                             }
                         }
                         last_guest_regs_outputs[guest_reg as usize] = None;
@@ -185,28 +178,24 @@ impl BasicBlock {
                                         op: BlockSystemRegOp::Mrs,
                                         operand: Reg::CPSR.into(),
                                     });
+
                                     self.insts_link.insert_end(asm.buf.insts.len());
                                     asm.buf.insts.push(BlockInst::Transfer {
                                         op: BlockTransferOp::Read,
                                         operands: [asm.tmp_guest_cpsr_reg.into(), asm.thread_regs_addr_reg.into(), (Reg::CPSR as u32 * 4).into()],
                                         signed: false,
-                                        amount: MemoryAmount::Word,
+                                        amount: MemoryAmount::Half,
                                         add_to_base: true,
                                     });
+
                                     self.insts_link.insert_end(asm.buf.insts.len());
                                     asm.buf.insts.push(BlockInst::Alu3 {
                                         op: BlockAluOp::And,
                                         operands: [Reg::CPSR.into(), Reg::CPSR.into(), (0xF8, ShiftType::Ror, 4).into()],
                                         set_cond: BlockAluSetCond::None,
                                         thumb_pc_aligned: false,
                                     });
-                                    self.insts_link.insert_end(asm.buf.insts.len());
-                                    asm.buf.insts.push(BlockInst::Alu3 {
-                                        op: BlockAluOp::Bic,
-                                        operands: [asm.tmp_guest_cpsr_reg.into(), asm.tmp_guest_cpsr_reg.into(), (0xF8, ShiftType::Ror, 4).into()],
-                                        set_cond: BlockAluSetCond::None,
-                                        thumb_pc_aligned: false,
-                                    });
+
                                     self.insts_link.insert_end(asm.buf.insts.len());
                                     asm.buf.insts.push(BlockInst::Alu3 {
                                         op: BlockAluOp::Orr,
@@ -279,7 +268,6 @@ impl BasicBlock {
                     guest_reg,
                     reg_mapped: guest_reg.into(),
                     thread_regs_addr_reg: asm.thread_regs_addr_reg,
-                    tmp_guest_cpsr_reg: asm.tmp_guest_cpsr_reg,
                 });
             }
         }

src/jit/assembler/block_asm.rs

@@ -385,7 +385,6 @@ impl<'a> BlockAsm<'a> {
             guest_reg,
             reg_mapped: BlockReg::from(guest_reg),
             thread_regs_addr_reg: self.thread_regs_addr_reg,
-            tmp_guest_cpsr_reg: self.tmp_guest_cpsr_reg,
         });
     }
 

src/jit/assembler/block_inst.rs

@@ -142,7 +142,6 @@ impl BlockInst {
                 guest_reg,
                 reg_mapped,
                 thread_regs_addr_reg,
-                tmp_guest_cpsr_reg,
             } => {
                 let mut inputs = BlockRegSet::new();
                 let mut outputs = BlockRegSet::new();
@@ -151,7 +150,6 @@ impl BlockInst {
                         inputs += BlockReg::Fixed(Reg::CPSR);
                         inputs += *thread_regs_addr_reg;
                         outputs += *reg_mapped;
-                        outputs += *tmp_guest_cpsr_reg;
                     }
                     _ => {
                         inputs += *reg_mapped;
@@ -335,16 +333,10 @@ impl BlockInst {
             BlockInst::Bfc { operand, .. } => Self::replace_reg(operand, old, new),
             BlockInst::Bfi { operands, .. } => Self::replace_reg(&mut operands[0], old, new),
             BlockInst::SaveContext { tmp_guest_cpsr_reg, .. } => Self::replace_reg(tmp_guest_cpsr_reg, old, new),
-            BlockInst::SaveReg {
-                guest_reg,
-                reg_mapped,
-                tmp_guest_cpsr_reg,
-                ..
-            } => {
+            BlockInst::SaveReg { guest_reg, reg_mapped, .. } => {
                 if *guest_reg == Reg::CPSR {
                     Self::replace_reg(reg_mapped, old, new);
                 }
-                Self::replace_reg(tmp_guest_cpsr_reg, old, new)
             }
             BlockInst::RestoreReg {
                 guest_reg,
@@ -384,13 +376,11 @@ impl BlockInst {
             BlockInst::SaveContext { .. } => {
                 unreachable!()
             }
-            BlockInst::SaveReg {
-                reg_mapped,
-                thread_regs_addr_reg,
-                tmp_guest_cpsr_reg,
-                ..
+            BlockInst::SaveReg { reg_mapped, thread_regs_addr_reg, .. } => {
+                Self::replace_reg(reg_mapped, old, new);
+                Self::replace_reg(thread_regs_addr_reg, old, new);
             }
-            | BlockInst::RestoreReg {
+            BlockInst::RestoreReg {
                 reg_mapped,
                 thread_regs_addr_reg,
                 tmp_guest_cpsr_reg,
@@ -411,26 +401,11 @@ impl BlockInst {
         }
     }
 
-    fn save_guest_cpsr(opcodes: &mut Vec<u32>, thread_regs_addr_reg: Reg, host_reg: Reg, guest_reg: Reg) {
+    fn save_guest_cpsr(opcodes: &mut Vec<u32>, thread_regs_addr_reg: Reg, host_reg: Reg) {
         opcodes.push(Mrs::cpsr(host_reg, Cond::AL));
-        opcodes.push(LdrStrImm::ldr_offset_al(guest_reg, thread_regs_addr_reg, Reg::CPSR as u16 * 4));
         // Only copy the cond flags from host cpsr
-        opcodes.push(AluImm::and(
-            host_reg,
-            host_reg,
-            0xF8,
-            4, // 8 Bytes, steps of 2
-            Cond::AL,
-        ));
-        opcodes.push(AluImm::bic(
-            guest_reg,
-            guest_reg,
-            0xF8,
-            4, // 8 Bytes, steps of 2
-            Cond::AL,
-        ));
-        opcodes.push(AluShiftImm::orr_al(guest_reg, host_reg, guest_reg));
-        opcodes.push(LdrStrImm::str_offset_al(guest_reg, thread_regs_addr_reg, Reg::CPSR as u16 * 4));
+        opcodes.push(AluShiftImm::mov(host_reg, host_reg, ShiftType::Lsr, 16, Cond::AL));
+        opcodes.push(LdrStrImmSBHD::strh(host_reg, thread_regs_addr_reg, Reg::CPSR as u8 * 4 + 2, Cond::AL));
     }
 
     pub fn emit_opcode(&mut self, opcodes: &mut Vec<u32>, opcode_index: usize, branch_placeholders: &mut Vec<usize>, opcodes_offset: usize, used_host_regs: RegReserve) {
@@ -588,9 +563,9 @@ impl BlockInst {
                 guest_reg,
                 reg_mapped,
                 thread_regs_addr_reg,
-                tmp_guest_cpsr_reg,
+                ..
             } => match guest_reg {
-                Reg::CPSR => Self::save_guest_cpsr(opcodes, thread_regs_addr_reg.as_fixed(), reg_mapped.as_fixed(), tmp_guest_cpsr_reg.as_fixed()),
+                Reg::CPSR => Self::save_guest_cpsr(opcodes, thread_regs_addr_reg.as_fixed(), reg_mapped.as_fixed()),
                 _ => opcodes.push(LdrStrImm::str_offset_al(reg_mapped.as_fixed(), thread_regs_addr_reg.as_fixed(), *guest_reg as u16 * 4)),
             },
             BlockInst::RestoreReg {
@@ -769,7 +744,6 @@ pub enum BlockInst {
         guest_reg: Reg,
         reg_mapped: BlockReg,
         thread_regs_addr_reg: BlockReg,
-        tmp_guest_cpsr_reg: BlockReg,
     },
     RestoreReg {
         guest_reg: Reg,