Add an Abort terminator to MIR and lower all abort intrinsic calls to it

oli-obk · oli-obk · commit 4b6421136edf · 2024-03-13T15:42:39.000Z
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
@@ -755,6 +755,7 @@ impl<'cx, 'tcx, R> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx, R> for MirBorro
 
             TerminatorKind::Goto { target: _ }
             | TerminatorKind::UnwindTerminate(_)
+            | TerminatorKind::Abort
             | TerminatorKind::Unreachable
             | TerminatorKind::UnwindResume
             | TerminatorKind::Return
@@ -810,6 +811,7 @@ impl<'cx, 'tcx, R> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx, R> for MirBorro
             | TerminatorKind::Goto { .. }
             | TerminatorKind::SwitchInt { .. }
             | TerminatorKind::Unreachable
+            | TerminatorKind::Abort
             | TerminatorKind::InlineAsm { .. } => {}
         }
     }
diff --git a/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs
@@ -190,6 +190,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for LoanInvalidationsGenerator<'cx, 'tcx> {
             TerminatorKind::Goto { target: _ }
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Unreachable
+            | TerminatorKind::Abort
             | TerminatorKind::FalseEdge { real_target: _, imaginary_target: _ }
             | TerminatorKind::FalseUnwind { real_target: _, unwind: _ } => {
                 // no data used, thus irrelevant to borrowck
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1396,6 +1396,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Return
             | TerminatorKind::CoroutineDrop
+            | TerminatorKind::Abort
             | TerminatorKind::Unreachable
             | TerminatorKind::Drop { .. }
             | TerminatorKind::FalseEdge { .. }
@@ -1750,7 +1751,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                     self.assert_iscleanup(body, block_data, drop, is_cleanup);
                 }
             }
-            TerminatorKind::Unreachable => {}
+            TerminatorKind::Abort | TerminatorKind::Unreachable => {}
             TerminatorKind::Drop { target, unwind, .. }
             | TerminatorKind::Assert { target, unwind, .. } => {
                 self.assert_iscleanup(body, block_data, target, is_cleanup);
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -487,6 +487,9 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
             TerminatorKind::Unreachable => {
                 fx.bcx.ins().trap(TrapCode::UnreachableCodeReached);
             }
+            TerminatorKind::Abort => {
+                fx.bcx.ins().trap(TrapCode::User(0));
+            }
             TerminatorKind::Yield { .. }
             | TerminatorKind::FalseEdge { .. }
             | TerminatorKind::FalseUnwind { .. }
diff --git a/compiler/rustc_codegen_cranelift/src/constant.rs b/compiler/rustc_codegen_cranelift/src/constant.rs
@@ -532,6 +532,7 @@ pub(crate) fn mir_operand_get_const_val<'tcx>(
                     | TerminatorKind::UnwindResume
                     | TerminatorKind::UnwindTerminate(_)
                     | TerminatorKind::Return
+                    | TerminatorKind::Abort
                     | TerminatorKind::Unreachable
                     | TerminatorKind::Drop { .. }
                     | TerminatorKind::Assert { .. } => {}
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@@ -439,10 +439,6 @@ fn codegen_regular_intrinsic_call<'tcx>(
     let usize_layout = fx.layout_of(fx.tcx.types.usize);
 
     match intrinsic {
-        sym::abort => {
-            fx.bcx.ins().trap(TrapCode::User(0));
-            return Ok(());
-        }
         sym::likely | sym::unlikely => {
             intrinsic_args!(fx, args => (a); intrinsic);
 
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -88,7 +88,6 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
         sym::roundf64 => "round",
         sym::roundevenf32 => "roundevenf",
         sym::roundevenf64 => "roundeven",
-        sym::abort => "abort",
         _ => return None,
     };
     Some(cx.context.get_builtin_function(&gcc_name))
diff --git a/compiler/rustc_codegen_ssa/src/mir/analyze.rs b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
@@ -280,6 +280,7 @@ pub fn cleanup_kinds(mir: &mir::Body<'_>) -> IndexVec<mir::BasicBlock, CleanupKi
                 | TerminatorKind::UnwindTerminate(_)
                 | TerminatorKind::Return
                 | TerminatorKind::CoroutineDrop
+                | TerminatorKind::Abort
                 | TerminatorKind::Unreachable
                 | TerminatorKind::SwitchInt { .. }
                 | TerminatorKind::Yield { .. }
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -1295,6 +1295,14 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 MergingSucc::False
             }
 
+            mir::TerminatorKind::Abort => {
+                bx.abort();
+                // `abort` does not terminate the block, so we still need to generate
+                // an `unreachable` terminator after it.
+                bx.unreachable();
+                MergingSucc::False
+            }
+
             mir::TerminatorKind::Drop { place, target, unwind, replace: _ } => {
                 self.codegen_drop_terminator(helper, bx, place, target, unwind, mergeable_succ())
             }
diff --git a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
@@ -79,11 +79,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         let result = PlaceRef::new_sized(llresult, fn_abi.ret.layout);
 
         let llval = match name {
-            sym::abort => {
-                bx.abort();
-                return Ok(());
-            }
-
             sym::va_start => bx.va_start(args[0].immediate()),
             sym::va_end => bx.va_end(args[0].immediate()),
             sym::size_of_val => {
diff --git a/compiler/rustc_const_eval/src/interpret/terminator.rs b/compiler/rustc_const_eval/src/interpret/terminator.rs
@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use either::Either;
 
 use rustc_middle::{
-    mir,
+    mir::{self, interpret},
     ty::{
         self,
         layout::{FnAbiOf, IntegerExt, LayoutOf, TyAndLayout},
@@ -212,6 +212,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 return Ok(());
             }
 
+            Abort => throw_machine_stop!(interpret::Abort),
+
             // It is UB to ever encounter this.
             Unreachable => throw_ub!(Unreachable),
 
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
@@ -955,6 +955,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
             | TerminatorKind::Goto { .. }
             | TerminatorKind::UnwindResume
             | TerminatorKind::Return
+            | TerminatorKind::Abort
             | TerminatorKind::SwitchInt { .. }
             | TerminatorKind::Unreachable => {}
         }
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/post_drop_elaboration.rs b/compiler/rustc_const_eval/src/transform/check_consts/post_drop_elaboration.rs
@@ -117,6 +117,7 @@ impl<'tcx> Visitor<'tcx> for CheckLiveDrops<'_, 'tcx> {
             | mir::TerminatorKind::Return
             | mir::TerminatorKind::SwitchInt { .. }
             | mir::TerminatorKind::Unreachable
+            | mir::TerminatorKind::Abort
             | mir::TerminatorKind::Yield { .. } => {}
         }
     }
diff --git a/compiler/rustc_const_eval/src/transform/validate.rs b/compiler/rustc_const_eval/src/transform/validate.rs
@@ -509,7 +509,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CfgChecker<'a, 'tcx> {
                     self.fail(location, "Cannot `Return` from cleanup basic block")
                 }
             }
-            TerminatorKind::Unreachable => {}
+            TerminatorKind::Abort | TerminatorKind::Unreachable => {}
         }
 
         self.super_terminator(terminator, location);
@@ -1342,6 +1342,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             | TerminatorKind::UnwindResume
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Return
+            | TerminatorKind::Abort
             | TerminatorKind::Unreachable => {}
         }
 
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -501,6 +501,17 @@ impl dyn MachineStopType {
     }
 }
 
+#[derive(Debug)]
+pub struct Abort;
+
+impl MachineStopType for Abort {
+    fn diagnostic_message(&self) -> DiagMessage {
+        "the program aborted execution".into()
+    }
+
+    fn add_args(self: Box<Self>, _adder: &mut dyn FnMut(DiagArgName, DiagArgValue)) {}
+}
+
 #[derive(Debug)]
 pub enum InterpError<'tcx> {
     /// The program caused undefined behavior.
diff --git a/compiler/rustc_middle/src/mir/interpret/mod.rs b/compiler/rustc_middle/src/mir/interpret/mod.rs
@@ -142,12 +142,12 @@ use crate::ty::GenericArgKind;
 use crate::ty::{self, Instance, Ty, TyCtxt};
 
 pub use self::error::{
-    BadBytesAccess, CheckAlignMsg, CheckInAllocMsg, ErrorHandled, EvalStaticInitializerRawResult,
-    EvalToAllocationRawResult, EvalToConstValueResult, EvalToValTreeResult, ExpectedKind,
-    InterpError, InterpErrorInfo, InterpResult, InvalidMetaKind, InvalidProgramInfo,
-    MachineStopType, Misalignment, PointerKind, ReportedErrorInfo, ResourceExhaustionInfo,
-    ScalarSizeMismatch, UndefinedBehaviorInfo, UnsupportedOpInfo, ValidationErrorInfo,
-    ValidationErrorKind,
+    Abort, BadBytesAccess, CheckAlignMsg, CheckInAllocMsg, ErrorHandled,
+    EvalStaticInitializerRawResult, EvalToAllocationRawResult, EvalToConstValueResult,
+    EvalToValTreeResult, ExpectedKind, InterpError, InterpErrorInfo, InterpResult, InvalidMetaKind,
+    InvalidProgramInfo, MachineStopType, Misalignment, PointerKind, ReportedErrorInfo,
+    ResourceExhaustionInfo, ScalarSizeMismatch, UndefinedBehaviorInfo, UnsupportedOpInfo,
+    ValidationErrorInfo, ValidationErrorKind,
 };
 
 pub use self::value::Scalar;
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -768,6 +768,7 @@ impl<'tcx> TerminatorKind<'tcx> {
             }
             Yield { value, resume_arg, .. } => write!(fmt, "{resume_arg:?} = yield({value:?})"),
             Unreachable => write!(fmt, "unreachable"),
+            Abort => write!(fmt, "abort"),
             Drop { place, .. } => write!(fmt, "drop({place:?})"),
             Call { func, args, destination, .. } => {
                 write!(fmt, "{destination:?} = ")?;
@@ -847,7 +848,9 @@ impl<'tcx> TerminatorKind<'tcx> {
     pub fn fmt_successor_labels(&self) -> Vec<Cow<'static, str>> {
         use self::TerminatorKind::*;
         match *self {
-            Return | UnwindResume | UnwindTerminate(_) | Unreachable | CoroutineDrop => vec![],
+            Return | UnwindResume | UnwindTerminate(_) | Unreachable | CoroutineDrop | Abort => {
+                vec![]
+            }
             Goto { .. } => vec!["".into()],
             SwitchInt { ref targets, .. } => targets
                 .values
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
@@ -637,6 +637,11 @@ pub enum TerminatorKind<'tcx> {
     /// Executing this terminator is UB.
     Unreachable,
 
+    /// Equivalent to invoking the `abort` intrinsic
+    ///
+    /// Halts execution without unwinding.
+    Abort,
+
     /// The behavior of this statement differs significantly before and after drop elaboration.
     ///
     /// After drop elaboration: `Drop` terminators are a complete nop for types that have no drop
@@ -815,6 +820,7 @@ impl TerminatorKind<'_> {
             TerminatorKind::UnwindTerminate(_) => "UnwindTerminate",
             TerminatorKind::Return => "Return",
             TerminatorKind::Unreachable => "Unreachable",
+            TerminatorKind::Abort => "Abort",
             TerminatorKind::Drop { .. } => "Drop",
             TerminatorKind::Call { .. } => "Call",
             TerminatorKind::Assert { .. } => "Assert",
diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
@@ -402,6 +402,7 @@ impl<'tcx> TerminatorKind<'tcx> {
             | CoroutineDrop
             | Return
             | Unreachable
+            | Abort
             | Call { target: None, unwind: _, .. } => (&[]).into_iter().copied().chain(None),
             InlineAsm { ref targets, unwind: UnwindAction::Cleanup(u), .. } => {
                 targets.iter().copied().chain(Some(u))
@@ -439,6 +440,7 @@ impl<'tcx> TerminatorKind<'tcx> {
             | CoroutineDrop
             | Return
             | Unreachable
+            | Abort
             | Call { target: None, unwind: _, .. } => (&mut []).into_iter().chain(None),
             InlineAsm { ref mut targets, unwind: UnwindAction::Cleanup(ref mut u), .. } => {
                 targets.iter_mut().chain(Some(u))
@@ -459,6 +461,7 @@ impl<'tcx> TerminatorKind<'tcx> {
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Return
             | TerminatorKind::Unreachable
+            | TerminatorKind::Abort
             | TerminatorKind::CoroutineDrop
             | TerminatorKind::Yield { .. }
             | TerminatorKind::SwitchInt { .. }
@@ -479,6 +482,7 @@ impl<'tcx> TerminatorKind<'tcx> {
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Return
             | TerminatorKind::Unreachable
+            | TerminatorKind::Abort
             | TerminatorKind::CoroutineDrop
             | TerminatorKind::Yield { .. }
             | TerminatorKind::SwitchInt { .. }
@@ -563,7 +567,7 @@ impl<'tcx> TerminatorKind<'tcx> {
     pub fn edges(&self) -> TerminatorEdges<'_, 'tcx> {
         use TerminatorKind::*;
         match *self {
-            Return | UnwindResume | UnwindTerminate(_) | CoroutineDrop | Unreachable => {
+            Return | UnwindResume | UnwindTerminate(_) | CoroutineDrop | Unreachable | Abort => {
                 TerminatorEdges::None
             }
 
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
@@ -475,6 +475,7 @@ macro_rules! make_mir_visitor {
                     TerminatorKind::UnwindTerminate(_) |
                     TerminatorKind::CoroutineDrop |
                     TerminatorKind::Unreachable |
+                    TerminatorKind::Abort |
                     TerminatorKind::FalseEdge { .. } |
                     TerminatorKind::FalseUnwind { .. } => {}
 
diff --git a/compiler/rustc_mir_build/src/build/scope.rs b/compiler/rustc_mir_build/src/build/scope.rs
@@ -1532,6 +1532,7 @@ impl<'tcx> DropTreeBuilder<'tcx> for Unwind {
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Return
             | TerminatorKind::Unreachable
+            | TerminatorKind::Abort
             | TerminatorKind::Yield { .. }
             | TerminatorKind::CoroutineDrop
             | TerminatorKind::FalseEdge { .. } => {
diff --git a/compiler/rustc_mir_build/src/lints.rs b/compiler/rustc_mir_build/src/lints.rs
@@ -197,6 +197,7 @@ impl<'mir, 'tcx, C: TerminatorClassifier<'tcx>> TriColorVisitor<BasicBlocks<'tcx
             | TerminatorKind::UnwindResume
             | TerminatorKind::Return
             | TerminatorKind::Unreachable
+            | TerminatorKind::Abort
             | TerminatorKind::Yield { .. } => ControlFlow::Break(NonRecursive),
 
             // A InlineAsm without targets (diverging and contains no labels)
diff --git a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
@@ -148,6 +148,7 @@ where
             | TerminatorKind::Return
             | TerminatorKind::SwitchInt { .. }
             | TerminatorKind::Unreachable
+            | TerminatorKind::Abort
             | TerminatorKind::Yield { .. } => {}
         }
     }
diff --git a/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs b/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs
@@ -288,6 +288,7 @@ impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {
             | TerminatorKind::Goto { .. }
             | TerminatorKind::UnwindResume
             | TerminatorKind::Return
+            | TerminatorKind::Abort
             | TerminatorKind::SwitchInt { .. }
             | TerminatorKind::Unreachable => {}
         }
@@ -325,6 +326,7 @@ impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {
             | TerminatorKind::Goto { .. }
             | TerminatorKind::UnwindResume
             | TerminatorKind::Return
+            | TerminatorKind::Abort
             | TerminatorKind::SwitchInt { .. }
             | TerminatorKind::Unreachable => {}
         }
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -453,6 +453,7 @@ impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> {
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::CoroutineDrop
             | TerminatorKind::Unreachable
+            | TerminatorKind::Abort
             | TerminatorKind::Drop { .. } => {}
 
             TerminatorKind::Assert { ref cond, .. } => {
diff --git a/compiler/rustc_mir_dataflow/src/value_analysis.rs b/compiler/rustc_mir_dataflow/src/value_analysis.rs
@@ -273,6 +273,7 @@ pub trait ValueAnalysis<'tcx> {
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Return
             | TerminatorKind::Unreachable
+            | TerminatorKind::Abort
             | TerminatorKind::Assert { .. }
             | TerminatorKind::CoroutineDrop
             | TerminatorKind::FalseEdge { .. }
diff --git a/compiler/rustc_mir_transform/src/check_unsafety.rs b/compiler/rustc_mir_transform/src/check_unsafety.rs
@@ -60,6 +60,7 @@ impl<'tcx> Visitor<'tcx> for UnsafetyChecker<'_, 'tcx> {
             | TerminatorKind::UnwindResume
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Return
+            | TerminatorKind::Abort
             | TerminatorKind::Unreachable
             | TerminatorKind::FalseEdge { .. }
             | TerminatorKind::FalseUnwind { .. } => {
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -1356,6 +1356,7 @@ fn can_unwind<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) -> bool {
             | TerminatorKind::SwitchInt { .. }
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Return
+            | TerminatorKind::Abort
             | TerminatorKind::Unreachable
             | TerminatorKind::CoroutineDrop
             | TerminatorKind::FalseEdge { .. }
@@ -1887,6 +1888,7 @@ impl<'tcx> Visitor<'tcx> for EnsureCoroutineFieldAssignmentsNeverAlias<'_> {
             | TerminatorKind::UnwindResume
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Return
+            | TerminatorKind::Abort
             | TerminatorKind::Unreachable
             | TerminatorKind::Drop { .. }
             | TerminatorKind::Assert { .. }
diff --git a/compiler/rustc_mir_transform/src/coverage/graph.rs b/compiler/rustc_mir_transform/src/coverage/graph.rs
@@ -367,7 +367,7 @@ fn bcb_filtered_successors<'a, 'tcx>(terminator: &'a Terminator<'tcx>) -> Covera
         }
 
         // These terminators have no coverage-relevant successors.
-        CoroutineDrop | Return | Unreachable | UnwindResume | UnwindTerminate(_) => {
+        CoroutineDrop | Return | Unreachable | Abort | UnwindResume | UnwindTerminate(_) => {
             CoverageSuccessors::NotChainable(&[])
         }
     }
diff --git a/compiler/rustc_mir_transform/src/coverage/spans/from_mir.rs b/compiler/rustc_mir_transform/src/coverage/spans/from_mir.rs
@@ -242,6 +242,7 @@ fn filtered_terminator_span(terminator: &Terminator<'_>) -> Option<Span> {
         // but for coverage, the code region executed, up to *and* through the SwitchInt,
         // actually stops before the if's block.)
         TerminatorKind::Unreachable // Unreachable blocks are not connected to the MIR CFG
+        | TerminatorKind::Abort
         | TerminatorKind::Assert { .. }
         | TerminatorKind::Drop { .. }
         | TerminatorKind::SwitchInt { .. }
diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -657,6 +657,7 @@ impl WriteInfo {
             | TerminatorKind::UnwindResume
             | TerminatorKind::UnwindTerminate(_)
             | TerminatorKind::Return
+            | TerminatorKind::Abort
             | TerminatorKind::Unreachable { .. } => (),
             TerminatorKind::Drop { .. } => {
                 // `Drop`s create a `&mut` and so are not considered
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
diff --git a/compiler/rustc_mir_transform/src/jump_threading.rs b/compiler/rustc_mir_transform/src/jump_threading.rs
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
diff --git a/compiler/rustc_mir_transform/src/lower_intrinsics.rs b/compiler/rustc_mir_transform/src/lower_intrinsics.rs
diff --git a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
diff --git a/compiler/stable_mir/src/mir/body.rs b/compiler/stable_mir/src/mir/body.rs
diff --git a/compiler/stable_mir/src/mir/pretty.rs b/compiler/stable_mir/src/mir/pretty.rs
diff --git a/compiler/stable_mir/src/mir/visit.rs b/compiler/stable_mir/src/mir/visit.rs
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
diff --git a/src/tools/miri/src/shims/intrinsics/mod.rs b/src/tools/miri/src/shims/intrinsics/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -755,6 +755,7 @@ impl<'cx, 'tcx, R> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx, R> for MirBorro`
`755`	`755`
`756`	`756`	`TerminatorKind::Goto { target: _ }`
`757`	`757`	`\| TerminatorKind::UnwindTerminate(_)`
	`758`	`+ \| TerminatorKind::Abort`
`758`	`759`	`\| TerminatorKind::Unreachable`
`759`	`760`	`\| TerminatorKind::UnwindResume`
`760`	`761`	`\| TerminatorKind::Return`
`@@ -810,6 +811,7 @@ impl<'cx, 'tcx, R> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx, R> for MirBorro`
`810`	`811`	`\| TerminatorKind::Goto { .. }`
`811`	`812`	`\| TerminatorKind::SwitchInt { .. }`
`812`	`813`	`\| TerminatorKind::Unreachable`
	`814`	`+ \| TerminatorKind::Abort`
`813`	`815`	`\| TerminatorKind::InlineAsm { .. } => {}`
`814`	`816`	`}`
`815`	`817`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1295,6 +1295,14 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`1295`	`1295`	`MergingSucc::False`
`1296`	`1296`	`}`
`1297`	`1297`
	`1298`	`+ mir::TerminatorKind::Abort => {`
	`1299`	`+ bx.abort();`
	`1300`	+ // `abort` does not terminate the block, so we still need to generate
	`1301`	+ // an `unreachable` terminator after it.
	`1302`	`+ bx.unreachable();`
	`1303`	`+ MergingSucc::False`
	`1304`	`+ }`
	`1305`	`+`
`1298`	`1306`	`mir::TerminatorKind::Drop { place, target, unwind, replace: _ } => {`
`1299`	`1307`	`self.codegen_drop_terminator(helper, bx, place, target, unwind, mergeable_succ())`
`1300`	`1308`	`}`