src/shims/windows/dlsym.rs

   1 use rustc_middle::mir;
   2
   3 use log::trace;
   4
   5 use crate::*;
   6 use helpers::check_arg_count;
   7 use shims::windows::sync::EvalContextExt as _;
   8
   9 #[derive(Debug, Copy, Clone)]
  10 pub enum Dlsym {
  11     AcquireSRWLockExclusive,
  12     ReleaseSRWLockExclusive,
  13     TryAcquireSRWLockExclusive,
  14     AcquireSRWLockShared,
  15     ReleaseSRWLockShared,
  16     TryAcquireSRWLockShared,
  17 }
  18
  19 impl Dlsym {
  20     // Returns an error for unsupported symbols, and None if this symbol
  21     // should become a NULL pointer (pretend it does not exist).
  22     pub fn from_str(name: &str) -> InterpResult<'static, Option<Dlsym>> {
  23         Ok(match name {
  24             "AcquireSRWLockExclusive" => Some(Dlsym::AcquireSRWLockExclusive),
  25             "ReleaseSRWLockExclusive" => Some(Dlsym::ReleaseSRWLockExclusive),
  26             "TryAcquireSRWLockExclusive" => Some(Dlsym::TryAcquireSRWLockExclusive),
  27             "AcquireSRWLockShared" => Some(Dlsym::AcquireSRWLockShared),
  28             "ReleaseSRWLockShared" => Some(Dlsym::ReleaseSRWLockShared),
  29             "TryAcquireSRWLockShared" => Some(Dlsym::TryAcquireSRWLockShared),
  30             "GetSystemTimePreciseAsFileTime" => None,
  31             _ => throw_unsup_format!("unsupported Windows dlsym: {}", name),
  32         })
  33     }
  34 }
  35
  36 impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
  37 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
  38     fn call_dlsym(
  39         &mut self,
  40         dlsym: Dlsym,
  41         args: &[OpTy<'tcx, Tag>],
  42         ret: Option<(PlaceTy<'tcx, Tag>, mir::BasicBlock)>,
  43     ) -> InterpResult<'tcx> {
  44         let this = self.eval_context_mut();
  45         let (dest, ret) = ret.expect("we don't support any diverging dlsym");
  46         assert!(this.tcx.sess.target.os == "windows");
  47
  48         match dlsym {
  49             Dlsym::AcquireSRWLockExclusive => {
  50                 let &[ptr] = check_arg_count(args)?;
  51                 this.AcquireSRWLockExclusive(ptr)?;
  52             }
  53             Dlsym::ReleaseSRWLockExclusive => {
  54                 let &[ptr] = check_arg_count(args)?;
  55                 this.ReleaseSRWLockExclusive(ptr)?;
  56             }
  57             Dlsym::TryAcquireSRWLockExclusive => {
  58                 let &[ptr] = check_arg_count(args)?;
  59                 let ret = this.TryAcquireSRWLockExclusive(ptr)?;
  60                 this.write_scalar(Scalar::from_u8(ret), dest)?;
  61             }
  62             Dlsym::AcquireSRWLockShared => {
  63                 let &[ptr] = check_arg_count(args)?;
  64                 this.AcquireSRWLockShared(ptr)?;
  65             }
  66             Dlsym::ReleaseSRWLockShared => {
  67                 let &[ptr] = check_arg_count(args)?;
  68                 this.ReleaseSRWLockShared(ptr)?;
  69             }
  70             Dlsym::TryAcquireSRWLockShared => {
  71                 let &[ptr] = check_arg_count(args)?;
  72                 let ret = this.TryAcquireSRWLockShared(ptr)?;
  73                 this.write_scalar(Scalar::from_u8(ret), dest)?;
  74             }
  75         }
  76
  77         trace!("{:?}", this.dump_place(*dest));
  78         this.go_to_block(ret);
  79         Ok(())
  80     }
  81 }