Amend experimental thread support warnings

[rust.git] / src / shims / time.rs

diff --git a/src/shims/time.rs b/src/shims/time.rs
index d293e4d12774463bdc391e258fbfd363e68ee152..be453a429ec5192616e31f6741b47cba0f865c53 100644 (file)
--- a/src/shims/time.rs
+++ b/src/shims/time.rs
@@ -1,9 +1,6 @@
-use std::convert::TryFrom;
 use std::time::{Duration, Instant, SystemTime};
 
-use crate::stacked_borrows::Tag;
 use crate::*;
-use helpers::{immty_from_int_checked, immty_from_uint_checked};
 use thread::Time;
 
 /// Returns the time elapsed between the provided time and the unix epoch as a `Duration`.
@@ -19,19 +16,32 @@ fn clock_gettime(
         clk_id_op: &OpTy<'tcx, Tag>,
         tp_op: &OpTy<'tcx, Tag>,
     ) -> InterpResult<'tcx, i32> {
+        // This clock support is deliberately minimal because a lot of clock types have fiddly
+        // properties (is it possible for Miri to be suspended independently of the host?). If you
+        // have a use for another clock type, please open an issue.
+
         let this = self.eval_context_mut();
 
         this.assert_target_os("linux", "clock_gettime");
         this.check_no_isolation("`clock_gettime`")?;
 
         let clk_id = this.read_scalar(clk_id_op)?.to_i32()?;
-        let tp = this.deref_operand(tp_op)?;
 
-        let duration = if clk_id == this.eval_libc_i32("CLOCK_REALTIME")? {
+        // Linux has two main kinds of clocks. REALTIME clocks return the actual time since the
+        // Unix epoch, including effects which may cause time to move backwards such as NTP.
+        // Linux further distinguishes regular and "coarse" clocks, but the "coarse" version
+        // is just specified to be "faster and less precise", so we implement both the same way.
+        let absolute_clocks =
+            [this.eval_libc_i32("CLOCK_REALTIME")?, this.eval_libc_i32("CLOCK_REALTIME_COARSE")?];
+        // The second kind is MONOTONIC clocks for which 0 is an arbitrary time point, but they are
+        // never allowed to go backwards. We don't need to do any additonal monotonicity
+        // enforcement because std::time::Instant already guarantees that it is monotonic.
+        let relative_clocks =
+            [this.eval_libc_i32("CLOCK_MONOTONIC")?, this.eval_libc_i32("CLOCK_MONOTONIC_COARSE")?];
+
+        let duration = if absolute_clocks.contains(&clk_id) {
             system_time_to_duration(&SystemTime::now())?
-        } else if clk_id == this.eval_libc_i32("CLOCK_MONOTONIC")? {
-            // Absolute time does not matter, only relative time does, so we can just
-            // use our own time anchor here.
+        } else if relative_clocks.contains(&clk_id) {
             Instant::now().duration_since(this.machine.time_anchor)
         } else {
             let einval = this.eval_libc("EINVAL")?;
@@ -42,12 +52,7 @@ fn clock_gettime(
         let tv_sec = duration.as_secs();
         let tv_nsec = duration.subsec_nanos();
 
-        let imms = [
-            immty_from_int_checked(tv_sec, this.libc_ty_layout("time_t")?)?,
-            immty_from_int_checked(tv_nsec, this.libc_ty_layout("c_long")?)?,
-        ];
-
-        this.write_packed_immediates(&tp, &imms)?;
+        this.write_int_fields(&[tv_sec.into(), tv_nsec.into()], &this.deref_operand(tp_op)?)?;
 
         Ok(0)
     }
@@ -63,25 +68,18 @@ fn gettimeofday(
         this.check_no_isolation("`gettimeofday`")?;
 
         // Using tz is obsolete and should always be null
-        let tz = this.read_scalar(tz_op)?.check_init()?;
-        if !this.is_null(tz)? {
+        let tz = this.read_pointer(tz_op)?;
+        if !this.ptr_is_null(tz)? {
             let einval = this.eval_libc("EINVAL")?;
             this.set_last_error(einval)?;
             return Ok(-1);
         }
 
-        let tv = this.deref_operand(tv_op)?;
-
         let duration = system_time_to_duration(&SystemTime::now())?;
         let tv_sec = duration.as_secs();
         let tv_usec = duration.subsec_micros();
 
-        let imms = [
-            immty_from_int_checked(tv_sec, this.libc_ty_layout("time_t")?)?,
-            immty_from_int_checked(tv_usec, this.libc_ty_layout("suseconds_t")?)?,
-        ];
-
-        this.write_packed_immediates(&tv, &imms)?;
+        this.write_int_fields(&[tv_sec.into(), tv_usec.into()], &this.deref_operand(tv_op)?)?;
 
         Ok(0)
     }
@@ -106,12 +104,11 @@ fn GetSystemTimeAsFileTime(&mut self, LPFILETIME_op: &OpTy<'tcx, Tag>) -> Interp
 
         let dwLowDateTime = u32::try_from(duration_ticks & 0x00000000FFFFFFFF).unwrap();
         let dwHighDateTime = u32::try_from((duration_ticks & 0xFFFFFFFF00000000) >> 32).unwrap();
-        let DWORD_tylayout = this.machine.layouts.u32;
-        let imms = [
-            immty_from_uint_checked(dwLowDateTime, DWORD_tylayout)?,
-            immty_from_uint_checked(dwHighDateTime, DWORD_tylayout)?,
-        ];
-        this.write_packed_immediates(&this.deref_operand(LPFILETIME_op)?, &imms)?;
+        this.write_int_fields(
+            &[dwLowDateTime.into(), dwHighDateTime.into()],
+            &this.deref_operand(LPFILETIME_op)?,
+        )?;
+
         Ok(())
     }
 
@@ -186,12 +183,8 @@ fn mach_timebase_info(&mut self, info_op: &OpTy<'tcx, Tag>) -> InterpResult<'tcx
         // Since our emulated ticks in `mach_absolute_time` *are* nanoseconds,
         // no scaling needs to happen.
         let (numer, denom) = (1, 1);
-        let imms = [
-            immty_from_int_checked(numer, this.machine.layouts.u32)?,
-            immty_from_int_checked(denom, this.machine.layouts.u32)?,
-        ];
+        this.write_int_fields(&[numer.into(), denom.into()], &info)?;
 
-        this.write_packed_immediates(&info, &imms)?;
         Ok(0) // KERN_SUCCESS
     }
 
@@ -206,7 +199,7 @@ fn nanosleep(
 
         this.check_no_isolation("`nanosleep`")?;
 
-        let duration = match this.read_timespec(req_op)? {
+        let duration = match this.read_timespec(&this.deref_operand(req_op)?)? {
             Some(duration) => duration,
             None => {
                 let einval = this.eval_libc("EINVAL")?;