From 05067cf99e21bcb8fd5dce745d09865d1a91b189 Mon Sep 17 00:00:00 2001
From: varkor <github@varkor.com>
Date: Wed, 16 May 2018 21:26:50 +0100
Subject: [PATCH 1/2] Fix an ICE when attempting to transmute an uninhabited
 type

---
 src/librustc_codegen_llvm/mir/block.rs        | 16 +++++++--
 .../compile-fail/never_transmute_never.rs     | 33 +++++++++++++++++++
 2 files changed, 46 insertions(+), 3 deletions(-)
 create mode 100644 src/test/compile-fail/never_transmute_never.rs

diff --git a/src/librustc_codegen_llvm/mir/block.rs b/src/librustc_codegen_llvm/mir/block.rs
index 556baeba39e0a..bc5819791fa37 100644
--- a/src/librustc_codegen_llvm/mir/block.rs
+++ b/src/librustc_codegen_llvm/mir/block.rs
@@ -428,9 +428,19 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
                 let intrinsic = intrinsic.as_ref().map(|s| &s[..]);
 
                 if intrinsic == Some("transmute") {
-                    let &(ref dest, target) = destination.as_ref().unwrap();
-                    self.codegen_transmute(&bx, &args[0], dest);
-                    funclet_br(self, bx, target);
+                    if let Some(destination_ref) = destination.as_ref() {
+                        let &(ref dest, target) = destination_ref;
+                        self.trans_transmute(&bx, &args[0], dest);
+                        funclet_br(self, bx, target);
+                    } else {
+                        // If we are trying to transmute to an uninhabited type,
+                        // it is likely there is no allotted destination. In fact,
+                        // transmuting to an uninhabited type is UB, which means
+                        // we can do what we like. Here, we declare that transmuting
+                        // into an uninhabited type is impossible, so anything following
+                        // it must be unreachable.
+                        bx.unreachable();
+                    }
                     return;
                 }
 
diff --git a/src/test/compile-fail/never_transmute_never.rs b/src/test/compile-fail/never_transmute_never.rs
new file mode 100644
index 0000000000000..cbcc47f60c313
--- /dev/null
+++ b/src/test/compile-fail/never_transmute_never.rs
@@ -0,0 +1,33 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-pass
+
+#![crate_type="lib"]
+
+#![feature(never_type)]
+#![allow(dead_code)]
+#![allow(unreachable_code)]
+#![allow(unused_variables)]
+
+struct Foo;
+
+pub fn f(x: !) -> ! {
+    x
+}
+
+pub fn ub() {
+    // This is completely undefined behaviour,
+    // but we still want to make sure it compiles.
+    let x: ! = unsafe {
+        std::mem::transmute::<Foo, !>(Foo)
+    };
+    f(x)
+}

From f90033303b491bdd4c89aa892a13323cf2ba941f Mon Sep 17 00:00:00 2001
From: varkor <github@varkor.com>
Date: Thu, 17 May 2018 18:16:59 +0100
Subject: [PATCH 2/2] Make sure the type we think is uninhabited actually is

---
 src/librustc_codegen_llvm/mir/block.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/librustc_codegen_llvm/mir/block.rs b/src/librustc_codegen_llvm/mir/block.rs
index bc5819791fa37..1669059a760f4 100644
--- a/src/librustc_codegen_llvm/mir/block.rs
+++ b/src/librustc_codegen_llvm/mir/block.rs
@@ -430,7 +430,7 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
                 if intrinsic == Some("transmute") {
                     if let Some(destination_ref) = destination.as_ref() {
                         let &(ref dest, target) = destination_ref;
-                        self.trans_transmute(&bx, &args[0], dest);
+                        self.codegen_transmute(&bx, &args[0], dest);
                         funclet_br(self, bx, target);
                     } else {
                         // If we are trying to transmute to an uninhabited type,
@@ -439,6 +439,7 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
                         // we can do what we like. Here, we declare that transmuting
                         // into an uninhabited type is impossible, so anything following
                         // it must be unreachable.
+                        assert_eq!(bx.cx.layout_of(sig.output()).abi, layout::Abi::Uninhabited);
                         bx.unreachable();
                     }
                     return;