Infer nounwind and use it in MIR opts

Author: saethlin

compiler/rustc_interface/src/passes.rs

@@ -931,7 +931,7 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
     });
     sess.time("MIR_effect_checking", || {
         tcx.par_hir_body_owners(|def_id| {
-            tcx.ensure_ok().has_ffi_unwind_calls(def_id);
+            tcx.ensure_ok().mir_flags(def_id);
 
             // If we need to codegen, ensure that we emit all errors from
             // `mir_drops_elaborated_and_const_checked` now, to avoid discovering

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -347,6 +347,7 @@ provide! { tcx, def_id, other, cdata,
     is_mir_available => { cdata.is_item_mir_available(def_id.index) }
     is_ctfe_mir_available => { cdata.is_ctfe_mir_available(def_id.index) }
     cross_crate_inlinable => { table_direct }
+    mir_flags => { table_direct }
 
     dylib_dependency_formats => { cdata.get_dylib_dependency_formats(tcx) }
     is_private_dep => { cdata.private_dep }

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -26,6 +26,7 @@ use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
 use rustc_middle::middle::lib_features::FeatureStability;
 use rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault;
+use rustc_middle::mir::MirFlags;
 use rustc_middle::ty::fast_reject::SimplifiedType;
 use rustc_middle::ty::{
     self, DeducedParamAttrs, ParameterizedOverTcx, Ty, TyCtxt, UnusedGenericParams,
@@ -402,6 +403,7 @@ define_tables! {
     // individually instead of `DefId`s.
     module_children_reexports: Table<DefIndex, LazyArray<ModChild>>,
     cross_crate_inlinable: Table<DefIndex, bool>,
+    mir_flags: Table<DefIndex, MirFlags>,
 
 - optional:
     attributes: Table<DefIndex, LazyArray<hir::Attribute>>,

compiler/rustc_metadata/src/rmeta/table.rs

@@ -53,6 +53,12 @@ impl IsDefault for UnusedGenericParams {
     }
 }
 
+impl IsDefault for MirFlags {
+    fn is_default(&self) -> bool {
+        *self == Self::default()
+    }
+}
+
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
 /// Used mainly for Lazy positions and lengths.
 /// Unchecked invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
@@ -291,6 +297,21 @@ impl FixedSizeEncoding for AttrFlags {
     }
 }
 
+impl FixedSizeEncoding for MirFlags {
+    type ByteArray = [u8; 1];
+
+    #[inline]
+    fn from_bytes(b: &[u8; 1]) -> Self {
+        MirFlags::from_bits_truncate(b[0])
+    }
+
+    #[inline]
+    fn write_to_bytes(self, b: &mut [u8; 1]) {
+        debug_assert!(!self.is_default());
+        b[0] = self.bits();
+    }
+}
+
 impl FixedSizeEncoding for bool {
     type ByteArray = [u8; 1];
 

compiler/rustc_middle/src/mir/mod.rs

@@ -1743,6 +1743,16 @@ pub fn find_self_call<'tcx>(
     None
 }
 
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)]
+pub struct MirFlags(u8);
+
+bitflags::bitflags! {
+    impl MirFlags: u8 {
+        const IS_NOUNWIND = 1 << 0;
+        const HAS_FFI_UNWIND_CALLS = 1 << 1;
+    }
+}
+
 // Some nodes are used a lot. Make sure they don't unintentionally get bigger.
 #[cfg(target_pointer_width = "64")]
 mod size_asserts {

compiler/rustc_middle/src/query/erase.rs

@@ -287,6 +287,7 @@ trivial! {
     rustc_middle::middle::resolve_bound_vars::ResolvedArg,
     rustc_middle::middle::stability::DeprecationEntry,
     rustc_middle::mir::ConstQualifs,
+    rustc_middle::mir::MirFlags,
     rustc_middle::mir::interpret::AllocId,
     rustc_middle::mir::interpret::CtfeProvenance,
     rustc_middle::mir::interpret::ErrorHandled,

compiler/rustc_middle/src/query/mod.rs

@@ -53,6 +53,7 @@ use crate::middle::lib_features::LibFeatures;
 use crate::middle::privacy::EffectiveVisibilities;
 use crate::middle::resolve_bound_vars::{ObjectLifetimeDefault, ResolveBoundVars, ResolvedArg};
 use crate::middle::stability::{self, DeprecationEntry};
+use crate::mir::MirFlags;
 use crate::mir::interpret::{
     EvalStaticInitializerRawResult, EvalToAllocationRawResult, EvalToConstValueResult,
     EvalToValTreeResult, GlobalId, LitToConstInput,
@@ -1681,9 +1682,10 @@ rustc_queries! {
         desc { "checking if a crate is `#![profiler_runtime]`" }
         separate_provide_extern
     }
-    query has_ffi_unwind_calls(key: LocalDefId) -> bool {
-        desc { |tcx| "checking if `{}` contains FFI-unwind calls", tcx.def_path_str(key) }
-        cache_on_disk_if { true }
+    query mir_flags(key: DefId) -> MirFlags {
+        desc { |tcx| "stashing some local properties of `{}` before the body is stolen", tcx.def_path_str(key) }
+        cache_on_disk_if { key.is_local() }
+        separate_provide_extern
     }
     query required_panic_strategy(_: CrateNum) -> Option<PanicStrategy> {
         fatal_cycle

compiler/rustc_middle/src/ty/context.rs

@@ -65,7 +65,7 @@ use crate::metadata::ModChild;
 use crate::middle::codegen_fn_attrs::{CodegenFnAttrs, TargetFeature};
 use crate::middle::{resolve_bound_vars, stability};
 use crate::mir::interpret::{self, Allocation, ConstAllocation};
-use crate::mir::{Body, Local, Place, PlaceElem, ProjectionKind, Promoted};
+use crate::mir::{Body, Local, MirFlags, Place, PlaceElem, ProjectionKind, Promoted};
 use crate::query::plumbing::QuerySystem;
 use crate::query::{IntoQueryParam, LocalCrate, Providers, TyCtxtAt};
 use crate::thir::Thir;
@@ -3283,6 +3283,14 @@ impl<'tcx> TyCtxt<'tcx> {
         }
     }
 
+    pub fn is_nounwind(self, def_id: DefId) -> bool {
+        self.mir_flags(def_id).contains(MirFlags::IS_NOUNWIND)
+    }
+
+    pub fn has_ffi_unwind_calls(self, def_id: DefId) -> bool {
+        self.mir_flags(def_id).contains(MirFlags::HAS_FFI_UNWIND_CALLS)
+    }
+
     /// Whether this is a trait implementation that has `#[diagnostic::do_not_recommend]`
     pub fn do_not_recommend_impl(self, def_id: DefId) -> bool {
         self.get_diagnostic_attr(def_id, sym::do_not_recommend).is_some()

compiler/rustc_middle/src/ty/parameterized.rs

@@ -100,6 +100,7 @@ trivially_parameterized_over_tcx! {
     rustc_hir::PreciseCapturingArgKind<Symbol, Symbol>,
     rustc_index::bit_set::DenseBitSet<u32>,
     rustc_index::bit_set::FiniteBitSet<u32>,
+    rustc_middle::mir::MirFlags,
     rustc_session::cstore::ForeignModule,
     rustc_session::cstore::LinkagePreference,
     rustc_session::cstore::NativeLib,

compiler/rustc_mir_transform/src/ffi_unwind_calls.rs

@@ -1,5 +1,5 @@
 use rustc_abi::ExternAbi;
-use rustc_hir::def_id::{LOCAL_CRATE, LocalDefId};
+use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_middle::mir::*;
 use rustc_middle::query::{LocalCrate, Providers};
 use rustc_middle::ty::{self, TyCtxt, layout};
@@ -11,17 +11,10 @@ use tracing::debug;
 use crate::errors;
 
 // Check if the body of this def_id can possibly leak a foreign unwind into Rust code.
-fn has_ffi_unwind_calls(tcx: TyCtxt<'_>, local_def_id: LocalDefId) -> bool {
-    debug!("has_ffi_unwind_calls({local_def_id:?})");
+pub(crate) fn has_ffi_unwind_calls<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) -> bool {
+    let def_id = body.source.def_id();
 
-    // Only perform check on functions because constants cannot call FFI functions.
-    let def_id = local_def_id.to_def_id();
-    let kind = tcx.def_kind(def_id);
-    if !kind.is_fn_like() {
-        return false;
-    }
-
-    let body = &*tcx.mir_built(local_def_id).borrow();
+    debug!("has_ffi_unwind_calls({def_id:?})");
 
     let body_ty = tcx.type_of(def_id).skip_binder();
     let body_abi = match body_ty.kind() {
@@ -110,7 +103,7 @@ fn required_panic_strategy(tcx: TyCtxt<'_>, _: LocalCrate) -> Option<PanicStrate
     }
 
     for def_id in tcx.hir_body_owners() {
-        if tcx.has_ffi_unwind_calls(def_id) {
+        if tcx.has_ffi_unwind_calls(def_id.into()) {
             // Given that this crate is compiled in `-C panic=unwind`, the `AbortUnwindingCalls`
             // MIR pass will not be run on FFI-unwind call sites, therefore a foreign exception
             // can enter Rust through these sites.
@@ -141,5 +134,5 @@ fn required_panic_strategy(tcx: TyCtxt<'_>, _: LocalCrate) -> Option<PanicStrate
 }
 
 pub(crate) fn provide(providers: &mut Providers) {
-    *providers = Providers { has_ffi_unwind_calls, required_panic_strategy, ..*providers };
+    *providers = Providers { required_panic_strategy, ..*providers };
 }

compiler/rustc_mir_transform/src/instsimplify.rs

@@ -293,7 +293,9 @@ impl<'tcx> InstSimplifyContext<'_, 'tcx> {
             _ => bug!("unexpected body ty: {:?}", body_ty),
         };
 
-        if !layout::fn_can_unwind(self.tcx, Some(def_id), body_abi) {
+        if !layout::fn_can_unwind(self.tcx, Some(def_id), body_abi)
+            || (self.tcx.sess.opts.incremental.is_none() && self.tcx.is_nounwind(def_id))
+        {
             *unwind = UnwindAction::Unreachable;
         }
     }

compiler/rustc_mir_transform/src/lib.rs

@@ -27,8 +27,8 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_index::IndexVec;
 use rustc_middle::mir::{
     AnalysisPhase, Body, CallSource, ClearCrossCrate, ConstOperand, ConstQualifs, LocalDecl,
-    MirPhase, Operand, Place, ProjectionElem, Promoted, RuntimePhase, Rvalue, START_BLOCK,
-    SourceInfo, Statement, StatementKind, TerminatorKind,
+    MirFlags, MirPhase, Operand, Place, ProjectionElem, Promoted, RuntimePhase, Rvalue,
+    START_BLOCK, SourceInfo, Statement, StatementKind, TerminatorKind,
 };
 use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
 use rustc_middle::util::Providers;
@@ -225,6 +225,7 @@ pub fn provide(providers: &mut Providers) {
         promoted_mir,
         deduced_param_attrs: deduce_param_attrs::deduced_param_attrs,
         coroutine_by_move_body_def_id: coroutine::coroutine_by_move_body_def_id,
+        mir_flags,
         ..providers.queries
     };
 }
@@ -425,9 +426,6 @@ fn mir_promoted(
         _ => ConstQualifs::default(),
     };
 
-    // the `has_ffi_unwind_calls` query uses the raw mir, so make sure it is run.
-    tcx.ensure_done().has_ffi_unwind_calls(def);
-
     // the `by_move_body` query uses the raw mir, so make sure it is run.
     if tcx.needs_coroutine_by_move_body_def_id(def.to_def_id()) {
         tcx.ensure_done().coroutine_by_move_body_def_id(def);
@@ -458,6 +456,33 @@ fn mir_promoted(
     (tcx.alloc_steal_mir(body), tcx.alloc_steal_promoted(promoted))
 }
 
+fn mir_flags<'tcx>(tcx: TyCtxt<'tcx>, local_def_id: LocalDefId) -> MirFlags {
+    let mut flags = MirFlags::default();
+    // Only perform check on functions because constants cannot call FFI functions.
+    let kind = tcx.def_kind(local_def_id);
+    if !kind.is_fn_like() {
+        return flags;
+    }
+
+    if !tcx.mir_keys(()).contains(&local_def_id) {
+        return flags;
+    }
+
+    let body = &*tcx.mir_promoted(local_def_id).0.borrow();
+
+    if is_nounwind(body) {
+        flags.insert(MirFlags::IS_NOUNWIND);
+    }
+    if ffi_unwind_calls::has_ffi_unwind_calls(tcx, body) {
+        flags.insert(MirFlags::HAS_FFI_UNWIND_CALLS);
+    }
+    flags
+}
+
+fn is_nounwind<'tcx>(body: &Body<'tcx>) -> bool {
+    body.basic_blocks.iter().all(|block| block.terminator().unwind().is_none())
+}
+
 /// Compute the MIR that is used during CTFE (and thus has no optimizations run on it)
 fn mir_for_ctfe(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &Body<'_> {
     tcx.arena.alloc(inner_mir_for_ctfe(tcx, def_id))
@@ -508,6 +533,7 @@ fn mir_drops_elaborated_and_const_checked(tcx: TyCtxt<'_>, def: LocalDefId) -> &
         {
             tcx.ensure_done().mir_inliner_callees(ty::InstanceKind::Item(def.to_def_id()));
         }
+        tcx.ensure_done().mir_flags(def);
     }
 
     let (body, _) = tcx.mir_promoted(def);

tests/codegen/drop.rs

@@ -23,7 +23,7 @@ pub fn droppy() {
     // FIXME(eddyb) the `void @` forces a match on the instruction, instead of the
     // comment, that's `; call core::ptr::drop_in_place::<drop::SomeUniqueName>`
     // for the `v0` mangling, should switch to matching on that once `legacy` is gone.
-    // CHECK-COUNT-6: {{(call|invoke) void @.*}}drop_in_place{{.*}}SomeUniqueName
+    // CHECK-COUNT-5: {{(call|invoke) void @.*}}drop_in_place{{.*}}SomeUniqueName
     // CHECK-NOT: {{(call|invoke) void @.*}}drop_in_place{{.*}}SomeUniqueName
     // The next line checks for the } that ends the function definition
     // CHECK-LABEL: {{^[}]}}

tests/codegen/personality_lifetimes.rs

@@ -13,7 +13,9 @@ impl Drop for S {
 }
 
 #[inline(never)]
-fn might_unwind() {}
+fn might_unwind() {
+    panic!()
+}
 
 // CHECK-LABEL: @test
 #[no_mangle]

tests/mir-opt/inline/caller_with_trivial_bound.foo.Inline.panic-unwind.diff

@@ -10,7 +10,7 @@
 
       bb0: {
           StorageLive(_1);
-          _1 = bar::<T>() -> [return: bb1, unwind continue];
+          _1 = bar::<T>() -> [return: bb1, unwind unreachable];
       }
 
       bb1: {

tests/mir-opt/inline/forced.caller.ForceInline.panic-unwind.diff

@@ -9,7 +9,7 @@
 
       bb0: {
           StorageLive(_1);
--         _1 = callee_forced() -> [return: bb1, unwind continue];
+-         _1 = callee_forced() -> [return: bb1, unwind unreachable];
 -     }
 - 
 -     bb1: {

tests/mir-opt/inline/forced_closure.caller-{closure#0}.ForceInline.panic-unwind.diff

@@ -9,7 +9,7 @@
 
       bb0: {
           StorageLive(_2);
--         _2 = callee_forced() -> [return: bb1, unwind continue];
+-         _2 = callee_forced() -> [return: bb1, unwind unreachable];
 -     }
 - 
 -     bb1: {

tests/mir-opt/inline/forced_dead_code.caller.ForceInline.panic-unwind.diff

@@ -9,7 +9,7 @@
 
       bb0: {
           StorageLive(_1);
--         _1 = callee_forced() -> [return: bb1, unwind continue];
+-         _1 = callee_forced() -> [return: bb1, unwind unreachable];
 -     }
 - 
 -     bb1: {

tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff

@@ -30,7 +30,7 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
--         _4 = g() -> [return: bb1, unwind continue];
+-         _4 = g() -> [return: bb1, unwind unreachable];
 +         _4 = {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8 (#0)};
 +         _3 = &mut _4;
 +         _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: copy _3 };

tests/mir-opt/inline/inline_options.main.Inline.after.panic-unwind.mir

@@ -21,7 +21,7 @@ fn main() -> () {
         StorageLive(_3);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = g() -> [return: bb3, unwind continue];
+        _3 = g() -> [return: bb3, unwind unreachable];
     }
 
     bb2: {
@@ -34,10 +34,10 @@ fn main() -> () {
     }
 
     bb3: {
-        _4 = g() -> [return: bb4, unwind continue];
+        _4 = g() -> [return: bb4, unwind unreachable];
     }
 
     bb4: {
-        _5 = g() -> [return: bb2, unwind continue];
+        _5 = g() -> [return: bb2, unwind unreachable];
     }
 }

tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-unwind.mir

@@ -8,7 +8,7 @@ fn test(_1: &dyn X) -> u32 {
     bb0: {
         StorageLive(_2);
         _2 = copy _1;
-        _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind continue];
+        _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {

tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir

@@ -15,7 +15,7 @@ fn test2(_1: &dyn X) -> bool {
         _3 = copy _1;
         _2 = move _3;
         StorageDead(_3);
-        _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind continue];
+        _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {

tests/mir-opt/inline/issue_78442.bar.Inline.panic-unwind.diff

@@ -19,7 +19,7 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
--         _4 = hide_foo() -> [return: bb1, unwind: bb4];
+-         _4 = hide_foo() -> [return: bb1, unwind unreachable];
 -     }
 - 
 -     bb1: {

tests/mir-opt/inline/rustc_no_mir_inline.caller.Inline.panic-unwind.diff

@@ -7,7 +7,7 @@
 
       bb0: {
           StorageLive(_1);
-          _1 = callee() -> [return: bb1, unwind continue];
+          _1 = callee() -> [return: bb1, unwind unreachable];
       }
 
       bb1: {