bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

adjust all pointer_size checks to use the method

Browse source
This commit is contained in:
Oliver Schneider 2016-06-23 10:00:31 +02:00
parent d13153c424
commit 4c7aae73bc
No known key found for this signature in database
GPG key ID: 56D6EEA0FC67AC46
4 changed files with 23 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/error.rs
View file

@ -16,7 +16,7 @@ pub enum EvalError<'tcx> {
PointerOutOfBounds {
ptr: Pointer,
size: usize,
allocation_size: u64,
allocation_size: usize,
},
ReadPointerAsBytes,
ReadBytesAsPointer,

16
src/interpreter/mod.rs
View file

@ -178,7 +178,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
Ok(ptr)
}
Str(ref s) => {
let psize = self.memory.pointer_size;
let psize = self.memory.pointer_size();
let static_ptr = self.memory.allocate(s.len());
let ptr = self.memory.allocate(psize * 2);
self.memory.write_bytes(static_ptr, s.as_bytes())?;
@ -187,7 +187,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
Ok(ptr)
}
ByteStr(ref bs) => {
let psize = self.memory.pointer_size;
let psize = self.memory.pointer_size();
let static_ptr = self.memory.allocate(bs.len());
let ptr = self.memory.allocate(psize);
self.memory.write_bytes(static_ptr, bs)?;
@ -511,7 +511,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
match lv.extra {
LvalueExtra::None => {},
LvalueExtra::Length(len) => {
let len_ptr = dest.offset(self.memory.pointer_size as isize);
let len_ptr = dest.offset(self.memory.pointer_size() as isize);
self.memory.write_usize(len_ptr, len)?;
}
LvalueExtra::DowncastVariant(..) =>
@ -537,7 +537,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
match (&src_pointee_ty.sty, &dest_pointee_ty.sty) {
(&ty::TyArray(_, length), &ty::TySlice(_)) => {
let len_ptr = dest.offset(self.memory.pointer_size as isize);
let len_ptr = dest.offset(self.memory.pointer_size() as isize);
self.memory.write_usize(len_ptr, length as u64)?;
}
@ -651,7 +651,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
Ok(Size::from_bytes(0))
}
FatPointer { .. } => {
let bytes = layout::FAT_PTR_ADDR * self.memory.pointer_size;
let bytes = layout::FAT_PTR_ADDR * self.memory.pointer_size();
Ok(Size::from_bytes(bytes as u64))
}
_ => Err(EvalError::Unimplemented(format!("can't handle type: {:?}, with layout: {:?}", ty, layout))),
@ -762,7 +762,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
let ptr = self.memory.read_ptr(base.ptr)?;
let extra = match pointee_ty.sty {
ty::TySlice(_) | ty::TyStr => {
let len_ptr = base.ptr.offset(self.memory.pointer_size as isize);
let len_ptr = base.ptr.offset(self.memory.pointer_size() as isize);
let len = self.memory.read_usize(len_ptr)?;
LvalueExtra::Length(len)
}
@ -811,7 +811,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
pub fn read_primval(&mut self, ptr: Pointer, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
use syntax::ast::{IntTy, UintTy};
let val = match (self.memory.pointer_size, &ty.sty) {
let val = match (self.memory.pointer_size(), &ty.sty) {
(_, &ty::TyBool) => PrimVal::Bool(self.memory.read_bool(ptr)?),
(_, &ty::TyChar) => {
let c = self.memory.read_uint(ptr, 4)? as u32;
@ -919,7 +919,7 @@ pub fn eval_main<'a, 'tcx: 'a>(
if mir.arg_decls.len() == 2 {
// start function
let ptr_size = ecx.memory().pointer_size;
let ptr_size = ecx.memory().pointer_size();
let nargs = ecx.memory_mut().allocate(ptr_size);
ecx.memory_mut().write_usize(nargs, 0).unwrap();
let args = ecx.memory_mut().allocate(ptr_size);

6
src/interpreter/terminator.rs
View file

@ -277,7 +277,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
.collect();
let args_ptrs = args_res?;
let pointer_size = self.memory.pointer_size;
let pointer_size = self.memory.pointer_size();
match name {
"add_with_overflow" => self.intrinsic_with_overflow(mir::BinOp::Add, &args[0], &args[1], dest, dest_layout)?,
@ -368,7 +368,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
ty::TySlice(_) | ty::TyStr => {
let elem_ty = ty.sequence_element_type(self.tcx);
let elem_size = self.type_size(elem_ty) as u64;
let ptr_size = self.memory.pointer_size as isize;
let ptr_size = self.memory.pointer_size() as isize;
let n = self.memory.read_usize(args_ptrs[0].offset(ptr_size))?;
self.memory.write_uint(dest, n * elem_size, pointer_size)?;
}
@ -557,7 +557,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
self.memory.deallocate(contents_ptr)?;
}
Err(EvalError::ReadBytesAsPointer) => {
let size = self.memory.pointer_size;
let size = self.memory.pointer_size();
let possible_drop_fill = self.memory.read_bytes(ptr, size)?;
if possible_drop_fill.iter().all(|&b| b == mem::POST_DROP_U8) {
return Ok(());

22
src/memory.rs
View file

@ -238,11 +238,11 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
if !relocations.is_empty() {
print!("{:1$}", "", prefix.len()); // Print spaces.
let mut pos = 0;
let relocation_width = (self.pointer_size - 1) * 3;
let relocation_width = (self.pointer_size() - 1) * 3;
for (i, target_id) in relocations {
print!("{:1$}", "", (i - pos) * 3);
print!("└{0:─^1$}┘ ", format!("({})", target_id), relocation_width);
pos = i + self.pointer_size;
pos = i + self.pointer_size();
}
println!("");
}
@ -337,7 +337,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
}
pub fn read_ptr(&self, ptr: Pointer) -> EvalResult<'tcx, Pointer> {
let size = self.pointer_size;
let size = self.pointer_size();
self.check_defined(ptr, size)?;
let offset = self.get_bytes_unchecked(ptr, size)?
.read_uint::<NativeEndian>(size).unwrap() as usize;
@ -350,7 +350,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
pub fn write_ptr(&mut self, dest: Pointer, ptr: Pointer) -> EvalResult<'tcx, ()> {
{
let size = self.pointer_size;
let size = self.pointer_size();
let mut bytes = self.get_bytes_mut(dest, size)?;
bytes.write_uint::<NativeEndian>(ptr.offset as u64, size).unwrap();
}
@ -359,7 +359,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
}
pub fn write_primval(&mut self, ptr: Pointer, val: PrimVal) -> EvalResult<'tcx, ()> {
let pointer_size = self.pointer_size;
let pointer_size = self.pointer_size();
match val {
PrimVal::Bool(b) => self.write_bool(ptr, b),
PrimVal::I8(n) => self.write_int(ptr, n as i64, 1),
@ -407,20 +407,20 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
}
pub fn read_isize(&self, ptr: Pointer) -> EvalResult<'tcx, i64> {
self.read_int(ptr, self.pointer_size)
self.read_int(ptr, self.pointer_size())
}
pub fn write_isize(&mut self, ptr: Pointer, n: i64) -> EvalResult<'tcx, ()> {
let size = self.pointer_size;
let size = self.pointer_size();
self.write_int(ptr, n, size)
}
pub fn read_usize(&self, ptr: Pointer) -> EvalResult<'tcx, u64> {
self.read_uint(ptr, self.pointer_size)
self.read_uint(ptr, self.pointer_size())
}
pub fn write_usize(&mut self, ptr: Pointer, n: u64) -> EvalResult<'tcx, ()> {
let size = self.pointer_size;
let size = self.pointer_size();
self.write_uint(ptr, n, size)
}
}
@ -430,7 +430,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
fn relocations(&self, ptr: Pointer, size: usize)
-> EvalResult<'tcx, btree_map::Range<usize, AllocId>>
{
let start = ptr.offset.saturating_sub(self.pointer_size - 1);
let start = ptr.offset.saturating_sub(self.pointer_size() - 1);
let end = ptr.offset + size;
Ok(self.get(ptr.alloc_id)?.relocations.range(Included(&start), Excluded(&end)))
}
@ -444,7 +444,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
let start = ptr.offset;
let end = start + size;
let first = *keys.first().unwrap();
let last = *keys.last().unwrap() + self.pointer_size;
let last = *keys.last().unwrap() + self.pointer_size();
let alloc = self.get_mut(ptr.alloc_id)?;