Implement rwlocks on Windows

src/shims/dlsym.rs

@@ -1,34 +1,24 @@
 use rustc_middle::mir;
 
 use crate::*;
-use helpers::check_arg_count;
+use shims::posix::dlsym as posix;
+use shims::windows::dlsym as windows;
 
 #[derive(Debug, Copy, Clone)]
+#[allow(non_camel_case_types)]
 pub enum Dlsym {
-    GetEntropy,
+    Posix(posix::Dlsym),
+    Windows(windows::Dlsym),
 }
 
 impl Dlsym {
     // Returns an error for unsupported symbols, and None if this symbol
     // should become a NULL pointer (pretend it does not exist).
     pub fn from_str(name: &[u8], target_os: &str) -> InterpResult<'static, Option<Dlsym>> {
-        use self::Dlsym::*;
-        let name = String::from_utf8_lossy(name);
+        let name = &*String::from_utf8_lossy(name);
         Ok(match target_os {
-            "linux" => match &*name {
-                "__pthread_get_minstack" => None,
-                _ => throw_unsup_format!("unsupported Linux dlsym: {}", name),
-            }
-            "macos" => match &*name {
-                "getentropy" => Some(GetEntropy),
-                _ => throw_unsup_format!("unsupported macOS dlsym: {}", name),
-            }
-            "windows" => match &*name {
-                "SetThreadStackGuarantee" => None,
-                "AcquireSRWLockExclusive" => None,
-                "GetSystemTimePreciseAsFileTime" => None,
-                _ => throw_unsup_format!("unsupported Windows dlsym: {}", name),
-            }
+            "linux" | "macos" => posix::Dlsym::from_str(name, target_os)?.map(Dlsym::Posix),
+            "windows" => windows::Dlsym::from_str(name)?.map(Dlsym::Windows),
             os => bug!("dlsym not implemented for target_os {}", os),
         })
     }
@@ -42,23 +32,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         args: &[OpTy<'tcx, Tag>],
         ret: Option<(PlaceTy<'tcx, Tag>, mir::BasicBlock)>,
     ) -> InterpResult<'tcx> {
-        use self::Dlsym::*;
-
         let this = self.eval_context_mut();
-        let (dest, ret) = ret.expect("we don't support any diverging dlsym");
-
         match dlsym {
-            GetEntropy => {
-                let &[ptr, len] = check_arg_count(args)?;
-                let ptr = this.read_scalar(ptr)?.not_undef()?;
-                let len = this.read_scalar(len)?.to_machine_usize(this)?;
-                this.gen_random(ptr, len)?;
-                this.write_null(dest)?;
-            }
+            Dlsym::Posix(dlsym) => posix::EvalContextExt::call_dlsym(this, dlsym, args, ret),
+            Dlsym::Windows(dlsym) => windows::EvalContextExt::call_dlsym(this, dlsym, args, ret),
         }
-
-        this.dump_place(*dest);
-        this.go_to_block(ret);
-        Ok(())
     }
 }

src/shims/posix/dlsym.rs

@@ -0,0 +1,39 @@
+use rustc_middle::mir;
+
+use crate::*;
+use shims::posix::linux::dlsym as linux;
+use shims::posix::macos::dlsym as macos;
+
+#[derive(Debug, Copy, Clone)]
+pub enum Dlsym {
+    Linux(linux::Dlsym),
+    MacOs(macos::Dlsym),
+}
+
+impl Dlsym {
+    // Returns an error for unsupported symbols, and None if this symbol
+    // should become a NULL pointer (pretend it does not exist).
+    pub fn from_str(name: &str, target_os: &str) -> InterpResult<'static, Option<Dlsym>> {
+        Ok(match target_os {
+            "linux" => linux::Dlsym::from_str(name)?.map(Dlsym::Linux),
+            "macos" => macos::Dlsym::from_str(name)?.map(Dlsym::MacOs),
+            _ => unreachable!(),
+        })
+    }
+}
+
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
+    fn call_dlsym(
+        &mut self,
+        dlsym: Dlsym,
+        args: &[OpTy<'tcx, Tag>],
+        ret: Option<(PlaceTy<'tcx, Tag>, mir::BasicBlock)>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+        match dlsym {
+            Dlsym::Linux(dlsym) => linux::EvalContextExt::call_dlsym(this, dlsym, args, ret),
+            Dlsym::MacOs(dlsym) => macos::EvalContextExt::call_dlsym(this, dlsym, args, ret),
+        }
+    }
+}

src/shims/posix/linux/dlsym.rs

@@ -0,0 +1,34 @@
+use rustc_middle::mir;
+
+use crate::*;
+
+#[derive(Debug, Copy, Clone)]
+pub enum Dlsym {
+}
+
+impl Dlsym {
+    // Returns an error for unsupported symbols, and None if this symbol
+    // should become a NULL pointer (pretend it does not exist).
+    pub fn from_str(name: &str) -> InterpResult<'static, Option<Dlsym>> {
+        Ok(match &*name {
+            "__pthread_get_minstack" => None,
+            _ => throw_unsup_format!("unsupported Linux dlsym: {}", name),
+        })
+    }
+}
+
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
+    fn call_dlsym(
+        &mut self,
+        dlsym: Dlsym,
+        _args: &[OpTy<'tcx, Tag>],
+        ret: Option<(PlaceTy<'tcx, Tag>, mir::BasicBlock)>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+        let (_dest, _ret) = ret.expect("we don't support any diverging dlsym");
+        assert!(this.tcx.sess.target.target.target_os == "linux");
+
+        match dlsym {}
+    }
+}

src/shims/posix/linux/mod.rs

@@ -1 +1,2 @@
 pub mod foreign_items;
+pub mod dlsym;

src/shims/posix/macos/dlsym.rs

@@ -0,0 +1,49 @@
+use rustc_middle::mir;
+
+use crate::*;
+use helpers::check_arg_count;
+
+#[derive(Debug, Copy, Clone)]
+#[allow(non_camel_case_types)]
+pub enum Dlsym {
+    getentropy,
+}
+
+impl Dlsym {
+    // Returns an error for unsupported symbols, and None if this symbol
+    // should become a NULL pointer (pretend it does not exist).
+    pub fn from_str(name: &str) -> InterpResult<'static, Option<Dlsym>> {
+        Ok(match name {
+            "getentropy" => Some(Dlsym::getentropy),
+            _ => throw_unsup_format!("unsupported macOS dlsym: {}", name),
+        })
+    }
+}
+
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
+    fn call_dlsym(
+        &mut self,
+        dlsym: Dlsym,
+        args: &[OpTy<'tcx, Tag>],
+        ret: Option<(PlaceTy<'tcx, Tag>, mir::BasicBlock)>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+        let (dest, ret) = ret.expect("we don't support any diverging dlsym");
+        assert!(this.tcx.sess.target.target.target_os == "macos");
+
+        match dlsym {
+            Dlsym::getentropy => {
+                let &[ptr, len] = check_arg_count(args)?;
+                let ptr = this.read_scalar(ptr)?.not_undef()?;
+                let len = this.read_scalar(len)?.to_machine_usize(this)?;
+                this.gen_random(ptr, len)?;
+                this.write_null(dest)?;
+            }
+        }
+
+        this.dump_place(*dest);
+        this.go_to_block(ret);
+        Ok(())
+    }
+}

src/shims/posix/macos/mod.rs

@@ -1 +1,2 @@
 pub mod foreign_items;
+pub mod dlsym;

src/shims/posix/mod.rs

@@ -1,4 +1,5 @@
 pub mod foreign_items;
+pub mod dlsym;
 
 mod fs;
 mod sync;

src/shims/tls.rs

@@ -230,7 +230,7 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     fn schedule_windows_tls_dtors(&mut self) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         let active_thread = this.get_active_thread();
-        assert_eq!(this.get_total_thread_count(), 1, "concurrency on Windows not supported");
+        assert_eq!(this.get_total_thread_count(), 1, "concurrency on Windows is not supported");
         // Windows has a special magic linker section that is run on certain events.
         // Instead of searching for that section and supporting arbitrary hooks in there
         // (that would be basically https://github.com/rust-lang/miri/issues/450),

src/shims/windows/dlsym.rs

@@ -0,0 +1,80 @@
+use rustc_middle::mir;
+
+use crate::*;
+use helpers::check_arg_count;
+use shims::windows::sync::EvalContextExt as _;
+
+#[derive(Debug, Copy, Clone)]
+pub enum Dlsym {
+    AcquireSRWLockExclusive,
+    ReleaseSRWLockExclusive,
+    TryAcquireSRWLockExclusive,
+    AcquireSRWLockShared,
+    ReleaseSRWLockShared,
+    TryAcquireSRWLockShared,
+}
+
+impl Dlsym {
+    // Returns an error for unsupported symbols, and None if this symbol
+    // should become a NULL pointer (pretend it does not exist).
+    pub fn from_str(name: &str) -> InterpResult<'static, Option<Dlsym>> {
+        Ok(match name {
+            "AcquireSRWLockExclusive" => Some(Dlsym::AcquireSRWLockExclusive),
+            "ReleaseSRWLockExclusive" => Some(Dlsym::ReleaseSRWLockExclusive),
+            "TryAcquireSRWLockExclusive" => Some(Dlsym::TryAcquireSRWLockExclusive),
+            "AcquireSRWLockShared" => Some(Dlsym::AcquireSRWLockShared),
+            "ReleaseSRWLockShared" => Some(Dlsym::ReleaseSRWLockShared),
+            "TryAcquireSRWLockShared" => Some(Dlsym::TryAcquireSRWLockShared),
+            "SetThreadStackGuarantee" => None,
+            "GetSystemTimePreciseAsFileTime" => None,
+            _ => throw_unsup_format!("unsupported Windows dlsym: {}", name),
+        })
+    }
+}
+
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
+    fn call_dlsym(
+        &mut self,
+        dlsym: Dlsym,
+        args: &[OpTy<'tcx, Tag>],
+        ret: Option<(PlaceTy<'tcx, Tag>, mir::BasicBlock)>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+        let (dest, ret) = ret.expect("we don't support any diverging dlsym");
+        assert!(this.tcx.sess.target.target.target_os == "windows");
+
+        match dlsym {
+            Dlsym::AcquireSRWLockExclusive => {
+                let &[ptr] = check_arg_count(args)?;
+                this.AcquireSRWLockExclusive(ptr)?;
+            }
+            Dlsym::ReleaseSRWLockExclusive => {
+                let &[ptr] = check_arg_count(args)?;
+                this.ReleaseSRWLockExclusive(ptr)?;
+            }
+            Dlsym::TryAcquireSRWLockExclusive => {
+                let &[ptr] = check_arg_count(args)?;
+                let ret = this.TryAcquireSRWLockExclusive(ptr)?;
+                this.write_scalar(Scalar::from_u8(ret), dest)?;
+            }
+            Dlsym::AcquireSRWLockShared => {
+                let &[ptr] = check_arg_count(args)?;
+                this.AcquireSRWLockShared(ptr)?;
+            }
+            Dlsym::ReleaseSRWLockShared => {
+                let &[ptr] = check_arg_count(args)?;
+                this.ReleaseSRWLockShared(ptr)?;
+            }
+            Dlsym::TryAcquireSRWLockShared => {
+                let &[ptr] = check_arg_count(args)?;
+                let ret = this.TryAcquireSRWLockShared(ptr)?;
+                this.write_scalar(Scalar::from_u8(ret), dest)?;
+            }
+        }
+
+        this.dump_place(*dest);
+        this.go_to_block(ret);
+        Ok(())
+    }
+}

src/shims/windows/foreign_items.rs

@@ -21,6 +21,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         // HANDLE = isize
         // DWORD = ULONG = u32
         // BOOL = i32
+        // BOOLEAN = u8
         match link_name {
             // Environment related shims
             "GetEnvironmentVariableW" => {
@@ -301,7 +302,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 #[allow(non_snake_case)]
                 let &[_lpCriticalSection] = check_arg_count(args)?;
                 assert_eq!(this.get_total_thread_count(), 1, "concurrency on Windows not supported");
-                // There is only one thread, so this always succeeds and returns TRUE
+                // There is only one thread, so this always succeeds and returns TRUE.
                 this.write_scalar(Scalar::from_i32(1), dest)?;
             }
 

src/shims/windows/mod.rs

@@ -1 +1,4 @@
 pub mod foreign_items;
+pub mod dlsym;
+
+mod sync;