Detect unwind-free functions in MIR

This adds analysis as part of inlining that will mark calls to functions
with Unwind::Unreachable even if inlining is not possible, so long as
their MIR indicates that they cannot unwind.

This would ideally persist into the codegen fn attrs, but that will take
more work.

Author: Mark-Simulacrum

compiler/rustc_mir_transform/src/inline.rs

@@ -115,6 +115,7 @@ trait Inliner<'tcx> {
 
     /// Has the caller body been changed?
     fn changed(self) -> bool;
+    fn set_changed(&mut self);
 
     /// Should inlining happen for a given callee?
     fn should_inline_for_callee(&self, def_id: DefId) -> bool;
@@ -187,6 +188,10 @@ impl<'tcx> Inliner<'tcx> for ForceInliner<'tcx> {
         self.changed
     }
 
+    fn set_changed(&mut self) {
+        self.changed = true;
+    }
+
     fn should_inline_for_callee(&self, def_id: DefId) -> bool {
         ForceInline::should_run_pass_for_callee(self.tcx(), def_id)
     }
@@ -334,6 +339,10 @@ impl<'tcx> Inliner<'tcx> for NormalInliner<'tcx> {
         self.changed
     }
 
+    fn set_changed(&mut self) {
+        self.changed = true;
+    }
+
     fn should_inline_for_callee(&self, _: DefId) -> bool {
         true
     }
@@ -529,10 +538,35 @@ fn process_blocks<'tcx, I: Inliner<'tcx>>(
         let span = trace_span!("process_blocks", %callsite.callee, ?bb);
         let _guard = span.enter();
 
-        match try_inlining(inliner, caller_body, &callsite) {
+        let mut unwind_unreachable = Err("did not reach analysis");
+        match try_inlining(inliner, caller_body, &callsite, &mut unwind_unreachable) {
             Err(reason) => {
                 debug!("not-inlined {} [{}]", callsite.callee, reason);
                 inliner.on_inline_failure(&callsite, reason);
+
+                match unwind_unreachable {
+                    Ok(()) => {
+                        if let Some(TerminatorKind::Call { unwind, .. }) =
+                            caller_body[callsite.block].terminator.as_mut().map(|v| &mut v.kind)
+                        {
+                            inliner.set_changed();
+                            tracing::info!("marked {} unwind unreachable", callsite.callee);
+                            *unwind = UnwindAction::Unreachable;
+                        } else {
+                            bug!(
+                                "unexpected terminator: {:?}",
+                                caller_body[callsite.block].terminator
+                            );
+                        }
+                    }
+                    Err(reason) => {
+                        tracing::info!(
+                            "not marking unwind unreachable {}: {}",
+                            callsite.callee,
+                            reason
+                        );
+                    }
+                }
             }
             Ok(new_blocks) => {
                 debug!("inlined {}", callsite.callee);
@@ -595,17 +629,69 @@ fn resolve_callsite<'tcx, I: Inliner<'tcx>>(
     None
 }
 
+/// Ok indicates yes, Err(reason) otherwise.
+fn should_mark_nounwind<'tcx>(_tcx: TyCtxt<'tcx>, body: &Body<'tcx>) -> Result<(), &'static str> {
+    // Unwinds can only start at certain terminators.
+    for block in body.basic_blocks.iter() {
+        let unwind = match block.terminator().kind {
+            // These never unwind.
+            TerminatorKind::Goto { .. }
+            | TerminatorKind::SwitchInt { .. }
+            | TerminatorKind::UnwindTerminate(_)
+            | TerminatorKind::Return
+            | TerminatorKind::Unreachable
+            | TerminatorKind::CoroutineDrop
+            | TerminatorKind::FalseEdge { .. }
+            | TerminatorKind::FalseUnwind { .. } => continue,
+
+            // Resume will *continue* unwinding, but if there's no other unwinding terminator it
+            // will never be reached.
+            TerminatorKind::UnwindResume => continue,
+
+            TerminatorKind::Yield { .. } => {
+                return Err("impl limitation: yield");
+            }
+
+            TerminatorKind::Drop { unwind, .. }
+            | TerminatorKind::Call { unwind, .. }
+            | TerminatorKind::Assert { unwind, .. } => unwind,
+
+            TerminatorKind::InlineAsm { .. } => return Err("inlineasm"),
+
+            TerminatorKind::TailCall { .. } => {
+                return Err("impl limitation: tail call");
+            }
+        };
+
+        match unwind {
+            UnwindAction::Continue => return Err("unwind: continue"),
+            // cannot unwind
+            UnwindAction::Unreachable => {}
+            // cannot unwind either -- will terminate instead
+            UnwindAction::Terminate(_) => {}
+            UnwindAction::Cleanup(_) => return Err("unwind: cleanup"),
+        }
+    }
+
+    // If we didn't find an unwinding terminator, the function cannot unwind.
+    Ok(())
+}
+
 /// Attempts to inline a callsite into the caller body. When successful returns basic blocks
 /// containing the inlined body. Otherwise returns an error describing why inlining didn't take
 /// place.
 fn try_inlining<'tcx, I: Inliner<'tcx>>(
     inliner: &I,
     caller_body: &mut Body<'tcx>,
     callsite: &CallSite<'tcx>,
+    unwind: &mut Result<(), &'static str>,
 ) -> Result<std::ops::Range<BasicBlock>, &'static str> {
     let tcx = inliner.tcx();
     check_mir_is_available(inliner, caller_body, callsite.callee)?;
 
+    let callee_body = try_instance_mir(tcx, callsite.callee.def)?;
+    *unwind = should_mark_nounwind(tcx, callee_body);
+
     let callee_attrs = tcx.codegen_fn_attrs(callsite.callee.def_id());
     check_inline::is_inline_valid_on_fn(tcx, callsite.callee.def_id())?;
     check_codegen_attributes(inliner, callsite, callee_attrs)?;
@@ -622,7 +708,6 @@ fn try_inlining<'tcx, I: Inliner<'tcx>>(
         }
     }
 
-    let callee_body = try_instance_mir(tcx, callsite.callee.def)?;
     check_inline::is_inline_valid_on_body(tcx, callee_body)?;
     inliner.check_callee_mir_body(callsite, callee_body, callee_attrs)?;
 

tests/codegen/drop.rs

@@ -11,7 +11,9 @@ impl Drop for SomeUniqueName {
 }
 
 #[inline(never)]
-pub fn possibly_unwinding() {}
+pub fn possibly_unwinding() {
+    panic!();
+}
 
 // CHECK-LABEL: @droppy
 #[no_mangle]

tests/codegen/mem-replace-big-type.rs

@@ -25,7 +25,7 @@ pub fn replace_big(dst: &mut Big, src: Big) -> Big {
 // CHECK-NOT: call void @llvm.memcpy
 
 // For a large type, we expect exactly three `memcpy`s
-// CHECK-LABEL: define internal void @{{.+}}mem{{.+}}replace{{.+}}(ptr
+// CHECK-LABEL: define void @{{.+}}mem{{.+}}replace{{.+}}(ptr
 // CHECK-SAME: sret([56 x i8]){{.+}}[[RESULT:%.+]], ptr{{.+}}%dest, ptr{{.+}}%src)
 // CHECK-NOT: call void @llvm.memcpy
 // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 8 [[RESULT]], ptr align 8 %dest, i{{.*}} 56, i1 false)

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

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

@@ -56,7 +56,7 @@
 +         StorageLive(_17);
 +         StorageLive(_18);
 +         StorageLive(_19);
-+         _17 = <() as A>::call() -> [return: bb12, unwind continue];
++         _17 = <() as A>::call() -> [return: bb12, unwind unreachable];
       }
 
       bb1: {
@@ -124,11 +124,11 @@
 +     }
 + 
 +     bb12: {
-+         _18 = <() as A>::call() -> [return: bb13, unwind continue];
++         _18 = <() as A>::call() -> [return: bb13, unwind unreachable];
 +     }
 + 
 +     bb13: {
-+         _19 = <() as A>::call() -> [return: bb11, unwind continue];
++         _19 = <() as A>::call() -> [return: bb11, unwind unreachable];
       }
   }
 

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

@@ -12,7 +12,7 @@ fn main() -> () {
 
     bb0: {
         StorageLive(_1);
-        _1 = not_inlined() -> [return: bb1, unwind continue];
+        _1 = not_inlined() -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
@@ -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/issue_106141.outer.Inline.panic-unwind.diff

@@ -20,7 +20,7 @@
 +         StorageLive(_1);
 +         StorageLive(_2);
 +         _1 = const inner::promoted[0];
-+         _0 = index() -> [return: bb1, unwind continue];
++         _0 = index() -> [return: bb1, unwind unreachable];
       }
 
       bb1: {

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

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

tests/mir-opt/inline/rustc_no_mir_inline.caller.PreCodegen.after.panic-unwind.mir

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