diff --git a/libcc2rs/src/rc.rs b/libcc2rs/src/rc.rs index f7f22dfad..248e89a7c 100644 --- a/libcc2rs/src/rc.rs +++ b/libcc2rs/src/rc.rs @@ -1952,6 +1952,46 @@ mod tests { p.delete(); } + #[test] + fn reinterpreted_slice_writeback_encodes_only_partial_elements() { + #[derive(Clone)] + struct Word([u8; 4], Rc>); + impl ByteRepr for Word { + fn byte_size() -> usize { + 4 + } + fn to_bytes(&self, buf: &mut [u8]) { + self.1.set(self.1.get() + 1); + buf.copy_from_slice(&self.0); + } + fn assign_bytes(&mut self, buf: &[u8]) { + self.0.copy_from_slice(buf); + } + } + + let encodes = Rc::new(std::cell::Cell::new(0)); + let words: Value> = Rc::new(RefCell::new( + vec![Word([0xA5; 4], encodes.clone()); 3].into_boxed_slice(), + )); + let bytes = words.decay().reinterpret_cast::(); + bytes.with_slice_mut(12, |buf| { + assert_eq!(buf, &[0xA5; 12]); + encodes.set(0); + buf.fill(1); + }); + assert_eq!(encodes.get(), 0); + bytes.offset(2).with_slice_mut(8, |buf| { + assert_eq!(buf, &[1; 8]); + encodes.set(0); + buf.fill(2); + }); + assert_eq!(encodes.get(), 2); + let words = words.borrow(); + assert_eq!(words[0].0, [1, 1, 2, 2]); + assert_eq!(words[1].0, [2; 4]); + assert_eq!(words[2].0, [2, 2, 1, 1]); + } + #[test] fn reinterpreted_u8_storage_is_read_and_written_bytewise() { let p: Ptr = Ptr::alloc_array(vec![0u8; 16].into_boxed_slice()); diff --git a/libcc2rs/src/reinterpret.rs b/libcc2rs/src/reinterpret.rs index 0dcd4c0a5..39611a2a2 100644 --- a/libcc2rs/src/reinterpret.rs +++ b/libcc2rs/src/reinterpret.rs @@ -520,20 +520,34 @@ fn slice_write_bytes(slice: &mut [S], byte_offset: usize, data: &[u let elem_size = S::byte_size(); let first_elem = byte_offset / elem_size; let last_elem = (byte_offset + data.len()).div_ceil(elem_size); - if byte_offset.is_multiple_of(elem_size) && data.len() == elem_size { - slice[first_elem].assign_bytes(data); + let slice = &mut slice[first_elem..last_elem]; + if slice.is_empty() { + return; + } + if data.len() == elem_size && byte_offset.is_multiple_of(elem_size) { + slice[0].assign_bytes(data); return; } with_scratch(elem_size, |elem_buf| { - for (idx, elem) in slice[first_elem..last_elem].iter_mut().enumerate() { - let elem_byte_start = (first_elem + idx) * elem_size; + let mut elems = slice.iter_mut(); + let mut data = data; + let start = byte_offset % elem_size; + if start != 0 { + let elem = elems.next().unwrap(); + let len = data.len().min(elem_size - start); + elem.to_bytes(elem_buf); + elem_buf[start..start + len].copy_from_slice(&data[..len]); + elem.assign_bytes(elem_buf); + data = &data[len..]; + } + let mut chunks = data.chunks_exact(elem_size); + for (bytes, elem) in chunks.by_ref().zip(elems.by_ref()) { + elem.assign_bytes(bytes); + } + if let Some(elem) = elems.next() { + let tail = chunks.remainder(); elem.to_bytes(elem_buf); - let overlap_start = byte_offset.max(elem_byte_start) - elem_byte_start; - let overlap_end = - (byte_offset + data.len()).min(elem_byte_start + elem_size) - elem_byte_start; - let data_start = byte_offset.max(elem_byte_start) - byte_offset; - elem_buf[overlap_start..overlap_end] - .copy_from_slice(&data[data_start..data_start + (overlap_end - overlap_start)]); + elem_buf[..tail.len()].copy_from_slice(tail); elem.assign_bytes(elem_buf); } });