separate machine state from cpu state

Use a new enum for the total machine state, separately from per-CPU state.
Drop the "Exit" state for a CPU, as that is a process-wide thing.

cli/src/main.rs

@@ -188,19 +188,16 @@ fn main() -> anyhow::Result<ExitCode> {
             while machine.run() {}
         }
 
-        match &machine.emu.x86.cpu().state {
-            x86::CPUState::Error(error) => {
-                log::error!("{:?}", error);
-                machine.dump_state(0);
-                exit_code = 1;
-            }
-            x86::CPUState::Exit(code) => {
+        match &machine.status {
+            win32::Status::Exit(code) => {
                 exit_code = *code;
             }
-            x86::CPUState::Running | x86::CPUState::Blocked(_) | x86::CPUState::SysCall => {
-                unreachable!()
+            win32::Status::Error { message } => {
+                log::error!("{}", message);
+                machine.dump_state(0);
+                exit_code = 1;
             }
-            x86::CPUState::DebugBreak => todo!(),
+            _ => unreachable!(),
         }
 
         let millis = start.elapsed().as_millis() as usize;

web/emulator.ts

@@ -66,7 +66,7 @@ export class Emulator extends JsHost {
   private runBatch() {
     const startTime = performance.now();
     const startSteps = this.emu.instr_count;
-    const cpuState = this.emu.run(this.stepSize) as wasm.CPUState;
+    const cpuState = this.emu.run(this.stepSize) as wasm.Status;
     const endTime = performance.now();
     const endSteps = this.emu.instr_count;
 
@@ -94,9 +94,9 @@ export class Emulator extends JsHost {
     this.breakpoints.uninstall(this.emu);
 
     switch (cpuState) {
-      case wasm.CPUState.Running:
+      case wasm.Status.Running:
         return true;
-      case wasm.CPUState.DebugBreak: {
+      case wasm.Status.DebugBreak: {
         const bp = this.breakpoints.isAtBreakpoint(this.emu.eip);
         if (bp) {
           if (!bp.oneShot) {
@@ -106,9 +106,9 @@ export class Emulator extends JsHost {
         }
         return false;
       }
-      case wasm.CPUState.Blocked:
-      case wasm.CPUState.Error:
-      case wasm.CPUState.Exit:
+      case wasm.Status.Blocked:
+      case wasm.Status.Error:
+      case wasm.Status.Exit:
         this.emuHost.onStopped();
         return false;
     }

web/glue/src/lib.rs

@@ -16,7 +16,7 @@ pub struct Emulator {
 }
 
 #[wasm_bindgen]
-pub enum CPUState {
+pub enum Status {
     Running,
     Blocked,
     Error,
@@ -82,7 +82,7 @@ impl Emulator {
 
     /// Run code until at least count instructions have run.
     /// This exists to avoid many round-trips from JS to Rust in the execution loop.
-    pub fn run(&mut self, count: usize) -> JsResult<CPUState> {
+    pub fn run(&mut self, count: usize) -> JsResult<Status> {
         if count == 1 {
             self.machine.single_step();
         } else {
@@ -96,12 +96,14 @@ impl Emulator {
             }
         }
 
-        Ok(match &self.machine.emu.x86.cpu().state {
-            x86::CPUState::Running | x86::CPUState::SysCall => CPUState::Running,
-            x86::CPUState::Blocked(_) => CPUState::Blocked,
-            x86::CPUState::Error(msg) => return Err(JsError::new(msg)),
-            x86::CPUState::DebugBreak => CPUState::DebugBreak,
-            x86::CPUState::Exit(_) => CPUState::Exit,
+        Ok(match &self.machine.status {
+            win32::Status::Running => Status::Running,
+            win32::Status::Blocked => Status::Blocked,
+            win32::Status::Error { message } => return Err(JsError::new(message)),
+            win32::Status::Exit(_code) => {
+                // TODO: use exit code
+                Status::Exit
+            }
         })
     }
 

win32/src/machine.rs

@@ -41,3 +41,9 @@ pub enum Status {
     /// Process exited.
     Exit(u32),
 }
+
+impl Status {
+    pub fn is_running(&self) -> bool {
+        matches!(self, Status::Running)
+    }
+}

win32/src/machine_emu.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     host,
-    machine::{LoadedAddrs, MachineX},
+    machine::{LoadedAddrs, MachineX, Status},
     pe,
     shims::{Handler, Shims},
     winapi,
@@ -135,6 +135,7 @@ impl MachineX<Emulator> {
                 x86::CPUState::Blocked(_) | x86::CPUState::DebugBreak
             ) {
                 cpu.state = x86::CPUState::Running;
+                self.status = Status::Running;
             }
         }
     }
@@ -146,6 +147,7 @@ impl MachineX<Emulator> {
             x86::CPUState::Blocked(_) | x86::CPUState::DebugBreak
         ) {
             cpu.state = x86::CPUState::Running;
+            self.status = Status::Running;
         }
     }
 
@@ -159,12 +161,17 @@ impl MachineX<Emulator> {
                 if self.host.block(wait) {
                     self.unblock();
                 } else {
-                    return false;
+                    self.status = Status::Blocked;
                 }
             }
-            _ => return false,
+            x86::CPUState::Error(message) => {
+                self.status = Status::Error {
+                    message: message.clone(),
+                };
+            }
+            _ => unimplemented!(),
         }
-        true
+        self.status.is_running()
     }
 
     fn execute_block(&mut self) {
@@ -264,12 +271,6 @@ impl MachineX<Emulator> {
     }
 
     pub fn exit(&mut self, exit_code: u32) {
-        // Set the CPU state immediately here because otherwise the CPU will
-        // continue executing instructions after the exit call.
-        // TODO: this is unsatisfying.
-        // Maybe better is to generate a hlt instruction somewhere and jump to it?
-        // Note also we need a mechanism to exit a completed thread without stopping the whole
-        // program.
-        self.emu.x86.cpu_mut().state = x86::CPUState::Exit(exit_code);
+        self.status = Status::Exit(exit_code);
     }
 }

win32/src/machine_unicorn.rs

@@ -303,7 +303,7 @@ impl MachineX<Emulator> {
 
     fn run(&mut self, eip: u32) {
         let mut eip = eip as u64;
-        while matches!(self.status, Status::Running) {
+        while self.status.is_running() {
             if let Err(err) = self.emu.unicorn.emu_start(eip, MAGIC_ADDR, 0, 0) {
                 self.status = Status::Error {
                     message: format!("unicorn: {:?}", err),

x86/src/x86.rs

@@ -20,7 +20,6 @@ pub enum CPUState {
     DebugBreak,
     SysCall,
     Error(String),
-    Exit(u32),
 }
 
 impl CPUState {
@@ -246,10 +245,7 @@ impl X86 {
         for (i, cpu) in self.cpus.iter().enumerate() {
             match cpu.state {
                 CPUState::Running => {}
-                CPUState::DebugBreak
-                | CPUState::Error(_)
-                | CPUState::Exit(_)
-                | CPUState::SysCall => {
+                CPUState::DebugBreak | CPUState::Error(_) | CPUState::SysCall => {
                     self.cur_cpu = i;
                     return;
                 }