Chip8模拟器Rust代码match分支嵌套借用编译错误求助

问题根源 #

你遇到的编译错误是Rust所有权规则的直接约束：在execute方法中，先通过self.cpu.borrow_mut()获取了CPU的可变借用（该借用会持续到cpu变量被销毁，即函数末尾），后续调用display_op等方法时又尝试传递&mut self（整个VM的可变借用）。由于self.cpu是self的一部分，已被可变借用的情况下，整个self无法再被可变借用，违反了Rust“同一时间不能存在同一数据的可变与不可变借用”的规则。

可行解决方案 #

方案1：重构CPU方法，传递单个所需组件而非整个VM #

既然display_op、draw_op等方法仅依赖VM的特定组件（memory、keyboard等），直接传递这些组件的引用，避免传递整个&mut Vm，既符合借用规则，也能明确依赖关系。

修改CPU方法定义：

pub(crate) fn display_op(&mut self, nn: u8, memory: &mut Memory) {
    // 直接使用memory，无需再调用borrow_mut
}

pub(crate) fn draw_op(&mut self, x: u8, y: u8, n: u8, memory: &mut Memory, display: &mut Display) {
    // 使用memory和display
}

pub(crate) fn key_op(&mut self, x: u8, nn: u8, keyboard: &Keyboard) {
    // 使用keyboard
}

pub(crate) fn timer_op(&mut self, x: u8, nn: u8, memory: &mut Memory) {
    // 使用memory
}

调整Vm::execute逻辑，提前获取对应组件的借用（注意调整顺序避免冲突）：

pub fn execute(&mut self, inst: u16) {
    let op = (inst & 0xF000) >> 12;

    match op {
        0x0000 => {
            let mut cpu = self.cpu.borrow_mut();
            let (_, nn, _, _, _) = cpu.decode_instruction(inst);
            let mut mem = self.memory.borrow_mut();
            cpu.display_op(nn, &mut mem);
        }
        0xD000 => {
            let mut cpu = self.cpu.borrow_mut();
            let (_, _, n, x, y) = cpu.decode_instruction(inst);
            let mut mem = self.memory.borrow_mut();
            let mut display = self.display.borrow_mut();
            cpu.draw_op(x, y, n, &mut mem, &mut display);
        }
        0xE000 => {
            let mut cpu = self.cpu.borrow_mut();
            let (_, nn, _, x, _) = cpu.decode_instruction(inst);
            let keys = self.keyboard.borrow();
            cpu.key_op(x, nn, &keys);
        }
        0xF000 => {
            let mut cpu = self.cpu.borrow_mut();
            let (_, nn, _, x, _) = cpu.decode_instruction(inst);
            let mut mem = self.memory.borrow_mut();
            cpu.timer_op(x, nn, &mut mem);
        }
        // 其他无需访问VM组件的opcode，保留原有逻辑
        _ => {
            let mut cpu = self.cpu.borrow_mut();
            let (nnn, nn, n, x, y) = cpu.decode_instruction(inst);
            match op {
                0x1000 => cpu.jump_to_addr(nnn),
                0x2000 => cpu.call(nnn),
                0x3000 => cpu.skip_execution(inst, x, nn),
                0x4000 => cpu.skip_execution(inst, x, nn),
                0x5000 => cpu.reg_check_skip_exec(inst, x, y),
                0x6000 => cpu.set_reg_nn(x, nn),
                0x7000 => cpu.add_reg_nn(x, nn),
                0x8000 => cpu.alu_op(x, y, nn),
                0x9000 => cpu.reg_check_skip_exec(inst, x, y),
                0xA000 => cpu.set_i_to_addr(nnn),
                0xB000 => cpu.jump_to_addr_plus_offset(nnn),
                0xC000 => cpu.set_reg_rand(x, nn),
                _ => todo!()
            }
        }
    }
}

方案2：调整借用顺序，提前释放CPU借用 #

将CPU解码操作放在独立代码块中，解码完成后立即释放CPU的借用，后续调用需要访问VM的方法时就不会产生冲突：

pub fn execute(&mut self, inst: u16) {
    // 解码操作放在单独代码块，完成后立即释放CPU借用
    let (nnn, nn, n, x, y, op);
    {
        let mut cpu = self.cpu.borrow_mut();
        (nnn, nn, n, x, y) = cpu.decode_instruction(inst);
        op = (inst & 0xF000) >> 12;
    }

    match op {
        0x0000 => {
            let mut cpu = self.cpu.borrow_mut();
            cpu.display_op(nn, self);
        }
        0xD000 => {
            let mut cpu = self.cpu.borrow_mut();
            cpu.draw_op(x, y, n, self);
        }
        0xE000 => {
            let mut cpu = self.cpu.borrow_mut();
            cpu.key_op(x, nn, self);
        }
        0xF000 => {
            let mut cpu = self.cpu.borrow_mut();
            cpu.timer_op(x, nn, self);
        }
        // 其他opcode逻辑
        _ => {
            let mut cpu = self.cpu.borrow_mut();
            match op {
                0x1000 => cpu.jump_to_addr(nnn),
                0x2000 => cpu.call(nnn),
                0x3000 => cpu.skip_execution(inst, x, nn),
                0x4000 => cpu.skip_execution(inst, x, nn),
                0x5000 => cpu.reg_check_skip_exec(inst, x, y),
                0x6000 => cpu.set_reg_nn(x, nn),
                0x7000 => cpu.add_reg_nn(x, nn),
                0x8000 => cpu.alu_op(x, y, nn),
                0x9000 => cpu.reg_check_skip_exec(inst, x, y),
                0xA000 => cpu.set_i_to_addr(nnn),
                0xB000 => cpu.jump_to_addr_plus_offset(nnn),
                0xC000 => cpu.set_reg_rand(x, nn),
                _ => todo!()
            }
        }
    }
}

方案3：采用总线架构（模拟器常用模式） #

定义总线结构体统一持有所有外设，让CPU持有总线引用，彻底解耦CPU与VM，避免传递VM引用带来的借用问题：

pub struct Bus {
    pub memory: RefCell<Memory>,
    pub keyboard: RefCell<Keyboard>,
    pub display: RefCell<Display>,
}

pub struct Processor {
    // CPU内部状态寄存器等
    bus: Rc<Bus>,
}

pub struct Vm {
    pub cpu: RefCell<Processor>,
    pub bus: Rc<Bus>,
}

impl Vm {
    pub fn new() -> Self {
        let bus = Rc::new(Bus {
            memory: RefCell::new(Memory::new()),
            keyboard: RefCell::new(Keyboard::new()),
            display: RefCell::new(Display::new()),
        });
        let cpu = RefCell::new(Processor {
            // 初始化CPU内部状态
            bus: bus.clone(),
        });
        Vm { cpu, bus }
    }

    pub fn execute(&mut self, inst: u16) {
        let mut cpu = self.cpu.borrow_mut();
        let (nnn, nn, n, x, y) = cpu.decode_instruction(inst);
        let op = (inst & 0xF000) >> 12;

        match op {
            0x0000 => cpu.display_op(nn),
            0xD000 => cpu.draw_op(x, y, n),
            0xE000 => cpu.key_op(x, nn),
            0xF000 => cpu.timer_op(x, nn),
            // 其他opcode逻辑
            _ => todo!()
        }
    }
}

impl Processor {
    pub(crate) fn display_op(&mut self, nn: u8) {
        let mut mem = self.bus.memory.borrow_mut();
        // 具体操作逻辑
    }

    // 其他方法直接通过self.bus访问对应外设
}

总结 #

• 方案1、2适合快速修复现有代码，改动量小；
• 方案3是更优雅的架构重构，适合长期维护，也是模拟器开发的标准模式之一。

内容的提问来源于stack exchange，提问作者psychedelicpandas