diff --git a/src/cast.rs b/src/cast.rs index 4412bd3d4188..f00dbcec499d 100644 --- a/src/cast.rs +++ b/src/cast.rs @@ -69,7 +69,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { TyChar if v as u8 as u64 == v => Ok(PrimVal::Bytes(v)), TyChar => Err(EvalError::InvalidChar(v)), - TyRawPtr(_) => Ok(PrimVal::Pointer(Pointer::from_int(v))), + TyRawPtr(_) => Ok(PrimVal::Ptr(Pointer::from_int(v))), _ => Err(EvalError::Unimplemented(format!("int to {:?} cast", ty))), } @@ -94,7 +94,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { use rustc::ty::TypeVariants::*; match ty.sty { TyRef(..) | TyRawPtr(_) | TyFnPtr(_) | TyInt(_) | TyUint(_) => - Ok(PrimVal::Pointer(ptr)), + Ok(PrimVal::Ptr(ptr)), _ => Err(EvalError::Unimplemented(format!("ptr to {:?} cast", ty))), } } diff --git a/src/eval_context.rs b/src/eval_context.rs index 7ed1a17e44f5..eca0684dcb95 100644 --- a/src/eval_context.rs +++ b/src/eval_context.rs @@ -172,7 +172,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let ptr = self.memory.allocate(s.len() as u64, 1)?; self.memory.write_bytes(ptr, s.as_bytes())?; self.memory.freeze(ptr.alloc_id)?; - Ok(Value::ByValPair(PrimVal::Pointer(ptr), PrimVal::from_uint(s.len() as u64))) + Ok(Value::ByValPair(PrimVal::Ptr(ptr), PrimVal::from_uint(s.len() as u64))) } pub(super) fn const_to_value(&mut self, const_val: &ConstVal) -> EvalResult<'tcx, Value> { @@ -196,7 +196,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let ptr = self.memory.allocate(bs.len() as u64, 1)?; self.memory.write_bytes(ptr, bs)?; self.memory.freeze(ptr.alloc_id)?; - PrimVal::Pointer(ptr) + PrimVal::Ptr(ptr) } Struct(_) => unimplemented!(), @@ -563,12 +563,12 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { Ref(_, _, ref lvalue) => { let src = self.eval_lvalue(lvalue)?; let (raw_ptr, extra) = self.force_allocation(src)?.to_ptr_and_extra(); - let ptr = PrimVal::Pointer(raw_ptr); + let ptr = PrimVal::Ptr(raw_ptr); let val = match extra { LvalueExtra::None => Value::ByVal(ptr), LvalueExtra::Length(len) => Value::ByValPair(ptr, PrimVal::from_uint(len)), - LvalueExtra::Vtable(vtable) => Value::ByValPair(ptr, PrimVal::Pointer(vtable)), + LvalueExtra::Vtable(vtable) => Value::ByValPair(ptr, PrimVal::Ptr(vtable)), LvalueExtra::DowncastVariant(..) => bug!("attempted to take a reference to an enum downcast lvalue"), }; @@ -578,7 +578,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { Box(ty) => { let ptr = self.alloc_ptr(ty)?; - self.write_primval(dest, PrimVal::Pointer(ptr), dest_ty)?; + self.write_primval(dest, PrimVal::Ptr(ptr), dest_ty)?; } Cast(kind, ref operand, cast_ty) => { @@ -617,7 +617,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { ty::TyFnDef(def_id, substs, fn_ty) => { let fn_ty = self.tcx.erase_regions(&fn_ty); let fn_ptr = self.memory.create_fn_ptr(self.tcx,def_id, substs, fn_ty); - self.write_value(Value::ByVal(PrimVal::Pointer(fn_ptr)), dest, dest_ty)?; + self.write_value(Value::ByVal(PrimVal::Ptr(fn_ptr)), dest, dest_ty)?; }, ref other => bug!("reify fn pointer on {:?}", other), }, @@ -629,7 +629,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let (def_id, substs, _, _) = self.memory.get_fn(ptr.alloc_id)?; let unsafe_fn_ty = self.tcx.erase_regions(&unsafe_fn_ty); let fn_ptr = self.memory.create_fn_ptr(self.tcx, def_id, substs, unsafe_fn_ty); - self.write_value(Value::ByVal(PrimVal::Pointer(fn_ptr)), dest, dest_ty)?; + self.write_value(Value::ByVal(PrimVal::Ptr(fn_ptr)), dest, dest_ty)?; }, ref other => bug!("fn to unsafe fn cast on {:?}", other), }, @@ -1150,23 +1150,23 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { ty::TyFloat(FloatTy::F32) => PrimVal::from_f32(self.memory.read_f32(ptr)?), ty::TyFloat(FloatTy::F64) => PrimVal::from_f64(self.memory.read_f64(ptr)?), - ty::TyFnPtr(_) => self.memory.read_ptr(ptr).map(PrimVal::Pointer)?, + ty::TyFnPtr(_) => self.memory.read_ptr(ptr).map(PrimVal::Ptr)?, ty::TyBox(ty) | ty::TyRef(_, ty::TypeAndMut { ty, .. }) | ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => { let p = self.memory.read_ptr(ptr)?; if self.type_is_sized(ty) { - PrimVal::Pointer(p) + PrimVal::Ptr(p) } else { trace!("reading fat pointer extra of type {}", ty); let extra = ptr.offset(self.memory.pointer_size()); let extra = match self.tcx.struct_tail(ty).sty { - ty::TyDynamic(..) => PrimVal::Pointer(self.memory.read_ptr(extra)?), + ty::TyDynamic(..) => PrimVal::Ptr(self.memory.read_ptr(extra)?), ty::TySlice(..) | ty::TyStr => PrimVal::from_uint(self.memory.read_usize(extra)?), _ => bug!("unsized primval ptr read from {:?}", ty), }; - return Ok(Some(Value::ByValPair(PrimVal::Pointer(p), extra))); + return Ok(Some(Value::ByValPair(PrimVal::Ptr(p), extra))); } } @@ -1225,7 +1225,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { (&ty::TyArray(_, length), &ty::TySlice(_)) => { let ptr = src.read_ptr(&self.memory)?; let len = PrimVal::from_uint(length as u64); - let ptr = PrimVal::Pointer(ptr); + let ptr = PrimVal::Ptr(ptr); self.write_value(Value::ByValPair(ptr, len), dest, dest_ty)?; } (&ty::TyDynamic(..), &ty::TyDynamic(..)) => { @@ -1239,8 +1239,8 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let trait_ref = self.tcx.erase_regions(&trait_ref); let vtable = self.get_vtable(trait_ref)?; let ptr = src.read_ptr(&self.memory)?; - let ptr = PrimVal::Pointer(ptr); - let extra = PrimVal::Pointer(vtable); + let ptr = PrimVal::Ptr(ptr); + let extra = PrimVal::Ptr(vtable); self.write_value(Value::ByValPair(ptr, extra), dest, dest_ty)?; }, diff --git a/src/terminator/intrinsic.rs b/src/terminator/intrinsic.rs index de9c972ffd41..732e4f555a9a 100644 --- a/src/terminator/intrinsic.rs +++ b/src/terminator/intrinsic.rs @@ -47,7 +47,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let ptr = arg_vals[0].read_ptr(&self.memory)?; let offset = self.value_to_primval(arg_vals[1], isize)?.to_i64(); let new_ptr = ptr.signed_offset(offset); - self.write_primval(dest, PrimVal::Pointer(new_ptr), dest_ty)?; + self.write_primval(dest, PrimVal::Ptr(new_ptr), dest_ty)?; } "assume" => { @@ -292,7 +292,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let ptr = arg_vals[0].read_ptr(&self.memory)?; let result_ptr = ptr.signed_offset(offset * pointee_size); - self.write_primval(dest, PrimVal::Pointer(result_ptr), dest_ty)?; + self.write_primval(dest, PrimVal::Ptr(result_ptr), dest_ty)?; } "overflowing_sub" => { diff --git a/src/terminator/mod.rs b/src/terminator/mod.rs index c48a8a72c3d5..06c006baeed7 100644 --- a/src/terminator/mod.rs +++ b/src/terminator/mod.rs @@ -336,7 +336,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let size = self.value_to_primval(args[0], usize)?.to_u64(); let align = self.value_to_primval(args[1], usize)?.to_u64(); let ptr = self.memory.allocate(size, align)?; - self.write_primval(dest, PrimVal::Pointer(ptr), dest_ty)?; + self.write_primval(dest, PrimVal::Ptr(ptr), dest_ty)?; } "__rust_deallocate" => { @@ -352,7 +352,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let size = self.value_to_primval(args[2], usize)?.to_u64(); let align = self.value_to_primval(args[3], usize)?.to_u64(); let new_ptr = self.memory.reallocate(ptr, size, align)?; - self.write_primval(dest, PrimVal::Pointer(new_ptr), dest_ty)?; + self.write_primval(dest, PrimVal::Ptr(new_ptr), dest_ty)?; } "memcmp" => { @@ -527,7 +527,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { ptr }, }; - args[0].0 = Value::ByVal(PrimVal::Pointer(ptr)); + args[0].0 = Value::ByVal(PrimVal::Ptr(ptr)); args[0].1 = self.tcx.mk_mut_ptr(args[0].1); } @@ -550,7 +550,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let idx = self.tcx.get_vtable_index_of_object_method(data, def_id) as u64; if let Some(&mut(ref mut first_arg, ref mut first_ty)) = args.get_mut(0) { let (self_ptr, vtable) = first_arg.expect_ptr_vtable_pair(&self.memory)?; - *first_arg = Value::ByVal(PrimVal::Pointer(self_ptr)); + *first_arg = Value::ByVal(PrimVal::Ptr(self_ptr)); let idx = idx + 3; let offset = idx * self.memory.pointer_size(); let fn_ptr = self.memory.read_ptr(vtable.offset(offset))?; @@ -633,7 +633,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { }; // run drop impl before the fields' drop impls if let Some(drop_def_id) = adt_def.destructor() { - drop.push((drop_def_id, Value::ByVal(PrimVal::Pointer(adt_ptr)), substs)); + drop.push((drop_def_id, Value::ByVal(PrimVal::Ptr(adt_ptr)), substs)); } let layout = self.type_layout(ty)?; let fields = match *layout { @@ -701,7 +701,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { let (def_id, substs, _abi, sig) = self.memory.get_fn(drop_fn.alloc_id)?; let real_ty = sig.inputs()[0]; self.drop(Lvalue::from_ptr(ptr), real_ty, drop)?; - drop.push((def_id, Value::ByVal(PrimVal::Pointer(ptr)), substs)); + drop.push((def_id, Value::ByVal(PrimVal::Ptr(ptr)), substs)); } else { // just a sanity check assert_eq!(drop_fn.offset, 0); diff --git a/src/value.rs b/src/value.rs index 7055548095d0..943f096c7ed8 100644 --- a/src/value.rs +++ b/src/value.rs @@ -43,19 +43,22 @@ pub enum Value { ByValPair(PrimVal, PrimVal), } -/// A `PrimVal` represents an immediate, primitive value existing outside of an allocation. It is -/// considered to be like a +/// A `PrimVal` represents an immediate, primitive value existing outside of a +/// `memory::Allocation`. It is in many ways like a small chunk of a `Allocation`, up to 8 bytes in +/// size. Like a range of bytes in an `Allocation`, a `PrimVal` can either represent the raw bytes +/// of a simple value, a pointer into another `Allocation`, or be undefined. #[derive(Clone, Copy, Debug, PartialEq)] pub enum PrimVal { + /// The raw bytes of a simple value. Bytes(u64), - // FIXME(solson): Rename this variant to Ptr. - // FIXME(solson): Outdated comment, pulled from `relocations` field I deleted. - /// This field is initialized when the `PrimVal` represents a pointer into an `Allocation`. An - /// `Allocation` in the `memory` module has a list of relocations, but a `PrimVal` is only - /// large enough to contain one, hence the `Option`. - Pointer(Pointer), + /// A pointer into an `Allocation`. An `Allocation` in the `memory` module has a list of + /// relocations, but a `PrimVal` is only large enough to contain one, so we just represent the + /// relocation and its associated offset together as a `Pointer` here. + Ptr(Pointer), + /// An undefined `PrimVal`, for representing values that aren't safe to examine, but are safe + /// to copy around, just like undefined bytes in an `Allocation`. Undefined, } @@ -119,7 +122,7 @@ impl PrimVal { pub fn bits(&self) -> u64 { match *self { PrimVal::Bytes(b) => b, - PrimVal::Pointer(p) => p.offset, + PrimVal::Ptr(p) => p.offset, PrimVal::Undefined => panic!(".bits()() on PrimVal::Undefined"), } } @@ -127,7 +130,7 @@ impl PrimVal { // FIXME(solson): Remove this. It's a temporary function to aid refactoring, but it shouldn't // stick around with this name. pub fn relocation(&self) -> Option { - if let PrimVal::Pointer(ref p) = *self { + if let PrimVal::Ptr(ref p) = *self { Some(p.alloc_id) } else { None