Use lang items rather than diagnostic items for profiling markers

Author: jsgf

compiler/rustc_codegen_ssa/src/mir/operand.rs

@@ -5,13 +5,13 @@ use rustc_abi as abi;
 use rustc_abi::{
     Align, BackendRepr, FIRST_VARIANT, FieldIdx, Primitive, Size, TagEncoding, VariantIdx, Variants,
 };
+use rustc_hir::LangItem;
 use rustc_middle::mir::interpret::{Pointer, Scalar, alloc_range};
 use rustc_middle::mir::{self, ConstValue};
 use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, Ty};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::{AnnotateMoves, DebugInfo, OptLevel};
-use rustc_span::{Symbol, sym};
 use tracing::{debug, instrument};
 
 use super::place::{PlaceRef, PlaceValue};
@@ -1039,8 +1039,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         match *operand {
             mir::Operand::Copy(ref place) | mir::Operand::Move(ref place) => {
                 let kind = match operand {
-                    mir::Operand::Move(_) => sym::compiler_move,
-                    mir::Operand::Copy(_) => sym::compiler_copy,
+                    mir::Operand::Move(_) => LangItem::CompilerMove,
+                    mir::Operand::Copy(_) => LangItem::CompilerCopy,
                     _ => unreachable!(),
                 };
 
@@ -1086,7 +1086,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         &self,
         bx: &Bx,
         place: mir::PlaceRef<'tcx>,
-        kind: Symbol,
+        kind: LangItem,
     ) -> Option<ty::Instance<'tcx>> {
         let tcx = bx.tcx();
         let sess = tcx.sess;
@@ -1116,9 +1116,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             return None;
         }
 
-        // Look up the DefId for compiler_move or compiler_copy (skip if it's missing for some
-        // reason).
-        let def_id = tcx.get_diagnostic_item(kind)?;
+        // Look up the DefId for compiler_move or compiler_copy lang item
+        let def_id = tcx.lang_items().get(kind)?;
 
         // Create generic args: compiler_move<T, SIZE> or compiler_copy<T, SIZE>
         let size_const = ty::Const::from_target_usize(tcx, ty_size);

compiler/rustc_hir/src/lang_items.rs

@@ -345,6 +345,10 @@ language_item_table! {
     EhPersonality,           sym::eh_personality,      eh_personality,             Target::Fn,             GenericRequirement::None;
     EhCatchTypeinfo,         sym::eh_catch_typeinfo,   eh_catch_typeinfo,          Target::Static,         GenericRequirement::None;
 
+    // Profiling markers for move/copy operations (used by -Z annotate-moves)
+    CompilerMove,            sym::compiler_move,       compiler_move_fn,           Target::Fn,             GenericRequirement::Exact(2);
+    CompilerCopy,            sym::compiler_copy,       compiler_copy_fn,           Target::Fn,             GenericRequirement::Exact(2);
+
     OwnedBox,                sym::owned_box,           owned_box,                  Target::Struct,         GenericRequirement::Minimum(1);
     GlobalAlloc,             sym::global_alloc_ty,     global_alloc_ty,            Target::Struct,         GenericRequirement::None;
 

library/core/src/profiling.rs

@@ -8,7 +8,7 @@
 ///
 /// The `SIZE` parameter encodes the size of the type being moved.
 #[unstable(feature = "profiling_marker_api", issue = "none")]
-#[rustc_diagnostic_item = "compiler_move"]
+#[lang = "compiler_move"]
 pub fn compiler_move<T, const SIZE: usize>(_src: *const T, _dst: *mut T) {
     unreachable!(
         "compiler_move marks where the compiler generated a copy; it is never actually called"
@@ -23,7 +23,7 @@ pub fn compiler_move<T, const SIZE: usize>(_src: *const T, _dst: *mut T) {
 ///
 /// The `SIZE` parameter encodes the size of the type being copied.
 #[unstable(feature = "profiling_marker_api", issue = "none")]
-#[rustc_diagnostic_item = "compiler_copy"]
+#[lang = "compiler_copy"]
 pub fn compiler_copy<T, const SIZE: usize>(_src: *const T, _dst: *mut T) {
     unreachable!(
         "compiler_copy marks where the compiler generated a copy; it is never actually called"