Make core::mem::MaybeUninit::zeroed a const fn

src/libcore/lib.rs

@@ -128,6 +128,7 @@
 #![feature(const_transmute)]
 #![feature(reverse_bits)]
 #![feature(non_exhaustive)]
+#![cfg_attr(not(stage0), feature(const_write_bytes))]
 
 #[prelude_import]
 #[allow(unused)]

src/libcore/mem.rs

@@ -1039,6 +1039,19 @@ impl<T> MaybeUninit<T> {
     /// Note that dropping a `MaybeUninit` will never call `T`'s drop code.
     /// It is your responsibility to make sure `T` gets dropped if it got initialized.
     #[unstable(feature = "maybe_uninit", issue = "53491")]
+    #[rustc_const_unstable(feature = "const_maybe_uninit_zeroed")]
+    #[cfg(not(stage0))]
+    pub const fn zeroed() -> MaybeUninit<T> {
+        let mut u = MaybeUninit::<T>::uninitialized();
+        unsafe {
+            (&mut *u.value as *mut T).write_bytes(0u8, 1);
+        }
+        u
+    }
+
+    #[unstable(feature = "maybe_uninit", issue = "53491")]
+    #[cfg(stage0)]
+    /// Ceci n'est pas la documentation
     pub fn zeroed() -> MaybeUninit<T> {
         let mut u = MaybeUninit::<T>::uninitialized();
         unsafe {

src/librustc_mir/interpret/intrinsics.rs

@@ -157,6 +157,23 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
                 let dest = self.force_allocation(dest)?;
                 self.copy_op(args[0], dest.into())?;
             }
+            "write_bytes" => {
+                let ptr = self.read_value(args[0])?;
+                let mplace = self.ref_to_mplace(ptr)?;
+                let val = self.read_scalar(args[1])?.to_u8()?;
+                let count = self.read_scalar(args[2])?.to_usize(&self.memory)?;
+                if mplace.layout.is_zst() || count == 0 {
+                    return Ok(true);
+                }
+                if let Some(byte_count) = mplace.layout.size.checked_mul(count, &self.memory) {
+                    self.memory.write_repeat(mplace.ptr, val, byte_count)?;
+                } else {
+                    return err!(Intrinsic(
+                        format!("Overflowing computing `count * size_of::<T>()` ({} * {}) in {}",
+                                count, mplace.layout.size.bytes(), intrinsic_name),
+                    ));
+                }
+            }
 
             _ => return Ok(false),
         }

src/librustc_mir/transform/qualify_consts.rs

@@ -858,6 +858,19 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> {
                                     }
                                 }
                             }
+                            "write_bytes" => {
+                                if self.tcx.sess.features_untracked().const_write_bytes {
+                                    is_const_fn = true;
+                                } else if self.mode != Mode::Fn {
+                                    // Using write_bytes in a const expression requires the feature
+                                    // gate.
+                                    emit_feature_err(
+                                        &self.tcx.sess.parse_sess, "const_write_bytes",
+                                        self.span, GateIssue::Language,
+                                        &format!("The use of std::ptr::write_bytes() \
+                                        is gated in {}s", self.mode));
+                                }
+                            }
 
                             name if name.starts_with("simd_shuffle") => {
                                 is_shuffle = true;

src/libsyntax/feature_gate.rs

@@ -243,6 +243,9 @@ declare_features! (
     // Allows panicking during const eval (produces compile-time errors)
     (active, const_panic, "1.30.0", Some(51999), None),
 
+    // Allows writing repeated bytes to a pointer during const eval.
+    (active, const_write_bytes, "1.31.0", Some(53491), None),
+
     // Allows using #[prelude_import] on glob `use` items.
     //
     // rustc internal

src/test/run-pass/const-maybe-init-zeroed.rs

@@ -0,0 +1,26 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+#![feature(maybe_uninit, const_maybe_uninit_zeroed)]
+
+use std::mem;
+
+fn main() {
+    const UNIT: mem::MaybeUninit<()> = mem::MaybeUninit::zeroed();
+    let bytes: [u8; 0] = unsafe { mem::transmute(UNIT) };
+    assert_eq!(bytes, [0u8; 0]);
+
+    const STRING: mem::MaybeUninit<String> = mem::MaybeUninit::zeroed();
+    let bytes: [u8; mem::size_of::<String>()] = unsafe { mem::transmute(STRING) };
+    assert_eq!(bytes, [0u8; mem::size_of::<String>()]);
+
+    const U8: mem::MaybeUninit<u8> = mem::MaybeUninit::zeroed();
+    let bytes: [u8; 1] = unsafe { mem::transmute(U8) };
+    assert_eq!(bytes, [0u8; 1]);
+}

src/test/ui/feature-gates/feature-gate-const_write_bytes.rs

@@ -0,0 +1,18 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(const_fn, const_let)]
+
+fn main() {}
+
+const unsafe fn foo(u: *mut u32) {
+    std::ptr::write_bytes(u, 0u8, 1);
+    //~^ ERROR The use of std::ptr::write_bytes() is gated in constant functions (see issue #53491)
+}

src/test/ui/feature-gates/feature-gate-const_write_bytes.stderr

@@ -0,0 +1,11 @@
+error[E0658]: The use of std::ptr::write_bytes() is gated in constant functions (see issue #53491)
+  --> $DIR/feature-gate-const_write_bytes.rs:16:5
+   |
+LL |     std::ptr::write_bytes(u, 0u8, 1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: add #![feature(const_write_bytes)] to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0658`.