Auto merge of #130909 - saethlin:infer-nounwind, r=<try>

Infer nounwind and use it in MIR opts

r? `@ghost`

Sinking this into `layout::fn_can_unwind` yields bigger MIR diffs. That's something to try tweaking.

But also, this analysis reduces incrementality because call sites depend on callee bodies. So I've currently disabled it when incremental is enabled. That's another tweak I want to try.

Author: bors

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

@@ -352,6 +352,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 }
+    is_nounwind => { table_direct }
 
     dylib_dependency_formats => { cdata.get_dylib_dependency_formats(tcx) }
     is_private_dep => { cdata.private_dep }

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -404,6 +404,7 @@ define_tables! {
     // individually instead of `DefId`s.
     module_children_reexports: Table<DefIndex, LazyArray<ModChild>>,
     cross_crate_inlinable: Table<DefIndex, bool>,
+    is_nounwind: Table<DefIndex, bool>,
 
 - optional:
     attributes: Table<DefIndex, LazyArray<ast::Attribute>>,

compiler/rustc_middle/src/query/mod.rs

@@ -1505,6 +1505,10 @@ rustc_queries! {
         desc { |tcx| "checking if `{}` contains FFI-unwind calls", tcx.def_path_str(key) }
         cache_on_disk_if { true }
     }
+    query is_nounwind(key: DefId) -> bool {
+        desc { |tcx| "checking if `{}` contains unwinds", tcx.def_path_str(key) }
+        separate_provide_extern
+    }
     query required_panic_strategy(_: CrateNum) -> Option<PanicStrategy> {
         fatal_cycle
         desc { "getting a crate's required panic strategy" }

compiler/rustc_mir_transform/src/instsimplify.rs

@@ -326,7 +326,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

@@ -135,6 +135,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,
+        is_nounwind,
         ..providers.queries
     };
 }
@@ -339,6 +340,8 @@ fn mir_promoted(
         tcx.ensure_with_value().coroutine_by_move_body_def_id(def);
     }
 
+    tcx.ensure_with_value().is_nounwind(def);
+
     let mut body = tcx.mir_built(def).steal();
     if let Some(error_reported) = const_qualifs.tainted_by_errors {
         body.tainted_by_errors = Some(error_reported);
@@ -361,6 +364,24 @@ fn mir_promoted(
     (tcx.alloc_steal_mir(body), tcx.alloc_steal_promoted(promoted))
 }
 
+fn is_nounwind<'tcx>(tcx: TyCtxt<'tcx>, local_def_id: LocalDefId) -> bool {
+    if !tcx.is_mir_available(local_def_id) {
+        return false;
+    }
+
+    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();
+    if body.basic_blocks.iter().all(|block| block.terminator().unwind().is_none()) {
+        return true;
+    }
+    false
+}
+
 /// 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))

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/inline_coroutine.main.Inline.panic-unwind.diff

@@ -31,7 +31,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];
     }
 }