-use std::time::{Duration, SystemTime, Instant};
-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`.
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")? {
system_time_to_duration(&SystemTime::now())?
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)
}
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)
}
let NANOS_PER_INTERVAL = NANOS_PER_SEC / INTERVALS_PER_SEC;
let SECONDS_TO_UNIX_EPOCH = INTERVALS_TO_UNIX_EPOCH / INTERVALS_PER_SEC;
- let duration = system_time_to_duration(&SystemTime::now())? + Duration::from_secs(SECONDS_TO_UNIX_EPOCH);
+ let duration = system_time_to_duration(&SystemTime::now())?
+ + Duration::from_secs(SECONDS_TO_UNIX_EPOCH);
let duration_ticks = u64::try_from(duration.as_nanos() / u128::from(NANOS_PER_INTERVAL))
.map_err(|_| err_unsup_format!("programs running more than 2^64 Windows ticks after the Windows epoch are not supported"))?;
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(())
}
#[allow(non_snake_case)]
- fn QueryPerformanceCounter(&mut self, lpPerformanceCount_op: &OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
+ fn QueryPerformanceCounter(
+ &mut self,
+ lpPerformanceCount_op: &OpTy<'tcx, Tag>,
+ ) -> InterpResult<'tcx, i32> {
let this = self.eval_context_mut();
this.assert_target_os("windows", "QueryPerformanceCounter");
// QueryPerformanceCounter uses a hardware counter as its basis.
// Miri will emulate a counter with a resolution of 1 nanosecond.
let duration = Instant::now().duration_since(this.machine.time_anchor);
- let qpc = i64::try_from(duration.as_nanos())
- .map_err(|_| err_unsup_format!("programs running longer than 2^63 nanoseconds are not supported"))?;
- this.write_scalar(Scalar::from_i64(qpc), &this.deref_operand(lpPerformanceCount_op)?.into())?;
+ let qpc = i64::try_from(duration.as_nanos()).map_err(|_| {
+ err_unsup_format!("programs running longer than 2^63 nanoseconds are not supported")
+ })?;
+ this.write_scalar(
+ Scalar::from_i64(qpc),
+ &this.deref_operand(lpPerformanceCount_op)?.into(),
+ )?;
Ok(-1) // return non-zero on success
}
#[allow(non_snake_case)]
- fn QueryPerformanceFrequency(&mut self, lpFrequency_op: &OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
+ fn QueryPerformanceFrequency(
+ &mut self,
+ lpFrequency_op: &OpTy<'tcx, Tag>,
+ ) -> InterpResult<'tcx, i32> {
let this = self.eval_context_mut();
this.assert_target_os("windows", "QueryPerformanceFrequency");
// is consistent across all processors.
// Miri emulates a "hardware" performance counter with a resolution of 1ns,
// and thus 10^9 counts per second.
- this.write_scalar(Scalar::from_i64(1_000_000_000), &this.deref_operand(lpFrequency_op)?.into())?;
+ this.write_scalar(
+ Scalar::from_i64(1_000_000_000),
+ &this.deref_operand(lpFrequency_op)?.into(),
+ )?;
Ok(-1) // Return non-zero on success
}
// This returns a u64, with time units determined dynamically by `mach_timebase_info`.
// We return plain nanoseconds.
let duration = Instant::now().duration_since(this.machine.time_anchor);
- u64::try_from(duration.as_nanos())
- .map_err(|_| err_unsup_format!("programs running longer than 2^64 nanoseconds are not supported").into())
+ u64::try_from(duration.as_nanos()).map_err(|_| {
+ err_unsup_format!("programs running longer than 2^64 nanoseconds are not supported")
+ .into()
+ })
}
fn mach_timebase_info(&mut self, info_op: &OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
// 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)?
- ];
+ let (numer, denom) = (1, 1);
+ this.write_int_fields(&[numer.into(), denom.into()], &info)?;
- this.write_packed_immediates(&info, &imms)?;
Ok(0) // KERN_SUCCESS
}
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")?;
projects / rust.git / blobdiff