Fix bug with reporting wrong thread for races with reads & add thread ids to data...

[rust.git] / src / helpers.rs

diff --git a/src/helpers.rs b/src/helpers.rs
index f5094b169f9ed0e0956568dbe0b9ffda03886091..4c989db0170b5408c71116555a8fcfc0702aab17 100644 (file)
--- a/src/helpers.rs
+++ b/src/helpers.rs
@@ -59,7 +59,7 @@ fn eval_path_scalar(
         let this = self.eval_context_mut();
         let instance = this.resolve_path(path);
         let cid = GlobalId { instance, promoted: None };
-        let const_val = this.const_eval_raw(cid)?;
+        let const_val = this.eval_to_allocation(cid)?;
         let const_val = this.read_scalar(const_val.into())?;
         return Ok(const_val);
     }
@@ -387,7 +387,7 @@ fn check_no_isolation(&self, name: &str) -> InterpResult<'tcx> {
     /// if this is not the case.
     fn assert_target_os(&self, target_os: &str, name: &str) {
         assert_eq!(
-            self.eval_context_ref().tcx.sess.target.target.target_os,
+            self.eval_context_ref().tcx.sess.target.os,
             target_os,
             "`{}` is only available on the `{}` target OS",
             name,
@@ -430,9 +430,9 @@ fn get_last_error(&mut self) -> InterpResult<'tcx, Scalar<Tag>> {
     fn set_last_error_from_io_error(&mut self, e: std::io::Error) -> InterpResult<'tcx> {
         use std::io::ErrorKind::*;
         let this = self.eval_context_mut();
-        let target = &this.tcx.sess.target.target;
-        let target_os = &target.target_os;
-        let last_error = if target.options.target_family == Some("unix".to_owned()) {
+        let target = &this.tcx.sess.target;
+        let target_os = &target.os;
+        let last_error = if target.os_family == Some("unix".to_owned()) {
             this.eval_libc(match e.kind() {
                 ConnectionRefused => "ECONNREFUSED",
                 ConnectionReset => "ECONNRESET",
@@ -530,23 +530,17 @@ fn read_timespec(
         let nanoseconds_scalar = this.read_scalar(nanoseconds_place.into())?;
         let nanoseconds = nanoseconds_scalar.to_machine_isize(this)?;
 
-        let seconds: u64 = if let Ok(s) = seconds.try_into() {
-            s
-        } else {
+        Ok(try {
             // tv_sec must be non-negative.
-            return Ok(None);
-        };
-        let nanoseconds: u32 = if let Ok(ns) = nanoseconds.try_into() {
-            if ns >= 1_000_000_000 {
+            let seconds: u64 = seconds.try_into().ok()?;
+            // tv_nsec must be non-negative.
+            let nanoseconds: u32 = nanoseconds.try_into().ok()?;
+            if nanoseconds >= 1_000_000_000 {
                 // tv_nsec must not be greater than 999,999,999.
-                return Ok(None);
+                None?
             }
-            ns
-        } else {
-            // tv_nsec must be non-negative.
-            return Ok(None);
-        };
-        Ok(Some(Duration::new(seconds, nanoseconds)))
+            Duration::new(seconds, nanoseconds)
+        })
     }
 }
 
@@ -561,7 +555,7 @@ fn read_timespec(
 
 pub fn isolation_error(name: &str) -> InterpResult<'static> {
     throw_machine_stop!(TerminationInfo::UnsupportedInIsolation(format!(
-        "`{}` not available when isolation is enabled",
+        "{} not available when isolation is enabled",
         name,
     )))
 }