Update match branches

This updates all places where match branches check on StatementKind or UseContext.
This doesn't properly implement them, but adds TODOs where they are, and also adds some best
guesses to what they should be in some cases.

Author: JulianKnodt

compiler/rustc_codegen_ssa/src/mir/analyze.rs

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

compiler/rustc_codegen_ssa/src/mir/statement.rs

@@ -120,18 +120,22 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 ref dst,
                 ref size,
             }) => {
-                let dst_val = self.codegen_place(&mut bx, dst.as_ref());
-                let src_val = self.codegen_place(&mut bx, src.as_ref());
+                let dst_val = self.codegen_operand(&mut bx, dst);
+                let src_val = self.codegen_operand(&mut bx, src);
                 let size_val = self.codegen_operand(&mut bx, size);
                 let size = size_val.immediate_or_packed_pair(&mut bx);
+                let dst = dst_val.immediate_or_packed_pair(&mut bx);
+                let src = src_val.immediate_or_packed_pair(&mut bx);
+                use crate::MemFlags;
+                let flags =
+                    (!MemFlags::UNALIGNED) & (!MemFlags::VOLATILE) & (!MemFlags::NONTEMPORAL);
                 bx.memcpy(
-                    dst_val.llval,
-                    dst_val.align,
-                    src_val.llval,
-                    src_val.align,
+                    dst,
+                    dst_val.layout.layout.align.pref,
+                    src,
+                    src_val.layout.layout.align.pref,
                     size,
-                    // TODO probably want to have this change based on alignment above?
-                    crate::MemFlags::empty(),
+                    flags,
                 );
                 bx
             }

compiler/rustc_middle/src/mir/mod.rs

@@ -1642,7 +1642,7 @@ impl Debug for Statement<'_> {
                 ref src,
                 ref dst,
                 ref size,
-            }) => write!(fmt, "copy_nonoverlapping(src={:?}, dst={:?},bytes={:?})", src, dst, size),
+            }) => write!(fmt, "copy_nonoverlapping(src={:?}, dst={:?}, size={:?})", src, dst, size),
             Nop => write!(fmt, "nop"),
         }
     }
@@ -1656,8 +1656,8 @@ pub struct Coverage {
 
 #[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)]
 pub struct CopyNonOverlapping<'tcx> {
-    pub src: Place<'tcx>,
-    pub dst: Place<'tcx>,
+    pub src: Operand<'tcx>,
+    pub dst: Operand<'tcx>,
     pub size: Operand<'tcx>,
 }
 

compiler/rustc_middle/src/mir/visit.rs

@@ -439,14 +439,12 @@ macro_rules! make_mir_visitor {
                       ref $($mutability)? dst,
                       ref $($mutability)? size,
                     }) => {
-                      self.visit_place(
+                      self.visit_operand(
                             src,
-                            PlaceContext::NonMutatingUse(NonMutatingUseContext::CopyNonOverlapping),
                             location
                       );
-                      self.visit_place(
+                      self.visit_operand(
                             dst,
-                            PlaceContext::MutatingUse(MutatingUseContext::CopyNonOverlapping),
                             location
                       );
                       self.visit_operand(size, location)
@@ -1166,8 +1164,6 @@ pub enum NonMutatingUseContext {
     ///     f(&x.y);
     ///
     Projection,
-    /// Source from copy_nonoverlapping.
-    CopyNonOverlapping,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -1197,8 +1193,6 @@ 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)]

compiler/rustc_mir/src/borrow_check/invalidation.rs

@@ -92,6 +92,21 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {
                     self.consume_operand(location, input);
                 }
             }
+            StatementKind::CopyNonOverlapping(box rustc_middle::mir::CopyNonOverlapping {
+                ref src,
+                ref dst,
+                ref size,
+            }) => {
+                self.consume_operand(location, src);
+                self.consume_operand(location, dst);
+                self.consume_operand(location, size);
+                match dst {
+                    Operand::Move(ref place) | Operand::Copy(ref place) => {
+                        self.mutate_place(location, *place, Deep, JustWrite);
+                    }
+                    _ => {}
+                }
+            }
             StatementKind::Nop
             | StatementKind::Coverage(..)
             | StatementKind::AscribeUserType(..)

compiler/rustc_mir/src/borrow_check/mod.rs

@@ -626,6 +626,8 @@ impl<'cx, 'tcx> dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtxt<'cx, 'tc
                     self.consume_operand(location, (input, span), flow_state);
                 }
             }
+
+            StatementKind::CopyNonOverlapping(..) => todo!(),
             StatementKind::Nop
             | StatementKind::Coverage(..)
             | StatementKind::AscribeUserType(..)

compiler/rustc_mir/src/borrow_check/type_check/mod.rs

@@ -1520,6 +1520,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                     );
                 }
             }
+            StatementKind::CopyNonOverlapping(..) => todo!(),
             StatementKind::FakeRead(..)
             | StatementKind::StorageLive(..)
             | StatementKind::StorageDead(..)

compiler/rustc_mir/src/dataflow/impls/borrows.rs

@@ -306,6 +306,8 @@ impl<'tcx> dataflow::GenKillAnalysis<'tcx> for Borrows<'_, 'tcx> {
             | mir::StatementKind::AscribeUserType(..)
             | mir::StatementKind::Coverage(..)
             | mir::StatementKind::Nop => {}
+
+            mir::StatementKind::CopyNonOverlapping(..) => todo!(),
         }
     }
 

compiler/rustc_mir/src/dataflow/impls/storage_liveness.rs

@@ -150,6 +150,8 @@ impl<'mir, 'tcx> dataflow::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'mir,
             | StatementKind::Nop
             | StatementKind::Retag(..)
             | StatementKind::StorageLive(..) => {}
+
+            StatementKind::CopyNonOverlapping(..) => todo!(),
         }
     }
 

compiler/rustc_mir/src/dataflow/move_paths/builder.rs

@@ -319,6 +319,8 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
             | StatementKind::AscribeUserType(..)
             | StatementKind::Coverage(..)
             | StatementKind::Nop => {}
+
+            StatementKind::CopyNonOverlapping(..) => todo!(),
         }
     }
 

compiler/rustc_mir/src/interpret/step.rs

@@ -113,6 +113,23 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 M::retag(self, *kind, &dest)?;
             }
 
+            // Call CopyNonOverlapping
+            CopyNonOverlapping(box rustc_middle::mir::CopyNonOverlapping { dst, src, size }) => {
+                let size = self.eval_operand(size, None)?;
+
+                let dst = {
+                    let dst = self.eval_operand(dst, None)?;
+                    dst.assert_mem_place(self)
+                };
+                let src = {
+                    let src = self.eval_operand(src, None)?;
+                    src.assert_mem_place(self)
+                };
+                // Not sure how to convert an MPlaceTy<'_, <M as Machine<'_, '_>>::PointerTag>
+                // to a pointer, or OpTy to a size
+                self.memory.copy(src, dst, size, /*nonoverlapping*/ true)?;
+            }
+
             // Statements we do not track.
             AscribeUserType(..) => {}
 

compiler/rustc_mir/src/transform/check_consts/validation.rs

@@ -808,6 +808,7 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
             | StatementKind::Retag { .. }
             | StatementKind::AscribeUserType(..)
             | StatementKind::Coverage(..)
+            | StatementKind::CopyNonOverlapping(..)
             | StatementKind::Nop => {}
         }
     }

compiler/rustc_mir/src/transform/check_unsafety.rs

@@ -115,6 +115,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
             | StatementKind::Retag { .. }
             | StatementKind::AscribeUserType(..)
             | StatementKind::Coverage(..)
+            | StatementKind::CopyNonOverlapping(..)
             | StatementKind::Nop => {
                 // safe (at least as emitted during MIR construction)
             }

compiler/rustc_mir/src/transform/dest_prop.rs

@@ -582,6 +582,7 @@ impl Conflicts<'a> {
             | StatementKind::FakeRead(..)
             | StatementKind::AscribeUserType(..)
             | StatementKind::Coverage(..)
+            | StatementKind::CopyNonOverlapping(..)
             | StatementKind::Nop => {}
         }
     }

compiler/rustc_mir/src/transform/generator.rs

@@ -1453,6 +1453,7 @@ impl Visitor<'tcx> for EnsureGeneratorFieldAssignmentsNeverAlias<'_> {
             | StatementKind::Retag(..)
             | StatementKind::AscribeUserType(..)
             | StatementKind::Coverage(..)
+            | StatementKind::CopyNonOverlapping(..)
             | StatementKind::Nop => {}
         }
     }