have windows tests use windows-sys

beepster4096 · beepster4096 · commit ac9368ab1eec · 2023-12-25T17:09:14.000-08:00
diff --git a/src/tools/miri/test_dependencies/Cargo.lock b/src/tools/miri/test_dependencies/Cargo.lock
diff --git a/src/tools/miri/test_dependencies/Cargo.toml b/src/tools/miri/test_dependencies/Cargo.toml
@@ -20,4 +20,7 @@ rand = { version = "0.8", features = ["small_rng"] }
 page_size = "0.6"
 tokio = { version = "1.24", features = ["full"] }
 
+[target.'cfg(windows)'.dependencies]
+windows-sys = { version = "0.52", features = [ "Win32_Foundation", "Win32_System_Threading" ] }
+
 [workspace]
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_detached.rs b/src/tools/miri/tests/fail-dep/concurrency/windows_join_detached.rs
@@ -3,18 +3,16 @@
 
 // Joining a detached thread is undefined behavior.
 
-use std::os::windows::io::{AsRawHandle, RawHandle};
+use std::os::windows::io::AsRawHandle;
 use std::thread;
 
-extern "system" {
-    fn CloseHandle(handle: RawHandle) -> u32;
-}
+use windows_sys::Win32::Foundation::CloseHandle;
 
 fn main() {
     let thread = thread::spawn(|| ());
 
     unsafe {
-        assert_ne!(CloseHandle(thread.as_raw_handle()), 0);
+        assert_ne!(CloseHandle(thread.as_raw_handle() as _), 0);
     }
 
     thread.join().unwrap();
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_detached.stderr b/src/tools/miri/tests/fail-dep/concurrency/windows_join_detached.stderr
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.rs b/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.rs
@@ -6,21 +6,18 @@
 
 use std::thread;
 
-extern "system" {
-    fn WaitForSingleObject(handle: isize, timeout: u32) -> u32;
-}
-
-const INFINITE: u32 = u32::MAX;
+use windows_sys::Win32::Foundation::{HANDLE, WAIT_OBJECT_0};
+use windows_sys::Win32::System::Threading::{WaitForSingleObject, INFINITE};
 
 // XXX HACK: This is how miri represents the handle for thread 0.
 // This value can be "legitimately" obtained by using `GetCurrentThread` with `DuplicateHandle`
 // but miri does not implement `DuplicateHandle` yet.
-const MAIN_THREAD: isize = (2i32 << 30) as isize;
+const MAIN_THREAD: HANDLE = (2i32 << 30) as HANDLE;
 
 fn main() {
     thread::spawn(|| {
         unsafe {
-            assert_eq!(WaitForSingleObject(MAIN_THREAD, INFINITE), 0); //~ ERROR: deadlock: the evaluated program deadlocked
+            assert_eq!(WaitForSingleObject(MAIN_THREAD, INFINITE), WAIT_OBJECT_0); //~ ERROR: deadlock: the evaluated program deadlocked
         }
     })
     .join()
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.stderr b/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.stderr
@@ -1,8 +1,8 @@
 error: deadlock: the evaluated program deadlocked
   --> $DIR/windows_join_main.rs:LL:CC
    |
-LL |             assert_eq!(WaitForSingleObject(MAIN_THREAD, INFINITE), 0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program deadlocked
+LL |             assert_eq!(WaitForSingleObject(MAIN_THREAD, INFINITE), WAIT_OBJECT_0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program deadlocked
    |
    = note: inside closure at RUSTLIB/core/src/macros/mod.rs:LL:CC
    = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.rs b/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.rs
@@ -6,18 +6,14 @@
 
 use std::thread;
 
-extern "system" {
-    fn GetCurrentThread() -> usize;
-    fn WaitForSingleObject(handle: usize, timeout: u32) -> u32;
-}
-
-const INFINITE: u32 = u32::MAX;
+use windows_sys::Win32::Foundation::WAIT_OBJECT_0;
+use windows_sys::Win32::System::Threading::{GetCurrentThread, WaitForSingleObject, INFINITE};
 
 fn main() {
     thread::spawn(|| {
         unsafe {
             let native = GetCurrentThread();
-            assert_eq!(WaitForSingleObject(native, INFINITE), 0); //~ ERROR: deadlock: the evaluated program deadlocked
+            assert_eq!(WaitForSingleObject(native, INFINITE), WAIT_OBJECT_0); //~ ERROR: deadlock: the evaluated program deadlocked
         }
     })
     .join()
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.stderr b/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.stderr
@@ -1,7 +1,7 @@
 error: deadlock: the evaluated program deadlocked
   --> $DIR/windows_join_self.rs:LL:CC
    |
-LL |             assert_eq!(WaitForSingleObject(native, INFINITE), 0);
+LL |             assert_eq!(WaitForSingleObject(native, INFINITE), WAIT_OBJECT_0);
    |                                                            ^ the evaluated program deadlocked
    |
    = note: inside closure at $DIR/windows_join_self.rs:LL:CC
diff --git a/src/tools/miri/tests/pass-dep/concurrency/windows_condvar_shared.rs b/src/tools/miri/tests/pass-dep/concurrency/windows_condvar_shared.rs
@@ -2,42 +2,29 @@
 // We are making scheduler assumptions here.
 //@compile-flags: -Zmiri-preemption-rate=0
 
-use std::ffi::c_void;
-use std::ptr::null_mut;
+use std::mem::MaybeUninit;
 use std::thread;
 
+use windows_sys::Win32::System::Threading::{
+    AcquireSRWLockExclusive, AcquireSRWLockShared, ReleaseSRWLockExclusive, ReleaseSRWLockShared,
+    SleepConditionVariableSRW, WakeAllConditionVariable, CONDITION_VARIABLE_LOCKMODE_SHARED,
+    INFINITE,
+};
+
 #[derive(Copy, Clone)]
 struct SendPtr<T>(*mut T);
 
 unsafe impl<T> Send for SendPtr<T> {}
 
-extern "system" {
-    fn SleepConditionVariableSRW(
-        condvar: *mut *mut c_void,
-        lock: *mut *mut c_void,
-        timeout: u32,
-        flags: u32,
-    ) -> i32;
-    fn WakeAllConditionVariable(condvar: *mut *mut c_void);
-
-    fn AcquireSRWLockExclusive(lock: *mut *mut c_void);
-    fn AcquireSRWLockShared(lock: *mut *mut c_void);
-    fn ReleaseSRWLockExclusive(lock: *mut *mut c_void);
-    fn ReleaseSRWLockShared(lock: *mut *mut c_void);
-}
-
-const CONDITION_VARIABLE_LOCKMODE_SHARED: u32 = 1;
-const INFINITE: u32 = u32::MAX;
-
 /// threads should be able to reacquire the lock while it is locked by multiple other threads in shared mode
 fn all_shared() {
     println!("all_shared");
 
-    let mut lock = null_mut();
-    let mut condvar = null_mut();
+    let mut lock = MaybeUninit::zeroed();
+    let mut condvar = MaybeUninit::zeroed();
 
-    let lock_ptr = SendPtr(&mut lock);
-    let condvar_ptr = SendPtr(&mut condvar);
+    let lock_ptr = SendPtr(lock.as_mut_ptr());
+    let condvar_ptr = SendPtr(condvar.as_mut_ptr());
 
     let mut handles = Vec::with_capacity(10);
 
@@ -105,11 +92,11 @@ fn all_shared() {
 fn shared_sleep_and_exclusive_lock() {
     println!("shared_sleep_and_exclusive_lock");
 
-    let mut lock = null_mut();
-    let mut condvar = null_mut();
+    let mut lock = MaybeUninit::zeroed();
+    let mut condvar = MaybeUninit::zeroed();
 
-    let lock_ptr = SendPtr(&mut lock);
-    let condvar_ptr = SendPtr(&mut condvar);
+    let lock_ptr = SendPtr(lock.as_mut_ptr());
+    let condvar_ptr = SendPtr(condvar.as_mut_ptr());
 
     let mut waiters = Vec::with_capacity(5);
     for i in 0..5 {
@@ -166,11 +153,11 @@ fn shared_sleep_and_exclusive_lock() {
 fn exclusive_sleep_and_shared_lock() {
     println!("exclusive_sleep_and_shared_lock");
 
-    let mut lock = null_mut();
-    let mut condvar = null_mut();
+    let mut lock = MaybeUninit::zeroed();
+    let mut condvar = MaybeUninit::zeroed();
 
-    let lock_ptr = SendPtr(&mut lock);
-    let condvar_ptr = SendPtr(&mut condvar);
+    let lock_ptr = SendPtr(lock.as_mut_ptr());
+    let condvar_ptr = SendPtr(condvar.as_mut_ptr());
 
     let mut handles = Vec::with_capacity(10);
     for i in 0..5 {
diff --git a/src/tools/miri/tests/pass-dep/concurrency/windows_condvar_shared.stdout b/src/tools/miri/tests/pass-dep/concurrency/windows_condvar_shared.stdout
diff --git a/src/tools/miri/tests/pass-dep/concurrency/windows_detach_terminated.rs b/src/tools/miri/tests/pass-dep/concurrency/windows_detach_terminated.rs
@@ -5,17 +5,15 @@
 use std::os::windows::io::IntoRawHandle;
 use std::thread;
 
-extern "system" {
-    fn CloseHandle(handle: usize) -> i32;
-}
+use windows_sys::Win32::Foundation::CloseHandle;
 
 fn main() {
-    let thread = thread::spawn(|| {}).into_raw_handle() as usize;
+    let thread = thread::spawn(|| {}).into_raw_handle();
 
     // this yield ensures that `thread` is terminated by this point
     thread::yield_now();
 
     unsafe {
-        assert_ne!(CloseHandle(thread), 0);
+        assert_ne!(CloseHandle(thread as _), 0);
     }
 }
diff --git a/src/tools/miri/tests/pass-dep/concurrency/windows_init_once.rs b/src/tools/miri/tests/pass-dep/concurrency/windows_init_once.rs
@@ -2,68 +2,75 @@
 // We are making scheduler assumptions here.
 //@compile-flags: -Zmiri-preemption-rate=0
 
-use std::ffi::c_void;
+use std::mem::MaybeUninit;
 use std::ptr::null_mut;
 use std::thread;
 
+use windows_sys::Win32::Foundation::{FALSE, TRUE};
+use windows_sys::Win32::System::Threading::{
+    InitOnceBeginInitialize, InitOnceComplete, INIT_ONCE_INIT_FAILED,
+};
+
 #[derive(Copy, Clone)]
 struct SendPtr<T>(*mut T);
 
 unsafe impl<T> Send for SendPtr<T> {}
 
-extern "system" {
-    fn InitOnceBeginInitialize(
-        init: *mut *mut c_void,
-        flags: u32,
-        pending: *mut i32,
-        context: *mut c_void,
-    ) -> i32;
-
-    fn InitOnceComplete(init: *mut *mut c_void, flags: u32, context: *mut c_void) -> i32;
-}
-
-const TRUE: i32 = 1;
-const FALSE: i32 = 0;
-
-const INIT_ONCE_INIT_FAILED: u32 = 4;
-
 fn single_thread() {
-    let mut init_once = null_mut();
+    let mut init_once = MaybeUninit::zeroed();
     let mut pending = 0;
 
     unsafe {
-        assert_eq!(InitOnceBeginInitialize(&mut init_once, 0, &mut pending, null_mut()), TRUE);
+        assert_eq!(
+            InitOnceBeginInitialize(init_once.as_mut_ptr(), 0, &mut pending, null_mut()),
+            TRUE
+        );
         assert_eq!(pending, TRUE);
 
-        assert_eq!(InitOnceComplete(&mut init_once, 0, null_mut()), TRUE);
+        assert_eq!(InitOnceComplete(init_once.as_mut_ptr(), 0, null_mut()), TRUE);
 
-        assert_eq!(InitOnceBeginInitialize(&mut init_once, 0, &mut pending, null_mut()), TRUE);
+        assert_eq!(
+            InitOnceBeginInitialize(init_once.as_mut_ptr(), 0, &mut pending, null_mut()),
+            TRUE
+        );
         assert_eq!(pending, FALSE);
     }
 
-    let mut init_once = null_mut();
+    let mut init_once = MaybeUninit::zeroed();
 
     unsafe {
-        assert_eq!(InitOnceBeginInitialize(&mut init_once, 0, &mut pending, null_mut()), TRUE);
+        assert_eq!(
+            InitOnceBeginInitialize(init_once.as_mut_ptr(), 0, &mut pending, null_mut()),
+            TRUE
+        );
         assert_eq!(pending, TRUE);
 
-        assert_eq!(InitOnceComplete(&mut init_once, INIT_ONCE_INIT_FAILED, null_mut()), TRUE);
+        assert_eq!(
+            InitOnceComplete(init_once.as_mut_ptr(), INIT_ONCE_INIT_FAILED, null_mut()),
+            TRUE
+        );
 
-        assert_eq!(InitOnceBeginInitialize(&mut init_once, 0, &mut pending, null_mut()), TRUE);
+        assert_eq!(
+            InitOnceBeginInitialize(init_once.as_mut_ptr(), 0, &mut pending, null_mut()),
+            TRUE
+        );
         assert_eq!(pending, TRUE);
     }
 }
 
 fn block_until_complete() {
-    let mut init_once = null_mut();
+    let mut init_once = MaybeUninit::zeroed();
     let mut pending = 0;
 
     unsafe {
-        assert_eq!(InitOnceBeginInitialize(&mut init_once, 0, &mut pending, null_mut()), TRUE);
+        assert_eq!(
+            InitOnceBeginInitialize(init_once.as_mut_ptr(), 0, &mut pending, null_mut()),
+            TRUE
+        );
         assert_eq!(pending, TRUE);
     }
 
-    let init_once_ptr = SendPtr(&mut init_once);
+    let init_once_ptr = SendPtr(init_once.as_mut_ptr());
 
     let waiter = move || unsafe {
         let init_once_ptr = init_once_ptr; // avoid field capture
@@ -92,15 +99,18 @@ fn block_until_complete() {
 }
 
 fn retry_on_fail() {
-    let mut init_once = null_mut();
+    let mut init_once = MaybeUninit::zeroed();
     let mut pending = 0;
 
     unsafe {
-        assert_eq!(InitOnceBeginInitialize(&mut init_once, 0, &mut pending, null_mut()), TRUE);
+        assert_eq!(
+            InitOnceBeginInitialize(init_once.as_mut_ptr(), 0, &mut pending, null_mut()),
+            TRUE
+        );
         assert_eq!(pending, TRUE);
     }
 
-    let init_once_ptr = SendPtr(&mut init_once);
+    let init_once_ptr = SendPtr(init_once.as_mut_ptr());
 
     let waiter = move || unsafe {
         let init_once_ptr = init_once_ptr; // avoid field capture
@@ -134,15 +144,18 @@ fn retry_on_fail() {
 }
 
 fn no_data_race_after_complete() {
-    let mut init_once = null_mut();
+    let mut init_once = MaybeUninit::zeroed();
     let mut pending = 0;
 
     unsafe {
-        assert_eq!(InitOnceBeginInitialize(&mut init_once, 0, &mut pending, null_mut()), TRUE);
+        assert_eq!(
+            InitOnceBeginInitialize(init_once.as_mut_ptr(), 0, &mut pending, null_mut()),
+            TRUE
+        );
         assert_eq!(pending, TRUE);
     }
 
-    let init_once_ptr = SendPtr(&mut init_once);
+    let init_once_ptr = SendPtr(init_once.as_mut_ptr());
 
     let mut place = 0;
     let place_ptr = SendPtr(&mut place);
diff --git a/src/tools/miri/tests/pass-dep/concurrency/windows_init_once.stdout b/src/tools/miri/tests/pass-dep/concurrency/windows_init_once.stdout
diff --git a/src/tools/miri/tests/pass-dep/concurrency/windows_join_multiple.rs b/src/tools/miri/tests/pass-dep/concurrency/windows_join_multiple.rs
@@ -6,11 +6,8 @@ use std::os::windows::io::IntoRawHandle;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread;
 
-extern "system" {
-    fn WaitForSingleObject(handle: usize, timeout: u32) -> u32;
-}
-
-const INFINITE: u32 = u32::MAX;
+use windows_sys::Win32::Foundation::WAIT_OBJECT_0;
+use windows_sys::Win32::System::Threading::{WaitForSingleObject, INFINITE};
 
 fn main() {
     static FLAG: AtomicBool = AtomicBool::new(false);
@@ -20,10 +17,10 @@ fn main() {
             thread::yield_now();
         }
     })
-    .into_raw_handle() as usize;
+    .into_raw_handle() as _;
 
     let waiter = move || unsafe {
-        assert_eq!(WaitForSingleObject(blocker, INFINITE), 0);
+        assert_eq!(WaitForSingleObject(blocker, INFINITE), WAIT_OBJECT_0);
     };
 
     let waiter1 = thread::spawn(waiter);

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`	`1`	`error: deadlock: the evaluated program deadlocked`
`2`	`2`	`--> $DIR/windows_join_main.rs:LL:CC`
`3`	`3`	`\|`
`4`		`-LL \| assert_eq!(WaitForSingleObject(MAIN_THREAD, INFINITE), 0);`
`5`		`- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program deadlocked`
	`4`	`+LL \| assert_eq!(WaitForSingleObject(MAIN_THREAD, INFINITE), WAIT_OBJECT_0);`
	`5`	`+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program deadlocked`
`6`	`6`	`\|`
`7`	`7`	`= note: inside closure at RUSTLIB/core/src/macros/mod.rs:LL:CC`
`8`	`8`	= note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`error: deadlock: the evaluated program deadlocked`
`2`	`2`	`--> $DIR/windows_join_self.rs:LL:CC`
`3`	`3`	`\|`
`4`		`-LL \| assert_eq!(WaitForSingleObject(native, INFINITE), 0);`
	`4`	`+LL \| assert_eq!(WaitForSingleObject(native, INFINITE), WAIT_OBJECT_0);`
`5`	`5`	`\| ^ the evaluated program deadlocked`
`6`	`6`	`\|`
`7`	`7`	`= note: inside closure at $DIR/windows_join_self.rs:LL:CC`