Fix read_wide_string implementation

Author: tyilo

src/helpers.rs

@@ -918,11 +918,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         mut ptr: Pointer<Option<Provenance>>,
         size: Size,
         align: Align,
-    ) -> InterpResult<'tcx, Size> {
+    ) -> InterpResult<'tcx, u64> {
         let this = self.eval_context_ref();
         this.check_ptr_align(ptr, align)?;
 
-        let mut len = Size::ZERO;
+        let mut len = 0;
         loop {
             // FIXME: We are re-getting the allocation each time around the loop.
             // Would be nice if we could somehow "extend" an existing AllocRange.
@@ -931,25 +931,25 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
             if c == 0 {
                 break;
             } else {
-                len += Size::from_bytes(1);
+                len += 1;
                 ptr = ptr.offset(size, this)?;
             }
         }
         Ok(len)
     }
 
     /// Calculates the length of a null terminated string of bytes.
-    fn strlen(&self, ptr: Pointer<Option<Provenance>>) -> InterpResult<'tcx, Size> {
+    fn strlen(&self, ptr: Pointer<Option<Provenance>>) -> InterpResult<'tcx, u64> {
         self.generic_strlen(ptr, Size::from_bytes(1), Align::from_bytes(1).unwrap())
     }
 
     /// Calculates the length of a null terminated string of u16.
-    fn u16_strlen(&self, ptr: Pointer<Option<Provenance>>) -> InterpResult<'tcx, Size> {
+    fn u16_strlen(&self, ptr: Pointer<Option<Provenance>>) -> InterpResult<'tcx, u64> {
         self.generic_strlen(ptr, Size::from_bytes(2), Align::from_bytes(2).unwrap())
     }
 
     /// Calculates the length of a null terminated string of wchar_t.
-    fn wchar_t_strlen(&self, ptr: Pointer<Option<Provenance>>) -> InterpResult<'tcx, Size> {
+    fn wchar_t_strlen(&self, ptr: Pointer<Option<Provenance>>) -> InterpResult<'tcx, u64> {
         let this = self.eval_context_ref();
         let wchar_t = this.libc_ty_layout("wchar_t");
         self.generic_strlen(ptr, wchar_t.size, wchar_t.align.abi)
@@ -976,7 +976,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         'mir: 'a,
     {
         let this = self.eval_context_ref();
-        let len = this.strlen(ptr)?;
+        let len = Size::from_bytes(this.strlen(ptr)?);
         this.read_bytes_ptr_strip_provenance(ptr, len)
     }
 
@@ -1014,8 +1014,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     {
         let this = self.eval_context_ref();
         let len = this.u16_strlen(ptr)?;
-        let bytes = this.read_bytes_ptr_strip_provenance(ptr, len)?;
-        unsafe { Ok(bytes.align_to::<u16>().1) }
+        let bytes = this.read_bytes_ptr_strip_provenance(ptr, Size::from_bytes(2 * len))?;
+        unsafe {
+            Ok(std::slice::from_raw_parts(bytes.as_ptr().cast::<u16>(), len.try_into().unwrap()))
+        }
     }
 
     /// Helper function to write a sequence of u16 with an added 0x0000-terminator, which is what

src/shims/foreign_items.rs

@@ -804,14 +804,14 @@ trait EvalContextExtPriv<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 let ptr = this.read_pointer(ptr)?;
                 // This reads at least 1 byte, so we are already enforcing that this is a valid pointer.
                 let n = this.strlen(ptr)?;
-                this.write_scalar(Scalar::from_target_usize(n.bytes(), this), dest)?;
+                this.write_scalar(Scalar::from_target_usize(n, this), dest)?;
             }
             "wcslen" => {
                 let [ptr] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
                 let ptr = this.read_pointer(ptr)?;
                 // This reads at least 1 byte, so we are already enforcing that this is a valid pointer.
                 let n = this.wchar_t_strlen(ptr)?;
-                this.write_scalar(Scalar::from_target_usize(n.bytes(), this), dest)?;
+                this.write_scalar(Scalar::from_target_usize(n, this), dest)?;
             }
             "memcpy" => {
                 let [ptr_dest, ptr_src, n] =
@@ -840,7 +840,7 @@ trait EvalContextExtPriv<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 // That is probably overly cautious, but there also is no fundamental
                 // reason to have `strcpy` destroy pointer provenance.
                 // This reads at least 1 byte, so we are already enforcing that this is a valid pointer.
-                let n = this.strlen(ptr_src)?.bytes().checked_add(1).unwrap();
+                let n = this.strlen(ptr_src)?.checked_add(1).unwrap();
                 this.mem_copy(ptr_src, ptr_dest, Size::from_bytes(n), true)?;
                 this.write_pointer(ptr_dest, dest)?;
             }