Mirrors/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2026-06-01 22:18:23 +03:00
Code Issues Packages Projects Releases Wiki Activity

Refactor isize/usize read/writes.

Browse Source
This commit is contained in:
Scott Olson
2016-03-20 23:24:27 -06:00
parent 95e225d765
commit 0de1bbefd5
2 changed files with 35 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/interpreter.rs
+17 -24
View File
@@ -348,7 +348,7 @@ fn call_intrinsic(&mut self, name: &str, substs: &'tcx Substs<'tcx>,
let src = try!(self.memory.read_ptr(src_arg));
let dest = try!(self.memory.read_ptr(dest_arg));
let count = try!(self.memory.read_int(count_arg, self.memory.pointer_size));
let count = try!(self.memory.read_isize(count_arg));
try!(self.memory.copy(src, dest, count as usize * elem_size));
}
@@ -397,7 +397,7 @@ fn call_intrinsic(&mut self, name: &str, substs: &'tcx Substs<'tcx>,
let ptr_arg = try!(self.eval_operand(&args[0]));
let offset_arg = try!(self.eval_operand(&args[1]));
let offset = try!(self.memory.read_int(offset_arg, self.memory.pointer_size));
let offset = try!(self.memory.read_isize(offset_arg));
match self.memory.read_ptr(ptr_arg) {
Ok(ptr) => {
@@ -405,10 +405,9 @@ fn call_intrinsic(&mut self, name: &str, substs: &'tcx Substs<'tcx>,
try!(self.memory.write_ptr(dest, result_ptr));
}
Err(EvalError::ReadBytesAsPointer) => {
let psize = self.memory.pointer_size;
let addr = try!(self.memory.read_int(ptr_arg, psize));
let addr = try!(self.memory.read_isize(ptr_arg));
let result_addr = addr + offset * pointee_size as i64;
try!(self.memory.write_int(dest, result_addr, psize));
try!(self.memory.write_isize(dest, result_addr));
}
Err(e) => return Err(e),
}
@@ -451,7 +450,7 @@ fn call_c_abi(&mut self, def_id: DefId, args: &[mir::Operand<'tcx>], dest: Point
"__rust_allocate" => {
let size_arg = try!(self.eval_operand(&args[0]));
let _align_arg = try!(self.eval_operand(&args[1]));
let size = try!(self.memory.read_uint(size_arg, self.memory.pointer_size));
let size = try!(self.memory.read_usize(size_arg));
let ptr = self.memory.allocate(size as usize);
try!(self.memory.write_ptr(dest, ptr));
}
@@ -553,8 +552,7 @@ fn eval_assignment(&mut self, lvalue: &mir::Lvalue<'tcx>, rvalue: &mir::Rvalue<'
},
_ => panic!("Rvalue::Len expected array or slice, got {:?}", ty),
};
let psize = self.memory.pointer_size;
try!(self.memory.write_uint(dest, len, psize));
try!(self.memory.write_usize(dest, len));
}
Ref(_, _, ref lvalue) => {
@@ -563,9 +561,8 @@ fn eval_assignment(&mut self, lvalue: &mir::Lvalue<'tcx>, rvalue: &mir::Rvalue<'
match lv.extra {
LvalueExtra::None => {},
LvalueExtra::Length(len) => {
let psize = self.memory.pointer_size;
let len_ptr = dest.offset(psize as isize);
try!(self.memory.write_uint(len_ptr, len, psize));
let len_ptr = dest.offset(self.memory.pointer_size as isize);
try!(self.memory.write_usize(len_ptr, len));
}
}
}
@@ -589,9 +586,8 @@ fn eval_assignment(&mut self, lvalue: &mir::Lvalue<'tcx>, rvalue: &mir::Rvalue<'
match (&src_pointee_ty.sty, &dest_pointee_ty.sty) {
(&ty::TyArray(_, length), &ty::TySlice(_)) => {
let size = self.memory.pointer_size;
let len_ptr = dest.offset(size as isize);
try!(self.memory.write_uint(len_ptr, length as u64, size));
let len_ptr = dest.offset(self.memory.pointer_size as isize);
try!(self.memory.write_usize(len_ptr, length as u64));
}
_ => panic!("can't handle cast: {:?}", rvalue),
@@ -685,9 +681,8 @@ fn eval_lvalue(&mut self, lvalue: &mir::Lvalue<'tcx>) -> EvalResult<Lvalue> {
let ptr = try!(self.memory.read_ptr(base_ptr));
let extra = match pointee_ty.sty {
ty::TySlice(_) => {
let psize = self.memory.pointer_size;
let len_ptr = base_ptr.offset(psize as isize);
let len = try!(self.memory.read_uint(len_ptr, psize));
let len_ptr = base_ptr.offset(self.memory.pointer_size as isize);
let len = try!(self.memory.read_usize(len_ptr));
LvalueExtra::Length(len)
}
ty::TyTrait(_) => unimplemented!(),
@@ -703,7 +698,7 @@ fn eval_lvalue(&mut self, lvalue: &mir::Lvalue<'tcx>) -> EvalResult<Lvalue> {
_ => panic!("indexing expected an array or slice, got {:?}", base_ty),
};
let n_ptr = try!(self.eval_operand(operand));
let n = try!(self.memory.read_uint(n_ptr, self.memory.pointer_size));
let n = try!(self.memory.read_usize(n_ptr));
base_ptr.offset(n as isize * elem_size as isize)
}
@@ -734,7 +729,7 @@ fn const_to_ptr(&mut self, const_val: &const_eval::ConstVal) -> EvalResult<Point
let ptr = self.memory.allocate(psize * 2);
try!(self.memory.write_bytes(static_ptr, s.as_bytes()));
try!(self.memory.write_ptr(ptr, static_ptr));
try!(self.memory.write_uint(ptr.offset(psize as isize), s.len() as u64, psize));
try!(self.memory.write_usize(ptr.offset(psize as isize), s.len() as u64));
Ok(ptr)
}
ByteStr(ref bs) => {
@@ -887,10 +882,8 @@ pub fn read_primval(&mut self, ptr: Pointer, ty: ty::Ty<'tcx>) -> EvalResult<Pri
ty::TyUint(UintTy::U64) => PrimVal::U64(try!(self.memory.read_uint(ptr, 8)) as u64),
// TODO(tsion): Pick the PrimVal dynamically.
ty::TyInt(IntTy::Is) =>
PrimVal::I64(try!(self.memory.read_int(ptr, self.memory.pointer_size))),
ty::TyUint(UintTy::Us) =>
PrimVal::U64(try!(self.memory.read_uint(ptr, self.memory.pointer_size))),
ty::TyInt(IntTy::Is) => PrimVal::I64(try!(self.memory.read_isize(ptr))),
ty::TyUint(UintTy::Us) => PrimVal::U64(try!(self.memory.read_usize(ptr))),
ty::TyRef(_, ty::TypeAndMut { ty, .. }) |
ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => {
@@ -898,7 +891,7 @@ pub fn read_primval(&mut self, ptr: Pointer, ty: ty::Ty<'tcx>) -> EvalResult<Pri
match self.memory.read_ptr(ptr) {
Ok(p) => PrimVal::AbstractPtr(p),
Err(EvalError::ReadBytesAsPointer) => {
let n = try!(self.memory.read_uint(ptr, self.memory.pointer_size));
let n = try!(self.memory.read_usize(ptr));
PrimVal::IntegerPtr(n)
}
Err(e) => return Err(e),
src/memory.rs
+18
View File
@@ -215,6 +215,24 @@ pub fn read_uint(&self, ptr: Pointer, size: usize) -> EvalResult<u64> {
pub fn write_uint(&mut self, ptr: Pointer, n: u64, size: usize) -> EvalResult<()> {
self.get_bytes_mut(ptr, size).map(|mut b| b.write_uint::<NativeEndian>(n, size).unwrap())
}
pub fn read_isize(&self, ptr: Pointer) -> EvalResult<i64> {
self.read_int(ptr, self.pointer_size)
}
pub fn write_isize(&mut self, ptr: Pointer, n: i64) -> EvalResult<()> {
let size = self.pointer_size;
self.write_int(ptr, n, size)
}
pub fn read_usize(&self, ptr: Pointer) -> EvalResult<u64> {
self.read_uint(ptr, self.pointer_size)
}
pub fn write_usize(&mut self, ptr: Pointer, n: u64) -> EvalResult<()> {
let size = self.pointer_size;
self.write_uint(ptr, n, size)
}
}
impl Allocation {