Simplify the canonical clone method to copy

The optimized clone method ends up as the following MIR:

```
_2 = ((*_1).0: i32);
_3 = ((*_1).1: u64);
_4 = ((*_1).2: [i8; 3]);
_0 = Foo { a: move _2, b: move _3, c: move _4 };
```

We can transform this to:

```
_0 = (*_1);
```

Author: dianqk

compiler/rustc_index/src/vec.rs

@@ -190,6 +190,16 @@ impl<I: Idx, T> IndexVec<I, T> {
         let min_new_len = elem.index() + 1;
         self.raw.resize_with(min_new_len, fill_value);
     }
+
+    #[inline]
+    pub fn reset_all(&mut self, elem: T)
+    where
+        T: Copy,
+    {
+        for e in self.raw.iter_mut() {
+            *e = elem;
+        }
+    }
 }
 
 /// `IndexVec` is often used as a map, so it provides some map-like APIs.

compiler/rustc_mir_transform/src/instsimplify.rs

@@ -4,6 +4,7 @@ use crate::simplify::simplify_duplicate_switch_targets;
 use crate::take_array;
 use rustc_ast::attr;
 use rustc_hir::LangItem;
+use rustc_index::IndexVec;
 use rustc_middle::bug;
 use rustc_middle::mir::*;
 use rustc_middle::ty::layout;
@@ -60,8 +61,8 @@ impl<'tcx> MirPass<'tcx> for InstSimplify {
                     _ => {}
                 }
             }
-
             ctx.simplify_primitive_clone(block.terminator.as_mut().unwrap(), &mut block.statements);
+            ctx.simplify_copy_like(&mut block.statements);
             ctx.simplify_intrinsic_assert(block.terminator.as_mut().unwrap());
             ctx.simplify_nounwind_call(block.terminator.as_mut().unwrap());
             simplify_duplicate_switch_targets(block.terminator.as_mut().unwrap());
@@ -207,6 +208,83 @@ impl<'tcx> InstSimplifyContext<'tcx, '_> {
         }
     }
 
+    /// Transform `Aggregate(Adt, [(*_1).0, (*_1).1])` ==> `Copy(*_1)`.
+    /// This comes from the simplification of the clone method by `simplify_primitive_clone`.
+    fn simplify_copy_like(&self, statements: &mut Vec<Statement<'tcx>>) {
+        let mut assignments = IndexVec::from_elem(None::<Place<'tcx>>, self.local_decls);
+        for statement in statements {
+            match statement.kind {
+                StatementKind::Assign(box (dest, ref mut rvalue)) => {
+                    if let Rvalue::Aggregate(_, fields) = rvalue {
+                        let mut from_local = None;
+                        if fields.iter_enumerated().all(|(index, field)| {
+                            let Some(from_place) = field
+                                .place()
+                                .and_then(|p| p.as_local())
+                                .and_then(|l| assignments[l])
+                            else {
+                                return false;
+                            };
+                            // All fields must come from the same local.
+                            if let Some(from_local) = from_local {
+                                if from_place.local != from_local {
+                                    return false;
+                                }
+                            } else {
+                                // We can only copy the same type.
+                                let Some(from_ty) =
+                                    self.local_decls[from_place.local].ty.builtin_deref(false)
+                                else {
+                                    return false;
+                                };
+                                let dest_ty = dest.ty(self.local_decls, self.tcx).ty;
+                                if dest_ty != from_ty {
+                                    return false;
+                                };
+                                from_local = Some(from_place.local);
+                            }
+                            // For more complex scenarios, we expect to get this simplified projection within a complete pipeline.
+                            let [ProjectionElem::Deref, ProjectionElem::Field(from_index, _)] =
+                                *from_place.projection.as_slice()
+                            else {
+                                return false;
+                            };
+                            from_index == index
+                        }) {
+                            if let Some(local) = from_local {
+                                if self.should_simplify(&statement.source_info, rvalue) {
+                                    *rvalue = Rvalue::Use(Operand::Copy(Place {
+                                        local,
+                                        projection: self
+                                            .tcx
+                                            .mk_place_elems(&[ProjectionElem::Deref]),
+                                    }));
+                                }
+                            }
+                        }
+                    }
+                    // Collect available assignments, including those transformed from `Aggregate`.
+                    if let Some(local) = dest.as_local() {
+                        assignments[local] = if let Rvalue::Use(Operand::Copy(place)) = rvalue {
+                            Some(*place)
+                        } else {
+                            // This assignment generally comes from debuginfo (e.g., Ref),
+                            // but we still need to check if a local is being overridden.
+                            None
+                        };
+                    } else {
+                        // We don't handle projection, so we drop all previous assignments.
+                        assignments.reset_all(None);
+                    }
+                }
+                StatementKind::StorageLive(_) | StatementKind::StorageDead(_) => {}
+                _ => {
+                    assignments.reset_all(None);
+                }
+            }
+        }
+    }
+
     fn simplify_cast(&self, rvalue: &mut Rvalue<'tcx>) {
         if let Rvalue::Cast(kind, operand, cast_ty) = rvalue {
             let operand_ty = operand.ty(self.local_decls, self.tcx);

tests/codegen/clone_as_copy.rs

@@ -0,0 +1,40 @@
+//@ revisions: DEBUGINFO NODEBUGINFO
+//@ compile-flags: -O -Cno-prepopulate-passes
+//@ [DEBUGINFO] compile-flags: -Cdebuginfo=full
+
+// From https://github.com/rust-lang/rust/issues/128081.
+// Ensure that we only generate a memcpy instruction.
+
+#![crate_type = "lib"]
+
+#[derive(Clone)]
+struct SubCloneAndCopy {
+    v1: u32,
+    v2: u32,
+}
+
+#[derive(Clone)]
+struct CloneOnly {
+    v1: u8,
+    v2: u8,
+    v3: u8,
+    v4: u8,
+    v5: u8,
+    v6: u8,
+    v7: u8,
+    v8: u8,
+    v9: u8,
+    v_sub: SubCloneAndCopy,
+    v_large: [u8; 256],
+}
+
+// CHECK-LABEL: define {{.*}}@clone_only(
+#[no_mangle]
+pub fn clone_only(v: &CloneOnly) -> CloneOnly {
+    // CHECK-NOT: call {{.*}}clone
+    // CHECK-NOT: store i8
+    // CHECK-NOT: store i32
+    // CHECK: call void @llvm.memcpy
+    // CHECK-NEXT: ret void
+    v.clone()
+}

tests/mir-opt/instsimplify/clone.rs

@@ -0,0 +1,17 @@
+//@ test-mir-pass: InstSimplify-after-simplifycfg
+//@ compile-flags: -Zmir-enable-passes=+InstSimplify-before-inline,+ReferencePropagation,+SimplifyCfg-after-unreachable-enum-branching
+
+// Check if we have transformed the default clone to copy in the specific pipeline.
+
+// EMIT_MIR clone.{impl#0}-clone.InstSimplify-after-simplifycfg.diff
+
+// CHECK-LABEL: ::clone(
+// CHECK-NOT: = AllCopy { {{.*}} };
+// CHECK: _0 = (*_1);
+// CHECK: return;
+#[derive(Clone)]
+struct AllCopy {
+    a: i32,
+    b: u64,
+    c: [i8; 3],
+}

tests/mir-opt/instsimplify/clone.{impl#0}-clone.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,32 @@
+- // MIR for `<impl at $DIR/clone.rs:12:10: 12:15>::clone` before InstSimplify-after-simplifycfg
++ // MIR for `<impl at $DIR/clone.rs:12:10: 12:15>::clone` after InstSimplify-after-simplifycfg
+  
+  fn <impl at $DIR/clone.rs:12:10: 12:15>::clone(_1: &AllCopy) -> AllCopy {
+      debug self => _1;
+      let mut _0: AllCopy;
+      let mut _2: i32;
+      let mut _3: &i32;
+      let _4: &i32;
+      let mut _5: u64;
+      let mut _6: &u64;
+      let _7: &u64;
+      let mut _8: [i8; 3];
+      let mut _9: &[i8; 3];
+      let _10: &[i8; 3];
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          StorageLive(_5);
+          _5 = ((*_1).1: u64);
+          StorageLive(_8);
+          _8 = ((*_1).2: [i8; 3]);
+-         _0 = AllCopy { a: move _2, b: move _5, c: move _8 };
++         _0 = (*_1);
+          StorageDead(_8);
+          StorageDead(_5);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/pre-codegen/clone_as_copy.clone_as_copy.PreCodegen.after.mir

@@ -0,0 +1,21 @@
+// MIR for `clone_as_copy` after PreCodegen
+
+fn clone_as_copy(_1: &CopyLikeStruct) -> CopyLikeStruct {
+    debug v => _1;
+    let mut _0: CopyLikeStruct;
+    scope 1 (inlined <CopyLikeStruct as Clone>::clone) {
+        debug self => _1;
+        let _2: &AllCopy;
+        scope 2 (inlined <AllCopy as Clone>::clone) {
+            debug self => _2;
+        }
+    }
+
+    bb0: {
+        StorageLive(_2);
+        _2 = &((*_1).1: AllCopy);
+        _0 = (*_1);
+        StorageDead(_2);
+        return;
+    }
+}

tests/mir-opt/pre-codegen/clone_as_copy.rs

@@ -0,0 +1,28 @@
+//@ compile-flags: -Cdebuginfo=full
+
+// Check if we have transformed the nested clone to the copy in the complete pipeline.
+
+#[derive(Clone)]
+struct AllCopy {
+    a: i32,
+    b: u64,
+    c: [i8; 3],
+}
+
+#[derive(Clone)]
+struct CopyLikeStruct {
+    a: i32,
+    b: AllCopy,
+    c: [i8; 3],
+}
+
+// EMIT_MIR clone_as_copy.clone_as_copy.PreCodegen.after.mir
+#[inline(never)]
+fn clone_as_copy(v: &CopyLikeStruct) -> CopyLikeStruct {
+    // CHECK-LABEL: fn clone_as_copy(
+    // CHECK-NOT: = AllCopy { {{.*}} };
+    // CHECK-NOT: = CopyLikeStruct { {{.*}} };
+    // CHECK: _0 = (*_1);
+    // CHECK: return;
+    v.clone()
+}

tests/mir-opt/pre-codegen/no_inlined_clone.{impl#0}-clone.PreCodegen.after.mir

@@ -3,13 +3,9 @@
 fn <impl at $DIR/no_inlined_clone.rs:9:10: 9:15>::clone(_1: &Foo) -> Foo {
     debug self => _1;
     let mut _0: Foo;
-    let mut _2: i32;
 
     bb0: {
-        StorageLive(_2);
-        _2 = ((*_1).0: i32);
-        _0 = Foo { a: move _2 };
-        StorageDead(_2);
+        _0 = (*_1);
         return;
     }
 }