Impl StatementKind::CopyNonOverlapping

Author: JulianKnodt

compiler/rustc_codegen_ssa/src/mir/analyze.rs

@@ -293,15 +293,17 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>
                 | MutatingUseContext::AsmOutput
                 | MutatingUseContext::Borrow
                 | MutatingUseContext::AddressOf
-                | MutatingUseContext::Projection,
+                | MutatingUseContext::Projection
+                | MutatingUseContext::CopyNonOverlapping,
             )
             | PlaceContext::NonMutatingUse(
                 NonMutatingUseContext::Inspect
                 | NonMutatingUseContext::SharedBorrow
                 | NonMutatingUseContext::UniqueBorrow
                 | NonMutatingUseContext::ShallowBorrow
                 | NonMutatingUseContext::AddressOf
-                | NonMutatingUseContext::Projection,
+                | NonMutatingUseContext::Projection
+                | NonMutatingUseContext::CopyNonOverlapping,
             ) => {
                 self.not_ssa(local);
             }

compiler/rustc_codegen_ssa/src/mir/statement.rs

@@ -115,6 +115,21 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 self.codegen_coverage(&mut bx, coverage.clone());
                 bx
             }
+            mir::StatementKind::CopyNonOverlapping(box mir::CopyNonOverlapping {
+                ref src,
+                ref dst,
+                ref size,
+            }) => {
+              bx.memcpy(
+                dst,
+                todo!(),
+                src,
+                todo!(),
+                size,
+                todo!(),
+              );
+              bx
+            }
             mir::StatementKind::FakeRead(..)
             | mir::StatementKind::Retag { .. }
             | mir::StatementKind::AscribeUserType(..)

compiler/rustc_middle/src/mir/mod.rs

@@ -1515,6 +1515,11 @@ pub enum StatementKind<'tcx> {
     /// counter varible at runtime, each time the code region is executed.
     Coverage(Box<Coverage>),
 
+    /// Denotes a call to the intrinsic function copy_overlapping, where `src_dst` denotes the
+    /// memory being read from and written to(one field to save memory), and size
+    /// indicates how many bytes are being copied over.
+    CopyNonOverlapping(Box<CopyNonOverlapping<'tcx>>),
+
     /// No-op. Useful for deleting instructions without affecting statement indices.
     Nop,
 }
@@ -1633,6 +1638,11 @@ impl Debug for Statement<'_> {
                     write!(fmt, "Coverage::{:?}", coverage.kind)
                 }
             }
+            CopyNonOverlapping(box crate::mir::CopyNonOverlapping {
+                ref src,
+                ref dst,
+                ref size,
+            }) => write!(fmt, "src {:?} -> dst {:?}, {:?} bytes", src, dst, size),
             Nop => write!(fmt, "nop"),
         }
     }
@@ -1644,6 +1654,13 @@ pub struct Coverage {
     pub code_region: Option<CodeRegion>,
 }
 
+#[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)]
+pub struct CopyNonOverlapping<'tcx> {
+    pub src: Place<'tcx>,
+    pub dst: Place<'tcx>,
+    pub size: Operand<'tcx>,
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // Places
 

compiler/rustc_middle/src/mir/visit.rs

@@ -434,6 +434,23 @@ macro_rules! make_mir_visitor {
                             location
                         )
                     }
+                    StatementKind::CopyNonOverlapping(box crate::mir::CopyNonOverlapping{
+                      ref $($mutability)? src,
+                      ref $($mutability)? dst,
+                      ref $($mutability)? size,
+                    }) => {
+                      self.visit_place(
+                            src,
+                            PlaceContext::NonMutatingUse(NonMutatingUseContext::CopyNonOverlapping),
+                            location
+                      );
+                      self.visit_place(
+                            dst,
+                            PlaceContext::MutatingUse(MutatingUseContext::CopyNonOverlapping),
+                            location
+                      );
+                      self.visit_operand(size, location)
+                    }
                     StatementKind::Nop => {}
                 }
             }
@@ -1149,6 +1166,8 @@ pub enum NonMutatingUseContext {
     ///     f(&x.y);
     ///
     Projection,
+    /// Source from copy_nonoverlapping.
+    CopyNonOverlapping,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -1178,6 +1197,8 @@ pub enum MutatingUseContext {
     Projection,
     /// Retagging, a "Stacked Borrows" shadow state operation
     Retag,
+    /// Memory written to in copy_nonoverlapping.
+    CopyNonOverlapping,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]