user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename PrimVal::Pointer to PrimVal::Ptr.

Browse source 
Also fill out the PrimVal doc comments.
This commit is contained in:
Scott Olson 2016-12-15 23:55:00 -08:00
parent b36a83171b
commit 67e1627a55
5 changed files with 37 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/cast.rs
View file

@ -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))),
}
}

28
src/eval_context.rs
View file

@ -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)?;
},

4
src/terminator/intrinsic.rs
View file

@ -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" => {

12
src/terminator/mod.rs
View file

@ -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);

23
src/value.rs
View file

@ -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<AllocId> {
if let PrimVal::Pointer(ref p) = *self {
if let PrimVal::Ptr(ref p) = *self {
Some(p.alloc_id)
} else {
None