Use MaybeUninit

Author: Zoxc

compiler/rustc_query_system/src/dep_graph/serialized.rs

@@ -454,8 +454,8 @@ impl NodeInfo {
 
         let bytes_per_index = header.bytes_per_index();
         for node_index in edges.iter() {
-            e.write_with(|dest| {
-                *dest = node_index.as_u32().to_le_bytes();
+            e.write_with::<4>(|dest| {
+                dest.write_copy_of_slice(&node_index.as_u32().to_le_bytes());
                 bytes_per_index
             });
         }
@@ -492,8 +492,8 @@ impl NodeInfo {
         let bytes_per_index = header.bytes_per_index();
         for node_index in edges {
             let node_index = colors.current(node_index).unwrap();
-            e.write_with(|dest| {
-                *dest = node_index.as_u32().to_le_bytes();
+            e.write_with::<4>(|dest| {
+                dest.write_copy_of_slice(&node_index.as_u32().to_le_bytes());
                 bytes_per_index
             });
         }

compiler/rustc_query_system/src/lib.rs

@@ -4,6 +4,7 @@
 #![feature(core_intrinsics)]
 #![feature(dropck_eyepatch)]
 #![feature(let_chains)]
+#![feature(maybe_uninit_write_slice)]
 #![feature(min_specialization)]
 // tidy-alphabetical-end
 

compiler/rustc_serialize/src/leb128.rs

@@ -1,5 +1,7 @@
 // This code is very hot and uses lots of arithmetic, avoid overflow checks for performance.
 // See https://github.com/rust-lang/rust/pull/119440#issuecomment-1874255727
+use std::mem::MaybeUninit;
+
 use crate::int_overflow::DebugStrictAdd;
 use crate::opaque::MemDecoder;
 use crate::serialize::Decoder;
@@ -18,20 +20,23 @@ pub const fn largest_max_leb128_len() -> usize {
 macro_rules! impl_write_unsigned_leb128 {
     ($fn_name:ident, $int_ty:ty) => {
         #[inline]
-        pub fn $fn_name(out: &mut [u8; max_leb128_len::<$int_ty>()], mut value: $int_ty) -> usize {
+        pub fn $fn_name(
+            out: &mut [MaybeUninit<u8>; max_leb128_len::<$int_ty>()],
+            mut value: $int_ty,
+        ) -> usize {
             let mut i = 0;
 
             loop {
                 if value < 0x80 {
                     unsafe {
-                        *out.get_unchecked_mut(i) = value as u8;
+                        out.get_unchecked_mut(i).write(value as u8);
                     }
 
                     i = i.debug_strict_add(1);
                     break;
                 } else {
                     unsafe {
-                        *out.get_unchecked_mut(i) = ((value & 0x7f) | 0x80) as u8;
+                        out.get_unchecked_mut(i).write(((value & 0x7f) | 0x80) as u8);
                     }
 
                     value >>= 7;
@@ -87,7 +92,10 @@ impl_read_unsigned_leb128!(read_usize_leb128, usize);
 macro_rules! impl_write_signed_leb128 {
     ($fn_name:ident, $int_ty:ty) => {
         #[inline]
-        pub fn $fn_name(out: &mut [u8; max_leb128_len::<$int_ty>()], mut value: $int_ty) -> usize {
+        pub fn $fn_name(
+            out: &mut [MaybeUninit<u8>; max_leb128_len::<$int_ty>()],
+            mut value: $int_ty,
+        ) -> usize {
             let mut i = 0;
 
             loop {
@@ -101,7 +109,7 @@ macro_rules! impl_write_signed_leb128 {
                 }
 
                 unsafe {
-                    *out.get_unchecked_mut(i) = byte;
+                    out.get_unchecked_mut(i).write(byte);
                 }
 
                 i = i.debug_strict_add(1);

compiler/rustc_serialize/src/leb128/tests.rs

@@ -1,3 +1,5 @@
+use std::mem::MaybeUninit;
+
 use super::*;
 use crate::Decoder;
 use crate::opaque::{MAGIC_END_BYTES, MemDecoder};
@@ -21,10 +23,10 @@ macro_rules! impl_test_unsigned_leb128 {
 
             let mut stream = Vec::new();
 
-            let mut buf = Default::default();
+            let mut buf = [const { MaybeUninit::<u8>::uninit() }; max_leb128_len::<$int_ty>()];
             for &x in &values {
                 let n = $write_fn_name(&mut buf, x);
-                stream.extend(&buf[..n]);
+                stream.extend(unsafe { buf[..n].assume_init_ref() });
             }
             let stream_end = stream.len();
             stream.extend(MAGIC_END_BYTES);
@@ -70,10 +72,10 @@ macro_rules! impl_test_signed_leb128 {
 
             let mut stream = Vec::new();
 
-            let mut buf = Default::default();
+            let mut buf = [const { MaybeUninit::<u8>::uninit() }; max_leb128_len::<$int_ty>()];
             for &x in &values {
                 let n = $write_fn_name(&mut buf, x);
-                stream.extend(&buf[..n]);
+                stream.extend(unsafe { buf[..n].assume_init_ref() });
             }
             let stream_end = stream.len();
             stream.extend(MAGIC_END_BYTES);

compiler/rustc_serialize/src/lib.rs

@@ -11,6 +11,8 @@
 )]
 #![doc(rust_logo)]
 #![feature(core_intrinsics)]
+#![feature(maybe_uninit_slice)]
+#![feature(maybe_uninit_write_slice)]
 #![feature(min_specialization)]
 #![feature(never_type)]
 #![feature(rustdoc_internals)]

compiler/rustc_serialize/src/opaque.rs

@@ -1,6 +1,7 @@
 use std::fs::File;
 use std::io::{self, Write};
 use std::marker::PhantomData;
+use std::mem::{MaybeUninit, transmute};
 use std::ops::Range;
 use std::path::{Path, PathBuf};
 
@@ -168,6 +169,15 @@ impl FileEncoder {
         self.buffered = self.buffered.debug_strict_add(written);
     }
 
+    /// This is a variant of `write_with` which gives out a `MaybeUninit` slice.
+    #[inline]
+    fn write_with_uninit<const N: usize>(
+        &mut self,
+        visitor: impl FnOnce(&mut [MaybeUninit<u8>; N]) -> usize,
+    ) {
+        self.write_with(|buf: &mut [u8; N]| visitor(unsafe { transmute(buf) }))
+    }
+
     #[cold]
     #[inline(never)]
     fn panic_invalid_write<const N: usize>(written: usize) {
@@ -210,7 +220,7 @@ macro_rules! write_leb128 {
     ($this_fn:ident, $int_ty:ty, $write_leb_fn:ident) => {
         #[inline]
         fn $this_fn(&mut self, v: $int_ty) {
-            self.write_with(|buf| leb128::$write_leb_fn(buf, v))
+            self.write_with_uninit(|buf| leb128::$write_leb_fn(buf, v))
         }
     };
 }

compiler/rustc_serialize/src/opaque/mem_encoder.rs

@@ -1,3 +1,5 @@
+use std::mem::MaybeUninit;
+
 use super::IntEncodedWithFixedSize;
 use crate::{Encodable, Encoder, leb128};
 
@@ -31,12 +33,16 @@ impl MemEncoder {
     /// architectures support fixed-size writes up to 8 bytes with one instruction, so while this
     /// does in some sense do wasted work, we come out ahead.
     #[inline]
-    pub fn write_with<const N: usize>(&mut self, visitor: impl FnOnce(&mut [u8; N]) -> usize) {
+    pub fn write_with<const N: usize>(
+        &mut self,
+        visitor: impl FnOnce(&mut [MaybeUninit<u8>; N]) -> usize,
+    ) {
         self.data.reserve(N);
 
         let old_len = self.data.len();
         // SAFETY: fix
-        let buf = unsafe { &mut *(self.data.as_mut_ptr().add(old_len) as *mut [u8; N]) };
+        let buf =
+            unsafe { &mut *(self.data.as_mut_ptr().add(old_len) as *mut [MaybeUninit<u8>; N]) };
         let written = visitor(buf);
         if written > N {
             Self::panic_invalid_write::<N>(written);
@@ -53,8 +59,8 @@ impl MemEncoder {
     /// Helper for calls where [`MemEncoder::write_with`] always writes the whole array.
     #[inline]
     pub fn write_array<const N: usize>(&mut self, buf: [u8; N]) {
-        self.write_with(|dest| {
-            *dest = buf;
+        self.write_with::<N>(|dest| {
+            dest.write_copy_of_slice(&buf);
             N
         })
     }