Use windows-sys in windows tests

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]

tests/fail/concurrency/windows_join_detached.rs → 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, HANDLE};
 
 fn main() {
     let thread = thread::spawn(|| ());
 
     unsafe {
-        assert_ne!(CloseHandle(thread.as_raw_handle()), 0);
+        assert_ne!(CloseHandle(thread.as_raw_handle() as HANDLE), 0);
     }
 
     thread.join().unwrap();

tests/fail/concurrency/windows_join_main.rs → 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()

tests/fail/concurrency/windows_join_main.stderr → 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)

tests/fail/concurrency/windows_join_self.rs → 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()

tests/fail/concurrency/windows_join_self.stderr → 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

tests/pass/concurrency/windows_condvar_shared.rs → tests/pass-dep/concurrency/windows_condvar_shared.rs

@@ -2,39 +2,30 @@
 // We are making scheduler assumptions here.
 //@compile-flags: -Zmiri-preemption-rate=0
 
-use std::ffi::c_void;
 use std::ptr::null_mut;
 use std::thread;
 
+use windows_sys::Win32::System::Threading::{
+    AcquireSRWLockExclusive, AcquireSRWLockShared, ReleaseSRWLockExclusive, ReleaseSRWLockShared,
+    SleepConditionVariableSRW, WakeAllConditionVariable, CONDITION_VARIABLE,
+    CONDITION_VARIABLE_LOCKMODE_SHARED, INFINITE, SRWLOCK,
+};
+
+// not in windows-sys
+const SRWLOCK_INIT: SRWLOCK = SRWLOCK { Ptr: null_mut() };
+const CONDITION_VARIABLE_INIT: CONDITION_VARIABLE = CONDITION_VARIABLE { Ptr: null_mut() };
+
 #[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 = SRWLOCK_INIT;
+    let mut condvar = CONDITION_VARIABLE_INIT;
 
     let lock_ptr = SendPtr(&mut lock);
     let condvar_ptr = SendPtr(&mut condvar);
@@ -105,8 +96,8 @@ 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 = SRWLOCK_INIT;
+    let mut condvar = CONDITION_VARIABLE_INIT;
 
     let lock_ptr = SendPtr(&mut lock);
     let condvar_ptr = SendPtr(&mut condvar);
@@ -166,8 +157,8 @@ 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 = SRWLOCK_INIT;
+    let mut condvar = CONDITION_VARIABLE_INIT;
 
     let lock_ptr = SendPtr(&mut lock);
     let condvar_ptr = SendPtr(&mut condvar);

tests/pass/concurrency/windows_detach_terminated.rs → tests/pass-dep/concurrency/windows_detach_terminated.rs

@@ -5,12 +5,10 @@
 use std::os::windows::io::IntoRawHandle;
 use std::thread;
 
-extern "system" {
-    fn CloseHandle(handle: usize) -> i32;
-}
+use windows_sys::Win32::Foundation::{CloseHandle, HANDLE};
 
 fn main() {
-    let thread = thread::spawn(|| {}).into_raw_handle() as usize;
+    let thread = thread::spawn(|| {}).into_raw_handle() as HANDLE;
 
     // this yield ensures that `thread` is terminated by this point
     thread::yield_now();