Move time related functions to its own module

Author: pvdrz

src/lib.rs

@@ -32,6 +32,7 @@ pub use crate::shims::{EvalContextExt as ShimsEvalContextExt};
 pub use crate::shims::foreign_items::EvalContextExt as ForeignItemsEvalContextExt;
 pub use crate::shims::intrinsics::EvalContextExt as IntrinsicsEvalContextExt;
 pub use crate::shims::tls::{EvalContextExt as TlsEvalContextExt, TlsData};
+pub use crate::shims::time::{EvalContextExt as TimeEvalContextExt};
 pub use crate::shims::dlsym::{Dlsym, EvalContextExt as DlsymEvalContextExt};
 pub use crate::shims::env::{EnvVars, EvalContextExt as EnvEvalContextExt};
 pub use crate::shims::io::{FileHandler, EvalContextExt as FileEvalContextExt};

src/shims/foreign_items.rs

@@ -508,67 +508,13 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             }
 
             "clock_gettime" => {
-                if !this.machine.communicate {
-                    throw_unsup_format!("`clock_gettime` not available when isolation is enabled")
-                } else {
-                    let clk_id = this.read_scalar(args[0])?.to_i32()?;
-
-                    if clk_id != this.eval_libc_i32("CLOCK_REALTIME")? {
-                        let einval = this.eval_libc("EINVAL")?;
-                        this.set_last_error(einval)?;
-                        this.write_scalar(Scalar::from_int(-1i32, dest.layout.size), dest)?;
-                    } else {
-                        let tp = this.force_ptr(this.read_scalar(args[1])?.not_undef()?)?;
-
-                        let mut sign = 1;
-
-                        let duration = std::time::SystemTime::now()
-                            .duration_since(std::time::SystemTime::UNIX_EPOCH)
-                            .unwrap_or_else(|e| {
-                                sign = -1;
-                                e.duration()
-                            });
-
-                        let tv_sec = sign * (duration.as_secs() as i128);
-                        let tv_nsec = duration.subsec_nanos() as i128;
-
-                        this.write_c_ints(&tp, &[tv_sec, tv_nsec], &["time_t", "c_long"])?;
-
-                        this.write_scalar(Scalar::from_int(0i32, dest.layout.size), dest)?;
-                    }
-                }
+                let result = this.clock_gettime(args[0], args[1])?;
+                this.write_scalar(Scalar::from_int(result, dest.layout.size), dest)?;
             }
 
             "gettimeofday" => {
-                if !this.machine.communicate {
-                    throw_unsup_format!("`gettimeofday` not available when isolation is enabled")
-                } else {
-                    let tz = this.read_scalar(args[1])?.not_undef()?;
-                    // Using tz is obsolete and should always be null
-                    if !this.is_null(tz)? {
-                        let einval = this.eval_libc("EINVAL")?;
-                        this.set_last_error(einval)?;
-                        this.write_scalar(Scalar::from_int(-1i32, dest.layout.size), dest)?;
-                    } else {
-                        let tv = this.force_ptr(this.read_scalar(args[0])?.not_undef()?)?;
-
-                        let mut sign = 1;
-
-                        let duration = std::time::SystemTime::now()
-                            .duration_since(std::time::SystemTime::UNIX_EPOCH)
-                            .unwrap_or_else(|e| {
-                                sign = -1;
-                                e.duration()
-                            });
-
-                        let tv_sec = sign * (duration.as_secs() as i128);
-                        let tv_usec = duration.subsec_micros() as i128;
-
-                        this.write_c_ints(&tv, &[tv_sec, tv_usec], &["time_t", "suseconds_t"])?;
-
-                        this.write_scalar(Scalar::from_int(0i32, dest.layout.size), dest)?;
-                    }
-                }
+                let result = this.gettimeofday(args[0], args[1])?;
+                this.write_scalar(Scalar::from_int(result, dest.layout.size), dest)?;
             }
 
             "strlen" => {

src/shims/mod.rs

@@ -3,6 +3,7 @@ pub mod env;
 pub mod foreign_items;
 pub mod intrinsics;
 pub mod tls;
+pub mod time;
 pub mod io;
 
 use rustc::{mir, ty};

src/shims/time.rs

@@ -0,0 +1,75 @@
+use crate::stacked_borrows::Tag;
+use crate::*;
+
+use std::time::{Duration, SystemTime};
+
+fn get_time() -> (Duration, i128) {
+    let mut sign = 1;
+    let duration = SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .unwrap_or_else(|e| {
+            sign = -1;
+            e.duration()
+        });
+    (duration, sign)
+}
+
+impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
+    fn clock_gettime(
+        &mut self,
+        clk_id_op: OpTy<'tcx, Tag>,
+        tp_op: OpTy<'tcx, Tag>,
+    ) -> InterpResult<'tcx, i32> {
+        let this = self.eval_context_mut();
+
+        if !this.machine.communicate {
+            throw_unsup_format!("`clock_gettime` not available when isolation is enabled")
+        }
+
+        let clk_id = this.read_scalar(clk_id_op)?.to_i32()?;
+        if clk_id != this.eval_libc_i32("CLOCK_REALTIME")? {
+            let einval = this.eval_libc("EINVAL")?;
+            this.set_last_error(einval)?;
+            return Ok(-1);
+        }
+
+        let tp = this.force_ptr(this.read_scalar(tp_op)?.not_undef()?)?;
+
+        let (duration, sign) = get_time();
+        let tv_sec = sign * (duration.as_secs() as i128);
+        let tv_nsec = duration.subsec_nanos() as i128;
+        this.write_c_ints(&tp, &[tv_sec, tv_nsec], &["time_t", "c_long"])?;
+
+        Ok(0)
+    }
+
+    fn gettimeofday(
+        &mut self,
+        tv_op: OpTy<'tcx, Tag>,
+        tz_op: OpTy<'tcx, Tag>,
+    ) -> InterpResult<'tcx, i32> {
+        let this = self.eval_context_mut();
+
+        if !this.machine.communicate {
+            throw_unsup_format!("`gettimeofday` not available when isolation is enabled")
+        }
+        // Using tz is obsolete and should always be null
+        let tz = this.read_scalar(tz_op)?.not_undef()?;
+        if !this.is_null(tz)? {
+            let einval = this.eval_libc("EINVAL")?;
+            this.set_last_error(einval)?;
+            return Ok(-1);
+        }
+
+        let tv = this.force_ptr(this.read_scalar(tv_op)?.not_undef()?)?;
+
+        let (duration, sign) = get_time();
+        let tv_sec = sign * (duration.as_secs() as i128);
+        let tv_usec = duration.subsec_micros() as i128;
+
+        this.write_c_ints(&tv, &[tv_sec, tv_usec], &["time_t", "suseconds_t"])?;
+
+        Ok(0)
+    }
+}