Auto merge of rust-lang#128299 - DianQK:clone-copy, r=<try>

Simplify the canonical clone method and the copy-like forms to copy

Fixes rust-lang#128081. Currently being blocked by rust-lang#128265.

`@rustbot` label +S-blocked

r? `@saethlin`

Author: bors

compiler/rustc_index/src/vec.rs

@@ -188,6 +188,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

@@ -2,6 +2,7 @@
 
 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::ValidityRequirement;
@@ -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,95 @@ 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) = rvalue
+                            && let Some(place) = operand.place()
+                        {
+                            if let Some(rvalue_local) = place.as_local() {
+                                let place = assignments[rvalue_local];
+                                if operand.is_move() {
+                                    assignments[rvalue_local] = None;
+                                }
+                                place
+                            } else {
+                                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(_)
+                | StatementKind::Nop => {}
+                _ => {
+                    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/instsimplify/copy_like.all_copy.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,47 @@
+- // MIR for `all_copy` before InstSimplify-after-simplifycfg
++ // MIR for `all_copy` after InstSimplify-after-simplifycfg
+  
+  fn all_copy(_1: &AllCopy) -> AllCopy {
+      debug v => _1;
+      let mut _0: AllCopy;
+      let _2: i32;
+      let mut _5: i32;
+      let mut _6: u64;
+      let mut _7: [i8; 3];
+      scope 1 {
+          debug a => _2;
+          let _3: u64;
+          scope 2 {
+              debug b => _3;
+              let _4: [i8; 3];
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          StorageLive(_3);
+          _3 = ((*_1).1: u64);
+          StorageLive(_4);
+          _4 = ((*_1).2: [i8; 3]);
+          StorageLive(_5);
+          _5 = _2;
+          StorageLive(_6);
+          _6 = _3;
+          StorageLive(_7);
+          _7 = _4;
+-         _0 = AllCopy { a: move _5, b: move _6, c: move _7 };
++         _0 = (*_1);
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.all_copy_different_type.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,46 @@
+- // MIR for `all_copy_different_type` before InstSimplify-after-simplifycfg
++ // MIR for `all_copy_different_type` after InstSimplify-after-simplifycfg
+  
+  fn all_copy_different_type(_1: &AllCopy) -> AllCopy2 {
+      debug v => _1;
+      let mut _0: AllCopy2;
+      let _2: i32;
+      let mut _5: i32;
+      let mut _6: u64;
+      let mut _7: [i8; 3];
+      scope 1 {
+          debug a => _2;
+          let _3: u64;
+          scope 2 {
+              debug b => _3;
+              let _4: [i8; 3];
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          StorageLive(_3);
+          _3 = ((*_1).1: u64);
+          StorageLive(_4);
+          _4 = ((*_1).2: [i8; 3]);
+          StorageLive(_5);
+          _5 = _2;
+          StorageLive(_6);
+          _6 = _3;
+          StorageLive(_7);
+          _7 = _4;
+          _0 = AllCopy2 { a: move _5, b: move _6, c: move _7 };
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.all_copy_has_changed.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,47 @@
+- // MIR for `all_copy_has_changed` before InstSimplify-after-simplifycfg
++ // MIR for `all_copy_has_changed` after InstSimplify-after-simplifycfg
+  
+  fn all_copy_has_changed(_1: &mut AllCopy) -> AllCopy {
+      debug v => _1;
+      let mut _0: AllCopy;
+      let _2: i32;
+      let mut _5: i32;
+      let mut _6: u64;
+      let mut _7: [i8; 3];
+      scope 1 {
+          debug a => _2;
+          let _3: u64;
+          scope 2 {
+              debug b => _3;
+              let _4: [i8; 3];
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          StorageLive(_3);
+          _3 = ((*_1).1: u64);
+          StorageLive(_4);
+          _4 = ((*_1).2: [i8; 3]);
+          ((*_1).0: i32) = const 1_i32;
+          StorageLive(_5);
+          _5 = _2;
+          StorageLive(_6);
+          _6 = _3;
+          StorageLive(_7);
+          _7 = _4;
+          _0 = AllCopy { a: move _5, b: move _6, c: move _7 };
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+