From 25c47a48858122b3b20a4a5f08ecbf13eb15e19d Mon Sep 17 00:00:00 2001
From: Eduard-Mihai Burtescu <edy.burt@gmail.com>
Date: Sat, 16 Jun 2018 14:19:05 +0300
Subject: [PATCH] rustc_codegen_llvm: don't treat i1 as signed, even for
 #[repr(i8)] enums.

---
 src/librustc_codegen_llvm/mir/place.rs  |  6 +++++-
 src/librustc_codegen_llvm/mir/rvalue.rs |  6 +++++-
 src/test/run-pass/issue-51582.rs        | 27 +++++++++++++++++++++++++
 3 files changed, 37 insertions(+), 2 deletions(-)
 create mode 100644 src/test/run-pass/issue-51582.rs

diff --git a/src/librustc_codegen_llvm/mir/place.rs b/src/librustc_codegen_llvm/mir/place.rs
index bda8c75875051..2a1e3980adbcf 100644
--- a/src/librustc_codegen_llvm/mir/place.rs
+++ b/src/librustc_codegen_llvm/mir/place.rs
@@ -275,7 +275,11 @@ impl<'a, 'tcx> PlaceRef<'tcx> {
             layout::Variants::Single { .. } => bug!(),
             layout::Variants::Tagged { ref tag, .. } => {
                 let signed = match tag.value {
-                    layout::Int(_, signed) => signed,
+                    // We use `i1` for bytes that are always `0` or `1`,
+                    // e.g. `#[repr(i8)] enum E { A, B }`, but we can't
+                    // let LLVM interpret the `i1` as signed, because
+                    // then `i1 1` (i.e. E::B) is effectively `i8 -1`.
+                    layout::Int(_, signed) => !tag.is_bool() && signed,
                     _ => false
                 };
                 bx.intcast(lldiscr, cast_to, signed)
diff --git a/src/librustc_codegen_llvm/mir/rvalue.rs b/src/librustc_codegen_llvm/mir/rvalue.rs
index d1b949d4f7351..0fd81c6074e48 100644
--- a/src/librustc_codegen_llvm/mir/rvalue.rs
+++ b/src/librustc_codegen_llvm/mir/rvalue.rs
@@ -298,7 +298,11 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
                         let mut signed = false;
                         if let layout::Abi::Scalar(ref scalar) = operand.layout.abi {
                             if let layout::Int(_, s) = scalar.value {
-                                signed = s;
+                                // We use `i1` for bytes that are always `0` or `1`,
+                                // e.g. `#[repr(i8)] enum E { A, B }`, but we can't
+                                // let LLVM interpret the `i1` as signed, because
+                                // then `i1 1` (i.e. E::B) is effectively `i8 -1`.
+                                signed = !scalar.is_bool() && s;
 
                                 if scalar.valid_range.end() > scalar.valid_range.start() {
                                     // We want `table[e as usize]` to not
diff --git a/src/test/run-pass/issue-51582.rs b/src/test/run-pass/issue-51582.rs
new file mode 100644
index 0000000000000..bca05d83e4064
--- /dev/null
+++ b/src/test/run-pass/issue-51582.rs
@@ -0,0 +1,27 @@
+// 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.
+
+#![feature(core_intrinsics)]
+
+#[repr(i8)]
+pub enum Enum {
+    VariantA,
+    VariantB,
+}
+
+fn make_b() -> Enum { Enum::VariantB }
+
+fn main() {
+    assert_eq!(1, make_b() as i8);
+    assert_eq!(1, make_b() as u8);
+    assert_eq!(1, make_b() as i32);
+    assert_eq!(1, make_b() as u32);
+    assert_eq!(1, unsafe { std::intrinsics::discriminant_value(&make_b()) });
+}