follow-up to reviews from RalfJung

Author: JOE1994

src/helpers.rs

@@ -448,31 +448,30 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     }
 
     fn read_os_str_from_target_str<'a>(&'a self, scalar: Scalar<Tag>) -> InterpResult<'tcx, OsString> {
-        if cfg!(target_os = "unix") {
-            self.read_os_str_from_c_str(scalar)
-        } else if cfg!(target_os = "windows") {
-            self.read_os_str_from_wide_str(scalar)
-        } else {
-            throw_unsup_format!("support for target OS not yet available")
+        let target_os = self.eval_context_ref().tcx.sess.target.target.target_os.as_str();
+        match target_os {
+            "linux" => self.read_os_str_from_c_str(scalar).map(|x| x.to_os_string()),
+            "windows" => self.read_os_str_from_wide_str(scalar),
+            _ => throw_unsup_format!("support for target OS not yet available"),
         }
     }
 
     /// 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, scalar: Scalar<Tag>) -> InterpResult<'tcx, OsString>
+    fn read_os_str_from_c_str<'a>(&'a self, scalar: Scalar<Tag>) -> InterpResult<'tcx, &'a OsStr>
     where
         'tcx: 'a,
         'mir: 'a,
     {
         #[cfg(target_os = "unix")]
-        fn bytes_to_os_str<'tcx>(bytes: &[u8]) -> InterpResult<'tcx, OsString> {
-            Ok(std::os::unix::ffi::OsStringExt::from_bytes(bytes).to_os_string())
+        fn bytes_to_os_str<'tcx, 'a>(bytes: &'a [u8]) -> InterpResult<'tcx, &'a OsStr> {
+            Ok(std::os::unix::ffi::OsStringExt::from_bytes(bytes))
         }
         #[cfg(not(target_os = "unix"))]
-        fn bytes_to_os_str<'tcx>(bytes: &[u8]) -> InterpResult<'tcx, OsString> {
+        fn bytes_to_os_str<'tcx, 'a>(bytes: &'a [u8]) -> InterpResult<'tcx, &'a OsStr> {
             let s = std::str::from_utf8(bytes)
                 .map_err(|_| err_unsup_format!("{:?} is not a valid utf-8 string", bytes))?;
-            Ok(OsStr::new(s).to_os_string())
+            Ok(OsStr::new(s))
         }
 
         let this = self.eval_context_ref();
@@ -509,12 +508,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         mplace: MPlaceTy<'tcx, Tag>,
         size: u64,
     ) -> InterpResult<'tcx, (bool, u64)> {
-        if cfg!(target_os = "unix") {
-            self.write_os_str_to_c_str(os_str, mplace.ptr, size)
-        } else if cfg!(target_os = "windows") {
-            self.write_os_str_to_wide_str(os_str, mplace, size)
-        } else {
-            panic!("support for target OS not yet available")
+        let target_os = self.eval_context_ref().tcx.sess.target.target.target_os.as_str();
+        match target_os {
+            "linux" => self.write_os_str_to_c_str(os_str, mplace.ptr, size),
+            "windows" => self.write_os_str_to_wide_str(os_str, mplace, size),
+            _ => panic!("support for target OS not yet available"),
         }
     }
 
@@ -574,7 +572,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         }
         #[cfg(not(target_os = "windows"))]
         fn os_str_to_u16vec(os_str: &OsStr) -> Vec<u16> {
-            os_str.to_str().encode_utf16().collect()
+            os_str.to_str().unwrap().encode_utf16().collect()
         }
 
         let u16_vec = os_str_to_u16vec(os_str);
@@ -589,7 +587,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
         // Store the UTF-16 string.
         let char_size = Size::from_bytes(2);
-        for (idx, &c) in u16_vec.iter().enumerate() {
+        for (idx, c) in u16_vec.into_iter().chain(iter::once(0x0000)).enumerate() {
             let place = this.mplace_field(mplace, idx as u64)?; 
             this.write_scalar(Scalar::from_uint(c, char_size), place.into())?;
         }
@@ -601,12 +599,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         os_str: &OsStr,
         memkind: MemoryKind<MiriMemoryKind>,
     ) -> MPlaceTy<'tcx, Tag> {
-        if cfg!(target_os = "unix") {
-            self.alloc_os_str_as_c_str(os_str, memkind)
-        } else if cfg!(target_os = "windows") {
-            self.alloc_os_str_as_wide_str(os_str, memkind)
-        } else {
-            panic!("support for target OS not yet available")
+        let target_os = self.eval_context_ref().tcx.sess.target.target.target_os.as_str();
+        match target_os {
+            "linux" => self.alloc_os_str_as_c_str(os_str, memkind),
+            "windows" => self.alloc_os_str_as_wide_str(os_str, memkind),
         }
     }