adjust all pointer_size checks to use the method

oli-obk · oli-obk · commit 4c7aae73bc2e · 2016-06-23T10:02:39.000+02:00
diff --git a/src/error.rs b/src/error.rs
@@ -16,7 +16,7 @@ pub enum EvalError<'tcx> {
     PointerOutOfBounds {
         ptr: Pointer,
         size: usize,
-        allocation_size: u64,
+        allocation_size: usize,
     },
     ReadPointerAsBytes,
     ReadBytesAsPointer,
diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
@@ -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);
diff --git a/src/interpreter/terminator.rs b/src/interpreter/terminator.rs
@@ -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(());
diff --git a/src/memory.rs b/src/memory.rs
@@ -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)?;
 

Original file line number	Diff line number	Diff line change
`@@ -238,11 +238,11 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {`
`238`	`238`	`if !relocations.is_empty() {`
`239`	`239`	`print!("{:1$}", "", prefix.len()); // Print spaces.`
`240`	`240`	`let mut pos = 0;`
`241`		`- let relocation_width = (self.pointer_size - 1) * 3;`
	`241`	`+ let relocation_width = (self.pointer_size() - 1) * 3;`
`242`	`242`	`for (i, target_id) in relocations {`
`243`	`243`	`print!("{:1$}", "", (i - pos) * 3);`
`244`	`244`	`print!("└{0:─^1$}┘ ", format!("({})", target_id), relocation_width);`
`245`		`- pos = i + self.pointer_size;`
	`245`	`+ pos = i + self.pointer_size();`
`246`	`246`	`}`
`247`	`247`	`println!("");`
`248`	`248`	`}`
`@@ -337,7 +337,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`pub fn read_ptr(&self, ptr: Pointer) -> EvalResult<'tcx, Pointer> {`
`340`		`- let size = self.pointer_size;`
	`340`	`+ let size = self.pointer_size();`
`341`	`341`	`self.check_defined(ptr, size)?;`
`342`	`342`	`let offset = self.get_bytes_unchecked(ptr, size)?`
`343`	`343`	`.read_uint::<NativeEndian>(size).unwrap() as usize;`
`@@ -350,7 +350,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {`
`350`	`350`
`351`	`351`	`pub fn write_ptr(&mut self, dest: Pointer, ptr: Pointer) -> EvalResult<'tcx, ()> {`
`352`	`352`	`{`
`353`		`- let size = self.pointer_size;`
	`353`	`+ let size = self.pointer_size();`
`354`	`354`	`let mut bytes = self.get_bytes_mut(dest, size)?;`
`355`	`355`	`bytes.write_uint::<NativeEndian>(ptr.offset as u64, size).unwrap();`
`356`	`356`	`}`
`@@ -359,7 +359,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {`
`359`	`359`	`}`
`360`	`360`
`361`	`361`	`pub fn write_primval(&mut self, ptr: Pointer, val: PrimVal) -> EvalResult<'tcx, ()> {`
`362`		`- let pointer_size = self.pointer_size;`
	`362`	`+ let pointer_size = self.pointer_size();`
`363`	`363`	`match val {`
`364`	`364`	`PrimVal::Bool(b) => self.write_bool(ptr, b),`
`365`	`365`	`PrimVal::I8(n) => self.write_int(ptr, n as i64, 1),`
`@@ -407,20 +407,20 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {`
`407`	`407`	`}`
`408`	`408`
`409`	`409`	`pub fn read_isize(&self, ptr: Pointer) -> EvalResult<'tcx, i64> {`
`410`		`- self.read_int(ptr, self.pointer_size)`
	`410`	`+ self.read_int(ptr, self.pointer_size())`
`411`	`411`	`}`
`412`	`412`
`413`	`413`	`pub fn write_isize(&mut self, ptr: Pointer, n: i64) -> EvalResult<'tcx, ()> {`
`414`		`- let size = self.pointer_size;`
	`414`	`+ let size = self.pointer_size();`
`415`	`415`	`self.write_int(ptr, n, size)`
`416`	`416`	`}`
`417`	`417`
`418`	`418`	`pub fn read_usize(&self, ptr: Pointer) -> EvalResult<'tcx, u64> {`
`419`		`- self.read_uint(ptr, self.pointer_size)`
	`419`	`+ self.read_uint(ptr, self.pointer_size())`
`420`	`420`	`}`
`421`	`421`
`422`	`422`	`pub fn write_usize(&mut self, ptr: Pointer, n: u64) -> EvalResult<'tcx, ()> {`
`423`		`- let size = self.pointer_size;`
	`423`	`+ let size = self.pointer_size();`
`424`	`424`	`self.write_uint(ptr, n, size)`
`425`	`425`	`}`
`426`	`426`	`}`
`@@ -430,7 +430,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {`
`430`	`430`	`fn relocations(&self, ptr: Pointer, size: usize)`
`431`	`431`	`-> EvalResult<'tcx, btree_map::Range<usize, AllocId>>`
`432`	`432`	`{`
`433`		`- let start = ptr.offset.saturating_sub(self.pointer_size - 1);`
	`433`	`+ let start = ptr.offset.saturating_sub(self.pointer_size() - 1);`
`434`	`434`	`let end = ptr.offset + size;`
`435`	`435`	`Ok(self.get(ptr.alloc_id)?.relocations.range(Included(&start), Excluded(&end)))`
`436`	`436`	`}`
`@@ -444,7 +444,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {`
`444`	`444`	`let start = ptr.offset;`
`445`	`445`	`let end = start + size;`
`446`	`446`	`let first = *keys.first().unwrap();`
`447`		`- let last = *keys.last().unwrap() + self.pointer_size;`
	`447`	`+ let last = *keys.last().unwrap() + self.pointer_size();`
`448`	`448`
`449`	`449`	`let alloc = self.get_mut(ptr.alloc_id)?;`
`450`	`450`