fix: handle zero-sized memory intrinsics

Author: mizoz

example/mini_core.rs

@@ -662,6 +662,8 @@ pub mod intrinsics {
     #[rustc_intrinsic]
     pub unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize);
     #[rustc_intrinsic]
+    pub unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize);
+    #[rustc_intrinsic]
     pub unsafe fn transmute<T, U>(e: T) -> U;
     #[rustc_intrinsic]
     pub unsafe fn ctlz_nonzero<T>(x: T) -> u32;

src/intrinsic/mod.rs

@@ -338,6 +338,13 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                 );
                 return Ok(());
             }
+            sym::copy | sym::copy_nonoverlapping | sym::write_bytes => {
+                let ty = fn_args.type_at(0);
+                if self.layout_of(ty).size.bytes() == 0 {
+                    return Ok(());
+                }
+                return Err(Instance::new_raw(instance.def_id(), instance.args));
+            }
             sym::breakpoint => {
                 unimplemented!();
             }

tests/run/zero_sized_mem.rs

@@ -0,0 +1,28 @@
+// Compiler:
+//
+// Run-time:
+//   status: 0
+
+#![feature(no_core)]
+#![no_std]
+#![no_core]
+#![no_main]
+
+extern crate mini_core;
+use mini_core::*;
+
+#[inline(never)]
+unsafe fn zero_sized_mem_ops(count: usize) {
+    let src = 0usize as *const ();
+    let dst = 0usize as *mut ();
+
+    intrinsics::copy_nonoverlapping(src, dst, count);
+    intrinsics::copy(src, dst, count);
+    intrinsics::write_bytes(dst, 0xab, count);
+}
+
+#[no_mangle]
+extern "C" fn main(_argc: i32, _argv: *const *const u8) -> i32 {
+    unsafe { zero_sized_mem_ops(1) };
+    0
+}