cleanup positioning

Author: beepster4096

src/shims/windows/foreign_items.rs

@@ -323,15 +323,6 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 // FIXME: we should set last_error, but to what?
                 this.write_null(dest)?;
             }
-            // this is only callable from std because we know that std ignores the return value
-            "SwitchToThread" if this.frame_in_std() => {
-                let [] = this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
-
-                this.yield_active_thread();
-
-                // FIXME: this should return a nonzero value if this call does result in switching to another thread.
-                this.write_null(dest)?;
-            }
             "GetStdHandle" => {
                 let [which] =
                     this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
@@ -417,6 +408,15 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 let result = this.GetCurrentProcessId()?;
                 this.write_scalar(Scalar::from_u32(result), dest)?;
             }
+            // this is only callable from std because we know that std ignores the return value
+            "SwitchToThread" if this.frame_in_std() => {
+                let [] = this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
+
+                this.yield_active_thread();
+
+                // FIXME: this should return a nonzero value if this call does result in switching to another thread.
+                this.write_null(dest)?;
+            }
 
             _ => return Ok(EmulateByNameResult::NotSupported),
         }

src/shims/windows/handle.rs

@@ -8,6 +8,14 @@ pub enum PseudoHandle {
     CurrentThread,
 }
 
+/// Miri representation of a Windows `HANDLE`
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Handle {
+    Null,
+    Pseudo(PseudoHandle),
+    Thread(ThreadId),
+}
+
 impl PseudoHandle {
     const CURRENT_THREAD_VALUE: u32 = 0;
 
@@ -25,14 +33,6 @@ impl PseudoHandle {
     }
 }
 
-/// Miri representation of a Windows `HANDLE`
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum Handle {
-    Null,
-    Pseudo(PseudoHandle),
-    Thread(ThreadId),
-}
-
 impl Handle {
     const NULL_DISCRIMINANT: u32 = 0;
     const PSEUDO_DISCRIMINANT: u32 = 1;
@@ -154,7 +154,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     fn CloseHandle(&mut self, handle_op: &OpTy<'tcx, Provenance>) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
-        match Handle::from_scalar(this.read_scalar(handle_op)?.check_init()?, this)? {
+        let handle = this.read_scalar(handle_op)?.check_init()?;
+
+        match Handle::from_scalar(handle, this)? {
             Some(Handle::Thread(thread)) => this.detach_thread(thread, true)?,
             _ => this.invalid_handle("CloseHandle")?,
         }

src/shims/windows/thread.rs

@@ -59,20 +59,24 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
     fn WaitForSingleObject(
         &mut self,
-        handle: &OpTy<'tcx, Provenance>,
-        timeout: &OpTy<'tcx, Provenance>,
+        handle_op: &OpTy<'tcx, Provenance>,
+        timeout_op: &OpTy<'tcx, Provenance>,
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
-        let thread = match Handle::from_scalar(this.read_scalar(handle)?.check_init()?, this)? {
+        let handle = this.read_scalar(handle_op)?.check_init()?;
+
+        let timeout = this.read_scalar(timeout_op)?.to_u32()?;
+
+        let thread = match Handle::from_scalar(handle, this)? {
             Some(Handle::Thread(thread)) => thread,
             // Unlike on posix, joining the current thread is not UB on windows.
             // It will just deadlock.
             Some(Handle::Pseudo(PseudoHandle::CurrentThread)) => this.get_active_thread(),
             _ => this.invalid_handle("WaitForSingleObject")?,
         };
 
-        if this.read_scalar(timeout)?.to_u32()? != this.eval_windows("c", "INFINITE")?.to_u32()? {
+        if timeout != this.eval_windows("c", "INFINITE")?.to_u32()? {
             throw_unsup_format!("`WaitForSingleObject` with non-infinite timeout");
         }