From ce95ae592742517df40498b288938570c877e706 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Sat, 28 Jan 2017 15:46:46 +0100 Subject: [PATCH] correctly implement pointers to enum variant constructors --- src/eval_context.rs | 19 ++++++---- src/terminator/mod.rs | 36 ++++++++++++++----- ..._variant_constructor_struct_pointer_opt.rs | 9 +++++ 3 files changed, 50 insertions(+), 14 deletions(-) diff --git a/src/eval_context.rs b/src/eval_context.rs index 10d0217b4c7..ce44e34f9ed 100644 --- a/src/eval_context.rs +++ b/src/eval_context.rs @@ -685,22 +685,25 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let path = discrfield.iter().skip(2).map(|&i| i as usize); // Handle the field index for the outer non-null variant. - let inner_ty = match ty.sty { + let (inner_offset, inner_ty) = match ty.sty { ty::TyAdt(adt_def, substs) => { let variant = &adt_def.variants[nndiscr as usize]; let index = discrfield[1]; let field = &variant.fields[index as usize]; - field.ty(self.tcx, substs) + (self.get_field_offset(ty, index as usize)?, field.ty(self.tcx, substs)) } _ => bug!("non-enum for StructWrappedNullablePointer: {}", ty), }; - self.field_path_offset_and_ty(inner_ty, path) + self.field_path_offset_and_ty(inner_offset, inner_ty, path) } - fn field_path_offset_and_ty>(&self, mut ty: Ty<'tcx>, path: I) -> EvalResult<'tcx, (Size, Ty<'tcx>)> { - let mut offset = Size::from_bytes(0); - + fn field_path_offset_and_ty>( + &self, + mut offset: Size, + mut ty: Ty<'tcx>, + path: I, + ) -> EvalResult<'tcx, (Size, Ty<'tcx>)> { // Skip the initial 0 intended for LLVM GEP. for field_index in path { let field_offset = self.get_field_offset(ty, field_index)?; @@ -747,6 +750,9 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let bytes = field_index as u64 * self.memory.pointer_size(); Ok(Size::from_bytes(bytes)) } + StructWrappedNullablePointer { ref nonnull, .. } => { + Ok(nonnull.offsets[field_index]) + } _ => { let msg = format!("can't handle type: {:?}, with layout: {:?}", ty, layout); Err(EvalError::Unimplemented(msg)) @@ -761,6 +767,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { match *layout { Univariant { ref variant, .. } => Ok(variant.offsets.len()), FatPointer { .. } => Ok(2), + StructWrappedNullablePointer { ref nonnull, .. } => Ok(nonnull.offsets.len()), _ => { let msg = format!("can't handle type: {:?}, with layout: {:?}", ty, layout); Err(EvalError::Unimplemented(msg)) diff --git a/src/terminator/mod.rs b/src/terminator/mod.rs index bd93bd53a49..b2124486f49 100644 --- a/src/terminator/mod.rs +++ b/src/terminator/mod.rs @@ -238,27 +238,46 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let (lvalue, target) = destination.expect("tuple struct constructors can't diverge"); let dest_ty = self.tcx.item_type(adt_def.did); let dest_layout = self.type_layout(dest_ty)?; - let disr = v.disr_val.to_u128_unchecked(); + trace!("layout({:?}) = {:#?}", dest_ty, dest_layout); match *dest_layout { Layout::Univariant { ref variant, .. } => { - assert_eq!(disr, 0); + let disr_val = v.disr_val.to_u128_unchecked(); + assert_eq!(disr_val, 0); let offsets = variant.offsets.iter().map(|s| s.bytes()); self.assign_fields(lvalue, offsets, args)?; }, Layout::General { discr, ref variants, .. } => { - // FIXME: report a proper error for invalid discriminants - // right now we simply go into index out of bounds + let disr_val = v.disr_val.to_u128_unchecked(); let discr_size = discr.size().bytes(); self.assign_discr_and_fields( lvalue, - variants[disr as usize].offsets.iter().cloned().map(Size::bytes), + variants[disr_val as usize].offsets.iter().cloned().map(Size::bytes), args, - disr, + disr_val, discr_size, )?; }, - Layout::StructWrappedNullablePointer { .. } | + Layout::StructWrappedNullablePointer { nndiscr, ref nonnull, ref discrfield, .. } => { + let disr_val = v.disr_val.to_u128_unchecked(); + if nndiscr as u128 == disr_val { + let offsets = nonnull.offsets.iter().map(|s| s.bytes()); + self.assign_fields(lvalue, offsets, args)?; + } else { + for (_, ty) in args { + assert_eq!(self.type_size(ty)?, Some(0)); + } + let (offset, ty) = self.nonnull_offset_and_ty(dest_ty, nndiscr, discrfield)?; + + // FIXME(solson) + let dest = self.force_allocation(lvalue)?.to_ptr(); + + let dest = dest.offset(offset.bytes()); + let dest_size = self.type_size(ty)? + .expect("bad StructWrappedNullablePointer discrfield"); + self.memory.write_int(dest, 0, dest_size)?; + } + }, Layout::RawNullablePointer { .. } => { assert_eq!(args.len(), 1); let (val, ty) = args.pop().unwrap(); @@ -307,7 +326,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { fn read_discriminant_value(&self, adt_ptr: Pointer, adt_ty: Ty<'tcx>) -> EvalResult<'tcx, u128> { use rustc::ty::layout::Layout::*; let adt_layout = self.type_layout(adt_ty)?; - trace!("read_discriminant_value {:?}", adt_layout); + trace!("read_discriminant_value {:#?}", adt_layout); let discr_val = match *adt_layout { General { discr, .. } | CEnum { discr, signed: false, .. } => { @@ -344,6 +363,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { } fn read_nonnull_discriminant_value(&self, ptr: Pointer, nndiscr: u128, discr_size: u64) -> EvalResult<'tcx, u128> { + trace!("read_nonnull_discriminant_value: {:?}, {}, {}", ptr, nndiscr, discr_size); let not_null = match self.memory.read_uint(ptr, discr_size) { Ok(0) => false, Ok(_) | Err(EvalError::ReadPointerAsBytes) => true, diff --git a/tests/run-pass/tuple_like_enum_variant_constructor_struct_pointer_opt.rs b/tests/run-pass/tuple_like_enum_variant_constructor_struct_pointer_opt.rs index 059c4b972ee..44441ed1d36 100644 --- a/tests/run-pass/tuple_like_enum_variant_constructor_struct_pointer_opt.rs +++ b/tests/run-pass/tuple_like_enum_variant_constructor_struct_pointer_opt.rs @@ -7,6 +7,13 @@ struct A<'a> { #[derive(Copy, Clone, PartialEq, Debug)] struct B<'a>(i32, &'a i32); +#[derive(Copy, Clone, PartialEq, Debug)] +enum C<'a> { + Value(i32, &'a i32), + #[allow(dead_code)] + NoValue, +} + fn main() { let x = 5; let a = A { x: 99, y: &x }; @@ -17,6 +24,8 @@ fn main() { //let f: for<'a> fn(i32, &'a i32) -> B<'a> = B; //assert_eq!(Some(B(42, &x)), Some(f(42, &x))); assert_eq!(B(42, &x), foo(&x, B)); + let f = C::Value; + assert_eq!(C::Value(42, &x), f(42, &x)); } fn foo<'a, F: Fn(i32, &'a i32) -> B<'a>>(i: &'a i32, f: F) -> B<'a> {