2 use rustc_ast::InlineAsmOptions;
3 use rustc_hir::def::DefKind;
4 use rustc_middle::mir::*;
5 use rustc_middle::ty::layout;
6 use rustc_middle::ty::{self, TyCtxt};
7 use rustc_target::spec::abi::Abi;
8 use rustc_target::spec::PanicStrategy;
10 /// A pass that runs which is targeted at ensuring that codegen guarantees about
11 /// unwinding are upheld for compilations of panic=abort programs.
13 /// When compiling with panic=abort codegen backends generally want to assume
14 /// that all Rust-defined functions do not unwind, and it's UB if they actually
15 /// do unwind. Foreign functions, however, can be declared as "may unwind" via
16 /// their ABI (e.g. `extern "C-unwind"`). To uphold the guarantees that
17 /// Rust-defined functions never unwind a well-behaved Rust program needs to
18 /// catch unwinding from foreign functions and force them to abort.
20 /// This pass walks over all functions calls which may possibly unwind,
21 /// and if any are found sets their cleanup to a block that aborts the process.
22 /// This forces all unwinds, in panic=abort mode happening in foreign code, to
23 /// trigger a process abort.
25 pub struct AbortUnwindingCalls;
27 impl<'tcx> MirPass<'tcx> for AbortUnwindingCalls {
28 fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
29 let def_id = body.source.def_id();
30 let kind = tcx.def_kind(def_id);
32 // We don't simplify the MIR of constants at this time because that
33 // namely results in a cyclic query when we call `tcx.type_of` below.
34 let is_function = match kind {
35 DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(..) => true,
36 _ => tcx.is_closure(def_id),
42 // This pass only runs on functions which themselves cannot unwind,
43 // forcibly changing the body of the function to structurally provide
44 // this guarantee by aborting on an unwind. If this function can unwind,
45 // then there's nothing to do because it already should work correctly.
47 // Here we test for this function itself whether its ABI allows
49 let body_ty = tcx.type_of(def_id);
50 let body_abi = match body_ty.kind() {
51 ty::FnDef(..) => body_ty.fn_sig(tcx).abi(),
52 ty::Closure(..) => Abi::RustCall,
53 ty::Generator(..) => Abi::Rust,
54 _ => span_bug!(body.span, "unexpected body ty: {:?}", body_ty),
56 let body_can_unwind = layout::fn_can_unwind(tcx, Some(def_id), body_abi);
58 // Look in this function body for any basic blocks which are terminated
59 // with a function call, and whose function we're calling may unwind.
60 // This will filter to functions with `extern "C-unwind"` ABIs, for
62 let mut calls_to_terminate = Vec::new();
63 let mut cleanups_to_remove = Vec::new();
64 for (id, block) in body.basic_blocks().iter_enumerated() {
68 let Some(terminator) = &block.terminator else { continue };
69 let span = terminator.source_info.span;
71 let call_can_unwind = match &terminator.kind {
72 TerminatorKind::Call { func, .. } => {
73 let ty = func.ty(body, tcx);
74 let sig = ty.fn_sig(tcx);
75 let fn_def_id = match ty.kind() {
77 &ty::FnDef(def_id, _) => Some(def_id),
78 _ => span_bug!(span, "invalid callee of type {:?}", ty),
80 layout::fn_can_unwind(tcx, fn_def_id, sig.abi())
82 TerminatorKind::Drop { .. } | TerminatorKind::DropAndReplace { .. } => {
83 tcx.sess.opts.debugging_opts.panic_in_drop == PanicStrategy::Unwind
84 && layout::fn_can_unwind(tcx, None, Abi::Rust)
86 TerminatorKind::Assert { .. } | TerminatorKind::FalseUnwind { .. } => {
87 layout::fn_can_unwind(tcx, None, Abi::Rust)
89 TerminatorKind::InlineAsm { options, .. } => {
90 options.contains(InlineAsmOptions::MAY_UNWIND)
92 _ if terminator.unwind().is_some() => {
93 span_bug!(span, "unexpected terminator that may unwind {:?}", terminator)
98 // If this function call can't unwind, then there's no need for it
99 // to have a landing pad. This means that we can remove any cleanup
100 // registered for it.
101 if !call_can_unwind {
102 cleanups_to_remove.push(id);
106 // Otherwise if this function can unwind, then if the outer function
107 // can also unwind there's nothing to do. If the outer function
108 // can't unwind, however, we need to change the landing pad for this
109 // function call to one that aborts.
110 if !body_can_unwind {
111 calls_to_terminate.push(id);
115 // For call instructions which need to be terminated, we insert a
116 // singular basic block which simply terminates, and then configure the
117 // `cleanup` attribute for all calls we found to this basic block we
118 // insert which means that any unwinding that happens in the functions
119 // will force an abort of the process.
120 if !calls_to_terminate.is_empty() {
121 let bb = BasicBlockData {
122 statements: Vec::new(),
124 terminator: Some(Terminator {
125 source_info: SourceInfo::outermost(body.span),
126 kind: TerminatorKind::Abort,
129 let abort_bb = body.basic_blocks_mut().push(bb);
131 for bb in calls_to_terminate {
132 let cleanup = body.basic_blocks_mut()[bb].terminator_mut().unwind_mut().unwrap();
133 *cleanup = Some(abort_bb);
137 for id in cleanups_to_remove {
138 let cleanup = body.basic_blocks_mut()[id].terminator_mut().unwind_mut().unwrap();
142 // We may have invalidated some `cleanup` blocks so clean those up now.
143 super::simplify::remove_dead_blocks(tcx, body);