Auto merge of #2245 - saethlin:color-always, r=RalfJung

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

diff --git a/src/shims/os_str.rs b/src/shims/os_str.rs
index ea99921c0b67648b3628b757547c61422cf8bdc1..d6669b21a731a8fde8b7e59d5d964bb7d3881b1e 100644 (file)
--- a/src/shims/os_str.rs
+++ b/src/shims/os_str.rs
@@ -1,5 +1,4 @@
 use std::borrow::Cow;
-use std::convert::TryFrom;
 use std::ffi::{OsStr, OsString};
 use std::iter;
 use std::path::{Path, PathBuf};
@@ -9,7 +8,8 @@
 #[cfg(windows)]
 use std::os::windows::ffi::{OsStrExt, OsStringExt};
 
-use rustc_target::abi::{Align, LayoutOf, Size};
+use rustc_middle::ty::layout::LayoutOf;
+use rustc_target::abi::{Align, Size};
 
 use crate::*;
 
@@ -50,19 +50,25 @@ impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mi
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
     /// Helper function to read an OsString from a null-terminated sequence of bytes, which is what
     /// the Unix APIs usually handle.
-    fn read_os_str_from_c_str<'a>(&'a self, sptr: Scalar<Tag>) -> InterpResult<'tcx, &'a OsStr>
+    fn read_os_str_from_c_str<'a>(
+        &'a self,
+        ptr: Pointer<Option<Tag>>,
+    ) -> InterpResult<'tcx, &'a OsStr>
     where
         'tcx: 'a,
         'mir: 'a,
     {
         let this = self.eval_context_ref();
-        let bytes = this.read_c_str(sptr)?;
+        let bytes = this.read_c_str(ptr)?;
         bytes_to_os_str(bytes)
     }
 
     /// Helper function to read an OsString from a 0x0000-terminated sequence of u16,
     /// which is what the Windows APIs usually handle.
-    fn read_os_str_from_wide_str<'a>(&'a self, sptr: Scalar<Tag>) -> InterpResult<'tcx, OsString>
+    fn read_os_str_from_wide_str<'a>(
+        &'a self,
+        ptr: Pointer<Option<Tag>>,
+    ) -> InterpResult<'tcx, OsString>
     where
         'tcx: 'a,
         'mir: 'a,
@@ -72,13 +78,13 @@ pub fn u16vec_to_osstring<'tcx, 'a>(u16_vec: Vec<u16>) -> InterpResult<'tcx, OsS
             Ok(OsString::from_wide(&u16_vec[..]))
         }
         #[cfg(not(windows))]
-        pub fn u16vec_to_osstring<'tcx, 'a>(u16_vec: Vec<u16>) -> InterpResult<'tcx, OsString> {
+        pub fn u16vec_to_osstring<'tcx>(u16_vec: Vec<u16>) -> InterpResult<'tcx, OsString> {
             let s = String::from_utf16(&u16_vec[..])
                 .map_err(|_| err_unsup_format!("{:?} is not a valid utf-16 string", u16_vec))?;
             Ok(s.into())
         }
 
-        let u16_vec = self.eval_context_ref().read_wide_str(sptr)?;
+        let u16_vec = self.eval_context_ref().read_wide_str(ptr)?;
         u16vec_to_osstring(u16_vec)
     }
 
@@ -90,7 +96,7 @@ pub fn u16vec_to_osstring<'tcx, 'a>(u16_vec: Vec<u16>) -> InterpResult<'tcx, OsS
     fn write_os_str_to_c_str(
         &mut self,
         os_str: &OsStr,
-        sptr: Scalar<Tag>,
+        ptr: Pointer<Option<Tag>>,
         size: u64,
     ) -> InterpResult<'tcx, (bool, u64)> {
         let bytes = os_str_to_bytes(os_str)?;
@@ -101,8 +107,7 @@ fn write_os_str_to_c_str(
             return Ok((false, string_length));
         }
         self.eval_context_mut()
-            .memory
-            .write_bytes(sptr, bytes.iter().copied().chain(iter::once(0u8)))?;
+            .write_bytes_ptr(ptr, bytes.iter().copied().chain(iter::once(0u8)))?;
         Ok((true, string_length))
     }
 
@@ -114,7 +119,7 @@ fn write_os_str_to_c_str(
     fn write_os_str_to_wide_str(
         &mut self,
         os_str: &OsStr,
-        sptr: Scalar<Tag>,
+        ptr: Pointer<Option<Tag>>,
         size: u64,
     ) -> InterpResult<'tcx, (bool, u64)> {
         #[cfg(windows)]
@@ -145,8 +150,7 @@ fn os_str_to_u16vec<'tcx>(os_str: &OsStr) -> InterpResult<'tcx, Vec<u16>> {
         let size2 = Size::from_bytes(2);
         let this = self.eval_context_mut();
         let mut alloc = this
-            .memory
-            .get_mut(sptr, size2 * string_length, Align::from_bytes(2).unwrap())?
+            .get_ptr_alloc_mut(ptr, size2 * string_length, Align::from_bytes(2).unwrap())?
             .unwrap(); // not a ZST, so we will get a result
         for (offset, wchar) in u16_vec.into_iter().chain(iter::once(0x0000)).enumerate() {
             let offset = u64::try_from(offset).unwrap();
@@ -161,14 +165,14 @@ fn alloc_os_str_as_c_str(
         &mut self,
         os_str: &OsStr,
         memkind: MemoryKind<MiriMemoryKind>,
-    ) -> InterpResult<'tcx, Pointer<Tag>> {
+    ) -> InterpResult<'tcx, Pointer<Option<Tag>>> {
         let size = u64::try_from(os_str.len()).unwrap().checked_add(1).unwrap(); // Make space for `0` terminator.
         let this = self.eval_context_mut();
 
         let arg_type = this.tcx.mk_array(this.tcx.types.u8, size);
         let arg_place = this.allocate(this.layout_of(arg_type).unwrap(), memkind)?;
         assert!(self.write_os_str_to_c_str(os_str, arg_place.ptr, size).unwrap().0);
-        Ok(arg_place.ptr.assert_ptr())
+        Ok(arg_place.ptr)
     }
 
     /// Allocate enough memory to store the given `OsStr` as a null-terminated sequence of `u16`.
@@ -176,24 +180,27 @@ fn alloc_os_str_as_wide_str(
         &mut self,
         os_str: &OsStr,
         memkind: MemoryKind<MiriMemoryKind>,
-    ) -> InterpResult<'tcx, Pointer<Tag>> {
+    ) -> InterpResult<'tcx, Pointer<Option<Tag>>> {
         let size = u64::try_from(os_str.len()).unwrap().checked_add(1).unwrap(); // Make space for `0x0000` terminator.
         let this = self.eval_context_mut();
 
         let arg_type = this.tcx.mk_array(this.tcx.types.u16, size);
         let arg_place = this.allocate(this.layout_of(arg_type).unwrap(), memkind)?;
         assert!(self.write_os_str_to_wide_str(os_str, arg_place.ptr, size).unwrap().0);
-        Ok(arg_place.ptr.assert_ptr())
+        Ok(arg_place.ptr)
     }
 
     /// Read a null-terminated sequence of bytes, and perform path separator conversion if needed.
-    fn read_path_from_c_str<'a>(&'a self, sptr: Scalar<Tag>) -> InterpResult<'tcx, Cow<'a, Path>>
+    fn read_path_from_c_str<'a>(
+        &'a self,
+        ptr: Pointer<Option<Tag>>,
+    ) -> InterpResult<'tcx, Cow<'a, Path>>
     where
         'tcx: 'a,
         'mir: 'a,
     {
         let this = self.eval_context_ref();
-        let os_str = this.read_os_str_from_c_str(sptr)?;
+        let os_str = this.read_os_str_from_c_str(ptr)?;
 
         Ok(match this.convert_path_separator(Cow::Borrowed(os_str), PathConversion::TargetToHost) {
             Cow::Borrowed(x) => Cow::Borrowed(Path::new(x)),
@@ -202,9 +209,9 @@ fn read_path_from_c_str<'a>(&'a self, sptr: Scalar<Tag>) -> InterpResult<'tcx, C
     }
 
     /// Read a null-terminated sequence of `u16`s, and perform path separator conversion if needed.
-    fn read_path_from_wide_str(&self, sptr: Scalar<Tag>) -> InterpResult<'tcx, PathBuf> {
+    fn read_path_from_wide_str(&self, ptr: Pointer<Option<Tag>>) -> InterpResult<'tcx, PathBuf> {
         let this = self.eval_context_ref();
-        let os_str = this.read_os_str_from_wide_str(sptr)?;
+        let os_str = this.read_os_str_from_wide_str(ptr)?;
 
         Ok(this
             .convert_path_separator(Cow::Owned(os_str), PathConversion::TargetToHost)
@@ -217,13 +224,13 @@ fn read_path_from_wide_str(&self, sptr: Scalar<Tag>) -> InterpResult<'tcx, PathB
     fn write_path_to_c_str(
         &mut self,
         path: &Path,
-        sptr: Scalar<Tag>,
+        ptr: Pointer<Option<Tag>>,
         size: u64,
     ) -> InterpResult<'tcx, (bool, u64)> {
         let this = self.eval_context_mut();
         let os_str = this
             .convert_path_separator(Cow::Borrowed(path.as_os_str()), PathConversion::HostToTarget);
-        this.write_os_str_to_c_str(&os_str, sptr, size)
+        this.write_os_str_to_c_str(&os_str, ptr, size)
     }
 
     /// Write a Path to the machine memory (as a null-terminated sequence of `u16`s),
@@ -231,13 +238,13 @@ fn write_path_to_c_str(
     fn write_path_to_wide_str(
         &mut self,
         path: &Path,
-        sptr: Scalar<Tag>,
+        ptr: Pointer<Option<Tag>>,
         size: u64,
     ) -> InterpResult<'tcx, (bool, u64)> {
         let this = self.eval_context_mut();
         let os_str = this
             .convert_path_separator(Cow::Borrowed(path.as_os_str()), PathConversion::HostToTarget);
-        this.write_os_str_to_wide_str(&os_str, sptr, size)
+        this.write_os_str_to_wide_str(&os_str, ptr, size)
     }
 
     fn convert_path_separator<'a>(