Refactor move_copy_annotation_instance

Just pass the `PlaceRef` and defer anything possibly expensive until
after we've decided we're going to do the annotation.

Flip the representation check to only instrument BackendRepr::Memory
represented objects.

Author: jsgf

compiler/rustc_codegen_ssa/src/mir/operand.rs

@@ -1043,11 +1043,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     mir::Operand::Copy(_) => sym::compiler_copy,
                     _ => unreachable!(),
                 };
-                let ty = self.monomorphized_place_ty(place.as_ref());
-                let layout = bx.cx().layout_of(ty);
 
                 // Check if we should annotate this move/copy for profiling
-                let move_annotation = self.move_copy_annotation_instance(bx, ty, layout, kind);
+                let move_annotation = self.move_copy_annotation_instance(bx, place.as_ref(), kind);
 
                 OperandRef { move_annotation, ..self.codegen_consume(bx, place.as_ref()) }
             }
@@ -1076,44 +1074,44 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
     /// Creates an `Instance` for annotating a move/copy operation at codegen time.
     ///
-    /// Returns `Some(instance)` if the operation should be annotated with debug info,
-    /// `None` otherwise. The instance represents a monomorphized `compiler_move<T, SIZE>`
-    /// or `compiler_copy<T, SIZE>` function that can be used to create debug scopes.
+    /// Returns `Some(instance)` if the operation should be annotated with debug info, `None`
+    /// otherwise. The instance represents a monomorphized `compiler_move<T, SIZE>` or
+    /// `compiler_copy<T, SIZE>` function that can be used to create debug scopes.
     ///
-    /// Annotation criteria:
-    /// - Codegen annotation flag must be enabled
-    /// - Debug info must be enabled
-    /// - Type must not be ZST
-    /// - Type size must meet threshold
-    /// - Type must not be scalar/scalar-pair/SIMD (no memcpy generated)
+    /// There are a number of conditions that must be met for an annotation to be created, but aside
+    /// from the basics (annotation is enabled, we're generating debuginfo), the primary concern is
+    /// moves/copies which could result in a real `memcpy`. So we check for the size limit, but also
+    /// that the underlying representation of the type is in memory.
     fn move_copy_annotation_instance(
         &self,
         bx: &Bx,
-        ty: Ty<'tcx>,
-        layout: TyAndLayout<'tcx>,
+        place: mir::PlaceRef<'tcx>,
         kind: Symbol,
     ) -> Option<ty::Instance<'tcx>> {
         let tcx = bx.tcx();
         let sess = tcx.sess;
 
-        // Check if annotation is enabled and get size limit
+        // Skip if we're not generating debuginfo
+        if sess.opts.debuginfo == DebugInfo::None {
+            return None;
+        }
+
+        // Check if annotation is enabled and get size limit (otherwise skip)
         let size_limit = match sess.opts.unstable_opts.annotate_moves {
             AnnotateMoves::Disabled => return None,
             AnnotateMoves::Enabled(None) => MOVE_ANNOTATION_DEFAULT_LIMIT,
             AnnotateMoves::Enabled(Some(limit)) => limit,
         };
-        let size = layout.size.bytes();
-        // Skip if we're not generating debug info, or if ty is zst, or the size limit isn't met, or
-        // if the layout is not moved by memcpy.
-        if sess.opts.debuginfo == DebugInfo::None
-            || layout.is_zst()
-            || size < size_limit
-            || matches!(
-                layout.backend_repr,
-                BackendRepr::Scalar(_)
-                    | BackendRepr::ScalarPair(_, _)
-                    | BackendRepr::SimdVector { .. }
-            )
+
+        let ty = self.monomorphized_place_ty(place);
+        let layout = bx.cx().layout_of(ty);
+        let ty_size = layout.size.bytes();
+
+        // Only annotate if type has a memory representation and exceeds size limit (and has a
+        // non-zero size)
+        if layout.is_zst()
+            || ty_size < size_limit
+            || !matches!(layout.backend_repr, BackendRepr::Memory { .. })
         {
             return None;
         }
@@ -1123,7 +1121,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         let def_id = tcx.get_diagnostic_item(kind)?;
 
         // Create generic args: compiler_move<T, SIZE> or compiler_copy<T, SIZE>
-        let size_const = ty::Const::from_target_usize(tcx, size);
+        let size_const = ty::Const::from_target_usize(tcx, ty_size);
         let generic_args = tcx.mk_args(&[ty.into(), size_const.into()]);
 
         // Create the Instance