From 2fa550b85d6d3faed9ab7fbf442ac3b11b380184 Mon Sep 17 00:00:00 2001 From: Wesley Wiser Date: Wed, 18 Mar 2020 22:15:23 -0400 Subject: [PATCH 1/2] Fix ICE caused by truncating a negative ZST enum discriminant --- src/librustc_codegen_ssa/mir/rvalue.rs | 7 ++- src/librustc_mir/interpret/cast.rs | 4 +- .../ui/consts/cast-discriminant-zst-enum.rs | 47 +++++++++++++++++++ 3 files changed, 56 insertions(+), 2 deletions(-) create mode 100644 src/test/ui/consts/cast-discriminant-zst-enum.rs diff --git a/src/librustc_codegen_ssa/mir/rvalue.rs b/src/librustc_codegen_ssa/mir/rvalue.rs index 6d0046063989b..245df0846b583 100644 --- a/src/librustc_codegen_ssa/mir/rvalue.rs +++ b/src/librustc_codegen_ssa/mir/rvalue.rs @@ -293,7 +293,12 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { if let Some(discr) = operand.layout.ty.discriminant_for_variant(bx.tcx(), index) { - let discr_val = bx.cx().const_uint_big(ll_t_out, discr.val); + let discr_layout = bx.cx().layout_of(discr.ty); + let discr_t = bx.cx().immediate_backend_type(discr_layout); + let discr_val = bx.cx().const_uint_big(discr_t, discr.val); + let discr_val = + bx.intcast(discr_val, ll_t_out, discr.ty.is_signed()); + return ( bx, OperandRef { diff --git a/src/librustc_mir/interpret/cast.rs b/src/librustc_mir/interpret/cast.rs index 3cbb0667ff392..df63127f368b8 100644 --- a/src/librustc_mir/interpret/cast.rs +++ b/src/librustc_mir/interpret/cast.rs @@ -3,6 +3,7 @@ use rustc::ty::layout::{self, Size, TyLayout}; use rustc::ty::{self, Ty, TypeAndMut, TypeFoldable}; use rustc_ast::ast::FloatTy; use rustc_span::symbol::sym; +use rustc_target::abi::LayoutOf; use rustc::mir::interpret::{InterpResult, PointerArithmetic, Scalar}; use rustc::mir::CastKind; @@ -134,7 +135,8 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { layout::Variants::Single { index } => { if let Some(discr) = src.layout.ty.discriminant_for_variant(*self.tcx, index) { assert!(src.layout.is_zst()); - return Ok(Scalar::from_uint(discr.val, dest_layout.size).into()); + let discr_layout = self.layout_of(discr.ty)?; + return Ok(self.cast_from_int(discr.val, discr_layout, dest_layout)?.into()); } } layout::Variants::Multiple { .. } => {} diff --git a/src/test/ui/consts/cast-discriminant-zst-enum.rs b/src/test/ui/consts/cast-discriminant-zst-enum.rs new file mode 100644 index 0000000000000..a77258120111e --- /dev/null +++ b/src/test/ui/consts/cast-discriminant-zst-enum.rs @@ -0,0 +1,47 @@ +// run-pass +// Test a ZST enum whose dicriminant is ~0i128. This caused an ICE when casting to a i32. + +#[derive(Copy, Clone)] +enum Nums { + NegOne = -1, +} + +const NEG_ONE_I8: i8 = Nums::NegOne as i8; +const NEG_ONE_I16: i16 = Nums::NegOne as i16; +const NEG_ONE_I32: i32 = Nums::NegOne as i32; +const NEG_ONE_I64: i64 = Nums::NegOne as i64; +const NEG_ONE_I128: i128 = Nums::NegOne as i128; + +#[inline(never)] +fn identity(t: T) -> T { t } + +fn test_as_arg(n: Nums) { + assert_eq!(-1i8, n as i8); + assert_eq!(-1i16, n as i16); + assert_eq!(-1i32, n as i32); + assert_eq!(-1i64, n as i64); + assert_eq!(-1i128, n as i128); +} + +fn main() { + let kind = Nums::NegOne; + assert_eq!(-1i8, kind as i8); + assert_eq!(-1i16, kind as i16); + assert_eq!(-1i32, kind as i32); + assert_eq!(-1i64, kind as i64); + assert_eq!(-1i128, kind as i128); + + assert_eq!(-1i8, identity(kind) as i8); + assert_eq!(-1i16, identity(kind) as i16); + assert_eq!(-1i32, identity(kind) as i32); + assert_eq!(-1i64, identity(kind) as i64); + assert_eq!(-1i128, identity(kind) as i128); + + test_as_arg(Nums::NegOne); + + assert_eq!(-1i8, NEG_ONE_I8); + assert_eq!(-1i16, NEG_ONE_I16); + assert_eq!(-1i32, NEG_ONE_I32); + assert_eq!(-1i64, NEG_ONE_I64); + assert_eq!(-1i128, NEG_ONE_I128); +} From 96bbd1ccb6c210318d5ba90e7b68430b643e470a Mon Sep 17 00:00:00 2001 From: Wesley Wiser Date: Fri, 20 Mar 2020 19:57:29 -0400 Subject: [PATCH 2/2] Rename `cast_from_int` to `cast_from_int_like` --- src/librustc_mir/interpret/cast.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/librustc_mir/interpret/cast.rs b/src/librustc_mir/interpret/cast.rs index df63127f368b8..5c70b28a56786 100644 --- a/src/librustc_mir/interpret/cast.rs +++ b/src/librustc_mir/interpret/cast.rs @@ -136,7 +136,9 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { if let Some(discr) = src.layout.ty.discriminant_for_variant(*self.tcx, index) { assert!(src.layout.is_zst()); let discr_layout = self.layout_of(discr.ty)?; - return Ok(self.cast_from_int(discr.val, discr_layout, dest_layout)?.into()); + return Ok(self + .cast_from_int_like(discr.val, discr_layout, dest_layout)? + .into()); } } layout::Variants::Multiple { .. } => {} @@ -173,10 +175,10 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { // (b) cast from an integer-like (including bool, char, enums). // In both cases we want the bits. let bits = self.force_bits(src.to_scalar()?, src.layout.size)?; - Ok(self.cast_from_int(bits, src.layout, dest_layout)?.into()) + Ok(self.cast_from_int_like(bits, src.layout, dest_layout)?.into()) } - fn cast_from_int( + fn cast_from_int_like( &self, v: u128, // raw bits src_layout: TyLayout<'tcx>,