Add -Zannotate-moves for profiler visibility of move/copy operations

This implements a new unstable compiler flag `-Zannotate-moves` that makes
move and copy operations visible in profilers by creating synthetic debug
information. This is achieved with zero runtime cost by manipulating debug
info scopes to make moves/copies appear as calls to `compiler_move<T, SIZE>`
and `compiler_copy<T, SIZE>` marker functions in profiling tools.

A new `AnnotateMoves` MIR transform pass runs after MIR optimization
and modifies source scopes for statements containing `Operand::Move`
and `Operand::Copy` to make them appear as if inlined from profiling
marker functions in `core::profiling`.

Two marker functions (`compiler_move` and `compiler_copy`) are defined
in `library/core/src/profiling.rs`. These are never actually called -
they exist solely as debug info anchors.

The transform creates synthetic `SourceScopeData` with the `inlined`
field set to point to the appropriate profiling marker, leveraging the
existing inlining infrastructure.

Operations are only annotated if the type:
   - Meets the size threshold (default: 65 bytes, configurable via
     `-Zannotate-moves=SIZE`)
   - Has a non-scalar backend representation (scalars use registers,
   not memcpy)

An early issue was that modifying a statement's SourceInfo to add the
`compiler_move` scope affected the entire statement, including function calls
when the move was a call argument. This made profilers attribute the whole
function call to the move operation, greatly exaggerating its cost.

The solution stores argument move/copy SourceInfo separately in
`Body::call_arg_move_source_info`. During codegen, this SourceInfo is applied
only during argument preparation, then reset to the call site location before
emitting the call instruction itself. This ensures profilers see the argument
copy attributed to `compiler_move` while the function call retains its proper
source attribution.

Author: jsgf

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1151,6 +1151,16 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 _ => {}
             }
 
+            // Look up stored SourceInfo for this argument if it exists (from annotate_moves pass)
+            let bb_info = self
+                .mir
+                .call_arg_move_source_info
+                .iter()
+                .find(|&&((block, idx), _)| block == helper.bb && idx == i);
+            if let Some((_, arg_source_info)) = bb_info {
+                self.set_debug_loc(bx, *arg_source_info);
+            }
+
             self.codegen_argument(
                 bx,
                 op,

compiler/rustc_middle/src/mir/mod.rs

@@ -331,6 +331,13 @@ pub struct Body<'tcx> {
     #[type_foldable(identity)]
     #[type_visitable(ignore)]
     pub function_coverage_info: Option<Box<coverage::FunctionCoverageInfo>>,
+
+    /// Debug information for argument moves/copies in Call parameters. Stores pairs of
+    /// ((BasicBlock, argument_index), SourceInfo) for move/copy operations. Only populated when
+    /// `-Zannotate-moves` is enabled.
+    #[type_foldable(identity)]
+    #[type_visitable(ignore)]
+    pub call_arg_move_source_info: Vec<((BasicBlock, usize), SourceInfo)>,
 }
 
 impl<'tcx> Body<'tcx> {
@@ -374,6 +381,7 @@ impl<'tcx> Body<'tcx> {
             tainted_by_errors,
             coverage_info_hi: None,
             function_coverage_info: None,
+            call_arg_move_source_info: Vec::new(),
         };
         body.is_polymorphic = body.has_non_region_param();
         body
@@ -405,6 +413,7 @@ impl<'tcx> Body<'tcx> {
             tainted_by_errors: None,
             coverage_info_hi: None,
             function_coverage_info: None,
+            call_arg_move_source_info: Vec::new(),
         };
         body.is_polymorphic = body.has_non_region_param();
         body

compiler/rustc_mir_build/src/builder/custom/mod.rs

@@ -62,6 +62,7 @@ pub(super) fn build_custom_mir<'tcx>(
         pass_count: 0,
         coverage_info_hi: None,
         function_coverage_info: None,
+        call_arg_move_source_info: Vec::new(),
     };
 
     body.local_decls.push(LocalDecl::new(return_ty, return_ty_span));