Bit of cleanup

Author: saethlin

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -298,6 +298,9 @@ fn process_builtin_attrs(
                 codegen_fn_attrs.patchable_function_entry =
                     Some(PatchableFunctionEntry::from_prefix_and_entry(*prefix, *entry));
             }
+            AttributeKind::RustcPanicEntrypoint => {
+                codegen_fn_attrs.flags |= CodegenFnAttrFlags::PANIC_ENTRYPOINT
+            }
             _ => {}
         }
     }
@@ -392,7 +395,7 @@ fn apply_overrides(tcx: TyCtxt<'_>, did: LocalDefId, codegen_fn_attrs: &mut Code
         }
     }
 
-    if tcx.is_panic_entrypoint(did) {
+    if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::PANIC_ENTRYPOINT) {
         // Panic entrypoints are always cold.
         //
         // If we have immediate-abort enabled, we want panic entrypoints to be inlined. We have a

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -177,7 +177,7 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
         if let Some(instance) = instance
             && is_call_from_compiler_builtins_to_upstream_monomorphization(tcx, instance)
         {
-            if tcx.is_panic_entrypoint(instance.def_id()) {
+            if instance.def.is_panic_entrypoint(tcx) {
                 info!(
                     "compiler_builtins call to panic entrypoint {:?} replaced with abort",
                     instance.def_id()

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -154,7 +154,7 @@ impl AttributeKind {
             RustcObjectLifetimeDefault => No,
             RustcOffloadKernel => Yes,
             RustcOutlives => No,
-            RustcPanicEntrypoint => Yes,
+            RustcPanicEntrypoint => No,
             RustcParenSugar(..) => No,
             RustcPassByValue(..) => Yes,
             RustcPassIndirectlyInNonRusticAbis(..) => No,

compiler/rustc_middle/src/middle/codegen_fn_attrs.rs

@@ -210,6 +210,7 @@ bitflags::bitflags! {
         /// As such, we must make sure these symbols really do exist in the final binary/library.
         /// This flag is put on both the implementations of EIIs and the foreign item they implement.
         const EXTERNALLY_IMPLEMENTABLE_ITEM = 1 << 18;
+        const PANIC_ENTRYPOINT = 1 << 19;
     }
 }
 rustc_data_structures::external_bitflags_debug! { CodegenFnAttrFlags }

compiler/rustc_middle/src/ty/context.rs

@@ -2791,10 +2791,6 @@ impl<'tcx> TyCtxt<'tcx> {
         }
         false
     }
-
-    pub fn is_panic_entrypoint(self, def_id: impl Into<DefId>) -> bool {
-        find_attr!(self.get_all_attrs(def_id), AttributeKind::RustcPanicEntrypoint)
-    }
 }
 
 pub fn provide(providers: &mut Providers) {

compiler/rustc_middle/src/ty/instance.rs

@@ -353,6 +353,10 @@ impl<'tcx> InstanceKind<'tcx> {
             | InstanceKind::VTableShim(..) => true,
         }
     }
+
+    pub fn is_panic_entrypoint(&self, tcx: TyCtxt<'_>) -> bool {
+        tcx.codegen_instance_attrs(*self).flags.contains(CodegenFnAttrFlags::PANIC_ENTRYPOINT)
+    }
 }
 
 fn type_length<'tcx>(item: impl TypeVisitable<TyCtxt<'tcx>>) -> usize {

compiler/rustc_mir_transform/src/panic_entrypoints.rs

@@ -1,6 +1,6 @@
 use rustc_hir::LangItem;
 use rustc_middle::mir::{Const, ConstValue, UnwindAction, *};
-use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_middle::ty::{self, InstanceKind, Ty, TyCtxt};
 use rustc_span::Span;
 use rustc_target::spec::PanicStrategy;
 use tracing::{debug, instrument};
@@ -14,7 +14,7 @@ impl<'tcx> crate::MirPass<'tcx> for PanicEntrypoints {
 
     #[instrument(level = "trace", skip(self, tcx, body))]
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
-        if tcx.is_panic_entrypoint(body.source.def_id()) {
+        if body.source.instance.is_panic_entrypoint(tcx) {
             debug!("Replacing body of {:?}", body.source);
             let blocks = body.basic_blocks.as_mut();
             blocks.raw.clear();
@@ -27,13 +27,10 @@ impl<'tcx> crate::MirPass<'tcx> for PanicEntrypoints {
             let TerminatorKind::Call { func, .. } = &mut terminator.kind else {
                 continue;
             };
-            let Operand::Constant(box ConstOperand { const_, .. }) = &func else {
+            let Some((def_id, _args)) = func.const_fn_def() else {
                 continue;
             };
-            let ty::FnDef(def_id, _) = *const_.ty().kind() else {
-                continue;
-            };
-            if tcx.is_panic_entrypoint(def_id) {
+            if InstanceKind::Item(def_id).is_panic_entrypoint(tcx) {
                 debug!("Remapping call from {:?} to {:?}", body.source, def_id);
                 *terminator = abort_terminator(tcx, terminator.source_info.span);
             }

library/alloc/src/vec/mod.rs

@@ -2130,7 +2130,6 @@ impl<T, A: Allocator> Vec<T, A> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn swap_remove(&mut self, index: usize) -> T {
-        #[track_caller]
         #[rustc_panic_entrypoint]
         fn assert_failed(index: usize, len: usize) -> ! {
             panic!("swap_remove index (is {index}) should be < len (is {len})");

library/core/src/slice/sort/shared/smallsort.rs

@@ -840,7 +840,6 @@ unsafe fn bidirectional_merge<T: FreezeMarker, F: FnMut(&T, &T) -> bool>(
     }
 }
 
-#[track_caller]
 #[rustc_panic_entrypoint]
 fn panic_on_ord_violation() -> ! {
     // This is indicative of a logic bug in the user-provided comparison function or Ord

library/core/src/wtf8.rs

@@ -485,7 +485,6 @@ unsafe fn slice_unchecked(s: &Wtf8, begin: usize, end: usize) -> &Wtf8 {
 }
 
 /// Copied from core::str::raw::slice_error_fail
-#[track_caller]
 #[rustc_panic_entrypoint]
 fn slice_error_fail(s: &Wtf8, begin: usize, end: usize) -> ! {
     assert!(begin <= end);