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));