[WIP] Add replace_unreachable_intrinsic mir pass

Author: davidhewitt

src/librustc_codegen_llvm/intrinsic.rs

@@ -113,9 +113,6 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                         &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
                         None)
             }
-            "unreachable" => {
-                return;
-            },
             "likely" => {
                 let expect = self.get_intrinsic(&("llvm.expect.i1"));
                 self.call(expect, &[args[0].immediate(), self.const_bool(true)], None)

src/librustc_mir/transform/mod.rs

@@ -28,6 +28,7 @@ pub mod promote_consts;
 pub mod qualify_consts;
 pub mod qualify_min_const_fn;
 pub mod remove_noop_landing_pads;
+pub mod replace_unreachable_intrinsic;
 pub mod dump_mir;
 pub mod deaggregator;
 pub mod instcombine;
@@ -234,6 +235,7 @@ fn run_optimization_passes<'tcx>(
         &simplify_branches::SimplifyBranches::new("initial"),
         &remove_noop_landing_pads::RemoveNoopLandingPads,
         &cleanup_post_borrowck::CleanupNonCodegenStatements,
+        &replace_unreachable_intrinsic::ReplaceUnreachableIntrinsic::new(tcx),
 
         &simplify::SimplifyCfg::new("early-opt"),
 

src/librustc_mir/transform/replace_unreachable_intrinsic.rs

@@ -0,0 +1,50 @@
+//! This pass replaces the unreachable intrinsic with the Unreachable terminator,
+//! so that other optimisation passes can eliminate uncreachable code.
+
+use rustc::ty::{self, TyCtxt};
+use rustc::mir::*;
+use rustc::mir::visit::MutVisitor;
+use rustc_target::spec::abi::Abi;
+use syntax::symbol::sym;
+use crate::transform::{MirPass, MirSource};
+
+pub struct ReplaceUnreachableIntrinsic<'tcx> {
+    tcx: TyCtxt<'tcx>,
+}
+
+impl<'tcx> ReplaceUnreachableIntrinsic<'tcx> {
+    pub fn new(tcx: TyCtxt<'tcx>) -> Self {
+        ReplaceUnreachableIntrinsic { tcx }
+    }
+}
+
+impl<'tcx> MirPass<'tcx> for ReplaceUnreachableIntrinsic<'tcx> {
+    fn run_pass(&self, tcx: TyCtxt<'tcx>, _: MirSource<'tcx>, body: &mut Body<'tcx>) {
+        replace_unreachable_intrinsic(tcx, body)
+    }
+}
+
+pub fn replace_unreachable_intrinsic<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+    ReplaceUnreachableIntrinsic::new(tcx).visit_body(body);
+}
+
+impl<'tcx> MutVisitor<'tcx> for ReplaceUnreachableIntrinsic<'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn visit_terminator_kind(&mut self,
+                        kind: &mut TerminatorKind<'tcx>,
+                        _location: Location) {
+
+        if let TerminatorKind::Call { func: Operand::Constant(c), .. } = kind {
+            if let ty::FnDef(def_id, ..) = c.literal.ty.kind {
+                if let Abi::RustIntrinsic = self.tcx.fn_sig(def_id).abi() {
+                    if let sym::unreachable = self.tcx.item_name(def_id) {
+                        *kind = TerminatorKind::Unreachable;
+                    }
+                }
+            }
+        }
+    }
+}

src/libsyntax_pos/symbol.rs

@@ -718,6 +718,7 @@ symbols! {
         uniform_paths,
         universal_impl_trait,
         unmarked_api,
+        unreachable,
         unreachable_code,
         unrestricted_attribute_tokens,
         unsafe_no_drop_flag,

src/test/mir-opt/replace_unreachable_intrinsic.rs

@@ -0,0 +1,31 @@
+#![feature(core_intrinsics)]
+
+// Tests that unreachable intrinsic is replaced by unreachable terminator
+
+fn main() {
+    let x = Some(1);
+
+    match x {
+        Some(_) => {  },
+        None => unsafe { std::intrinsics::unreachable() }
+    }
+}
+
+
+// END RUST SOURCE
+// START rustc.main.ReplaceUnreachableIntrinsic.before.mir
+// ...
+// bb3: {
+//     StorageLive(_3);
+//     const std::intrinsics::unreachable();
+// }
+// ...
+// END rustc.main.ReplaceUnreachableIntrinsic.before.mir
+// START rustc.main.ReplaceUnreachableIntrinsic.after.mir
+// ...
+// bb3: {
+//     StorageLive(_3);
+//     unreachable;
+// }
+// ...
+// END rustc.main.ReplaceUnreachableIntrinsic.after.mir